Simple temporal accumulation with moving average

Author: Nelarius

CMakeLists.txt

@@ -128,6 +128,7 @@ set(TESTS_SOURCE_FILES
     bvh.cpp
     gltf.cpp
     intersection.cpp
+    math.cpp
     pt_format.cpp
     stream.cpp
     vector_set.cpp)

src/common/math.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cmath>
+
+namespace nlrs
+{
+inline float fract(const float x)
+{
+    if (x >= 0.0f)
+    {
+        return x - std::floor(x);
+    }
+    else
+    {
+        return x - std::ceil(x);
+    }
+}
+} // namespace nlrs

src/common/r_sequence.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "math.hpp"
+
+#include <glm/glm.hpp>
+
+#include <cmath>
+
+namespace nlrs
+{
+inline glm::vec2 r2Sequence(const std::uint32_t n, const std::uint32_t sequenceLength)
+{
+    // https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
+    constexpr float G = 1.32471795f;
+    constexpr float A1 = 1.0f / G;
+    constexpr float A2 = 1.0f / (G * G);
+
+    const float i = static_cast<float>(n % sequenceLength);
+    const float x = fract(0.5f + A1 * i);
+    const float y = fract(0.5f + A2 * i);
+    return glm::vec2(x, y);
+}
+} // namespace nlrs

src/pt/deferred_renderer.cpp

@@ -8,6 +8,7 @@
 #include "window.hpp"
 
 #include <common/assert.hpp>
+#include <common/r_sequence.hpp>
 
 #include <algorithm>
 #include <array>
@@ -107,7 +108,8 @@ DeferredRenderer::DeferredRenderer(
       mLightingPass(),
       mResolvePass(),
       mGbufferPassDurationsNs(),
-      mLightingPassDurationsNs()
+      mLightingPassDurationsNs(),
+      mFrameCount(0)
 {
     {
         const std::array<WGPUTextureFormat, 1> depthFormats{
@@ -240,6 +242,7 @@ DeferredRenderer::DeferredRenderer(DeferredRenderer&& other)
         mResolvePass = std::move(other.mResolvePass);
         mGbufferPassDurationsNs = std::move(other.mGbufferPassDurationsNs);
         mLightingPassDurationsNs = std::move(other.mLightingPassDurationsNs);
+        mFrameCount = other.mFrameCount;
     }
 }
 
@@ -270,6 +273,7 @@ DeferredRenderer& DeferredRenderer::operator=(DeferredRenderer&& other)
         mResolvePass = std::move(other.mResolvePass);
         mGbufferPassDurationsNs = std::move(other.mGbufferPassDurationsNs);
         mLightingPassDurationsNs = std::move(other.mLightingPassDurationsNs);
+        mFrameCount = other.mFrameCount;
     }
     return *this;
 }
@@ -293,13 +297,25 @@ void DeferredRenderer::render(
         return wgpuDeviceCreateCommandEncoder(gpuContext.device, &cmdEncoderDesc);
     }();
 
+    const Extent2f      framebufferSize = Extent2f(renderDesc.framebufferSize);
+    const std::uint32_t frameCount = mFrameCount++;
+    const glm::mat4     jitterMat = [framebufferSize, frameCount]() -> glm::mat4 {
+        glm::mat4       jitterMat = glm::mat4(1.0f);
+        const glm::vec2 j = r2Sequence(frameCount, 1 << 20);
+        jitterMat[3][0] = (j.x - 0.5f) / framebufferSize.x;
+        jitterMat[3][1] = (j.y - 0.5f) / framebufferSize.y;
+        return jitterMat;
+    }();
+
+    // GBuffer pass
+
     wgpuCommandEncoderWriteTimestamp(
         encoder,
         mQuerySet,
         offsetof(TimestampsLayout, gbufferPassStart) / TimestampsLayout::MEMBER_SIZE);
     mGbufferPass.render(
         gpuContext,
-        renderDesc.viewReverseZProjectionMatrix,
+        jitterMat * renderDesc.viewReverseZProjectionMatrix,
         encoder,
         mDepthTextureView,
         mAlbedoTextureView,
@@ -309,27 +325,31 @@ void DeferredRenderer::render(
         mQuerySet,
         offsetof(TimestampsLayout, gbufferPassEnd) / TimestampsLayout::MEMBER_SIZE);
 
+    // Lighting pass
+
     wgpuCommandEncoderWriteTimestamp(
         encoder,
         mQuerySet,
         offsetof(TimestampsLayout, lightingPassStart) / TimestampsLayout::MEMBER_SIZE);
-    const Extent2f framebufferSize = Extent2f(renderDesc.framebufferSize);
     {
         const glm::mat4 inverseViewProjectionMat =
-            glm::inverse(renderDesc.viewReverseZProjectionMatrix);
+            glm::inverse(jitterMat * renderDesc.viewReverseZProjectionMatrix);
         mLightingPass.render(
             gpuContext,
             encoder,
             inverseViewProjectionMat,
             renderDesc.cameraPosition,
             framebufferSize,
-            renderDesc.sky);
+            renderDesc.sky,
+            frameCount);
     }
     wgpuCommandEncoderWriteTimestamp(
         encoder,
         mQuerySet,
         offsetof(TimestampsLayout, lightingPassEnd) / TimestampsLayout::MEMBER_SIZE);
 
