ernie-renderer 0.2.0.dev47__tar.gz → 0.2.0.dev52__tar.gz

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev47
+Version: 0.2.0.dev52
 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.dev47 → ernie_renderer-0.2.0.dev52}/benchmarks/scene/extents.cpp

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace ernie::bench {
 namespace {

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/benchmarks/scene/storage.cpp

@@ -25,7 +25,7 @@ struct Robots {
         transform = store->Tokens().Intern("xformOp:transform");
         bucket = store->AddBucket(
             {store->Tokens().Intern("Xform"), {}},
-            std::vector<ColumnLayout>{ColumnLayout::Of<glm::dmat4>(transform, glm::dmat4(1.0))});
+            std::vector<ColumnLayout>{ColumnLayout::Make<glm::dmat4>(transform, glm::dmat4(1.0))});
         prims.clear();
     }
 

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/CMakeLists.txt

@@ -19,10 +19,8 @@ add_library(
     view.cpp
     xform.cpp
     schemas/camera.cpp
-    schemas/collection.cpp
     schemas/geom.cpp
     schemas/instancer.cpp
-    schemas/laser.cpp
     schemas/lux.cpp
     schemas/mesh.cpp
     schemas/planet.cpp

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/animation.cpp

@@ -58,11 +58,11 @@ std::optional<Value> Scene::GetAt(PrimId prim, std::string_view attribute, doubl
 }
 
 bool Scene::ClearSamples(PrimId prim, std::string_view attribute) {
-    const auto animated = animated_.find(prim.slot);
-    const std::optional<Token> token = store_.Tokens().Find(attribute);
-    if (animated == animated_.end() || !token || animated->second.samples.erase(*token) == 0) {
+    if (Samples(prim, attribute).empty()) {
         return false;
     }
+    const auto animated = animated_.find(prim.slot);
+    animated->second.samples.erase(*store_.Tokens().Find(attribute));
     if (animated->second.samples.empty()) {
         animated_.erase(animated);
     }

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/edit_history.cpp

@@ -3,6 +3,9 @@
 /// @brief Recording edits as steps of before and after states, and applying them either way.
 #include "ernie/scene/edit_history.h"
 
+#include "ernie/util/text.h"
+
+#include <algorithm>
 #include <stdexcept>
 
 namespace ernie {
@@ -15,7 +18,7 @@ void EditHistory::Set(Scene& scene, const Path& path,
         for (auto& [name, value] : edits) {
             Cell before = Capture(scene, prim, name);
             scene.Set(prim, name, std::move(value));
-            step.attributes.push_back({name, {std::move(before), Capture(scene, prim, name)}});
+            step.attributes.push_back({name, std::move(before), Capture(scene, prim, name)});
         }
     } catch (...) {
         // What applied before the rejected edit stays undoable.
@@ -25,20 +28,13 @@ void EditHistory::Set(Scene& scene, const Path& path,
         throw;
     }
     const auto same = [&](const Step& last) {
-        if (last.structural || !last.open || last.path != path ||
-            last.attributes.size() != step.attributes.size()) {
-            return false;
-        }
-        for (std::size_t i = 0; i < last.attributes.size(); ++i) {
-            if (last.attributes[i].first != step.attributes[i].first) {
-                return false;
-            }
-        }
-        return true;
+        return !last.structural && last.open && last.path == path &&
+               std::ranges::equal(last.attributes, step.attributes, {}, &AttributeEdit::name,
+                                  &AttributeEdit::name);
     };
     if (open && open_ && next_ == steps_.size() && !steps_.empty() && same(steps_.back())) {
         for (std::size_t i = 0; i < step.attributes.size(); ++i) {
-            steps_.back().attributes[i].second.second = std::move(step.attributes[i].second.second);
+            steps_.back().attributes[i].after = std::move(step.attributes[i].after);
         }
         return;
     }
@@ -50,9 +46,7 @@ void EditHistory::Clear(Scene& scene, const Path& path, std::string_view attribu
     const std::string name(attribute);
     Cell before = Capture(scene, prim, name);
     scene.Clear(prim, attribute);
-    Step step{.path = path};
-    step.attributes.push_back({name, {std::move(before), Capture(scene, prim, name)}});
-    Push(std::move(step));
+    Push({.path = path, .attributes = {{name, std::move(before), Capture(scene, prim, name)}}});
 }
 
 void EditHistory::Define(Scene& scene, const Path& path, std::string_view type) {
@@ -168,9 +162,7 @@ void EditHistory::Restore(Scene& scene, const std::vector<PrimSnapshot>& prims)
     for (const PrimSnapshot& snapshot : prims) {
         const PrimId prim = scene.Define(snapshot.path, snapshot.type);
         for (const std::string& api : snapshot.apis) {
-            if (!scene.HasApi(prim, api)) {
-                scene.ApplyApi(prim, api);
-            }
+            scene.ApplyApi(prim, api);
         }
         for (const auto& [name, cell] : snapshot.attributes) {
             Apply(scene, prim, name, cell);
@@ -190,8 +182,8 @@ void EditHistory::Apply(Scene& scene, const Step& step, bool forward) {
         return;
     }
     for (std::size_t i = 0; i < step.attributes.size(); ++i) {
-        const auto& [name, states] = step.attributes[forward ? i : step.attributes.size() - 1 - i];
-        Apply(scene, *prim, name, forward ? states.second : states.first);
+        const AttributeEdit& edit = step.attributes[forward ? i : step.attributes.size() - 1 - i];
+        Apply(scene, *prim, edit.name, forward ? edit.after : edit.before);
     }
 }
 
@@ -227,11 +219,7 @@ std::string EditHistory::Label(const Step& step) {
                                      : "Change ") +
                step.path.String();
     }
-    std::string label = step.path.String();
-    for (const auto& [name, states] : step.attributes) {
-        label += " " + name;
-    }
-    return label;
+    return step.path.String() + " " + Join(step.attributes, " ", &AttributeEdit::name);
 }
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/edit_history.h

@@ -93,10 +93,14 @@ class EditHistory {
         std::vector<std::string> apis;
         std::map<std::string, Cell> attributes;
     };
+    struct AttributeEdit {
+        std::string name;
+        Cell before;
+        Cell after;
+    };
     struct Step {
         Path path;
-        /// Attribute steps: each attribute's state before and after.
-        std::vector<std::pair<std::string, std::pair<Cell, Cell>>> attributes;
+        std::vector<AttributeEdit> attributes;
         /// Structure steps: the subtree at `path` before and after, parents first; empty for none.
         std::vector<PrimSnapshot> before;
         std::vector<PrimSnapshot> after;

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/extent_cache.cpp

@@ -14,28 +14,20 @@ void ExtentCache::Track(BucketId bucket, ExtentFunction compute) {
 
 void ExtentCache::Update(const PrimStore& store) {
     const ChangeSet changes = store.ChangesSince(cursor_);
-    const auto tracked = [&](BucketId bucket) {
-        return bucket < buckets_.size() && buckets_[bucket].compute != nullptr;
-    };
-    for (const BucketId bucket : changes.resets) {
-        if (tracked(bucket)) {
-            Resize(buckets_[bucket], 0);
-        }
-    }
     for (const ChangeSet::Rows& rows : changes.rows) {
-        if (tracked(rows.bucket)) {
+        if (Tracked(rows.bucket)) {
             Replay(buckets_[rows.bucket], rows.change);
         }
     }
     for (const ChangeSet::Values& values : changes.values) {
-        if (tracked(values.bucket)) {
+        if (Tracked(values.bucket)) {
             for (const RowRange range : values.rows) {
                 buckets_[values.bucket].stale.SetRange(range.begin, range.end);
             }
         }
     }
     for (BucketId bucket = 0; bucket < buckets_.size(); ++bucket) {
-        if (tracked(bucket) && store.GetBucket(bucket).version > cursor_) {
+        if (Tracked(bucket) && store.GetBucket(bucket).version > cursor_) {
             Refresh(buckets_[bucket], store, bucket);
         }
     }
@@ -44,16 +36,23 @@ void ExtentCache::Update(const PrimStore& store) {
 
 std::optional<Box> ExtentCache::Find(const PrimStore& store, BucketId bucket,
                                      std::uint32_t row) const {
-    if (bucket >= buckets_.size() || buckets_[bucket].compute == nullptr ||
-        store.GetBucket(bucket).version > cursor_ || row >= buckets_[bucket].boxes.size()) {
+    if (!Tracked(bucket) || store.GetBucket(bucket).version > cursor_ ||
+        row >= buckets_[bucket].boxes.size()) {
         return std::nullopt;
     }
     return buckets_[bucket].boxes[row];
 }
 
+bool ExtentCache::Tracked(BucketId bucket) const {
+    return bucket < buckets_.size() && buckets_[bucket].compute != nullptr;
+}
+
 void ExtentCache::Replay(Entry& entry, const StructuralChange& change) {
     using Kind = StructuralChange::Kind;
-    if (change.kind == Kind::Added) {
+    if (change.kind == Kind::Reset) {
+        Resize(entry, 0);
+    }
+    if (change.kind == Kind::Added || change.kind == Kind::Reset) {
         Resize(entry, change.row + change.count);
         entry.stale.SetRange(change.row, change.row + change.count);
     } else if (change.kind == Kind::Moved) {
@@ -72,12 +71,6 @@ void ExtentCache::Resize(Entry& entry, std::uint32_t rows) {
 }
 
 void ExtentCache::Refresh(Entry& entry, const PrimStore& store, BucketId bucket) {
-    const std::uint32_t rows = store.GetBucket(bucket).Rows();
-    if (entry.boxes.size() != rows) {
-        // Too far behind to replay (a reset): recompute the bucket whole.
-        Resize(entry, rows);
-        entry.stale.SetRange(0, rows);
-    }
     const ExtentRows columns{store, bucket};
     entry.stale.ForEachRun([&](std::size_t begin, std::size_t end) {
         entry.compute(columns, {static_cast<std::uint32_t>(begin), static_cast<std::uint32_t>(end)},

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/extent_cache.h

@@ -32,6 +32,7 @@ class ExtentCache {
         BitSet stale;
     };
 
+    bool Tracked(BucketId bucket) const;
     static void Replay(Entry& entry, const StructuralChange& change);
     static void Resize(Entry& entry, std::uint32_t rows);
     static void Refresh(Entry& entry, const PrimStore& store, BucketId bucket);

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/holder_index.cpp

@@ -3,6 +3,8 @@
 /// @brief Re-indexing changed relationship cells, and finding a target's live holders.
 #include "ernie/scene/holder_index.h"
 
+#include "ernie/util/algorithm.h"
+
 #include <algorithm>
 #include <unordered_set>
 
@@ -16,18 +18,28 @@ bool IsRelationship(ColumnType type) {
 /// @return The targets of a relationship cell, without the unset one.
 std::vector<PathId> Targets(const PrimStore& store, BucketId bucket, const Column& column,
                             std::uint32_t row) {
-    std::vector<PathId> targets;
-    if (column.values->Type() == ColumnType::Relationship) {
-        targets.push_back(store.Read<Target>(bucket, column.attribute)[row].path);
-    } else {
-        for (const Target target : store.Read<std::vector<Target>>(bucket, column.attribute)[row]) {
-            targets.push_back(target.path);
-        }
-    }
+    std::vector<PathId> targets =
+        column.values->Type() == ColumnType::Relationship
+            ? std::vector<PathId>{store.Read<Target>(bucket, column.attribute)[row].path}
+            : Map(store.Read<std::vector<Target>>(bucket, column.attribute)[row], &Target::path);
     std::erase(targets, kNoPath);
     return targets;
 }
 
+/// @return Whether the prim is alive and its relationship still targets `target`.
+bool Holds(const PrimStore& store, PrimId prim, AttributeId attribute, PathId target) {
+    if (!store.Alive(prim)) {
+        return false;
+    }
+    const BucketId bucket = store.PrimBucket(prim);
+    const Column* column = store.GetBucket(bucket).Find(attribute);
+    if (column == nullptr || !IsRelationship(column->values->Type())) {
+        return false;
+    }
+    const std::vector<PathId> targets = Targets(store, bucket, *column, store.PrimRow(prim));
+    return std::ranges::find(targets, target) != targets.end();
+}
+
 }  // namespace
 
 void HolderIndex::Update(const PrimStore& store) {
@@ -39,22 +51,12 @@ void HolderIndex::Update(const PrimStore& store) {
             continue;
         }
         for (const RowRange range : values.rows) {
-            for (std::uint32_t row = range.begin; row < std::min(range.end, bucket.Rows()); ++row) {
+            for (std::uint32_t row = range.begin; row < range.end; ++row) {
                 Index(bucket.prims[row], values.attribute,
                       Targets(store, values.bucket, column, row));
             }
         }
     }
-    // A bucket too far behind to replay reports every row of every column, as a fresh one does.
-    for (const BucketId id : changes.resets) {
-        const Bucket& bucket = store.GetBucket(id);
-        for (const Column& column : bucket.columns) {
-            for (std::uint32_t row = 0;
-                 IsRelationship(column.values->Type()) && row < bucket.Rows(); ++row) {
-                Index(bucket.prims[row], column.attribute, Targets(store, id, column, row));
-            }
-        }
-    }
     cursor_ = changes.version;
 }
 
@@ -95,17 +97,4 @@ std::vector<PrimId> HolderIndex::Find(const PrimStore& store, PathId target) con
     return found;
 }
 
-bool HolderIndex::Holds(const PrimStore& store, PrimId prim, AttributeId attribute, PathId target) {
-    if (!store.Alive(prim)) {
-        return false;
-    }
-    const BucketId bucket = store.PrimBucket(prim);
-    const Column* column = store.GetBucket(bucket).Find(attribute);
-    if (column == nullptr || !IsRelationship(column->values->Type())) {
-        return false;
-    }
-    const std::vector<PathId> targets = Targets(store, bucket, *column, store.PrimRow(prim));
-    return std::ranges::find(targets, target) != targets.end();
-}
-
 }  // namespace ernie

{ernie_renderer-0.2.0.dev47 → ernie_renderer-0.2.0.dev52}/ernie/scene/holder_index.h

@@ -29,8 +29,6 @@ class HolderIndex {
     }
 
     void Index(PrimId prim, AttributeId attribute, std::vector<PathId> targets);
-    /// @return Whether the prim is alive and its relationship still targets `target`.
-    static bool Holds(const PrimStore& store, PrimId prim, AttributeId attribute, PathId target);
 
     /// Each target's holding cells, with the generation of the prim that wrote them.
     std::unordered_map<PathId, std::unordered_map<Cell, std::uint32_t>> holders_;

ernie_renderer-0.2.0.dev52/ernie/scene/inherit.cpp

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file inherit.cpp
+/// @brief Resolving inherited attributes from the nearest authoring ancestor into their resolved
+/// columns, for only the subtrees whose authored values or prims changed.
+#include "ernie/scene/convert.h"
+#include "ernie/scene/scene.h"
+
+#include <algorithm>
+#include <concepts>
+
+namespace ernie {
+namespace {
+
+/// @brief One inherited attribute resolving over the store.
+template <typename T> struct Resolver {
+    PrimStore& store;
+    AttributeId attribute;
+    AttributeId resolved;
+    T fallback;
+    /// The "inherited" token, which authors nothing.
+    Token inherited;
+
+    /// @return What the prim's own value resolves to: null when it doesn't author one.
+    const T* Own(PrimId prim) const {
+        const T* own = store.Get<T>(prim, attribute);
+        if constexpr (std::same_as<T, Token>) {
+            return own != nullptr && *own == inherited ? nullptr : own;
+        }
+        return own;
+    }
+
+    /// @return The value `path` inherits from its ancestors.
+    T Above(PathId path) const {
+        const PathTable& paths = store.Paths();
+        for (PathId above = paths.Parent(path); above != kRootPath; above = paths.Parent(above)) {
+            const std::optional<PrimId> prim = store.Find(above);
+            if (const T* own = prim ? Own(*prim) : nullptr) {
+                return *own;
+            }
+        }
+        return fallback;
+    }
+
+    /// Resolves the subtree at `root`, descending past a prim only while its value changes or it
+    /// is one of `roots`, which it clears as it reaches them.
+    void Subtree(PathId root, BitSet& roots) {
+        std::vector<std::pair<PathId, T>> pending{{root, Above(root)}};
+        while (!pending.empty()) {
+            const auto [path, above] = std::move(pending.back());
+            pending.pop_back();
+            const std::optional<PrimId> prim = store.Find(path);
+            if (!prim) {
+                continue;
+            }
+            const bool isRoot = roots.Test(path);
+            roots.Set(path, false);
+            const T* own = Own(*prim);
+            const T value = own != nullptr ? *own : above;
+            // Prims without the column (typeless ones, materials) pass the value through.
+            const bool stored = store.GetBucket(store.PrimBucket(*prim)).Find(resolved) != nullptr;
+            // An unchanged prim's descendants are unchanged too, unless they are roots themselves.
+            if (store.Derive(*prim, resolved, value) || isRoot || !stored) {
+                store.Paths().ForEachChild(
+                    path, [&](PathId child) { pending.emplace_back(child, value); });
+            }
+        }
+    }
+};
+
+/// @return The paths of the prims whose subtrees resolve `attribute` again: those added or with
+/// it changed.
+BitSet Roots(const PrimStore& store, const ChangeSet& changes, AttributeId attribute) {
+    BitSet roots;
+    roots.Resize(store.Paths().Size());
+    const auto add = [&](BucketId bucket, std::uint32_t begin, std::uint32_t end) {
+        const Bucket& rows = store.GetBucket(bucket);
+        for (std::uint32_t row = begin; row < std::min(end, rows.Rows()); ++row) {
+            roots.Set(store.PrimPath(rows.prims[row]));
+        }
+    };
+    for (const ChangeSet::Rows& rows : changes.rows) {
+        if (rows.change.kind == StructuralChange::Kind::Added ||
+            rows.change.kind == StructuralChange::Kind::Reset) {
+            add(rows.bucket, rows.change.row, rows.change.row + rows.change.count);
+        }
+    }
+    for (const ChangeSet::Values& values : changes.values) {
+        if (values.attribute == attribute) {
+            for (const RowRange range : values.rows) {
+                add(values.bucket, range.begin, range.end);
+            }
+        }
+    }
+    return roots;
+}
+
+}  // namespace
+
+void Scene::Resolve() {
+    const ChangeSet changes = store_.ChangesSince(resolved_);
+    for (const AttributeDef* def : InheritedAttributes()) {
+        const AttributeId attribute = store_.Tokens().Intern(def->name);
+        WithColumnType(def->type, [&]<typename T>(std::type_identity<T>) {
+            if constexpr (std::equality_comparable<T> && !std::same_as<T, Tensor>) {
+                Resolver<T> resolver{
+                    store_, attribute, store_.Tokens().Intern(ResolvedName(def->name)),
+                    ToElement<T>(store_.Paths(), def->fallback).value_or(T{}), inherited_};
+                BitSet roots = Roots(store_, changes, attribute);
+                // Ancestors intern first, so most roots are reached from one above them.
+                const BitSet start = roots;
+                start.ForEachRun([&](std::size_t begin, std::size_t end) {
+                    for (std::size_t path = begin; path < end; ++path) {
+                        if (roots.Test(path)) {
+                            resolver.Subtree(static_cast<PathId>(path), roots);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    // Its own writes are to resolved columns, which no resolve reads.
+    resolved_ = store_.Version();
+}
+
+}  // namespace ernie