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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev161
+Version: 0.2.0.dev166
 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.dev166}/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.dev166/benchmarks/app/viewer_frame.cpp

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file viewer_frame.cpp
+/// @brief The viewer's frame: an offscreen 1920 x 1080 viewer over a scene of a few hundred
+/// prims, eco mode off, its time split by host and device profiler zone. `app.viewer_frame`
+/// traces apart from the UI where the device has a compute queue; `app.viewer_frame_sync` traces
+/// every frame before its UI.
+#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 <algorithm>
+#include <cstdio>
+#include <map>
+#include <string>
+#include <string_view>
+#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(bool async) {
+    Scene scene;
+    BuildScene(scene);
+    app::ViewerOptions options{
+        .size = {1920, 1080}, .offscreen = true, .frames = kWarmup, .asyncRender = async};
+    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();
+    std::vector<double> durations;
+    for (const profiler::Frame& frame : frames) {
+        durations.push_back(static_cast<double>(frame.end - frame.start) * 1e-6);
+    }
+    std::ranges::sort(durations);
+    double frameMs = 0.0;
+    for (const double ms : durations) {
+        frameMs += ms;
+    }
+    frameMs /= static_cast<double>(durations.size());
+    std::printf("  median %.3f ms, slowest %.3f ms a frame\n", durations[durations.size() / 2],
+                durations.back());
+    // A trace writes its pose first: the frames that started one.
+    const auto traced = std::ranges::count_if(frames, [](const profiler::Frame& frame) {
+        return std::ranges::any_of(frame.cpu, [](const profiler::Zone& zone) {
+            return std::string_view(zone.name) == "Write the viewport pose";
+        });
+    });
+    std::printf("  %zu frames of 1920 x 1080, %d prims, %s: %.3f ms a frame, %.0f frames and "
+                "%.0f traces a second\n",
+                frames.size(), kGroups * (kShapesPerGroup + 1) + 1,
+                viewer.AsyncRender() ? "tracing apart from the UI" : "tracing each frame", frameMs,
+                1e3 / frameMs,
+                static_cast<double>(traced) / static_cast<double>(frames.size()) * 1e3 / 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", [] { return RunViewerFrame(true); });
+const bool kRegisteredSync =
+    Register("app.viewer_frame_sync", [] { return RunViewerFrame(false); });
+
+}  // namespace
+}  // namespace ernie::bench

{ernie_renderer-0.2.0.dev161 → ernie_renderer-0.2.0.dev166}/ernie/app/ui.h