+    // Resolve pass
+
     wgpuCommandEncoderWriteTimestamp(
         encoder,
         mQuerySet,
@@ -341,13 +361,16 @@ void DeferredRenderer::render(
             renderDesc.targetTextureView,
             framebufferSize,
             renderDesc.exposure,
+            frameCount,
             gui);
     }
     wgpuCommandEncoderWriteTimestamp(
         encoder,
         mQuerySet,
         offsetof(TimestampsLayout, resolvePassEnd) / TimestampsLayout::MEMBER_SIZE);
 
+    // Resolve timestamp queries
+
     wgpuCommandEncoderResolveQuerySet(
         encoder, mQuerySet, 0, TimestampsLayout::QUERY_COUNT, mQueryBuffer.ptr(), 0);
     wgpuCommandEncoderCopyBufferToBuffer(
@@ -676,15 +699,15 @@ DeferredRenderer::GbufferPass::GbufferPass(
           gpuContext.device,
           "Uniform buffer",
           {GpuBufferUsage::Uniform, GpuBufferUsage::CopyDst},
-          sizeof(glm::mat4)),
+          sizeof(Uniforms)),
       mUniformBindGroup(),
       mSamplerBindGroup(),
       mPipeline(nullptr)
 {
     const GpuBindGroupLayout uniformBindGroupLayout{
         gpuContext.device,
         "Uniform bind group layout",
-        mUniformBuffer.bindGroupLayoutEntry(0, WGPUShaderStage_Vertex, sizeof(glm::mat4))};
+        mUniformBuffer.bindGroupLayoutEntry(0, WGPUShaderStage_Vertex, sizeof(Uniforms))};
 
     mUniformBindGroup = GpuBindGroup{
         gpuContext.device,
@@ -990,12 +1013,8 @@ void DeferredRenderer::GbufferPass::render(
     const WGPUTextureView    albedoTextureView,
     const WGPUTextureView    normalTextureView)
 {
-    wgpuQueueWriteBuffer(
-        gpuContext.queue,
-        mUniformBuffer.ptr(),
-        0,
-        &viewReverseZProjectionMatrix[0][0],
-        sizeof(glm::mat4));
+    const Uniforms uniforms{viewReverseZProjectionMatrix};
+    wgpuQueueWriteBuffer(gpuContext.queue, mUniformBuffer.ptr(), 0, &uniforms, sizeof(Uniforms));
 
     const WGPURenderPassEncoder renderPassEncoder = [cmdEncoder,
                                                      depthTextureView,
@@ -1644,7 +1663,6 @@ DeferredRenderer::LightingPass::LightingPass(LightingPass&& other) noexcept
         mSampleBindGroup = std::move(other.mSampleBindGroup);
         mPipeline = other.mPipeline;
         other.mPipeline = nullptr;
-        mFrameCount = other.mFrameCount;
     }
 }
 
@@ -1670,7 +1688,6 @@ DeferredRenderer::LightingPass& DeferredRenderer::LightingPass::operator=(
         computePipelineSafeRelease(mPipeline);
         mPipeline = other.mPipeline;
         other.mPipeline = nullptr;
-        mFrameCount = other.mFrameCount;
     }
     return *this;
 }
