based wtf

libhart/scene/camera.hpp

@@ -10,7 +10,7 @@ namespace inferno::graphics {
 
 struct _CameraImpl;
 
-typedef struct Viewports {
+typedef struct Viewport {
     glm::ivec2 Raster;
     glm::ivec2 Ray;
 } Viewports;
@@ -20,7 +20,7 @@ typedef struct Camera {
     glm::mat4 ProjectionMatrix;
     glm::mat4 LookMatrix;
 
-    std::shared_ptr<Viewports> Viewports;
+    std::shared_ptr<Viewport> Views;
 
     float MouseSensitivity = 0.4f;
     float Speed = 0.1f;

src/hart_directory.hpp

@@ -53,7 +53,7 @@ public:
 
     void setActive(std::string moduleName);
     void setActiveIndex(int index);
-    
+
     HARTModule* getActiveModule();
     std::string getActive();
     int getActiveIndex();

src/inferno.cpp

@@ -1,4 +1,4 @@
-#include "inferno.hpp"
+#include "infergo.hpp"
 
 #include <version.hpp>
 // #include "gui/layout.hpp"

src/preview_renderer/renderer.cpp

@@ -3,112 +3,134 @@
 #include "shader.hpp"
 
 #include <scene/camera.hpp>
-#include <scene/scene.hpp>
 #include <scene/material.hpp>
 #include <scene/mesh.hpp>
+#include <scene/scene.hpp>
 
 #include <iostream>
 
-using namespace inferno;
+namespace inferno::graphics {
 
-RasterizeRenderer::RasterizeRenderer()
+std::unique_ptr<PreviewRenderer> preview_create()
 {
-    glGenFramebuffers(1, &mRenderTarget);
+    std::unique_ptr<PreviewRenderer> renderer = std::make_unique<PreviewRenderer>();
-    glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
 
+    glGenFramebuffers(1, &renderer->RenderTarget);
+    glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
 
-    glGenTextures(1, &mRenderTargetTexture);
+    glGenTextures(1, &renderer->RenderTargetTexture);
-    glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture);
+    glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);  
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
-
+    glGenTextures(1, &renderer->RenderTargetDepthTexture);
-	glGenTextures(1, &mRenderTargetDepthTexture );
+    glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
-	glBindTexture(GL_TEXTURE_2D, mRenderTargetDepthTexture );
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
-	// Attach the texture to the framebuffer.
+    // Attach the texture to the framebuffer.
-	glFramebufferTexture2D( GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, mRenderTargetDepthTexture, 0 );
+    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderer->RenderTargetDepthTexture, 0);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mRenderTargetTexture, 0);  
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderer->RenderTargetTexture, 0);
 
     assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);  
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    return renderer;
 }
 
-RasterizeRenderer::~RasterizeRenderer()
+void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer)
 {
-
 }
 
-void RasterizeRenderer::setScene(Scene* scene)
+void preview_set_scene(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<Scene> scene)
 {
-    mCurrentScene = scene;
+    renderer->CurrentScene = scene;
 }
 
-void RasterizeRenderer::setTargetSize(glm::ivec2 size)
+void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<const Viewport> viewport)
 {
-    glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
+    renderer->RenderTargetSize = viewport;
+    glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
 
-    glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture);
+    glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+    glTexImage2D(
+        GL_TEXTURE_2D,
+        0,
+        GL_RGB,
+        viewport->Raster.x,
+        viewport->Raster.y,
+        0,
+        GL_RGB,
+        GL_UNSIGNED_BYTE,
+        NULL);
 
-    glBindTexture(GL_TEXTURE_2D, mRenderTargetDepthTexture);
+    glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
-	glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, size.x, size.y, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL );
+    glTexImage2D(GL_TEXTURE_2D,
+        0,
+        GL_DEPTH24_STENCIL8,
+        viewport->Raster.x,
+        viewport->Raster.y,
+        0,
+        GL_DEPTH_COMPONENT,
+        GL_FLOAT,
+        NULL);
 
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    mRenderTargetSize = size;
 }
 
-GLuint RasterizeRenderer::getRenderedTexture()
+const glm::ivec2& preview_get_viewport(std::unique_ptr<PreviewRenderer>& renderer)
 {
-    glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
+    return renderer->RenderTargetSize->Raster;
-    return mRenderTargetTexture;
 }
 
-glm::ivec2 RasterizeRenderer::getTargetSize()
+GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer)
 {
-    return mRenderTargetSize;
+    glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
+    return renderer->RenderTargetTexture;
 }
 
