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);
+			}
+
+			if (mRenderRaster.isFired()) {
+				mEditor->setRenderType(Editor::RenderType::RASTER);
+			}
 		}
 
-		void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBaseColor); }
+		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,
 }