ernie-renderer 0.2.0.dev161__tar.gz → 0.2.0.dev164__tar.gz

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/CMakeLists.txt

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

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

@@ -2,6 +2,7 @@
 add_executable(
     ernie_benchmarks
     main.cpp
+    app/viewer_frame.cpp
     device/pose_step.cpp
     render/batch_step.cpp
     render/hide_seek.cpp
@@ -11,5 +12,5 @@ add_executable(
 )
 target_link_libraries(
     ernie_benchmarks
-    PRIVATE ernie_static ernie_volk ernie_vma ernie_build_options
+    PRIVATE ernie_viewer ernie_static ernie_volk ernie_vma ernie_build_options
 )

ernie_renderer-0.2.0.dev164/benchmarks/app/viewer_frame.cpp

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file viewer_frame.cpp
+/// @brief The viewer's frame on the host: an offscreen 1920 x 1080 viewer over a scene of a few
+/// hundred prims, tracing every frame (eco mode off), its host time split by profiler zone.
+#include "benchmarks/bench.h"
+#include "ernie/app/viewer.h"
+#include "ernie/scene/schema/geom.h"
+#include "ernie/scene/schema/planet.h"
+#include "ernie/scene/xform.h"
+#include "ernie/util/profiler.h"
+
+#include <cstdio>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+namespace {
+
+constexpr int kGroups = 20;
+constexpr int kShapesPerGroup = 15;
+/// Frames drawn before measuring, while pipelines compile and the layout settles.
+constexpr std::uint64_t kWarmup = 30;
+constexpr std::uint64_t kMeasured = 200;
+
+void BuildScene(Scene& scene) {
+    GroundPlane::Define(scene, "/World/Ground");
+    for (int group = 0; group < kGroups; ++group) {
+        const std::string root = "/World/Group" + std::to_string(group);
+        Xform::Define(scene, root);
+        SetXform(scene, root, {.translate = glm::dvec3(3.0 * (group % 5), 3.0 * (group / 5), 0)});
+        for (int shape = 0; shape < kShapesPerGroup; ++shape) {
+            const std::string path = root + "/Shape" + std::to_string(shape);
+            if (shape % 2 == 0) {
+                Sphere::Define(scene, path).SetRadius(0.2);
+            } else {
+                Cube::Define(scene, path).SetSize(0.3);
+            }
+            SetXform(scene, path,
+                     {.translate = glm::dvec3(0.4 * (shape % 4), 0.4 * (shape / 4), 0.5)});
+        }
+    }
+    scene.Update();
+}
+
+/// The average milliseconds a frame spends in each zone at most `deepest` deep, by name, in the
+/// order they first end.
+std::vector<std::pair<std::string, double>>
+Average(const std::vector<profiler::Frame>& frames,
+        std::vector<profiler::Zone> profiler::Frame::* zones, std::uint32_t deepest) {
+    std::map<std::string, double> totals;
+    std::vector<std::string> order;
+    std::size_t counted = 0;
+    for (const profiler::Frame& frame : frames) {
+        // GPU zones of the newest frames may not have arrived.
+        if ((frame.*zones).empty()) {
+            continue;
+        }
+        ++counted;
+        for (const profiler::Zone& zone : frame.*zones) {
+            if (zone.thread != 0 || zone.depth > deepest) {
+                continue;
+            }
+            const std::string name = std::string(2 * zone.depth, ' ') + zone.name;
+            if (!totals.contains(name)) {
+                order.push_back(name);
+            }
+            totals[name] += static_cast<double>(zone.end - zone.start);
+        }
+    }
+    std::vector<std::pair<std::string, double>> averages;
+    for (const std::string& name : order) {
+        averages.emplace_back(name, totals[name] / static_cast<double>(counted) * 1e-6);
+    }
+    return averages;
+}
+
+Timing RunViewerFrame() {
+    Scene scene;
+    BuildScene(scene);
+    app::ViewerOptions options{.size = {1920, 1080}, .offscreen = true, .frames = kWarmup};
+    options.shell.display.eco = false;
+    // Zones every frame, not only while the Profiler panel's tab shows.
+    options.shell.profile = true;
+    profiler::SetHistory(kMeasured);
+    app::Viewer viewer(scene, options);
+    // A prim selected, as while working, so Properties draws its fields.
+    viewer.GetShell().Selected().Set("/World/Group0/Shape0");
+    viewer.Run();
+    profiler::Clear();
+    profiler::SetEnabled(true);
+    viewer.RunFrames(kMeasured);
+    profiler::SetEnabled(false);
+    const std::vector<profiler::Frame> frames = profiler::Frames();
+    double frameMs = 0.0;
+    for (const profiler::Frame& frame : frames) {
+        frameMs += static_cast<double>(frame.end - frame.start) * 1e-6;
+    }
+    frameMs /= static_cast<double>(frames.size());
+    std::printf("  %zu frames of 1920 x 1080, %d prims: %.3f ms a frame\n", frames.size(),
+                kGroups * (kShapesPerGroup + 1) + 1, frameMs);
+    for (const auto& [title, zones, deepest] :
+         {std::tuple("Host", &profiler::Frame::cpu, 2u), {"Device", &profiler::Frame::gpu, 2u}}) {
+        std::printf("  %s\n", title);
+        for (const auto& [name, ms] : Average(frames, zones, deepest)) {
+            std::printf("    %-44s %8.3f ms\n", name.c_str(), ms);
+        }
+    }
+    return {.ms = frameMs, .targetMs = 1.0};
+}
+
+const bool kRegistered = Register("app.viewer_frame", RunViewerFrame);
+
+}  // namespace
+}  // namespace ernie::bench

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/app/viewer.cpp

