Merge branch 'blue-noise'

Author: Nelarius

.gitignore

@@ -56,3 +56,20 @@ Temporary Items
 ### macOS Patch ###
 # iCloud generated files
 *.icloud
+
+
+### Rust ###
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb

CMakeLists.txt

@@ -91,6 +91,7 @@ add_custom_target(bake-wgsl DEPENDS ${SHADER_SOURCE_HEADER_FILE})
 
 # pt
 set(PT_SOURCE_FILES
+    blue_noise.c
     fly_camera_controller.cpp
     main.cpp
     gpu_bind_group.cpp

README.md

@@ -42,6 +42,8 @@ An interactive experimental pathtracer, implemented using WebGPU via the [Dawn](
 - Depth precision and reverse Z projection
   - [Depth Precision Visualized](https://www.reedbeta.com/blog/depth-precision-visualized/)
   - [Reverse Z (and why it's so awesome)](https://tomhultonharrop.com/mathematics/graphics/2023/08/06/reverse-z.html)
+- [Free blue noise textures](http://momentsingraphics.de/BlueNoise.html)
+- _Using Blue Noise for Ray Traced Soft Shadows_, _Ray Tracing Gems II_
 
 ## Build
 

src/pt/blue_noise.c

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+// Array contains consecutive R, G values. Pixels are indexed from the top-left.
+extern const uint8_t blueNoiseValues[32768];
+
+extern const size_t blueNoiseWidth;
+extern const size_t blueNoiseHeight;
+#ifdef __cplusplus
+}
+#endif

src/pt/blue_noise.h

@@ -1,3 +1,4 @@
+#include "blue_noise.h"
 #include "gpu_context.hpp"
 #include "gpu_limits.hpp"
 #include "deferred_renderer.hpp"
@@ -9,6 +10,7 @@
 
 #include <algorithm>
 #include <array>
+#include <bit>
 #include <numeric>
 
 namespace nlrs
@@ -1230,6 +1232,23 @@ DeferredRenderer::LightingPass::LightingPass(
           std::span<const VertexAttributes>(sceneVertexAttributes)},
       mTextureDescriptorBuffer{},
       mTextureBuffer{},
+      mBlueNoiseBuffer{[&gpuContext]() -> GpuBuffer {
+          std::span<const std::uint8_t> blueNoise(blueNoiseValues, sizeof(blueNoiseValues));
+          std::vector<std::uint32_t>    bufferData;
+          bufferData.reserve(2 + blueNoise.size()); // size + array of values
+          bufferData.push_back(static_cast<std::uint32_t>(blueNoiseWidth));
+          bufferData.push_back(static_cast<std::uint32_t>(blueNoiseHeight));
+          for (const std::uint8_t value : blueNoise)
+          {
+              const float f = static_cast<float>(value) / 255.0f;
+              bufferData.push_back(std::bit_cast<std::uint32_t>(f));
+          }
+          return GpuBuffer{
+              gpuContext.device,
+              "blue noise buffer",
+              {GpuBufferUsage::ReadOnlyStorage, GpuBufferUsage::CopyDst},
+              std::span<const std::uint32_t>(bufferData)};
+      }()},
       mBvhBindGroup{},
       mPipeline(nullptr)
 {
@@ -1323,24 +1342,26 @@ DeferredRenderer::LightingPass::LightingPass(
     const GpuBindGroupLayout bvhBindGroupLayout{
         gpuContext.device,
         "Scene bind group layout",
-        std::array<WGPUBindGroupLayoutEntry, 5>{
+        std::array<WGPUBindGroupLayoutEntry, 6>{
             mBvhNodeBuffer.bindGroupLayoutEntry(0, WGPUShaderStage_Fragment),
             mPositionAttributesBuffer.bindGroupLayoutEntry(1, WGPUShaderStage_Fragment),
             mVertexAttributesBuffer.bindGroupLayoutEntry(2, WGPUShaderStage_Fragment),
             mTextureDescriptorBuffer.bindGroupLayoutEntry(3, WGPUShaderStage_Fragment),
             mTextureBuffer.bindGroupLayoutEntry(4, WGPUShaderStage_Fragment),
+            mBlueNoiseBuffer.bindGroupLayoutEntry(5, WGPUShaderStage_Fragment),
         }};
 
     mBvhBindGroup = GpuBindGroup{
         gpuContext.device,
         "Lighting pass BVH bind group",
         bvhBindGroupLayout.ptr(),
-        std::array<WGPUBindGroupEntry, 5>{
+        std::array<WGPUBindGroupEntry, 6>{
             mBvhNodeBuffer.bindGroupEntry(0),
             mPositionAttributesBuffer.bindGroupEntry(1),
             mVertexAttributesBuffer.bindGroupEntry(2),
             mTextureDescriptorBuffer.bindGroupEntry(3),
             mTextureBuffer.bindGroupEntry(4),
+            mBlueNoiseBuffer.bindGroupEntry(5),
         }};
 
     {
@@ -1492,6 +1513,7 @@ DeferredRenderer::LightingPass::LightingPass(LightingPass&& other) noexcept
         mVertexAttributesBuffer = std::move(other.mVertexAttributesBuffer);
         mTextureDescriptorBuffer = std::move(other.mTextureDescriptorBuffer);
         mTextureBuffer = std::move(other.mTextureBuffer);
+        mBlueNoiseBuffer = std::move(other.mBlueNoiseBuffer);
         mBvhBindGroup = std::move(other.mBvhBindGroup);
         mPipeline = other.mPipeline;
         other.mPipeline = nullptr;
@@ -1515,6 +1537,7 @@ DeferredRenderer::LightingPass& DeferredRenderer::LightingPass::operator=(
         mVertexAttributesBuffer = std::move(other.mVertexAttributesBuffer);
         mTextureDescriptorBuffer = std::move(other.mTextureDescriptorBuffer);
         mTextureBuffer = std::move(other.mTextureBuffer);
+        mBlueNoiseBuffer = std::move(other.mBlueNoiseBuffer);
         mBvhBindGroup = std::move(other.mBvhBindGroup);
         renderPipelineSafeRelease(mPipeline);
         mPipeline = other.mPipeline;

src/pt/deferred_renderer.cpp

@@ -168,6 +168,7 @@ class DeferredRenderer
         GpuBuffer          mVertexAttributesBuffer = GpuBuffer{};
         GpuBuffer          mTextureDescriptorBuffer = GpuBuffer{};
         GpuBuffer          mTextureBuffer = GpuBuffer{};
+        GpuBuffer          mBlueNoiseBuffer = GpuBuffer{};
         GpuBindGroup       mBvhBindGroup = GpuBindGroup{};
         WGPURenderPipeline mPipeline = nullptr;
 

src/pt/deferred_renderer.hpp

@@ -43,6 +43,7 @@ struct Uniforms {
 @group(3) @binding(2) var<storage, read> vertexAttributes: array<VertexAttributes>;
 @group(3) @binding(3) var<storage, read> textureDescriptors: array<TextureDescriptor>;
 @group(3) @binding(4) var<storage, read> textures: array<u32>;
+@group(3) @binding(5) var<storage, read> blueNoise: BlueNoise;
 
 struct Aabb {
     min: vec3f,
@@ -86,6 +87,12 @@ struct Ray {
     direction: vec3f
 }
 
+struct BlueNoise {
+    width: u32,
+    height: u32,
+    data: array<vec2f>,
+}
+
 const CHANNEL_R = 0u;
 const CHANNEL_G = 1u;
 const CHANNEL_B = 2u;
@@ -109,7 +116,6 @@ fn fsMain(in: VertexOutput) -> @location(0) vec4f {
 
     let uv = in.texCoord;
     let textureIdx = vec2u(floor(uv * uniforms.framebufferSize));
-    var rng = initRng(textureIdx, vec2u(uniforms.framebufferSize), uniforms.frameCount);
     let depthSample = textureLoad(gbufferDepth, textureIdx, 0);
     if depthSample == 0.0 {
         let world = worldFromUv(uv, depthSample);
@@ -124,11 +130,12 @@ fn fsMain(in: VertexOutput) -> @location(0) vec4f {
             skyRadiance(theta, gamma, CHANNEL_B)
         );
     } else {
+        let coord = vec2u(uv * uniforms.framebufferSize);
         let position = worldFromUv(uv, depthSample);
         let encodedNormal = textureLoad(gbufferNormal, textureIdx, 0).rgb;
         let decodedNormal = 2f * encodedNormal - vec3(1f);
         let albedo = textureLoad(gbufferAlbedo, textureIdx, 0).rgb;
-        color = surfaceColor(&rng, offsetPosition(position, decodedNormal), decodedNormal, albedo);
+        color = surfaceColor(coord, offsetPosition(position, decodedNormal), decodedNormal, albedo);
     }
 
     return vec4(acesFilmic(uniforms.exposure * color), 1.0);
@@ -145,17 +152,18 @@ fn worldFromUv(uv: vec2f, depthSample: f32) -> vec3f {
 const NUM_BOUNCES = 2;
 
 @must_use
-fn surfaceColor(rng: ptr<function, u32>, primaryPos: vec3f, primaryNormal: vec3f, primaryAlbedo: vec3f) -> vec3f {
+fn surfaceColor(coord: vec2u, primaryPos: vec3f, primaryNormal: vec3f, primaryAlbedo: vec3f) -> vec3f {
     var position = primaryPos;
     var normal = primaryNormal;
     var albedo = primaryAlbedo;
     var radiance = vec3(0f);
     var throughput = vec3(1f);
+    let blueNoise = animatedBlueNoise(coord, uniforms.frameCount, 512u);
 
-    radiance += throughput * lightSample(rng, position, normal, albedo);
+    radiance += throughput * lightSample(blueNoise, position, normal, albedo);
 
     for (var bounce = 1; bounce < NUM_BOUNCES; bounce += 1) {
-        let wi = evalImplicitLambertian(normal, rng);
+        let wi = evalImplicitLambertian(blueNoise, normal);
         let ray = Ray(position, wi);
         throughput *= albedo;
 
@@ -183,15 +191,15 @@ fn surfaceColor(rng: ptr<function, u32>, primaryPos: vec3f, primaryNormal: vec3f
             break;
         }
 
-        radiance += throughput * lightSample(rng, position, normal, albedo);
+        radiance += throughput * lightSample(blueNoise, position, normal, albedo);
     }
 
     return radiance;
 }
 
 @must_use
-fn lightSample(rng: ptr<function, u32>, position: vec3f, normal: vec3f, albedo: vec3f) -> vec3f {
-    let lightDirection = sampleSolarDiskDirection(SOLAR_COS_THETA_MAX, skyState.sunDirection, rng);
+fn lightSample(u: vec2f, position: vec3f, normal: vec3f, albedo: vec3f) -> vec3f {
+    let lightDirection = sampleSolarDiskDirection(u, SOLAR_COS_THETA_MAX, skyState.sunDirection);
     let lightIntensity = vec3(
         skyState.solarRadiances[CHANNEL_R],
         skyState.solarRadiances[CHANNEL_G],
@@ -250,15 +258,15 @@ fn acesFilmic(x: vec3f) -> vec3f {
 }
 
 @must_use
-fn sampleSolarDiskDirection(cosThetaMax: f32, direction: vec3f, state: ptr<function, u32>) -> vec3f {
-    let v = rngNextInCone(state, cosThetaMax);
+fn sampleSolarDiskDirection(u: vec2f, cosThetaMax: f32, direction: vec3f) -> vec3f {
+    let v = directionInCone(u, cosThetaMax);
     let onb = pixarOnb(direction);
     return onb * v;
 }
 
 @must_use
-fn evalImplicitLambertian(n: vec3f, rngState: ptr<function, u32>) -> vec3f {
-    let v = rngNextInCosineWeightedHemisphere(rngState);
+fn evalImplicitLambertian(u: vec2f, n: vec3f) -> vec3f {
+    let v = directionInCosineWeightedHemisphere(u);
     let onb = pixarOnb(n);
     return onb * v;
 }
@@ -534,14 +542,12 @@ fn offsetPosition(p: vec3f, n: vec3f) -> vec3f {
     );
 }
 
+// `u` is a random number in [0, 1].
 @must_use
-fn rngNextInCone(state: ptr<function, u32>, cosThetaMax: f32) -> vec3f {
-    let u1 = rngNextFloat(state);
-    let u2 = rngNextFloat(state);
-
-    let cosTheta = 1f - u1 * (1f - cosThetaMax);
+fn directionInCone(u: vec2f, cosThetaMax: f32) -> vec3f {
+    let cosTheta = 1f - u.x * (1f - cosThetaMax);
     let sinTheta = sqrt(1f - cosTheta * cosTheta);
-    let phi = 2f * PI * u2;
+    let phi = 2f * PI * u.y;
 
     let x = cos(phi) * sinTheta;
     let y = sin(phi) * sinTheta;
@@ -550,49 +556,31 @@ fn rngNextInCone(state: ptr<function, u32>, cosThetaMax: f32) -> vec3f {
     return vec3(x, y, z);
 }
 
+// `u` is a random number in [0, 1].
 @must_use
-fn rngNextInCosineWeightedHemisphere(state: ptr<function, u32>) -> vec3f {
-    let u1 = rngNextFloat(state);
-    let u2 = rngNextFloat(state);
-
-    let phi = 2f * PI * u2;
-    let sinTheta = sqrt(1f - u1);
+fn directionInCosineWeightedHemisphere(u: vec2f) -> vec3f {
+    let phi = 2f * PI * u.y;
+    let sinTheta = sqrt(1f - u.x);
 
     let x = cos(phi) * sinTheta;
     let y = sin(phi) * sinTheta;
-    let z = sqrt(u1);
+    let z = sqrt(u.x);
 
     return vec3(x, y, z);
 }
 
 @must_use
-fn initRng(pixel: vec2u, resolution: vec2u, frame: u32) -> u32 {
-    // Adapted from https://github.com/boksajak/referencePT
-    let seed = dot(pixel, vec2u(1u, resolution.x)) ^ jenkinsHash(frame);
-    return jenkinsHash(seed);
-}
-
-@must_use
-fn jenkinsHash(input: u32) -> u32 {
-    var x = input;
-    x += x << 10u;
-    x ^= x >> 6u;
-    x += x << 3u;
-    x ^= x >> 11u;
-    x += x << 15u;
-    return x;
-}
-
-fn rngNextFloat(state: ptr<function, u32>) -> f32 {
-    rngNextInt(state);
-    return f32(*state) / f32(0xffffffffu);
-}
-
-fn rngNextInt(state: ptr<function, u32>) {
-    // PCG random number generator
-    // Based on https://www.shadertoy.com/view/XlGcRh
-
-    let oldState = *state + 747796405u + 2891336453u;
-    let word = ((oldState >> ((oldState >> 28u) + 4u)) ^ oldState) * 277803737u;
-    *state = (word >> 22u) ^ word;
+fn animatedBlueNoise(coord: vec2u, frameIdx: u32, totalSampleCount: u32) -> vec2f {
+    let idx = (coord.y % blueNoise.height) * blueNoise.width + (coord.x % blueNoise.width);
+    let blueNoise = blueNoise.data[idx];
+    // 2-dimensional golden ratio additive recurrence sequence
+    // https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
+    let n = frameIdx % totalSampleCount;
+    let a1 = 0.7548776662466927f;
+    let a2 = 0.5698402909980532f;
+    let r2Seq = fract(vec2(
+        a1 * f32(n),
+        a2 * f32(n)
+    ));
+    return fract(blueNoise + r2Seq);
 }

src/pt/deferred_renderer_lighting_pass.wgsl

@@ -51,7 +51,7 @@ struct UiState
     int   rendererType = RendererType_Deferred;
     float vfovDegrees = 70.0f;
     // sampling
-    int numSamplesPerPixel = 128;
+    int numSamplesPerPixel = 64;
     int numBounces = 2;
     // sky
     float                sunZenithDegrees = 30.0f;
@@ -376,11 +376,11 @@ try
 
             ImGui::Text("num samples:");
             ImGui::SameLine();
-            ImGui::RadioButton("64", &appState.ui.numSamplesPerPixel, 64);
+            ImGui::RadioButton("8", &appState.ui.numSamplesPerPixel, 8);
             ImGui::SameLine();
-            ImGui::RadioButton("128", &appState.ui.numSamplesPerPixel, 128);
+            ImGui::RadioButton("64", &appState.ui.numSamplesPerPixel, 64);
             ImGui::SameLine();
-            ImGui::RadioButton("256", &appState.ui.numSamplesPerPixel, 256);
+            ImGui::RadioButton("512", &appState.ui.numSamplesPerPixel, 512);
 
             ImGui::Text("num bounces:");
             ImGui::SameLine();