@@ -494,6 +494,10 @@ class Shell {
     bool TakeScreenshot() {
         return std::exchange(screenshot_, false);
     }
+    /// @return Whether a screenshot is asked for this frame, leaving the request.
+    bool ScreenshotRequested() const {
+        return screenshot_;
+    }
     void RequestScreenshot() {
         screenshot_ = true;
     }

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

@@ -14,6 +14,7 @@
 #include <imgui.h>
 
 #include <charconv>
+#include <cstring>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -105,6 +106,12 @@ 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_);
+            // On one queue, a trace and the UI run in turn whatever the order: tracing apart
+            // would only show each image a frame later.
+            async_ = options.asyncRender && &context_->Compute() != &context_->Main();
+            if (async_) {
+                deviceScene_->SetQueue(context_->Compute());
+            }
         }
         sampler_ = std::make_unique<Sampler>(
             *context_, SamplerDescription{.filter = Filter::Nearest, .address = Address::Clamp},
@@ -114,8 +121,12 @@ Viewer::Viewer(Scene& scene, const ViewerOptions& options)
 }
 
 Viewer::~Viewer() {
-    // Frames in flight sample the viewport and read the frame's columns.
-    Quietly([this] { context_->Main().Last().Wait(); });
+    // Frames and traces in flight sample the viewport and read the frame's columns.
+    Quietly([this] {
+        for (const Queue* queue : context_->Queues()) {
+            queue->Last().Wait();
+        }
+    });
 }
 
 void Viewer::Run() {
@@ -123,6 +134,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 +184,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 +212,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) {
@@ -281,7 +299,10 @@ bool Viewer::Step() {
         ERNIE_ZONE("Update the scene");
         scene_.Update();
     }
-    ShowViewport();
+    {
+        ERNIE_ZONE("Show the viewport");
+        ShowViewport();
+    }
     {
         ERNIE_ZONE("Build the UI's draw data");
         ImGui::Render();
@@ -307,12 +328,22 @@ 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 (tracingNow_) {
+                deviceScene_->Follow(shell_->Camera().Eye());
+                const std::size_t slot = *tracingNow_;
+                slots_[slot].traced = TraceViewport(slot);
+                // The UI shows it this frame, waiting for it, or once it has finished.
+                if (slot == shown_) {
+                    traced_ = true;
+                } else {
+                    tracing_.push_back(slot);
+                }
+            } else if (!camera_ && !ecoPaused_) {
+                // The device scene still follows the scene, with nothing to trace.
+                deviceScene_->Step([](graph::Graph&) {}, recorded_);
+            }
+            drawn = DrawUi(data, *target);
+            slots_[shown_].sampled = drawn;
         }
         inFlight_.push_back(drawn);
         if (const std::optional<Shell::Pick> pick = shell_->TakePick()) {
@@ -326,7 +357,10 @@ bool Viewer::Step() {
         ERNIE_ZONE("Present");
         presenter_->Present(drawn);
     }
-    context_->Collect();
+    {
+        ERNIE_ZONE("Free retired objects");
+        context_->Collect();
+    }
     ++frames_;
     return shell_->Open() && (options_.frames == 0 || frames_ < options_.frames);
 }
@@ -335,47 +369,97 @@ 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_);
+    ChooseSlots();
+    ImGui::GetBackgroundDrawList()->AddImage(slots_[shown_].texture, position,
                                              {position.x + size.x, position.y + size.y});
 }
 
+void Viewer::ChooseSlots() {
+    tracingNow_.reset();
+    if (!camera_) {
+        return;
+    }
+    // Traces finish in order on their queue: the newest finished one is shown.
+    while (!tracing_.empty() && slots_[tracing_.front()].traced.Done()) {
+        shown_ = tracing_.front();
+        tracing_.pop_front();
+        traced_ = true;
+    }
+    if (ecoPaused_) {
+        return;
+    }
+    // A trace takes a slot neither shown nor tracing, so their images stay whole.
+    std::size_t next = 0;
+    while (next == shown_ || std::ranges::find(tracing_, next) != tracing_.end()) {
+        ++next;
+    }
+    const bool capturing = recording_ || shell_->ScreenshotRequested();
+    if (!async_ || capturing || !traced_) {
+        // This frame's own image, which the UI waits for; older traces, still running, show
+        // nothing newer.
+        tracingNow_ = next;
+        shown_ = next;
+        tracing_.clear();
+    } else if (tracing_.size() < kSlots - 1) {
+        tracingNow_ = next;
+    }
+}
+
 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_);
+    // Frames and traces in flight may still use the old images.
+    for (const Queue* queue : context_->Queues()) {
+        queue->Last().Wait();
+    }
+    tracing_.clear();
+    traced_ = false;
+    for (ViewportSlot& slot : slots_) {
+        slot.traced = {};
+        slot.sampled = {};
+        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);
+            if (!slot.pose) {
+                slot.pose = std::make_unique<Buffer>(*context_, kPoseBytes, MemoryUse::Upload,
+                                                     "viewport pose");
+            }
         }
     }
-    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 +471,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 +479,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(std::size_t index) {
+    const OrbitCamera& orbit = shell_->Camera();
+    ViewportSlot& slot = slots_[index];
+    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_;
     }
-    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;
+    {
+        // Written in place from the host once the slot's last trace, which read it, is done:
+        // the submission makes it visible to this one.
+        ERNIE_ZONE("Write the viewport pose");
+        if (slot.traced.timeline != nullptr) {
+            slot.traced.Wait();
+        }
+        const glm::dmat4 relative =
+            glm::translate(glm::dmat4(1.0), -deviceScene_->Transforms().Origin()) *
+            orbit.Transform();
+        const std::array<glm::vec4, 3> rows = ToAffineRows(relative);
+        std::memcpy(slot.pose->Mapped().data(), rows.data(), kPoseBytes);
+        slot.pose->Flush(0, kPoseBytes);
+    }
+    // After the UI frames that sampled the slot's last image.
+    const std::span<const Ticket> sampled =
+        slot.sampled.timeline != nullptr ? std::span(&slot.sampled, 1) : std::span<const Ticket>();
+    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(*slot.pose, 0, kPoseBytes, "viewport pose")},
+                         outputs);
+        },
+        recorded_ * kSlots + index, sampled);
 }
 
