very basic working version

src/ThreadPool.cpp

@@ -45,7 +45,7 @@ void ThreadPool::work()
         std::function<void()> job;
         {
             std::unique_lock l(queueLock);
-            if (taskQueue.front().jobs.empty())
+            if (taskQueue.empty() || taskQueue.front().jobs.empty())
             {
                 queueCV.wait(l);
                 continue;

src/scene/Scene.cpp

@@ -1,40 +1,50 @@
 #include "Scene.h"
+#include <iostream>
+#include <chrono>
 
 Scene::Scene() {}
 
 Scene::~Scene() {}
 
+static bool firstTime = true;
 void Scene::render(Camera cam, RenderParameter params)
 {
+    if (!firstTime)
+    {
         pendingCancel = true;
         worker.join();
+        firstTime = false;
+    }
     pendingCancel = false;
+    image.clear();
+    accumulator.clear();
+    image.resize(params.width * params.height);
+    accumulator.resize(params.width * params.height);
     worker = std::thread(
         [&]()
         {
-            image.clear();
-            accumulator.clear();
-            image.resize(params.width * params.height * 3);
-            accumulator.resize(params.width * params.height * 3);
             for (int samp = 0; samp < params.numSamples; ++samp)
             {
                 if (pendingCancel)
                     return;
                 Batch batch;
                 for (int w = 0; w < params.width; ++w)
+                {
+                    batch.jobs.push_back(
+                        [&, w]()
                         {
                             for (int h = 0; h < params.height; ++h)
                             {
-                        batch.jobs.push_back(
+                                // Ray r = Ray();
-                            [&]()
+                                // bvh.traceRay(r);
-                            {
+                                accumulator[w + h * params.width] +=
-                                Ray r = Ray();
+                                    glm::vec3(w / float(params.width * params.numSamples), h / float(params.height * params.numSamples), 0);
-                                bvh.traceRay(r);
+                            }
                         });
                 }
-                }
                 threadPool.runBatch(std::move(batch));
-                std::memcpy(image.data(), accumulator.data(), accumulator.size());
+                std::memcpy(image.data(), accumulator.data(), accumulator.size() * sizeof(glm::vec3));
+                std::cout << samp << std::endl;
             }
         });
 }

src/scene/Scene.h

@@ -17,14 +17,14 @@ class Scene
     Scene();
     ~Scene();
     void render(Camera cam, RenderParameter params);
-    constexpr const std::vector<unsigned char>& getImage() const { return image; }
+    constexpr const std::vector<glm::vec3>& getImage() const { return image; }
   private:
     std::atomic_bool pendingCancel = false;
     ThreadPool threadPool;
     std::thread worker;
     // the thing being displayed
-    std::vector<unsigned char> image;
+    std::vector<glm::vec3> image;
     // radiance accumulator
-    std::vector<unsigned char> accumulator;
+    std::vector<glm::vec3> accumulator;
     BVH bvh;
 };

src/window/Window.cpp

@@ -18,7 +18,7 @@ Window::Window(int width, int height) : width(width), height(height)
     glBindVertexArray(vao);
     glGenTextures(1, &texture);
     glBindTexture(GL_TEXTURE_2D, texture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_FLOAT, nullptr);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     program = glCreateProgram();
     vertShader = glCreateShader(GL_VERTEX_SHADER);
@@ -76,11 +76,11 @@ Window::Window(int width, int height) : width(width), height(height)
 
 Window::~Window() {}
 
-void Window::update(const std::vector<unsigned char>& textureData)
+void Window::update(const std::vector<glm::vec3>& textureData)
 {
     glClear(GL_COLOR_BUFFER_BIT);
     glBindTexture(GL_TEXTURE_2D, texture);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, textureData.data());
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGB, GL_FLOAT, textureData.data());
     glUseProgram(program);
     glDrawArrays(GL_TRIANGLES, 0, 3);
     glfwSwapBuffers(window);

src/window/Window.h

@@ -2,13 +2,14 @@
 #include <GL/glew.h>
 #include <glfw/glfw3.h>
 #include <vector>
+#include <glm/glm.hpp>
 
 class Window
 {
   public:
     Window(int width, int height);
     ~Window();
-    void update(const std::vector<unsigned char>& textureData);
+    void update(const std::vector<glm::vec3>& textureData);
 
   private:
     int width;