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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev166
+Version: 0.2.0.dev168
 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.dev168}/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.dev168/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.dev168}/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.dev168}/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.dev168}/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;
@@ -180,6 +181,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 +210,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.dev168}/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.dev168}/ernie/render/rt/ray_tracer.cpp

@@ -36,7 +36,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)},

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev168}/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.dev168}/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.dev168}/ernie/shaders/rt/ray_tracer.slang

@@ -26,13 +26,21 @@ struct TopLevel {
     uint count;
 };
 
+/// `TracerParameters::shared` without a shared top level.
+static const uint kNoSharedTop = 0xffffffff;
+
 /// What a pass hands its tracer.
 struct TracerParameters {
-    /// Each world's top level.
+    /// Each world's top level, then the shared one, if any.
     BufferRef<TopLevel> tops;
     /// Each top-level record's instance row, world after world.
     BufferRef<uint> sources;
     BufferRef<GeometryRecord> records;
+    /// The batch worlds' top levels, the first of `tops`.
+    uint worlds;
+    /// The top level of the prims every world sees, traced after each world's own; or
+    /// `kNoSharedTop` when every world's top level holds them.
+    uint shared;
 };
 
 #ifdef __cplusplus
@@ -69,11 +77,33 @@ struct RayTracer {
         this.top = parameters.tops[world];
     }
 
