Add basic R-MIS estimator

MrMagnifico · MrMagnifico · commit 94b03e60f0e6 · 2024-04-17T18:12:18.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -78,4 +78,4 @@ _deps
 ### Blobs ###
 /build
 /out
-assignment.html
+/renders
diff --git a/framework/third_party/glm/CMakeLists.txt b/framework/third_party/glm/CMakeLists.txt
@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.2 FATAL_ERROR)
-cmake_policy(VERSION 3.2)
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
+cmake_policy(VERSION 3.5)
 
 
 file(READ "glm/detail/setup.hpp" GLM_SETUP_FILE)
diff --git a/src/main.cpp b/src/main.cpp
@@ -95,8 +95,8 @@ int main(int argc, char** argv) {
                         break;
                     }
                     case GLFW_KEY_M: { // Change render mode and reset temporal predecessor
-                        viewMode            = viewMode == ViewMode::Rasterization ? ViewMode::RayTracing : ViewMode::Rasterization;
-                        previousFrameGrid   = nullptr;
+                        viewMode = viewMode == ViewMode::Rasterization ? ViewMode::ReSTIR : ViewMode::Rasterization;
+                        previousFrameGrid.reset();
                         break;
                     }
                 };
@@ -160,10 +160,10 @@ int main(int argc, char** argv) {
                         glPopAttrib();
                     }
                 } break;