-void RasterizeRenderer::prepare()
+void preview_prepare(std::unique_ptr<PreviewRenderer>& renderer)
 {
-    glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
+    glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
     glClearColor(0.1, 0.1, 0.1, 1.0);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-void RasterizeRenderer::draw()
+void preview_draw(std::unique_ptr<PreviewRenderer>& renderer)
 {
-    glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
+    glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
-    glViewport(0, 0, mRenderTargetSize.x, mRenderTargetSize.y);
+    glViewport(0,
+        0,
+        renderer->RenderTargetSize->Raster.x,
+        renderer->RenderTargetSize->Raster.y);
 
-	glEnable(GL_DEPTH_TEST);
+    glEnable(GL_DEPTH_TEST);
-    
-    for (Mesh* m : mCurrentScene->getRenderables())
-    {
-		//m->getMaterial()->getGlShader()->use();
-        //GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model");
-        //glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
 
-        //GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view");
+    for (Mesh* m : renderer->CurrentScene->getRenderables()) {
-        //glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getViewMatrix()));
+        // m->getMaterial()->getGlShader()->use();
+        // GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model");
+        // glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
+
+        // GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view");
+        // glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getViewMatrix()));
+
+        // GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj");
+        // glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getProjectionMatrix()));
 
-        //GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj");
-        //glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getProjectionMatrix()));
-        
         glBindVertexArray(m->getVAO());
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO());
 
         glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0);
     }
-    
+
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
+
+}

src/preview_renderer/renderer.hpp

@@ -2,32 +2,33 @@
 
 #include <graphics.hpp>
 
-namespace inferno {
+#include <memory>
-
-class Scene;
-
-class RasterizeRenderer 
-{
-public:
-    RasterizeRenderer();
-    ~RasterizeRenderer();
-
-    void setScene(Scene* scene);
-
-    void setTargetSize(glm::ivec2 size);
-    glm::ivec2 getTargetSize();
-    GLuint getRenderedTexture();
-
-    void prepare();
-    void draw();
-
-private:
-    GLuint mRenderTarget = 0;
-    GLuint mRenderTargetTexture = 0;
-    GLuint mRenderTargetDepthTexture = 0;
-    glm::ivec2 mRenderTargetSize = {1920, 1080};
-
-    Scene* mCurrentScene;
-};
 
+namespace inferno::scene {
+struct Scene;
 }
+
+namespace inferno::graphics {
+
+struct Viewport;
+
+typedef struct PreviewRenderer {
+    GLuint RenderTarget = 0;
+    GLuint RenderTargetTexture = 0;
+    GLuint RenderTargetDepthTexture = 0;
+    std::shared_ptr<scene::Scene> CurrentScene;
+    std::shared_ptr<const Viewport> RenderTargetSize;
+} PreviewRenderer;
+
+std::unique_ptr<PreviewRenderer> preview_create();
+void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer);
+
+void preview_set_scene(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<scene::Scene> scene);
+void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<const Viewport> viewports);
+const glm::ivec2& preview_get_viewport(std::unique_ptr<PreviewRenderer>& renderer);
+GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer);
+
+void preview_prepare(std::unique_ptr<PreviewRenderer>& renderer);
+void preview_draw(std::unique_ptr<PreviewRenderer>& renderer);
+
+} // namespace inferno::graphics

src/scene/camera.cpp

@@ -12,9 +12,9 @@ std::unique_ptr<Camera> camera_create()
 {
     std::unique_ptr<Camera> camera = std::make_unique<Camera>();
     camera->_impl = std::make_unique<_CameraImpl>();
-    camera->Viewports = std::make_shared<Viewports>();
+    camera->Views = std::make_shared<Viewports>();
-    camera->Viewports->Raster = glm::ivec2(800, 600);
+    camera->Views->Raster = glm::ivec2(800, 600);
-    camera->Viewports->Ray = glm::ivec2(800, 600);
+    camera->Views->Ray = glm::ivec2(800, 600);
 
     camera->ProjectionMatrix = glm::perspective(
         glm::radians(camera->FOV),
@@ -61,7 +61,7 @@ void camera_update(std::unique_ptr<Camera>& camera)
     camera->ViewMatrix = rotate * translate;
     camera->ProjectionMatrix = glm::perspective(
         glm::radians(camera->FOV),
-        static_cast<float>(camera->Viewports->Raster.x) / static_cast<float>(camera->Viewports->Raster.y),
+        static_cast<float>(camera->Views->Raster.x) / static_cast<float>(camera->Views->Raster.y),
         0.1f,
         1000.0f);
 
@@ -108,7 +108,7 @@ glm::mat4 camera_get_look(std::unique_ptr<Camera>& camera)
 void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
-    camera->Viewports->Raster = viewport;
+    camera->Views->Raster = viewport;
     camera->ProjectionMatrix = glm::perspective(
         glm::radians(camera->FOV),
         static_cast<float>(viewport.x) / static_cast<float>(viewport.y),
@@ -119,19 +119,19 @@ void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
 glm::ivec2 raster_get_viewport(std::unique_ptr<Camera>& camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
-    return camera->Viewports->Raster;
+    return camera->Views->Raster;
 }
 
 void ray_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
-    camera->Viewports->Ray = viewport;
+    camera->Views->Ray = viewport;
 }
 
 glm::ivec2 ray_get_viewport(std::unique_ptr<Camera>& camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
-    return camera->Viewports->Ray;
+    return camera->Views->Ray;
 }
 
 void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta)

src/scene/scene.hpp

@@ -2,14 +2,17 @@
 
 #include <vector>
 
-namespace inferno {
+namespace inferno::scene {
 
 class SceneObject;
 class Camera;
 class Mesh;
 class Sky;
 
-class Scene 
+typedef struct Scene {
+
+} Scene;
+
 {
 public:
     Scene();