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

Update widgets module. Raster example initial.

Browse source
This commit is contained in:
IlyaShurupov 2024-04-12 15:27:40 +03:00
parent 9e339defd6
commit 9cfae3fe3e
48 changed files with 1169 additions and 530 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Sketch3D/CMakeLists.txt
View file

@ -1,8 +1,8 @@
project(Sketch3D)
### ---------------------- Externals --------------------- ###
set(BINDINGS_INCLUDE ../Externals/glfw/include ${GLEW_INCLUDE_DIR})
set(BINDINGS_LIBS glfw Imgui ${GLEW_LIB})
set(BINDINGS_INCLUDE ../Externals/glfw/include)
set(BINDINGS_LIBS glfw Imgui)
### ---------------------- Static Library --------------------- ###
file(GLOB SOURCES "./private/*.cpp" "./private/*/*.cpp")
@ -11,12 +11,12 @@ file(GLOB HEADERS "./public/*.hpp" "./public/*/*.hpp")
add_library(${PROJECT_NAME} STATIC ${SOURCES} ${HEADERS})
target_include_directories(${PROJECT_NAME} PUBLIC ./public/ ${BINDINGS_INCLUDE} ./ext/)
target_link_libraries(${PROJECT_NAME} PUBLIC Graphics Connection Widgets Math)
target_link_libraries(${PROJECT_NAME} PUBLIC Graphics Connection Widgets Math RasterRender)
target_link_libraries(${PROJECT_NAME} PUBLIC ${BINDINGS_LIBS})
### -------------------------- Applications -------------------------- ###
add_executable(Sketch3DApp ./applications/Entry.cpp)
target_link_libraries(Sketch3DApp ${PROJECT_NAME})
file(COPY "rsc" DESTINATION "${CMAKE_BINARY_DIR}/${PROJECT_NAME}/")
file(COPY "applications/Font.ttf" DESTINATION "${CMAKE_BINARY_DIR}/${PROJECT_NAME}/")

19
Sketch3D/applications/Entry.cpp
View file

@ -8,30 +8,25 @@ using namespace tp;
class Sketch3DApplication : public Application {
public:
Sketch3DApplication() : mGui(*mGraphics->getCanvas(), {1920, 1080}) {}
Sketch3DApplication() :
mGui(*mGraphics->getCanvas(), { 1920, 1080 }) {}
void processFrame(EventHandler* eventHandler) override {
auto rec = RectF( { 0, 0 }, mWindow->getSize() );
auto rec = RectF({ 0, 0 }, mWindow->getSize());
mGui.updateConfigCache(mWidgetManager);
mGui.proc(*eventHandler, rec, rec);
}
void drawFrame(Canvas* canvas) override {
mGui.draw(*canvas);
}
void drawFrame(Canvas* canvas) override { mGui.draw(*canvas); }
private:
WidgetManager mWidgetManager;
Sketch3DGUI<EventHandler, Canvas> mGui;
};
void runApp() {
tp::GlobalGUIConfig config;
tp::gGlobalGUIConfig = &config;
Sketch3DApplication app;
app.run();
}
int main() {
runApp();
}
int main() { runApp(); }

110
Sketch3D/private/FrameBuffer.cpp
View file

@ -1,110 +0,0 @@
#include "FrameBuffer.hpp"
#include "GraphicsApi.hpp"
#include <stdio.h>
void glerr(GLenum type) { printf("GL ERROR\n"); }
#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; }

162
Sketch3D/private/Shader.cpp
View file

@ -1,162 +0,0 @@
#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) {
std::string content;
auto loadFile = [&](const char* path) {
LocalConnection file;
if (!file.connect(LocalConnection::Location(path), LocalConnection::Type(true))) {
content = "";
return false;
}
const auto size = file.size();
auto tmp = new char[size + 1];
tmp[size] = 0;
file.readBytes(tmp, size);
content = tmp;
delete[] tmp;
return true;
};
printf("Compiling shader : %s\n", pvert);
if (loadFile(pvert)) {
compile_shader(content.c_str(), VertexShaderID);
}
if (GeometryShaderID) {
printf("Compiling shader : %s\n", pgeom);
if (loadFile(pgeom)) {
compile_shader(content.c_str(), GeometryShaderID);
}
}
printf("Compiling shader : %s\n", pfrag);
if (loadFile(pfrag)) {
compile_shader(content.c_str(), 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);
}

205
Sketch3D/private/Texture.cpp
View file

@ -1,205 +0,0 @@
#include "Texture.hpp"
#include "Map.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<std::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 std::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
}

34
Sketch3D/public/FrameBuffer.hpp
View file

