what an obtuse error

hart/inferno-hart-cpu/src/main.cpp

@@ -27,7 +27,11 @@ public:
                             std::vector<Material*>* mats,
                             std::vector<int>* indicies)  override {}
 
-    void submitQueue(std::queue<Ray*> queue) override {}
+    void submitQueue(std::vector<Ray*> queue) override 
+    {
+        
+    }
+
     void pushtoQueue(Ray* ray) override {}
 };
 

hart/inferno-hart-opencl/src/main.cpp

@@ -27,7 +27,7 @@ public:
                             std::vector<Material*>* mats,
                             std::vector<int>* indicies)  override {}
 
-    void submitQueue(std::queue<Ray*> queue) override {}
+    void submitQueue(std::vector<Ray*> queue) override {}
     void pushtoQueue(Ray* ray) override {}
 };
 

src/hart_module.cpp

@@ -1,5 +1,7 @@
 #include "hart_module.hpp"
 
+#include <vector>
+
 #include <renderer/ray_source.hpp>
 #include <scene/scene.hpp>
 #include <scene/mesh.hpp>
@@ -38,10 +40,10 @@ void HHM::notifySceneUpdate()
     // same again
 }
 
-void HHM::startTrace(RayField* sourceScatter)
+void HHM::startTrace(RayField sourceScatter)
 {
     HARTModule* mod = mDirectory.getActiveModule();
-    mod->submitQueue(reinterpret_cast<std::vector<Ray*>>(sourceScatter));
+    mod->submitQueue(sourceScatter);
 }
 
 void HHM::rayReturn(HitInfo* hit)

src/hart_module.hpp

@@ -3,17 +3,19 @@
 // the HHM (Hamlin Hamlin McGill) aka the Head HART Module keeps track of the module
 // and gives the renderer a cleaner interface to talk to a HART Module
 
+#include <vector>
+
 #include "hart_directory.hpp"
 
 namespace inferno {
 
 class Scene;
 class Ray;
-class RayField;
 class HitInfo;
-
 class HARTModule;
 
+using RayField = std::vector<Ray*>;
+
 class HHM 
 {
 public:
@@ -25,14 +27,13 @@ public:
     void newScene(Scene* scene);
     void notifySceneUpdate();    
 
-    void startTrace(RayField* sourceScatter);
+    void startTrace(RayField sourceScatter);
 
     void rayReturn(HitInfo* hit);
     void bounce(Ray* newRay);
 
 private:
     HARTModuleDirectory mDirectory;
-
 };
 
 }

src/inferno.cpp

@@ -9,6 +9,7 @@
 
 #include "preview_renderer/renderer.hpp"
 #include "preview_renderer/shader.hpp"
+#include "renderer/dispatcher.hpp"
 #include "renderer/renderer.hpp"
 #include "scene/camera.hpp"
 #include "scene/scene.hpp"
@@ -34,9 +35,7 @@ Inferno::Inferno()
     mWin = &Window::GetInstance();
     mWin->init("Inferno v" INFERNO_VERSION, 1280, 720);
 
-    mHeadHartModule = new HHM();
     mRasterRenderer = new RasterizeRenderer();
-    mRayRenderer = new RayRenderer(mHeadHartModule);
     mScene = new Scene();
 }
 
@@ -146,7 +145,7 @@ int Inferno::run()
     mScene->setCamera(&camera);
 
     mRasterRenderer->setScene(mScene);
