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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev137
+Version: 0.2.0.dev140
 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.dev137 → ernie_renderer-0.2.0.dev140}/cmake/EmbedShader.cmake

@@ -17,6 +17,7 @@ endforeach()
 
 set(chunks "")
 string(LENGTH "${source}" length)
+# MSVC limits a string literal to 16 KB; concatenated pieces may total any length.
 set(chunk 8192)
 set(at 0)
 while(at LESS length)
@@ -29,8 +30,14 @@ if(chunks STREQUAL "")
 endif()
 
 file(RELATIVE_PATH from "${ROOT}" "${INPUT}")
+# A file with a part C++ reads shares its types: the header brings them too.
+set(shared "")
+string(FIND "${source}" "#ifdef __cplusplus" cplusplus)
+if(NOT cplusplus EQUAL -1)
+    set(shared "#include \"${from}\"\n")
+endif()
 set(header
-    "// Generated from ${from} by cmake/EmbedShader.cmake: edit that file.\n#pragma once\n\n#include \"ernie/device/shader_compiler.h\"\n\nnamespace ernie::shaders {\n\ninline const ShaderModule ${identifier}{\n    \"${NAME}\",\n${chunks}};\n\n}  // namespace ernie::shaders\n"
+    "// Generated from ${from} by cmake/EmbedShader.cmake: edit that file.\n#pragma once\n\n#include \"ernie/device/shader_compiler.h\"\n${shared}\nnamespace ernie::shaders {\n\ninline const ShaderModule ${identifier}{\n    \"${NAME}\",\n${chunks}};\n\n}  // namespace ernie::shaders\n"
 )
 # Unchanged headers keep their times, so nothing that includes them rebuilds.
 if(EXISTS "${OUTPUT}")

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/cmake/third_party/slang.cmake

@@ -6,9 +6,6 @@ set(ERNIE_DEP_VERSION_slang
 )
 mark_as_advanced(ERNIE_DEP_VERSION_slang)
 
-# Prebuilt Slang: the compiler Ernie links to turn Slang modules into SPIR-V (and WGSL) at run
-# time, so user models compile into Ernie's kernels. The Linux builds target old glibc versions,
-# so they run wherever manylinux_2_34 wheels do.
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
     set(slang_platform linux-x86_64-glibc-2.27)
     set(slang_sha256 ae348a33d906ed29d14c2294f2260746cb2c3eb4aa2c7fc4bfd887a3a298737d)

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/device/column.h

@@ -6,6 +6,7 @@
 
 #include "ernie/device/arena.h"
 #include "ernie/device/staging.h"
+#include "ernie/shaders/shared.h"
 #include "ernie/util/algorithm.h"
 #include "ernie/util/tensor.h"
 
@@ -106,6 +107,11 @@ class DeviceColumn {
     BufferRange range_;
 };
 
+/// @return A shader's handle of a column's rows as `T`s.
+template <typename T> shaders::BufferRef<T> ToBufferRef(const DeviceColumn& column) {
+    return {column.Address()};
+}
+
 /// @brief Stages `rows` of a host mirror into the same rows of `column`. The rows are sorted and
 /// made unique in place, and those past the mirror's end dropped; the caller clears them.
 template <typename T>

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

@@ -52,8 +52,13 @@ struct ShaderCompiler::Session {
         std::array<slang::CompilerOptionEntry, 1> options{};
         options[0].name = slang::CompilerOptionName::MatrixLayoutColumn;
         options[0].value.intValue0 = 1;
+        // WebGPU has no buffer pointers: ref.slang reads buffers through bound arenas there.
+        const slang::PreprocessorMacroDesc webGpu{.name = "ERNIE_WEBGPU", .value = "1"};
+        const bool wgsl = format == SLANG_WGSL;
         const slang::SessionDesc description{.targets = &target,
                                              .targetCount = 1,
+                                             .preprocessorMacros = wgsl ? &webGpu : nullptr,
+                                             .preprocessorMacroCount = wgsl ? 1 : 0,
                                              .compilerOptionEntries = options.data(),
                                              .compilerOptionEntryCount =
                                                  static_cast<std::uint32_t>(options.size())};

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/graph/graph.h

@@ -90,6 +90,10 @@ struct BufferSlice {
     VkDeviceAddress Address() const {
         return buffer->Address() + offset;
     }
+    /// @return A shader's handle of the slice as `T`s.
+    template <typename T> shaders::BufferRef<T> BufferRef() const {
+        return {Address()};
+    }
 };
 
 class Graph;

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

@@ -364,8 +364,8 @@ void GeometryPool::AddUploads(graph::Graph& graph) {
                                 .halfLength = geometry.halfLength,
                                 .vertexCount = geometry.vertexCount,
                                 .triangleCount = geometry.triangleCount,
-                                .vertices = address(geometry.vertices),
-                                .indices = address(geometry.indices)};
+                                .vertices = {address(geometry.vertices)},
+                                .indices = {address(geometry.indices)}};
         }
         StageRows(uploader_, *records_, hostRecords_, dirtyRecords_);
         dirtyRecords_.clear();

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/geometry.h