-    /// @return The nearest hit along the ray among instances in `mask`.
+    /// @return The nearest hit along the ray among instances in `mask`: the world's own, then
+    /// the shared prims nearer than it.
     Hit TraceClosest(RayDesc ray, uint mask) {
+        Hit hit = TraceTop(top, ray, mask);
+        if (parameters.shared != kNoSharedTop) {
+            RayDesc nearer = ray;
+            nearer.TMax = hit.found ? hit.t : ray.TMax;
+            Hit shared = TraceTop(parameters.tops[parameters.shared], nearer, mask);
+            if (shared.found) {
+                hit = shared;
+            }
+        }
+        return hit;
+    }
+
+    /// @return Whether anything in `mask` blocks the ray, for visibility.
+    bool TraceAny(RayDesc ray, uint mask) {
+        return Blocks(top, ray, mask) ||
+               (parameters.shared != kNoSharedTop &&
+                Blocks(parameters.tops[parameters.shared], ray, mask));
+    }
+
+    /// @return The nearest hit along the ray in one top level.
+    Hit TraceTop(TopLevel traced, RayDesc ray, uint mask) {
         RayQuery<RAY_FLAG_NONE> query;
         ShapeHit nearest;
-        Run(query, ray, mask, nearest);
+        Run(query, traced, ray, mask, nearest);
         Hit hit = {};
         uint status = query.CommittedStatus();
         hit.found = status != COMMITTED_NOTHING;
@@ -81,7 +111,7 @@ struct RayTracer {
         // A committed instance's values are read only once there is one: lavapipe faults on them
         // after a miss.
         if (hit.found) {
-            hit.instance = parameters.sources[top.first + query.CommittedInstanceIndex()];
+            hit.instance = parameters.sources[traced.first + query.CommittedInstanceIndex()];
             hit.primitive = query.CommittedPrimitiveIndex();
             hit.geometry = query.CommittedInstanceID();
             if (status == COMMITTED_TRIANGLE_HIT) {
@@ -93,11 +123,11 @@ struct RayTracer {
         return hit;
     }
 
-    /// @return Whether anything in `mask` blocks the ray, for visibility.
-    bool TraceAny(RayDesc ray, uint mask) {
+    /// @return Whether anything in `mask` in one top level blocks the ray.
+    bool Blocks(TopLevel traced, RayDesc ray, uint mask) {
         RayQuery<RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH> query;
         ShapeHit nearest;
-        Run(query, ray, mask, nearest);
+        Run(query, traced, ray, mask, nearest);
         return query.CommittedStatus() != COMMITTED_NOTHING;
     }
 
@@ -117,9 +147,9 @@ struct RayTracer {
 
     /// Runs the query; `Flags` may end it at the first hit. NVIDIA's compiler fails on
     /// `CandidateObjectRay*`: the object ray comes from the candidate's matrix instead.
-    void Run<let Flags : int>(inout RayQuery<Flags> query, RayDesc ray, uint mask,
-                              out ShapeHit nearest) {
-        query.TraceRayInline(RaytracingAccelerationStructure(top.address), RAY_FLAG_NONE,
+    void Run<let Flags : int>(inout RayQuery<Flags> query, TopLevel traced, RayDesc ray,
+                              uint mask, out ShapeHit nearest) {
+        query.TraceRayInline(RaytracingAccelerationStructure(traced.address), RAY_FLAG_NONE,
                              mask, ray);
         nearest.t = ray.TMax;
         nearest.normal = float3(0, 0, 1);

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev168}/ernie/shaders/scene/world_layout.slang

@@ -2,9 +2,9 @@
 /// @file world_layout.slang
 /// @brief The top levels' records sorted by world on the device, from each instance row's world:
 /// `Clear` empties every record, `Scatter` puts each row in its world after the shared ones, and
-/// `FillShared` copies the shared rows into every world. Each world's records start `stride`
-/// apart; within a world, its own rows come in no fixed order. The parameters are shared with C++
-/// (instances.cpp).
+/// `FillShared` copies the shared rows into every world, or once into their own top level's
+/// records after every world's. Each world's records start `stride` apart; within a world, its
+/// own rows come in no fixed order. The parameters are shared with C++ (instances.cpp).
 #ifdef __cplusplus
 #pragma once
 #include "ernie/shaders/shared.h"
@@ -29,6 +29,9 @@ struct LayoutParameters {
     uint worldCount;
     uint stride;
     uint sharedCount;
+    /// The first record of the shared rows' own top level, after every world's; `kNoSource`
+    /// when each world's records hold them first.
+    uint sharedFirst;
     /// The threads dispatched, each taking every `threads`th item.
     uint threads;
 };
@@ -40,7 +43,11 @@ struct LayoutParameters {
 [shader("compute")]
 [numthreads(64, 1, 1)]
 void Clear(uint3 id : SV_DispatchThreadID, uniform LayoutParameters parameters) {
-    for (uint i = id.x; i < parameters.worldCount * parameters.stride; i += parameters.threads) {
+    uint records = parameters.worldCount * parameters.stride;
+    if (parameters.sharedFirst != kNoSource) {
+        records += parameters.sharedCount;
+    }
+    for (uint i = id.x; i < records; i += parameters.threads) {
         parameters.sources[i] = kNoSource;
     }
     for (uint i = id.x; i <= parameters.worldCount; i += parameters.threads) {
@@ -56,7 +63,8 @@ void Scatter(uint3 id : SV_DispatchThreadID, uniform LayoutParameters parameters
         if (world < 0) {
             parameters.sharedRows[parameters.cursors.AtomicAdd(parameters.worldCount, 1)] = row;
         } else if (uint(world) < parameters.worldCount) {
-            uint slot = parameters.sharedCount + parameters.cursors.AtomicAdd(uint(world), 1);
+            uint ahead = parameters.sharedFirst == kNoSource ? parameters.sharedCount : 0;
+            uint slot = ahead + parameters.cursors.AtomicAdd(uint(world), 1);
             parameters.sources[uint(world) * parameters.stride + slot] = row;
         }
     }
@@ -65,6 +73,13 @@ void Scatter(uint3 id : SV_DispatchThreadID, uniform LayoutParameters parameters
 [shader("compute")]
 [numthreads(64, 1, 1)]
 void FillShared(uint3 id : SV_DispatchThreadID, uniform LayoutParameters parameters) {
+    if (parameters.sharedFirst != kNoSource) {
+        // Once, in their own top level's records.
+        for (uint i = id.x; i < parameters.sharedCount; i += parameters.threads) {
+            parameters.sources[parameters.sharedFirst + i] = parameters.sharedRows[i];
+        }
+        return;
+    }
     uint count = parameters.worldCount * parameters.sharedCount;
     for (uint i = id.x; i < count; i += parameters.threads) {
         uint world = i / parameters.sharedCount;

{ernie_renderer-0.2.0.dev166 → ernie_renderer-0.2.0.dev168}/tests/render/device_scene_test.cpp

@@ -197,14 +197,23 @@ void ExpectSources(DeviceContext& context, DeviceScene& frame, const Scene& scen
         return part;
     };
     ASSERT_EQ(instances.Worlds().size(), own.size());
-    const std::size_t stride = instances.Records() / own.size();
+    // The shared rows lead each world's records, or have their own after every world's.
+    const std::optional<InstanceTable::WorldRecords> sharedTop = instances.Shared();
+    const std::size_t ahead = sharedTop ? 0 : shared.size();
+    const std::size_t stride =
+        (instances.Records() - (sharedTop ? sharedTop->count : 0)) / own.size();
+    if (sharedTop) {
+        EXPECT_EQ(sharedTop->first, own.size() * stride);
+        EXPECT_EQ(sharedTop->count, shared.size());
+        EXPECT_EQ(sorted(sharedTop->first, sharedTop->first + sharedTop->count), rows(shared));
+    }
     for (std::size_t world = 0; world < own.size(); ++world) {
         const InstanceTable::WorldRecords records = instances.Worlds()[world];
         EXPECT_EQ(records.first, world * stride);
-        EXPECT_EQ(records.count, shared.size() + own[world].size()) << "world " << world;
-        EXPECT_EQ(sorted(records.first, records.first + shared.size()), rows(shared));
-        EXPECT_EQ(sorted(records.first + shared.size(), records.first + records.count),
-                  rows(own[world]))
+        EXPECT_EQ(records.count, ahead + own[world].size()) << "world " << world;
+        EXPECT_EQ(sorted(records.first, records.first + ahead),
+                  sharedTop ? std::vector<std::uint32_t>{} : rows(shared));
+        EXPECT_EQ(sorted(records.first + ahead, records.first + records.count), rows(own[world]))
             << "world " << world;
         for (std::size_t spare = records.first + records.count; spare < (world + 1) * stride;
              ++spare) {
@@ -216,8 +225,14 @@ void ExpectSources(DeviceContext& context, DeviceScene& frame, const Scene& scen
 TEST(DeviceScene, SortsInstancesByWorldOnTheDevice) {
     ERNIE_CONTEXT(context);
     const ShaderCompiler compiler;
-    for (const WorldCapacities capacities : {WorldCapacities{}, WorldCapacities{4, 6}}) {
-        SCOPED_TRACE(capacities.worlds);
+    for (const WorldCapacities capacities :
+         {WorldCapacities{.sharedPrims = SharedPrims::Duplicated},
+          WorldCapacities{4, 6, SharedPrims::Duplicated},
+          WorldCapacities{.sharedPrims = SharedPrims::SharedTopLevel},
+          WorldCapacities{4, 6, SharedPrims::SharedTopLevel}}) {
+        SCOPED_TRACE(
+            std::to_string(capacities.worlds) +
+            (capacities.sharedPrims == SharedPrims::Duplicated ? " duplicated" : " own top level"));
         // Two walls in every world; world 0 has a ball, world 1 none and world 2 three.
         Scene scene;
         Cube::Define(scene, "/Wall0");