ernie-renderer 0.2.0.dev19__tar.gz → 0.2.0.dev20__tar.gz

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev19
+Version: 0.2.0.dev20
 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.dev19 → ernie_renderer-0.2.0.dev20}/benchmarks/CMakeLists.txt

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: BSD-3-Clause
-add_executable(ernie_benchmarks main.cpp scene_storage.cpp)
+add_executable(ernie_benchmarks main.cpp scene/storage.cpp)
 target_link_libraries(ernie_benchmarks PRIVATE ernie_static ernie_build_options)

ernie_renderer-0.2.0.dev19/benchmarks/scene_storage.cpp → ernie_renderer-0.2.0.dev20/benchmarks/scene/storage.cpp

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: BSD-3-Clause
-/// @file scene_storage.cpp
+/// @file storage.cpp
 /// @brief The prim store at 100,000 prims: create, first sync, one edit, edit all, add and remove.
-#include "benchmarks/bench.h"
 #include "ernie/scene/storage.h"
+#include "benchmarks/bench.h"
 
 #include <memory>
 #include <string>

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/ernie/CMakeLists.txt

@@ -22,6 +22,7 @@ set_target_properties(
 
 # One object library per layer; a layer links only the layers below it.
 add_subdirectory(util)
+add_subdirectory(geometry)
 add_subdirectory(physics)
 add_subdirectory(io)
 add_subdirectory(scene)
@@ -31,6 +32,7 @@ add_subdirectory(render)
 
 set(ernie_layers
     ernie_util
+    ernie_geometry
     ernie_physics
     ernie_io
     ernie_scene

ernie_renderer-0.2.0.dev20/ernie/geometry/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(ernie_geometry INTERFACE)
+target_link_libraries(ernie_geometry INTERFACE ernie_util)

ernie_renderer-0.2.0.dev20/ernie/geometry/bounds.h

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file bounds.h
+/// @brief Axis-aligned boxes in double precision.
+#pragma once
+
+#include <glm/glm.hpp>
+
+#include <cmath>
+#include <limits>
+
+namespace ernie {
+
+/// @brief An axis-aligned box; the default one is empty and grows to hold what it is given.
+struct Box {
+    glm::dvec3 min{std::numeric_limits<double>::infinity()};
+    glm::dvec3 max{-std::numeric_limits<double>::infinity()};
+
+    static Box Around(const glm::dvec3& center, const glm::dvec3& halfSize) {
+        return {center - halfSize, center + halfSize};
+    }
+
+    bool Empty() const {
+        return !(min.x <= max.x && min.y <= max.y && min.z <= max.z);
+    }
+    glm::dvec3 Center() const {
+        return 0.5 * (min + max);
+    }
+    glm::dvec3 Size() const {
+        return Empty() ? glm::dvec3(0.0) : max - min;
+    }
+
+    Box& Extend(const glm::dvec3& point) {
+        min = glm::min(min, point);
+        max = glm::max(max, point);
+        return *this;
+    }
+    Box& Extend(const Box& other) {
+        if (!other.Empty()) {
+            min = glm::min(min, other.min);
+            max = glm::max(max, other.max);
+        }
+        return *this;
+    }
+    Box Grown(double margin) const {
+        return Empty() ? *this : Box{min - margin, max + margin};
+    }
+
+    /// @return The box holding this one after `transform` (Arvo's method, exact for affine maps).
+    Box Transformed(const glm::dmat4& transform) const {
+        if (Empty()) {
+            return *this;
+        }
+        const glm::dvec3 translation(transform[3]);
+        Box out{translation, translation};
+        for (int column = 0; column < 3; ++column) {
+            for (int row = 0; row < 3; ++row) {
+                const double a = transform[column][row] * min[column];
+                const double b = transform[column][row] * max[column];
+                out.min[row] += std::min(a, b);
+                out.max[row] += std::max(a, b);
+            }
+        }
+        return out;
+    }
+
+    bool operator==(const Box&) const = default;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/ernie/io/CMakeLists.txt

@@ -10,7 +10,7 @@ add_library(
 )
 target_link_libraries(
     ernie_io
-    PUBLIC ernie_util
+    PUBLIC ernie_geometry
     PRIVATE
         ernie_build_options
         ernie_basisu

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/ernie/io/nanovdb.cpp

@@ -222,22 +222,12 @@ bool NanoVdbGrid::Vector() const {
     return type == NanoVdbType::Vec3f;
 }
 
-void NanoVdbGrid::GridBounds(glm::dvec3& min, glm::dvec3& max) const {
-    min = glm::dvec3(std::numeric_limits<double>::infinity());
-    max = -min;
+Box NanoVdbGrid::GridBounds() const {
     if (Empty()) {
-        min = max = glm::dvec3(indexToGrid[3]);
-        return;
-    }
-    const glm::dvec3 lo = glm::dvec3(indexMin) - 1.0;
-    const glm::dvec3 hi = glm::dvec3(indexMax) + 1.0;
-    for (int corner = 0; corner < 8; ++corner) {
-        const glm::dvec3 index{(corner & 1) != 0 ? hi.x : lo.x, (corner & 2) != 0 ? hi.y : lo.y,
-                               (corner & 4) != 0 ? hi.z : lo.z};
-        const glm::dvec3 point = glm::dvec3(indexToGrid * glm::dvec4(index, 1.0));
-        min = glm::min(min, point);
-        max = glm::max(max, point);
+        const glm::dvec3 origin(indexToGrid[3]);
+        return {origin, origin};
     }
+    return Box{glm::dvec3(indexMin) - 1.0, glm::dvec3(indexMax) + 1.0}.Transformed(indexToGrid);
 }
 
 std::vector<NanoVdbGrid> ParseNanoVdbGrids(std::span<const std::uint8_t> bytes) {

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/ernie/io/nanovdb.h

@@ -3,6 +3,8 @@
 /// @brief NanoVDB grids: reading .nvdb/.vdb files and building grids.
 #pragma once
 
+#include "ernie/geometry/bounds.h"
+
 #include <glm/glm.hpp>
 
 #include <cstdint>
@@ -79,11 +81,9 @@ struct NanoVdbGrid {
     bool Scalar() const;
     /// @return Whether volumes sample a 3-vector per voxel.
     bool Vector() const;
-    /// @brief Active bounds in the grid frame, grown by a voxel on
-    /// each side for trilinear sampling.
-    /// @param min Receives the lower corner.
-    /// @param max Receives the upper corner.
-    void GridBounds(glm::dvec3& min, glm::dvec3& max) const;
+    /// @return Active bounds in the grid frame, grown by a voxel on each side for trilinear
+    /// sampling; the grid's origin when it has no active voxels.
+    Box GridBounds() const;
 };
 
 /// @brief Reads every grid of a NanoVDB file, in file order.

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/ernie/scene/storage.cpp

@@ -113,26 +113,66 @@ std::vector<PrimId> PrimStore::DefineMany(std::span<const PathId> paths, BucketI
             throw std::invalid_argument("Prim " + paths_.ToPath(path).String() + " already exists");
         }
     }
-    Bucket& b = *buckets_[bucket];
-    const std::uint32_t first = b.Rows();
     const auto count = static_cast<std::uint32_t>(paths.size());
-    for (Column& column : b.columns) {
-        column.values->Grow(count);
-        column.Resize(first + count);
-    }
+    const std::uint32_t first = AddRows(bucket, count);
+    Bucket& b = *buckets_[bucket];
     std::vector<PrimId> prims;
     prims.reserve(count);
-    b.prims.reserve(first + count);
     for (std::uint32_t i = 0; i < count; ++i) {
         prims.push_back(AddSlot(paths[i], bucket, first + i));
-        b.prims.push_back(prims.back());
+        b.prims[first + i] = prims.back();
     }
-    Log(b, {Next(), StructuralChange::Kind::Added, first, count, 0});
     return prims;
 }
 
+std::uint32_t PrimStore::AddRows(BucketId bucket, std::uint32_t count) {
+    Bucket& b = *buckets_[bucket];
+    const std::uint32_t first = b.Rows();
+    for (Column& column : b.columns) {
+        column.values->Grow(count);
+        column.Resize(first + count);
+    }
+    b.prims.resize(first + count);
+    Log(b, {Next(), StructuralChange::Kind::Added, first, count, 0});
+    return first;
+}
+
 void PrimStore::Remove(PrimId prim) {
     SlotData& slot = const_cast<SlotData&>(Slot(prim));
+    DropRow(slot);
+    pathSlots_[slot.path] = kNoSlot;
+    slot.alive = false;
+    ++slot.generation;
+    free_.push_back(prim.slot);
+}
+
+void PrimStore::Move(PrimId prim, BucketId bucket) {
+    SlotData& slot = const_cast<SlotData&>(Slot(prim));
+    if (slot.bucket == bucket) {
+        return;
+    }
+    const std::uint32_t row = AddRows(bucket, 1);
+    Bucket& to = *buckets_[bucket];
+    const Bucket& from = *buckets_[slot.bucket];
+    to.prims[row] = prim;
+    const std::uint64_t version = Next();
+    for (const Column& source : from.columns) {
+        const auto found = to.columnIndex.find(source.attribute);
+        if (found == to.columnIndex.end() || !source.authored.Test(slot.row)) {
+            continue;
+        }
+        Column& column = to.columns[found->second];
+        if (column.values->Type() == source.values->Type()) {
+            column.values->CopyRow(row, *source.values, slot.row);
+            Stamp(bucket, column, row, row + 1, version);
+        }
+    }
+    DropRow(slot);
+    slot.bucket = bucket;
+    slot.row = row;
+}
+
+void PrimStore::DropRow(const SlotData& slot) {
     Bucket& b = *buckets_[slot.bucket];
     const std::uint32_t row = slot.row;
     const std::uint32_t last = b.Rows() - 1;
@@ -149,10 +189,6 @@ void PrimStore::Remove(PrimId prim) {
         column.authored.Set(row, column.authored.Test(last));
         column.Resize(last);
     }
-    pathSlots_[slot.path] = kNoSlot;
-    slot.alive = false;
-    ++slot.generation;
-    free_.push_back(prim.slot);
 }
 
 void PrimStore::Clear(PrimId prim, AttributeId attribute) {

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/ernie/scene/storage.h

@@ -108,6 +108,8 @@ class ColumnValues {
     virtual void SwapRemove(std::size_t row) = 0;
     /// Puts the fallback back in `row`.
     virtual void Reset(std::size_t row) = 0;
+    /// Copies `source`'s value at `from` into `row`; `source` holds the same type.
+    virtual void CopyRow(std::size_t row, const ColumnValues& source, std::size_t from) = 0;
 };
 
 template <typename T> class TypedColumn final : public ColumnValues {
@@ -132,6 +134,9 @@ template <typename T> class TypedColumn final : public ColumnValues {
     void Reset(std::size_t row) override {
         values_[row] = fallback_;
     }
+    void CopyRow(std::size_t row, const ColumnValues& source, std::size_t from) override {
+        values_[row] = static_cast<const TypedColumn&>(source).values_[from];
+    }
 
     std::vector<T>& Values() {
         return values_;
@@ -290,6 +295,9 @@ class PrimStore {
     std::vector<PrimId> DefineMany(std::span<const PathId> paths, BucketId bucket);
     /// @brief Removes a prim; the bucket's last row moves into its place.
     void Remove(PrimId prim);
+    /// @brief Moves a prim to another bucket, keeping its id and the authored values of the
+    /// attributes both buckets have.
+    void Move(PrimId prim, BucketId bucket);
 
     bool Alive(PrimId prim) const;
     std::optional<PrimId> Find(PathId path) const;
@@ -362,6 +370,10 @@ class PrimStore {
     }
     const SlotData& Slot(PrimId prim) const;
     PrimId AddSlot(PathId path, BucketId bucket, std::uint32_t row);
+    /// Appends `count` rows at their fallbacks to a bucket, logged as one change.
+    std::uint32_t AddRows(BucketId bucket, std::uint32_t count);
+    /// Drops a prim's row from its bucket, the last row moving into its place.
+    void DropRow(const SlotData& slot);
     void Log(Bucket& bucket, StructuralChange change);
     /// Marks rows [begin, end) authored and changed at `version`.
     void Stamp(BucketId bucket, Column& column, std::uint32_t begin, std::uint32_t end,

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/tests/io/nanovdb_test.cpp

@@ -62,11 +62,9 @@ TEST(NanoVdb, ReadsWarpsFile) {
     EXPECT_EQ(grid.maxValue, 0.0);
 
     // Grown by a voxel each side, what trilinear sampling reaches.
-    glm::dvec3 min;
-    glm::dvec3 max;
-    grid.GridBounds(min, max);
-    EXPECT_NEAR(min.x, -0.85, kFloat);
-    EXPECT_NEAR(max.y, 0.85, kFloat);
+    const Box bounds = grid.GridBounds();
+    EXPECT_NEAR(bounds.min.x, -0.85, kFloat);
+    EXPECT_NEAR(bounds.max.y, 0.85, kFloat);
 }
 
 TEST(NanoVdb, RawBufferMatchesTheFile) {

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev20}/tests/scene/storage_test.cpp

@@ -48,6 +48,35 @@ TEST(PrimStore, DefinesFindsAndRemovesPrims) {
     EXPECT_FALSE(s.store.Alive(a));
 }
 
+TEST(PrimStore, MovingToAnotherBucketKeepsTheIdAndSharedAuthoredValues) {
+    Spheres s;
+    const AttributeId height = s.store.Tokens().Intern("height");
+    const BucketId cylinders =
+        s.store.AddBucket({s.store.Tokens().Intern("Cylinder"), {}},
+                          std::vector<ColumnLayout>{ColumnLayout::Of<double>(s.radius, 1.0),
+                                                    ColumnLayout::Of<double>(height, 2.0)});
+    const PrimId a = s.Define("/A");
+    const PrimId b = s.Define("/B");
+    s.store.Set(a, s.radius, 3.0);
+    s.store.Set(a, s.color, glm::dvec3(1.0));
+    const std::uint64_t cursor = s.store.Version();
+
+    s.store.Move(a, cylinders);
+    EXPECT_TRUE(s.store.Alive(a));
+    EXPECT_EQ(s.store.BucketOf(a), cylinders);
+    EXPECT_EQ(*s.store.Get<double>(a, s.radius), 3.0) << "both buckets have radius";
+    EXPECT_EQ(s.store.Get<double>(a, height), nullptr) << "unauthored in its new bucket";
+    EXPECT_EQ(s.store.RowOf(b), 0u) << "the old bucket's last row filled the gap";
+
+    const ChangeSet changes = s.store.ChangesSince(cursor);
+    ASSERT_EQ(changes.rows.size(), 3u) << "removed and moved in one bucket, added in the other";
+    EXPECT_EQ(changes.rows[0].bucket, s.bucket);
+    EXPECT_EQ(changes.rows[0].change.kind, StructuralChange::Kind::Removed);
+    EXPECT_EQ(changes.rows[1].change.kind, StructuralChange::Kind::Moved);
+    EXPECT_EQ(changes.rows[2].bucket, cylinders);
+    EXPECT_EQ(changes.rows[2].change.kind, StructuralChange::Kind::Added);
+}
+
 TEST(PrimStore, UnauthoredRowsHoldTheFallbackForWholeColumnReads) {
     Spheres s;
     const PrimId a = s.Define("/A");