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

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

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

@@ -1,7 +1,9 @@
 // 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.
+/// @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"
@@ -9,9 +11,11 @@
 #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 {
@@ -75,10 +79,11 @@ Average(const std::vector<profiler::Frame>& frames,
     return averages;
 }
 
-Timing RunViewerFrame() {
+Timing RunViewerFrame(bool async) {
     Scene scene;
     BuildScene(scene);
-    app::ViewerOptions options{.size = {1920, 1080}, .offscreen = true, .frames = kWarmup};
+    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;
@@ -92,13 +97,30 @@ Timing RunViewerFrame() {
     viewer.RunFrames(kMeasured);
     profiler::SetEnabled(false);
     const std::vector<profiler::Frame> frames = profiler::Frames();
-    double frameMs = 0.0;
+    std::vector<double> durations;
     for (const profiler::Frame& frame : frames) {
-        frameMs += static_cast<double>(frame.end - frame.start) * 1e-6;
+        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>(frames.size());
-    std::printf("  %zu frames of 1920 x 1080, %d prims: %.3f ms a frame\n", frames.size(),
-                kGroups * (kShapesPerGroup + 1) + 1, frameMs);
+    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);
@@ -109,7 +131,9 @@ Timing RunViewerFrame() {
     return {.ms = frameMs, .targetMs = 1.0};
 }
 
-const bool kRegistered = Register("app.viewer_frame", RunViewerFrame);
+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.dev164 → 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.dev164 → 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,9 +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_);
-            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());
+            // 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},
@@ -117,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() {
@@ -291,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();
@@ -317,11 +328,22 @@ bool Viewer::Step() {
         Ticket drawn;
         {
             ERNIE_ZONE("Run the frame");
-            if (!ecoPaused_) {
+            if (tracingNow_) {
                 deviceScene_->Follow(shell_->Camera().Eye());
-                TraceViewport();
+                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()) {
@@ -335,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);
 }
@@ -349,19 +374,53 @@ void Viewer::ShowViewport() {
     }
     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;
-    }
+    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 images.
-    context_->Main().Last().Wait();
+    // 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_) {
@@ -380,6 +439,10 @@ void Viewer::ResizeViewport(glm::uvec2 pixels) {
             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");
+            }
         }
     }
     // The recorded frames name the old images.
@@ -416,13 +479,9 @@ bool Viewer::EcoPause() {
            stillFrames_ >= static_cast<std::uint64_t>(std::max(display.ecoFrames, 1));
 }
 
-Ticket Viewer::TraceViewport() {
-    if (!camera_) {
-        // The device scene still follows the scene, with nothing to trace.
-        return deviceScene_->Step([](graph::Graph&) {}, recorded_);
-    }
+Ticket Viewer::TraceViewport(std::size_t index) {
     const OrbitCamera& orbit = shell_->Camera();
-    const ViewportSlot& slot = slots_[shown_];
+    ViewportSlot& slot = slots_[index];
     const glm::uvec2 size(slot.image->Description().extent);
     const RecordedView view{.size = size,
                             .fov = orbit.verticalFov,
@@ -432,19 +491,22 @@ Ticket Viewer::TraceViewport() {
         ++recorded_;
     }
     {
-        // Its own submission, before the trace's recorded commands read it.
-        ERNIE_ZONE("Upload the viewport pose");
+        // 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);
-        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());
+        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"),
@@ -455,15 +517,16 @@ Ticket Viewer::TraceViewport() {
                          {.cameraToWorld = orbit.Transform(),
                           .size = size,
                           .lens = MakePinhole(orbit.verticalFov, size),
-                          .pose = graph.Import(*pose_)},
+                          .pose = graph.Import(*slot.pose, 0, kPoseBytes, "viewport pose")},
                          outputs);
         },
-        recorded_ * kSlots + shown_);
+        recorded_ * kSlots + index, sampled);
 }
 
 Ticket Viewer::DrawUi(ImDrawData& data, const FrameTarget& target) {
     graph::Graph graph(*context_, deviceScene_->Pool());
-    graph::Image viewport = graph.Import(*slots_[shown_].image, "viewport");
+    const ViewportSlot& shown = slots_[shown_];
+    graph::Image viewport = graph.Import(*shown.image, "viewport");
     if (!camera_) {
         graph.Add(
             "Viewport", graph::Kind::Copy,
@@ -485,7 +548,11 @@ Ticket Viewer::DrawUi(ImDrawData& data, const FrameTarget& target) {
             renderer_->Record(pass.commands.Handle(), data, target,
                               glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
         });
-    return graph.Execute(context_->Main(), {}, target.semaphores);
+    // 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.dev164 → ernie_renderer-0.2.0.dev166}/ernie/app/viewer.h

@@ -40,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;
@@ -72,6 +75,10 @@ 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 {
@@ -117,11 +124,17 @@ class Viewer {
     void RecordFrame(const Ticket& drawn);
     /// @brief Ends the recording, encoding its frames into video when asked.
     void FinishSequence();
-    /// @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.
+    /// @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();
+    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.
@@ -141,22 +154,35 @@ class Viewer {
     std::unique_ptr<BindlessHeap> heap_;
     std::unique_ptr<CameraPass> camera_;
     std::unique_ptr<Sampler> sampler_;
-    /// 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).
+    /// 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;
     };
-    /// Frames take turns tracing into the slots, each with a recorded frame of its own to replay.
-    static constexpr std::size_t kSlots = 2;
+    /// 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 one traced this frame, or the last while eco mode pauses.
+    /// The slot the UI shows: the newest finished trace's, or this frame's when it waits for it.
     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_;
+    /// 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};

{ernie_renderer-0.2.0.dev164 → ernie_renderer-0.2.0.dev166}/ernie/device/buffer.cpp

@@ -18,10 +18,16 @@ VkBufferCreateInfo BufferInfo(const DeviceContext& context, std::uint64_t size,
             ? VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
                   VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR
             : 0;
+    // Shared by every queue family, so queues pass buffers to each other with tickets alone.
+    const std::span<const std::uint32_t> families = context.QueueFamilies();
     return {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
             .size = size,
             .usage = usage | kBufferUsage | acceleration,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE};
+            .sharingMode =
+                families.size() > 1 ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE,
+            .queueFamilyIndexCount =
+                families.size() > 1 ? static_cast<std::uint32_t>(families.size()) : 0,
+            .pQueueFamilyIndices = families.size() > 1 ? families.data() : nullptr};
 }
 
 void RequireExternal(const DeviceContext& context) {

{ernie_renderer-0.2.0.dev164 → ernie_renderer-0.2.0.dev166}/ernie/device/context.cpp

@@ -187,6 +187,7 @@ DeviceContext::DeviceContext(const DeviceContextOptions& options)
     main_ = chosen[0];
     compute_ = chosen[1];
     transfer_ = chosen[2];
+    families_ = distinct;
 
     pipelineCachePath_ = options.pipelineCache;
     const std::vector<std::byte> cached =

{ernie_renderer-0.2.0.dev164 → ernie_renderer-0.2.0.dev166}/ernie/device/context.h

@@ -15,6 +15,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -79,6 +80,12 @@ class DeviceContext {
     }
     /// @return Each distinct queue once.
     std::vector<Queue*> Queues() const;
+    /// @return The queues' distinct families. With more than one, buffers and images are shared
+    /// by all of them concurrently, so any queue reads what another wrote, ordered by tickets,
+    /// with no ownership transfers.
+    std::span<const std::uint32_t> QueueFamilies() const {
+        return families_;
+    }
 
     /// @brief Keeps `object` alive until every queue's work submitted so far is done.
     void Retire(std::shared_ptr<const void> object);
@@ -161,6 +168,7 @@ class DeviceContext {
     VkPipelineCache pipelineCache_ = VK_NULL_HANDLE;
     std::unique_ptr<GpuProfiler> profiler_;
     std::vector<std::unique_ptr<Queue>> queues_;
+    std::vector<std::uint32_t> families_;
     Queue* main_ = nullptr;
     Queue* compute_ = nullptr;
     Queue* transfer_ = nullptr;

{ernie_renderer-0.2.0.dev164 → ernie_renderer-0.2.0.dev166}/ernie/device/image.cpp

@@ -56,6 +56,9 @@ DeviceImage::DeviceImage(DeviceContext& context, const ImageDescription& descrip
                          std::string_view name)
     : context_(context), description_(description) {
     const bool volume = description.extent.z > 1;
+    // Shared by every queue family, as buffers are.
+    const std::span<const std::uint32_t> families = context.QueueFamilies();
+    const bool concurrent = families.size() > 1;
     const VkImageCreateInfo info{
         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
         .imageType = volume ? VK_IMAGE_TYPE_3D : VK_IMAGE_TYPE_2D,
@@ -66,7 +69,9 @@ DeviceImage::DeviceImage(DeviceContext& context, const ImageDescription& descrip
         .samples = VK_SAMPLE_COUNT_1_BIT,
         .tiling = VK_IMAGE_TILING_OPTIMAL,
         .usage = ToVkUsage(description.usage),
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .sharingMode = concurrent ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = concurrent ? static_cast<std::uint32_t>(families.size()) : 0,
+        .pQueueFamilyIndices = concurrent ? families.data() : nullptr,
         .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED};
     const VkPhysicalDeviceImageFormatInfo2 query{
         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,

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

@@ -12,9 +12,9 @@ namespace ernie {
 
 DeviceScene::DeviceScene(DeviceContext& context, Arenas& arenas, const Scene& scene,
                          const ShaderCompiler& compiler, WorldCapacities capacities)
-    : context_(context), scene_(scene), pool_(context), columns_(context, arenas, scene),
-      transforms_(context, arenas, scene, compiler), geometry_(context, arenas, scene),
-      instances_(context, arenas, scene, compiler, capacities) {
+    : context_(context), scene_(scene), queue_(&context.Main()), pool_(context),
+      columns_(context, arenas, scene), transforms_(context, arenas, scene, compiler),
+      geometry_(context, arenas, scene), instances_(context, arenas, scene, compiler, capacities) {
     if (context.Capabilities().rayQuery) {
         tracer_ = std::make_unique<RayTracer>(context, arenas, compiler, geometry_);
     }
@@ -35,11 +35,27 @@ Ticket DeviceScene::Execute(const std::function<void(graph::Graph&)>& passes,
     captured_.clear();
     graph::Graph graph(context_, pool_);
     AddFrame(graph, passes);
-    return graph.Execute(context_.Main(), waits, binary);
+    return graph.Execute(*queue_, Waits(waits), binary);
+}
+
+void DeviceScene::SetQueue(Queue& queue) {
+    queue_ = &queue;
+    // Recorded commands belong to their queue.
+    captured_.clear();
+}
+
+std::vector<Ticket> DeviceScene::Waits(std::span<const Ticket> waits) const {
+    std::vector<Ticket> all(waits.begin(), waits.end());
+    // The main queue's work the frame may read: columns' resizes, bindings' first values.
+    if (queue_ != &context_.Main()) {
+        all.push_back(context_.Main().Last());
+    }
+    return all;
 }
 
 Ticket DeviceScene::Step(const std::function<void(graph::Graph&)>& passes, std::uint64_t key,
-                         std::span<const Ticket> waits) {
+                         std::span<const Ticket> given) {
+    const std::vector<Ticket> waits = Waits(given);
     const CaptureKey now{scene_.Store().Version(), transforms_.Origin(), key};
     // Frames of another version or origin record what no longer stands.
     std::erase_if(captured_, [&](const Captured& frame) {
@@ -58,12 +74,12 @@ Ticket DeviceScene::Step(const std::function<void(graph::Graph&)>& passes, std::
     graph::Graph graph(context_, pool_);
     AddFrame(graph, passes);
     if (!Settled() || !graph.Capturable()) {
-        return graph.Execute(context_.Main(), waits);
+        return graph.Execute(*queue_, waits);
     }
     if (captured_.size() == kKeptFrames) {
         captured_.erase(captured_.begin());
     }
-    captured_.push_back({now, graph.Capture(context_.Main())});
+    captured_.push_back({now, graph.Capture(*queue_)});
     return captured_.back().graph->Submit(waits);
 }
 

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

@@ -86,6 +86,13 @@ class DeviceScene {
     /// @return The frame's ticket.
     Ticket Step(const std::function<void(graph::Graph&)>& passes, std::uint64_t key,
                 std::span<const Ticket> waits = {});
+    /// @brief Runs frames on `queue` from now on, the main queue to begin with: the compute
+    /// queue runs them apart from a UI drawing on the main one. Frames on another queue wait
+    /// for the main queue's work submitted before them.
+    void SetQueue(Queue& queue);
+    Queue& FrameQueue() const {
+        return *queue_;
+    }
     /// @return Whether the last `Step` replayed a captured frame.
     bool Replayed() const {
         return replayed_;
@@ -111,9 +118,12 @@ class DeviceScene {
     void AddFrame(graph::Graph& graph, const std::function<void(graph::Graph&)>& passes);
     /// @return Whether no work waits for a later frame.
     bool Settled() const;
+    /// @return `waits`, and on a queue other than the main one, the main queue's last ticket.
+    std::vector<Ticket> Waits(std::span<const Ticket> waits) const;
 
     DeviceContext& context_;
     const Scene& scene_;
+    Queue* queue_;
     graph::TransientPool pool_;
     SceneColumns columns_;
     TransformGraph transforms_;