ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

trying to compile

Browse source
This commit is contained in:
Ilusha 2024-03-17 11:00:10 +03:00 • committed by IlyaShurupov
parent b8bab2264f
commit 57d5bc61ed
19 changed files with 999 additions and 1890 deletions
Download patch file Download diff file Expand all files Collapse all files

108
Sketch3D/private/FrameBuffer.cpp Normal file
View file

@ -0,0 +1,108 @@
#include "FrameBuffer.hpp"
#include "GraphicsApi.hpp"
void glerr(GLenum type);
#define AssertGL(x) { x; GLenum __gle = glGetError(); if (__gle != GL_NO_ERROR) glerr(__gle); }
using namespace tp;
RenderBuffer::RenderBuffer(const Vec2F& size) :
mSize(size) {
mDrawBuffers[0] = {GL_COLOR_ATTACHMENT0};
// --------- texture ---------
AssertGL(glGenTextures(1, &mTextureId));
AssertGL(glBindTexture(GL_TEXTURE_2D, mTextureId));
// Give an empty image to OpenGL ( the last "0" )
AssertGL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)size.x, (GLsizei)size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
// Poor filtering. Needed
AssertGL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
AssertGL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
// --------- depth ---------
AssertGL(glGenRenderbuffers(1, &mDepthBufferID));
AssertGL(glBindRenderbuffer(GL_RENDERBUFFER, mDepthBufferID));
AssertGL(glRenderbufferStorage(GL_RENDERBUFFER, GLW_CONTEXT_DEPTH_COMPONENT, (GLsizei)size.x, (GLsizei)size.y));
// ------------ framebuffer ------------
AssertGL(glGenFramebuffers(1, &mFrameBufferID));
AssertGL(glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferID));
AssertGL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepthBufferID));
// Set "renderedTexture" as our colour attachement #0
AssertGL(glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTextureId, 0));
// Set the list of draw buffers.
AssertGL(glDrawBuffers(1, mDrawBuffers)); // "1" is the size of DrawBuffers
ASSERT(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
RenderBuffer::RenderBuffer(const Vec2F& size, tp::uint1 samples) :
mSize(size) {
mDrawBuffers[0] = { GL_COLOR_ATTACHMENT0 };
// ------- texture ---------
AssertGL(glGenTextures(1, &mTextureId));
AssertGL(glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTextureId));
#ifdef ENV_OS_ANDROID
AssertGL(glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, GL_RGBA, (GLsizei)size.x, (GLsizei)size.y, GL_TRUE));
#else
AssertGL(glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, GL_RGBA, (GLsizei)size.x, (GLsizei)size.y, GL_TRUE));
#endif
// !?
//AssertGL(glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
//AssertGL(glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
// ------- depth -------
AssertGL(glGenRenderbuffers(1, &mDepthBufferID));
AssertGL(glBindRenderbuffer(GL_RENDERBUFFER, mDepthBufferID));
AssertGL(glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, GLW_CONTEXT_DEPTH_COMPONENT, (GLsizei)size.x, (GLsizei)size.y));
// ------- fbuff -------
AssertGL(glGenFramebuffers(1, &mFrameBufferID));
AssertGL(glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferID));
AssertGL(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, mTextureId, 0));
AssertGL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepthBufferID));
AssertGL(glDrawBuffers(1, mDrawBuffers));
ASSERT(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
uint4 RenderBuffer::buffId() const {
return mFrameBufferID;
}
void RenderBuffer::beginDraw() {
AssertGL(glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferID));
setViewport({ 0.f, 0.f, mSize.x, mSize.y });
}
void RenderBuffer::setViewport(const RectF& viewport) {
AssertGL(glViewport((GLsizei)viewport.x, (GLsizei)viewport.y, (GLsizei)viewport.z, (GLsizei)viewport.w));
}
void RenderBuffer::clear() {
AssertGL(glClearColor(mClearCol.r, mClearCol.g, mClearCol.b, mClearCol.a));
AssertGL(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
}
void RenderBuffer::endDraw() {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0, 0, 0, 0);
glUseProgram(0);
}
RenderBuffer::~RenderBuffer() {
glDeleteFramebuffers(1, &mFrameBufferID);
glDeleteTextures(1, &mTextureId);
glDeleteRenderbuffers(1, &mDepthBufferID);
}
uint4 RenderBuffer::texId() const {
return mTextureId;
}
const Vec2F& RenderBuffer::getSize() const { return mSize; }

159
Sketch3D/private/Shader.cpp Normal file
View file

