3D editor stable with path tracer

3DEditor/private/Editor.cpp

@@ -1,24 +1,97 @@
 
 #include "Editor.hpp"
 
+#include "GraphicsApi.hpp"
+
 using namespace tp;
 
-void Editor::loadDefaults() {
-	mScene.load("rsc/scene/script.lua");
-}
+Editor::Editor() {
 
-uint4 Editor::getViewportTexID() {
-	return mRasterRenderer.getRenderBufferID();
+	{ // create path tracer gpu texture
+		glGenTextures(1, &mPathRenderTexture);
+		glBindTexture(GL_TEXTURE_2D, mPathRenderTexture);
+
+		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_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 100, 100, 0, GL_RGBA, GL_FLOAT, nullptr);
+		glBindTexture(GL_TEXTURE_2D, 0);
+	}
 }
 
 void Editor::renderViewport() {
-	mRasterRenderer.render(mScene, mViewportSize);
+	switch (mRenderType) {
+		case RenderType::RASTER:
+			mRasterRenderer.render(mScene, mScene.mRenderSettings.size);
+			break;
+
+		case RenderType::PATH_TRACER:
+			{
+				// TODO : include in render viewport method
+				// renderPathFrame();
+				break;
+			}
+
+		default:
+			break;
+	}
+}
+
+uint4 Editor::getViewportTexID() {
+	switch (mRenderType) {
+		case RenderType::PATH_TRACER:
+			return mPathRenderTexture;
+
+		case RenderType::RASTER:
+			return mRasterRenderer.getRenderBufferID();
+
+		default:
+			return 0;
+	}
+}
+
+void Editor::loadDefaults() {
+	mScene.load("rsc/scene/script.lua");
 }
 
 void Editor::setViewportSize(const Vec2F& size) {
 	// TODO remove
 	mScene.mCamera.rotate(0.01f, 0.0);
 
+	mScene.mRenderSettings.size = size;
+
 	mRasterRenderer.getRenderBuffer()->resize(size);
 	mScene.mCamera.setRatio(size.y / size.x);
 }
+
+Editor::~Editor() {
+	glDeleteTextures(1, &mPathRenderTexture);
+}
+
+void Editor::renderPathFrame() {
+	mPathRenderer.render(mScene, mPathTracerBuffers, mScene.mRenderSettings);
+
+	{
+		glBindTexture(GL_TEXTURE_2D, mPathRenderTexture);
+		const auto size = mPathTracerBuffers.color.size();
+		glTexImage2D(
+			GL_TEXTURE_2D,
+			0,
+			GL_RGBA32F,
+			(GLsizei) size.x,
+			(GLsizei) size.y,
+			0,
+			GL_RGBA,
+			GL_FLOAT,
+			mPathTracerBuffers.color.getBuff()
+		);
+		glBindTexture(GL_TEXTURE_2D, 0);
+
+	}
+}
+
+void Editor::setRenderType(Editor::RenderType type) {
+	mRenderType = type;
+}

3DEditor/public/Editor.hpp

@@ -6,21 +6,31 @@
 namespace tp {
 	class Editor {
 	public:
-		Editor() = default;
+		enum class RenderType { RASTER, PATH_TRACER };
+
+	public:
+		Editor();
+		~Editor();
 
 		void loadDefaults();
 
 		uint4 getViewportTexID();
+
 		void setViewportSize(const Vec2F& size);
 		void renderViewport();
 
+		void renderPathFrame();
+		void setRenderType(RenderType type);
+
 	private:
 		Scene mScene;
 
+		RenderType mRenderType = RenderType::RASTER;
+
 		RasterRender mRasterRenderer;
 		RayTracer mPathRenderer;
 
-		// TODO move inside the scene
-		Vec2F mViewportSize;
+		RayTracer::OutputBuffers mPathTracerBuffers;
+		uint4 mPathRenderTexture = 0;
 	};
 }

3DEditor/public/EditorWidget.hpp

