ernie-renderer 0.2.0.dev168__tar.gz → 0.2.0.dev170__tar.gz

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev168" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev170" CACHE STRING "Pre-release suffix of Ernie's version")
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
 option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev168
+Version: 0.2.0.dev170
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/products.cpp

@@ -6,6 +6,7 @@
 #include "ernie/scene/schema/camera.h"
 #include "ernie/scene/schema/geom.h"
 #include "ernie/scene/schema/render.h"
+#include "ernie/util/random.h"
 
 #include <algorithm>
 #include <array>
@@ -81,7 +82,10 @@ ProductSpec ReadProduct(const Scene& scene, const RenderSettingsBase& settings,
                 ReadLens(scene, *prim, size, pick(own.HasPixelAspectRatio()).GetPixelAspectRatio(),
                          pick(own.HasAspectRatioConformPolicy()).GetAspectRatioConformPolicy()),
             .clipping = glm::vec2(Camera(scene, camera).GetClippingRange()),
-            .vars = ReadVars(scene, vars)};
+            .vars = ReadVars(scene, vars),
+            .samples = static_cast<std::uint32_t>(std::max(1, pick(own.HasSamples()).GetSamples())),
+            .seed = static_cast<std::uint32_t>(pick(own.HasSeed()).GetSeed()),
+            .stream = HashStream(path.String())};
 }
 
 }  // namespace

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/products.h

@@ -27,6 +27,11 @@ struct ProductSpec {
     glm::vec2 clipping{0.0f, 1e30f};
     /// Its vars' source names, in order.
     std::vector<std::string> vars;
+    /// Samples a pixel per frame: `ernie:samples`, or the Minimal tier's one for 0.
+    std::uint32_t samples = 1;
+    /// `ernie:seed`, and its path hashed, which its random numbers are keyed by.
+    std::uint32_t seed = 0;
+    std::uint32_t stream = 0;
 };
 
 /// @return The products of the scene's first RenderSettings: its `products`, or one default

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/renderer.cpp

@@ -126,7 +126,10 @@ void Renderer::Device::Plan(const Scene& scene, const std::vector<ProductSpec>&
                                    .lens = spec->lens,
                                    .node = spec->camera.slot,
                                    .world = spec->world,
-                                   .clipping = spec->clipping});
+                                   .clipping = spec->clipping,
+                                   .samples = spec->samples,
+                                   .seed = spec->seed,
+                                   .stream = spec->stream});
         }
         if (i < batches.size()) {
             batch.columns = std::move(batches[i].columns);

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/rt/camera_pass.cpp

@@ -6,6 +6,7 @@
 #include "ernie/render/rt/ray_tracer.h"
 #include "ernie/render/transform_graph.h"
 #include "ernie/shaders/device/bindless.h"
+#include "ernie/shaders/sampling/random.h"
 #include "ernie/shaders/sensors/camera.h"
 #include "ernie/shaders/sensors/lens.h"
 #include "ernie/shaders/spectral/spectrum.h"
@@ -45,7 +46,10 @@ View ToView(const CameraView& view, const glm::dvec3& origin, std::uint32_t firs
             .first = first,
             .world = view.world,
             .near = view.clipping.x,
-            .far = view.clipping.y};
+            .far = view.clipping.y,
+            .samples = std::max(view.samples, 1u),
+            .seed = view.seed,
+            .stream = view.stream};
 }
 
 }  // namespace
@@ -68,8 +72,8 @@ std::span<const ShaderModule> CameraPass::Modules() {
         for (const ShaderModule& module : TransformGraph::WorldModules().subspan(1)) {
             list.push_back(module);
         }
-        list.insert(list.end(),
-                    {shaders::kBindless, shaders::kSpectrum, shaders::kLens, shaders::kCamera});
+        list.insert(list.end(), {shaders::kBindless, shaders::kSpectrum, shaders::kLens,
+                                 shaders::kRandom, shaders::kCamera});
         return list;
     }();
     return modules;