@ -0,0 +1,159 @@
#include "Strings.hpp"
#include "Buffer.hpp"
#include "LocalConnection.hpp"
#include "Shader.hpp"
#include "GraphicsApi.hpp"
#include <cstdio>
using namespace tp;
RenderShader::RenderShader() {
programm = 0;
VertexShaderID = 0;
FragmentShaderID = 0;
GeometryShaderID = 0;
}
void RenderShader::vert_bind_source(const char* vert_src) {
VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
compile_shader(vert_src, VertexShaderID);
}
void RenderShader::frag_bind_source(const char* frag_src) {
FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
compile_shader(frag_src, FragmentShaderID);
}
void RenderShader::geom_bind_source(const char* geom_src) {
GeometryShaderID = glCreateShader(GL_GEOMETRY_SHADER);
compile_shader(geom_src, GeometryShaderID);
}
void RenderShader::compile() {
GLint Result = GL_FALSE;
int InfoLogLength;
programm = glCreateProgram();
glAttachShader(programm, VertexShaderID);
if (GeometryShaderID) glAttachShader(programm, GeometryShaderID);
glAttachShader(programm, FragmentShaderID);
glLinkProgram(programm);
// Check the program
glGetProgramiv(programm, GL_LINK_STATUS, &Result);
glGetProgramiv(programm, GL_INFO_LOG_LENGTH, &InfoLogLength);
if (InfoLogLength > 0) {
Buffer<char> ProgramErrorMessage(InfoLogLength + 1);
glGetProgramInfoLog(programm, InfoLogLength, NULL, &ProgramErrorMessage[0]);
printf("%s\n", &ProgramErrorMessage[0]);
}
glDetachShader(programm, VertexShaderID);
glDetachShader(programm, FragmentShaderID);
if (GeometryShaderID) glDetachShader(programm, GeometryShaderID);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
if (GeometryShaderID) glDeleteShader(GeometryShaderID);
}
bool RenderShader::compile_shader(const char* ShaderCode, uint4 ShaderID) {
GLint Result = GL_FALSE;
int InfoLogLength;
char const* SourcePointer = ShaderCode;
glShaderSource(ShaderID, 1, &SourcePointer, NULL);
glCompileShader(ShaderID);
// Check Shader
glGetShaderiv(ShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(ShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if (InfoLogLength > 0) {
Buffer<char> VertexShaderErrorMessage(InfoLogLength + 1);
glGetShaderInfoLog(ShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
printf("%s\n", &VertexShaderErrorMessage[0]);
}
return Result;
}
void RenderShader::load(const char* pvert, const char* pgeom, const char* pfrag, bool paths) {
// Create the shaders
VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
if (pgeom) GeometryShaderID = glCreateShader(GL_GEOMETRY_SHADER);
else GeometryShaderID = 0;
GLint Result = GL_FALSE;
int InfoLogLength = 0;
if (paths) {
String content;
auto loadFile = [&](const char* path) {
LocalConnection file;
if (!file.connect(LocalConnection::Location(path), LocalConnection::Type(true))) {
content = "";
return false;
}
content.resize(file.size());
file.readBytes(content.write(), content.size());
return true;
};
printf("Compiling shader : %s\n", pvert);
if (loadFile(pvert)) {
compile_shader(content.read(), VertexShaderID);
}
if (GeometryShaderID) {
printf("Compiling shader : %s\n", pgeom);
if (loadFile(pgeom)) {
compile_shader(content.read(), GeometryShaderID);
}
}
printf("Compiling shader : %s\n", pfrag);
if (loadFile(pfrag)) {
compile_shader(content.read(), FragmentShaderID);
}
}
else {
compile_shader(pvert, VertexShaderID);
if (GeometryShaderID) {
compile_shader(pgeom, GeometryShaderID);
}
compile_shader(pfrag, FragmentShaderID);
}
compile();
}
RenderShader::RenderShader(const char* vert, const char* geom, const char* frag, bool paths) {
load(vert, geom, frag, paths);
}
void RenderShader::bind() {
glUseProgram(programm);
}
GLuint RenderShader::getu(const char* uid) {
return glGetUniformLocation(programm, uid);
}
void RenderShader::unbind() {
glUseProgram(0);
}
RenderShader::~RenderShader() {
glDeleteProgram(programm);
}

206
Sketch3D/private/strokes.cpp → Sketch3D/private/Sketch3D.cpp
View file

@ -1,5 +1,5 @@
#include "Strokes.h"
#include "Sketch3D.hpp"
using namespace strokes;
@ -10,11 +10,11 @@ Stroke::GLHandles::GLHandles() {
glGenBuffers(1, &vertexbuffer);
}
void Stroke::GLHandles::sendDataToGPU(tp::Array<Point>* mPoints) {
void Stroke::GLHandles::sendDataToGPU(tp::Buffer<Point>* mPoints) {
glBindVertexArray(VertexArrayID);
vbo_len = mPoints->length();
vbo_len = mPoints->size();
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(mPoints[0]) * vbo_len, mPoints->buff(), GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(mPoints[0]) * vbo_len, mPoints->getBuff(), GL_STATIC_DRAW);
}
Stroke::GLHandles::~GLHandles() {
@ -24,7 +24,7 @@ Stroke::GLHandles::~GLHandles() {
Stroke::Stroke() {}
tp::Array<Stroke::Point>& Stroke::buff() {
tp::Buffer<Stroke::Point>& Stroke::buff() {
return mPoints;
}
@ -34,7 +34,7 @@ void Stroke::updateGpuBuffers() {
void Stroke::denoisePos(tp::halni passes) {
for (auto pass : tp::Range(passes)) {
for (auto pi : tp::Range(mPoints.length() - 2)) {
for (auto pi : tp::Range(mPoints.size() - 2)) {
mPoints[pi + 1].pos = (mPoints[pi + 1].pos + mPoints[pi].pos + mPoints[pi + 2].pos) / 3.f;
}
}
@ -42,32 +42,32 @@ void Stroke::denoisePos(tp::halni passes) {
void Stroke::denoiseThickness(tp::halni passes) {
for (auto pass : tp::Range(passes)) {
for (auto pi : tp::Range(mPoints.length() - 2)) {
for (auto pi : tp::Range(mPoints.size() - 2)) {
mPoints[pi + 1].thickness = (mPoints[pi].thickness + mPoints[pi + 2].thickness) / 2.f;
}
}
}
void Stroke::compress(tp::halnf factor) {
if (mPoints.length() < 3) {
if (mPoints.size() < 3) {
return;
}
tp::List<Point> passed_poits;
for (auto idx : tp::Range(mPoints.length())) {
for (auto idx : tp::Range(mPoints.size())) {
passed_poits.pushBack(mPoints[idx]);
}
tp::ListNode<Point>* min_node = NULL;
tp::List<Point>::Node* min_node = NULL;
do {
min_node = NULL;
tp::halnf min_factor = factor;
tp::ListNode<Point>* iter = passed_poits.first()->next;
tp::List<Point>::Node* iter = passed_poits.first()->next;
for (; iter->next; iter = iter->next) {
tp::vec3f dir1 = (iter->data.pos - iter->prev->data.pos).normalize();
tp::vec3f dir2 = (iter->next->data.pos - iter->data.pos).normalize();
tp::Vec3F dir1 = (iter->data.pos - iter->prev->data.pos).normalize();
tp::Vec3F dir2 = (iter->next->data.pos - iter->data.pos).normalize();
tp::halnf factor = 1 - dir1.dot(dir2);
if (factor < min_factor) {
@ -77,31 +77,33 @@ void Stroke::compress(tp::halnf factor) {
}
if (min_node) {
passed_poits.delNode(min_node);
passed_poits.deleteNode(min_node);
}
} while (min_node);
mPoints.reserve(passed_poits.length());
tp::ualni idx = 0;
for (auto point : passed_poits) {
mPoints[point.idx()] = point.data();
mPoints[idx] = point.data();
idx++;
}
}
void Stroke::subdiv(tp::halnf precision, tp::Camera* cam, tp::halni passes) {
// TODO
if (mPoints.length() < 4) {
if (mPoints.size() < 4) {
return;
}
tp::List<Point> new_points;
for (auto idx : tp::Range(mPoints.length())) {
for (auto idx : tp::Range(mPoints.size())) {
new_points.pushBack(mPoints[idx]);
}
auto viewmat = cam->viewmat();
auto projmat = cam->projmat();
auto viewmat = cam->calculateViewMatrix();
auto projmat = cam->calculateProjectionMatrix();
for (auto i : tp::Range(passes)) {
@ -120,14 +122,14 @@ void Stroke::subdiv(tp::halnf precision, tp::Camera* cam, tp::halni passes) {
auto len = (p1_2d - p2_2d).length();
if (len > precision * 1.5f) {
auto const a = (p1->data.pos - p0->data.pos).unitv();
auto const b = (p2->data.pos - p3->data.pos).unitv();
auto const a = (p1->data.pos - p0->data.pos).unitV();
auto const b = (p2->data.pos - p3->data.pos).unitV();
auto const l = p1->data.pos - p2->data.pos;
auto const l_len = l.length();
auto const ab = a.dot(b);
auto const la = l.dot(a);
auto const lb = l.dot(b);
tp::vec3f mid;
tp::Vec3F mid;
if (1 - tp::abs(ab) < 0.001f) {
goto SKIP;
@ -185,56 +187,25 @@ void Stroke::subdiv(tp::halnf precision, tp::Camera* cam, tp::halni passes) {
}
}
if (new_points.length() != mPoints.length()) {
if (new_points.length() != mPoints.size()) {
mPoints.reserve(new_points.length());
tp::ualni idx = 0;
for (auto point : new_points) {
mPoints[point.idx()] = point.data();
mPoints[idx] = point.data();
idx++;
}
}
}
tp::halni Stroke::saveSize() {
tp::halni out = 0;
out += sizeof(tp::rgba);
out += sizeof(tp::alni);
out += mPoints.length() * sizeof(Point);
return out;
}
void Stroke::save(tp::File& file) {
file.write<tp::rgba>(&mCol);
tp::alni length = mPoints.length();
file.write<tp::alni>(&length);
for (auto piter : mPoints) {
file.write<Point>(&piter.data());
}
}
void Stroke::load(tp::File& file) {
tp::rgba color;
file.read<tp::rgba>(&color);
tp::alni p_len;
file.read<tp::alni>(&p_len);
mPoints.reserve(p_len);
for (auto piter : mPoints) {
file.read<Point>(&piter.data());
}
updateGpuBuffers();
}
PencilBrush::PencilBrush() {
mType = "pencil";
}
void PencilBrush::unsureReady(Stroke* stroke, tp::Camera* cam, bool debug) {
if (stroke->buff().length() == 1) {
if (stroke->buff().size() == 1) {
auto new_point = stroke->buff()[0];
new_point.pos += 0.00001f;
stroke->buff().pushBack(new_point);
stroke->buff().append(new_point);
}
if (mEnableCompression && !debug) {
@ -246,12 +217,12 @@ void PencilBrush::unsureReady(Stroke* stroke, tp::Camera* cam, bool debug) {
stroke->updateGpuBuffers();
}
void PencilBrush::sample(Project* proj, tp::vec2f crs, tp::halnf pressure) {
void PencilBrush::sample(Project* proj, tp::Vec2F crs, tp::halnf pressure) {
if (proj->mActiveLayer == -1) {
return;
}
bool max_level = mStroke && mStroke->mPoints.length() > mMaxPoints;
bool max_level = mStroke && mStroke->mPoints.size() > mMaxPoints;
if (!pressure || max_level) {
if (mStroke) {
unsureReady(mStroke, &proj->mCamera);
@ -263,7 +234,7 @@ void PencilBrush::sample(Project* proj, tp::vec2f crs, tp::halnf pressure) {
mStroke = new Stroke();
mStroke->mCol = mCol;
mStroke->mPoints.pushBack(proj->mLayers[proj->mActiveLayer]->strokes.last()->data->mPoints.last());
mStroke->mPoints.append(proj->mLayers[proj->mActiveLayer]->strokes.last()->data->mPoints.last());
}
if (!pressure) {
@ -274,7 +245,7 @@ void PencilBrush::sample(Project* proj, tp::vec2f crs, tp::halnf pressure) {
auto thickness = pressure * (proj->mCamera.project({ 0.f, 0.f }) - proj->mCamera.project({ mSize, 0.f })).length();
bool point_passed = true;
if (mStroke && mStroke->buff().length()) {
if (mStroke && mStroke->buff().size()) {
auto last_point_2d = proj->mCamera.project(mStroke->buff().last().pos);
point_passed = (crs - last_point_2d).length() > mPrecision;
}
@ -289,7 +260,7 @@ void PencilBrush::sample(Project* proj, tp::vec2f crs, tp::halnf pressure) {
}
auto point_coords = proj->mCamera.project(crs);
mStroke->buff().pushBack({ point_coords, (tp::halnf) thickness });
mStroke->buff().append({ point_coords, (tp::halnf) thickness });
mStroke->updateGpuBuffers();
}
@ -317,11 +288,11 @@ Project::Layer::~Layer() {
}
Project::Project() {
mCamera.lookat({ 0.0f, 0.0f, 0.0f }, { 2.0f, 0.0f, 0.f }, { 0, 0, 1 });
mCamera.lookAtPoint({ 0.0f, 0.0f, 0.0f }, { 2.0f, 0.0f, 0.f }, { 0, 0, 1 });
auto lay = new Layer();
lay->enabled = true;
mLayers.pushBack(lay);
mLayers.append(lay);
mActiveLayer = 0;
mBrushes.put("eraser", new EraserBrush());
@ -341,77 +312,10 @@ Project::~Project() {
}
}
tp::alni Project::saveSize() {
tp::alni out = 0;
out += sizeof(tp::Camera);
out += sizeof(tp::rgba);
out += sizeof(tp::halni);
out += sizeof(tp::alni);
for (auto layer : mLayers) {
out += layer.data()->name.save_size();
out += sizeof(bool);
out += sizeof(tp::alni);
for (auto stiter : layer.data()->strokes) {
out += stiter->saveSize();
}
}
return out;
}
void Project::save(tp::File& file) {
file.write<tp::Camera>(&mCamera);
file.write<tp::rgba>(&mBackgroundColor);
file.write<tp::halni>(&mActiveLayer);
tp::alni lay_len = mLayers.length();
file.write<tp::alni>(&lay_len);
for (auto layer : mLayers) {
layer.data()->name.save(&file);
file.write<bool>(&layer.data()->enabled);
tp::alni len = layer.data()->strokes.length();
file.write<tp::alni>(&len);
for (auto stiter : layer.data()->strokes) {
stiter->save(file);
}
}
}
void Project::load(tp::File& file) {
file.read<tp::Camera>(&mCamera);
file.read<tp::rgba>(&mBackgroundColor);
file.read<tp::halni>(&mActiveLayer);
tp::alni layers_len;
file.read<tp::alni>(&layers_len);
mLayers.reserve(layers_len);
for (tp::alni idx = 0; idx < layers_len; idx++) {
tp::string key; key.load(&file);
auto layer = new Layer();
layer->name = key;
mLayers[idx] = layer;
file.read<bool>(&layer->enabled);
tp::alni len;
file.read<tp::alni>(&len);
for (tp::alni str_idx = 0; str_idx < len; str_idx++) {
auto str = new Stroke();
layer->strokes.pushBack(str);
layer->strokes.last()->data->load(file);
}
}
}
Renderer::Renderer(tp::vec2f size) :
mBuffer(size, { 0.f, 0.f, 1.f, 1.f }, 4),
mBufferDowncast(size, { 0.f, 0.f, 1.f, 1.f }),
mShader(".\\rsc\\shaders\\stroke", ".\\rsc\\shaders\\stroke", ".\\rsc\\shaders\\stroke")
Renderer::Renderer(tp::Vec2F size) :
mBuffer(size, 4),
mBufferDowncast(size),
mShader(".\\rsc\\shaders\\stroke.vert", ".\\rsc\\shaders\\stroke.geom", ".\\rsc\\shaders\\stroke.frag")
{
mMatrixUniform = mShader.getu("MVP");
mColorUniform = mShader.getu("Color");
@ -421,11 +325,11 @@ Renderer::Renderer(tp::vec2f size) :
}
void Renderer::renderBegin() {
mBuffer.begin_draw();
mBuffer.beginDraw();
mBuffer.clear();
}
void Renderer::setViewport(tp::rectf viewport) {
void Renderer::setViewport(tp::RectF viewport) {
mBuffer.setViewport(viewport);
}
@ -441,18 +345,18 @@ void Renderer::drawStroke(Stroke* str, tp::Camera* camera) {
glBindVertexArray(str->mGl.VertexArrayID);
mShader.bind();
auto cam_mat = camera->transform_mat().transpose();
auto cam_mat = camera->calculateTransformationMatrix().transpose();
glUniformMatrix4fv(mMatrixUniform, 1, GL_FALSE, &cam_mat[0][0]);
glUniform4fv(mColorUniform, 1, &str->mCol.r);
glUniform4fv(mBGColUniform, 1, &mBuffer.col_clear.r);
glUniform4fv(mBGColUniform, 1, &mBuffer.mClearCol.r);
auto ratio = camera->get_ratio();
auto ratio = camera->getRatio();
glUniform1fv(mRatioUniform, 1, &ratio);
auto target = tp::halnf(((camera->get_target() - camera->get_pos()).length() - camera->get_near())
/ (camera->get_far() - camera->get_near()));
auto target = tp::halnf(((camera->getTarget() - camera->getPos()).length() - camera->getNear())
/ (camera->getFar() - camera->getNear()));
glUniform1fv(mTargetUniform, 1, &target);
@ -470,9 +374,9 @@ void Renderer::drawStroke(Stroke* str, tp::Camera* camera) {
}
void Renderer::renderEnd() {
mBuffer.end_draw();
mBuffer.endDraw();
mBufferDowncast.begin_draw();
mBufferDowncast.beginDraw();
auto size = mBufferDowncast.getSize();
@ -481,20 +385,20 @@ void Renderer::renderEnd() {
mBufferDowncast.clear();
glBlitFramebuffer(0, 0, size.x, size.y, 0, 0, size.x, size.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);
mBufferDowncast.end_draw();
mBufferDowncast.endDraw();
}
tp::uhalni Renderer::getTextudeId() {
return mBufferDowncast.texId();
}
tp::ogl::fbuffer* Renderer::getBuff() {
tp::RenderBuffer* Renderer::getBuff() {
return &mBufferDowncast;
}
void Renderer::setClearCol(tp::rgba col) {
mBuffer.col_clear = col;
mBufferDowncast.col_clear = col;
void Renderer::setClearCol(tp::RGBA col) {
mBuffer.mClearCol = col;
mBufferDowncast.mClearCol = col;
}
Renderer::~Renderer() {

260
Sketch3D/private/StrokesWidget.cpp
View file

@ -1,260 +0,0 @@
#include "StrokesWidget.h"
#include "operator.h"
using namespace nd;
void StrokesWidget::constructor(StrokesWidget* self) {
new (&self->mRenderer) strokes::Renderer({ 1980, 1020 });
self->createMember("link", "TargetProject");
self->createMember("StrokesProject", "default");
self->createMember("rgba", "draw_color");
self->addMember(obj::ColorObject::create({ 0.13f, 0.13f, 0.13f, 1.f }), "bg_color");
}
void StrokesWidget::destructor(StrokesWidget* self) {
self->mRenderer.~Renderer();
self->mImage.free(self->mDrawer);
self->mImage.~ImageHandle();
}
void StrokesWidget::copy(Widget* self, const Widget* in) {}
strokes::Project* StrokesWidget::getTargetProject() {
auto link = getMember<obj::LinkObject>("TargetProject");
if (!link) {
return NULL;
}
auto obj = link->getLink();
if (!obj) {
link->setLink(getMember<obj::StrokesObject>("default"));
return getTargetProject();
}
auto strokes = NDO_CAST(obj::StrokesObject, obj);
if (!strokes) {
return NULL;
}
return &strokes->mProject;
}
void StrokesWidget::procInputs(StrokesWidget* self, nd::GUIInputs* inputs) {
auto proj = self->getTargetProject();
if (!proj) {
return;
}
auto rec = self->getRect();
proj->mCamera.set_ratio(rec.w / rec.z);
auto col_obj_bg = self->getMember<obj::ColorObject>("bg_color");
if (col_obj_bg) {
proj->mBackgroundColor = col_obj_bg->mCol;
}
if (!rec.inside(inputs->mCrsPrev)) {
return;
}
auto pressure = inputs->mPressure;
if (!inputs->Anticipating()) {
pressure = 0.f;
}
auto idx = proj->mBrushes.presents(proj->mActiveBrush);
if (idx) {
auto brush = proj->mBrushes.getSlotVal(idx);
auto crs = (inputs->mCrs - rec.pos);
crs.x /= rec.z;
crs.y /= rec.w;
crs = (crs - 0.5) * 2;
if (brush->mType == "pencil") {
auto col_obj = self->getMember<obj::ColorObject>("draw_color");
if (col_obj) {
((strokes::PencilBrush*)brush)->mCol = col_obj->mCol;
}
}
brush->sample(proj, crs, pressure);
}
}
void StrokesWidget::presentOutput(StrokesWidget* self, nd::GUIdrawer* drawer) {
auto proj = self->getTargetProject();
if (!proj) {
return;
}
if (!self->mImage.mId) {
self->mDrawer = drawer;
self->mImage.createFromBuff(self->mRenderer.getBuff(), drawer);
}
auto rec = self->getRect();
self->mRenderer.setViewport({ 0, 0, rec.z, rec.w });
self->mRenderer.setClearCol(proj->mBackgroundColor);
self->mRenderer.renderBegin();
for (auto lay : proj->mLayers) {
if (lay.data()->enabled) {
for (auto str : lay.data()->strokes) {
self->mRenderer.drawStroke(str.data(), &proj->mCamera);
}
}
}
auto idx = proj->mBrushes.presents(proj->mActiveBrush);
if (idx) {
auto brush = proj->mBrushes.getSlotVal(idx);
brush->draw(&self->mRenderer, &proj->mCamera);
}
self->mRenderer.renderEnd();
drawer->drawImage(rec, &self->mImage, 0, 1, 12);
}
struct obj::ObjectType StrokesWidget::TypeData = {
.base = &Widget::TypeData,
.constructor = (obj::object_constructor)StrokesWidget::constructor,
.destructor = (obj::object_destructor)StrokesWidget::destructor,
.copy = (obj::object_copy)StrokesWidget::copy,
.size = sizeof(StrokesWidget),
.name = "StrokesWidget",
.vtable = &StrokesWidget::vtable
};
struct StrokesWidget::Vtable StrokesWidget::vtable = {
(void (*)(Widget*, nd::GUIInputs*)) & StrokesWidget::procInputs,
(void (*)(Widget*, nd::GUIdrawer*)) & StrokesWidget::presentOutput,
};
class StrokesWidgetOps : public nd::TypeOperators {
struct CameraOrbit : public nd::Operator {
tp::vec2f prev_crs;
struct Invoke : public nd::OpCallBack {
Invoke() {
auto transf = obj::EnumObject::create({ "move", "rotate" , "scale" });
arg_interface.put("Gui", obj::NDO->create("link"));
arg_interface.put("transf", transf);
func = exec;
description = "invoke";
}
static void exec(Operator* op, obj::DictObject* args) {
auto active = OpCallBack::getActiveWidget<StrokesWidget>(args);
if (!active) {
return;
}
auto proj = active->getTargetProject();
if (!proj) {
return;
}
auto rec = active->getRect();
auto gui = OpCallBack::getGUI(args);
auto prev_crs = ((CameraOrbit*)op)->prev_crs;
prev_crs = tp::vec2f(prev_crs.x / rec.size.x, prev_crs.y / rec.size.y);
prev_crs = (prev_crs - 0.5f) * 2.f;
auto crs = tp::vec2f(gui->mInputs.mCrs.x / rec.size.x, gui->mInputs.mCrs.y / rec.size.y);
crs = (crs - 0.5f) * 2.f;
auto delta = (crs - prev_crs);
if (tp::abs(delta.x) < 0.1 && tp::abs(delta.y) < 0.1) {
auto type = OpCallBack::getArg<obj::EnumObject>(args, "transf");
switch (type->active) {
case 0: {
proj->mCamera.move(crs, prev_crs);
break;
}
case 1: {
proj->mCamera.rotate(-delta.x * 5, -delta.y * 5);
break;
}
case 2: {
proj->mCamera.zoom((crs.y + 1.f) / (prev_crs.y + 1.f));
break;
}
}
}
((CameraOrbit*)op)->prev_crs = gui->mInputs.mCrs;
}
} invoke_callback;
CameraOrbit() {
description = "Orbits camera";
callbacks.put("invoke", &invoke_callback);
}
} camera_orbit_op;
public:
StrokesWidgetOps() {
operators.put("camera_orbit", &camera_orbit_op);
}
};
void StrokesWidget::OpsInit() {
assert(!StrokesWidget::TypeData.nodes_custom_data);
StrokesWidget::TypeData.nodes_custom_data = new StrokesWidgetOps();
}
void StrokesWidget::OpsUnInit() {
assert(StrokesWidget::TypeData.nodes_custom_data);
auto del = (StrokesWidgetOps*)StrokesWidget::TypeData.nodes_custom_data;
StrokesWidget::TypeData.nodes_custom_data = NULL;
delete del;
}
void StrokesWidget::addShortcuts(nd::NodesCore* nodes) {
auto uis_list = nodes->getMemberAssert<obj::ListObject>("uis");
NDO_CASTV(nd::GUI, uis_list->getItems()[0], gui);
NDO_CASTV(nd::TUI, uis_list->getItems()[1], tui);
auto shortcuts = tui->getMemberAssert<obj::ListObject>("shortcuts");
auto inputs = tui->getMemberAssert<obj::DictObject>("inputs");
auto input_states = tui->getMemberAssert<obj::DictObject>("input_states");
auto input_state_hold = input_states->get("hold");
{ // orbit
auto shortcut = nd::Shortcut::createShortcut("StrokesWidget", "camera_orbit");
auto args = NDO_CAST(obj::DictObject, shortcut->callbacks_arguments->get("invoke"));
NDO_CAST(obj::LinkObject, args->get("Gui"))->setLink(gui);
NDO_CAST(obj::EnumObject, args->get("transf"))->active = 1;
shortcuts->pushBack(shortcut);
auto trigger = shortcut->addTrigger("invoke");
auto back = tui->getInput(tp::Keycode::LEFT_ALT)->getMember<obj::EnumObject>("state");
trigger->addComparator("comp", back, input_state_hold);
}
{ // zoom
auto shortcut = nd::Shortcut::createShortcut("StrokesWidget", "camera_orbit");
auto args = NDO_CAST(obj::DictObject, shortcut->callbacks_arguments->get("invoke"));
NDO_CAST(obj::LinkObject, args->get("Gui"))->setLink(gui);
NDO_CAST(obj::EnumObject, args->get("transf"))->active = 2;
shortcuts->pushBack(shortcut);
auto trigger = shortcut->addTrigger("invoke");
auto back = tui->getInput(tp::Keycode::LEFT_CONTROL)->getMember<obj::EnumObject>("state");
trigger->addComparator("comp", back, input_state_hold);
}
{ // pan
auto shortcut = nd::Shortcut::createShortcut("StrokesWidget", "camera_orbit");
auto args = NDO_CAST(obj::DictObject, shortcut->callbacks_arguments->get("invoke"));
NDO_CAST(obj::LinkObject, args->get("Gui"))->setLink(gui);
shortcuts->pushBack(shortcut);
auto trigger = shortcut->addTrigger("invoke");
auto back = tui->getInput(tp::Keycode::SPACE)->getMember<obj::EnumObject>("state");
trigger->addComparator("comp", back, input_state_hold);
}
}

207
Sketch3D/private/Texture.cpp Normal file
View file

@ -0,0 +1,207 @@
#include "Texture.hpp"
#include "Map.hpp"
#include "Strings.hpp"
#include "Shader.hpp"
#include "GraphicsApi.hpp"
const char* texture_vertex =
#ifdef ENV_OS_ANDROID
"#version 300 es\n"
"precision mediump float;\n"
#else
"#version 330 core\n"
#endif
"layout(location = 0) in vec3 vPos;\n"
"out vec2 UV;\n"
"void main() {\n"
" gl_Position = vec4(vPos, 1);\n"
" UV = (vPos.xy + vec2(1, 1)) / 2.0;\n"
"}\n";
const char* texture_fragment =
#ifdef ENV_OS_ANDROID
"#version 300 es\n"
"precision mediump float;\n"
#else
"#version 330 core\n"
#endif
"in vec2 UV;\n"
"out vec4 color;\n"
"uniform sampler2D renderedTexture;\n"
"uniform float time;\n"
"void main() {\n"
" vec4 texColor = texture(renderedTexture, UV);\n"
" if (texColor.a < 0.2)\n"
" discard;\n"
" color = texColor;\n"
"}\n";
using namespace tp;
GLuint RenderTexture::getid() { return id; }
RenderTexture::RenderTexture() {
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
}
RenderTexture::~RenderTexture() { glDeleteTextures(1, &id); }
void RenderTexture::update(const Buffer2D<RGBA>& buff) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)buff.size().x, (GLsizei)buff.size().y, 0, GL_RGBA, GL_FLOAT, buff.getBuff());
}
void RenderTexture::draw(const GLuint& out) {
draw_texture(out, id);
}
struct texture_drawer_data {
Map<String, GLuint> textures;
GLuint quad_VertexArrayID;
GLuint quad_vertexbuffer;
GLuint texID;
RenderShader shader;
const GLfloat g_quad_vertex_buffer_data[18] = {
-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
};
texture_drawer_data() : shader(texture_vertex, nullptr, texture_fragment, false) {
// The fullscreen quad's FBO
glGenVertexArrays(1, &quad_VertexArrayID);
glBindVertexArray(quad_VertexArrayID);
glGenBuffers(1, &quad_vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data),
g_quad_vertex_buffer_data, GL_STATIC_DRAW);
texID = shader.getu("renderedTexture");
}
~texture_drawer_data() {
glDeleteBuffers(1, &quad_vertexbuffer);
glDeleteVertexArrays(1, &quad_VertexArrayID);
for (auto tex : textures) {
glDeleteTextures(1, &tex->val);
}
}
};
texture_drawer_data* texdd = NULL;
void RenderTexture::init() {
if (!texdd) texdd = new texture_drawer_data();
}
void RenderTexture::deinit() {
if (texdd) delete texdd;
texdd = NULL;
}
void RenderTexture::draw_texture(uint4 out, uint4 in) {
ASSERT(in);
// Render to the screen
glBindFramebuffer(GL_FRAMEBUFFER, out);
// Use our shader
texdd->shader.bind();
// Bind our texture in Texture Unit 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, in);
// Set our "renderedTexture" sampler to use Texture Unit 0
glUniform1i(texdd->texID, 0);
// glUniformMatrix4fv(texdd->rect_mat, 1, GL_FALSE, &tmat[0][0]);
// 1rst attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, texdd->quad_vertexbuffer);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
// Draw the triangles. 2*3 indices starting at 0 -> 2 triangles
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(0);
texdd->shader.unbind();
}
GLuint load_texture(const String& name) {
GLuint tex_2d = 0;
ASSERT(0 && "incomplete compilation - no SOIL support added");
if (0) {
//auto document = lunasvg::Document::loadFromFile("tiger.svg");
//auto bitmap = document->renderToBitmap();
}
else {
/*
tex_2d = SOIL_load_OGL_texture(
name.cstr(), SOIL_LOAD_RGBA, SOIL_CREATE_NEW_ID,
SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB |
SOIL_FLAG_COMPRESS_TO_DXT);
if (0 == tex_2d) {
printf("SOIL loading error: '%s'\n", SOIL_last_result());
}
*/
}
return tex_2d;
}
GLuint RenderTexture::get_tex(const char* TexId) {
GLuint out = 0;
auto idx = texdd->textures.presents(TexId);
if (idx) {
out = texdd->textures.get(TexId);
}
else {
out = load_texture(TexId);
texdd->textures.put(TexId, out);
}
return out;
}
void RenderTexture::drawCurcle(Vec2F pos, double radius, RGBA col) {
#ifndef ENV_OS_ANDROID
static alni precision = 40;
glColor4f(col.r, col.g, col.b, col.a);
double twicePi = 2.0 * 3.142;
glBegin(GL_TRIANGLE_FAN); // BEGIN CIRCLE
glVertex2f(pos.x, pos.y); // center of circle
for (alni i = 0; i <= precision; i++) {
glVertex2f((GLfloat)(pos.x + (radius * cos(i * twicePi / precision))),
(GLfloat)(pos.y + (radius * sin(i * twicePi / precision))));
}
glEnd(); // END
#endif
}

42
Sketch3D/private/strokesobject.cpp
View file

@ -1,42 +0,0 @@
#include "strokesobject.h"
using namespace tp;
using namespace obj;
void StrokesObject::constructor(StrokesObject* self) {
new (&self->mProject) strokes::Project();
}
void StrokesObject::copy(StrokesObject* self, const StrokesObject* in) {
self->mProject = in->mProject;
}
void StrokesObject::destructor(StrokesObject* self) {
self->mProject.~Project();
}
static alni save_size(StrokesObject* self) {
return self->mProject.saveSize();
}
static void save(StrokesObject* self, File& file_self) {
self->mProject.save(file_self);
}
static void load(File& file_self, StrokesObject* self) {
new (&self->mProject) strokes::Project();
self->mProject.load(file_self);
}
struct ObjectType obj::StrokesObject::TypeData = {
.base = NULL,
.constructor = (object_constructor) StrokesObject::constructor,
.destructor = (object_destructor) StrokesObject::destructor,
.copy = (object_copy) StrokesObject::copy,
.size = sizeof(StrokesObject),
.name = "StrokesProject",
.save_size = (object_save_size) save_size,
.save = (object_save) save,
.load = (object_load) load,
};

1049
Sketch3D/private/temp.cpp
View file

File diff suppressed because it is too large Load diff