@@ -1681,7 +1698,8 @@ void DeferredRenderer::LightingPass::render(
     const glm::mat4&         inverseViewReverseZProjectionMatrix,
     const glm::vec3&         cameraPosition,
     const Extent2f&          fbsize,
-    const Sky&               sky)
+    const Sky&               sky,
+    const std::uint32_t      frameCount)
 {
     if (mCurrentSky != sky)
     {
@@ -1696,7 +1714,7 @@ void DeferredRenderer::LightingPass::render(
             inverseViewReverseZProjectionMatrix,
             glm::vec4(cameraPosition, 1.f),
             glm::vec2(fbsize.x, fbsize.y),
-            mFrameCount++,
+            frameCount,
             0};
         wgpuQueueWriteBuffer(
             gpuContext.queue, mUniformBuffer.ptr(), 0, &uniforms, sizeof(Uniforms));
@@ -1953,10 +1971,11 @@ void DeferredRenderer::ResolvePass::render(
     WGPUTextureView          targetTextureView,
     const Extent2f&          fbsize,
     const float              exposure,
+    const std::uint32_t      frameCount,
     Gui&                     gui)
 {
     {
-        const Uniforms uniforms{glm::vec2(fbsize.x, fbsize.y), exposure, 0.f};
+        const Uniforms uniforms{glm::vec2(fbsize.x, fbsize.y), exposure, frameCount};
         wgpuQueueWriteBuffer(
             gpuContext.queue, mUniformBuffer.ptr(), 0, &uniforms, sizeof(Uniforms));
     }

src/pt/deferred_renderer.hpp

@@ -106,6 +106,11 @@ class DeferredRenderer
         GpuBindGroup              mSamplerBindGroup{};
         WGPURenderPipeline        mPipeline = nullptr;
 
+        struct Uniforms
+        {
+            glm::mat4 viewProjectionMat;
+        };
+
     public:
         GbufferPass() = default;
         GbufferPass(const GpuContext&, const DeferredRendererDescriptor&);
@@ -184,8 +189,6 @@ class DeferredRenderer
         GpuBindGroup        mSampleBindGroup = GpuBindGroup{};
         WGPUComputePipeline mPipeline = nullptr;
 
-        std::uint32_t mFrameCount = 0;
-
         struct Uniforms
         {
             glm::mat4     inverseViewReverseZProjectionMat;
@@ -221,7 +224,8 @@ class DeferredRenderer
             const glm::mat4&   inverseViewProjection,
             const glm::vec3&   cameraPosition,
             const Extent2f&    framebufferSize,
-            const Sky&         sky);
+            const Sky&         sky,
+            std::uint32_t      frameCount);
         void resize(
             const GpuContext&,
             WGPUTextureView albedoTextureView,
@@ -241,9 +245,9 @@ class DeferredRenderer
 
         struct Uniforms
         {
-            glm::vec2 framebufferSize;
-            float     exposure;
-            float     _padding;
+            glm::vec2     framebufferSize;
+            float         exposure;
+            std::uint32_t frameCount;
         };
 
     public:
@@ -266,6 +270,7 @@ class DeferredRenderer
             WGPUTextureView    targetTextureView,
             const Extent2f&    framebufferSize,
             float              exposure,
+            std::uint32_t      frameCount,
             Gui&               gui);
     };
 
@@ -286,5 +291,6 @@ class DeferredRenderer
     std::deque<std::uint64_t> mGbufferPassDurationsNs;
     std::deque<std::uint64_t> mLightingPassDurationsNs;
     std::deque<std::uint64_t> mResolvePassDurationsNs;
+    std::uint32_t             mFrameCount;
 };
 } // namespace nlrs

src/pt/deferred_renderer_gbuffer_pass.wgsl

