ernie-renderer 0.2.0.dev135__tar.gz → 0.2.0.dev137__tar.gz

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/CMakeLists.txt

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

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

@@ -186,31 +186,35 @@ void Viewer::ShowViewport() {
     const ImVec2 scale = ImGui::GetIO().DisplayFramebufferScale;
     const glm::uvec2 pixels(std::max(1.0f, size.x * scale.x), std::max(1.0f, size.y * scale.y));
     if (!viewport_ || glm::uvec2(viewport_->Description().extent) != pixels) {
-        ERNIE_ZONE("Resize the viewport");
-        // Frames in flight may still sample the old image.
-        context_->Main().Last().Wait();
-        if (viewport_) {
-            renderer_->RemoveTexture(viewportTexture_);
-            if (heap_) {
-                heap_->RemoveStorageImage(viewportImage_);
-            }
-        }
-        viewport_ = std::make_unique<DeviceImage>(
-            *context_,
-            ImageDescription{.format = ImageFormat::Rgba8Unorm,
-                             .extent = {pixels, 1},
-                             .usage = ImageUsage::Sampled | ImageUsage::Storage},
-            "Viewport");
-        viewportTexture_ = renderer_->AddTexture(viewport_->View(), sampler_->Handle());
-        if (heap_) {
-            viewportImage_ = heap_->AddStorageImage(*viewport_);
-        }
+        ResizeViewport(pixels);
     }
     ImGui::GetBackgroundDrawList()->AddImage(viewportTexture_, position,
                                              {position.x + size.x, position.y + size.y});
 }
 