@ -1,34 +0,0 @@
#pragma once
#include "Rect.hpp"
#include "Color.hpp"
namespace tp {
class RenderBuffer {
public:
RenderBuffer(const Vec2F& size);
RenderBuffer(const Vec2F& size, tp::uint1 samples);
~RenderBuffer();
void beginDraw();
void setViewport(const RectF& viewport);
void clear();
void endDraw();
uint4 texId() const;
uint4 buffId() const;
const Vec2F& getSize() const;
public:
RGBA mClearCol = 0.f;
private:
uint4 mFrameBufferID = 0; // regroups 0, 1, or more textures, and 0 or 1 depth buffer.
uint4 mTextureId = 0; // texture we're going to render to ( colour attachement #0 )
uint4 mDepthBufferID = 0;
uint4 mDrawBuffers[1];
Vec2F mSize;
};
};

19
Sketch3D/public/GraphicsApi.hpp
View file

@ -1,19 +0,0 @@
#pragma once
#include "Environment.hpp"
#ifdef ENV_OS_ANDROID
#include <EGL/egl.h>
#include <GLES3/gl32.h>
#else
#include "GL/glew.h"
#endif
#ifdef ENV_OS_ANDROID
#define GLW_CONTEXT_DEPTH_BITS 16
#define GLW_CONTEXT_DEPTH_COMPONENT GL_DEPTH_COMPONENT16
#else
#define GLW_CONTEXT_DEPTH_BITS 32
#define GLW_CONTEXT_DEPTH_COMPONENT GL_DEPTH_COMPONENT32
#endif

31
Sketch3D/public/Shader.hpp
View file

@ -1,31 +0,0 @@
#pragma once
namespace tp {
class RenderShader {
public:
RenderShader();
RenderShader(const char* vertid, const char* geomid, const char* fragid, bool paths = true);
~RenderShader();
void vert_bind_source(const char* vert_src);
void frag_bind_source(const char* frag_src);
void geom_bind_source(const char* geom_src);
void compile();
void bind();
uint4 getu(const char* uid);
void unbind();
private:
bool compile_shader(const char* ShaderCode, uint4 ShaderID);
void load(const char* vert, const char* geom, const char* frag, bool paths);
private:
uint4 programm;
uint4 VertexShaderID;
uint4 FragmentShaderID;
uint4 GeometryShaderID;
};
};

71
Sketch3D/public/Sketch3DWidget.hpp
View file