-    mRayRenderer->setScene(mScene);
+    mRayRenderer->getRenderer()->setScene(mScene);
 
     while (true) 
     {
@@ -207,10 +206,9 @@ int Inferno::run()
 
         if (ImGui::Begin("Render", nullptr, ImGuiWindowFlags_NoScrollbar))
         {
-            mRayRenderer->prepare();
-            mRayRenderer->draw();
-            ImGui::Image((ImTextureID)mRayRenderer->getRenderedTexture(),
-                { mRayRenderer->getTargetSize().x, mRayRenderer->getTargetSize().y },
+            ImGui::Image((ImTextureID)mRayRenderer->getLatestTexture(),
+                { mRayRenderer->getRenderer()->getTargetSize().x,
+                  mRayRenderer->getRenderer()->getTargetSize().y },
                 ImVec2(0,1), ImVec2(1,0));
             glBindTexture(GL_TEXTURE_2D, 0);
             ImGui::End();
@@ -220,25 +218,26 @@ int Inferno::run()
         {
             if (ImGui::TreeNode("Render"))
             {
+                HHM* hhm = mRayRenderer->getTopModule();
                 if (ImGui::TreeNode("Accelerator"))
                 {
                     ImGui::Button("Find Accelerator...");
                     ImGui::Text("Select Accelerator:");
                     if (ImGui::BeginListBox("", ImVec2(-FLT_MIN, 3 * ImGui::GetTextLineHeightWithSpacing())))
                     {
-                        std::vector<std::string> moduleNames = mHeadHartModule->getModuleDirectory()->getModules();
-                        int active = mHeadHartModule->getModuleDirectory()->getActiveIndex();
+                        std::vector<std::string> moduleNames = hhm->getModuleDirectory()->getModules();
+                        int active = hhm->getModuleDirectory()->getActiveIndex();
                         for (int n = 0; n < moduleNames.size(); n++)
                         {
                             const bool isSelected = (active == n);
                             if (ImGui::Selectable(moduleNames[n].c_str(), isSelected))
-                                 mHeadHartModule->getModuleDirectory()->setActiveIndex(n);
+                                 hhm->getModuleDirectory()->setActiveIndex(n);
                             if (isSelected)
                                 ImGui::SetItemDefaultFocus();
                         }
                         ImGui::EndListBox();
                     }
-                    auto* activeCredit = mHeadHartModule->getModuleDirectory()->getActiveCredit();
+                    auto* activeCredit = hhm->getModuleDirectory()->getActiveCredit();
                     ImGui::Text(activeCredit->ModuleName.c_str());
                     ImGui::SameLine();
                     ImGui::Text("v%i.%i.%i", activeCredit->VersionMajor,

src/inferno.hpp

@@ -10,7 +10,7 @@ class Window;
 class HHM;
 
 class RasterizeRenderer;
-class RayRenderer;
+class RenderDispatcher;
 class Scene;
 
 class Inferno : public helpers::Singleton<Inferno>
@@ -35,10 +35,8 @@ private:
     // need deffered init as they need an OpenGL context
     // could and should be fixed with a static window
     RasterizeRenderer* mRasterRenderer;
-    RayRenderer* mRayRenderer;
+    RenderDispatcher* mRayRenderer;
     Scene* mScene;
-
-    HHM* mHeadHartModule;
     
 private:
     Window* mWin;

src/renderer/dispatcher.cpp

@@ -0,0 +1,45 @@
+#include "dispatcher.hpp"
+
+#include <graphics.hpp>
+
+#include "renderer.hpp"
+
+#include "hart_module.hpp"
+
+using namespace inferno;
+
+RenderDispatcher::RenderDispatcher()
+{
+    mHHM = new HHM();
+    mRenderer = new RayRenderer(mHHM);
+}
+
+RenderDispatcher::~RenderDispatcher()
+{
+
+}
+
+RayRenderer* RenderDispatcher::getRenderer()
+{
+    return mRenderer;
+}
+
+HHM* RenderDispatcher::getTopModule()
+{
+    return mHHM;
+}
+
+void RenderDispatcher::startProgression()
+{
+
+}
+
+void RenderDispatcher::stopProgression()
+{
+
+}
+
+GLuint RenderDispatcher::getLatestTexture()
+{
+
+}

src/renderer/dispatcher.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+namespace inferno {
+
+// Thread dispatcher keeps track of the thread that calls the
+// copy function because OpenGL is a nightmare
+
+#include <graphics.hpp>
+
+class HHM;
+class Scene;
+class RayRenderer;
+
+class RenderDispatcher 
+{
+public:
+    RenderDispatcher();
+    ~RenderDispatcher();
+
+    RayRenderer* getRenderer();
+    HHM* getTopModule();
+
+    void startProgression();
+    void stopProgression();
+    GLuint getLatestTexture();
+    
+private:
+    HHM* mHHM;
+    RayRenderer* mRenderer;
+};
+
+}

src/renderer/ray_source.hpp

@@ -8,7 +8,7 @@
 
 namespace inferno {
 
-typedef std::vector<Ray*> RayField;
+using RayField = std::vector<Ray*>;
 
 class Camera;
 

src/renderer/renderer.cpp

@@ -71,7 +71,7 @@ void RayRenderer::prepare()
 void RayRenderer::draw()
 {
     RayField startRays = mRaySource->getInitialRays(true);
-    mIface->startTrace(&startRays);
+    mIface->startTrace(startRays);
 
     for (int x = 0; x < mRenderTargetSize.x; x++)
     for (int y = 0; y < mRenderTargetSize.y; y++)