@@ -105,6 +105,9 @@ Viewer::Viewer(Scene& scene, const ViewerOptions& options)
         if (deviceScene_->Tracer() != nullptr) {
             heap_ = std::make_unique<BindlessHeap>(*context_);
             camera_ = std::make_unique<CameraPass>(*context_, compiler, *heap_);
+            pose_ = std::make_unique<DeviceColumn>(*arenas_, "viewport pose", DType::Float32,
+                                                   std::vector<std::int64_t>{4}, 3);
+            poseUploader_ = std::make_unique<Uploader>(*context_, context_->Main());
         }
         sampler_ = std::make_unique<Sampler>(
             *context_, SamplerDescription{.filter = Filter::Nearest, .address = Address::Clamp},
@@ -123,6 +126,13 @@ void Viewer::Run() {
     }
 }
 
+void Viewer::RunFrames(std::uint64_t count) {
+    for (std::uint64_t frame = 0; frame < count && !presenter_->CloseRequested() && shell_->Open();
+         ++frame) {
+        Step();
+    }
+}
+
 Tensor Viewer::ReadImage(const DeviceImage& image, const Ticket& drawn) {
     const glm::uvec2 size(image.Description().extent);
     const std::uint64_t bytes = std::uint64_t{4} * size.x * size.y;
@@ -166,7 +176,7 @@ void Viewer::Capture(const Ticket& drawn) {
     if (shell_->TakeScreenshot()) {
         try {
             const std::filesystem::path path = CapturePath(".png", 0);
-            WritePng(path, ReadImage(*viewport_, drawn));
+            WritePng(path, ReadImage(*slots_[shown_].image, drawn));
             shell_->AddRecentCapture(path);
         } catch (const std::exception& error) {
             shell_->Log().Error(std::string("Capturing: ") + error.what());
@@ -194,7 +204,7 @@ void Viewer::RecordFrame(const Ticket& drawn) {
     std::array<char, 32> name{};
     std::snprintf(name.data(), name.size(), "frame_%04lld.png",
                   static_cast<long long>(recording.done));
-    WritePng(recording.folder / name.data(), ReadImage(*viewport_, drawn));
+    WritePng(recording.folder / name.data(), ReadImage(*slots_[shown_].image, drawn));
     ++recording.done;
     recording.next += recording.request.every;
     if (recording.done >= recording.total || shell_->stopRecording) {
@@ -307,12 +317,11 @@ bool Viewer::Step() {
         Ticket drawn;
         {
             ERNIE_ZONE("Run the frame");
-            ecoPaused_ = EcoPause();
-            shell_->SetEcoPaused(ecoPaused_);
-            deviceScene_->Follow(shell_->Camera().Eye());
-            drawn =
-                deviceScene_->Execute([&](graph::Graph& graph) { AddPasses(graph, data, *target); },
-                                      {}, target->semaphores);
+            if (!ecoPaused_) {
+                deviceScene_->Follow(shell_->Camera().Eye());
+                TraceViewport();
+            }
+            drawn = DrawUi(data, *target);
         }
         inFlight_.push_back(drawn);
         if (const std::optional<Shell::Pick> pick = shell_->TakePick()) {
@@ -335,47 +344,59 @@ void Viewer::ShowViewport() {
     const auto [position, size] = shell_->Viewport();
     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) {
+    if (!slots_[0].image || glm::uvec2(slots_[0].image->Description().extent) != pixels) {
         ResizeViewport(pixels);
     }
-    ImGui::GetBackgroundDrawList()->AddImage(viewportTexture_, position,
+    ecoPaused_ = EcoPause();
+    shell_->SetEcoPaused(ecoPaused_);
+    // A traced frame takes the other slot, so the last one's image stays whole while it renders.
+    if (!ecoPaused_ && camera_) {
+        shown_ = (shown_ + 1) % kSlots;
+    }
+    ImGui::GetBackgroundDrawList()->AddImage(slots_[shown_].texture, position,
                                              {position.x + size.x, position.y + size.y});
 }
 
 void Viewer::ResizeViewport(glm::uvec2 pixels) {
     ERNIE_ZONE("Resize the viewport");
-    // Frames in flight may still sample the old image.
+    // Frames in flight may still sample the old images.
     context_->Main().Last().Wait();
-    if (viewport_) {
-        renderer_->RemoveTexture(viewportTexture_);
+    for (ViewportSlot& slot : slots_) {
+        if (slot.image) {
+            renderer_->RemoveTexture(slot.texture);
+            if (heap_) {
+                heap_->RemoveStorageImage(slot.storage);
+            }
+        }
+        slot.image = std::make_unique<DeviceImage>(
+            *context_,
+            ImageDescription{.format = ImageFormat::Rgba8Unorm,
+                             .extent = {pixels, 1},
+                             .usage = ImageUsage::Sampled | ImageUsage::Storage},
+            "Viewport");
+        slot.texture = renderer_->AddTexture(slot.image->View(), sampler_->Handle());
         if (heap_) {
-            heap_->RemoveStorageImage(viewportImage_);
+            slot.storage = heap_->AddStorageImage(*slot.image);
+            slot.prims = std::make_unique<DeviceColumn>(*arenas_, "viewport prims", DType::UInt32,
+                                                        std::vector<std::int64_t>{},
+                                                        std::uint64_t{pixels.x} * pixels.y);
         }
     }
-    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_);
-        prims_ = std::make_unique<DeviceColumn>(*arenas_, "viewport prims", DType::UInt32,
-                                                std::vector<std::int64_t>{},
-                                                std::uint64_t{pixels.x} * pixels.y);
-    }
+    // The recorded frames name the old images.
+    ++recorded_;
 }
 
 void Viewer::Pick(const Shell::Pick& pick, const Ticket& drawn) {
-    if (!prims_) {
+    const ViewportSlot& shown = slots_[shown_];
+    if (!shown.prims) {
         return;
     }
-    const glm::uvec2 size(viewport_->Description().extent);
+    const DeviceColumn& prims = *shown.prims;
+    const glm::uvec2 size(shown.image->Description().extent);
     const glm::uvec2 pixel = glm::min(glm::uvec2(pick.at * glm::vec2(size)), size - 1u);
     const std::uint64_t at = std::uint64_t{pixel.y} * size.x + pixel.x;
-    Readback readback(*context_, context_->Main(), prims_->Storage(),
-                      prims_->Range().offset + at * sizeof(std::uint32_t), sizeof(std::uint32_t),
+    Readback readback(*context_, context_->Main(), prims.Storage(),
+                      prims.Range().offset + at * sizeof(std::uint32_t), sizeof(std::uint32_t),
                       std::span(&drawn, 1));
     const std::uint32_t slot = readback.Values<std::uint32_t>().front();
     const std::optional<PrimId> prim = scene_.Store().PrimAtSlot(slot);
@@ -387,7 +408,7 @@ bool Viewer::EcoPause() {
     const ViewState now{.version = scene_.Store().Version(),
                         .camera = orbit.Transform(),
                         .fov = orbit.verticalFov,
-                        .size = glm::uvec2(viewport_->Description().extent)};
+                        .size = glm::uvec2(slots_[0].image->Description().extent)};
     stillFrames_ = lastView_ == now ? stillFrames_ + 1 : 0;
     lastView_ = now;
     const ViewportDisplay& display = shell_->Display();
@@ -395,37 +416,62 @@ bool Viewer::EcoPause() {
            stillFrames_ >= static_cast<std::uint64_t>(std::max(display.ecoFrames, 1));
 }
 
-graph::Image Viewer::AddViewportPass(graph::Graph& graph) {
-    graph::Image viewport = graph.Import(*viewport_, "viewport");
-    if (ecoPaused_) {
-        // Still: the last frame's image stands.
-        return viewport;
-    }
-    if (camera_) {
-        const OrbitCamera& orbit = shell_->Camera();
-        CameraOutputs outputs{.colour = viewport,
-                              .colourIndex = viewportImage_,
-                              .background = glm::vec3(shell_->GetTheme().viewport),
-                              .prims = graph.Import(*prims_)};
-        const glm::uvec2 size(viewport_->Description().extent);
-        camera_->Add(graph,
-                     {.cameraToWorld = orbit.Transform(),
-                      .size = size,
-                      .lens = MakePinhole(orbit.verticalFov, size)},
-                     outputs);
-        return *outputs.colour;
+Ticket Viewer::TraceViewport() {
+    if (!camera_) {
+        // The device scene still follows the scene, with nothing to trace.
+        return deviceScene_->Step([](graph::Graph&) {}, recorded_);
     }
-    graph.Add(
-        "Viewport", graph::Kind::Copy,
-        [&](graph::PassBuilder& pass) { viewport = pass.Write(viewport, graph::Use::CopyDst); },
-        [this, viewport](graph::PassContext& pass) {
-            pass.Clear(viewport, shell_->GetTheme().viewport);
-        });
-    return viewport;
+    const OrbitCamera& orbit = shell_->Camera();
+    const ViewportSlot& slot = slots_[shown_];
+    const glm::uvec2 size(slot.image->Description().extent);
+    const RecordedView view{.size = size,
+                            .fov = orbit.verticalFov,
+                            .background = glm::vec3(shell_->GetTheme().viewport)};
+    if (recordedView_ != view) {
+        recordedView_ = view;
+        ++recorded_;
+    }
+    {
+        // Its own submission, before the trace's recorded commands read it.
+        ERNIE_ZONE("Upload the viewport pose");
+        const glm::dmat4 relative =
+            glm::translate(glm::dmat4(1.0), -deviceScene_->Transforms().Origin()) *
+            orbit.Transform();
+        const std::array<glm::vec4, 3> rows = ToAffineRows(relative);
+        poseUploader_->Write(pose_->Storage(), pose_->Range().offset,
+                             std::span<const glm::vec4>(rows));
+        graph::Graph graph(*context_, deviceScene_->Pool());
+        std::array buffers{graph.Import(*pose_)};
+        graph::AddUploadPass(graph, "Upload the viewport pose", *poseUploader_, buffers);
+        graph.Execute(context_->Main());
+    }
+    return deviceScene_->Step(
+        [&](graph::Graph& graph) {
+            CameraOutputs outputs{.colour = graph.Import(*slot.image, "viewport"),
+                                  .colourIndex = slot.storage,
+                                  .background = view.background,
+                                  .prims = graph.Import(*slot.prims)};
+            camera_->Add(graph,
+                         {.cameraToWorld = orbit.Transform(),
+                          .size = size,
+                          .lens = MakePinhole(orbit.verticalFov, size),
+                          .pose = graph.Import(*pose_)},
+                         outputs);
+        },
+        recorded_ * kSlots + shown_);
 }
 
-void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
-    const graph::Image viewport = AddViewportPass(graph);
+Ticket Viewer::DrawUi(ImDrawData& data, const FrameTarget& target) {
+    graph::Graph graph(*context_, deviceScene_->Pool());
+    graph::Image viewport = graph.Import(*slots_[shown_].image, "viewport");
+    if (!camera_) {
+        graph.Add(
+            "Viewport", graph::Kind::Copy,
+            [&](graph::PassBuilder& pass) { viewport = pass.Write(viewport, graph::Use::CopyDst); },
+            [this, viewport](graph::PassContext& pass) {
+                pass.Clear(viewport, shell_->GetTheme().viewport);
+            });
+    }
     graph.Add(
         "UI", graph::Kind::Raster,
         [&](graph::PassBuilder& pass) {
@@ -439,6 +485,7 @@ void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget&
             renderer_->Record(pass.commands.Handle(), data, target,
                               glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
         });
+    return graph.Execute(context_->Main(), {}, target.semaphores);
 }
 
 std::string_view ViewUsage() {

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/app/viewer.h

@@ -12,6 +12,7 @@
 
 #include <glm/vec2.hpp>
 
+#include <array>
 #include <chrono>
 #include <cstdint>
 #include <deque>
@@ -60,6 +61,9 @@ class Viewer {
 
     /// @brief Draws frames until the window closes, the user quits or the frame count is reached.
     void Run();
+    /// @brief Draws `count` more frames, whatever the frame count, or fewer once the window
+    /// closes or the user quits.
+    void RunFrames(std::uint64_t count);
 
     std::uint64_t Frames() const {
         return frames_;
@@ -68,6 +72,11 @@ class Viewer {
     bool EcoPaused() const {
         return ecoPaused_;
     }
+    /// @return Whether the last frame's trace submitted commands recorded for an earlier frame
+    /// again, as it does while only the camera's pose and device columns change.
+    bool Replayed() const {
+        return deviceScene_->Replayed();
+    }
     Shell& GetShell() {
         return *shell_;
     }
@@ -108,12 +117,15 @@ class Viewer {
     void RecordFrame(const Ticket& drawn);
     /// @brief Ends the recording, encoding its frames into video when asked.
     void FinishSequence();
-    /// @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);
+    /// @brief Uploads the orbit camera's pose, then traces the shown slot through the device
+    /// scene's steps: replayed while the scene, the origin and the view's size, lens and
+    /// background stand, so only the pose and device columns change.
+    /// @return The trace's ticket.
+    Ticket TraceViewport();
+    /// @brief Submits the UI over the target, sampling the shown slot, which it clears to the
+    /// theme's colour without ray queries.
+    /// @return The frame's ticket.
+    Ticket DrawUi(ImDrawData& data, const FrameTarget& target);
 
     ViewerOptions options_;
     Scene& scene_;
@@ -128,13 +140,32 @@ class Viewer {
     /// 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_;
-    /// Each viewport pixel's prim slot, which picking reads; null without ray queries.
-    std::unique_ptr<DeviceColumn> prims_;
+    /// An image the viewport is rendered into, the UI's texture of it, its storage slot, and each
+    /// pixel's prim slot, which picking reads (null without ray queries).
+    struct ViewportSlot {
+        std::unique_ptr<DeviceImage> image;
+        ImTextureID texture = 0;
+        BindlessIndex storage;
+        std::unique_ptr<DeviceColumn> prims;
+    };
+    /// Frames take turns tracing into the slots, each with a recorded frame of its own to replay.
+    static constexpr std::size_t kSlots = 2;
+    std::array<ViewportSlot, kSlots> slots_;
+    /// The slot the UI shows: the one traced this frame, or the last while eco mode pauses.
+    std::size_t shown_ = 0;
+    /// The orbit camera's pose, three rows relative to the render origin, uploaded each frame.
+    std::unique_ptr<DeviceColumn> pose_;
+    std::unique_ptr<Uploader> poseUploader_;
+    /// What the trace records besides the pose; a change, or new slots, records anew.
+    struct RecordedView {
+        glm::uvec2 size{0};
+        double fov = 0.0;
+        glm::vec3 background{0.0f};
+        bool operator==(const RecordedView&) const = default;
+    };
+    std::optional<RecordedView> recordedView_;
+    std::uint64_t recorded_ = 0;
     /// What a frame renders from; eco mode counts the frames it stays the same.
     struct ViewState {
         std::uint64_t version = 0;

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/graph/graph.cpp

@@ -610,6 +610,14 @@ std::vector<std::string> Graph::ExecutedPasses() const {
     return names;
 }
 
+std::vector<std::string> Graph::PassNames() const {
+    std::vector<std::string> names;
+    for (const Pass& pass : passes_) {
+        names.push_back(pass.name);
+    }
+    return names;
+}
+
 std::string Graph::Dot() const {
     std::vector<bool> live(passes_.size(), !compiled_);
     for (const std::uint32_t p : live_) {

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/graph/graph.h

@@ -271,6 +271,8 @@ class Graph {
     }
     /// @return The names of the passes `Compile` kept, in order.
     std::vector<std::string> ExecutedPasses() const;
+    /// @return The names of every pass added so far, in order.
+    std::vector<std::string> PassNames() const;
     /// @return The graph in Graphviz's dot language.
     std::string Dot() const;
 

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/render/device_scene.cpp

@@ -72,14 +72,20 @@ bool DeviceScene::Settled() const {
 }
 
 void DeviceScene::AddFrame(graph::Graph& graph, const std::function<void(graph::Graph&)>& passes) {
+    // Instances move only with the host's edits, a rebase, bottom levels still building, or
+    // bound columns written on the device unseen; otherwise the last frame's worlds and top
+    // levels stand.
+    const MovedKey now{scene_.Store().Version(), transforms_.Origin()};
+    const bool moved = !moved_ || *moved_ != now || !Settled() || transforms_.Bound();
+    moved_ = now;
     columns_.AddSync(graph);
-    transforms_.AddUpdate(graph);
+    transforms_.AddUpdate(graph, moved);
     const GeometryPool::Changes changes = geometry_.Update();
     instances_.Apply(changes);
     geometry_.AddUploads(graph);
     instances_.AddUploads(graph);
     if (tracer_) {
-        tracer_->AddBuild(graph, changes, transforms_, instances_);
+        tracer_->AddBuild(graph, changes, transforms_, instances_, moved);
     }
     if (passes) {
         passes(graph);

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/render/device_scene.h

@@ -22,6 +22,7 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <span>
 #include <vector>
 
@@ -121,6 +122,13 @@ class DeviceScene {
     std::unique_ptr<RayTracer> tracer_;
     std::vector<Captured> captured_;
     bool replayed_ = false;
+    /// The scene's version and the origin the worlds and top levels were last made at.
+    struct MovedKey {
+        std::uint64_t version = 0;
+        glm::dvec3 origin{0.0};
+        bool operator==(const MovedKey&) const = default;
+    };
+    std::optional<MovedKey> moved_;
 };
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/render/rt/camera_pass.cpp

@@ -89,9 +89,11 @@ void CameraPass::Add(graph::Graph& graph, std::span<const CameraView> views,
         return;
     }
     std::vector<View> records;
+    std::vector<std::optional<graph::Buffer>> poses;
     glm::uvec2 largest{0};
     std::uint64_t pixels = 0;
     for (const CameraView& view : views) {
+        poses.push_back(view.pose);
         if (view.world >= scene->worlds) {
             throw std::invalid_argument("A view of world " + std::to_string(view.world) +
                                         ", of a scene of " + std::to_string(scene->worlds));
@@ -109,6 +111,11 @@ void CameraPass::Add(graph::Graph& graph, std::span<const CameraView> views,
         "Camera", graph::Kind::Compute,
         [&](graph::PassBuilder& pass) {
             scene->Read(pass);
+            for (const CameraView& view : views) {
+                if (view.pose) {
+                    pass.ReadAddress(*view.pose);
+                }
+            }
             // Written by the pass itself before its dispatch reads it.
             staged = pass.WriteAddress(staged, graph::Use::StorageWrite);
             if (outputs.colour) {
@@ -122,7 +129,7 @@ void CameraPass::Add(graph::Graph& graph, std::span<const CameraView> views,
                 }
             }
         },
-        [this, staged, largest, records = std::move(records), outputs,
+        [this, staged, largest, records = std::move(records), poses = std::move(poses), outputs,
          scene = *scene](graph::PassContext& pass) mutable {
             View written{.distances = BufferRefOrNull<float>(pass, outputs.distances),
                          .normals = BufferRefOrNull<float>(pass, outputs.normals),
@@ -130,6 +137,9 @@ void CameraPass::Add(graph::Graph& graph, std::span<const CameraView> views,
                          .prims = BufferRefOrNull<shaders::uint>(pass, outputs.prims),
                          .albedos = BufferRefOrNull<float>(pass, outputs.albedos),
                          .ldr = BufferRefOrNull<shaders::uint>(pass, outputs.ldr)};
+            for (std::size_t i = 0; i < records.size(); ++i) {
+                records[i].pose = BufferRefOrNull<glm::vec4>(pass, poses[i]);
+            }
             for (View& record : records) {
                 record.distances = written.distances;
                 record.normals = written.normals;

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/render/rt/camera_pass.h

@@ -49,6 +49,10 @@ struct CameraView {
     std::uint32_t world = 0;
     /// Metres along the view axis to the near and far clipping planes.
     glm::vec2 clipping{0.0f, 1e30f};
+    /// Three rows of four floats, camera to world relative to the render origin, which the pass
+    /// reads on the device in place of `cameraToWorld` when there is no node: a pose uploaded
+    /// each frame, so recorded commands replay as it moves.
+    std::optional<graph::Buffer> pose;
 };
 
 /// @brief What a camera pass writes; each left out is not written. The views' pixels are stacked

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/render/rt/ray_tracer.cpp

@@ -24,12 +24,14 @@ std::span<const ShaderModule> RayTracer::Modules() {
 }
 
 void RayTracer::AddBuild(graph::Graph& graph, const GeometryPool::Changes& changes,
-                         const TransformGraph& transforms, const InstanceTable& instances) {
+                         const TransformGraph& transforms, const InstanceTable& instances,
+                         bool rebuildTops) {
     ERNIE_ZONE("Update the ray tracer");
     const graph::Graph::ScopeGuard scope = graph.Scope("Ray tracer");
     bottoms_.Apply(changes);
     bottoms_.AddBuilds(graph);
-    const graph::Acceleration top = tops_.AddBuild(graph, transforms, instances, bottoms_);
+    const graph::Acceleration top =
+        tops_.AddBuild(graph, transforms, instances, bottoms_, rebuildTops);
     const DeviceColumn& records = geometry_.Records();
     graph.Board().Put(
         TraceScene{.parameters = {.tops = ToBufferRef<shaders::TopLevel>(tops_.Tops()),

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev164}/ernie/render/rt/ray_tracer.h

@@ -76,8 +76,10 @@ class RayTracer {
     /// @brief Adds the passes that bring the structures up to date with the frame's geometry
     /// changes, after the transforms and the geometry's and instances' uploads, and puts a
     /// `TraceScene` on the graph's blackboard.
+    /// @param rebuildTops Whether to build the top levels, as `TopLevels::AddBuild` takes it.
     void AddBuild(graph::Graph& graph, const GeometryPool::Changes& changes,
-                  const TransformGraph& transforms, const InstanceTable& instances);
+                  const TransformGraph& transforms, const InstanceTable& instances,
+                  bool rebuildTops = true);
 
     BottomLevels& Bottoms() {
         return bottoms_;