@@ -10,6 +10,7 @@
 #include "ernie/graph/graph.h"
 #include "ernie/render/prim_rows.h"
 #include "ernie/scene/scene.h"
+#include "ernie/shaders/scene/geometry.slang"
 
 #include <glm/glm.hpp>
 
@@ -24,7 +25,15 @@ namespace ernie {
 /// cylinder and cone about +z with z in [-1, 1] (the cone's apex at +1), a capsule of radius 1
 /// about a segment of half-length `Geometry::halfLength`, and a unit square in z = 0 facing +z
 /// (planes, and ground planes 200 km across).
-enum class GeometryKind : std::uint8_t { Triangles, Sphere, Cube, Cylinder, Cone, Capsule, Plane };
+enum class GeometryKind : std::uint8_t {
+    Triangles = shaders::kTriangles,
+    Sphere = shaders::kSphere,
+    Cube = shaders::kCube,
+    Cylinder = shaders::kCylinder,
+    Cone = shaders::kCone,
+    Capsule = shaders::kCapsule,
+    Plane = shaders::kPlane,
+};
 
 using GeometryId = std::uint32_t;
 
@@ -41,19 +50,8 @@ struct Geometry {
     float halfLength = 0.0f;
 };
 
-/// @brief A geometry as kernels read it from `GeometryPool::Records`, by geometry id: an instance's
-/// custom index.
-struct GeometryRecord {
-    /// A `GeometryKind`.
-    std::uint32_t kind = 0;
-    float halfLength = 0.0f;
-    std::uint32_t vertexCount = 0;
-    std::uint32_t triangleCount = 0;
-    /// Triangles' float x, y, z positions and their uint32 indices, by device address.
-    std::uint64_t vertices = 0;
-    std::uint64_t indices = 0;
-};
-static_assert(sizeof(GeometryRecord) == 32);
+/// @brief A geometry as kernels read it from `GeometryPool::Records`, as geometry.slang defines it.
+using GeometryRecord = shaders::GeometryRecord;
 
 /// @brief What a prim draws: its geometry, and the transform from the geometry's frame to the
 /// prim's, which sizes and turns a unit shape.

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

@@ -20,24 +20,8 @@
 namespace ernie {
 namespace {
 
-constexpr std::uint32_t kNoImage = 0xffffffff;
-
-/// A view as camera.slang's `View` reads it.
-struct ViewRecord {
-    std::array<glm::vec4, 3> rows;
-    glm::vec2 halfExtent;
-    glm::uvec2 size;
-    glm::vec3 background;
-    std::uint32_t colour;
-    VkDeviceAddress distances, normals, instances, albedos, ldr;
-};
-static_assert(sizeof(ViewRecord) == 120);
-
-struct CameraParameters {
-    TracerParameters tracer;
-    VkDeviceAddress views, colours;
-    std::uint32_t count, pad;
-};
+using shaders::CameraParameters;
+using shaders::View;
 
 /// The most `vkCmdUpdateBuffer` writes at once.
 constexpr std::size_t kUpdateBytes = 65536;
@@ -50,17 +34,24 @@ std::vector<std::uint32_t> Compile(const ShaderCompiler& compiler) {
 
 /// @return A view's record, its output addresses left for the pass to fill in once the graph has
 /// placed them.
-ViewRecord ToViewRecord(const PinholeView& view, const CameraOutputs& outputs,
-                        const glm::dvec3& origin) {
+/// @return A kernel's handle of an output, or a null one when it is left out.
+template <typename T>
+shaders::BufferRef<T> BufferRefOrNull(const graph::PassContext& pass,
+                                      const std::optional<graph::Buffer>& buffer) {
+    return buffer ? pass.Get(*buffer).BufferRef<T>() : shaders::BufferRef<T>{};
+}
+
+View ToView(const PinholeView& view, const CameraOutputs& outputs, const glm::dvec3& origin) {
     // Relative to the origin in double, then rounded: values near the camera stay small.
     const glm::dmat4 relative = glm::translate(glm::dmat4(1.0), -origin) * view.cameraToWorld;
     const double tangent = std::tan(0.5 * view.verticalFov);
     const double aspect = static_cast<double>(view.size.x) / static_cast<double>(view.size.y);
-    return {.rows = ToAffineRows(relative),
+    const std::array<glm::vec4, 3> rows = ToAffineRows(relative);
+    return {.rows = {rows[0], rows[1], rows[2]},
             .halfExtent = glm::vec2(tangent * aspect, tangent),
             .size = view.size,
             .background = outputs.background,
-            .colour = outputs.colour ? outputs.colourIndex.value : kNoImage};
+            .colour = outputs.colour ? outputs.colourIndex.value : shaders::kNoImage};
 }
 
 }  // namespace
@@ -83,13 +74,13 @@ void CameraPass::Add(graph::Graph& graph, std::span<CameraView> views) const {
     if (views.empty()) {
         return;
     }
-    std::vector<ViewRecord> records;
+    std::vector<View> records;
     glm::uvec2 largest{0};
     for (const CameraView& view : views) {
-        records.push_back(ToViewRecord(view.view, view.outputs, scene->origin));
+        records.push_back(ToView(view.view, view.outputs, scene->origin));
         largest = glm::max(largest, view.view.size);
     }
-    graph::Buffer staged = graph.Create(records.size() * sizeof(ViewRecord), "camera views");
+    graph::Buffer staged = graph.Create(records.size() * sizeof(View), "camera views");
     // For the recording to look up: any version of a resource names it.
     std::vector<CameraOutputs> outputs;
     for (const CameraView& view : views) {
@@ -117,30 +108,27 @@ void CameraPass::Add(graph::Graph& graph, std::span<CameraView> views) const {
         },
         [this, staged, largest, records = std::move(records), outputs = std::move(outputs),
          parameters =
-             CameraParameters{.tracer = scene->parameters, .colours = scene->colourAddress}](
+             CameraParameters{.tracer = scene->parameters, .colours = scene->colourBuffer}](
             graph::PassContext& pass) mutable {
-            const auto address = [&](const std::optional<graph::Buffer>& buffer) {
-                return buffer ? pass.Get(*buffer).Address() : VkDeviceAddress{0};
-            };
             for (std::size_t i = 0; i < records.size(); ++i) {
-                records[i].distances = address(outputs[i].distances);
-                records[i].normals = address(outputs[i].normals);
-                records[i].instances = address(outputs[i].instances);
-                records[i].albedos = address(outputs[i].albedos);
-                records[i].ldr = address(outputs[i].ldr);
+                records[i].distances = BufferRefOrNull<float>(pass, outputs[i].distances);
+                records[i].normals = BufferRefOrNull<float>(pass, outputs[i].normals);
+                records[i].instances = BufferRefOrNull<shaders::uint>(pass, outputs[i].instances);
+                records[i].albedos = BufferRefOrNull<float>(pass, outputs[i].albedos);
+                records[i].ldr = BufferRefOrNull<shaders::uint>(pass, outputs[i].ldr);
             }
             // The records hold the outputs' addresses, known only now, so the pass writes them
             // itself before it reads them.
             const graph::BufferSlice slice = pass.Get(staged);
             const auto* bytes = reinterpret_cast<const std::byte*>(records.data());
-            const std::size_t size = records.size() * sizeof(ViewRecord);
+            const std::size_t size = records.size() * sizeof(View);
             for (std::size_t at = 0; at < size; at += kUpdateBytes) {
                 vkCmdUpdateBuffer(pass.commands, slice.buffer->Handle(), slice.offset + at,
                                   std::min(kUpdateBytes, size - at), bytes + at);
             }
             Barrier(pass.commands, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT,
                     VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_STORAGE_READ_BIT);
-            parameters.views = slice.Address();
+            parameters.views = slice.BufferRef<View>();
             parameters.count = static_cast<std::uint32_t>(records.size());
             kernel_.Dispatch(
                 pass.commands,

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/rt/camera_pass.h

@@ -12,6 +12,8 @@
 #include "ernie/device/kernel.h"
 #include "ernie/device/shader_compiler.h"
 #include "ernie/graph/graph.h"
+#include "ernie/shaders/sensors/camera.slang"
+#include "ernie/shaders/spectral/spectrum.slang"
 
 #include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
@@ -64,9 +66,9 @@ struct CameraView {
 /// pixel, shading what each hits by its albedo and a headlight.
 class CameraPass {
   public:
-    static constexpr std::uint32_t kNoInstance = 0xffffffff;
+    static constexpr std::uint32_t kNoInstance = shaders::kNoInstance;
     /// The spectral bands albedos carry: RGB mode's three, linear sRGB.
-    static constexpr std::uint32_t kBands = 3;
+    static constexpr std::uint32_t kBands = shaders::kBands;
 
     CameraPass(DeviceContext& context, const ShaderCompiler& compiler, const BindlessHeap& heap);
 

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/rt/ray_tracer.cpp

@@ -3,6 +3,7 @@
 /// @brief Keeping the acceleration structures up to date each frame.
 #include "ernie/render/rt/ray_tracer.h"
 
+#include "ernie/shaders/device/buffer_ref.h"
 #include "ernie/shaders/rt/ray_tracer.h"
 #include "ernie/shaders/scene/geometry.h"
 #include "ernie/shaders/scene/shapes.h"
@@ -17,7 +18,8 @@ RayTracer::RayTracer(DeviceContext& context, Arenas& arenas, const ShaderCompile
     : geometry_(geometry), bottoms_(context, arenas, geometry), tops_(context, compiler) {}
 
 std::span<const ShaderModule> RayTracer::Modules() {
-    static const std::array modules{shaders::kGeometry, shaders::kShapes, shaders::kRayTracer};
+    static const std::array modules{shaders::kBufferRef, shaders::kGeometry, shaders::kShapes,
+                                    shaders::kRayTracer};
     return modules;
 }
 
@@ -30,14 +32,15 @@ void RayTracer::AddBuild(graph::Graph& graph, const GeometryPool::Changes& chang
     const graph::Acceleration top = tops_.AddBuild(graph, transforms, instances, bottoms_);
     const DeviceColumn& records = geometry_.Records();
     const DeviceColumn& colours = instances.Colours();
-    graph.Board().Put(TraceScene{
-        .parameters = {.scene = tops_.Structure()->Address(), .records = records.Address()},
-        .top = top,
-        .records = graph.Import(records),
-        .instances = instances.Count(),
-        .colours = graph.Import(colours),
-        .colourAddress = colours.Address(),
-        .origin = transforms.Origin()});
+    graph.Board().Put(
+        TraceScene{.parameters = {.scene = tops_.Structure()->Address(),
+                                  .records = ToBufferRef<shaders::GeometryRecord>(records)},
+                   .top = top,
+                   .records = graph.Import(records),
+                   .instances = instances.Count(),
+                   .colours = graph.Import(colours),
+                   .colourBuffer = ToBufferRef<float>(colours),
+                   .origin = transforms.Origin()});
 }
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/rt/ray_tracer.h

@@ -16,6 +16,7 @@
 #include "ernie/render/rt/bottom_levels.h"
 #include "ernie/render/rt/top_levels.h"
 #include "ernie/render/transform_graph.h"
+#include "ernie/shaders/rt/ray_tracer.slang"
 
 #include <glm/vec3.hpp>
 
@@ -24,14 +25,8 @@
 
 namespace ernie {
 
-/// @brief What a tracing kernel hands `RayTracer`, as ray_tracer.slang's `TracerParameters`.
-struct TracerParameters {
-    /// The top level's device address.
-    std::uint64_t scene = 0;
-    /// `GeometryPool::Records`' device address.
-    std::uint64_t records = 0;
-};
-static_assert(sizeof(TracerParameters) == 16);
+/// @brief What a tracing kernel hands its `RayTracer`, as ray_tracer.slang defines it.
+using TracerParameters = shaders::TracerParameters;
 
 /// @brief What a frame's passes trace, left on the graph's blackboard by `RayTracer::AddBuild`.
 struct TraceScene {
@@ -39,9 +34,9 @@ struct TraceScene {
     graph::Acceleration top;
     graph::Buffer records;
     std::uint32_t instances = 0;
-    /// Each instance row's albedo, three linear RGB floats, and their device address.
+    /// Each instance row's albedo, three linear RGB floats, and kernels' handle of them.
     graph::Buffer colours;
-    std::uint64_t colourAddress = 0;
+    shaders::BufferRef<float> colourBuffer;
     /// The render origin the structures are relative to: rays start from points less it.
     glm::dvec3 origin{0.0};
 

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/rt/top_levels.cpp

@@ -15,10 +15,8 @@
 namespace ernie {
 namespace {
 
-struct WriteParameters {
-    VkDeviceAddress worlds, nodes, geometries, shapes, bottoms, instances;
-    std::uint32_t count, pad;
-};
+using shaders::WriteParameters;
+static_assert(sizeof(shaders::Instance) == sizeof(AccelerationInstance));
 
 std::vector<std::uint32_t> Compile(const ShaderCompiler& compiler) {
     std::vector<ShaderModule> modules(TransformGraph::WorldModules().begin(),
@@ -81,8 +79,13 @@ void TopLevels::AddWritePass(graph::Graph& graph, const TransformGraph& transfor
         [this, reads, records, count](graph::PassContext& pass) {
             const auto address = [&](std::size_t read) { return pass.Get(reads[read]).Address(); };
             writer_.Dispatch(pass.commands, {DivideRoundUp(count, 64u), 1, 1},
-                             WriteParameters{address(0), address(1), address(2), address(3),
-                                             address(4), pass.Get(records).Address(), count, 0});
+                             WriteParameters{{address(0)},
+                                             {address(1)},
+                                             {address(2)},
+                                             {address(3)},
+                                             {address(4)},
+                                             pass.Get(records).BufferRef<shaders::Instance>(),
+                                             count});
         });
 }
 

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/transform_graph.cpp

@@ -6,6 +6,7 @@
 
 #include "ernie/scene/schema/geom.h"
 #include "ernie/scene/tokens.h"
+#include "ernie/shaders/device/buffer_ref.h"
 #include "ernie/shaders/math/affine.h"
 #include "ernie/shaders/math/double_float.h"
 #include "ernie/shaders/scene/transform.h"
@@ -21,25 +22,25 @@
 namespace ernie {
 namespace {
 
-struct LocalParameters {
-    VkDeviceAddress slots, programs, lengths, locals;
-    std::uint32_t count, pad;
-};
-struct ComposeParameters {
-    VkDeviceAddress slots, parents, locals, worlds;
-    std::uint32_t count, pad;
-};
-static_assert(sizeof(TransformGraph::DeviceOp) == 112);
+using shaders::ComposeParameters;
+using shaders::LocalParameters;
+
+// The shaders tell op kinds apart by these, so `XformOpKind` keeps its order.
+static_assert(TransformGraph::OpKind(XformOpKind::Translate) == shaders::kTranslate);
+static_assert(TransformGraph::OpKind(XformOpKind::Scale) == shaders::kScale);
+static_assert(TransformGraph::OpKind(XformOpKind::RotateX) == shaders::kRotateX);
+static_assert(TransformGraph::OpKind(XformOpKind::RotateXYZ) == shaders::kRotateXYZ);
+static_assert(TransformGraph::OpKind(XformOpKind::Orient) == shaders::kOrient);
 
 /// @return A transform's top three rows, each value split exactly into a high and a low float.
 TransformGraph::SplitRows Split(const glm::dmat4& m) {
     TransformGraph::SplitRows rows{};
     for (int r = 0; r < 3; ++r) {
         for (int c = 0; c < 4; ++c) {
-            const auto at = static_cast<std::size_t>(r * 4 + c);
             const double value = m[c][r];
-            rows[at] = static_cast<float>(value);
-            rows[12 + at] = static_cast<float>(value - static_cast<double>(rows[at]));
+            const auto high = static_cast<float>(value);
+            rows.high[r][c] = high;
+            rows.low[r][c] = static_cast<float>(value - static_cast<double>(high));
         }
     }
     return rows;
@@ -131,7 +132,8 @@ void TransformGraph::SetOrigin(const glm::dvec3& origin) {
 }
 
 std::span<const ShaderModule> TransformGraph::WorldModules() {
-    static const std::array modules{shaders::kAffine, shaders::kDoubleFloat, shaders::kTransform};
+    static const std::array modules{shaders::kBufferRef, shaders::kAffine, shaders::kDoubleFloat,
+                                    shaders::kTransform};
     return modules;
 }
 
@@ -366,7 +368,7 @@ TransformGraph::Built TransformGraph::BuildProgram(std::uint32_t slot) const {
     // Runs of the host's ops become one matrix each.
     const auto fold = [&] {
         if (folded != glm::dmat4(1.0) && built.onDevice) {
-            push({.kind = kConstantOp, .constant = Split(folded)});
+            push({.kind = shaders::kConstant, .constant = Split(folded)});
             folded = glm::dmat4(1.0);
         }
     };
@@ -381,8 +383,8 @@ TransformGraph::Built TransformGraph::BuildProgram(std::uint32_t slot) const {
         const DeviceColumn& column = *bound->column;
         const auto floats = static_cast<std::uint32_t>(CountFloats(column));
         push({.kind = OpKind(op.kind),
-              .flags = (op.invert ? kInvertFlag : 0u) | floats << kFloatsShift,
-              .source = bound->address + row * column.RowBytes()});
+              .flags = (op.invert ? shaders::kInvert : 0u) | floats << shaders::kFloatsShift,
+              .source = {bound->address + row * column.RowBytes()}});
     }
     fold();
     built.local = Split(folded);
@@ -509,16 +511,20 @@ void TransformGraph::UploadDirty() {
 
 void TransformGraph::DispatchLocals(VkCommandBuffer commands) const {
     local_.Dispatch(commands, Groups(programmed_.slots.size()),
-                    LocalParameters{programmed_.device->Address(), programColumn_->Address(),
-                                    lengthColumn_->Address(), localColumn_->Address(),
-                                    static_cast<std::uint32_t>(programmed_.slots.size()), 0});
+                    LocalParameters{ToBufferRef<shaders::uint>(*programmed_.device),
+                                    ToBufferRef<DeviceOp>(*programColumn_),
+                                    ToBufferRef<shaders::uint>(*lengthColumn_),
+                                    ToBufferRef<shaders::float4>(*localColumn_),
+                                    static_cast<std::uint32_t>(programmed_.slots.size())});
 }
 
 void TransformGraph::DispatchLevel(VkCommandBuffer commands, const SlotList& level) const {
     compose_.Dispatch(commands, Groups(level.slots.size()),
-                      ComposeParameters{level.device->Address(), parentColumn_->Address(),
-                                        localColumn_->Address(), worlds_->Address(),
-                                        static_cast<std::uint32_t>(level.slots.size()), 0});
+                      ComposeParameters{ToBufferRef<shaders::uint>(*level.device),
+                                        ToBufferRef<shaders::uint>(*parentColumn_),
+                                        ToBufferRef<shaders::float4>(*localColumn_),
+                                        ToBufferRef<shaders::float4>(*worlds_),
+                                        static_cast<std::uint32_t>(level.slots.size())});
 }
 
 Ticket TransformGraph::Update(std::span<const Ticket> waits) {

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/render/transform_graph.h

@@ -13,6 +13,7 @@
 #include "ernie/render/prim_rows.h"
 #include "ernie/scene/scene.h"
 #include "ernie/scene/xform.h"
+#include "ernie/shaders/scene/transform.slang"
 
 #include <array>
 #include <cstdint>
@@ -47,30 +48,17 @@ namespace ernie {
 /// them over by walking only that subtree.
 class TransformGraph {
   public:
-    static constexpr std::uint32_t kNone = std::numeric_limits<std::uint32_t>::max();
-    /// The most ops a program holds: device ops and the folded host ops between them.
-    static constexpr std::uint32_t kMaxOps = 8;
-    /// A transform's top three rows in double-float, as the device keeps them: the high floats'
-    /// twelve, then the low floats' twelve, each value their sum.
-    using SplitRows = std::array<float, 24>;
+    static constexpr std::uint32_t kNone = shaders::kNone;
+    static constexpr std::uint32_t kMaxOps = shaders::kMaxOps;
+    /// A transform's top three rows in double-float, as the device keeps them.
+    using SplitRows = shaders::SplitRows;
     /// One op of a program, as the device reads it.
-    struct DeviceOp {
-        std::uint32_t kind = 0;
-        /// Bit 0 inverts; bits 8 to 15 count the floats the op reads.
-        std::uint32_t flags = 0;
-        VkDeviceAddress source = 0;
-        SplitRows constant{};
-        bool operator==(const DeviceOp&) const = default;
-    };
+    using DeviceOp = shaders::Op;
     using Program = std::array<DeviceOp, kMaxOps>;
-    /// A `DeviceOp::kind`: a folded constant, then each `XformOpKind` after it.
-    static constexpr std::uint32_t kConstantOp = 0;
+    /// @return An op's kind: each `XformOpKind` after the folded constant's.
     static constexpr std::uint32_t OpKind(XformOpKind kind) {
         return 1 + static_cast<std::uint32_t>(kind);
     }
-    /// `DeviceOp::flags`' inverting bit, and where its float count starts.
-    static constexpr std::uint32_t kInvertFlag = 1;
-    static constexpr std::uint32_t kFloatsShift = 8;
 
     TransformGraph(DeviceContext& context, Arenas& arenas, const Scene& scene,
                    const ShaderCompiler& compiler);

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/shaders/CMakeLists.txt

@@ -2,6 +2,7 @@
 ernie_add_shaders(
     ernie_shaders
     device/bindless.slang
+    device/buffer_ref.slang
     math/affine.slang
     math/double_float.slang
     rt/ray_tracer.slang

{ernie_renderer-0.2.0.dev137 → ernie_renderer-0.2.0.dev140}/ernie/shaders/device/bindless.slang

@@ -6,6 +6,6 @@
 ///     import bindless;
 ///     images[NonUniformResourceIndex(parameters.image)][pixel] = colour;
 
-[[vk::binding(0, 0)]] public Texture2D textures[];
-[[vk::binding(1, 0)]] public RWTexture2D<float4> images[];
-[[vk::binding(2, 0)]] public SamplerState samplers[];
+[[vk::binding(0, 0)]] Texture2D textures[];
+[[vk::binding(1, 0)]] RWTexture2D<float4> images[];
+[[vk::binding(2, 0)]] SamplerState samplers[];

ernie_renderer-0.2.0.dev140/ernie/shaders/device/buffer_ref.slang

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file buffer_ref.slang
+/// @brief `BufferRef<T>`, the one way shaders reach buffers, so a backend without device addresses can
+/// run them. Its 8 bytes are a buffer's device address on Vulkan. WebGPU has no pointers, so
+/// there (`ERNIE_WEBGPU`) they are an arena index and a byte offset, read through the arenas
+/// bound as byte buffers. Data keeps the same packed layout either way.
+///
+///     struct Parameters { BufferRef<float> values; uint count; };
+///     parameters.values[i] = 2 * parameters.values[i];
+
+#if defined(ERNIE_WEBGPU)
+
+/// The most arenas a WebGPU kernel reaches.
+static const uint kArenas = 8;
+[[vk::binding(0, 1)]] RWByteAddressBuffer arenas[kArenas];
+
+struct BufferRef<T> {
+    uint arena;
+    /// Bytes into the arena; `kNull` for none.
+    uint offset;
+
+    static const uint kNull = 0xffffffff;
+
+    bool IsNull() {
+        return offset == kNull;
+    }
+
+    __subscript(uint index) -> T {
+        get {
+            return arenas[arena].Load<T>(offset + index * sizeof(T));
+        }
+        [nonmutating] set {
+            arenas[arena].Store<T>(offset + index * sizeof(T), newValue);
+        }
+    }
+}
+
+#else
+
+struct BufferRef<T> {
+    /// The buffer's device address; 0 for none.
+    uint64_t handle;
+
+    bool IsNull() {
+        return handle == 0;
+    }
+
+    __subscript(uint index) -> T {
+        get {
+            return ((T*)handle)[index];
+        }
+        [nonmutating] set {
+            ((T*)handle)[index] = newValue;
+        }
+    }
+}
+
+#endif