ernie-renderer 0.2.0.dev121__tar.gz → 0.2.0.dev127__tar.gz

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev121
+Version: 0.2.0.dev127
 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.dev121 → ernie_renderer-0.2.0.dev127}/ernie/app/viewer.cpp

@@ -97,7 +97,12 @@ Viewer::Viewer(const Scene& scene, const ViewerOptions& options)
         ERNIE_ZONE("Set up the device scene");
         arenas_ = std::make_unique<Arenas>(*context_, MemoryUse::Device, "scene columns",
                                            std::uint64_t{16} << 20);
-        deviceScene_ = std::make_unique<DeviceScene>(*context_, *arenas_, scene, ShaderCompiler());
+        const ShaderCompiler compiler;
+        deviceScene_ = std::make_unique<DeviceScene>(*context_, *arenas_, scene, compiler);
+        if (deviceScene_->Tracer() != nullptr) {
+            heap_ = std::make_unique<BindlessHeap>(*context_);
+            camera_ = std::make_unique<CameraPass>(*context_, compiler, *heap_);
+        }
         sampler_ = std::make_unique<Sampler>(
             *context_, SamplerDescription{.filter = Filter::Nearest, .address = Address::Clamp},
             "viewport");
@@ -162,6 +167,7 @@ bool Viewer::Step() {
         Ticket drawn;
         {
             ERNIE_ZONE("Run the frame");
+            deviceScene_->Follow(shell_->Camera().Eye());
             drawn =
                 deviceScene_->Execute([&](graph::Graph& graph) { AddPasses(graph, data, *target); },
                                       {}, target->semaphores);
@@ -185,6 +191,9 @@ void Viewer::ShowViewport() {
         context_->Main().Last().Wait();
         if (viewport_) {
             renderer_->RemoveTexture(viewportTexture_);
+            if (heap_) {
+                heap_->RemoveStorageImage(viewportImage_);
+            }
         }
         viewport_ = std::make_unique<DeviceImage>(
             *context_,
@@ -193,6 +202,9 @@ void Viewer::ShowViewport() {
                              .usage = ImageUsage::Sampled | ImageUsage::Storage},
             "Viewport");
         viewportTexture_ = renderer_->AddTexture(viewport_->View(), sampler_->Handle());
+        if (heap_) {
+            viewportImage_ = heap_->AddStorageImage(*viewport_);
+        }
     }
     ImGui::GetBackgroundDrawList()->AddImage(viewportTexture_, position,
                                              {position.x + size.x, position.y + size.y});
@@ -200,18 +212,30 @@ void Viewer::ShowViewport() {
 
 void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
     graph::Image viewport = graph.Import(*viewport_, "viewport");
-    // Until a renderer draws it, the viewport is the theme's colour.
-    graph.Add(
-        "Viewport", graph::Kind::Copy,
-        [&](graph::PassBuilder& pass) { viewport = pass.Write(viewport, graph::Use::CopyDst); },
-        [this, viewport](graph::PassContext& pass) {
-            const glm::vec4 colour = shell_->GetTheme().viewport;
-            const VkClearColorValue clear{.float32 = {colour.r, colour.g, colour.b, colour.a}};
-            const VkImageSubresourceRange all{
-                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1};
-            vkCmdClearColorImage(pass.commands, pass.Get(viewport).Handle(), pass.Layout(viewport),
-                                 &clear, 1, &all);
-        });
+    if (camera_) {
+        const OrbitCamera& orbit = shell_->Camera();
+        CameraOutputs outputs{.colour = viewport,
+                              .colourIndex = viewportImage_,
+                              .background = glm::vec3(shell_->GetTheme().viewport)};
+        camera_->Add(graph,
+                     {.cameraToWorld = orbit.Transform(),
+                      .verticalFov = orbit.verticalFov,
+                      .size = glm::uvec2(viewport_->Description().extent)},
+                     outputs);
+        viewport = *outputs.colour;
+    } else {
+        graph.Add(
+            "Viewport", graph::Kind::Copy,
+            [&](graph::PassBuilder& pass) { viewport = pass.Write(viewport, graph::Use::CopyDst); },
+            [this, viewport](graph::PassContext& pass) {
+                const glm::vec4 colour = shell_->GetTheme().viewport;
+                const VkClearColorValue clear{.float32 = {colour.r, colour.g, colour.b, colour.a}};
+                const VkImageSubresourceRange all{
+                    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1};
+                vkCmdClearColorImage(pass.commands, pass.Get(viewport).Handle(),
+                                     pass.Layout(viewport), &clear, 1, &all);
+            });
+    }
     graph.Add(
         "UI", graph::Kind::Raster,
         [&](graph::PassBuilder& pass) {

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/app/viewer.h

@@ -6,6 +6,8 @@
 
 #include "ernie/app/imgui_backend.h"
 #include "ernie/app/ui.h"
+#include "ernie/device/bindless.h"
+#include "ernie/render/camera_pass.h"
 #include "ernie/render/device_scene.h"
 
 #include <glm/vec2.hpp>
@@ -39,9 +41,9 @@ struct ViewerOptions {
     ShellOptions shell;
 };
 
-/// @brief The viewer on a scene. Each frame takes input, draws the shell's UI, clears the frame
-/// to the theme's viewport colour, draws the UI over it and presents it. Drive it on the thread
-/// that made it.
+/// @brief The viewer on a scene. Each frame takes input, draws the shell's UI, traces the orbit
+/// camera into the viewport (or clears it to the theme's colour on devices without ray queries),
+/// draws the UI over it and presents it. Drive it on the thread that made it.
 class Viewer {
   public:
     /// @param scene Read by the panels; must outlive the viewer.
@@ -87,10 +89,14 @@ class Viewer {
     std::unique_ptr<Shell> shell_;
     std::unique_ptr<Arenas> arenas_;
     std::unique_ptr<DeviceScene> deviceScene_;
-    /// The image the viewport is rendered into, and the UI's texture of it.
+    /// The heap and pass tracing the viewport; null without ray queries.
+    std::unique_ptr<BindlessHeap> heap_;
+    std::unique_ptr<CameraPass> camera_;
+    /// The image the viewport is rendered into, the UI's texture of it, and its storage slot.
     std::unique_ptr<Sampler> sampler_;
     std::unique_ptr<DeviceImage> viewport_;
     ImTextureID viewportTexture_ = 0;
+    BindlessIndex viewportImage_;
     /// The frames the device may still be drawing, oldest first.
     std::deque<Ticket> inFlight_;
     std::uint64_t frames_ = 0;

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/CMakeLists.txt

@@ -2,6 +2,7 @@
 add_library(
     ernie_render
     OBJECT
+    camera_pass.cpp
     device_scene.cpp
     geometry.cpp
     instances.cpp

ernie_renderer-0.2.0.dev127/ernie/render/camera_pass.cpp

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file camera_pass.cpp
+/// @brief Tracing pinhole cameras as a frame-graph pass.
+#include "ernie/render/camera_pass.h"
+
+#include "ernie/device/vulkan.h"
+#include "ernie/render/rt/ray_tracer.h"
+#include "ernie/shaders/device/bindless.h"
+#include "ernie/shaders/sensors/camera.h"
+#include "ernie/shaders/spectral/spectrum.h"
+
+#include <glm/gtc/matrix_access.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <stdexcept>
+#include <vector>
+
+namespace ernie {
+namespace {
+
+constexpr std::uint32_t kNoImage = 0xffffffff;
+
+/// A view as camera.slang's `View` reads it.
+struct ViewRecord {
+    glm::vec4 rows[3];
+    glm::vec2 halfExtent;
+    glm::uvec2 size;
+    glm::vec3 background;
+    std::uint32_t colour;
+    VkDeviceAddress distances, normals, instances, albedos;
+};
+static_assert(sizeof(ViewRecord) == 112);
+
+struct CameraParameters {
+    TracerParameters tracer;
+    VkDeviceAddress views, colours;
+    std::uint32_t count, pad;
+};
+
+/// The most `vkCmdUpdateBuffer` writes at once.
+constexpr std::size_t kUpdateBytes = 65536;
+
+std::vector<std::uint32_t> Compile(const ShaderCompiler& compiler) {
+    std::vector<ShaderModule> modules(RayTracer::Modules().begin(), RayTracer::Modules().end());
+    modules.insert(modules.end(), {shaders::kBindless, shaders::kSpectrum, shaders::kCamera});
+    return compiler.Spirv(modules, "main");
+}
+
+/// @return A view's record, its output addresses left for the pass to fill in once the graph has
+/// placed them.
+ViewRecord Record(const PinholeView& view, const CameraOutputs& outputs, const glm::dvec3& origin) {
+    // Relative to the origin in double, then rounded: values near the camera stay small.
+    const glm::dmat4 relative = glm::translate(glm::dmat4(1.0), -origin) * view.cameraToWorld;
+    const double tangent = std::tan(0.5 * view.verticalFov);
+    const double aspect = static_cast<double>(view.size.x) / static_cast<double>(view.size.y);
+    ViewRecord record{.halfExtent = glm::vec2(tangent * aspect, tangent),
+                      .size = view.size,
+                      .background = outputs.background,
+                      .colour = outputs.colour ? outputs.colourIndex.value : kNoImage};
+    for (int r = 0; r < 3; ++r) {
+        record.rows[r] = glm::vec4(glm::row(relative, r));
+    }
+    return record;
+}
+
+}  // namespace
+
+CameraPass::CameraPass(DeviceContext& context, const ShaderCompiler& compiler,
+                       const BindlessHeap& heap)
+    : kernel_(context, Compile(compiler), "camera", sizeof(CameraParameters), &heap) {}
+
+void CameraPass::Add(graph::Graph& graph, const PinholeView& view, CameraOutputs& outputs) const {
+    CameraView one{view, outputs};
+    Add(graph, std::span(&one, 1));
+    outputs = one.outputs;
+}
+
+void CameraPass::Add(graph::Graph& graph, std::span<CameraView> views) const {
+    const TraceScene* scene = graph.Board().Find<TraceScene>();
+    if (scene == nullptr) {
+        throw std::invalid_argument("A camera pass needs the ray tracer's TraceScene");
+    }
+    if (views.empty()) {
+        return;
+    }
+    std::vector<ViewRecord> records;
+    glm::uvec2 largest{0};
+    for (const CameraView& view : views) {
+        records.push_back(Record(view.view, view.outputs, scene->origin));
+        largest = glm::max(largest, view.view.size);
+    }
+    graph::Buffer staged = graph.Create(records.size() * sizeof(ViewRecord), "camera views");
+    // For the recording to look up: any version of a resource names it.
+    std::vector<CameraOutputs> outputs;
+    for (const CameraView& view : views) {
+        outputs.push_back(view.outputs);
+    }
+    graph.Add(
+        "Camera", graph::Kind::Compute,
+        [&](graph::PassBuilder& pass) {
+            scene->Read(pass);
+            // Written by the pass itself before its dispatch reads it.
+            staged = pass.WriteAddress(staged, graph::Use::StorageWrite);
+            for (CameraView& view : views) {
+                CameraOutputs& output = view.outputs;
+                if (output.colour) {
+                    output.colour = pass.Write(*output.colour, graph::Use::StorageWrite);
+                }
+                for (std::optional<graph::Buffer>* buffer :
+                     {&output.distances, &output.normals, &output.instances, &output.albedos}) {
+                    if (*buffer) {
+                        *buffer = pass.WriteAddress(**buffer, graph::Use::StorageWrite);
+                    }
+                }
+            }
+        },
+        [this, staged, largest, records = std::move(records), outputs = std::move(outputs),
+         parameters =
+             CameraParameters{.tracer = scene->parameters, .colours = scene->colourAddress}](
+            graph::PassContext& pass) mutable {
+            const auto address = [&](const std::optional<graph::Buffer>& buffer) {
+                return buffer ? pass.Get(*buffer).Address() : VkDeviceAddress{0};
+            };
+            for (std::size_t i = 0; i < records.size(); ++i) {
+                records[i].distances = address(outputs[i].distances);
+                records[i].normals = address(outputs[i].normals);
+                records[i].instances = address(outputs[i].instances);
+                records[i].albedos = address(outputs[i].albedos);
+            }
+            // The records hold the outputs' addresses, known only now, so the pass writes them
+            // itself before it reads them.
+            const graph::BufferSlice slice = pass.Get(staged);
+            const auto* bytes = reinterpret_cast<const std::byte*>(records.data());
+            const std::size_t size = records.size() * sizeof(ViewRecord);
+            for (std::size_t at = 0; at < size; at += kUpdateBytes) {
+                vkCmdUpdateBuffer(pass.commands, slice.buffer->Handle(), slice.offset + at,
+                                  std::min(kUpdateBytes, size - at), bytes + at);
+            }
+            Barrier(pass.commands, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT,
+                    VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_STORAGE_READ_BIT);
+            parameters.views = slice.Address();
+            parameters.count = static_cast<std::uint32_t>(records.size());
+            kernel_.Dispatch(pass.commands,
+                             {(largest.x + 7) / 8, (largest.y + 7) / 8, parameters.count},
+                             parameters);
+        });
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev127/ernie/render/camera_pass.h

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file camera_pass.h
+/// @brief Pinhole cameras traced through the scene, every view in one dispatch: a shaded colour
+/// image to look at, and each pixel's distance, normal, instance and albedo in buffers kernels,
+/// CUDA or PyTorch read in place.
+///
+///     CameraOutputs outputs{.colour = graph.Import(image, "colour"), .colourIndex = index};
+///     camera.Add(graph, {.cameraToWorld = orbit.Transform(), .size = {640, 480}}, outputs);
+#pragma once
+
+#include "ernie/device/bindless.h"
+#include "ernie/device/kernel.h"
+#include "ernie/device/shader_compiler.h"
+#include "ernie/graph/graph.h"
+
+#include <glm/mat4x4.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+
+#include <cstdint>
+#include <optional>
+#include <span>
+
+namespace ernie {
+
+/// @brief A pinhole camera in the scene's frame, in double: the pass makes it relative to the
+/// render origin before it rounds to float.
+struct PinholeView {
+    /// Camera to world; the camera looks down -z with +y up, as `glm::lookAtRH`'s inverse.
+    glm::dmat4 cameraToWorld{1.0};
+    /// Radians.
+    double verticalFov = 0.785398;
+    /// Pixels.
+    glm::uvec2 size{1};
+};
+
+/// @brief What a camera pass writes for a view; each left out is not written. Each written one is
+/// replaced by its version after the pass.
+struct CameraOutputs {
+    /// A storage image of the view's size, and its slot in the pass's heap.
+    std::optional<graph::Image> colour;
+    BindlessIndex colourIndex;
+    /// What `colour` shows where nothing is hit, as it is stored.
+    glm::vec3 background{0.0f};
+    /// A float a pixel, row by row: the hit distance in metres, infinity where nothing is hit.
+    std::optional<graph::Buffer> distances;
+    /// Three floats a pixel: the world normal, zero where nothing is hit.
+    std::optional<graph::Buffer> normals;
+    /// A uint32 a pixel: the instance row hit, or `kNoInstance`.
+    std::optional<graph::Buffer> instances;
+    /// `kBands` floats a pixel: the albedo hit, per spectral band; zero where nothing is hit.
+    std::optional<graph::Buffer> albedos;
+};
+
+/// @brief A view and what to write of it.
+struct CameraView {
+    PinholeView view;
+    CameraOutputs outputs;
+};
+
+/// @brief Traces pinhole cameras through the scene the graph's `TraceScene` describes, one ray a
+/// pixel, shading what each hits by its albedo and a headlight.
+class CameraPass {
+  public:
+    static constexpr std::uint32_t kNoInstance = 0xffffffff;
+    /// The spectral bands albedos carry: RGB mode's three, linear sRGB.
+    static constexpr std::uint32_t kBands = 3;
+
+    CameraPass(DeviceContext& context, const ShaderCompiler& compiler, const BindlessHeap& heap);
+
+    /// @brief Adds the pass tracing every view in one dispatch, after the ray tracer's builds.
+    /// @throws std::invalid_argument when the graph has no `TraceScene`.
+    void Add(graph::Graph& graph, std::span<CameraView> views) const;
+    void Add(graph::Graph& graph, const PinholeView& view, CameraOutputs& outputs) const;
+
+  private:
+    ComputeKernel kernel_;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/device_scene.cpp

@@ -3,6 +3,9 @@
 /// @brief Building and running each frame's graph over the device scene.
 #include "ernie/render/device_scene.h"
 
+#include <glm/common.hpp>
+#include <glm/geometric.hpp>
+
 namespace ernie {
 
 DeviceScene::DeviceScene(DeviceContext& context, Arenas& arenas, const Scene& scene,
@@ -15,6 +18,15 @@ DeviceScene::DeviceScene(DeviceContext& context, Arenas& arenas, const Scene& sc
     }
 }
 
+bool DeviceScene::Follow(const glm::dvec3& viewpoint) {
+    if (glm::length(viewpoint - transforms_.Origin()) <= kRebaseDistance) {
+        return false;
+    }
+    ERNIE_ZONE("Rebase the render origin");
+    transforms_.SetOrigin(glm::round(viewpoint / kRebaseDistance) * kRebaseDistance);
+    return true;
+}
+
 Ticket DeviceScene::Execute(const std::function<void(graph::Graph&)>& passes,
                             std::span<const Ticket> waits, BinarySemaphores binary) {
     ERNIE_ZONE("Run a frame");

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/device_scene.h

@@ -54,6 +54,14 @@ class DeviceScene {
     RayTracer* Tracer() {
         return tracer_.get();
     }
+    /// @brief Keeps the render origin near a viewpoint: once it is more than `kRebaseDistance`
+    /// away, the origin moves to the viewpoint snapped to a `kRebaseDistance` grid, so a viewpoint
+    /// hovering at the threshold does not rebase back and forth.
+    /// @return Whether the origin moved.
+    bool Follow(const glm::dvec3& viewpoint);
+    /// Metres: far enough that rebases are rare, near enough that floats there resolve 0.1 mm.
+    static constexpr double kRebaseDistance = 1024.0;
+
     /// @return Where the frames' transients come from.
     graph::TransientPool& Pool() {
         return pool_;

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/geometry.cpp

@@ -47,6 +47,20 @@ double Number(const Scene& scene, PrimId prim, std::string_view attribute) {
     return *number;
 }
 
+/// @return The prim's display colour, authored in double or float precision.
+glm::vec3 DisplayColour(const Scene& scene, PrimId prim) {
+    const std::optional<Value> value = scene.GetOrFallback(prim, Gprim::kDisplayColor);
+    if (value) {
+        if (const auto* colour = value->Get<glm::dvec3>()) {
+            return glm::vec3(*colour);
+        }
+        if (const auto* colour = value->Get<glm::vec3>()) {
+            return *colour;
+        }
+    }
+    return glm::vec3(0.5f);
+}
+
 /// @return The turn taking a unit shape's +z to the prim's axis, cyclically, keeping handedness.
 glm::dmat4 AxisTurn(const Scene& scene, PrimId prim) {
     const std::optional<Value> axis = scene.GetOrFallback(prim, Cylinder::kAxis);
@@ -102,9 +116,17 @@ struct Touched {
     bool shape = false;
     bool points = false;
     bool topology = false;
+    bool colour = false;
+
+    bool Any() const {
+        return shape || points || topology || colour;
+    }
 };
 
 Touched Classify(std::string_view attribute) {
+    if (attribute == Gprim::kDisplayColor) {
+        return {.colour = true};
+    }
     if (attribute == Mesh::kPoints) {
         return {.points = true};
     }
@@ -226,7 +248,7 @@ void GeometryPool::UploadMesh(PrimId prim, GeometryId id, bool topology, Changes
     }
 }
 
-void GeometryPool::Place(PrimId prim, bool topology, Changes& changes) {
+void GeometryPool::Place(PrimId prim, bool points, bool topology, Changes& changes) {
     const std::optional<GeometryKind> kind = KindHeld(scene_, prim);
     if (!kind) {
         return;
@@ -239,7 +261,9 @@ void GeometryPool::Place(PrimId prim, bool topology, Changes& changes) {
     PrimGeometry next{.prim = prim};
     if (*kind == GeometryKind::Triangles) {
         next.geometry = known ? placed->geometry : Allocate({.kind = GeometryKind::Triangles});
-        UploadMesh(prim, next.geometry, topology || !known, changes);
+        if (!known || points || topology) {
+            UploadMesh(prim, next.geometry, topology || !known, changes);
+        }
     } else if (*kind == GeometryKind::Capsule) {
         const double radius = Number(scene_, prim, Capsule::kRadius);
         const auto halfLength =
@@ -262,7 +286,9 @@ void GeometryPool::Place(PrimId prim, bool topology, Changes& changes) {
         }
     }
     next.shape = ShapeTransform(scene_, prim, *kind);
-    if (!known || placed->geometry != next.geometry || placed->shape != next.shape) {
+    next.colour = DisplayColour(scene_, prim);
+    if (!known || placed->geometry != next.geometry || placed->shape != next.shape ||
+        placed->colour != next.colour) {
         changes.placed.push_back(next);
     }
     placed = next;
@@ -287,7 +313,7 @@ GeometryPool::Changes GeometryPool::Update() {
         }
     }
     for (const PrimId prim : followed.added) {
-        Place(prim, true, changes);
+        Place(prim, true, true, changes);
     }
     // Prims just added were placed from all their values: none of them is an edit.
     std::vector<bool> fresh(prims_.size(), false);
@@ -296,10 +322,10 @@ GeometryPool::Changes GeometryPool::Update() {
             fresh[prim.slot] = true;
         }
     }
-    // Values the host authored: shapes, points and topology.
+    // Values the host authored: shapes, points, topology and colours.
     for (const ChangeSet::Values& values : changeSet.values) {
         const Touched touched = Classify(store.Tokens().Text(values.attribute));
-        if (!touched.shape && !touched.points && !touched.topology) {
+        if (!touched.Any()) {
             continue;
         }
         const Bucket& bucket = store.GetBucket(values.bucket);
@@ -307,7 +333,7 @@ GeometryPool::Changes GeometryPool::Update() {
             for (std::uint32_t row = range.begin; row < std::min(range.end, bucket.Rows()); ++row) {
                 const PrimId prim = bucket.prims[row];
                 if (Find(prim) && !fresh[prim.slot]) {
-                    Place(prim, touched.topology, changes);
+                    Place(prim, touched.points, touched.topology, changes);
                 }
             }
         }

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/geometry.h

@@ -60,6 +60,8 @@ struct PrimGeometry {
     PrimId prim;
     GeometryId geometry = 0;
     glm::dmat4 shape{1.0};
+    /// Its albedo in linear RGB, from `primvars:displayColor`, until materials bind one.
+    glm::vec3 colour{0.5f};
 };
 
 /// @brief The scene's gprims as device geometry. Implicit shapes share one unit geometry a kind
@@ -71,7 +73,7 @@ class GeometryPool {
   public:
     /// @brief What an update changed, for the bottom levels and instances that follow it.
     struct Changes {
-        /// Prims added, or whose geometry or shape changed.
+        /// Prims added, or whose geometry, shape or colour changed.
         std::vector<PrimGeometry> placed;
         std::vector<PrimId> removed;
         /// Geometries new or of new topology, whose bottom levels are built anew.
@@ -109,8 +111,9 @@ class GeometryPool {
     }
 
   private:
-    /// Places a prim: its geometry, built or shared, and its shape transform.
-    void Place(PrimId prim, bool topology, Changes& changes);
+    /// Places a prim: its geometry, built or shared, its shape transform and its colour. A mesh's
+    /// points are uploaded when it is new or `points`, its triangles when `topology`.
+    void Place(PrimId prim, bool points, bool topology, Changes& changes);
     /// @return The unit shape geometry of a kind, made the first time it is asked for.
     GeometryId UnitShape(GeometryKind kind);
     /// @return A new or recycled geometry id.

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/instances.cpp

@@ -33,6 +33,7 @@ InstanceTable::InstanceTable(DeviceContext& context, Arenas& arenas)
     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});
 }
 
 std::optional<std::uint32_t> InstanceTable::Row(PrimId prim) const {
@@ -48,6 +49,7 @@ void InstanceTable::Set(std::uint32_t row, const PrimGeometry& placed) {
     hostNodes_[row] = placed.prim.slot;
     hostGeometries_[row] = placed.geometry;
     hostShapes_[row] = RowMajor(placed.shape);
+    hostColours_[row] = placed.colour;
     rows_[placed.prim.slot] = row;
     dirty_.push_back(row);
 }
@@ -64,6 +66,7 @@ void InstanceTable::Remove(PrimId prim) {
         hostNodes_[*row] = hostNodes_[last];
         hostGeometries_[*row] = hostGeometries_[last];
         hostShapes_[*row] = hostShapes_[last];
+        hostColours_[*row] = hostColours_[last];
         rows_[prims_[*row].slot] = *row;
         dirty_.push_back(*row);
     }
@@ -72,6 +75,7 @@ void InstanceTable::Remove(PrimId prim) {
     hostNodes_.pop_back();
     hostGeometries_.pop_back();
     hostShapes_.pop_back();
+    hostColours_.pop_back();
 }
 
 void InstanceTable::Apply(const GeometryPool::Changes& changes) {
@@ -92,13 +96,14 @@ void InstanceTable::Apply(const GeometryPool::Changes& changes) {
         hostNodes_.emplace_back();
         hostGeometries_.emplace_back();
         hostShapes_.emplace_back();
+        hostColours_.emplace_back();
         Set(static_cast<std::uint32_t>(prims_.size() - 1), placed);
     }
 }
 
 void InstanceTable::AddUploads(graph::Graph& graph) {
     const std::size_t rows = prims_.size();
-    for (DeviceColumn* column : {nodes_.get(), geometries_.get(), shapes_.get()}) {
+    for (DeviceColumn* column : {nodes_.get(), geometries_.get(), shapes_.get(), colours_.get()}) {
         column->Resize(rows, context_.Main());
     }
     std::ranges::sort(dirty_);
@@ -114,10 +119,11 @@ void InstanceTable::AddUploads(graph::Graph& graph) {
     upload(*nodes_, hostNodes_);
     upload(*geometries_, hostGeometries_);
     upload(*shapes_, hostShapes_);
+    upload(*colours_, hostColours_);
     dirty_.clear();
-    std::array columns{graph.Import(*nodes_, nodes_->Name()),
-                       graph.Import(*geometries_, geometries_->Name()),
-                       graph.Import(*shapes_, shapes_->Name())};
+    std::array columns{
+        graph.Import(*nodes_, nodes_->Name()), graph.Import(*geometries_, geometries_->Name()),
+        graph.Import(*shapes_, shapes_->Name()), graph.Import(*colours_, colours_->Name())};
     graph.Add(
         "Upload instances", graph::Kind::Copy,
         [&](graph::PassBuilder& pass) {

{ernie_renderer-0.2.0.dev121 → ernie_renderer-0.2.0.dev127}/ernie/render/instances.h

@@ -18,8 +18,9 @@
 namespace ernie {
 
 /// @brief A row a drawn prim, in device columns: `Nodes` its transform graph slot, `Geometries` its
-/// geometry and `Shapes` the 3x4 row-major transform from that geometry to the prim. Rows are kept
-/// dense by swap-removal, so a row is no stable id; a prim's row is found with `Row`.
+/// geometry, `Shapes` the 3x4 row-major transform from that geometry to the prim, and `Colours` its
+/// linear RGB albedo. Rows are kept dense by swap-removal, so a row is no stable id; a prim's row
+/// is found with `Row`.
 class InstanceTable {
   public:
     using Shape = std::array<float, 12>;
@@ -48,6 +49,9 @@ class InstanceTable {
     const DeviceColumn& Shapes() const {
         return *shapes_;
     }
+    const DeviceColumn& Colours() const {
+        return *colours_;
+    }
 
   private:
     void Set(std::uint32_t row, const PrimGeometry& placed);
@@ -60,12 +64,14 @@ class InstanceTable {
     std::vector<std::uint32_t> hostNodes_;
     std::vector<std::uint32_t> hostGeometries_;
     std::vector<Shape> hostShapes_;
+    std::vector<glm::vec3> hostColours_;
     /// Each prim's row by its id's slot.
     std::vector<std::uint32_t> rows_;
     std::vector<std::uint32_t> dirty_;
     std::unique_ptr<DeviceColumn> nodes_;
     std::unique_ptr<DeviceColumn> geometries_;
     std::unique_ptr<DeviceColumn> shapes_;
+    std::unique_ptr<DeviceColumn> colours_;
 };
 
 }  // namespace ernie