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

{ernie_renderer-0.2.0.dev166 → 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 ".dev166" 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.dev166 → ernie_renderer-0.2.0.dev170}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev166
+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.dev166 → ernie_renderer-0.2.0.dev170}/benchmarks/CMakeLists.txt

@@ -6,6 +6,7 @@ add_executable(
     device/pose_step.cpp
     render/batch_step.cpp
     render/hide_seek.cpp
+    render/shared_prims.cpp
     render/transform_graph.cpp
     scene/extents.cpp
     scene/storage.cpp

ernie_renderer-0.2.0.dev170/benchmarks/render/shared_prims.cpp

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file shared_prims.cpp
+/// @brief How batch worlds best trace the prims they share, as Isaac Lab's scenes have
+/// them: a shared ground and room, with furniture, and a few small objects a world whose poses
+/// device columns hold, so every step rebuilds the top levels as a learning step does. Each world
+/// renders colour and depth at 64 x 64. Reports a step's time with the shared prims duplicated
+/// into every world's top level and with them in a top level of their own.
+#include "benchmarks/bench.h"
+#include "ernie/device/context.h"
+#include "ernie/render/renderer.h"
+#include "ernie/scene/schema/camera.h"
+#include "ernie/scene/schema/geom.h"
+#include "ernie/scene/schema/planet.h"
+#include "ernie/scene/schema/render.h"
+#include "ernie/scene/tokens.h"
+#include "ernie/scene/xform.h"
+
+#include <cstdio>
+#include <memory>
+#include <random>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+namespace {
+
+constexpr int kObjectsPerWorld = 8;
+constexpr std::uint32_t kSide = 64;
+
+/// @brief A room 10 m square around the origin: the ground, four walls, and furniture making up
+/// `shared` prims in all; and `worlds` worlds, each with small objects and a camera inside it.
+void BuildRoom(Scene& scene, int worlds, int shared) {
+    GroundPlane::Define(scene, "/Room/Ground");
+    for (int wall = 0; wall < 4; ++wall) {
+        const std::string path = "/Room/Wall" + std::to_string(wall);
+        Cube::Define(scene, path).SetSize(1.0);
+        const double angle = 1.5707963267948966 * wall;
+        SetXform(
+            scene, path,
+            {.translate = glm::dvec3(5.0 * std::cos(angle), 5.0 * std::sin(angle), 1.5),
+             .scale = wall % 2 == 0 ? glm::dvec3(0.2, 10.0, 3.0) : glm::dvec3(10.0, 0.2, 3.0)});
+    }
+    std::mt19937 random(11);
+    std::uniform_real_distribution<double> across(-4.0, 4.0);
+    for (int item = 5; item < shared; ++item) {
+        const std::string path = "/Room/Furniture" + std::to_string(item);
+        Cube::Define(scene, path).SetSize(0.5);
+        SetXform(scene, path, {.translate = glm::dvec3(across(random), across(random), 0.25)});
+    }
+    const std::vector<Path> vars{Path("/Render/Vars/Colour"), Path("/Render/Vars/Depth")};
+    RenderVar::Define(scene, vars[0]).SetSourceName(std::string(render_vars::kLdrColor));
+    RenderVar::Define(scene, vars[1]).SetSourceName(std::string(render_vars::kDistanceToCamera));
+    std::vector<Path> products;
+    for (int world = 0; world < worlds; ++world) {
+        const std::string root = "/World" + std::to_string(world);
+        Xform::Define(scene, root).SetWorld(world);
+        for (int object = 0; object < kObjectsPerWorld; ++object) {
+            const std::string path = root + "/Object" + std::to_string(object);
+            if (object % 2 == 0) {
+                Sphere::Define(scene, path).SetRadius(0.15);
+            } else {
+                Cube::Define(scene, path).SetSize(0.25);
+            }
+            SetXform(scene, path, {.translate = glm::dvec3(across(random), across(random), 0.2)});
+        }
+        const std::string camera = root + "/Camera";
+        Camera::Define(scene, camera).SetHorizontalAperture(0.036).SetVerticalAperture(0.036);
+        scene.Set(camera, tokens::kTransform,
+                  LookAtTransform({across(random), -4.5, 1.5}, {0.0, 0.0, 0.5}, {0.0, 0.0, 1.0}));
+        products.emplace_back("/Render/View" + std::to_string(world));
+        RenderProduct::Define(scene, products.back())
+            .SetCamera(camera)
+            .SetResolution(glm::dvec2(kSide))
+            .SetOrderedVars(vars);
+    }
+    RenderSettings::Define(scene, "/Render/Settings").SetProducts(products);
+}
+
+Timing StepRoom(SharedPrims policy, int worlds, int shared) {
+    const double targetMs = 0.005 * worlds;
+    std::unique_ptr<Renderer> renderer;
+    try {
+        renderer = std::make_unique<Renderer>(RendererOptions{.sharedPrims = policy});
+    } catch (const std::exception& error) {
+        std::printf("skipped: %s\n", error.what());
+        return {0.0, targetMs};
+    }
+    Scene scene;
+    BuildRoom(scene, worlds, shared);
+    // The objects' poses on the device, as a simulation writes them: every step rebuilds the top
+    // levels.
+    renderer->BindColumn(scene, "/World0/Object0", "xformOp:translate");
+    renderer->BindColumn(scene, "/World0/Object1", "xformOp:translate");
+    renderer->Step(scene);
+    renderer->Context().WaitIdle();
+    const double ms = Fastest([] {},
+                              [&] {
+                                  renderer->Step(scene);
+                                  renderer->Context().WaitIdle();
+                              });
+    std::printf("  %s, %d worlds, %d shared prims: %.0f views a second\n",
+                policy == SharedPrims::Duplicated ? "duplicated" : "own top level", worlds, shared,
+                1000.0 * worlds / ms);
+    return {ms, targetMs};
+}
+
+bool RegisterRoom(SharedPrims policy, int worlds, int shared) {
+    const std::string name = policy == SharedPrims::Duplicated ? "duplicated" : "own_top_level";
+    return Register("render.shared_prims." + name + "." + std::to_string(worlds) + "_worlds_" +
+                        std::to_string(shared) + "_shared",
+                    [=] { return StepRoom(policy, worlds, shared); });
+}
+
+bool RegisterRooms() {
+    for (const int shared : {8, 64}) {
+        for (const int worlds : {64, 1024, 4096, 16384}) {
+            for (const SharedPrims policy :
+                 {SharedPrims::Duplicated, SharedPrims::SharedTopLevel}) {
+                RegisterRoom(policy, worlds, shared);
+            }
+        }
+    }
+    return true;
+}
+
+const bool kRooms = RegisterRooms();
+
+}  // namespace
+}  // namespace ernie::bench

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev170}/ernie/render/instances.cpp