-                case ViewMode::RayTracing: {
+                case ViewMode::ReSTIR: {
                     const auto start    = std::chrono::high_resolution_clock::now();
                     screen.clear(glm::vec3(0.0f));
-                    previousFrameGrid   = make_shared<ReservoirGrid>(renderRayTracing(previousFrameGrid, scene, camera, bvh, screen, camera.getLastDelta(), config.features));
+                    previousFrameGrid   = make_shared<ReservoirGrid>(renderReSTIR(previousFrameGrid, scene, camera, bvh, screen, config.features));
                     screen.setPixel(0, 0, glm::vec3(1.0f));
                     screen.draw(); // Takes the image generated using ray tracing and outputs it to the screen using OpenGL.
                     const auto end      = std::chrono::high_resolution_clock::now();
@@ -218,7 +218,7 @@ int main(int argc, char** argv) {
                 screen.clear(glm::vec3(0.0f));
                 Trackball camera { &window, glm::radians(cameraConfig.fieldOfView), cameraConfig.distanceFromLookAt };
                 camera.setCamera(cameraConfig.lookAt, glm::radians(cameraConfig.rotation), cameraConfig.distanceFromLookAt);
-                previousFrameGrid           = make_shared<ReservoirGrid>(renderRayTracing(previousFrameGrid, scene, camera, bvh, screen, camera.getLastDelta(), config.features));
+                previousFrameGrid           = make_shared<ReservoirGrid>(renderReSTIR(previousFrameGrid, scene, camera, bvh, screen, config.features));
                 const auto filename_base    = fmt::format("{}_{}_cam_{}", sceneName, start_time_string, index);
                 const auto filepath         = config.outputDir / (filename_base + ".bmp");
                 fmt::print("Image {} saved to {}\n", index, filepath.string());
diff --git a/src/rendering/render.cpp b/src/rendering/render.cpp
@@ -36,6 +36,19 @@ ReservoirGrid genInitialSamples(const Scene& scene, const Trackball& camera, con
     return initialSamples;
 }
 
+glm::vec3 finalShading(const Reservoir& reservoir, const Ray& primaryRay, const BvhInterface& bvh, const Features& features) {
+    glm::vec3 finalColor(0.0f);
+    for (const SampleData& sample : reservoir.outputSamples) {
+        glm::vec3 sampleColor   = testVisibilityLightSample(sample.lightSample.position, bvh, features, primaryRay, reservoir.hitInfo)              ?
+                                  computeShading(sample.lightSample.position, sample.lightSample.color, features, primaryRay, reservoir.hitInfo)    :
+                                  glm::vec3(0.0f);
+        sampleColor             *= sample.outputWeight;
+        finalColor              += sampleColor;
+    }
+    finalColor /= reservoir.outputSamples.size(); // Divide final shading value by number of samples
+    return finalColor;
+}
+
 void spatialReuse(ReservoirGrid& reservoirGrid, const BvhInterface& bvh, const Screen& screen, const Features& features) {
     // Uniform selection of neighbours in N pixel Manhattan distance radius
     std::random_device rd;
@@ -86,7 +99,7 @@ void spatialReuse(ReservoirGrid& reservoirGrid, const BvhInterface& bvh, const S
 }
 
 void temporalReuse(ReservoirGrid& reservoirGrid, ReservoirGrid& previousFrameGrid, const BvhInterface& bvh,
-                   Screen& screen, const glm::vec2 motionVector, const Features& features) {
+                   Screen& screen, const Features& features) {
     glm::ivec2 windowResolution = screen.resolution();
     #ifdef NDEBUG
     #pragma omp parallel for schedule(guided)
@@ -116,12 +129,12 @@ void temporalReuse(ReservoirGrid& reservoirGrid, ReservoirGrid& previousFrameGri
     }
 }
 
-ReservoirGrid renderRayTracing(std::shared_ptr<ReservoirGrid> previousFrameGrid,
-                               const Scene& scene, const Trackball& camera,
-                               const BvhInterface& bvh, Screen& screen,
-                               const glm::vec2 motionVector, const Features& features) {
+ReservoirGrid renderReSTIR(std::shared_ptr<ReservoirGrid> previousFrameGrid,
+                           const Scene& scene, const Trackball& camera,
+                           const BvhInterface& bvh, Screen& screen,
+                           const Features& features) {
     ReservoirGrid reservoirGrid = genInitialSamples(scene, camera, bvh, screen, features);
-    if (features.temporalReuse && previousFrameGrid)    { temporalReuse(reservoirGrid, *previousFrameGrid.get(), bvh, screen, motionVector, features); }
+    if (features.temporalReuse && previousFrameGrid)    { temporalReuse(reservoirGrid, *previousFrameGrid.get(), bvh, screen, features); }
     if (features.spatialReuse)                          { spatialReuse(reservoirGrid, bvh, screen, features); }
 
     // Final shading
@@ -132,16 +145,8 @@ ReservoirGrid renderRayTracing(std::shared_ptr<ReservoirGrid> previousFrameGrid,
     for (int y = 0; y < windowResolution.y; y++) {
         for (int x = 0; x != windowResolution.x; x++) {
             // Compute shading from final sample(s)
-            glm::vec3 finalColor(0.0f);
-            const Reservoir& reservoir = reservoirGrid[y][x];
-            for (const SampleData& sample : reservoir.outputSamples) {
-                glm::vec3 sampleColor   = testVisibilityLightSample(sample.lightSample.position, bvh, features, reservoir.cameraRay, reservoir.hitInfo)             ?
-                                          computeShading(sample.lightSample.position, sample.lightSample.color, features, reservoir.cameraRay, reservoir.hitInfo)   :
-                                          glm::vec3(0.0f);
-                sampleColor             *= sample.outputWeight;
-                finalColor              += sampleColor;
-            }
-            finalColor /= reservoir.outputSamples.size(); // Divide final shading value by number of samples
+            const Reservoir& reservoir  = reservoirGrid[y][x];
+            glm::vec3 finalColor        = finalShading(reservoir, reservoir.cameraRay, bvh, features);
 
             // Apply tone mapping and set final pixel color
             if (features.enableToneMapping) { finalColor = exposureToneMapping(finalColor, features); }
@@ -151,4 +156,33 @@ ReservoirGrid renderRayTracing(std::shared_ptr<ReservoirGrid> previousFrameGrid,
 
     // Return current frame's final grid for temporal reuse
     return reservoirGrid;
-}
+}
+
+void renderRMIS(const Scene& scene, const Trackball& camera, const BvhInterface& bvh, Screen& screen, const Features& features) {
+    ReservoirGrid reservoirGrid = genInitialSamples(scene, camera, bvh, screen, features);
+    glm::ivec2 windowResolution = screen.resolution();
+
+    #ifdef NDEBUG
+    #pragma omp parallel for schedule(guided)
+    #endif
+    for (int y = 0; y < windowResolution.y; y++) {
+        for (int x = 0; x != windowResolution.x; x++) {
+            const Ray& primaryRay = reservoirGrid[y][x].cameraRay;
+
+            // Combine samples from all pixels in 3x3 neighborhood
+            glm::vec3 finalColor(0.0f);
+            for (int sampleY = y - 1; sampleY <= y + 1; sampleY++) {
+                for (int sampleX = x - 1; sampleX <= x + 1; sampleX++) {
+                    int neighbourY  = std::clamp(sampleY, 0, windowResolution.y - 1);
+                    int neighbourX  = std::clamp(sampleX, 0, windowResolution.x - 1);
+                    finalColor += finalShading(reservoirGrid[neighbourY][neighbourX], primaryRay, bvh, features);    
+                }
+            }
+            finalColor *= (1.0f / 9.0f); // TODO: Change to actual OMIS MIS weights
+
+            // Apply tone mapping and set final pixel color
+            if (features.enableToneMapping) { finalColor = exposureToneMapping(finalColor, features); }
+            screen.setPixel(x, y, finalColor);
+        }
+    }
+}
diff --git a/src/rendering/render.h b/src/rendering/render.h
@@ -16,15 +16,20 @@ class Trackball;
 class BvhInterface;
 struct Features;
 
+// Common
 ReservoirGrid genInitialSamples(const Scene& scene, const Trackball& camera, const BvhInterface& bvh, const Screen& screen, const Features& features);
+glm::vec3 finalShading(const Reservoir& reservoir, const Ray& primaryRay, const BvhInterface& bvh, const Features& features);
 
+// ReSTIR-specific
 void spatialReuse(ReservoirGrid& reservoirGrid, const BvhInterface& bvh, const Screen& screen, const Features& features);
-
 void temporalReuse(ReservoirGrid& reservoirGrid, ReservoirGrid& previousFrameGrid, const BvhInterface& bvh,
-                   Screen& screen, const glm::vec2 motionVector, const Features& features);
+                   Screen& screen, const Features& features);
+
+// Render using ReSTIR
+ReservoirGrid renderReSTIR(std::shared_ptr<ReservoirGrid> previousFrameGrid,
+                           const Scene& scene, const Trackball& camera,
+                           const BvhInterface& bvh, Screen& screen,
+                           const Features& features);
 
-// Main rendering function.
-ReservoirGrid renderRayTracing(std::shared_ptr<ReservoirGrid> previousFrameGrid,
-                               const Scene& scene, const Trackball& camera,
-                               const BvhInterface& bvh, Screen& screen,
-                               const glm::vec2 motionVector, const Features& features);
+// Render using R-MIS
+void renderRMIS(const Scene& scene, const Trackball& camera, const BvhInterface& bvh, Screen& screen, const Features& features);
diff --git a/src/scene/light.cpp b/src/scene/light.cpp
@@ -51,7 +51,6 @@ Reservoir genCanonicalSamples(const Scene& scene, const BvhInterface& bvh, const
     }
 
     // Uniform selection of light sources
-    // TODO: Figure out better solution than uniform sampling (fuck you, point lights)
     std::random_device rd;
     std::mt19937 gen(rd());
     std::uniform_int_distribution<> distr(0, scene.lights.size() - 1UL);
diff --git a/src/ui/ui.cpp b/src/ui/ui.cpp
@@ -117,7 +117,7 @@ void UiManager::drawSceneSelection() {
 }
 
 void UiManager::drawViewModeSelection() {
-    constexpr std::array items { "Rasterization", "Ray Traced" };
+    constexpr std::array items { "Rasterization", "ReSTIR", "OMIS" };
     ImGui::Combo("View mode", reinterpret_cast<int*>(&viewMode), items.data(), int(items.size()));
 }
 
@@ -173,7 +173,7 @@ void UiManager::drawRenderToFile() {
             // Perform a new render and measure the time it took to generate the image.
             using clock         = std::chrono::high_resolution_clock;
             const auto start    = clock::now();
-            previousFrameGrid   = std::make_shared<ReservoirGrid>(renderRayTracing(previousFrameGrid, scene, camera, bvh, screen, camera.getLastDelta(), config.features));
+            renderRMIS(scene, camera, bvh, screen, config.features);
             const auto end      = clock::now();
             std::cout << "Time to render image: " << std::chrono::duration<float, std::milli>(end - start).count() << " milliseconds" << std::endl;
             
diff --git a/src/utils/common.h b/src/utils/common.h
@@ -13,7 +13,8 @@ enum class DrawMode {
 
 enum class ViewMode {
     Rasterization = 0,
-    RayTracing = 1
+    ReSTIR,
+    OMIS
 };
 
 struct HitInfo {
diff --git a/src/utils/magic_enum.hpp b/src/utils/magic_enum.hpp

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ Reservoir genCanonicalSamples(const Scene& scene, const BvhInterface& bvh, const`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`// Uniform selection of light sources`
`54`		`- // TODO: Figure out better solution than uniform sampling (fuck you, point lights)`
`55`	`54`	`std::random_device rd;`
`56`	`55`	`std::mt19937 gen(rd());`
`57`	`56`	`std::uniform_int_distribution<> distr(0, scene.lights.size() - 1UL);`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ void UiManager::drawSceneSelection() {`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`void UiManager::drawViewModeSelection() {`
`120`		`- constexpr std::array items { "Rasterization", "Ray Traced" };`
	`120`	`+ constexpr std::array items { "Rasterization", "ReSTIR", "OMIS" };`
`121`	`121`	`ImGui::Combo("View mode", reinterpret_cast<int*>(&viewMode), items.data(), int(items.size()));`
`122`	`122`	`}`
`123`	`123`
`@@ -173,7 +173,7 @@ void UiManager::drawRenderToFile() {`
`173`	`173`	`// Perform a new render and measure the time it took to generate the image.`
`174`	`174`	`using clock = std::chrono::high_resolution_clock;`
`175`	`175`	`const auto start = clock::now();`
`176`		`- previousFrameGrid = std::make_shared<ReservoirGrid>(renderRayTracing(previousFrameGrid, scene, camera, bvh, screen, camera.getLastDelta(), config.features));`
	`176`	`+ renderRMIS(scene, camera, bvh, screen, config.features);`
`177`	`177`	`const auto end = clock::now();`
`178`	`178`	`std::cout << "Time to render image: " << std::chrono::duration<float, std::milli>(end - start).count() << " milliseconds" << std::endl;`
`179`	`179`