tmp

GeometryEditor2D/CMakeLists.txt

@@ -0,0 +1,22 @@
+project(GeometryEditor2D)
+
+### ---------------------- Externals  ---------------------  ###
+set(BINDINGS_INCLUDE ../Externals/glfw/include)
+set(BINDINGS_LIBS glfw Imgui)
+
+### ---------------------- Static Library  ---------------------  ###
+file(GLOB SOURCES "./private/*.cpp" "./private/*/*.cpp")
+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 RasterRender)
+target_link_libraries(${PROJECT_NAME} PUBLIC ${BINDINGS_LIBS})
+
+### -------------------------- Applications  --------------------------  ###
+add_executable(geomEdit2d ./applications/Entry.cpp)
+target_link_libraries(geomEdit2d ${PROJECT_NAME})
+
+file(COPY "rsc" DESTINATION "${CMAKE_BINARY_DIR}/${PROJECT_NAME}/")
+file(COPY "rsc/Font.ttf" DESTINATION "${CMAKE_BINARY_DIR}/${PROJECT_NAME}/")

GeometryEditor2D/applications/Entry.cpp

@@ -0,0 +1,39 @@
+
+#include "EditorWidget.hpp"
+
+#include "GraphicApplication.hpp"
+
+using namespace tp;
+
+class EditorGUI : public Application {
+public:
+	EditorGUI() {
+		Vec2F renderResolution = { 1000, 1000 };
+		auto canvas = this->mGraphics->getCanvas();
+		mGui = new EditorWidget<EventHandler, Canvas>(canvas, &geometry, renderResolution);
+		//
+	}
+
+	~EditorGUI() override { delete mGui; }
+
+	void processFrame(EventHandler* eventHandler) override {
+		auto rec = RectF({ 0, 0 }, mWindow->getSize());
+		mGui->proc(*eventHandler, rec, rec);
+	}
+
+	void drawFrame(Canvas* canvas) override { mGui->draw(*canvas); }
+
+private:
+	Geometry geometry;
+	EditorWidget<EventHandler, Canvas>* mGui;
+};
+
+int main() {
+	GlobalGUIConfig mConfig;
+	gGlobalGUIConfig = &mConfig;
+
+	{
+		EditorGUI gui;
+		gui.run();
+	}
+}

GeometryEditor2D/private/Render.cpp

@@ -0,0 +1,76 @@
+#include "Render.hpp"
+
+#include "GraphicsApi.hpp"
+
+using namespace tp;
+
+struct Shape {
+	float buffer[6] = {
+		0, 0, 1, 0, 0, 1,
+	};
+
+	GLuint vbo_id = 0;
+	GLuint vbo_len = 6;
+
+	Shape() {
+		glGenBuffers(1, &vbo_id);
+		glBindBuffer(GL_ARRAY_BUFFER, vbo_id);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(buffer), buffer, GL_STATIC_COPY);
+	}
+
+	void drawCall() {
+		glBindBuffer(GL_ARRAY_BUFFER, vbo_id);
+
+		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), nullptr);
+		glEnableVertexAttribArray(0);
+
+		glDrawArrays(GL_TRIANGLES, 0, 3);
+
+		glDisableVertexAttribArray(0);
+		glBindVertexArray(0);
+	}
+
+	~Shape() { glDeleteBuffers(1, &vbo_id); }
+};
+
+Render::Render(Vec2F renderResolution) :
+	mRenderBuffer(renderResolution) {
+
+	mDefaultShader.load("rsc/shaders/default.vert", nullptr, "rsc/shaders/default.frag", true);
+}
+
+Render::~Render() {}
+
+uint4 Render::getRenderBuffer() { return mRenderBuffer.texId(); }
+
+Vec2F Render::getBufferSize() { return mRenderBuffer.getSize(); }
+
+void Render::render(const Geometry& geometry, Vec2F size) {
+
+	static Shape shape;
+
+	mRenderBuffer.mClearCol = { 0.1f, 0.1f, 0.1f, 1.f };
+
+	mRenderBuffer.beginDraw();
+	mRenderBuffer.clear();
+
+	{
+		mDefaultShader.bind();
+
+		static auto uniform_color = mDefaultShader.getu("Color");
+		static auto uniform_scale = mDefaultShader.getu("Viewport");
+
+		RGBA col = { 0, 0, 1.f, 1.f };
+		RectF viewport = { 0.0f, 0.0f, 1.f, 1.f };
+		viewport.w = viewport.z * (size.y / size.x);
+
+		glUniform4fv(uniform_color, 1, &col.r);
+		glUniform4fv(uniform_scale, 1, &viewport.x);
+
+		shape.drawCall();
+		
+		mDefaultShader.unbind();
+	}
+
+	mRenderBuffer.endDraw();
+}