@@ -158,6 +162,7 @@ void CameraPass::Add(graph::Graph& graph, std::span<const CameraView> views,
                 .worlds = pass.Get(scene.transforms).BufferRef<glm::vec4>(),
                 .colours = pass.Get(scene.colours).BufferRef<float>(),
                 .instancePrims = pass.Get(scene.prims).BufferRef<shaders::uint>(),
+                .frame = pass.Get(scene.frame).BufferRef<shaders::uint>(),
                 .count = static_cast<std::uint32_t>(records.size())};
             kernel_.Dispatch(
                 pass.commands,

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/rt/camera_pass.h

@@ -49,6 +49,12 @@ struct CameraView {
     std::uint32_t world = 0;
     /// Metres along the view axis to the near and far clipping planes.
     glm::vec2 clipping{0.0f, 1e30f};
+    /// Jittered rays a pixel's colour and albedo average; 1 for one through its middle.
+    std::uint32_t samples = 1;
+    /// What its random numbers are keyed by, with the device's frame number: the settings'
+    /// seed and its render product's path, hashed (`HashStream`).
+    std::uint32_t seed = 0;
+    std::uint32_t stream = 0;
     /// Three rows of four floats, camera to world relative to the render origin, which the pass
     /// reads on the device in place of `cameraToWorld` when there is no node: a pose uploaded
     /// each frame, so recorded commands replay as it moves.

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/rt/ray_tracer.cpp

@@ -4,6 +4,7 @@
 #include "ernie/render/rt/ray_tracer.h"
 
 #include "ernie/shaders/device/buffer_ref.h"
+#include "ernie/shaders/rt/frame_count.h"
 #include "ernie/shaders/rt/ray_tracer.h"
 #include "ernie/shaders/scene/geometry.h"
 #include "ernie/shaders/scene/shapes.h"
@@ -13,9 +14,22 @@
 
 namespace ernie {
 
+namespace {
+
+std::vector<std::uint32_t> CompileCounter(const ShaderCompiler& compiler) {
+    const std::array modules{shaders::kBufferRef, shaders::kFrameCount};
+    return compiler.Spirv(modules, "main");
+}
+
+}  // namespace
+
 RayTracer::RayTracer(DeviceContext& context, Arenas& arenas, const ShaderCompiler& compiler,
                      const GeometryPool& geometry)
-    : geometry_(geometry), bottoms_(context, arenas, geometry), tops_(context, arenas, compiler) {}
+    : geometry_(geometry), bottoms_(context, arenas, geometry), tops_(context, arenas, compiler),
+      counter_(context, CompileCounter(compiler), "count the frame",
+               std::uint32_t{sizeof(shaders::BufferRef<std::uint32_t>)}),
+      frame_(std::make_unique<DeviceColumn>(arenas, "frame number", DType::UInt32,
+                                            std::vector<std::int64_t>{}, 1)) {}
 
 std::span<const ShaderModule> RayTracer::Modules() {
     static const std::array modules{shaders::kBufferRef, shaders::kGeometry, shaders::kShapes,
@@ -28,6 +42,30 @@ void RayTracer::AddBuild(graph::Graph& graph, const GeometryPool::Changes& chang
                          bool rebuildTops) {
     ERNIE_ZONE("Update the ray tracer");
     const graph::Graph::ScopeGuard scope = graph.Scope("Ray tracer");
+    graph::Buffer frame = graph.Import(*frame_);
+    if (!counting_) {
+        // From zero, so the same steps key the same random numbers.
+        graph.Add(
+            "Start counting frames", graph::Kind::Copy,
+            [&](graph::PassBuilder& pass) {
+                pass.OneShot();
+                frame = pass.Write(frame, graph::Use::CopyDst);
+            },
+            [frame](graph::PassContext& pass) {
+                const graph::BufferSlice slice = pass.Get(frame);
+                const std::uint32_t zero = 0;
+                pass.commands.Update(*slice.buffer, slice.offset,
+                                     std::as_bytes(std::span(&zero, 1)));
+            });
+        counting_ = true;
+    }
+    // Recorded once and run every frame, replays too.
+    graph.Add(
+        "Count the frame", graph::Kind::Compute,
+        [&](graph::PassBuilder& pass) { frame = pass.WriteAddress(frame); },
+        [this, frame](graph::PassContext& pass) {
+            counter_.Dispatch(pass.commands, {1, 1, 1}, pass.Get(frame).BufferRef<std::uint32_t>());
+        });
     bottoms_.Apply(changes);
     bottoms_.AddBuilds(graph);
     const graph::Acceleration top =
@@ -47,6 +85,7 @@ void RayTracer::AddBuild(graph::Graph& graph, const GeometryPool::Changes& chang
                    .colours = graph.Import(instances.Colours()),
                    .prims = graph.Import(instances.Nodes()),
                    .transforms = graph.Import(transforms.Worlds()),
+                   .frame = frame,
                    .origin = transforms.Origin()});
 }
 

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/render/rt/ray_tracer.h

@@ -44,6 +44,8 @@ struct TraceScene {
     graph::Buffer prims;
     /// The transform graph's worlds, for poses read on the device.
     graph::Buffer transforms;
+    /// The frame's number, a uint counted on the device, which random numbers are keyed by.
+    graph::Buffer frame;
     /// The render origin the structures are relative to: rays start from points less it.
     glm::dvec3 origin{0.0};
 
@@ -53,7 +55,7 @@ struct TraceScene {
         for (const graph::Buffer& buffer : tables) {
             pass.ReadAddress(buffer);
         }
-        for (const graph::Buffer& buffer : {colours, prims, transforms}) {
+        for (const graph::Buffer& buffer : {colours, prims, transforms, frame}) {
             pass.ReadAddress(buffer);
         }
     }
@@ -75,7 +77,7 @@ class RayTracer {
 
     /// @brief Adds the passes that bring the structures up to date with the frame's geometry
     /// changes, after the transforms and the geometry's and instances' uploads, and puts a
-    /// `TraceScene` on the graph's blackboard.
+    /// `TraceScene` on the graph's blackboard, after a pass counting the frame on the device.
     /// @param rebuildTops Whether to build the top levels, as `TopLevels::AddBuild` takes it.
     void AddBuild(graph::Graph& graph, const GeometryPool::Changes& changes,
                   const TransformGraph& transforms, const InstanceTable& instances,
@@ -92,6 +94,10 @@ class RayTracer {
     const GeometryPool& geometry_;
     BottomLevels bottoms_;
     TopLevels tops_;
+    ComputeKernel counter_;
+    /// The frame's number, counted on the device from zero once started.
+    std::unique_ptr<DeviceColumn> frame_;
+    bool counting_ = false;
 };
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/shaders/CMakeLists.txt

@@ -5,8 +5,10 @@ ernie_add_shaders(
     device/buffer_ref.slang
     math/affine.slang
     math/double_float.slang
+    rt/frame_count.slang
     rt/ray_tracer.slang
     rt/write_instances.slang
+    sampling/random.slang
     scene/geometry.slang
     scene/instance_colours.slang
     scene/shapes.slang

ernie_renderer-0.2.0.dev170/ernie/shaders/rt/frame_count.slang

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file frame_count.slang
+/// @brief The device scene's frame number, counted on the device: one thread adds one each
+/// frame, so frames replayed from recorded commands count too, and the random numbers keyed by
+/// frame differ from one to the next.
+import buffer_ref;
+
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void main(uniform BufferRef<uint> frame) {
+    frame[0] = frame[0] + 1;
+}

ernie_renderer-0.2.0.dev170/ernie/shaders/sampling/random.slang

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file random.slang
+/// @brief Deterministic random numbers keyed by sample identity, as util/random.h computes them on
+/// the host, bit for bit: hashed uniform numbers, and an Owen-scrambled Sobol sequence over a
+/// pixel's samples. Any sample's numbers are regenerated without the ones before it, in any
+/// order, as a backward pass replays a path.
+///
+///     import random;
+///     SampleKey key = { frameSeed, view, pixel, sample };
+///     float2 jitter = float2(SampleSobol(key, kPixelDimension),
+///                            SampleSobol(key, kPixelDimension + 1));
+///
+/// References:
+/// - M. Jarzynski and M. Olano, "Hash Functions for GPU Rendering", JCGT 9(3), 2020.
+/// - B. Burley, "Practical Hash-based Owen Scrambling", JCGT 9(4), 2020.
+/// - M. Pharr, W. Jakob and G. Humphreys, "Physically Based Rendering", 4th edition, 2023
+///   (`PaddedSobolSampler`).
+
+/// Each feature's dimensions, fixed so adding one reshuffles none of the others. Each pair is
+/// stratified on its own: the pixel's position, the lens's, then time with the band.
+static const uint kPixelDimension = 0;
+static const uint kLensDimension = 2;
+static const uint kTimeDimension = 4;
+static const uint kBandDimension = 5;
+
+/// Identifies one sample: which frame (`FrameSeed` on the host), view, pixel and sample it is.
+struct SampleKey {
+    uint frameSeed;
+    uint view;
+    uint pixel;
+    uint sample;
+};
+
+/// @return The pcg3d hash of `v`.
+uint3 Pcg3d(uint3 v) {
+    v = v * 1664525u + 1013904223u;
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    v = v ^ (v >> 16u);
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    return v;
+}
+
+/// @return The pcg4d hash of `v`.
+uint4 Pcg4d(uint4 v) {
+    v = v * 1664525u + 1013904223u;
+    v.x += v.y * v.w;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    v.w += v.y * v.z;
+    v = v ^ (v >> 16u);
+    v.x += v.y * v.w;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    v.w += v.y * v.z;
+    return v;
+}
+
+/// @return The seed of frame `frame` of stream `stream` (a render product's path hashed) under
+/// the authored `seed`, as the host's `FrameSeed` gives it for frames below 2^32.
+uint FrameSeed(uint seed, uint stream, uint frame) {
+    uint3 h = Pcg3d(uint3(seed, stream, frame));
+    return h.x ^ h.y ^ h.z;
+}
+
+/// @return 32 random bits for dimension `dimension` of a sample.
+uint SampleBits(SampleKey key, uint dimension) {
+    uint4 h = Pcg4d(uint4(key.pixel, key.sample, dimension, key.view ^ key.frameSeed));
+    return h.x ^ Pcg3d(uint3(h.y, h.z, key.frameSeed)).x;
+}
+
+/// @return A uniform number in [0, 1) for dimension `dimension` of a sample, with 24 random bits.
+float SampleUniform(SampleKey key, uint dimension) {
+    return float(SampleBits(key, dimension) >> 8u) * (1.0 / 16777216.0);
+}
+
+/// @return `x` permuted as an Owen scramble does, keyed by `seed`, in reversed bit order.
+uint LaineKarrasPermutation(uint x, uint seed) {
+    x += seed;
+    x ^= x * 0x6c50b47cu;
+    x ^= x * 0xb82f1e52u;
+    x ^= x * 0xc7afe638u;
+    x ^= x * 0x8d22f6e6u;
+    return x;
+}
+
+/// @return `x` Owen-scrambled under `seed`.
+uint NestedUniformScramble(uint x, uint seed) {
+    return reversebits(LaineKarrasPermutation(reversebits(x), seed));
+}
+
+/// @return `value` folded into a 32-bit `seed`.
+uint CombineSeed(uint seed, uint value) {
+    return seed ^ (value + (seed << 6u) + (seed >> 2u));
+}
+
+/// The Sobol sequence's direction numbers for its first two dimensions: a (0,2)-sequence.
+static const uint kSobolDirections[2][32] = {
+    { 0x80000000, 0x40000000, 0x20000000, 0x10000000, 0x08000000, 0x04000000, 0x02000000,
+      0x01000000, 0x00800000, 0x00400000, 0x00200000, 0x00100000, 0x00080000, 0x00040000,
+      0x00020000, 0x00010000, 0x00008000, 0x00004000, 0x00002000, 0x00001000, 0x00000800,
+      0x00000400, 0x00000200, 0x00000100, 0x00000080, 0x00000040, 0x00000020, 0x00000010,
+      0x00000008, 0x00000004, 0x00000002, 0x00000001 },
+    { 0x80000000, 0xc0000000, 0xa0000000, 0xf0000000, 0x88000000, 0xcc000000, 0xaa000000,
+      0xff000000, 0x80800000, 0xc0c00000, 0xa0a00000, 0xf0f00000, 0x88880000, 0xcccc0000,
+      0xaaaa0000, 0xffff0000, 0x80008000, 0xc000c000, 0xa000a000, 0xf000f000, 0x88008800,
+      0xcc00cc00, 0xaa00aa00, 0xff00ff00, 0x80808080, 0xc0c0c0c0, 0xa0a0a0a0, 0xf0f0f0f0,
+      0x88888888, 0xcccccccc, 0xaaaaaaaa, 0xffffffff }
+};
+
+/// @return Point `index`'s coordinate `dimension` (0 or 1) of the Sobol sequence, as 32 bits.
+uint SobolBits(uint index, uint dimension) {
+    uint bits = 0;
+    for (uint bit = 0; index != 0; ++bit, index >>= 1u) {
+        if ((index & 1u) != 0) {
+            bits ^= kSobolDirections[dimension][bit];
+        }
+    }
+    return bits;
+}
+
+/// @return A low-discrepancy number in [0, 1) for dimension `dimension` of a sample, with 24
+/// bits: an Owen-scrambled, shuffled Sobol sequence over the pixel's samples, each pair of
+/// dimensions Sobol's first two under a scramble of its own.
+float SampleSobol(SampleKey key, uint dimension) {
+    uint pair = dimension / 2u;
+    uint seed = Pcg4d(uint4(key.pixel, pair, key.view, key.frameSeed)).x;
+    uint index = NestedUniformScramble(key.sample, seed);
+    uint bits = NestedUniformScramble(SobolBits(index, dimension % 2u),
+                                      CombineSeed(seed, dimension % 2u));
+    return float(bits >> 8u) * (1.0 / 16777216.0);
+}

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/shaders/sensors/camera.slang

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /// @file camera.slang
-/// @brief Cameras traced one ray a pixel through their lenses, every view in one dispatch: a
-/// headlit colour into a bindless image, and each pixel's distance, world normal, instance, prim,
-/// albedo and RGBA8 colour into buffers kernels, CUDA or PyTorch read. The views and parameters
-/// are shared with C++ (rt/camera_pass.cpp).
+/// @brief Cameras traced through their lenses, every view in one dispatch: a headlit colour into
+/// a bindless image, and each pixel's distance, world normal, instance, prim, albedo and RGBA8
+/// colour into buffers kernels, CUDA or PyTorch read. One ray through a pixel's middle gives its
+/// geometry; with more samples, its colour and albedo average rays jittered across it by keyed
+/// Sobol samples. The views and parameters are shared with C++ (rt/camera_pass.cpp).
 #ifdef __cplusplus
 #pragma once
 #include "ernie/shaders/rt/ray_tracer.slang"
@@ -15,6 +16,7 @@ import bindless;
 import ray_tracer;
 import buffer_ref;
 import lens;
+import random;
 import spectrum;
 import transform;
 #endif
@@ -45,6 +47,12 @@ struct View {
     /// `clippingRange`: nothing nearer or farther is seen.
     float near;
     float far;
+    /// Jittered rays a pixel's colour and albedo average; 1 for one through its middle.
+    uint samples;
+    /// What its random numbers are keyed by, with the frame: the settings' seed and its render
+    /// product's path, hashed.
+    uint seed;
+    uint stream;
     /// Per pixel, row by row: the hit distance (infinity for none), the world normal's x, y and
     /// z, the instance row, the prim's slot, `kBands` albedo bands, and the colour image's RGBA8
     /// bytes; each null for no output.
@@ -68,6 +76,8 @@ struct CameraParameters {
     /// Each instance row's albedo, three linear RGB floats, and its prim's slot.
     BufferRef<float> colours;
     BufferRef<uint> instancePrims;
+    /// The frame's number, counted on the device.
+    BufferRef<uint> frame;
     uint count;
 };
 
@@ -86,9 +96,10 @@ Spectrum Shade(Spectrum albedo, float3 normal, no_diff float3 direction) {
     return albedo.Scaled(lerp(kAmbient, 1.0, lit));
 }
 
-/// @return A view's ray through the middle of a pixel, from the camera's pose `toWorld`.
-RayDesc PixelRay(View view, float3x4 toWorld, uint2 pixel) {
-    LensRay ray = Unproject(view.lens, float2(pixel) + 0.5);
+/// @return A view's ray through a pixel at `offset` across it, its middle by default, from the
+/// camera's pose `toWorld`.
+RayDesc PixelRay(View view, float3x4 toWorld, uint2 pixel, float2 offset = float2(0.5)) {
+    LensRay ray = Unproject(view.lens, float2(pixel) + offset);
     // The clipping planes are across the view axis: a ray off axis reaches them farther along.
     float along = max(-ray.direction.z, 1e-6);
     return { mul(toWorld, float4(ray.origin, 1)), view.near / along,
@@ -107,13 +118,28 @@ float3x4 ViewPose(View view, BufferRef<float4> worlds) {
     return float3x4(pose.rows[0], pose.rows[1], pose.rows[2]);
 }
 
-/// @brief Writes the colour a pixel shows to the view's image and RGBA8 buffer, as it asks.
-void WriteColour(View view, uint2 pixel, uint at, Hit hit, Spectrum light) {
-    float3 shown = view.background;
-    if (hit.found) {
-        // Stored as UNORM: encoded for display roughly as sRGB would.
-        shown = pow(saturate(ToLinearSrgb(light)), 1 / 2.2);
+/// @return An instance's albedo.
+Spectrum InstanceAlbedo(CameraParameters parameters, uint instance) {
+    uint colour = 3 * instance;
+    return Uplift(float3(parameters.colours[colour], parameters.colours[colour + 1],
+                         parameters.colours[colour + 2]));
+}
+
+/// @return What a ray shows, in linear sRGB: its hit lit from the eye, or the background.
+float3 RayColour(View view, RayTracer tracer, CameraParameters parameters, RayDesc ray,
+                 out Spectrum albedo) {
+    Hit hit = tracer.TraceClosest(ray, 0xff);
+    albedo = Spectrum(0);
+    if (!hit.found) {
+        return pow(view.background, 2.2);
     }
+    albedo = InstanceAlbedo(parameters, hit.instance);
+    return saturate(ToLinearSrgb(Shade(albedo, tracer.WorldNormal(hit), ray.Direction)));
+}
+
+/// @brief Writes the colour a pixel shows, as stored, to the view's image and RGBA8 buffer, as
+/// it asks.
+void WriteColour(View view, uint2 pixel, uint at, float3 shown) {
     if (view.colour != kNoImage) {
         images[NonUniformResourceIndex(view.colour)][pixel] = float4(shown, 1);
     }
@@ -134,21 +160,45 @@ void main(uint3 id : SV_DispatchThreadID, uniform CameraParameters parameters) {
     if (any(pixel >= view.size)) {
         return;
     }
-    RayDesc ray = PixelRay(view, ViewPose(view, parameters.worlds), pixel);
+    float3x4 toWorld = ViewPose(view, parameters.worlds);
+    RayDesc ray = PixelRay(view, toWorld, pixel);
     RayTracer tracer = RayTracer(parameters.tracer, view.world);
     Hit hit = tracer.TraceClosest(ray, 0xff);
     float3 normal = float3(0);
     Spectrum albedo = Spectrum(0);
+    // Stored as UNORM: encoded for display roughly as sRGB would.
+    float3 shown = view.background;
     if (hit.found) {
         normal = tracer.WorldNormal(hit);
-        uint colour = 3 * hit.instance;
-        albedo = Uplift(float3(parameters.colours[colour], parameters.colours[colour + 1],
-                               parameters.colours[colour + 2]));
+        albedo = InstanceAlbedo(parameters, hit.instance);
+        shown = pow(saturate(ToLinearSrgb(Shade(albedo, normal, ray.Direction))), 1 / 2.2);
     }
 
-    uint at = view.first + pixel.y * view.size.x + pixel.x;
+    uint pixelIndex = pixel.y * view.size.x + pixel.x;
+    uint at = view.first + pixelIndex;
+    bool coloured = view.colour != kNoImage || !view.ldr.IsNull() || !view.albedos.IsNull();
+    if (view.samples > 1 && coloured) {
+        // Colour and albedo integrate the pixel's area; the frame number keys each frame's own
+        // samples, as replayed frames count it.
+        SampleKey key = { FrameSeed(view.seed, view.stream,
+                                    parameters.frame.IsNull() ? 0 : parameters.frame[0]),
+                          0, pixelIndex, 0 };
+        float3 linear = float3(0);
+        Spectrum albedos = Spectrum(0);
+        for (uint sample = 0; sample < view.samples; ++sample) {
+            key.sample = sample;
+            float2 offset = float2(SampleSobol(key, kPixelDimension),
+                                   SampleSobol(key, kPixelDimension + 1));
+            Spectrum sampled;
+            linear += RayColour(view, tracer, parameters, PixelRay(view, toWorld, pixel, offset),
+                                sampled);
+            albedos = albedos.Plus(sampled);
+        }
+        shown = pow(linear / float(view.samples), 1 / 2.2);
+        albedo = albedos.Scaled(1.0 / float(view.samples));
+    }
     if (view.colour != kNoImage || !view.ldr.IsNull()) {
-        WriteColour(view, pixel, at, hit, Shade(albedo, normal, ray.Direction));
+        WriteColour(view, pixel, at, shown);
     }
     if (!view.distances.IsNull()) {
         view.distances[at] = hit.found ? hit.t : 1.0 / 0.0;

{ernie_renderer-0.2.0.dev168 → ernie_renderer-0.2.0.dev170}/ernie/util/random.h

@@ -93,6 +93,80 @@ inline constexpr float SampleUniform(const SampleKey& key, std::uint32_t dimensi
     return static_cast<float>(SampleBits(key, dimension) >> 8u) * (1.0f / 16777216.0f);
 }
 
+/// @return `x`'s bits in reverse order.
+inline constexpr std::uint32_t ReverseBits(std::uint32_t x) {
+    x = ((x >> 1u) & 0x55555555u) | ((x & 0x55555555u) << 1u);
+    x = ((x >> 2u) & 0x33333333u) | ((x & 0x33333333u) << 2u);
+    x = ((x >> 4u) & 0x0f0f0f0fu) | ((x & 0x0f0f0f0fu) << 4u);
+    x = ((x >> 8u) & 0x00ff00ffu) | ((x & 0x00ff00ffu) << 8u);
+    return (x >> 16u) | (x << 16u);
+}
+
+/// @return `x` permuted as an Owen scramble does, keyed by `seed`: each bit flipped by a hash of
+/// the bits below it, in the reversed order `NestedUniformScramble` hands it.
+inline constexpr std::uint32_t LaineKarrasPermutation(std::uint32_t x, std::uint32_t seed) {
+    x += seed;
+    x ^= x * 0x6c50b47cu;
+    x ^= x * 0xb82f1e52u;
+    x ^= x * 0xc7afe638u;
+    x ^= x * 0x8d22f6e6u;
+    return x;
+}
+
+/// @return `x` Owen-scrambled under `seed`: each bit flipped by a hash of the bits above it.
+inline constexpr std::uint32_t NestedUniformScramble(std::uint32_t x, std::uint32_t seed) {
+    return ReverseBits(LaineKarrasPermutation(ReverseBits(x), seed));
+}
+
+/// @return `value` folded into a 32-bit `seed`.
+inline constexpr std::uint32_t CombineSeed(std::uint32_t seed, std::uint32_t value) {
+    return seed ^ (value + (seed << 6u) + (seed >> 2u));
+}
+
+/// The Sobol sequence's direction numbers for its first two dimensions, van der Corput's and Joe
+/// and Kuo's first: together a (0,2)-sequence, stratified in every pair of grid sizes.
+inline constexpr std::uint32_t kSobolDirections[2][32] = {
+    {0x80000000, 0x40000000, 0x20000000, 0x10000000, 0x08000000, 0x04000000, 0x02000000,
+     0x01000000, 0x00800000, 0x00400000, 0x00200000, 0x00100000, 0x00080000, 0x00040000,
+     0x00020000, 0x00010000, 0x00008000, 0x00004000, 0x00002000, 0x00001000, 0x00000800,
+     0x00000400, 0x00000200, 0x00000100, 0x00000080, 0x00000040, 0x00000020, 0x00000010,
+     0x00000008, 0x00000004, 0x00000002, 0x00000001},
+    {0x80000000, 0xc0000000, 0xa0000000, 0xf0000000, 0x88000000, 0xcc000000, 0xaa000000,
+     0xff000000, 0x80800000, 0xc0c00000, 0xa0a00000, 0xf0f00000, 0x88880000, 0xcccc0000,
+     0xaaaa0000, 0xffff0000, 0x80008000, 0xc000c000, 0xa000a000, 0xf000f000, 0x88008800,
+     0xcc00cc00, 0xaa00aa00, 0xff00ff00, 0x80808080, 0xc0c0c0c0, 0xa0a0a0a0, 0xf0f0f0f0,
+     0x88888888, 0xcccccccc, 0xaaaaaaaa, 0xffffffff}};
+
+/// @return Point `index`'s coordinate `dimension` (0 or 1) of the Sobol sequence, as 32 bits.
+inline constexpr std::uint32_t SobolBits(std::uint32_t index, std::uint32_t dimension) {
+    std::uint32_t bits = 0;
+    for (std::uint32_t bit = 0; index != 0; ++bit, index >>= 1u) {
+        if ((index & 1u) != 0) {
+            bits ^= kSobolDirections[dimension][bit];
+        }
+    }
+    return bits;
+}
+
+/// A low-discrepancy number in [0, 1) for dimension `dimension` of a sample, with 24 bits: an
+/// Owen-scrambled, shuffled Sobol sequence over the pixel's samples. Dimensions come in pairs,
+/// each Sobol's first two dimensions under a scramble of its own, so a pixel's first 2^k samples
+/// stratify every pair as a (0,2)-sequence does, and a feature's dimensions keep their samples
+/// when others are added. Shaders implement the same function.
+///
+/// References:
+/// - B. Burley, "Practical Hash-based Owen Scrambling", JCGT 9(4), 2020.
+/// - M. Pharr, W. Jakob and G. Humphreys, "Physically Based Rendering", 4th edition, 2023
+///   (`PaddedSobolSampler`).
+inline constexpr float SampleSobol(const SampleKey& key, std::uint32_t dimension) {
+    const std::uint32_t pair = dimension / 2u;
+    const std::uint32_t seed = Pcg4d(glm::uvec4(key.pixel, pair, key.view, key.frameSeed)).x;
+    const std::uint32_t index = NestedUniformScramble(key.sample, seed);
+    const std::uint32_t bits =
+        NestedUniformScramble(SobolBits(index, dimension % 2u), CombineSeed(seed, dimension % 2u));
+    return static_cast<float>(bits >> 8u) * (1.0f / 16777216.0f);
+}
+
 /// @brief SplitMix64's finaliser: every input bit affects every output bit.
 /// @param z The bits.
 /// @return Them mixed.