-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());
+    const ViewportSlot& shown = slots_[shown_];
+    graph::Image viewport = graph.Import(*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 +548,11 @@ 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));
         });
+    // The shown trace has finished unless this frame waits for its own; waiting on it either
+    // way makes its writes visible across queues.
+    const std::span<const Ticket> traced =
+        shown.traced.timeline != nullptr ? std::span(&shown.traced, 1) : std::span<const Ticket>();
+    return graph.Execute(context_->Main(), traced, target.semaphores);
 }
 
 std::string_view ViewUsage() {

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

@@ -12,6 +12,7 @@
 
 #include <glm/vec2.hpp>
 
+#include <array>
 #include <chrono>
 #include <cstdint>
 #include <deque>
@@ -39,6 +40,9 @@ struct ViewerOptions {
     bool validation = false;
     /// Wait for the display's refresh; off by default, so frames show what they cost.
     bool vsync = false;
+    /// Trace the viewport on the compute queue, apart from the UI, when the device has one: the
+    /// UI keeps its rate, showing the newest finished image, however long a trace takes.
+    bool asyncRender = true;
     /// Where `RunView` saves the last frame drawn offscreen as a PNG; empty for nowhere.
     std::filesystem::path screenshot;
     ShellOptions shell;
@@ -60,6 +64,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 +75,15 @@ class Viewer {
     bool EcoPaused() const {
         return ecoPaused_;
     }
+    /// @return Whether the viewport is traced on the compute queue, apart from the UI.
+    bool AsyncRender() const {
+        return async_;
+    }
+    /// @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 +124,21 @@ 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 into slot `index` through the device
+    /// scene's steps, on its queue, after the UI frames that sampled the slot: 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(std::size_t index);
+    /// @brief Picks the slot the UI shows this frame, and the one it traces into, if any: the
+    /// newest finished trace's and the other, rendering apart from the UI; or the one traced
+    /// this frame, waited for, while captures need this frame's own image, before any trace
+    /// has finished, or without asynchronous rendering.
+    void ChooseSlots();
+    /// @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 +153,45 @@ 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, each
+    /// pixel's prim slot, which picking reads, and the orbit camera's pose its trace reads, three
+    /// rows relative to the render origin, written from the host (null without ray queries).
+    struct ViewportSlot {
+        std::unique_ptr<DeviceImage> image;
+        ImTextureID texture = 0;
+        BindlessIndex storage;
+        std::unique_ptr<DeviceColumn> prims;
+        std::unique_ptr<Buffer> pose;
+        /// The last trace into it, and the last UI frame that sampled it.
+        Ticket traced;
+        Ticket sampled;
+    };
+    /// A pose's bytes: three rows of four floats.
+    static constexpr std::uint64_t kPoseBytes = 3 * sizeof(glm::vec4);
+    /// Traces take turns among the slots, each with a recorded frame of its own to replay: one
+    /// shown and up to two tracing, so the compute queue runs one trace after another.
+    static constexpr std::size_t kSlots = 3;
+    std::array<ViewportSlot, kSlots> slots_;
+    /// The slot the UI shows: the newest finished trace's, or this frame's when it waits for it.
+    std::size_t shown_ = 0;
+    /// Whether traces run on the compute queue, apart from the UI.
+    bool async_ = false;
+    /// The slots traces still run into, apart from the UI, oldest first.
+    std::deque<std::size_t> tracing_;
+    /// Whether the shown slot holds a finished trace, so the UI need not wait for one.
+    bool traced_ = false;
+    /// What this frame does, as `ShowViewport` decided it: the slot it traces into, if any.
+    std::optional<std::size_t> tracingNow_;
+    /// 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;