@@ -111,7 +111,9 @@ void InstanceTable::LayOutWorlds() {
                                 std::to_string(capacities_.worlds) + " declared");
     }
     const std::size_t count = capacities_.worlds > 0 ? capacities_.worlds : needed;
-    std::vector<std::uint32_t> records(count, shared);
+    // With one world, a top level of their own would only add an empty one to trace.
+    const bool ownTop = capacities_.sharedPrims == SharedPrims::SharedTopLevel && count > 1;
+    std::vector<std::uint32_t> records(count, ownTop ? 0u : shared);
     for (const std::int32_t world : hostWorlds_) {
         if (world >= 0) {
             ++records[static_cast<std::size_t>(world)];
@@ -131,6 +133,11 @@ void InstanceTable::LayOutWorlds() {
         worlds_[world] = {.first = static_cast<std::uint32_t>(world) * stride_,
                           .count = records[world]};
     }
+    shared_.reset();
+    if (ownTop && shared > 0) {
+        shared_ =
+            WorldRecords{.first = static_cast<std::uint32_t>(count) * stride_, .count = shared};
+    }
 }
 
 void InstanceTable::AddLayoutPasses(graph::Graph& graph, graph::Buffer rowWorlds,
@@ -144,7 +151,9 @@ void InstanceTable::AddLayoutPasses(graph::Graph& graph, graph::Buffer rowWorlds
                                            .rows = Count(),
                                            .worldCount = static_cast<std::uint32_t>(worlds_.size()),
                                            .stride = stride_,
-                                           .sharedCount = sharedCount_};
+                                           .sharedCount = sharedCount_,
+                                           .sharedFirst =
+                                               shared_ ? shared_->first : shaders::kNoSource};
     const auto add = [&](const char* name, const ComputeKernel& kernel, std::uint32_t items,
                          const auto& declare) {
         if (items == 0) {
@@ -174,7 +183,8 @@ void InstanceTable::AddLayoutPasses(graph::Graph& graph, graph::Buffer rowWorlds
         cursors = pass.WriteAddress(cursors);
         shared = pass.WriteAddress(shared);
     });
-    add("Share records", sharer_, layout.worldCount * sharedCount_, [&](graph::PassBuilder& pass) {
+    const std::uint32_t copies = shared_ ? sharedCount_ : layout.worldCount * sharedCount_;
+    add("Share records", sharer_, copies, [&](graph::PassBuilder& pass) {
         pass.ReadAddress(shared);
         sources = pass.WriteAddress(sources);
     });

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev170}/ernie/render/instances.h

@@ -10,6 +10,7 @@
 #include "ernie/device/staging.h"
 #include "ernie/graph/graph.h"
 #include "ernie/render/geometry.h"
+#include "ernie/render/renderer.h"
 #include "ernie/util/glm.h"
 
 #include <algorithm>
@@ -35,8 +36,11 @@ namespace ernie {
 /// so nothing is laid out again or reallocated as counts move; 0 for as many as there are.
 struct WorldCapacities {
     std::uint32_t worlds = 0;
-    /// Each world's records: its own instances and the shared ones.
+    /// Each world's records: its own instances, and the shared ones when duplicated.
     std::uint32_t instancesPerWorld = 0;
+    /// How the shared rows are traced: in every world's records, or in their own top level's
+    /// when there is more than one world.
+    SharedPrims sharedPrims = SharedPrims::SharedTopLevel;
 };
 
 class InstanceTable {
@@ -96,6 +100,11 @@ class InstanceTable {
     std::span<const WorldRecords> Worlds() const {
         return worlds_;
     }
+    /// @return The records of the shared rows' own top level, after every world's; none when
+    /// they are duplicated into each world's, or there are none.
+    std::optional<WorldRecords> Shared() const {
+        return shared_;
+    }
     /// @return Each top-level record's instance row, a uint32 a record, world after world, each
     /// world's own rows in no fixed order; `kNoRow` for a record no instance fills.
     const DeviceColumn& Sources() const {
@@ -104,10 +113,11 @@ class InstanceTable {
     const WorldCapacities& Capacities() const {
         return capacities_;
     }
-    /// @return The records of every world: as many a world as the declared capacity, or as the
-    /// largest world's.
+    /// @return Every top level's records: as many a world as the declared capacity, or as the
+    /// largest world's, then the shared ones' own.
     std::uint32_t Records() const {
-        return static_cast<std::uint32_t>(worlds_.size()) * stride_;
+        return static_cast<std::uint32_t>(worlds_.size()) * stride_ +
+               (shared_ ? shared_->count : 0);
     }
 
   private:
@@ -168,6 +178,7 @@ class InstanceTable {
     /// Records from one world's first to the next's.
     std::uint32_t stride_ = 0;
     std::uint32_t sharedCount_ = 0;
+    std::optional<WorldRecords> shared_;
     std::unique_ptr<DeviceColumn> sources_;
     std::unique_ptr<DeviceColumn> rowWorlds_;
     /// The layout kernels' scratch.

{ernie_renderer-0.2.0.dev166 → 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.dev166 → 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.dev166 → ernie_renderer-0.2.0.dev170}/ernie/render/renderer.cpp

@@ -90,6 +90,7 @@ struct Renderer::Device {
     std::uint64_t sceneId = 0;
     std::unique_ptr<DeviceScene> deviceScene;
     std::uint32_t outputSets = 1;
+    SharedPrims sharedPrims = SharedPrims::SharedTopLevel;
     std::vector<Batch> batches;
     /// Each output set's batches.
     std::vector<std::vector<RenderBatch>> rendered;
@@ -125,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);
@@ -180,6 +184,7 @@ Renderer::Renderer(const RendererOptions& options) : device_(std::make_unique<De
         throw std::invalid_argument("A renderer needs at least one output set");
     }
     device.outputSets = options.outputSets;
+    device.sharedPrims = options.sharedPrims;
     device.context = std::make_unique<DeviceContext>(
         DeviceContextOptions{.validation = options.validation, .device = options.device});
     if (!device.context->Capabilities().rayQuery) {
@@ -208,7 +213,8 @@ DeviceScene& Renderer::Device::Follow(const Scene& scene) {
         deviceScene = std::make_unique<DeviceScene>(
             *context, *arenas, scene, compiler,
             WorldCapacities{.worlds = capacities.worlds,
-                            .instancesPerWorld = capacities.instancesPerWorld});
+                            .instancesPerWorld = capacities.instancesPerWorld,
+                            .sharedPrims = sharedPrims});
         sceneId = scene.Id();
         batches.clear();
         rendered.clear();

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev170}/ernie/render/renderer.h

@@ -40,6 +40,17 @@ struct RenderCapacities {
     std::uint32_t views = 0;
 };
 
+/// @brief How batch worlds trace the prims in every world, such as a shared ground and room. A
+/// scene of one world keeps them in its top level either way.
+enum class SharedPrims : std::uint8_t {
+    /// In every world's top level, beside its own prims.
+    Duplicated,
+    /// In one top level of their own, traced after each world's: a world's top level holds only
+    /// its own prims, however many shared ones there are. Measured faster from 64 to 16,384
+    /// worlds, by up to 40% with 64 shared prims (`render.shared_prims` in ernie_benchmarks).
+    SharedTopLevel,
+};
+
 struct RendererOptions {
     /// The device: its UUID in hex, or part of its name; empty for the best scoring one.
     std::string device;
@@ -49,6 +60,8 @@ struct RendererOptions {
     /// The sets of outputs steps take turns rendering into: with 2, a learner reads one step's
     /// outputs while the next step renders into the other set.
     std::uint32_t outputSets = 1;
+    /// How worlds trace their shared prims; the default is the faster one as measured.
+    SharedPrims sharedPrims = SharedPrims::SharedTopLevel;
 };
 
 /// @brief One var of a batch: every view's pixels, stacked on the device.

{ernie_renderer-0.2.0.dev166 → 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.dev166 → 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.dev166 → 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 =
@@ -36,7 +74,9 @@ void RayTracer::AddBuild(graph::Graph& graph, const GeometryPool::Changes& chang
     graph.Board().Put(
         TraceScene{.parameters = {.tops = ToBufferRef<shaders::TopLevel>(tops_.Tops()),
                                   .sources = ToBufferRef<shaders::uint>(instances.Sources()),
-                                  .records = ToBufferRef<shaders::GeometryRecord>(records)},
+                                  .records = ToBufferRef<shaders::GeometryRecord>(records),
+                                  .worlds = tops_.Worlds(),
+                                  .shared = tops_.SharedTop().value_or(shaders::kNoSharedTop)},
                    .top = top,
                    .tables = {graph.Import(tops_.Tops()), graph.Import(instances.Sources()),
                               graph.Import(records)},
@@ -45,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.dev166 → 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.dev166 → ernie_renderer-0.2.0.dev170}/ernie/render/rt/top_levels.cpp

@@ -46,8 +46,14 @@ graph::Acceleration TopLevels::AddBuild(graph::Graph& graph, const TransformGrap
                                         const InstanceTable& instances, const BottomLevels& bottoms,
                                         bool rebuild) {
     ERNIE_ZONE("Prepare the top levels");
-    const std::span<const InstanceTable::WorldRecords> worlds = instances.Worlds();
-    EnsureCapacity(worlds, instances.Capacities().instancesPerWorld);
+    // Each world's top level, then the shared prims' own, if any.
+    std::vector<InstanceTable::WorldRecords> tops(instances.Worlds().begin(),
+                                                  instances.Worlds().end());
+    worlds_ = static_cast<std::uint32_t>(tops.size());
+    if (const std::optional<InstanceTable::WorldRecords> shared = instances.Shared()) {
+        tops.push_back(*shared);
+    }
+    EnsureCapacity(tops, instances.Capacities().instancesPerWorld, worlds_);
     if (uploader_.Staged()) {
         std::array buffers{graph.Import(*tops_)};
         graph::AddUploadPass(graph, "Upload top levels", uploader_, buffers);
@@ -61,30 +67,31 @@ graph::Acceleration TopLevels::AddBuild(graph::Graph& graph, const TransformGrap
     if (instances.Records() > 0) {
         AddWritePass(graph, transforms, instances, bottoms, records);
     }
-    return AddBuildPass(graph, bottoms, worlds, records);
+    return AddBuildPass(graph, bottoms, tops, records);
 }
 
-void TopLevels::EnsureCapacity(std::span<const InstanceTable::WorldRecords> worlds,
-                               std::uint32_t declared) {
+void TopLevels::EnsureCapacity(std::span<const InstanceTable::WorldRecords> tops,
+                               std::uint32_t declared, std::size_t worlds) {
     // Frames in flight keep the old ones: destroying them retires them.
-    structures_.resize(worlds.size());
-    hostTops_.resize(worlds.size());
+    structures_.resize(tops.size());
+    hostTops_.resize(tops.size());
     bool changed = false;
-    for (std::size_t world = 0; world < worlds.size(); ++world) {
-        std::unique_ptr<AccelerationStructure>& top = structures_[world];
-        const std::uint32_t count = worlds[world].count;
+    for (std::size_t index = 0; index < tops.size(); ++index) {
+        std::unique_ptr<AccelerationStructure>& top = structures_[index];
+        const std::uint32_t count = tops[index].count;
         const std::uint32_t capacity = top ? top->Sizes().primitives[0] : 0;
-        const bool resize = declared > 0
-                                ? capacity != declared
-                                : count > capacity || (capacity > 4 && count < capacity / 4);
+        // The shared top level, after the worlds', grows with its prims.
+        const std::uint32_t fixed = index < worlds ? declared : 0;
+        const bool resize = fixed > 0 ? capacity != fixed
+                                      : count > capacity || (capacity > 4 && count < capacity / 4);
         if (!top || resize) {
             top = std::make_unique<AccelerationStructure>(
-                pool_, Sizes(context_, declared > 0 ? declared : RoundUpCapacity(count), kRebuilt),
-                "world " + std::to_string(world));
+                pool_, Sizes(context_, fixed > 0 ? fixed : RoundUpCapacity(count), kRebuilt),
+                index < worlds ? "world " + std::to_string(index) : std::string("shared"));
         }
         const shaders::TopLevel next{
-            .address = top->Address(), .first = worlds[world].first, .count = count};
-        shaders::TopLevel& last = hostTops_[world];
+            .address = top->Address(), .first = tops[index].first, .count = count};
+        shaders::TopLevel& last = hostTops_[index];
         if (last.address != next.address || last.first != next.first || last.count != count) {
             last = next;
             changed = true;

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev170}/ernie/render/rt/top_levels.h

@@ -25,7 +25,8 @@ namespace ernie {
 /// instance records, laid out by the instance table, from their world transforms, shape transforms
 /// and geometries' bottom levels, and one call builds them all. Instances whose bottom level is not
 /// built are switched off. An instance's custom index is its geometry; its row in the instance
-/// table is `InstanceIndex()`. Shared prims are in every world's top level. A world's capacity
+/// table is `InstanceIndex()`. Shared prims are in every world's top level, or in one of their own
+/// after the worlds', as the instance table lays them out. A world's capacity
 /// grows by doubling and shrinks once it is four times what is needed, so instance counts that
 /// wobble do not reallocate.
 class TopLevels {
@@ -47,15 +48,21 @@ class TopLevels {
     const DeviceColumn& Tops() const {
         return *tops_;
     }
+    /// @return The batch worlds' top levels: `Tops`' first entries.
     std::uint32_t Worlds() const {
-        return static_cast<std::uint32_t>(structures_.size());
+        return worlds_;
+    }
+    /// @return The shared prims' own top level's index in `Tops`, after the worlds'; none when
+    /// each world's holds them.
+    std::optional<std::uint32_t> SharedTop() const {
+        return structures_.size() > worlds_ ? std::optional(worlds_) : std::nullopt;
     }
 
   private:
-    /// Remakes the top levels whose worlds outgrow them or use under a quarter of them; with a
-    /// `declared` capacity a world, makes each once at that size.
-    void EnsureCapacity(std::span<const InstanceTable::WorldRecords> worlds,
-                        std::uint32_t declared);
+    /// Remakes the top levels whose records outgrow them or use under a quarter of them; with a
+    /// `declared` capacity a world, makes each of the first `worlds` once at that size.
+    void EnsureCapacity(std::span<const InstanceTable::WorldRecords> tops, std::uint32_t declared,
+                        std::size_t worlds);
     /// Adds the pass writing each record from its instance's world and shape transforms.
     void AddWritePass(graph::Graph& graph, const TransformGraph& transforms,
                       const InstanceTable& instances, const BottomLevels& bottoms,
@@ -70,6 +77,7 @@ class TopLevels {
     Uploader uploader_;
     std::vector<std::unique_ptr<AccelerationStructure>> structures_;
     std::vector<shaders::TopLevel> hostTops_;
+    std::uint32_t worlds_ = 0;
     std::unique_ptr<DeviceColumn> tops_;
 };
 

{ernie_renderer-0.2.0.dev166 → 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