ernie-renderer 0.2.0.dev119__tar.gz → 0.2.0.dev121__tar.gz

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/CMakeLists.txt

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

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

@@ -2,16 +2,22 @@
 # Slang shaders kept in .slang files and embedded in the library, so editors highlight and
 # resolve them and the program needs no files beside it.
 #
-#     ernie_add_shaders(ernie_render shaders/affine.slang shaders/world.slang)
-#     // In C++: #include "ernie/render/shaders/affine.h" for ernie::shaders::kAffine.
+#     ernie_add_shaders(ernie_shaders math/affine.slang rt/ray_tracer.slang)
+#     add_dependencies(ernie_render ernie_shaders)
+#     // In C++: #include "ernie/shaders/rt/ray_tracer.h" for ernie::shaders::kRayTracer.
 
-# Builds each file's header beside its path under the build's include directory, before the
-# target compiles.
+# Adds `target`, which writes each file's header beside its path under the build's include
+# directory. Module names are the files' names, so each must be unique.
 function(ernie_add_shaders target)
     set(headers "")
+    set(names "")
     foreach(file IN LISTS ARGN)
         get_filename_component(source "${file}" ABSOLUTE)
         get_filename_component(name "${file}" NAME_WE)
+        if(name IN_LIST names)
+            message(FATAL_ERROR "Two shader modules are named ${name}")
+        endif()
+        list(APPEND names "${name}")
         file(RELATIVE_PATH relative "${PROJECT_SOURCE_DIR}" "${source}")
         string(REGEX REPLACE "\\.slang$" ".h" relative "${relative}")
         set(header "${PROJECT_BINARY_DIR}/include/${relative}")
@@ -26,5 +32,5 @@ function(ernie_add_shaders target)
         )
         list(APPEND headers "${header}")
     endforeach()
-    target_sources(${target} PRIVATE ${headers})
+    add_custom_target(${target} DEPENDS ${headers} SOURCES ${ARGN})
 endfunction()

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/ernie/CMakeLists.txt

@@ -28,6 +28,7 @@ add_subdirectory(io)
 add_subdirectory(scene)
 add_subdirectory(device)
 add_subdirectory(graph)