-void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
+void Viewer::ResizeViewport(glm::uvec2 pixels) {
+    ERNIE_ZONE("Resize the viewport");
+    // Frames in flight may still sample the old image.
+    context_->Main().Last().Wait();
+    if (viewport_) {
+        renderer_->RemoveTexture(viewportTexture_);
+        if (heap_) {
+            heap_->RemoveStorageImage(viewportImage_);
+        }
+    }
+    viewport_ = std::make_unique<DeviceImage>(
+        *context_,
+        ImageDescription{.format = ImageFormat::Rgba8Unorm,
+                         .extent = {pixels, 1},
+                         .usage = ImageUsage::Sampled | ImageUsage::Storage},
+        "Viewport");
+    viewportTexture_ = renderer_->AddTexture(viewport_->View(), sampler_->Handle());
+    if (heap_) {
+        viewportImage_ = heap_->AddStorageImage(*viewport_);
+    }
+}
+
+graph::Image Viewer::AddViewportPass(graph::Graph& graph) {
     graph::Image viewport = graph.Import(*viewport_, "viewport");
     if (camera_) {
         const OrbitCamera& orbit = shell_->Camera();
@@ -222,20 +226,24 @@ void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget&
                       .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);
-            });
+        return *outputs.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);
+        });
+    return viewport;
+}
+
+void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
+    const graph::Image viewport = AddViewportPass(graph);
     graph.Add(
         "UI", graph::Kind::Raster,
         [&](graph::PassBuilder& pass) {

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/app/viewer.h

@@ -77,6 +77,12 @@ class Viewer {
     /// @brief Sizes the viewport's image to the dock space's central node and draws it there,
     /// behind the panels.
     void ShowViewport();
+    /// @brief Makes the viewport's image `pixels` in size, in the UI and the heap.
+    void ResizeViewport(glm::uvec2 pixels);
+    /// @brief Adds the pass filling the viewport: traced, or the theme's colour without ray
+    /// queries.
+    /// @return The viewport, filled.
+    graph::Image AddViewportPass(graph::Graph& graph);
     /// @brief Adds the frame's own passes: rendering the viewport, then the UI over the target.
     void AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target);
 

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/device/shader_compiler.cpp

@@ -36,6 +36,14 @@ struct ShaderCompiler::Session {
             throw std::invalid_argument("Compiling no shader modules");
         }
         const std::lock_guard lock(mutex);
+        const Slang::ComPtr<slang::ISession> session = CreateSession(format, profile);
+        slang::IModule* last = LoadModules(*session, modules);
+        return Link(*session, *last, modules.back().name, std::string(entryPoint));
+    }
+
+  private:
+    /// @return A session compiling for the target, the global session started the first time.
+    Slang::ComPtr<slang::ISession> CreateSession(SlangCompileTarget format, const char* profile) {
         if (!global && SLANG_FAILED(slang::createGlobalSession(global.writeRef()))) {
             throw std::runtime_error("Cannot start the Slang shader compiler");
         }
@@ -53,36 +61,45 @@ struct ShaderCompiler::Session {
         if (SLANG_FAILED(global->createSession(description, session.writeRef()))) {
             throw std::runtime_error("Cannot create a Slang session");
         }
+        return session;
+    }
 
+    /// @return The last module, each loaded after the modules it imports.
+    static slang::IModule* LoadModules(slang::ISession& session,
+                                       std::span<const ShaderModule> modules) {
         slang::IModule* last = nullptr;
         for (const ShaderModule& module : modules) {
             Slang::ComPtr<slang::IBlob> diagnostics;
             const std::string path = module.name + ".slang";
-            last = session->loadModuleFromSourceString(
+            last = session.loadModuleFromSourceString(
                 module.name.c_str(), path.c_str(), module.source.c_str(), diagnostics.writeRef());
             if (last == nullptr) {
                 throw std::invalid_argument("Shader module " + module.name +
                                             " failed to compile:\n" + Text(diagnostics));
             }
         }
-        const std::string entry(entryPoint);
+        return last;
+    }
+
+    /// @return The code of `module`'s entry point, linked with what it imports.
+    static Slang::ComPtr<slang::IBlob> Link(slang::ISession& session, slang::IModule& module,
+                                            const std::string& name, const std::string& entry) {
         Slang::ComPtr<slang::IEntryPoint> found;
-        if (SLANG_FAILED(last->findEntryPointByName(entry.c_str(), found.writeRef()))) {
-            throw std::invalid_argument("Shader module " + modules.back().name +
-                                        " has no entry point " + entry);
+        if (SLANG_FAILED(module.findEntryPointByName(entry.c_str(), found.writeRef()))) {
+            throw std::invalid_argument("Shader module " + name + " has no entry point " + entry);
         }
-        std::array<slang::IComponentType*, 2> parts{last, found};
+        std::array<slang::IComponentType*, 2> parts{&module, found};
         Slang::ComPtr<slang::IComponentType> program;
         Slang::ComPtr<slang::IComponentType> linked;
         Slang::ComPtr<slang::IBlob> code;
         Slang::ComPtr<slang::IBlob> diagnostics;
         const bool failed =
-            SLANG_FAILED(session->createCompositeComponentType(
+            SLANG_FAILED(session.createCompositeComponentType(
                 parts.data(), parts.size(), program.writeRef(), diagnostics.writeRef())) ||
             SLANG_FAILED(program->link(linked.writeRef(), diagnostics.writeRef())) ||
             SLANG_FAILED(linked->getEntryPointCode(0, 0, code.writeRef(), diagnostics.writeRef()));
         if (failed) {
-            throw std::invalid_argument("Entry point " + entry + " of " + modules.back().name +
+            throw std::invalid_argument("Entry point " + entry + " of " + name +
                                         " failed to compile:\n" + Text(diagnostics));
         }
         return code;

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/device/staging.h

@@ -8,6 +8,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <memory>
 #include <span>
 #include <vector>
@@ -88,6 +89,13 @@ class Readback {
     }
     /// @return The bytes, waiting for the copy if it is not done.
     std::span<const std::byte> Bytes();
+    /// @return The bytes as `T`s, waiting for the copy if it is not done.
+    template <typename T> std::vector<T> Values() {
+        const std::span<const std::byte> bytes = Bytes();
+        std::vector<T> values(bytes.size() / sizeof(T));
+        std::memcpy(values.data(), bytes.data(), values.size() * sizeof(T));
+        return values;
+    }
 
   private:
     DeviceContext& context_;

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/render/geometry.cpp

@@ -22,7 +22,7 @@ namespace {
 /// Metres from a ground plane's centre to its edges: far past any horizon a camera near it sees.
 constexpr double kGroundHalfWidth = 1e5;
 
-std::optional<GeometryKind> KindHeld(const Scene& scene, PrimId prim) {
+std::optional<GeometryKind> FindGeometryKind(const Scene& scene, PrimId prim) {
     const SchemaDef* schema = scene.Schema(prim);
     const std::array<std::pair<const SchemaDef*, GeometryKind>, 8> kinds{{
         {&Mesh::Definition(), GeometryKind::Triangles},
@@ -42,7 +42,7 @@ std::optional<GeometryKind> KindHeld(const Scene& scene, PrimId prim) {
     return std::nullopt;
 }
 
-double Number(const Scene& scene, PrimId prim, std::string_view attribute) {
+double RequireNumber(const Scene& scene, PrimId prim, std::string_view attribute) {
     const std::optional<Value> value = scene.GetOrFallback(prim, attribute);
     const std::optional<double> number = value ? ToNumber(*value) : std::nullopt;
     if (!number) {
@@ -88,25 +88,26 @@ glm::dmat4 ShapeTransform(const Scene& scene, PrimId prim, GeometryKind kind) {
     };
     switch (kind) {
     case GeometryKind::Sphere:
-        return scaled(glm::dvec3(Number(scene, prim, Sphere::kRadius)));
+        return scaled(glm::dvec3(RequireNumber(scene, prim, Sphere::kRadius)));
     case GeometryKind::Cube:
-        return scaled(glm::dvec3(0.5 * Number(scene, prim, Cube::kSize)));
+        return scaled(glm::dvec3(0.5 * RequireNumber(scene, prim, Cube::kSize)));
     case GeometryKind::Cylinder:
     case GeometryKind::Cone: {
-        const double radius = Number(scene, prim, Cylinder::kRadius);
+        const double radius = RequireNumber(scene, prim, Cylinder::kRadius);
         return AxisTurn(scene, prim) *
-               scaled({radius, radius, 0.5 * Number(scene, prim, Cylinder::kHeight)});
+               scaled({radius, radius, 0.5 * RequireNumber(scene, prim, Cylinder::kHeight)});
     }
     case GeometryKind::Capsule:
-        return AxisTurn(scene, prim) * scaled(glm::dvec3(Number(scene, prim, Capsule::kRadius)));
+        return AxisTurn(scene, prim) *
+               scaled(glm::dvec3(RequireNumber(scene, prim, Capsule::kRadius)));
     case GeometryKind::Plane: {
         if (IsA(scene.Schema(prim), GroundPlane::Definition())) {
             return scaled({kGroundHalfWidth, kGroundHalfWidth, 1.0});
         }
         // Width along x, or z for an X normal; length along y, or z for a Y normal: under the
         // cyclic turn, the unit square's x carries the length unless the normal is z.
-        const double width = 0.5 * Number(scene, prim, Plane::kWidth);
-        const double length = 0.5 * Number(scene, prim, Plane::kLength);
+        const double width = 0.5 * RequireNumber(scene, prim, Plane::kWidth);
+        const double length = 0.5 * RequireNumber(scene, prim, Plane::kLength);
         const glm::dmat4 turn = AxisTurn(scene, prim);
         const bool normalZ = turn[2][2] == 1.0;
         return turn *
@@ -118,8 +119,8 @@ glm::dmat4 ShapeTransform(const Scene& scene, PrimId prim, GeometryKind kind) {
     return glm::dmat4(1.0);
 }
 
-/// @return Whether a changed attribute reshapes a gprim, moves a mesh's points, or remakes its
-/// topology.
+/// What a changed attribute does to a gprim: reshapes it, moves a mesh's points, remakes its
+/// topology, or recolours it.
 struct Touched {
     bool shape = false;
     bool points = false;
@@ -131,7 +132,7 @@ struct Touched {
     }
 };
 
-Touched Classify(std::string_view attribute) {
+Touched ClassifyAttribute(std::string_view attribute) {
     if (attribute == Gprim::kDisplayColor) {
         return {.colour = true};
     }
@@ -257,7 +258,7 @@ void GeometryPool::UploadMesh(PrimId prim, GeometryId id, bool topology, Changes
 }
 
 void GeometryPool::Place(PrimId prim, bool points, bool topology, Changes& changes) {
-    const std::optional<GeometryKind> kind = KindHeld(scene_, prim);
+    const std::optional<GeometryKind> kind = FindGeometryKind(scene_, prim);
     if (!kind) {
         return;
     }
@@ -273,9 +274,9 @@ void GeometryPool::Place(PrimId prim, bool points, bool topology, Changes& chang
             UploadMesh(prim, next.geometry, topology || !known, changes);
         }
     } else if (*kind == GeometryKind::Capsule) {
-        const double radius = Number(scene_, prim, Capsule::kRadius);
+        const double radius = RequireNumber(scene_, prim, Capsule::kRadius);
         const auto halfLength =
-            static_cast<float>(0.5 * Number(scene_, prim, Capsule::kHeight) / radius);
+            static_cast<float>(0.5 * RequireNumber(scene_, prim, Capsule::kHeight) / radius);
         next.geometry = known ? placed->geometry
                               : Allocate({.kind = GeometryKind::Capsule,
                                           .box = arenas_.Allocate(6 * sizeof(float))});
@@ -332,7 +333,7 @@ GeometryPool::Changes GeometryPool::Update() {
     }
     // 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));
+        const Touched touched = ClassifyAttribute(store.Tokens().Text(values.attribute));
         if (!touched.Any()) {
             continue;
         }

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/render/instances.cpp

@@ -13,16 +13,6 @@ namespace {
 
 constexpr std::uint32_t kNoRow = std::numeric_limits<std::uint32_t>::max();
 
-InstanceTable::Shape RowMajor(const glm::dmat4& m) {
-    InstanceTable::Shape rows{};
-    for (int r = 0; r < 3; ++r) {
-        for (int c = 0; c < 4; ++c) {
-            rows[static_cast<std::size_t>(r * 4 + c)] = static_cast<float>(m[c][r]);
-        }
-    }
-    return rows;
-}
-
 }  // namespace
 
 InstanceTable::InstanceTable(DeviceContext& context, Arenas& arenas)
@@ -48,7 +38,7 @@ 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] = RowMajor(placed.shape);
+    hostShapes_[row] = ToAffineRows(placed.shape);
     hostColours_[row] = placed.colour;
     rows_[placed.prim.slot] = row;
     dirty_.push_back(row);

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/render/instances.h

@@ -8,6 +8,7 @@
 #include "ernie/device/staging.h"
 #include "ernie/graph/graph.h"
 #include "ernie/render/geometry.h"
+#include "ernie/util/glm.h"
 
 #include <array>
 #include <cstdint>
@@ -23,7 +24,7 @@ namespace ernie {
 /// is found with `Row`.
 class InstanceTable {
   public:
-    using Shape = std::array<float, 12>;
+    using Shape = std::array<glm::vec4, 3>;
 
     /// @param arenas Where the columns live.
     InstanceTable(DeviceContext& context, Arenas& arenas);

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/render/rt/bottom_levels.cpp

@@ -88,10 +88,21 @@ BottomBuild BottomLevels::Build(GeometryId id, bool refit, std::vector<TriangleG
 
 void BottomLevels::AddBuilds(graph::Graph& graph) {
     ERNIE_ZONE("Prepare the bottom levels");
-    // Compacted sizes that have come back: each level moves into a structure of its size.
-    std::vector<
-        std::pair<std::shared_ptr<AccelerationStructure>, std::shared_ptr<AccelerationStructure>>>
-        compactions;
+    Moves moves = TakeCompactedSizes();
+    FrameBuilds builds = PlanBuilds();
+    Compaction compaction = StartCompactionQuery(builds.built);
+    AddAddressUpload(graph);
+    if (!builds.builds.empty() || !moves.empty()) {
+        AddBuildPass(graph, std::move(builds), std::move(moves), compaction);
+    }
+    if (!compaction.geometries.empty()) {
+        compactions_.push_back(std::move(compaction));
+    }
+}
+
+BottomLevels::Moves BottomLevels::TakeCompactedSizes() {
+    // Each level whose compacted size came back moves into a structure of that size.
+    Moves moves;
     std::erase_if(compactions_, [&](Compaction& compaction) {
         const std::optional<std::vector<std::uint64_t>> sizes = compaction.query->Sizes();
         if (!sizes) {
@@ -110,21 +121,20 @@ void BottomLevels::AddBuilds(graph::Graph& graph) {
                 pool_, sizesCompacted, level.structure->Name() + " compacted");
             ++totals_.compacted;
             totals_.saved += level.structure->Sizes().storage - sizesCompacted.storage;
-            compactions.emplace_back(level.structure, compacted);
+            moves.emplace_back(level.structure, compacted);
             level.structure = compacted;
             SetAddress(compaction.geometries[i], compacted->Address());
         }
         return true;
     });
+    return moves;
+}
 
-    // This frame's builds, under the scratch budget.
-    std::vector<TriangleGeometry> triangles;
-    std::vector<BoxGeometry> boxes;
-    triangles.reserve(pending_.size());
-    boxes.reserve(pending_.size());
-    std::vector<BottomBuild> builds;
-    std::vector<GeometryId> built;
-    std::uint64_t scratch = 0;
+BottomLevels::FrameBuilds BottomLevels::PlanBuilds() {
+    FrameBuilds frame;
+    // Builds point into these, so they hold every geometry without growing.
+    frame.triangles.reserve(pending_.size());
+    frame.boxes.reserve(pending_.size());
     std::vector<Work> later;
     for (const Work& work : pending_) {
         const Geometry& geometry = geometry_.Get(work.geometry);
@@ -143,7 +153,7 @@ void BottomLevels::AddBuilds(graph::Graph& graph) {
                                                 ? Sizes(context_, input.triangles, flags)
                                                 : Sizes(context_, input.boxes, flags);
             // Over the budget, the level keeps tracing as it was until a later frame.
-            if (!builds.empty() && scratch + sizes.buildScratch > scratchBudget_) {
+            if (!frame.builds.empty() && frame.scratch + sizes.buildScratch > scratchBudget_) {
                 later.push_back(work);
                 continue;
             }
@@ -155,16 +165,19 @@ void BottomLevels::AddBuilds(graph::Graph& graph) {
             ++level.refits;
         }
         ++(work.refit ? totals_.refitted : totals_.built);
-        const BottomBuild build = Build(work.geometry, work.refit, triangles, boxes);
-        scratch +=
+        const BottomBuild build = Build(work.geometry, work.refit, frame.triangles, frame.boxes);
+        frame.scratch +=
             work.refit ? build.target->Sizes().updateScratch : build.target->Sizes().buildScratch;
-        builds.push_back(build);
-        built.push_back(work.geometry);
+        frame.builds.push_back(build);
+        frame.built.push_back(work.geometry);
         SetAddress(work.geometry, level.structure->Address());
     }
     pending_ = std::move(later);
+    return frame;
+}
 
-    // Static levels built now have their compacted sizes read back for a later frame.
+BottomLevels::Compaction BottomLevels::StartCompactionQuery(const std::vector<GeometryId>& built) {
+    // Static levels have their compacted sizes read back for a later frame.
     Compaction compaction;
     for (const GeometryId geometry : built) {
         Level& level = levels_[geometry];
@@ -174,30 +187,33 @@ void BottomLevels::AddBuilds(graph::Graph& graph) {
             compaction.structures.push_back(level.structure);
         }
     }
-    CompactionQuery* query = nullptr;
     if (!compaction.geometries.empty()) {
         compaction.query = std::make_unique<CompactionQuery>(
             context_, static_cast<std::uint32_t>(compaction.geometries.size()));
-        query = compaction.query.get();
     }
+    return compaction;
+}
 
-    if (!dirtyAddresses_.empty()) {
-        addresses_->Resize(hostAddresses_.size(), context_.Main());
-        StageRows(uploader_, *addresses_, hostAddresses_, dirtyAddresses_);
-        dirtyAddresses_.clear();
-        graph::Buffer addresses = graph.Import(*addresses_);
-        graph::AddUploadPass(graph, "Upload bottom-level addresses", uploader_,
-                             std::span(&addresses, 1));
-    }
-    if (builds.empty() && compactions.empty()) {
+void BottomLevels::AddAddressUpload(graph::Graph& graph) {
+    if (dirtyAddresses_.empty()) {
         return;
     }
+    addresses_->Resize(hostAddresses_.size(), context_.Main());
+    StageRows(uploader_, *addresses_, hostAddresses_, dirtyAddresses_);
+    dirtyAddresses_.clear();
+    graph::Buffer addresses = graph.Import(*addresses_);
+    graph::AddUploadPass(graph, "Upload bottom-level addresses", uploader_,
+                         std::span(&addresses, 1));
+}
 
+void BottomLevels::AddBuildPass(graph::Graph& graph, FrameBuilds frame, Moves moves,
+                                const Compaction& compaction) {
     graph::Acceleration levels = graph.Import(pool_);
     std::vector<graph::Buffer> inputs = geometry_.Import(graph);
     graph::Buffer scratchBuffer =
-        scratch > 0 ? graph.Create(ScratchBytes(builds, {}), "bottom-level scratch")
-                    : graph::Buffer{};
+        frame.scratch > 0 ? graph.Create(ScratchBytes(frame.builds, {}), "bottom-level scratch")
+                          : graph::Buffer{};
+    CompactionQuery* query = compaction.query.get();
     std::vector<const AccelerationStructure*> queried(compaction.structures.size());
     std::ranges::transform(compaction.structures, queried.begin(),
                            [](const auto& structure) { return structure.get(); });
@@ -213,17 +229,16 @@ void BottomLevels::AddBuilds(graph::Graph& graph) {
             pass.Read(levels, graph::Use::BuildInput);
             levels = pass.Build(levels);
         },
-        [builds = std::move(builds), triangles = std::move(triangles), boxes = std::move(boxes),
-         compactions = std::move(compactions), queried, query,
+        [frame = std::move(frame), moves = std::move(moves), queried, query,
          scratchBuffer](graph::PassContext& pass) {
-            for (const auto& [source, compacted] : compactions) {
+            for (const auto& [source, compacted] : moves) {
                 RecordCompaction(pass.commands, *source, *compacted);
                 // The copy reads the source: it goes once this frame's work is done.
                 pass.Keep(source);
             }
-            if (!builds.empty()) {
+            if (!frame.builds.empty()) {
                 const graph::BufferSlice space = pass.Get(scratchBuffer);
-                RecordBuilds(pass.commands, builds, {}, {space.buffer, space.offset});
+                RecordBuilds(pass.commands, frame.builds, {}, {space.buffer, space.offset});
             }
             if (query != nullptr) {
                 // Sizes are written once the builds are done.
@@ -234,9 +249,6 @@ void BottomLevels::AddBuilds(graph::Graph& graph) {
                 query->Record(pass.commands, queried);
             }
         });
-    if (!compaction.geometries.empty()) {
-        compactions_.push_back(std::move(compaction));
-    }
 }
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/render/rt/bottom_levels.h

@@ -83,12 +83,33 @@ class BottomLevels {
         std::vector<std::shared_ptr<AccelerationStructure>> structures;
     };
 
+    /// Levels moving into compacted copies: each source, then its copy.
+    using Moves = std::vector<
+        std::pair<std::shared_ptr<AccelerationStructure>, std::shared_ptr<AccelerationStructure>>>;
+    /// A frame's builds and refits, and the geometry they read.
+    struct FrameBuilds {
+        std::vector<TriangleGeometry> triangles;
+        std::vector<BoxGeometry> boxes;
+        std::vector<BottomBuild> builds;
+        std::vector<GeometryId> built;
+        std::uint64_t scratch = 0;
+    };
+
     Level& At(GeometryId geometry);
     void Queue(GeometryId geometry, bool refit);
     void SetAddress(GeometryId geometry, std::uint64_t address);
     /// @return The triangles or box a geometry's level is built over.
     BottomBuild Build(GeometryId geometry, bool refit, std::vector<TriangleGeometry>& triangles,
                       std::vector<BoxGeometry>& boxes) const;
+    /// @return The moves of levels whose compacted sizes have come back.
+    Moves TakeCompactedSizes();
+    /// @return The pending builds that fit the scratch budget; the rest wait for a later frame.
+    FrameBuilds PlanBuilds();
+    /// @return The query reading back the compacted sizes of the static levels just built.
+    Compaction StartCompactionQuery(const std::vector<GeometryId>& built);
+    void AddAddressUpload(graph::Graph& graph);
+    void AddBuildPass(graph::Graph& graph, FrameBuilds builds, Moves moves,
+                      const Compaction& compaction);
 
     DeviceContext& context_;
     const GeometryPool& geometry_;

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev137}/ernie/render/rt/camera_pass.cpp

@@ -10,7 +10,6 @@
 #include "ernie/shaders/spectral/spectrum.h"
 #include "ernie/util/math.h"
 
-#include <glm/gtc/matrix_access.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 
 #include <algorithm>
@@ -25,7 +24,7 @@ constexpr std::uint32_t kNoImage = 0xffffffff;
 
 /// A view as camera.slang's `View` reads it.
 struct ViewRecord {
-    glm::vec4 rows[3];
+    std::array<glm::vec4, 3> rows;
     glm::vec2 halfExtent;
     glm::uvec2 size;
     glm::vec3 background;
@@ -51,19 +50,17 @@ std::vector<std::uint32_t> Compile(const ShaderCompiler& compiler) {
 
 /// @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) {
+ViewRecord ToViewRecord(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;
+    return {.rows = ToAffineRows(relative),
+            .halfExtent = glm::vec2(tangent * aspect, tangent),
+            .size = view.size,
+            .background = outputs.background,
+            .colour = outputs.colour ? outputs.colourIndex.value : kNoImage};
 }
 
 }  // namespace
@@ -89,7 +86,7 @@ void CameraPass::Add(graph::Graph& graph, std::span<CameraView> views) const {
     std::vector<ViewRecord> records;
     glm::uvec2 largest{0};
     for (const CameraView& view : views) {
-        records.push_back(Record(view.view, view.outputs, scene->origin));
+        records.push_back(ToViewRecord(view.view, view.outputs, scene->origin));
         largest = glm::max(largest, view.view.size);
     }
     graph::Buffer staged = graph.Create(records.size() * sizeof(ViewRecord), "camera views");