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

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

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

@@ -186,31 +186,35 @@ void Viewer::ShowViewport() {
     const ImVec2 scale = ImGui::GetIO().DisplayFramebufferScale;
     const glm::uvec2 pixels(std::max(1.0f, size.x * scale.x), std::max(1.0f, size.y * scale.y));
     if (!viewport_ || glm::uvec2(viewport_->Description().extent) != pixels) {
-        ERNIE_ZONE("Resize the viewport");
-        // Frames in flight may still sample the old image.
-        context_->Main().Last().Wait();
-        if (viewport_) {
-            renderer_->RemoveTexture(viewportTexture_);
-            if (heap_) {
-                heap_->RemoveStorageImage(viewportImage_);
-            }
-        }
-        viewport_ = std::make_unique<DeviceImage>(
-            *context_,
-            ImageDescription{.format = ImageFormat::Rgba8Unorm,
-                             .extent = {pixels, 1},
-                             .usage = ImageUsage::Sampled | ImageUsage::Storage},
-            "Viewport");
-        viewportTexture_ = renderer_->AddTexture(viewport_->View(), sampler_->Handle());
-        if (heap_) {
-            viewportImage_ = heap_->AddStorageImage(*viewport_);
-        }
+        ResizeViewport(pixels);
     }
     ImGui::GetBackgroundDrawList()->AddImage(viewportTexture_, position,
                                              {position.x + size.x, position.y + size.y});
 }
 
-void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
+void Viewer::ResizeViewport(glm::uvec2 pixels) {
+    ERNIE_ZONE("Resize the viewport");
+    // Frames in flight may still sample the old image.
+    context_->Main().Last().Wait();
+    if (viewport_) {
+        renderer_->RemoveTexture(viewportTexture_);
+        if (heap_) {
+            heap_->RemoveStorageImage(viewportImage_);
+        }
+    }
+    viewport_ = std::make_unique<DeviceImage>(
+        *context_,
+        ImageDescription{.format = ImageFormat::Rgba8Unorm,
+                         .extent = {pixels, 1},
+                         .usage = ImageUsage::Sampled | ImageUsage::Storage},
+        "Viewport");
+    viewportTexture_ = renderer_->AddTexture(viewport_->View(), sampler_->Handle());
+    if (heap_) {
+        viewportImage_ = heap_->AddStorageImage(*viewport_);
+    }
+}
+
+graph::Image Viewer::AddViewportPass(graph::Graph& graph) {
     graph::Image viewport = graph.Import(*viewport_, "viewport");
     if (camera_) {
         const OrbitCamera& orbit = shell_->Camera();
@@ -222,20 +226,24 @@ void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget&
                       .verticalFov = orbit.verticalFov,
                       .size = glm::uvec2(viewport_->Description().extent)},
                      outputs);
-        viewport = *outputs.colour;
-    } else {
-        graph.Add(
-            "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);
-            });
+        return *outputs.colour;
     }
+    graph.Add(
+        "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);
+        });
+    return viewport;
+}
+
+void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
+    const graph::Image viewport = AddViewportPass(graph);
     graph.Add(
         "UI", graph::Kind::Raster,
         [&](graph::PassBuilder& pass) {

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev140}/ernie/app/viewer.h

@@ -77,6 +77,12 @@ class Viewer {
     /// @brief Sizes the viewport's image to the dock space's central node and draws it there,
     /// behind the panels.
     void ShowViewport();
+    /// @brief Makes the viewport's image `pixels` in size, in the UI and the heap.
+    void ResizeViewport(glm::uvec2 pixels);
+    /// @brief Adds the pass filling the viewport: traced, or the theme's colour without ray
+    /// queries.
+    /// @return The viewport, filled.
+    graph::Image AddViewportPass(graph::Graph& graph);
     /// @brief Adds the frame's own passes: rendering the viewport, then the UI over the target.
     void AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target);
 

{ernie_renderer-0.2.0.dev135 → 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.dev135 → ernie_renderer-0.2.0.dev140}/ernie/device/shader_compiler.cpp

@@ -36,6 +36,14 @@ struct ShaderCompiler::Session {
             throw std::invalid_argument("Compiling no shader modules");
         }
         const std::lock_guard lock(mutex);
+        const Slang::ComPtr<slang::ISession> session = CreateSession(format, profile);
+        slang::IModule* last = LoadModules(*session, modules);
+        return Link(*session, *last, modules.back().name, std::string(entryPoint));
+    }
+
+  private:
+    /// @return A session compiling for the target, the global session started the first time.
+    Slang::ComPtr<slang::ISession> CreateSession(SlangCompileTarget format, const char* profile) {
         if (!global && SLANG_FAILED(slang::createGlobalSession(global.writeRef()))) {
             throw std::runtime_error("Cannot start the Slang shader compiler");
         }
@@ -44,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())};
@@ -53,36 +66,45 @@ struct ShaderCompiler::Session {
         if (SLANG_FAILED(global->createSession(description, session.writeRef()))) {
             throw std::runtime_error("Cannot create a Slang session");
         }
+        return session;
+    }
 