+add_subdirectory(shaders)
 add_subdirectory(render)
 
 set(ernie_layers

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/ernie/render/CMakeLists.txt

@@ -2,27 +2,17 @@
 add_library(
     ernie_render
     OBJECT
-    bottom_levels.cpp
     device_scene.cpp
     geometry.cpp
     instances.cpp
     prim_rows.cpp
-    ray_tracer.cpp
+    rt/bottom_levels.cpp
+    rt/ray_tracer.cpp
+    rt/top_levels.cpp
     scene_columns.cpp
-    top_levels.cpp
     transform_graph.cpp
 )
-ernie_add_shaders(
-    ernie_render
-    shaders/affine.slang
-    shaders/compose.slang
-    shaders/double_float.slang
-    shaders/local.slang
-    shaders/ray_tracer.slang
-    shaders/shapes.slang
-    shaders/world.slang
-    shaders/write_instances.slang
-)
+add_dependencies(ernie_render ernie_shaders)
 target_link_libraries(
     ernie_render
     PUBLIC ernie_geometry ernie_scene ernie_graph

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/ernie/render/device_scene.cpp

@@ -11,8 +11,7 @@ DeviceScene::DeviceScene(DeviceContext& context, Arenas& arenas, const Scene& sc
       transforms_(context, arenas, scene, compiler), geometry_(context, arenas, scene),
       instances_(context, arenas) {
     if (context.Capabilities().rayQuery) {
-        bottoms_ = std::make_unique<BottomLevels>(context, arenas, geometry_);
-        tops_ = std::make_unique<TopLevels>(context, compiler);
+        tracer_ = std::make_unique<RayTracer>(context, arenas, compiler, geometry_);
     }
 }
 
@@ -26,10 +25,8 @@ Ticket DeviceScene::Execute(const std::function<void(graph::Graph&)>& passes,
     instances_.Apply(changes);
     geometry_.AddUploads(graph);
     instances_.AddUploads(graph);
-    if (bottoms_) {
-        bottoms_->Apply(changes);
-        bottoms_->AddBuilds(graph);
-        tops_->AddBuild(graph, transforms_, instances_, *bottoms_);
+    if (tracer_) {
+        tracer_->AddBuild(graph, changes, transforms_, instances_);
     }
     if (passes) {
         passes(graph);

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/ernie/render/device_scene.h

@@ -14,11 +14,10 @@
 
 #include "ernie/device/shader_compiler.h"
 #include "ernie/graph/graph.h"
-#include "ernie/render/bottom_levels.h"
 #include "ernie/render/geometry.h"
 #include "ernie/render/instances.h"
+#include "ernie/render/rt/ray_tracer.h"
 #include "ernie/render/scene_columns.h"
-#include "ernie/render/top_levels.h"
 #include "ernie/render/transform_graph.h"
 
 #include <functional>
@@ -30,8 +29,7 @@ namespace ernie {
 /// @brief A scene on a device and the graph each frame runs: the columns bound on the device
 /// follow the scene, world transforms compose from them, the geometry and its acceleration
 /// structures follow, and then the frame's own passes run, finding what to trace as a
-/// `SceneStructure` on the graph's blackboard. Devices without ray queries get no acceleration
-/// structures yet.
+/// `TraceScene` on the graph's blackboard. Devices without ray queries get no ray tracer yet.
 class DeviceScene {
   public:
     /// @param arenas Where the device columns live; `MemoryUse::Shared` to share them with CUDA.
@@ -52,9 +50,9 @@ class DeviceScene {
     InstanceTable& Instances() {
         return instances_;
     }
-    /// @return The bottom levels, or null on devices without ray queries.
-    BottomLevels* Bottoms() {
-        return bottoms_.get();
+    /// @return The ray tracer, or null on devices without ray queries.
+    RayTracer* Tracer() {
+        return tracer_.get();
     }
     /// @return Where the frames' transients come from.
     graph::TransientPool& Pool() {
@@ -76,8 +74,7 @@ class DeviceScene {
     TransformGraph transforms_;
     GeometryPool geometry_;
     InstanceTable instances_;
-    std::unique_ptr<BottomLevels> bottoms_;
-    std::unique_ptr<TopLevels> tops_;
+    std::unique_ptr<RayTracer> tracer_;
 };
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev119/ernie/render → ernie_renderer-0.2.0.dev121/ernie/render/rt}/bottom_levels.cpp

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /// @file bottom_levels.cpp
 /// @brief Building, refitting and compacting each geometry's bottom level as frame-graph passes.
-#include "ernie/render/bottom_levels.h"
+#include "ernie/render/rt/bottom_levels.h"
 
 #include "ernie/util/profiler.h"
 

ernie_renderer-0.2.0.dev121/ernie/render/rt/ray_tracer.cpp

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file ray_tracer.cpp
+/// @brief Keeping the acceleration structures up to date each frame.
+#include "ernie/render/rt/ray_tracer.h"
+
+#include "ernie/shaders/rt/ray_tracer.h"
+#include "ernie/shaders/scene/geometry.h"
+#include "ernie/shaders/scene/shapes.h"
+#include "ernie/util/profiler.h"
+
+#include <array>
+
+namespace ernie {
+
+RayTracer::RayTracer(DeviceContext& context, Arenas& arenas, const ShaderCompiler& compiler,
+                     const GeometryPool& geometry)
+    : 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};
+    return modules;
+}
+
+void RayTracer::AddBuild(graph::Graph& graph, const GeometryPool::Changes& changes,
+                         const TransformGraph& transforms, const InstanceTable& instances) {
+    ERNIE_ZONE("Update the ray tracer");
+    const graph::Graph::ScopeGuard scope = graph.Scope("Ray tracer");
+    bottoms_.Apply(changes);
+    bottoms_.AddBuilds(graph);
+    const graph::Acceleration top = tops_.AddBuild(graph, transforms, instances, bottoms_);
+    const DeviceColumn& records = geometry_.Records();
+    graph.Board().Put(TraceScene{
+        .parameters = {.scene = tops_.Structure()->Address(), .records = records.Address()},
+        .top = top,
+        .records = graph.Import(records, records.Name()),
+        .instances = instances.Count()});
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev121/ernie/render/rt/ray_tracer.h

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file ray_tracer.h
+/// @brief The ray tracer: the acceleration structures the scene is traced through, kept up to date
+/// each frame, and the Slang modules its passes trace them with.
+///
+///     const TraceScene& scene = graph.Board().Get<TraceScene>();
+///     graph.Add("Shade", graph::Kind::Compute,
+///               [&](graph::PassBuilder& pass) { scene.Read(pass); ... },
+///               [&](graph::PassContext& pass) { kernel.Dispatch(..., {scene.parameters, ...}); });
+#pragma once
+
+#include "ernie/device/shader_compiler.h"
+#include "ernie/graph/graph.h"
+#include "ernie/render/geometry.h"
+#include "ernie/render/instances.h"
+#include "ernie/render/rt/bottom_levels.h"
+#include "ernie/render/rt/top_levels.h"
+#include "ernie/render/transform_graph.h"
+
+#include <cstdint>
+#include <span>
+
+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 frame's passes trace, left on the graph's blackboard by `RayTracer::AddBuild`.
+struct TraceScene {
+    TracerParameters parameters;
+    graph::Acceleration top;
+    graph::Buffer records;
+    std::uint32_t instances = 0;
+
+    /// @brief Declares a pass's reads of everything tracing touches.
+    void Read(graph::PassBuilder& pass) const {
+        pass.Read(top);
+        pass.ReadAddress(records);
+    }
+};
+
+/// @brief The scene's acceleration structures on a device with ray queries: a bottom level for
+/// each geometry, built and compacted as it changes, and a top level over the instances rebuilt
+/// every frame.
+class RayTracer {
+  public:
+    RayTracer(DeviceContext& context, Arenas& arenas, const ShaderCompiler& compiler,
+              const GeometryPool& geometry);
+    RayTracer(const RayTracer&) = delete;
+    RayTracer& operator=(const RayTracer&) = delete;
+
+    /// @return The modules, in import order, a tracing kernel compiles with before its own; it
+    /// then imports `ray_tracer`.
+    static std::span<const ShaderModule> Modules();
+
+    /// @brief Adds the passes that bring the structures up to date with the frame's geometry
+    /// changes, after the transforms and the geometry's and instances' uploads, and puts a
+    /// `TraceScene` on the graph's blackboard.
+    void AddBuild(graph::Graph& graph, const GeometryPool::Changes& changes,
+                  const TransformGraph& transforms, const InstanceTable& instances);
+
+    BottomLevels& Bottoms() {
+        return bottoms_;
+    }
+    const TopLevels& Tops() const {
+        return tops_;
+    }
+
+  private:
+    const GeometryPool& geometry_;
+    BottomLevels bottoms_;
+    TopLevels tops_;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev119/ernie/render → ernie_renderer-0.2.0.dev121/ernie/render/rt}/top_levels.cpp

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /// @file top_levels.cpp
 /// @brief Writing instance records on the device and building the top level over them.
-#include "ernie/render/top_levels.h"
+#include "ernie/render/rt/top_levels.h"
 
-#include "ernie/render/shaders/write_instances.h"
+#include "ernie/shaders/rt/write_instances.h"
 #include "ernie/util/profiler.h"
 
 #include <algorithm>
@@ -37,8 +37,9 @@ TopLevels::TopLevels(DeviceContext& context, const ShaderCompiler& compiler)
                                  std::uint32_t{sizeof(WriteParameters)}),
       pool_(context, "top levels") {}
 
-void TopLevels::AddBuild(graph::Graph& graph, const TransformGraph& transforms,
-                         const InstanceTable& instances, const BottomLevels& bottoms) {
+graph::Acceleration TopLevels::AddBuild(graph::Graph& graph, const TransformGraph& transforms,
+                                        const InstanceTable& instances,
+                                        const BottomLevels& bottoms) {
     ERNIE_ZONE("Prepare the top level");
     const std::uint32_t count = instances.Count();
     const std::uint32_t capacity = top_ ? top_->Sizes().primitives[0] : 0;
@@ -101,7 +102,7 @@ void TopLevels::AddBuild(graph::Graph& graph, const TransformGraph& transforms,
             const graph::BufferSlice space = pass.Get(scratch);
             RecordBuilds(pass.commands, {}, std::span(&recorded, 1), {space.buffer, space.offset});
         });
-    graph.Board().Put(SceneStructure{.top = top, .address = top_->Address(), .instances = count});
+    return top;
 }
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev119/ernie/render → ernie_renderer-0.2.0.dev121/ernie/render/rt}/top_levels.h

@@ -8,24 +8,14 @@
 #include "ernie/device/kernel.h"
 #include "ernie/device/shader_compiler.h"
 #include "ernie/graph/graph.h"
-#include "ernie/render/bottom_levels.h"
 #include "ernie/render/instances.h"
+#include "ernie/render/rt/bottom_levels.h"
 #include "ernie/render/transform_graph.h"
 
-#include <cstdint>
 #include <memory>
 
 namespace ernie {
 
-/// @brief What a frame's passes trace, left on the graph's blackboard by `TopLevels::AddBuild`.
-struct SceneStructure {
-    /// The top level, for passes to read with `Use::Trace`.
-    graph::Acceleration top;
-    /// Its address, as kernels trace it: `RaytracingAccelerationStructure(address)`.
-    std::uint64_t address = 0;
-    std::uint32_t instances = 0;
-};
-
 /// @brief The scene's top level, rebuilt every frame: a kernel writes each instance's record from
 /// its world transform, its shape transform and its geometry's bottom level, and the build follows.
 /// Instances whose bottom level is not built are switched off. An instance's custom index is its
@@ -38,10 +28,10 @@ class TopLevels {
     TopLevels& operator=(const TopLevels&) = delete;
 
     /// @brief Adds the passes that write the instances and build the top level, after the
-    /// transforms, the instance uploads and the bottom levels' builds, and puts a
-    /// `SceneStructure` on the graph's blackboard.
-    void AddBuild(graph::Graph& graph, const TransformGraph& transforms,
-                  const InstanceTable& instances, const BottomLevels& bottoms);
+    /// transforms, the instance uploads and the bottom levels' builds.
+    /// @return The top level built, for passes to read with `Use::Trace`.
+    graph::Acceleration AddBuild(graph::Graph& graph, const TransformGraph& transforms,
+                                 const InstanceTable& instances, const BottomLevels& bottoms);
 
     /// @return The top level as last built, or null before the first build.
     const AccelerationStructure* Structure() const {

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/ernie/render/transform_graph.cpp

@@ -4,13 +4,11 @@
 /// composing it on the device.
 #include "ernie/render/transform_graph.h"
 
-#include "ernie/render/shaders/affine.h"
-#include "ernie/render/shaders/compose.h"
-#include "ernie/render/shaders/double_float.h"
-#include "ernie/render/shaders/local.h"
-#include "ernie/render/shaders/world.h"
 #include "ernie/scene/schema/geom.h"
 #include "ernie/scene/tokens.h"
+#include "ernie/shaders/math/affine.h"
+#include "ernie/shaders/math/double_float.h"
+#include "ernie/shaders/scene/transform.h"
 
 #include <glm/gtc/matrix_transform.hpp>
 
@@ -22,35 +20,6 @@
 namespace ernie {
 namespace {
 
-// A program's op kinds: a folded constant, then each `XformOpKind` after it.
-constexpr std::uint32_t kConstant = 0;
-constexpr std::uint32_t kInvert = 1;
-constexpr std::uint32_t kFloatsShift = 8;
-
-constexpr std::uint32_t ProgramKind(XformOpKind kind) {
-    return 1 + static_cast<std::uint32_t>(kind);
-}
-
-/// The op kinds and the program layout, from the constants above, for the kernels to import.
-ShaderModule OpConstants() {
-    std::string source;
-    const auto constant = [&](const char* name, std::uint32_t value) {
-        source +=
-            std::string("public static const uint ") + name + " = " + std::to_string(value) + ";\n";
-    };
-    constant("kConstant", kConstant);
-    constant("kTranslate", ProgramKind(XformOpKind::Translate));
-    constant("kScale", ProgramKind(XformOpKind::Scale));
-    constant("kRotateX", ProgramKind(XformOpKind::RotateX));
-    constant("kRotateXYZ", ProgramKind(XformOpKind::RotateXYZ));
-    constant("kOrient", ProgramKind(XformOpKind::Orient));
-    constant("kInvert", kInvert);
-    constant("kFloatsShift", kFloatsShift);
-    constant("kMaxOps", TransformGraph::kMaxOps);
-    constant("kNone", TransformGraph::kNone);
-    return {"ops", std::move(source)};
-}
-
 struct LocalParameters {
     VkDeviceAddress slots, programs, lengths, locals;
     std::uint32_t count, pad;
@@ -61,11 +30,6 @@ struct ComposeParameters {
 };
 static_assert(sizeof(TransformGraph::DeviceOp) == 112);
 
-std::vector<std::uint32_t> Compile(const ShaderCompiler& compiler, const ShaderModule& kernel) {
-    const std::array modules{shaders::kAffine, shaders::kDoubleFloat, OpConstants(), kernel};
-    return compiler.Spirv(modules, "main");
-}
-
 /// @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{};
@@ -114,9 +78,9 @@ glm::uvec3 Groups(std::size_t threads) {
 TransformGraph::TransformGraph(DeviceContext& context, Arenas& arenas, const Scene& scene,
                                const ShaderCompiler& compiler)
     : context_(context), arenas_(arenas), scene_(scene), uploader_(context, context.Main()),
-      local_(context, Compile(compiler, shaders::kLocal), "local transforms",
+      local_(context, compiler.Spirv(WorldModules(), "Local"), "local transforms",
              sizeof(LocalParameters)),
-      compose_(context, Compile(compiler, shaders::kCompose), "world transforms",
+      compose_(context, compiler.Spirv(WorldModules(), "Compose"), "world transforms",
                sizeof(ComposeParameters)) {
     const auto column = [&](std::string_view name, DType type, std::vector<std::int64_t> element) {
         return std::make_unique<DeviceColumn>(arenas, name, type, std::move(element), 0);
@@ -166,7 +130,7 @@ void TransformGraph::SetOrigin(const glm::dvec3& origin) {
 }
 
 std::span<const ShaderModule> TransformGraph::WorldModules() {
-    static const std::array modules{shaders::kAffine, shaders::kDoubleFloat, shaders::kWorld};
+    static const std::array modules{shaders::kAffine, shaders::kDoubleFloat, shaders::kTransform};
     return modules;
 }
 
@@ -401,7 +365,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 = kConstant, .constant = Split(folded)});
+            push({.kind = kConstantOp, .constant = Split(folded)});
             folded = glm::dmat4(1.0);
         }
     };
@@ -415,8 +379,8 @@ TransformGraph::Built TransformGraph::BuildProgram(std::uint32_t slot) const {
         fold();
         const DeviceColumn& column = *bound->column;
         const auto floats = static_cast<std::uint32_t>(Floats(column));
-        push({.kind = ProgramKind(op.kind),
-              .flags = (op.invert ? kInvert : 0u) | floats << kFloatsShift,
+        push({.kind = OpKind(op.kind),
+              .flags = (op.invert ? kInvertFlag : 0u) | floats << kFloatsShift,
               .source = bound->address + row * column.RowBytes()});
     }
     fold();

{ernie_renderer-0.2.0.dev119 → ernie_renderer-0.2.0.dev121}/ernie/render/transform_graph.h

@@ -63,6 +63,14 @@ class TransformGraph {
         bool operator==(const DeviceOp&) const = default;
     };
     using Program = std::array<DeviceOp, kMaxOps>;
+    /// A `DeviceOp::kind`: a folded constant, then each `XformOpKind` after it.
+    static constexpr std::uint32_t kConstantOp = 0;
+    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.dev121/ernie/shaders/CMakeLists.txt

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+ernie_add_shaders(
+    ernie_shaders
+    math/affine.slang
+    math/double_float.slang
+    rt/ray_tracer.slang
+    rt/write_instances.slang
+    scene/geometry.slang
+    scene/shapes.slang
+    scene/transform.slang
+)

{ernie_renderer-0.2.0.dev119/ernie/render/shaders → ernie_renderer-0.2.0.dev121/ernie/shaders/rt}/ray_tracer.slang

@@ -1,19 +1,20 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /// @file ray_tracer.slang
-/// @brief `IRayTracer`, the one interface passes trace through whatever backend answers it, and
-/// its hardware ray-query backend.
-// The geometry kinds, generated from GeometryKind in ray_tracer.cpp.
-import geometry_kinds;
+/// @brief `RayTracer`, what every pass traces the scene through: inline ray queries against the
+/// top level, each procedural candidate solved exactly as its unit shape.
+///
+///     import ray_tracer;
+///     RayTracer tracer = RayTracer(parameters.tracer);
+///     Hit hit = tracer.TraceClosest(ray, 0xff);
+///     if (hit.found) { float3 n = tracer.WorldNormal(hit); }
+import geometry;
 import shapes;
 
-/// A geometry's record, as the C++ `GeometryRecord`: an instance's custom index finds it.
-public struct GeometryRecord {
-    public uint kind;
-    public float halfLength;
-    public uint vertexCount;
-    public uint triangleCount;
-    public float* vertices;
-    public uint* indices;
+/// What a pass hands its tracer, as the C++ `TracerParameters`.
+public struct TracerParameters {
+    /// The top level's device address.
+    public uint64_t scene;
+    public GeometryRecord* records;
 };
 
 /// What a ray hit: where along it, which instance, primitive and geometry, and the transforms
@@ -32,45 +33,14 @@ public struct Hit {
     public float3x4 worldToObject;
 };
 
-/// The one interface every pass traces through, whichever backend answers it.
-public interface IRayTracer {
-    /// @return The nearest hit along the ray among instances in `mask`.
-    Hit TraceClosest(RayDesc ray, uint mask);
-    /// @return Whether anything in `mask` blocks the ray, for visibility.
-    bool TraceAny(RayDesc ray, uint mask);
-}
+public struct RayTracer {
+    TracerParameters parameters;
 
-/// Ray queries against a hardware top level, by its device address.
-public struct HardwareRayQuery : IRayTracer {
-    public uint64_t scene;
-    public GeometryRecord* records;
-
-    /// Runs the query, solving each procedural candidate exactly; `Flags` may end it at the first
-    /// hit. NVIDIA's compiler fails on `CandidateObjectRay*`: the object ray comes from the
-    /// candidate's matrix instead.
-    void Run<let Flags : int>(inout RayQuery<Flags> query, RayDesc ray, uint mask,
-                              out ShapeHit nearest) {
-        query.TraceRayInline(RaytracingAccelerationStructure(scene), RAY_FLAG_NONE, mask, ray);
-        nearest.t = ray.TMax;
-        nearest.normal = float3(0, 0, 1);
-        while (query.Proceed()) {
-            if (query.CandidateType() != CANDIDATE_PROCEDURAL_PRIMITIVE) {
-                continue;
-            }
-            GeometryRecord record = records[query.CandidateInstanceID()];
-            float3x4 toObject = query.CandidateWorldToObject3x4();
-            float3 o = mul(toObject, float4(query.WorldRayOrigin(), 1));
-            float3 d = mul(toObject, float4(query.WorldRayDirection(), 0));
-            // Object-space distances along the transformed direction are the ray's own.
-            ShapeHit hit = nearest;
-            hit.t = query.CommittedRayT();
-            if (IntersectShape(record.kind, record.halfLength, o, d, ray.TMin, hit)) {
-                query.CommitProceduralPrimitiveHit(hit.t);
-                nearest = hit;
-            }
-        }
+    public __init(TracerParameters parameters) {
+        this.parameters = parameters;
     }
 
+    /// @return The nearest hit along the ray among instances in `mask`.
     public Hit TraceClosest(RayDesc ray, uint mask) {
         RayQuery<RAY_FLAG_NONE> query;
         ShapeHit nearest;
@@ -90,28 +60,51 @@ public struct HardwareRayQuery : IRayTracer {
         return hit;
     }
 
+    /// @return Whether anything in `mask` blocks the ray, for visibility.
     public bool TraceAny(RayDesc ray, uint mask) {
         RayQuery<RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH> query;
         ShapeHit nearest;
         Run(query, ray, mask, nearest);
         return query.CommittedStatus() != COMMITTED_NOTHING;
     }
-}
 
-/// @return The surface's geometric normal at a hit, in the scene's frame, facing out of an
-/// implicit shape or by a triangle's winding.
-public float3 WorldNormal(Hit hit, GeometryRecord* records) {
-    float3 normal = hit.objectNormal;
-    GeometryRecord record = records[hit.geometry];
-    if (record.kind == kTriangles) {
-        uint* corners = record.indices + 3 * hit.primitive;
-        float3 p[3];
-        for (uint i = 0; i < 3; ++i) {
-            float* v = record.vertices + 3 * corners[i];
-            p[i] = float3(v[0], v[1], v[2]);
+    /// @return The surface's geometric normal at a hit, in the scene's frame, facing out of an
+    /// implicit shape or by a triangle's winding.
+    public float3 WorldNormal(Hit hit) {
+        float3 normal = hit.objectNormal;
+        GeometryRecord record = parameters.records[hit.geometry];
+        if (record.kind == kTriangles) {
+            float3 p[3];
+            Corners(record, hit.primitive, p);
+            normal = cross(p[1] - p[0], p[2] - p[0]);
+        }
+        // Normals take the inverse transpose: a row vector times the world-to-object matrix.
+        return normalize(mul(normal, (float3x3)hit.worldToObject));
+    }
+
+    /// Runs the query; `Flags` may end it at the first hit. NVIDIA's compiler fails on
+    /// `CandidateObjectRay*`: the object ray comes from the candidate's matrix instead.
+    void Run<let Flags : int>(inout RayQuery<Flags> query, RayDesc ray, uint mask,
+                              out ShapeHit nearest) {
+        query.TraceRayInline(RaytracingAccelerationStructure(parameters.scene), RAY_FLAG_NONE,
+                             mask, ray);
+        nearest.t = ray.TMax;
+        nearest.normal = float3(0, 0, 1);
+        while (query.Proceed()) {
+            if (query.CandidateType() != CANDIDATE_PROCEDURAL_PRIMITIVE) {
+                continue;
+            }
+            GeometryRecord record = parameters.records[query.CandidateInstanceID()];
+            float3x4 toObject = query.CandidateWorldToObject3x4();
+            float3 o = mul(toObject, float4(query.WorldRayOrigin(), 1));
+            float3 d = mul(toObject, float4(query.WorldRayDirection(), 0));
+            // Object-space distances along the transformed direction are the ray's own.
+            ShapeHit hit = nearest;
+            hit.t = query.CommittedRayT();
+            if (IntersectShape(record.kind, record.halfLength, o, d, ray.TMin, hit)) {
+                query.CommitProceduralPrimitiveHit(hit.t);
+                nearest = hit;
+            }
         }
-        normal = cross(p[1] - p[0], p[2] - p[0]);
     }
-    // Normals take the inverse transpose: a row vector times the world-to-object matrix.
-    return normalize(mul(normal, (float3x3)hit.worldToObject));
 }