@@ -21,6 +21,8 @@ namespace tp {
 
 		void eventDraw(Canvas& canvas) override {
 			mEditor->renderViewport();
+
+			canvas.updateTextureID(mImage, mEditor->getViewportTexID());
 			canvas.drawImage(this->mArea, &mImage, PI);
 		}
 
@@ -37,16 +39,38 @@ namespace tp {
 		EditorWidget(Canvas* canvas, Editor* editor) :
 			mViewport(canvas, editor)
 		{
+			mEditor = editor;
+
 			this->mChildWidgets.pushBack(&mViewport);
 			this->mChildWidgets.pushBack(&mSplitView);
+			this->mChildWidgets.pushBack(&mSettingsWidget);
+
+			mRenderPathTracer.mLabel.mLabel = "Render with Path Tracer";
+			mRenderRaster.mLabel.mLabel = "Render with Raster";
+
+			mSettingsWidget.addWidget(&mRenderPathTracer);
+			mSettingsWidget.addWidget(&mRenderRaster);
 		}
 
 		void eventProcess(const Events& events) override {
 			mSplitView.setArea(this->mArea);
+
 			mViewport.setArea(mSplitView.getFirst());
+			mSettingsWidget.setArea(mSplitView.getSecond());
+
+			if (mRenderPathTracer.isFired()) {
+				mEditor->renderPathFrame();
+				mEditor->setRenderType(Editor::RenderType::PATH_TRACER);
 			}
 
-		void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBaseColor); }
+			if (mRenderRaster.isFired()) {
+				mEditor->setRenderType(Editor::RenderType::RASTER);
+			}
+		}
+
+		void eventDraw(Canvas& canvas) override {
+			canvas.rect(this->mArea, mBaseColor);
+		}
 
 		void eventUpdateConfiguration(WidgetManager& wm) override {
 			wm.setActiveId("3DEditor");
@@ -54,9 +78,17 @@ namespace tp {
 		}
 
 	public:
-		ViewportWidget<Events, Canvas> mViewport;
+		Editor* mEditor = nullptr;
+
 		SplitView<Events, Canvas> mSplitView;
 
+		ViewportWidget<Events, Canvas> mViewport;
+
+		// Controls
+		ScrollableWindow<Events, Canvas> mSettingsWidget;
+		ButtonWidget<Events, Canvas> mRenderPathTracer;
+		ButtonWidget<Events, Canvas> mRenderRaster;
+
 		RGBA mBaseColor;
 	};
 }

3DEditor/rsc/scene/script.lua

@@ -20,6 +20,6 @@ Lights = {
 
 RenderSettings = {
     depth = 1,
-    spray = 3,
-    multisampling = 16,
+    spray = 1,
+    multisampling = 1,
 }

Containers/public/Buffer2D.hpp

@@ -40,7 +40,7 @@ namespace tp {
 		void allocateBuffer(Index2D size) {
 			deleteBuffer();
 			mBuff = (tType*) mAlloc.allocate(sizeof(tType) * size.x * size.y);
-			for (ualni i = 0; i < mSize.x * mSize.y; i++) {
+			for (ualni i = 0; i < size.x * size.y; i++) {
 				new (mBuff + i) tType();
 			}
 		}

Graphics/private/Canvas.cpp

@@ -130,6 +130,14 @@ void Canvas::drawImage(const RectF& rec, ImageHandle* image, halnf angle, halnf
 #endif
 }
 
+void Canvas::updateTextureID(ImageHandle handle, ualni id) {
+	auto nvgl = (GLNVGcontext*) nvgInternalParams(mContext->vg)->userPtr;
+	auto glhandle = nvglImageHandleGL3(mContext->vg, handle.id);
+
+	auto tex = glnvg__findTexture(nvgl, handle.id);
+	tex->tex = id;
+}
+
 void Canvas::deleteImageHandle(ImageHandle image) {
 	if (image.id) {
 		nvgDeleteImage(mContext->vg, image.id);

Graphics/public/Graphics.hpp

@@ -61,6 +61,8 @@ namespace tp {
 		void text(const char*, const RectF&, halnf size, Align, halnf padding, const RGBA&);
 
 		ImageHandle createImageFromTextId(ualni id, Vec2F size);
+		void updateTextureID(ImageHandle handle, ualni id);
+
 		void deleteImageHandle(ImageHandle image);
 		void drawImage(const RectF& rec, ImageHandle* image, halnf angle = 0, halnf alpha = 1.f, halnf rounding = 0.f);
 

Math/public/Color.hpp

@@ -80,8 +80,6 @@ namespace tp {
 		bool operator==(const RGBA& in) const { return r == in.r && g == in.g && b == in.b && a == in.a; }
 
 	public:
-		flt4 a;
-
 		union {
 			RGB rgbs;
 
@@ -91,6 +89,8 @@ namespace tp {
 				flt4 b;
 			};
 		};
+
+		flt4 a;
 	};
 
 	class HSVA {

RasterRender/private/Render.cpp

@@ -15,7 +15,7 @@ uint4 RasterRender::getRenderBufferID() { return mRenderBuffer.texId(); }
 
 Vec2F RasterRender::getBufferSize() { return mRenderBuffer.getSize(); }
 
-void RasterRender::render(const Scene& geometry, Vec2F size) {
+void RasterRender::render(const Scene& geometry, const Vec2<ualni>& size) {
 
 	for (auto object : geometry.mObjects) {
 		if (!object->mGUPBuffers) {

RasterRender/public/RasterRender.hpp

@@ -12,7 +12,7 @@ namespace tp {
 		RasterRender();
 		~RasterRender();
 
-		void render(const Scene& geometry, Vec2F size);
+		void render(const Scene& geometry, const Vec2<ualni>& size);
 		uint4 getRenderBufferID();
 		RenderBuffer* getRenderBuffer();
 		Vec2F getBufferSize();

Widgets/public/ButtonWidget.hpp

@@ -8,7 +8,7 @@ namespace tp {
 	class ButtonWidget : public Widget<Events, Canvas> {
 	public:
 		ButtonWidget() {
-			this->setArea({ 0, 0, 100, 100 });
+			this->setArea({ 0, 0, 100, 30 });
 			this->mChildWidgets.pushBack(&mLabel);
 		}