ernie-renderer 0.2.0.dev150__tar.gz → 0.2.0.dev151__tar.gz

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev150" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev151" 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.dev150 → ernie_renderer-0.2.0.dev151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev150
+Version: 0.2.0.dev151
 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.dev150 → ernie_renderer-0.2.0.dev151}/benchmarks/render/batch_step.cpp

@@ -25,11 +25,10 @@ namespace ernie::bench {
 namespace {
 
 constexpr int kShapesPerWorld = 8;
-constexpr glm::uvec2 kSize{64, 64};
 
 /// @brief A scene of `worlds` worlds side by side, each with shapes scattered in front of its
-/// camera, and the products rendering every camera's colour and depth.
-void BuildWorlds(Scene& scene, int worlds) {
+/// camera, and the products rendering every camera's colour and depth at `size` pixels.
+void BuildWorlds(Scene& scene, int worlds, glm::uvec2 size) {
     GroundPlane::Define(scene, "/Ground");
     const std::vector<Path> vars{Path("/Render/Vars/Colour"), Path("/Render/Vars/Depth")};
     RenderVar::Define(scene, vars[0]).SetSourceName(std::string(render_vars::kLdrColor));
@@ -58,13 +57,13 @@ void BuildWorlds(Scene& scene, int worlds) {
         products.emplace_back("/Render/View" + std::to_string(world));
         RenderProduct::Define(scene, products.back())
             .SetCamera(camera)
-            .SetResolution(glm::dvec2(kSize))
+            .SetResolution(glm::dvec2(size))
             .SetOrderedVars(vars);
     }
     RenderSettings::Define(scene, "/Render/Settings").SetProducts(products);
 }
 
-Timing StepWorlds(int worlds, double targetMs) {
+Timing StepWorlds(int worlds, glm::uvec2 size, double targetMs) {
     std::unique_ptr<Renderer> renderer;
     try {
         renderer = std::make_unique<Renderer>();
@@ -73,7 +72,7 @@ Timing StepWorlds(int worlds, double targetMs) {
         return {0.0, targetMs};
     }
     Scene scene;
-    BuildWorlds(scene, worlds);
+    BuildWorlds(scene, worlds, size);
     // The first step builds every bottom level; later ones rebuild only the top levels.
     renderer->Step(scene);
     renderer->Context().WaitIdle();
@@ -84,8 +83,10 @@ Timing StepWorlds(int worlds, double targetMs) {
                                   renderer->Step(scene);
                                   renderer->Context().WaitIdle();
                               });
-    std::printf("  %d views of %u x %u: %.0f views a second, %.2f ms submitting, on %s\n", worlds,
-                kSize.x, kSize.y, 1000.0 * worlds / ms, host,
+    const double pixels = static_cast<double>(worlds) * size.x * size.y;
+    std::printf("  %d views of %u x %u: %.0f views, %.2f gigapixels a second, %.2f ms submitting, "
+                "on %s\n",
+                worlds, size.x, size.y, 1000.0 * worlds / ms, pixels / ms / 1e6, host,
                 renderer->Context().Info().name.c_str());
     if (std::getenv("ERNIE_BENCH_PROFILE") != nullptr) {
         profiler::SetEnabled(true);
@@ -105,10 +106,17 @@ Timing StepWorlds(int worlds, double targetMs) {
     return {ms, targetMs};
 }
 
-const bool kBatch1k =
-    Register("render.batch_step.1024_worlds_64x64", [] { return StepWorlds(1024, 5.0); });
-const bool kBatch4k =
-    Register("render.batch_step.4096_worlds_64x64", [] { return StepWorlds(4096, 20.0); });
+/// Registers a step of `worlds` views of `side` x `side` pixels.
+bool RegisterBatch(int worlds, std::uint32_t side, double targetMs) {
+    return Register("render.batch_step." + std::to_string(worlds) + "_worlds_" +
+                        std::to_string(side) + "x" + std::to_string(side),
+                    [=] { return StepWorlds(worlds, glm::uvec2(side), targetMs); });
+}
+
+// Madrona's benchmark resolutions, then beyond, at 1024 worlds; and many worlds at 64 x 64.
+const bool kBatches = RegisterBatch(1024, 64, 5.0) && RegisterBatch(1024, 128, 15.0) &&
+                      RegisterBatch(1024, 256, 50.0) && RegisterBatch(1024, 512, 200.0) &&
+                      RegisterBatch(4096, 64, 20.0);
 
 }  // namespace
 }  // namespace ernie::bench

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/ernie/python/render.cpp

@@ -116,12 +116,19 @@ void BindRender(nb::module_& module) {
                                "rendering the same scene again costs only what changed.")
         .def(
             "__init__",
-            [](PythonRenderer* self, const std::string& device, bool validation) {
-                new (self)
-                    PythonRenderer(RendererOptions{.device = device, .validation = validation});
+            [](PythonRenderer* self, const std::string& device, bool validation,
+               std::uint32_t worlds, std::uint32_t instancesPerWorld, std::uint32_t views) {
+                new (self) PythonRenderer(RendererOptions{
+                    .device = device,
+                    .validation = validation,
+                    .capacities = {
+                        .worlds = worlds, .instancesPerWorld = instancesPerWorld, .views = views}});
             },
             nb::kw_only(), nb::arg("device") = "", nb::arg("validation") = false,
-            "Opens a device that ray traces: by UUID or part of its name, or the best one.")
+            nb::arg("worlds") = 0, nb::arg("instances_per_world") = 0, nb::arg("views") = 0,
+            "Opens a device that ray traces: by UUID or part of its name, or the best one. "
+            "worlds, instances_per_world and views declare the most the scene holds, laid out "
+            "once; a scene beyond them raises. 0 is as many as there are.")
         .def(
             "render",
             [](PythonRenderer& self, Scene& scene) { return ToNumpy(self.renderer.Render(scene)); },
@@ -138,12 +145,12 @@ void BindRender(nb::module_& module) {
             "and vars in one dispatch, and returns the RenderBatches without waiting: their vars "
             "are device columns that torch.from_dlpack views in place, or read() copies.")
         .def(
-            "bind_transform_op",
+            "bind_column",
             [](nb::object self, Scene& scene, const std::string& prim,
                const std::string& attribute) {
                 auto& renderer = nb::cast<PythonRenderer&>(self);
                 const DeviceColumn& bound =
-                    renderer.renderer.BindTransformOp(scene, Path(prim), attribute);
+                    renderer.renderer.BindColumn(scene, Path(prim), attribute);
                 auto* column = new Column(renderer.Pair(), bound, {}, Ticket{});
                 column->keeper = self;
                 nb::object handle = nb::cast(column, nb::rv_policy::take_ownership);
@@ -151,10 +158,10 @@ void BindRender(nb::module_& module) {
                 return handle;
             },
             nb::arg("scene"), nb::arg("prim"), nb::arg("attribute"),
-            "Hands a transform op (such as xformOp:translate) of every prim in the prim's bucket "
-            "to the device: returns its DeviceColumn, a row a prim in the bucket's order, which "
-            "PyTorch or Warp write in place; call ready(stream) after writing, and the next step "
-            "renders the new poses with no copy through the host.");
+            "Hands a transform op (such as xformOp:translate) or primvars:displayColor of every "
+            "prim in the prim's bucket to the device: returns its DeviceColumn, a row a prim in "
+            "the bucket's order, which PyTorch or Warp write in place; call ready(stream) after "
+            "writing, and the next step renders the new values with no copy through the host.");
 }
 
 }  // namespace ernie::python

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/ernie/render/device_scene.cpp

@@ -9,10 +9,10 @@
 namespace ernie {
 
 DeviceScene::DeviceScene(DeviceContext& context, Arenas& arenas, const Scene& scene,
-                         const ShaderCompiler& compiler)
+                         const ShaderCompiler& compiler, WorldCapacities capacities)
     : context_(context), scene_(scene), pool_(context), columns_(context, arenas, scene),
       transforms_(context, arenas, scene, compiler), geometry_(context, arenas, scene),
-      instances_(context, arenas) {
+      instances_(context, arenas, scene, compiler, capacities) {
     if (context.Capabilities().rayQuery) {
         tracer_ = std::make_unique<RayTracer>(context, arenas, compiler, geometry_);
     }

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/ernie/render/device_scene.h

@@ -33,8 +33,9 @@ namespace ernie {
 class DeviceScene {
   public:
     /// @param arenas Where the device columns live; `MemoryUse::Shared` to share them with CUDA.
+    /// @param capacities The worlds and instances a world declared up front, if any.
     DeviceScene(DeviceContext& context, Arenas& arenas, const Scene& scene,
-                const ShaderCompiler& compiler);
+                const ShaderCompiler& compiler, WorldCapacities capacities = {});
     DeviceScene(const DeviceScene&) = delete;
     DeviceScene& operator=(const DeviceScene&) = delete;
 

ernie_renderer-0.2.0.dev151/ernie/render/instances.cpp

@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file instances.cpp
+/// @brief Keeping instance rows dense as prims come and go, and uploading the rows that changed.
+#include "ernie/render/instances.h"
+
+#include "ernie/shaders/device/buffer_ref.h"
+#include "ernie/shaders/scene/instance_colours.h"
+#include "ernie/util/math.h"
+#include "ernie/util/profiler.h"
+
+#include <algorithm>
+#include <stdexcept>
+#include <string>
+
+namespace ernie {
+namespace {
+
+static_assert(shaders::kNoInstanceRow == InstanceTable::kNoRow);
+
+std::vector<std::uint32_t> CompileColourer(const ShaderCompiler& compiler) {
+    const std::array modules{shaders::kBufferRef, shaders::kInstanceColours};
+    return compiler.Spirv(modules, "main");
+}
+
+}  // namespace
+
+InstanceTable::InstanceTable(DeviceContext& context, Arenas& arenas, const Scene& scene,
+                             const ShaderCompiler& compiler, WorldCapacities capacities)
+    : context_(context), arenas_(arenas), scene_(scene), capacities_(capacities),
+      colourer_(context, CompileColourer(compiler), "instance colours",
+                std::uint32_t{sizeof(shaders::ColourParameters)}),
+      uploader_(context, context.Main()) {
+    const auto column = [&](std::string_view name, DType type, std::vector<std::int64_t> element) {
+        return std::make_unique<DeviceColumn>(arenas, name, type, std::move(element), 0);
+    };
+    nodes_ = column("instance nodes", DType::UInt32, {});
+    geometries_ = column("instance geometries", DType::UInt32, {});
+    shapes_ = column("instance shapes", DType::Float32, {3, 4});
+    colours_ = column("instance colours", DType::Float32, {3});
+    sources_ = column("top-level sources", DType::UInt32, {});
+}
+
+std::optional<std::uint32_t> InstanceTable::Row(PrimId prim) const {
+    if (prim.slot >= rows_.size() || rows_[prim.slot] == kNoRow ||
+        !(prims_[rows_[prim.slot]] == prim)) {
+        return std::nullopt;
+    }
+    return rows_[prim.slot];
+}
+
+void InstanceTable::Set(std::uint32_t row, const PrimGeometry& placed) {
+    prims_[row] = placed.prim;
+    hostNodes_[row] = placed.prim.slot;
+    hostGeometries_[row] = placed.geometry;
+    hostShapes_[row] = ToAffineRows(placed.shape);
+    hostColours_[row] = placed.colour;
+    relayout_ = relayout_ || hostWorlds_[row] != placed.world;
+    hostWorlds_[row] = placed.world;
+    rows_[placed.prim.slot] = row;
+    dirty_.push_back(row);
+}
+
+void InstanceTable::Remove(PrimId prim) {
+    const std::optional<std::uint32_t> row = Row(prim);
+    if (!row) {
+        return;
+    }
+    // The last row moves into the gap.
+    const auto last = static_cast<std::uint32_t>(prims_.size() - 1);
+    if (*row != last) {
+        ForEachHostColumn([&](auto& column) { column[*row] = column[last]; });
+        rows_[prims_[*row].slot] = *row;
+        dirty_.push_back(*row);
+    }
+    rows_[prim.slot] = kNoRow;
+    ForEachHostColumn([](auto& column) { column.pop_back(); });
+    relayout_ = true;
+}
+
+void InstanceTable::LayOutWorlds() {
+    std::int32_t highest = 0;
+    std::vector<std::uint32_t> shared;
+    for (std::uint32_t row = 0; row < hostWorlds_.size(); ++row) {
+        highest = std::max(highest, hostWorlds_[row]);
+        if (hostWorlds_[row] < 0) {
+            shared.push_back(row);
+        }
+    }
+    const std::size_t needed =
+        std::max<std::size_t>(static_cast<std::size_t>(highest) + 1, reserved_);
+    if (capacities_.worlds > 0 && needed > capacities_.worlds) {
+        throw std::length_error(std::to_string(needed) + " worlds are more than the " +
+                                std::to_string(capacities_.worlds) + " declared");
+    }
+    const std::size_t count = capacities_.worlds > 0 ? capacities_.worlds : needed;
+    std::vector<std::vector<std::uint32_t>> own(count);
+    for (std::uint32_t row = 0; row < hostWorlds_.size(); ++row) {
+        if (hostWorlds_[row] >= 0) {
+            own[static_cast<std::size_t>(hostWorlds_[row])].push_back(row);
+        }
+    }
+    const std::uint32_t stride = capacities_.instancesPerWorld;
+    worlds_.assign(count, {});
+    hostSources_.clear();
+    for (std::size_t world = 0; world < count; ++world) {
+        const auto records = static_cast<std::uint32_t>(shared.size() + own[world].size());
+        if (stride > 0 && records > stride) {
+            throw std::length_error("World " + std::to_string(world) + " has " +
+                                    std::to_string(records) + " instances, beyond the " +
+                                    std::to_string(stride) + " declared a world");
+        }
+        worlds_[world] = {.first = static_cast<std::uint32_t>(hostSources_.size()),
+                          .count = records};
+        hostSources_.insert(hostSources_.end(), shared.begin(), shared.end());
+        hostSources_.insert(hostSources_.end(), own[world].begin(), own[world].end());
+        if (stride > 0) {
+            hostSources_.resize(worlds_[world].first + stride, kNoRow);
+        }
+    }
+}
+
+void InstanceTable::Apply(const GeometryPool::Changes& changes) {
+    ERNIE_ZONE("Update instances");
+    for (const PrimId prim : changes.removed) {
+        Remove(prim);
+    }
+    for (const PrimGeometry& placed : changes.placed) {
+        if (placed.prim.slot >= rows_.size()) {
+            rows_.resize(placed.prim.slot + 1, kNoRow);
+        }
+        const std::optional<std::uint32_t> row = Row(placed.prim);
+        if (row) {
+            Set(*row, placed);
+            continue;
+        }
+        ForEachHostColumn([](auto& column) { column.emplace_back(); });
+        relayout_ = true;
+        Set(static_cast<std::uint32_t>(prims_.size() - 1), placed);
+    }
+}
+
+void InstanceTable::AddUploads(graph::Graph& graph) {
+    // Rows that came, went or moved move the bound colours' targets too.
+    retarget_ = retarget_ || relayout_;
+    const std::size_t rows = prims_.size();
+    for (DeviceColumn* column : {nodes_.get(), geometries_.get(), shapes_.get(), colours_.get()}) {
+        column->Resize(rows, context_.Main());
+    }
+    StageRows(uploader_, *nodes_, hostNodes_, dirty_);
+    StageRows(uploader_, *geometries_, hostGeometries_, dirty_);
+    StageRows(uploader_, *shapes_, hostShapes_, dirty_);
+    StageRows(uploader_, *colours_, hostColours_, dirty_);
+    dirty_.clear();
+    if (relayout_) {
+        LayOutWorlds();
+        sources_->Resize(hostSources_.size(), context_.Main());
+        uploader_.Write(sources_->Storage(), sources_->Range().offset,
+                        std::span<const std::uint32_t>(hostSources_));
+        relayout_ = false;
+    }
+    if (retarget_) {
+        TargetColours();
+    }
+    std::vector<graph::Buffer> columns{graph.Import(*nodes_), graph.Import(*geometries_),
+                                       graph.Import(*shapes_), graph.Import(*colours_),
+                                       graph.Import(*sources_)};
+    for (const ColourBinding& binding : colourBindings_) {
+        columns.push_back(graph.Import(*binding.targets));
+    }
+    graph::AddUploadPass(graph, "Upload instances", uploader_, columns);
+    AddColourPasses(graph);
+}
+
+void InstanceTable::BindColours(BucketId bucket, const DeviceColumn& column) {
+    if (column.Type() != DType::Float32 || column.Element() != std::vector<std::int64_t>{3}) {
+        throw std::invalid_argument(column.Name() + " does not hold three floats a row");
+    }
+    colourBindings_.push_back(
+        {.bucket = bucket,
+         .column = &column,
+         .targets = std::make_unique<DeviceColumn>(arenas_, "colour targets", DType::UInt32,
+                                                   std::vector<std::int64_t>{}, 0)});
+    retarget_ = true;
+}
+
+void InstanceTable::TargetColours() {
+    for (ColourBinding& binding : colourBindings_) {
+        const Bucket& bucket = scene_.Store().GetBucket(binding.bucket);
+        binding.hostTargets.resize(bucket.Rows());
+        for (std::uint32_t row = 0; row < bucket.Rows(); ++row) {
+            binding.hostTargets[row] = Row(bucket.prims[row]).value_or(kNoRow);
+        }
+        binding.targets->Resize(bucket.Rows(), context_.Main());
+        uploader_.Write(binding.targets->Storage(), binding.targets->Range().offset,
+                        std::span<const std::uint32_t>(binding.hostTargets));
+    }
+    retarget_ = false;
+}
+
+void InstanceTable::AddColourPasses(graph::Graph& graph) const {
+    for (const ColourBinding& binding : colourBindings_) {
+        const std::array reads{graph.Import(*binding.column), graph.Import(*binding.targets)};
+        graph::Buffer colours = graph.Import(*colours_);
+        const auto count = static_cast<std::uint32_t>(binding.hostTargets.size());
+        graph.Add(
+            "Bound colours", graph::Kind::Compute,
+            [&](graph::PassBuilder& pass) {
+                for (const graph::Buffer& read : reads) {
+                    pass.ReadAddress(read);
+                }
+                colours = pass.WriteAddress(colours);
+            },
+            [this, reads, colours, count](graph::PassContext& pass) {
+                colourer_.Dispatch(pass.commands, {DivideRoundUp(count, 64u), 1, 1},
+                                   shaders::ColourParameters{
+                                       .from = pass.Get(reads[0]).BufferRef<float>(),
+                                       .targets = pass.Get(reads[1]).BufferRef<shaders::uint>(),
+                                       .to = pass.Get(colours).BufferRef<float>(),
+                                       .count = count});
+            });
+    }
+}
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/ernie/render/instances.h

@@ -5,6 +5,8 @@
 #pragma once
 
 #include "ernie/device/column.h"
+#include "ernie/device/kernel.h"
+#include "ernie/device/shader_compiler.h"
 #include "ernie/device/staging.h"
 #include "ernie/graph/graph.h"
 #include "ernie/render/geometry.h"
@@ -28,9 +30,19 @@ namespace ernie {
 /// Each row is in a batch world, or in every world. The top levels' records, a world after
 /// another, are laid out by `Sources`: each world's records are the shared rows, then its own.
 /// The layout changes only as rows come, go or change world.
+/// @brief How many worlds and instances a world the device scene holds at most, declared up front
+/// 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.
+    std::uint32_t instancesPerWorld = 0;
+};
+
 class InstanceTable {
   public:
     using Shape = std::array<glm::vec4, 3>;
+    /// What a record holds when its world has fewer instances than its capacity.
+    static constexpr std::uint32_t kNoRow = 0xffffffff;
     /// A world's records: the first, and how many.
     struct WorldRecords {
         std::uint32_t first = 0;
@@ -38,14 +50,23 @@ class InstanceTable {
     };
 
     /// @param arenas Where the columns live.
-    InstanceTable(DeviceContext& context, Arenas& arenas);
+    /// @param capacities With instances a world declared, each world's records start a fixed
+    /// stride apart, the unused ones `kNoRow`.
+    InstanceTable(DeviceContext& context, Arenas& arenas, const Scene& scene,
+                  const ShaderCompiler& compiler, WorldCapacities capacities = {});
     InstanceTable(const InstanceTable&) = delete;
     InstanceTable& operator=(const InstanceTable&) = delete;
 
     /// @brief Takes in what a geometry update placed and removed.
     void Apply(const GeometryPool::Changes& changes);
-    /// @brief Adds the pass that uploads changed rows, before the passes that read the columns.
+    /// @brief Adds the pass that uploads changed rows, then one copying each bound colour column
+    /// into the colours, before the passes that read the columns.
     void AddUploads(graph::Graph& graph);
+    /// @brief Takes a bucket's colours from `column` each frame, three floats a bucket row as
+    /// `SceneColumns` keeps them, in place of the host's display colours: CUDA or a kernel
+    /// writing it recolours the prims with nothing through the host.
+    /// @throws std::invalid_argument unless `column` holds three floats a row.
+    void BindColours(BucketId bucket, const DeviceColumn& column);
 
     std::uint32_t Count() const {
         return static_cast<std::uint32_t>(prims_.size());
@@ -74,18 +95,33 @@ class InstanceTable {
     std::span<const WorldRecords> Worlds() const {
         return worlds_;
     }
-    /// @return Each top-level record's instance row, a uint32 a record, world after world.
+    /// @return Each top-level record's instance row, a uint32 a record, world after world;
+    /// `kNoRow` for a record no instance fills.
     const DeviceColumn& Sources() const {
         return *sources_;
     }
+    const WorldCapacities& Capacities() const {
+        return capacities_;
+    }
     /// @return The records of every world.
     std::uint32_t Records() const {
         return static_cast<std::uint32_t>(hostSources_.size());
     }
 
   private:
+    /// A bucket's colours bound to a device column, and each bucket row's instance row.
+    struct ColourBinding {
+        BucketId bucket = 0;
+        const DeviceColumn* column = nullptr;
+        std::vector<std::uint32_t> hostTargets;
+        std::unique_ptr<DeviceColumn> targets;
+    };
+
     /// Lays the records out again, world by world.
     void LayOutWorlds();
+    /// Maps each bound bucket's rows to instance rows again, after rows moved.
+    void TargetColours();
+    void AddColourPasses(graph::Graph& graph) const;
     void Set(std::uint32_t row, const PrimGeometry& placed);
     void Remove(PrimId prim);
     /// Calls `f` with each host array kept a row an instance, so they grow and shrink together.
@@ -99,7 +135,14 @@ class InstanceTable {
     }
 
     DeviceContext& context_;
+    Arenas& arenas_;
+    const Scene& scene_;
+    WorldCapacities capacities_;
+    ComputeKernel colourer_;
     Uploader uploader_;
+    std::vector<ColourBinding> colourBindings_;
+    /// Whether rows moved since the colour bindings were mapped.
+    bool retarget_ = false;
     // Host copies of the rows, by row.
     std::vector<PrimId> prims_;
     std::vector<std::uint32_t> hostNodes_;
@@ -111,7 +154,7 @@ class InstanceTable {
     std::vector<std::uint32_t> rows_;
     std::vector<std::uint32_t> dirty_;
     /// Whether rows came, went, moved or changed world since the layout.
-    bool relayout_ = false;
+    bool relayout_ = true;
     std::uint32_t reserved_ = 1;
     std::vector<WorldRecords> worlds_{1};
     std::vector<std::uint32_t> hostSources_;

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/ernie/render/renderer.cpp

@@ -10,6 +10,7 @@
 #include "ernie/render/device_scene.h"
 #include "ernie/render/products.h"
 #include "ernie/render/rt/camera_pass.h"
+#include "ernie/scene/schema/geom.h"
 #include "ernie/scene/schema/render.h"
 #include "ernie/util/profiler.h"
 
@@ -78,6 +79,7 @@ const RenderVarOutput* RenderBatch::Find(std::string_view name) const {
 /// What a renderer keeps on its device.
 struct Renderer::Device {
     ShaderCompiler compiler;
+    RenderCapacities capacities;
     std::unique_ptr<DeviceContext> context;
     /// Where the device scene and outputs live: shared with CUDA where the device can export
     /// memory, so bound columns and outputs map in place.
@@ -105,6 +107,10 @@ struct Renderer::Device {
 };
 
 void Renderer::Device::Plan(const Scene& scene, const std::vector<ProductSpec>& specs) {
+    if (capacities.views > 0 && specs.size() > capacities.views) {
+        throw std::length_error(std::to_string(specs.size()) + " products are more than the " +
+                                std::to_string(capacities.views) + " views declared");
+    }
     const std::vector<std::vector<const ProductSpec*>> groups = GroupProducts(specs);
     std::vector<Batch> planned(groups.size());
     for (std::size_t i = 0; i < groups.size(); ++i) {
@@ -154,6 +160,7 @@ void Renderer::Device::Allocate(Batch& batch, const std::vector<std::string>& va
 
 Renderer::Renderer(const RendererOptions& options) : device_(std::make_unique<Device>()) {
     Device& device = *device_;
+    device.capacities = options.capacities;
     device.context = std::make_unique<DeviceContext>(
         DeviceContextOptions{.validation = options.validation, .device = options.device});
     if (!device.context->Capabilities().rayQuery) {
@@ -179,7 +186,10 @@ DeviceContext& Renderer::Context() {
 DeviceScene& Renderer::Device::Follow(const Scene& scene) {
     if (scene.Id() != sceneId) {
         context->WaitIdle();
-        deviceScene = std::make_unique<DeviceScene>(*context, *arenas, scene, compiler);
+        deviceScene = std::make_unique<DeviceScene>(
+            *context, *arenas, scene, compiler,
+            WorldCapacities{.worlds = capacities.worlds,
+                            .instancesPerWorld = capacities.instancesPerWorld});
         sceneId = scene.Id();
         batches.clear();
         rendered.clear();
@@ -220,12 +230,21 @@ std::span<const RenderBatch> Renderer::Step(Scene& scene) {
     return device.rendered;
 }
 
-const DeviceColumn& Renderer::BindTransformOp(Scene& scene, const Path& prim,
-                                              std::string_view attribute) {
+const DeviceColumn& Renderer::BindColumn(Scene& scene, const Path& prim,
+                                         std::string_view attribute) {
+    const bool colour = attribute == Gprim::kDisplayColor;
+    if (!colour && !attribute.starts_with("xformOp:")) {
+        throw std::invalid_argument(std::string(attribute) +
+                                    " is no transform op or display colour to bind");
+    }
     DeviceScene& deviceScene = device_->Follow(scene);
     const BucketId bucket = scene.Store().PrimBucket(scene.Require(prim));
     const DeviceColumn& column = deviceScene.Columns().Bind(bucket, attribute);
-    deviceScene.Transforms().Bind(bucket, attribute, column);
+    if (colour) {
+        deviceScene.Instances().BindColours(bucket, column);
+    } else {
+        deviceScene.Transforms().Bind(bucket, attribute, column);
+    }
     ++device_->recorded;
     return column;
 }

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev151}/ernie/render/renderer.h

@@ -29,11 +29,23 @@ class DeviceColumn;
 class DeviceContext;
 struct Ticket;
 
+/// @brief The most a renderer's scene holds, declared up front as batched simulation does: memory
+/// is laid out once, never again as counts move, and a scene beyond it is an error, never cut
+/// short. 0 for as many as there are.
+struct RenderCapacities {
+    std::uint32_t worlds = 0;
+    /// Each world's instances, its own and the shared ones.
+    std::uint32_t instancesPerWorld = 0;
+    /// The products a step renders, a view each.
+    std::uint32_t views = 0;
+};
+
 struct RendererOptions {
     /// The device: its UUID in hex, or part of its name; empty for the best scoring one.
     std::string device;
     /// The Khronos validation layer with synchronization validation, when installed.
     bool validation = false;
+    RenderCapacities capacities;
 };
 
 /// @brief One var of a batch: every view's pixels, stacked on the device.
@@ -74,20 +86,23 @@ class ERNIE_API Renderer {
     /// is submitted. Cameras take their poses from the device's transforms, so poses CUDA writes
     /// move them.
     /// @return The batches, valid until the next step.
-    /// @throws std::invalid_argument as `ReadProducts`.
+    /// @throws std::invalid_argument as `ReadProducts`; std::length_error for a scene beyond the
+    /// declared capacities.
     std::span<const RenderBatch> Step(Scene& scene);
 
     /// @return A var's pixels copied to the host once the last step has rendered them.
     Tensor Read(const RenderVarOutput& var);
 
-    /// @brief Hands a transform op to the device for every prim in `prim`'s bucket (the prims of
-    /// its type and applied schemas), as the device scene's columns bind it: from then on the
-    /// column is what steps read, so CUDA, PyTorch or Warp write poses in place and nothing goes
-    /// through the host. Values the host authors later still overwrite their rows. The op must
-    /// be in the prims' `xformOpOrder`.
+    /// @brief Hands an attribute to the device for every prim in `prim`'s bucket (the prims of its
+    /// type and applied schemas), as the device scene's columns bind it: from then on the column
+    /// is what steps read, so CUDA, PyTorch or Warp write it in place each step, as poses or
+    /// domain randomisation do, and nothing goes through the host. Values the host authors later
+    /// still overwrite their rows. Binds a transform op in the prims' `xformOpOrder`, or
+    /// `primvars:displayColor`.
     /// @return The column, a row a prim in the bucket's row order, in memory CUDA can map.
-    /// @throws std::invalid_argument as `SceneColumns::Bind` and `TransformGraph::Bind`.
-    const DeviceColumn& BindTransformOp(Scene& scene, const Path& prim, std::string_view attribute);
+    /// @throws std::invalid_argument for another attribute, or as `SceneColumns::Bind` and
+    /// `TransformGraph::Bind`.
+    const DeviceColumn& BindColumn(Scene& scene, const Path& prim, std::string_view attribute);
     /// @brief Makes the next step wait on the device for `ticket`, such as CUDA's writes to a
     /// bound column.
     void WaitFor(const Ticket& ticket);