+    /// @return The last module, each loaded after the modules it imports.
+    static slang::IModule* LoadModules(slang::ISession& session,
+                                       std::span<const ShaderModule> modules) {
         slang::IModule* last = nullptr;
         for (const ShaderModule& module : modules) {
             Slang::ComPtr<slang::IBlob> diagnostics;
             const std::string path = module.name + ".slang";
-            last = session->loadModuleFromSourceString(
+            last = session.loadModuleFromSourceString(
                 module.name.c_str(), path.c_str(), module.source.c_str(), diagnostics.writeRef());
             if (last == nullptr) {
                 throw std::invalid_argument("Shader module " + module.name +
                                             " failed to compile:\n" + Text(diagnostics));
             }
         }
-        const std::string entry(entryPoint);
+        return last;
+    }
+
+    /// @return The code of `module`'s entry point, linked with what it imports.
+    static Slang::ComPtr<slang::IBlob> Link(slang::ISession& session, slang::IModule& module,
+                                            const std::string& name, const std::string& entry) {
         Slang::ComPtr<slang::IEntryPoint> found;
-        if (SLANG_FAILED(last->findEntryPointByName(entry.c_str(), found.writeRef()))) {
-            throw std::invalid_argument("Shader module " + modules.back().name +
-                                        " has no entry point " + entry);
+        if (SLANG_FAILED(module.findEntryPointByName(entry.c_str(), found.writeRef()))) {
+            throw std::invalid_argument("Shader module " + name + " has no entry point " + entry);
         }
-        std::array<slang::IComponentType*, 2> parts{last, found};
+        std::array<slang::IComponentType*, 2> parts{&module, found};
         Slang::ComPtr<slang::IComponentType> program;
         Slang::ComPtr<slang::IComponentType> linked;
         Slang::ComPtr<slang::IBlob> code;
         Slang::ComPtr<slang::IBlob> diagnostics;
         const bool failed =
-            SLANG_FAILED(session->createCompositeComponentType(
+            SLANG_FAILED(session.createCompositeComponentType(
                 parts.data(), parts.size(), program.writeRef(), diagnostics.writeRef())) ||
             SLANG_FAILED(program->link(linked.writeRef(), diagnostics.writeRef())) ||
             SLANG_FAILED(linked->getEntryPointCode(0, 0, code.writeRef(), diagnostics.writeRef()));
         if (failed) {
-            throw std::invalid_argument("Entry point " + entry + " of " + modules.back().name +
+            throw std::invalid_argument("Entry point " + entry + " of " + name +
                                         " failed to compile:\n" + Text(diagnostics));
         }
         return code;

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev140}/ernie/device/staging.h

@@ -8,6 +8,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <memory>
 #include <span>
 #include <vector>
@@ -88,6 +89,13 @@ class Readback {
     }
     /// @return The bytes, waiting for the copy if it is not done.
     std::span<const std::byte> Bytes();
+    /// @return The bytes as `T`s, waiting for the copy if it is not done.
+    template <typename T> std::vector<T> Values() {
+        const std::span<const std::byte> bytes = Bytes();
+        std::vector<T> values(bytes.size() / sizeof(T));
+        std::memcpy(values.data(), bytes.data(), values.size() * sizeof(T));
+        return values;
+    }
 
   private:
     DeviceContext& context_;

{ernie_renderer-0.2.0.dev135 → 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.dev135 → ernie_renderer-0.2.0.dev140}/ernie/render/geometry.cpp

@@ -22,7 +22,7 @@ namespace {
 /// Metres from a ground plane's centre to its edges: far past any horizon a camera near it sees.
 constexpr double kGroundHalfWidth = 1e5;
 
-std::optional<GeometryKind> KindHeld(const Scene& scene, PrimId prim) {
+std::optional<GeometryKind> FindGeometryKind(const Scene& scene, PrimId prim) {
     const SchemaDef* schema = scene.Schema(prim);
     const std::array<std::pair<const SchemaDef*, GeometryKind>, 8> kinds{{
         {&Mesh::Definition(), GeometryKind::Triangles},
@@ -42,7 +42,7 @@ std::optional<GeometryKind> KindHeld(const Scene& scene, PrimId prim) {
     return std::nullopt;
 }
 
-double Number(const Scene& scene, PrimId prim, std::string_view attribute) {
+double RequireNumber(const Scene& scene, PrimId prim, std::string_view attribute) {
     const std::optional<Value> value = scene.GetOrFallback(prim, attribute);
     const std::optional<double> number = value ? ToNumber(*value) : std::nullopt;
     if (!number) {
@@ -88,25 +88,26 @@ glm::dmat4 ShapeTransform(const Scene& scene, PrimId prim, GeometryKind kind) {
     };
     switch (kind) {
     case GeometryKind::Sphere:
-        return scaled(glm::dvec3(Number(scene, prim, Sphere::kRadius)));
+        return scaled(glm::dvec3(RequireNumber(scene, prim, Sphere::kRadius)));
     case GeometryKind::Cube:
-        return scaled(glm::dvec3(0.5 * Number(scene, prim, Cube::kSize)));
+        return scaled(glm::dvec3(0.5 * RequireNumber(scene, prim, Cube::kSize)));
     case GeometryKind::Cylinder:
     case GeometryKind::Cone: {
-        const double radius = Number(scene, prim, Cylinder::kRadius);
+        const double radius = RequireNumber(scene, prim, Cylinder::kRadius);
         return AxisTurn(scene, prim) *
-               scaled({radius, radius, 0.5 * Number(scene, prim, Cylinder::kHeight)});
+               scaled({radius, radius, 0.5 * RequireNumber(scene, prim, Cylinder::kHeight)});
     }
     case GeometryKind::Capsule:
-        return AxisTurn(scene, prim) * scaled(glm::dvec3(Number(scene, prim, Capsule::kRadius)));
+        return AxisTurn(scene, prim) *
+               scaled(glm::dvec3(RequireNumber(scene, prim, Capsule::kRadius)));
     case GeometryKind::Plane: {
         if (IsA(scene.Schema(prim), GroundPlane::Definition())) {
             return scaled({kGroundHalfWidth, kGroundHalfWidth, 1.0});
         }
         // Width along x, or z for an X normal; length along y, or z for a Y normal: under the
         // cyclic turn, the unit square's x carries the length unless the normal is z.
-        const double width = 0.5 * Number(scene, prim, Plane::kWidth);
-        const double length = 0.5 * Number(scene, prim, Plane::kLength);
+        const double width = 0.5 * RequireNumber(scene, prim, Plane::kWidth);
+        const double length = 0.5 * RequireNumber(scene, prim, Plane::kLength);
         const glm::dmat4 turn = AxisTurn(scene, prim);
         const bool normalZ = turn[2][2] == 1.0;
         return turn *
@@ -118,8 +119,8 @@ glm::dmat4 ShapeTransform(const Scene& scene, PrimId prim, GeometryKind kind) {
     return glm::dmat4(1.0);
 }
 
-/// @return Whether a changed attribute reshapes a gprim, moves a mesh's points, or remakes its
-/// topology.
+/// What a changed attribute does to a gprim: reshapes it, moves a mesh's points, remakes its
+/// topology, or recolours it.
 struct Touched {
     bool shape = false;
     bool points = false;
@@ -131,7 +132,7 @@ struct Touched {
     }
 };
 
-Touched Classify(std::string_view attribute) {
+Touched ClassifyAttribute(std::string_view attribute) {
     if (attribute == Gprim::kDisplayColor) {
         return {.colour = true};
     }
@@ -257,7 +258,7 @@ void GeometryPool::UploadMesh(PrimId prim, GeometryId id, bool topology, Changes
 }
 
 void GeometryPool::Place(PrimId prim, bool points, bool topology, Changes& changes) {
-    const std::optional<GeometryKind> kind = KindHeld(scene_, prim);
+    const std::optional<GeometryKind> kind = FindGeometryKind(scene_, prim);
     if (!kind) {
         return;
     }
@@ -273,9 +274,9 @@ void GeometryPool::Place(PrimId prim, bool points, bool topology, Changes& chang
             UploadMesh(prim, next.geometry, topology || !known, changes);
         }
     } else if (*kind == GeometryKind::Capsule) {
-        const double radius = Number(scene_, prim, Capsule::kRadius);
+        const double radius = RequireNumber(scene_, prim, Capsule::kRadius);
         const auto halfLength =
-            static_cast<float>(0.5 * Number(scene_, prim, Capsule::kHeight) / radius);
+            static_cast<float>(0.5 * RequireNumber(scene_, prim, Capsule::kHeight) / radius);
         next.geometry = known ? placed->geometry
                               : Allocate({.kind = GeometryKind::Capsule,
                                           .box = arenas_.Allocate(6 * sizeof(float))});
@@ -332,7 +333,7 @@ GeometryPool::Changes GeometryPool::Update() {
     }
     // Values the host authored: shapes, points, topology and colours.
     for (const ChangeSet::Values& values : changeSet.values) {
-        const Touched touched = Classify(store.Tokens().Text(values.attribute));
+        const Touched touched = ClassifyAttribute(store.Tokens().Text(values.attribute));
         if (!touched.Any()) {
             continue;
         }
@@ -363,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.dev135 → 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.dev135 → ernie_renderer-0.2.0.dev140}/ernie/render/instances.cpp

@@ -13,16 +13,6 @@ namespace {
 
 constexpr std::uint32_t kNoRow = std::numeric_limits<std::uint32_t>::max();
 
-InstanceTable::Shape RowMajor(const glm::dmat4& m) {
-    InstanceTable::Shape rows{};
-    for (int r = 0; r < 3; ++r) {
-        for (int c = 0; c < 4; ++c) {
-            rows[static_cast<std::size_t>(r * 4 + c)] = static_cast<float>(m[c][r]);
-        }
-    }
-    return rows;
-}
-
 }  // namespace
 
 InstanceTable::InstanceTable(DeviceContext& context, Arenas& arenas)
@@ -48,7 +38,7 @@ void InstanceTable::Set(std::uint32_t row, const PrimGeometry& placed) {
     prims_[row] = placed.prim;
     hostNodes_[row] = placed.prim.slot;
     hostGeometries_[row] = placed.geometry;
-    hostShapes_[row] = RowMajor(placed.shape);
+    hostShapes_[row] = ToAffineRows(placed.shape);
     hostColours_[row] = placed.colour;
     rows_[placed.prim.slot] = row;
     dirty_.push_back(row);

{ernie_renderer-0.2.0.dev135 → ernie_renderer-0.2.0.dev140}/ernie/render/instances.h

@@ -8,6 +8,7 @@
 #include "ernie/device/staging.h"
 #include "ernie/graph/graph.h"
 #include "ernie/render/geometry.h"
+#include "ernie/util/glm.h"
 
 #include <array>
 #include <cstdint>
@@ -23,7 +24,7 @@ namespace ernie {
 /// is found with `Row`.
 class InstanceTable {
   public:
-    using Shape = std::array<float, 12>;
+    using Shape = std::array<glm::vec4, 3>;
 
     /// @param arenas Where the columns live.
     InstanceTable(DeviceContext& context, Arenas& arenas);