@@ -1,4 +1,8 @@
-@group(0) @binding(0) var<uniform> viewProjectionMat: mat4x4f;
+struct Uniforms {
+    viewReverseZProjectionMat: mat4x4f
+}
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
 
 struct VertexInput {
     @location(0) position: vec4f,
@@ -15,7 +19,7 @@ struct VertexOutput {
 @vertex
 fn vsMain(in: VertexInput) -> VertexOutput {
     var out: VertexOutput;
-    out.position = viewProjectionMat * in.position;
+    out.position = uniforms.viewReverseZProjectionMat * in.position;
     out.normal = in.normal;
     out.texCoord = in.texCoord;
     return out;

src/pt/deferred_renderer_resolve_pass.wgsl

@@ -20,6 +20,7 @@ fn vsMain(in: VertexInput) -> VertexOutput {
 struct Uniforms {
     framebufferSize: vec2f,
     exposure: f32,
+    frameCount: u32,
 }
 
 // TODO: consider merging these into one bind group
@@ -35,7 +36,17 @@ fn fsMain(in: VertexOutput) -> @location(0) vec4f {
     let textureIdx = vec2u(floor(uv * uniforms.framebufferSize));
     let sampleBufferIdx = textureIdx.y * u32(uniforms.framebufferSize.x) + textureIdx.x;
     let sample: array<f32, 3> = sampleBuffer[sampleBufferIdx];
-    let color = vec3f(sample[0], sample[1], sample[2]);
+    let currentColor = vec3f(sample[0], sample[1], sample[2]);
+    var color = vec3f(0f);
+    if uniforms.frameCount == 0u {
+        accumulationBuffer[sampleBufferIdx] = sample;
+        color = currentColor;
+    } else {
+        let previousSample: array<f32, 3> = accumulationBuffer[sampleBufferIdx];
+        let previousColor = vec3f(previousSample[0], previousSample[1], previousSample[2]);
+        color = 0.1 * currentColor + 0.9 * previousColor;
+        accumulationBuffer[sampleBufferIdx] = array<f32, 3>(color.r, color.g, color.b);
+    }
 
     let rgb = acesFilmic(uniforms.exposure * color);
     let srgb = pow(rgb, vec3(1f / 2.2f));

src/pt/shader_source.hpp

@@ -623,7 +623,11 @@ fn animatedBlueNoise(coord: vec2u, frameIdx: u32, totalSampleCount: u32) -> vec2
 }
 )";
 
-const char* const DEFERRED_RENDERER_GBUFFER_PASS_SOURCE = R"(@group(0) @binding(0) var<uniform> viewProjectionMat: mat4x4f;
+const char* const DEFERRED_RENDERER_GBUFFER_PASS_SOURCE = R"(struct Uniforms {
+    viewReverseZProjectionMat: mat4x4f
+}
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
 
 struct VertexInput {
     @location(0) position: vec4f,
@@ -640,7 +644,7 @@ struct VertexOutput {
 @vertex
 fn vsMain(in: VertexInput) -> VertexOutput {
     var out: VertexOutput;
-    out.position = viewProjectionMat * in.position;
+    out.position = uniforms.viewReverseZProjectionMat * in.position;
     out.normal = in.normal;
     out.texCoord = in.texCoord;
     return out;
@@ -1291,6 +1295,7 @@ fn vsMain(in: VertexInput) -> VertexOutput {
 struct Uniforms {
     framebufferSize: vec2f,
     exposure: f32,
+    frameCount: u32,
 }
 
 // TODO: consider merging these into one bind group
@@ -1306,7 +1311,17 @@ fn fsMain(in: VertexOutput) -> @location(0) vec4f {
     let textureIdx = vec2u(floor(uv * uniforms.framebufferSize));
     let sampleBufferIdx = textureIdx.y * u32(uniforms.framebufferSize.x) + textureIdx.x;
     let sample: array<f32, 3> = sampleBuffer[sampleBufferIdx];
-    let color = vec3f(sample[0], sample[1], sample[2]);
+    let currentColor = vec3f(sample[0], sample[1], sample[2]);
+    var color = vec3f(0f);
+    if uniforms.frameCount == 0u {
+        accumulationBuffer[sampleBufferIdx] = sample;
+        color = currentColor;
+    } else {
+        let previousSample: array<f32, 3> = accumulationBuffer[sampleBufferIdx];
+        let previousColor = vec3f(previousSample[0], previousSample[1], previousSample[2]);
+        color = 0.1 * currentColor + 0.9 * previousColor;
+        accumulationBuffer[sampleBufferIdx] = array<f32, 3>(color.r, color.g, color.b);
+    }
 
     let rgb = acesFilmic(uniforms.exposure * color);
     let srgb = pow(rgb, vec3(1f / 2.2f));