@ -9,16 +9,14 @@ namespace tp {
class Sketch3DWidget : public Widget<Events, Canvas> {
public:
Sketch3DWidget(Canvas& canvas, Vec2F renderResolution) :
mRenderer(renderResolution) {
mRenderer(renderResolution) {
mImage = canvas.createImageFromTextId(mRenderer.getBuff()->texId(), mRenderer.getBuff()->getSize());
mCanvas = &canvas;
mProject.mBackgroundColor = { 0.13f, 0.13f, 0.13f, 1.f };
}
~Sketch3DWidget() {
mCanvas->deleteImageHandle(mImage);
}
~Sketch3DWidget() { mCanvas->deleteImageHandle(mImage); }
void proc(const Events& events, const RectF& areaParent, const RectF& area) override {
@ -51,20 +49,24 @@ namespace tp {
mProject.mCamera.setRatio(this->mArea.w / this->mArea.z);
switch (mMode) {
case Mode::MOVE: {
case Mode::MOVE:
{
if (mAction) mProject.mCamera.move(relativePos, relativePosPrev);
break;
}
case Mode::ZOOM: {
case Mode::ZOOM:
{
halnf factor = absolutePos.y / mActionPosAbsolutePrev.y;
if (mAction) mProject.mCamera.zoom(factor);
break;
}
case Mode::ROTATE: {
case Mode::ROTATE:
{
if (mAction) mProject.mCamera.rotate(-relativeDelta.x * halnf(PI), -relativeDelta.y * halnf(PI));
break;
}
case Mode::DRAW: {
case Mode::DRAW:
{
mProject.sample(events.getPointerPressure(), this->mArea.w / this->mArea.z, crs);
break;
}
@ -74,20 +76,15 @@ namespace tp {
mActionPosAbsolutePrev = absolutePos;
}
void draw(Canvas& canvas) override {
if (!this->mVisible) return;
void drawBody(Canvas& canvas) override {
mRenderer.renderToTexture(&mProject, this->mArea.size);
canvas.drawImage(this->mArea, &mImage, 0, 1, 12);
}
void setColor(const RGBA& color) {
((PencilBrush*) mProject.mBrushes.get("pencil"))->mCol = color;
}
void setColor(const RGBA& color) { ((PencilBrush*) mProject.mBrushes.get("pencil"))->mCol = color; }
public:
enum class Mode {
MOVE, ROTATE, ZOOM, DRAW, NONE
} mMode = Mode::NONE;
enum class Mode { MOVE, ROTATE, ZOOM, DRAW, NONE } mMode = Mode::NONE;
Vec2F mActionPosAbsolutePrev = { 0, 0 };
bool mAction = false;
@ -102,12 +99,8 @@ namespace tp {
template <typename Events, typename Canvas>
class Sketch3DGUI : public Widget<Events, Canvas> {
public:
Sketch3DGUI(Canvas& canvas, Vec2F renderResolution) : mViewport(canvas, renderResolution) {
this->createConfig("Sketch3D");
this->addColor("Background", "Background");
this->addValue("Rounding", "Rounding");
Sketch3DGUI(Canvas& canvas, Vec2F renderResolution) :
mViewport(canvas, renderResolution) {
mDrawButton = new ButtonWidget<Events, Canvas>("Draw", { 0, 0, 100, 30 });
mMoveButton = new ButtonWidget<Events, Canvas>("Pan View", { 0, 0, 100, 30 });
mRotateButton = new ButtonWidget<Events, Canvas>("Rotate view", { 0, 0, 100, 30 });
@ -119,26 +112,22 @@ namespace tp {
mOptions.mContents.append(mZoomButton);
// add color sliders
mRed = new NamedSliderWidget < Events, Canvas >("Red");
mGreen = new NamedSliderWidget < Events, Canvas >("Green");
mBlue = new NamedSliderWidget < Events, Canvas >("Blue");
mRed = new NamedSliderWidget<Events, Canvas>("Red");
mGreen = new NamedSliderWidget<Events, Canvas>("Green");
mBlue = new NamedSliderWidget<Events, Canvas>("Blue");
mOptions.mContents.append(mRed);
mOptions.mContents.append(mGreen);
mOptions.mContents.append(mBlue);
}
~Sketch3DGUI() {
~Sketch3DGUI() {
for (auto item : mOptions.mContents) {
delete item.data();
}
}
void proc(const Events& events, const RectF& areaParent, const RectF& area) override {
this->mArea = area;
this->mVisible = area.isOverlap(areaParent);
if (!this->mVisible) return;
void procBody(const Events& events) override {
mSplitView.proc(events, this->mArea, this->mArea);
mViewport.proc(events, this->mArea, mSplitView.getFirst());
mOptions.proc(events, this->mArea, mSplitView.getSecond());
@ -156,16 +145,25 @@ namespace tp {
mViewport.setColor(RGBA(mRed->mSlider.mFactor, mGreen->mSlider.mFactor, mBlue->mSlider.mFactor, 1.f));
}
void draw(Canvas& canvas) override {
if (!this->mVisible) return;
canvas.rect(this->mArea, this->getColor("Background"), this->getValue("Rounding"));
void drawBody(Canvas& canvas) override {
canvas.rect(this->mArea, mBackgroundColor, mRounding);
mSplitView.draw(canvas);
mViewport.draw(canvas);
mOptions.draw(canvas);
}
void updateConfigCache(WidgetManager& wm) override {
wm.setActiveId("Sketch3DGui");
mBackgroundColor = wm.getColor("Background", "Background");
mRounding = wm.getNumber("Rounding", "Rounding");
mSplitView.updateConfigCache(wm);
mOptions.updateConfigCache(wm);
mViewport.updateConfigCache(wm);
}
private:
Sketch3DWidget<Events, Canvas> mViewport;
SplitView<Events, Canvas> mSplitView;
@ -179,5 +177,8 @@ namespace tp {
NamedSliderWidget<Events, Canvas>* mRed = nullptr;
NamedSliderWidget<Events, Canvas>* mGreen = nullptr;
NamedSliderWidget<Events, Canvas>* mBlue = nullptr;
RGBA mBackgroundColor;
halnf mRounding = 0;
};
}

29
Sketch3D/public/Texture.hpp
View file

@ -1,29 +0,0 @@
#pragma once
#include "Buffer2D.hpp"
#include "Color.hpp"
#include "Vec.hpp"
namespace tp {
class RenderTexture {
public:
RenderTexture();
~RenderTexture();
uint4 getid();
void update(const Buffer2D<RGBA>& buff);
void draw(const uint4& out = 0);
public:
static void init();
static void deinit();
static void draw_texture(uint4 out, uint4 in);
static uint4 get_tex(const char* TexId);
static void drawCurcle(Vec2F pos, double radius, RGBA col);
private:
uint4 id;
};
};