GeometryEditor2D/public/EditorWidget.hpp

@@ -0,0 +1,68 @@
+#include "Widgets.hpp"
+#include "Render.hpp"
+
+namespace tp {
+	template <typename Events, typename Canvas>
+	class ViewportWidget : public Widget<Events, Canvas> {
+	public:
+		explicit ViewportWidget(Canvas* canvas, Geometry* geometry, Vec2F renderResolution) :
+			mRender(renderResolution) {
+			this->createConfig("ViewportWidget");
+			mImage = canvas->createImageFromTextId(mRender.getRenderBuffer(), mRender.getBufferSize());
+			mCanvas = canvas;
+		}
+
+		~ViewportWidget() { mCanvas->deleteImageHandle(mImage); }
+
+		void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
+			this->mArea = aArea;
+			this->mVisible = areaParent.isOverlap(aArea);
+			if (!this->mVisible) return;
+
+			mRender.render(*mGeometry, this->mArea.size);
+		}
+
+		void draw(Canvas& canvas) override {
+			if (!this->mVisible) return;
+
+			canvas.drawImage(this->mArea, &mImage);
+		}
+
+	public:
+		Render mRender;
+		Geometry* mGeometry = nullptr;
+		Canvas* mCanvas = nullptr;
+		Canvas::ImageHandle mImage;
+	};
+
+	template <typename Events, typename Canvas>
+	class EditorWidget : public Widget<Events, Canvas> {
+	public:
+		EditorWidget(Canvas* canvas, Geometry* geometry, Vec2F renderResolution) :
+			mViewport(canvas, geometry, renderResolution) {
+			this->createConfig("EditorWidget");
+			this->addColor("Base", "Base");
+		}
+
+		void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
+			this->mArea = aArea;
+			this->mVisible = areaParent.isOverlap(aArea);
+			if (!this->mVisible) return;
+
+			mSplitView.proc(events, aArea, aArea);
+			mViewport.proc(events, aArea, mSplitView.getFirst());
+		}
+
+		void draw(Canvas& canvas) override {
+			if (!this->mVisible) return;
+
+			canvas.rect(this->mArea, this->getColor("Base"));
+			mSplitView.draw(canvas);
+			mViewport.draw(canvas);
+		}
+
+	public:
+		ViewportWidget<Events, Canvas> mViewport;
+		SplitView<Events, Canvas> mSplitView;
+	};
+}

GeometryEditor2D/public/Geometry.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace tp {
+	class Geometry {
+	public:
+		Geometry() = default;
+	};
+}

GeometryEditor2D/public/Render.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Geometry.hpp"
+#include "Rect.hpp"
+
+#include "FrameBuffer.hpp"
+#include "Shader.hpp"
+
+namespace tp {
+	class Render {
+	public:
+		explicit Render(Vec2F renderResolution);
+		~Render();
+
+		void render(const Geometry& geometry, Vec2F size);
+		uint4 getRenderBuffer();
+		Vec2F getBufferSize();
+
+	private:
+		RenderBuffer mRenderBuffer;
+		RenderShader mDefaultShader;
+	};
+}

GeometryEditor2D/rsc/shaders/default.frag

@@ -0,0 +1,9 @@
+#version 330 core
+
+uniform vec4 Color;
+
+out vec4 FragColor;
+
+void main() {
+  FragColor = vec4(1.f);
+}

GeometryEditor2D/rsc/shaders/default.vert

@@ -0,0 +1,22 @@
+#version 330 core
+
+layout(location = 0) in vec2 point;
+
+uniform vec4 Viewport;
+
+void main() {
+    vec2 transformedPoint = point;
+
+    transformedPoint.x = transformedPoint.x - Viewport.x;
+    transformedPoint.y = transformedPoint.y - Viewport.y;
+
+    transformedPoint.x = transformedPoint.x / Viewport.z;
+    transformedPoint.y = transformedPoint.y / Viewport.w;
+
+    transformedPoint.y = -transformedPoint.y;
+
+    transformedPoint.y = transformedPoint.y * 2;
+    transformedPoint.x = transformedPoint.x * 2;
+
+	gl_Position = vec4(transformedPoint.x - 1, transformedPoint.y + 1, 1.0, 1.0);
+}