ernie-renderer 0.2.0.dev140__tar.gz → 0.2.0.dev148__tar.gz

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev140
+Version: 0.2.0.dev148
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause
@@ -87,67 +87,54 @@ Future work:
 - Benchmark against RTX, Cycles, Newton Warp Raytrace, Madrona both in speed, throughput, and image quality
 - Validation with real-world sensors and scenes.
 
-## Installation
+## Quick Start
 
-The Python package is on PyPI as `ernie-renderer` (Python 3.10 or later, with a Vulkan 1.3 driver). It bundles everything else, the viewer and the native `ernie` program included:
+We recommend starting with the Python package. Install it and open the Ernie Viewer:
 
 ```sh
 pip install ernie-renderer
+python -m ernie
 ```
 
-Each GitHub release also has an `ernie` package for Ubuntu 22.04+, Debian 12+ and RHEL 9+ (and a tarball for other distributions), with the library, the viewer, and the headers and CMake package for building against it in C++. Download it from the [latest release](https://github.com/alexmaietta/ernie/releases/latest) and install it with a Vulkan driver: Mesa's below, which includes the lavapipe software driver for machines without a GPU, or your GPU vendor's.
+Ernie ships with built-in demos covering cameras and sensors, lighting, atmospheres, terrain, lasers and batched rendering. Open the Demos panel in the viewer and explore. Each demo is written in both C++ and Python, and the two versions render the same image.
 
-```sh
-# Debian, Ubuntu
-sudo apt install mesa-vulkan-drivers
-sudo apt install ./ernie_*.deb
+From the command line, `python -m ernie --list` names every demo, `python -m ernie --demo demo_atmosphere_earth` runs one, and `--help` lists every option.
 
-# RHEL, Rocky, Fedora
-sudo dnf install mesa-vulkan-drivers
-sudo dnf install ./ernie-*.rpm
-```
+## Installation
+
+Ernie needs a Vulkan 1.3 driver: your GPU vendor's, or Mesa's (`mesa-vulkan-drivers`), which includes the lavapipe software driver for machines without a GPU.
 
-### Docker
+### Python
 
-The `ernie` program is also published as a Docker image.
+Python 3.10 or later. `pip` installs `ernie-renderer` from [PyPI](https://pypi.org/project/ernie-renderer/); the package bundles everything else, the viewer included.
 
 ```sh
-docker run --rm --gpus all -v "$PWD:/out" ghcr.io/alexmaietta/ernie --demo demo_atmosphere_earth --viewer null --output /out/earth.png
+pip install ernie-renderer
 ```
 
-### Build from source
+### C++
 
-Ernie needs CMake 3.24+, a C++20 compiler, Python 3.10+ with its development headers (or `-DERNIE_BUILD_PYTHON=OFF`) and a Vulkan 1.3 driver. Small dependencies are vendored; Slang and OpenEXR are fetched on first configure (see [third_party/README.md](third_party/README.md)).
+Each [GitHub release](https://github.com/alexmaietta/ernie/releases/latest) has an `ernie` package for Ubuntu 22.04+, Debian 12+ and RHEL 9+ (and a tarball for other distributions) with the library, the viewer, the headers and the CMake package.
 
 ```sh
-cmake -S . -B build -DERNIE_BUILD_TESTS=ON
-cmake --build build
-ctest --test-dir build -j4              # C++, GPU and Python tests
-build/bin/ernie                         # the viewer
-cmake --install build --prefix ~/.local # libernie, headers and the CMake package
+sudo apt install ./ernie_*.deb   # Debian, Ubuntu
+sudo dnf install ./ernie-*.rpm   # RHEL, Rocky, Fedora
 ```
 
-To build the Python wheel instead, run `uv build --wheel --out-dir dist .` and `uv pip install dist/ernie_renderer-*.whl`; for the Linux packages, `cmake --preset package-deb` (or `package-rpm`), `cmake --build --preset package-deb` and `cpack --preset package-deb`. See [CONTRIBUTING.md](CONTRIBUTING.md) for the build options, testing without a GPU on lavapipe, and benchmarks.
+The viewer is also a Docker image: `docker run --rm --gpus all ghcr.io/alexmaietta/ernie --help`.
 
-## Quick Start
-
-Run `ernie` to open the Ernie Viewer. Its Demos panel runs any of the built-in demos, each written in both C++ and Python, covering cameras and sensors, lighting, atmospheres, terrain, lasers, batched rendering and the viewer; the two versions of a demo render the same image.
-
-```sh
-ernie                               # the viewer, with the Demos panel
-ernie --list                        # every demo's name
-ernie --demo demo_atmosphere_earth  # run one demo
-ernie --help                        # every option
-```
+### Build from source
 
-`python -m ernie` opens the same viewer and takes the same options, and `python -m ernie.demos` runs the Python version of a demo:
+CMake 3.24+, a C++20 compiler and Python 3.10+ with its development headers (or `-DERNIE_BUILD_PYTHON=OFF`). Small dependencies are vendored; Slang and OpenEXR are fetched on first configure.
 
 ```sh
-python -m ernie.demos --list
-python -m ernie.demos demo_atmosphere_earth
+cmake -S . -B build -DERNIE_BUILD_TESTS=ON
+cmake --build build
+ctest --test-dir build -j4                # C++, GPU and Python tests
+cmake --install build --prefix ~/.local   # libernie, headers and the CMake package
 ```
 
-Every demo takes common options, such as `--viewer null` to render without a window and `--output frame.png` to save the last frame; `--help` lists them.
+For the Python wheel, `uv build --wheel --out-dir dist .`; for Linux packages, `cmake --preset package-deb` (or `package-rpm`), then `cmake --build --preset package-deb` and `cpack --preset package-deb`.
 
 ## Your First Render
 
@@ -187,10 +174,14 @@ target_link_libraries(my_app PRIVATE Ernie::ernie)
 ```
 
 ```cpp
-#include <ernie/scene/schemas.h>
+#include <ernie/render/renderer.h>
+#include <ernie/scene/schema/camera.h>
+#include <ernie/scene/schema/geom.h>
+#include <ernie/scene/schema/lux.h>
+#include <ernie/scene/schema/planet.h>
+#include <ernie/scene/schema/render.h>
 #include <ernie/scene/tokens.h>
 #include <ernie/scene/xform.h>
-#include <ernie/render/renderer.h>
 
 int main() {
     using namespace ernie;
@@ -230,3 +221,34 @@ If you use Ernie in your research, please cite it. GitHub's "Cite this repositor
 ## License
 
 Ernie is licensed under the [BSD 3-Clause License](LICENSE). The third-party libraries it bundles keep their own licenses, listed in [third_party/README.md](third_party/README.md).
+
+## Acknowledgements
+
+Ernie is built on these open-source projects. Versions and licenses are in [third_party/README.md](third_party/README.md).
+
+- [Vulkan Headers](https://github.com/KhronosGroup/Vulkan-Headers), [volk](https://github.com/zeux/volk) and [Vulkan Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator) for the GPU layer
+- [Slang](https://github.com/shader-slang/slang) for shaders
+- [DLPack](https://github.com/dmlc/dlpack) for sharing tensors with PyTorch, JAX, Warp and NumPy
+- [nanobind](https://github.com/wjakob/nanobind) for the Python bindings
+- [GLM](https://github.com/g-truc/glm) for math
+- [OpenEXR and Imath](https://github.com/AcademySoftwareFoundation/openexr), [stb](https://github.com/nothings/stb), [Basis Universal](https://github.com/BinomialLLC/basis_universal) and [bc7enc_rdo](https://github.com/richgel999/bc7enc_rdo) for images and textures
+- [NanoVDB](https://github.com/AcademySoftwareFoundation/openvdb) for volumes
+- [nlohmann/json](https://github.com/nlohmann/json) for JSON
+- [OpenUSD](https://openusd.org/) for scene interchange, with Ernie's schemas published as a USD schema plugin
+- [Dear ImGui](https://github.com/ocornut/imgui) and [GLFW](https://github.com/glfw/glfw) for the viewer
+- [Tracy](https://github.com/wolfpld/tracy) for profiling
+- [GoogleTest](https://github.com/google/googletest) for tests
+
+Ernie also leverages ideas from these renderers and projects:
+
+- [Madrona](https://madrona-engine.github.io/) for batch rendering across many worlds
+- [Chrono::Sensor](https://api.projectchrono.org/group__sensor.html) for sensor simulation inside Chrono
+- [Cycles](https://www.cycles-renderer.org/), [Mitsuba 3](https://www.mitsuba-renderer.org/) and [PBRT](https://pbrt.org/) for physically based and spectral rendering
+- [Unreal Engine](https://www.unrealengine.com/)'s Render Dependency Graph and Frostbite's FrameGraph for the frame graph
+- [OpenUSD](https://openusd.org/) and Omniverse Fabric for the schema-based, columnar scene
+- [nvpro-samples](https://github.com/nvpro-samples) for Vulkan ray tracing and cluster LOD
+- [PANGU](https://pangu.software/) for planetary and asteroid surface simulation
+- [IRIS](https://dartslab.jpl.nasa.gov/References/pdf/IRIS_aiaa2022SciTech.pdf) for real-time, closed-loop rendering of space sensors
+- [CosmoScout VR](https://github.com/cosmoscout/cosmoscout-vr) for planet-scale scenes and solar-system visualization
+- [three-geospatial](https://github.com/takram-design-engineering/three-geospatial) for atmospheres and clouds
+- [Isaac Lab](https://github.com/isaac-sim/IsaacLab) and [Newton](https://github.com/newton-physics/newton) for tiled cameras in robot learning

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/README.md

@@ -70,67 +70,54 @@ Future work:
 - Benchmark against RTX, Cycles, Newton Warp Raytrace, Madrona both in speed, throughput, and image quality
 - Validation with real-world sensors and scenes.
 
-## Installation
+## Quick Start
 
-The Python package is on PyPI as `ernie-renderer` (Python 3.10 or later, with a Vulkan 1.3 driver). It bundles everything else, the viewer and the native `ernie` program included:
+We recommend starting with the Python package. Install it and open the Ernie Viewer:
 
 ```sh
 pip install ernie-renderer
+python -m ernie
 ```
 
-Each GitHub release also has an `ernie` package for Ubuntu 22.04+, Debian 12+ and RHEL 9+ (and a tarball for other distributions), with the library, the viewer, and the headers and CMake package for building against it in C++. Download it from the [latest release](https://github.com/alexmaietta/ernie/releases/latest) and install it with a Vulkan driver: Mesa's below, which includes the lavapipe software driver for machines without a GPU, or your GPU vendor's.
+Ernie ships with built-in demos covering cameras and sensors, lighting, atmospheres, terrain, lasers and batched rendering. Open the Demos panel in the viewer and explore. Each demo is written in both C++ and Python, and the two versions render the same image.
 
-```sh
-# Debian, Ubuntu
-sudo apt install mesa-vulkan-drivers
-sudo apt install ./ernie_*.deb
+From the command line, `python -m ernie --list` names every demo, `python -m ernie --demo demo_atmosphere_earth` runs one, and `--help` lists every option.
 
-# RHEL, Rocky, Fedora
-sudo dnf install mesa-vulkan-drivers
-sudo dnf install ./ernie-*.rpm
-```
+## Installation
+
+Ernie needs a Vulkan 1.3 driver: your GPU vendor's, or Mesa's (`mesa-vulkan-drivers`), which includes the lavapipe software driver for machines without a GPU.
 
-### Docker
+### Python
 
-The `ernie` program is also published as a Docker image.
+Python 3.10 or later. `pip` installs `ernie-renderer` from [PyPI](https://pypi.org/project/ernie-renderer/); the package bundles everything else, the viewer included.
 
 ```sh
-docker run --rm --gpus all -v "$PWD:/out" ghcr.io/alexmaietta/ernie --demo demo_atmosphere_earth --viewer null --output /out/earth.png
+pip install ernie-renderer
 ```
 
-### Build from source
+### C++
 
-Ernie needs CMake 3.24+, a C++20 compiler, Python 3.10+ with its development headers (or `-DERNIE_BUILD_PYTHON=OFF`) and a Vulkan 1.3 driver. Small dependencies are vendored; Slang and OpenEXR are fetched on first configure (see [third_party/README.md](third_party/README.md)).
+Each [GitHub release](https://github.com/alexmaietta/ernie/releases/latest) has an `ernie` package for Ubuntu 22.04+, Debian 12+ and RHEL 9+ (and a tarball for other distributions) with the library, the viewer, the headers and the CMake package.
 
 ```sh
-cmake -S . -B build -DERNIE_BUILD_TESTS=ON
-cmake --build build
-ctest --test-dir build -j4              # C++, GPU and Python tests
-build/bin/ernie                         # the viewer
-cmake --install build --prefix ~/.local # libernie, headers and the CMake package
+sudo apt install ./ernie_*.deb   # Debian, Ubuntu
+sudo dnf install ./ernie-*.rpm   # RHEL, Rocky, Fedora
 ```
 
-To build the Python wheel instead, run `uv build --wheel --out-dir dist .` and `uv pip install dist/ernie_renderer-*.whl`; for the Linux packages, `cmake --preset package-deb` (or `package-rpm`), `cmake --build --preset package-deb` and `cpack --preset package-deb`. See [CONTRIBUTING.md](CONTRIBUTING.md) for the build options, testing without a GPU on lavapipe, and benchmarks.
+The viewer is also a Docker image: `docker run --rm --gpus all ghcr.io/alexmaietta/ernie --help`.
 
-## Quick Start
-
-Run `ernie` to open the Ernie Viewer. Its Demos panel runs any of the built-in demos, each written in both C++ and Python, covering cameras and sensors, lighting, atmospheres, terrain, lasers, batched rendering and the viewer; the two versions of a demo render the same image.
-
-```sh
-ernie                               # the viewer, with the Demos panel
-ernie --list                        # every demo's name
-ernie --demo demo_atmosphere_earth  # run one demo
-ernie --help                        # every option
-```
+### Build from source
 
-`python -m ernie` opens the same viewer and takes the same options, and `python -m ernie.demos` runs the Python version of a demo:
+CMake 3.24+, a C++20 compiler and Python 3.10+ with its development headers (or `-DERNIE_BUILD_PYTHON=OFF`). Small dependencies are vendored; Slang and OpenEXR are fetched on first configure.
 
 ```sh
-python -m ernie.demos --list
-python -m ernie.demos demo_atmosphere_earth
+cmake -S . -B build -DERNIE_BUILD_TESTS=ON
+cmake --build build
+ctest --test-dir build -j4                # C++, GPU and Python tests
+cmake --install build --prefix ~/.local   # libernie, headers and the CMake package
 ```
 
-Every demo takes common options, such as `--viewer null` to render without a window and `--output frame.png` to save the last frame; `--help` lists them.
+For the Python wheel, `uv build --wheel --out-dir dist .`; for Linux packages, `cmake --preset package-deb` (or `package-rpm`), then `cmake --build --preset package-deb` and `cpack --preset package-deb`.
 
 ## Your First Render
 
@@ -170,10 +157,14 @@ target_link_libraries(my_app PRIVATE Ernie::ernie)
 ```
 
 ```cpp
-#include <ernie/scene/schemas.h>
+#include <ernie/render/renderer.h>
+#include <ernie/scene/schema/camera.h>
+#include <ernie/scene/schema/geom.h>
+#include <ernie/scene/schema/lux.h>
+#include <ernie/scene/schema/planet.h>
+#include <ernie/scene/schema/render.h>
 #include <ernie/scene/tokens.h>
 #include <ernie/scene/xform.h>
-#include <ernie/render/renderer.h>
 
 int main() {
     using namespace ernie;
@@ -213,3 +204,34 @@ If you use Ernie in your research, please cite it. GitHub's "Cite this repositor
 ## License
 
 Ernie is licensed under the [BSD 3-Clause License](LICENSE). The third-party libraries it bundles keep their own licenses, listed in [third_party/README.md](third_party/README.md).
+
+## Acknowledgements
+
+Ernie is built on these open-source projects. Versions and licenses are in [third_party/README.md](third_party/README.md).
+
+- [Vulkan Headers](https://github.com/KhronosGroup/Vulkan-Headers), [volk](https://github.com/zeux/volk) and [Vulkan Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator) for the GPU layer
+- [Slang](https://github.com/shader-slang/slang) for shaders
+- [DLPack](https://github.com/dmlc/dlpack) for sharing tensors with PyTorch, JAX, Warp and NumPy
+- [nanobind](https://github.com/wjakob/nanobind) for the Python bindings
+- [GLM](https://github.com/g-truc/glm) for math
+- [OpenEXR and Imath](https://github.com/AcademySoftwareFoundation/openexr), [stb](https://github.com/nothings/stb), [Basis Universal](https://github.com/BinomialLLC/basis_universal) and [bc7enc_rdo](https://github.com/richgel999/bc7enc_rdo) for images and textures
+- [NanoVDB](https://github.com/AcademySoftwareFoundation/openvdb) for volumes
+- [nlohmann/json](https://github.com/nlohmann/json) for JSON
+- [OpenUSD](https://openusd.org/) for scene interchange, with Ernie's schemas published as a USD schema plugin
+- [Dear ImGui](https://github.com/ocornut/imgui) and [GLFW](https://github.com/glfw/glfw) for the viewer
+- [Tracy](https://github.com/wolfpld/tracy) for profiling
+- [GoogleTest](https://github.com/google/googletest) for tests
+
+Ernie also leverages ideas from these renderers and projects:
+
+- [Madrona](https://madrona-engine.github.io/) for batch rendering across many worlds
+- [Chrono::Sensor](https://api.projectchrono.org/group__sensor.html) for sensor simulation inside Chrono
+- [Cycles](https://www.cycles-renderer.org/), [Mitsuba 3](https://www.mitsuba-renderer.org/) and [PBRT](https://pbrt.org/) for physically based and spectral rendering
+- [Unreal Engine](https://www.unrealengine.com/)'s Render Dependency Graph and Frostbite's FrameGraph for the frame graph
+- [OpenUSD](https://openusd.org/) and Omniverse Fabric for the schema-based, columnar scene
+- [nvpro-samples](https://github.com/nvpro-samples) for Vulkan ray tracing and cluster LOD
+- [PANGU](https://pangu.software/) for planetary and asteroid surface simulation
+- [IRIS](https://dartslab.jpl.nasa.gov/References/pdf/IRIS_aiaa2022SciTech.pdf) for real-time, closed-loop rendering of space sensors
+- [CosmoScout VR](https://github.com/cosmoscout/cosmoscout-vr) for planet-scale scenes and solar-system visualization
+- [three-geospatial](https://github.com/takram-design-engineering/three-geospatial) for atmospheres and clouds
+- [Isaac Lab](https://github.com/isaac-sim/IsaacLab) and [Newton](https://github.com/newton-physics/newton) for tiled cameras in robot learning

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/cmake/ErnieShaders.cmake

@@ -13,7 +13,7 @@ function(ernie_add_shaders target)
     set(names "")
     foreach(file IN LISTS ARGN)
         get_filename_component(source "${file}" ABSOLUTE)
-        get_filename_component(name "${file}" NAME_WE)
+        get_filename_component(name "${file}" NAME_WLE)
         if(name IN_LIST names)
             message(FATAL_ERROR "Two shader modules are named ${name}")
         endif()

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/app/viewer.cpp

@@ -221,10 +221,11 @@ graph::Image Viewer::AddViewportPass(graph::Graph& graph) {
         CameraOutputs outputs{.colour = viewport,
                               .colourIndex = viewportImage_,
                               .background = glm::vec3(shell_->GetTheme().viewport)};
+        const glm::uvec2 size(viewport_->Description().extent);
         camera_->Add(graph,
                      {.cameraToWorld = orbit.Transform(),
-                      .verticalFov = orbit.verticalFov,
-                      .size = glm::uvec2(viewport_->Description().extent)},
+                      .size = size,
+                      .lens = MakePinhole(orbit.verticalFov, size)},
                      outputs);
         return *outputs.colour;
     }
@@ -232,12 +233,7 @@ graph::Image Viewer::AddViewportPass(graph::Graph& graph) {
         "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);
+            pass.Clear(viewport, shell_->GetTheme().viewport);
         });
     return viewport;
 }
@@ -254,7 +250,8 @@ void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget&
         [&](graph::PassContext& pass) {
             ERNIE_ZONE("Record the UI");
             // Panels and the viewport's image cover every pixel.
-            renderer_->Record(pass.commands, data, target, glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
+            renderer_->Record(pass.commands.Handle(), data, target,
+                              glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
         });
 }
 

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/device/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(
     arena.cpp
     bindless.cpp
     buffer.cpp
+    commands.cpp
     column.cpp
     context.cpp
     profile.cpp

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/device/acceleration.cpp

@@ -297,11 +297,12 @@ std::uint64_t ScratchBytes(std::span<const BottomBuild> bottoms, std::span<const
     return bytes;
 }
 
-void RecordBuilds(VkCommandBuffer commands, std::span<const BottomBuild> bottoms,
+void RecordBuilds(CommandList list, std::span<const BottomBuild> bottoms,
                   std::span<const TopBuild> tops, BufferView scratch) {
     if (bottoms.empty() && tops.empty()) {
         return;
     }
+    const VkCommandBuffer commands = list.Handle();
     const AccelerationPool& pool = BuildPool(bottoms, tops);
     const std::uint64_t alignment = pool.ScratchAlignment();
     VkDeviceAddress next = AlignUp(DeviceAddress(scratch), alignment);
@@ -365,8 +366,9 @@ CompactionQuery::~CompactionQuery() {
     vkDestroyQueryPool(device_, pool_, nullptr);
 }
 
-void CompactionQuery::Record(VkCommandBuffer commands,
+void CompactionQuery::Record(CommandList list,
                              std::span<const AccelerationStructure* const> built) {
+    const VkCommandBuffer commands = list.Handle();
     if (built.size() > capacity_) {
         throw std::invalid_argument("A compaction query holds " + std::to_string(capacity_) +
                                     " sizes, not " + std::to_string(built.size()));
@@ -379,6 +381,11 @@ void CompactionQuery::Record(VkCommandBuffer commands,
         handles.push_back(structure->Handle());
     }
     count_ = static_cast<std::uint32_t>(handles.size());
+    // Sizes are written once the builds before are done.
+    Barrier(commands, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
+            VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
+            VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
+            VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR);
     vkCmdResetQueryPool(commands, pool_, 0, capacity_);
     if (count_ > 0) {
         vkCmdWriteAccelerationStructuresPropertiesKHR(
@@ -410,14 +417,14 @@ std::optional<std::vector<std::uint64_t>> CompactionQuery::Sizes() const {
     return sizes;
 }
 
-void RecordCompaction(VkCommandBuffer commands, const AccelerationStructure& source,
+void RecordCompaction(CommandList commands, const AccelerationStructure& source,
                       const AccelerationStructure& compacted) {
     const VkCopyAccelerationStructureInfoKHR copy{
         .sType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR,
         .src = source.Handle(),
         .dst = compacted.Handle(),
         .mode = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR};
-    vkCmdCopyAccelerationStructureKHR(commands, &copy);
+    vkCmdCopyAccelerationStructureKHR(commands.Handle(), &copy);
 }
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/device/acceleration.h

@@ -20,6 +20,7 @@
 #pragma once
 
 #include "ernie/device/arena.h"
+#include "ernie/device/commands.h"
 
 #include <cstdint>
 #include <optional>
@@ -216,7 +217,7 @@ std::uint64_t ScratchBytes(std::span<const BottomBuild> bottoms, std::span<const
 /// @param scratch At least `ScratchBytes`, used only by these builds until they finish.
 /// @throws std::invalid_argument for a build larger than its target was sized for, an update of
 /// a structure not built updatable, or a target of the wrong kind.
-void RecordBuilds(VkCommandBuffer commands, std::span<const BottomBuild> bottoms,
+void RecordBuilds(CommandList commands, std::span<const BottomBuild> bottoms,
                   std::span<const TopBuild> tops, BufferView scratch);
 
 /// @brief The sizes structures compact to, written after their builds and read back without
@@ -230,7 +231,7 @@ class CompactionQuery {
 
     /// @brief Records writing the compacted sizes of `built`, after a barrier from their builds.
     /// @throws std::invalid_argument for more than the capacity, or a structure not compactable.
-    void Record(VkCommandBuffer commands, std::span<const AccelerationStructure* const> built);
+    void Record(CommandList commands, std::span<const AccelerationStructure* const> built);
     /// @return The sizes in `Record`'s order once the device has written them; none before.
     std::optional<std::vector<std::uint64_t>> Sizes() const;
 
@@ -242,7 +243,7 @@ class CompactionQuery {
 };
 
 /// @brief Records copying `source` into `compacted`, sized from a `CompactionQuery`.
-void RecordCompaction(VkCommandBuffer commands, const AccelerationStructure& source,
+void RecordCompaction(CommandList commands, const AccelerationStructure& source,
                       const AccelerationStructure& compacted);
 
 }  // namespace ernie

ernie_renderer-0.2.0.dev148/ernie/device/commands.cpp

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file commands.cpp
+/// @brief Recording copies and buffer writes on Vulkan.
+#include "ernie/device/commands.h"
+
+#include "ernie/device/buffer.h"
+
+#include <algorithm>
+#include <vector>
+
+namespace ernie {
+namespace {
+
+/// The most `vkCmdUpdateBuffer` writes at once.
+constexpr std::uint64_t kUpdateBytes = 65536;
+
+}  // namespace
+
+void CommandList::Copy(std::span<const BufferRegions> copies) const {
+    std::vector<std::vector<VkBufferCopy>> regions;
+    std::vector<BufferCopies> vulkan;
+    for (const BufferRegions& copy : copies) {
+        std::vector<VkBufferCopy>& converted = regions.emplace_back();
+        for (const CopyRegion& region : copy.regions) {
+            converted.push_back({region.from, region.to, region.bytes});
+        }
+        vulkan.push_back({copy.source->Handle(), copy.destination->Handle(), converted});
+    }
+    CopyBuffers(commands_, vulkan);
+}
+
+void CommandList::Update(const Buffer& buffer, std::uint64_t offset,
+                         std::span<const std::byte> bytes) const {
+    for (std::uint64_t at = 0; at < bytes.size(); at += kUpdateBytes) {
+        const std::uint64_t size = std::min<std::uint64_t>(kUpdateBytes, bytes.size() - at);
+        vkCmdUpdateBuffer(commands_, buffer.Handle(), offset + at, size, bytes.data() + at);
+    }
+    Barrier(commands_, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT,
+            VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, kAnyAccess);
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev148/ernie/device/commands.h

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file commands.h
+/// @brief What device calls record into, and the recording code above `device/` may do without
+/// naming a graphics API: copy between buffers, and write bytes into one.
+///
+///     kernel.Dispatch(pass.commands, groups, parameters);
+///     pass.commands.Update(buffer, offset, bytes);
+#pragma once
+
+#include "ernie/device/vulkan.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+namespace ernie {
+
+class Buffer;
+
+/// @brief A range copied from one buffer offset to another, in bytes.
+struct CopyRegion {
+    std::uint64_t from = 0;
+    std::uint64_t to = 0;
+    std::uint64_t bytes = 0;
+};
+
+/// @brief Regions copied from one buffer to another, or within one.
+struct BufferRegions {
+    const Buffer* source = nullptr;
+    const Buffer* destination = nullptr;
+    std::span<const CopyRegion> regions;
+};
+
+/// @brief Commands being recorded for a queue. On Vulkan a command buffer, which converts to one;
+/// another backend's encoder would take its place.
+class CommandList {
+  public:
+    CommandList(VkCommandBuffer commands) : commands_(commands) {}
+
+    VkCommandBuffer Handle() const {
+        return commands_;
+    }
+
+    /// @brief Records copies between buffers, ordered after earlier work on them and before later
+    /// work.
+    void Copy(std::span<const BufferRegions> copies) const;
+    /// @brief Records writing `bytes` at `offset` of a buffer, seen by the commands after it.
+    void Update(const Buffer& buffer, std::uint64_t offset, std::span<const std::byte> bytes) const;
+
+  private:
+    VkCommandBuffer commands_;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/device/kernel.cpp

@@ -61,8 +61,9 @@ ComputeKernel::~ComputeKernel() {
     vkDestroyPipelineLayout(device_, layout_, nullptr);
 }
 
-void ComputeKernel::Dispatch(VkCommandBuffer commands, glm::uvec3 groups,
+void ComputeKernel::Dispatch(CommandList list, glm::uvec3 groups,
                              std::span<const std::byte> parameters) const {
+    const VkCommandBuffer commands = list.Handle();
     if (parameters.size() != parameterBytes_) {
         throw std::invalid_argument(name_ + " takes " + std::to_string(parameterBytes_) +
                                     " bytes per dispatch, not " +
@@ -80,8 +81,8 @@ void ComputeKernel::Dispatch(VkCommandBuffer commands, glm::uvec3 groups,
     vkCmdDispatch(commands, groups.x, groups.y, groups.z);
 }
 
-void ComputeBarrier(VkCommandBuffer commands) {
-    Barrier(commands, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT,
+void ComputeBarrier(CommandList commands) {
+    Barrier(commands.Handle(), VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT,
             VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
             VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT);
 }

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/device/kernel.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "ernie/device/bindless.h"
+#include "ernie/device/commands.h"
 #include "ernie/device/context.h"
 
 #include <glm/vec3.hpp>
@@ -34,10 +35,10 @@ class ComputeKernel {
     ComputeKernel& operator=(const ComputeKernel&) = delete;
 
     /// @brief Records a dispatch of `groups` workgroups, passing `parameters`.
-    void Dispatch(VkCommandBuffer commands, glm::uvec3 groups,
+    void Dispatch(CommandList commands, glm::uvec3 groups,
                   std::span<const std::byte> parameters = {}) const;
     template <typename T>
-    void Dispatch(VkCommandBuffer commands, glm::uvec3 groups, const T& parameters) const {
+    void Dispatch(CommandList commands, glm::uvec3 groups, const T& parameters) const {
         Dispatch(commands, groups, std::as_bytes(std::span(&parameters, 1)));
     }
 
@@ -56,6 +57,6 @@ class ComputeKernel {
 
 /// @brief Records a barrier ordering earlier dispatches' writes before later dispatches' reads
 /// and writes. The frame graph places these between passes; this is for work recorded by hand.
-void ComputeBarrier(VkCommandBuffer commands);
+void ComputeBarrier(CommandList commands);
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev140 → ernie_renderer-0.2.0.dev148}/ernie/device/profile.cpp

@@ -276,8 +276,9 @@ void GpuProfiler::End(VkCommandBuffer commands, std::uint32_t zone) {
     timer_->End(commands, zone);
 }
 
-GpuZone::GpuZone(const DeviceContext& context, VkCommandBuffer commands, const char* name)
-    : context_(context), commands_(commands) {
+GpuZone::GpuZone(const DeviceContext& context, CommandList list, const char* name)
+    : context_(context), commands_(list.Handle()) {
+    const VkCommandBuffer commands = commands_;
     context.BeginLabel(commands, name);
     GpuProfiler* profiler = context.Profiler();
     if (profiler == nullptr) {