ernie-renderer 0.2.0.dev40__tar.gz → 0.2.0.dev43__tar.gz

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/CMakeLists.txt

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

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /// @file extents.cpp
-/// @brief Cached extents at 100,000 prims: the first update, and one edit's.
+/// @brief Scene updates at 100,000 prims: the first, one edit's, and one inherited edit's.
 #include "benchmarks/bench.h"
 #include "ernie/scene/schemas/geom.h"
 
@@ -21,20 +21,35 @@ std::unique_ptr<Scene> MakeSpheres() {
     return scene;
 }
 
-const bool kFirstUpdate = Register("scene.extents.first_update_100k", [] {
+const bool kFirstUpdate = Register("scene.update.first_100k", [] {
     std::unique_ptr<Scene> scene;
-    return Timing{Fastest([&] { scene = MakeSpheres(); }, [&] { scene->UpdateExtents(); }), 10.0};
+    return Timing{Fastest([&] { scene = MakeSpheres(); }, [&] { scene->Update(); }), 10.0};
 });
 
-const bool kOneEdit = Register("scene.extents.update_after_one_edit_of_100k", [] {
+const bool kOneEdit = Register("scene.update.after_one_edit_of_100k", [] {
     std::unique_ptr<Scene> scene = MakeSpheres();
-    scene->UpdateExtents();
+    scene->Update();
     const PrimId ball = *scene->Find("/World/Ball_54321");
     double radius = 1.0;
     const double ms = Fastest([&] { scene->Set(ball, Sphere::kRadius, radius += 1.0); },
-                              [&] { scene->UpdateExtents(); });
+                              [&] { scene->Update(); });
     return Timing{ms, 1.0};
 });
 
+const bool kInheritedEdit = Register("scene.update.after_hiding_the_parent_of_100k", [] {
+    std::unique_ptr<Scene> scene = MakeSpheres();
+    scene->Define("/World", "Xform");
+    scene->Update();
+    const PrimId world = *scene->Find("/World");
+    bool hidden = false;
+    const double ms = Fastest(
+        [&] {
+            hidden = !hidden;
+            scene->Set(world, Imageable::kVisibility, hidden ? "invisible" : "inherited");
+        },
+        [&] { scene->Update(); });
+    return Timing{ms, 10.0};
+});
+
 }  // namespace
 }  // namespace ernie::bench

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/CMakeLists.txt

@@ -3,6 +3,8 @@ add_library(
     ernie_scene
     OBJECT
     extent_cache.cpp
+    holder_index.cpp
+    inherit.cpp
     path.cpp
     schema.cpp
     scene.cpp

ernie_renderer-0.2.0.dev43/ernie/scene/holder_index.cpp

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file holder_index.cpp
+/// @brief Re-indexing changed relationship cells, and finding a target's live holders.
+#include "ernie/scene/holder_index.h"
+
+#include <algorithm>
+#include <unordered_set>
+
+namespace ernie {
+namespace {
+
+bool IsRelationship(ColumnType type) {
+    return type == ColumnType::Relationship || type == ColumnType::Relationships;
+}
+
+/// @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::erase(targets, kNoPath);
+    return targets;
+}
+
+}  // namespace
+
+void HolderIndex::Update(const PrimStore& store) {
+    const ChangeSet changes = store.ChangesSince(cursor_);
+    for (const ChangeSet::Values& values : changes.values) {
+        const Bucket& bucket = store.GetBucket(values.bucket);
+        const Column& column = *bucket.Find(values.attribute);
+        if (!IsRelationship(column.values->Type())) {
+            continue;
+        }
+        for (const RowRange range : values.rows) {
+            for (std::uint32_t row = range.begin; row < std::min(range.end, bucket.Rows()); ++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;
+}
+
+void HolderIndex::Index(PrimId prim, AttributeId attribute, std::vector<PathId> targets) {
+    const Cell cell = Key(prim, attribute);
+    const auto found = targets_.find(cell);
+    if (found != targets_.end()) {
+        for (const PathId old : found->second) {
+            holders_[old].erase(cell);
+        }
+    }
+    for (const PathId target : targets) {
+        holders_[target][cell] = prim.generation;
+    }
+    if (!targets.empty()) {
+        targets_[cell] = std::move(targets);
+    } else if (found != targets_.end()) {
+        targets_.erase(found);
+    }
+}
+
+std::vector<PrimId> HolderIndex::Find(const PrimStore& store, PathId target) const {
+    std::vector<PrimId> found;
+    const auto holders = holders_.find(target);
+    if (holders == holders_.end()) {
+        return found;
+    }
+    std::unordered_set<std::uint32_t> slots;
+    for (const auto& [cell, generation] : holders->second) {
+        const PrimId prim{static_cast<std::uint32_t>(cell >> 32), generation};
+        // Cells of removed prims, or of prims since moved to a bucket without the attribute, stay
+        // until their slot's next prim writes them.
+        if (Holds(store, prim, static_cast<AttributeId>(cell), target) &&
+            slots.insert(prim.slot).second) {
+            found.push_back(prim);
+        }
+    }
+    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.dev43/ernie/scene/holder_index.h

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file holder_index.h
+/// @brief The reverse index of relationships: which prims target each path.
+#pragma once
+
+#include "ernie/scene/storage.h"
+
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
+
+namespace ernie {
+
+/// @brief Which prims' relationships target each path, kept up to date from the store's changes,
+/// so an edit to a target reaches its holders: a prototype its instancers, a material the prims
+/// bound to it (through their resolved bindings), a body its terrains.
+class HolderIndex {
+  public:
+    /// Re-indexes the relationship cells that changed since the last update.
+    void Update(const PrimStore& store);
+    /// @return The live prims with a relationship targeting `target`, each once.
+    std::vector<PrimId> Find(const PrimStore& store, PathId target) const;
+
+  private:
+    /// A relationship cell: the prim's slot and the attribute, packed.
+    using Cell = std::uint64_t;
+    static Cell Key(PrimId prim, AttributeId attribute) {
+        return (std::uint64_t{prim.slot} << 32) | attribute;
+    }
+
+    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_;
+    /// Each cell's targets, to unindex them when it changes.
+    std::unordered_map<Cell, std::vector<PathId>> targets_;
+    std::uint64_t cursor_ = 0;
+};
+
+}  // namespace ernie

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

@@ -0,0 +1,120 @@
+// 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>
+#include <limits>
+
+namespace ernie {
+
+void Scene::Resolve() {
+    const ChangeSet changes = store_.ChangesSince(resolved_);
+    for (const AttributeDef* def : InheritedAttributes()) {
+        const AttributeId attribute = store_.Tokens().Intern(def->name);
+        const AttributeId resolved = store_.Tokens().Intern(ResolvedName(def->name));
+        WithColumnType(def->type, [&]<typename T>(std::type_identity<T>) {
+            if constexpr (std::equality_comparable<T> && !std::same_as<T, Tensor>) {
+                const T fallback = ToElement<T>(store_.Paths(), def->fallback).value_or(T{});
+                BitSet roots = ResolveRoots(changes, attribute);
+                std::vector<PathId> order;
+                roots.ForEachRun([&](std::size_t begin, std::size_t end) {
+                    for (std::size_t path = begin; path < end; ++path) {
+                        order.push_back(static_cast<PathId>(path));
+                    }
+                });
+                // Ancestors intern first, so most roots are reached from one above them.
+                for (const PathId root : order) {
+                    if (roots.Test(root)) {
+                        ResolveSubtree<T>(root, attribute, resolved, fallback, roots);
+                    }
+                }
+            }
+        });
+    }
+    // Its own writes are to resolved columns, which no resolve reads.
+    resolved_ = store_.Version();
+}
+
+BitSet Scene::ResolveRoots(const ChangeSet& changes, AttributeId attribute) const {
+    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 BucketId bucket : changes.resets) {
+        add(bucket, 0, std::numeric_limits<std::uint32_t>::max());
+    }
+    for (const ChangeSet::Rows& rows : changes.rows) {
+        if (rows.change.kind == StructuralChange::Kind::Added) {
+            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;
+}
+
+template <typename T> const T* Scene::Inheritable(PrimId prim, AttributeId attribute) const {
+    const BucketId bucket = store_.PrimBucket(prim);
+    const Column* column = store_.GetBucket(bucket).Find(attribute);
+    const std::uint32_t row = store_.PrimRow(prim);
+    if (column == nullptr || !column->authored.Test(row) ||
+        column->values->Type() != kColumnType<T>) {
+        return nullptr;
+    }
+    const T* own = &store_.Read<T>(bucket, attribute)[row];
+    if constexpr (std::same_as<T, Token>) {
+        return *own == inherited_ ? nullptr : own;
+    }
+    return own;
+}
+
+template <typename T> T Scene::Above(PathId path, AttributeId attribute, const T& fallback) 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 ? Inheritable<T>(*prim, attribute) : nullptr) {
+            return *own;
+        }
+    }
+    return fallback;
+}
+
+template <typename T>
+void Scene::ResolveSubtree(PathId root, AttributeId attribute, AttributeId resolved,
+                           const T& fallback, BitSet& roots) {
+    std::vector<std::pair<PathId, T>> pending{{root, Above<T>(root, attribute, fallback)}};
+    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 = Inheritable<T>(*prim, attribute);
+        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); });
+        }
+    }
+}
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/scene.cpp

@@ -38,7 +38,8 @@ std::string Describe(const Scene& scene, PrimId prim) {
 }  // namespace
 
 Scene::Scene()
-    : invisible_(store_.Tokens().Intern(tokens::kInvisible)),
+    : inherited_(store_.Tokens().Intern(tokens::kInherited)),
+      invisible_(store_.Tokens().Intern(tokens::kInvisible)),
       defaultPurpose_(store_.Tokens().Intern(tokens::kDefault)) {
     FindOrAddBucket(nullptr, {});
 }
@@ -169,20 +170,21 @@ void Scene::Write(PrimId prim, std::string_view attribute, Tensor array) {
     store_.Set(prim, token, std::move(array));
 }
 
-template <typename T> const T* Scene::Authored(PrimId prim, std::string_view attribute) const {
-    const Column* column = AuthoredColumn(prim, attribute);
-    if (column == nullptr || column->values->Type() != kColumnType<T>) {
-        return nullptr;
-    }
-    return &store_.Read<T>(store_.PrimBucket(prim), column->attribute)[store_.PrimRow(prim)];
-}
-
 const Tensor* Scene::Read(PrimId prim, std::string_view attribute) const {
     return Authored<Tensor>(prim, attribute);
 }
 
 std::optional<Value> Scene::Get(PrimId prim, std::string_view attribute) const {
-    const Column* column = AuthoredColumn(prim, attribute);
+    return CellValue(prim, AuthoredColumn(prim, attribute));
+}
+
+std::optional<Value> Scene::GetResolved(PrimId prim, std::string_view attribute) const {
+    const std::optional<Token> token = store_.Tokens().Find(ResolvedName(attribute));
+    return CellValue(prim,
+                     token ? store_.GetBucket(store_.PrimBucket(prim)).Find(*token) : nullptr);
+}
+
+std::optional<Value> Scene::CellValue(PrimId prim, const Column* column) const {
     if (column == nullptr) {
         return std::nullopt;
     }
@@ -252,6 +254,11 @@ std::optional<Box> Scene::Extent(PrimId prim) const {
     return extent;
 }
 
+std::vector<PrimId> Scene::Holders(const Path& target) const {
+    const std::optional<PathId> id = store_.Paths().Find(target);
+    return id ? holders_.Find(store_, *id) : std::vector<PrimId>{};
+}
+
 Box Scene::WorldBounds(const Path& path) const {
     const PrimId prim = Require(path);
     const PathId id = store_.PrimPath(prim);
@@ -333,6 +340,11 @@ BucketId Scene::FindOrAddBucket(const SchemaDef* schema, std::vector<Token> apis
     for (const ApiName& api : allApis) {
         add(*api.schema, api);
     }
+    if (schema != nullptr && schema->IsA(Imageable::Definition())) {
+        for (const AttributeDef* def : InheritedAttributes()) {
+            layout.push_back(MakeLayout(paths, *def, ResolvedName(def->name), def->fallback));
+        }
+    }
     const BucketId bucket = store_.AddBucket(key, layout);
     buckets_.resize(std::max<std::size_t>(buckets_.size(), bucket + 1));
     buckets_[bucket] = std::move(entry);
@@ -447,12 +459,18 @@ Dirty Scene::Classify(const ChangeSet::Values& change) const {
         return def->meta.dirty;
     }
     const std::string_view name = store_.Tokens().Text(change.attribute);
+    if (name.starts_with(tokens::kResolvedPrefix)) {
+        return FindInherited(name.substr(tokens::kResolvedPrefix.size()))->meta.dirty;
+    }
     return name.starts_with(tokens::kXformOpPrefix)    ? Dirty::Transform
            : name.starts_with(tokens::kPrimvarsPrefix) ? Dirty::Primvars
                                                        : Dirty::Params;
 }
 
 bool Scene::TakesUndeclared(PrimId prim, std::string_view attribute) const {
+    if (attribute.starts_with(tokens::kResolvedPrefix)) {
+        return false;
+    }
     const SchemaDef* schema = Schema(prim);
     return schema == nullptr || schema->IsOpen(attribute) ||
            std::ranges::any_of(AllApis(schema, Apis(prim)),

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/scene.h

@@ -5,6 +5,7 @@
 
 #include "ernie/geometry/bounds.h"
 #include "ernie/scene/extent_cache.h"
+#include "ernie/scene/holder_index.h"
 #include "ernie/scene/schema.h"
 #include "ernie/scene/storage.h"
 #include "ernie/scene/value.h"
@@ -68,6 +69,10 @@ class Scene {
     /// @return The authored value, or none.
     std::optional<Value> Get(PrimId prim, std::string_view attribute) const;
     std::optional<Value> Get(const Path& path, std::string_view attribute) const;
+    /// @return An inherited attribute's value as of the last `Update`: the prim's own or its
+    /// nearest authoring ancestor's (where "inherited" isn't authoring), else the fallback; none
+    /// for a prim that isn't Imageable.
+    std::optional<Value> GetResolved(PrimId prim, std::string_view attribute) const;
     /// @brief Authors an array attribute with a tensor on the host or a device, shared, not copied.
     /// @throws std::invalid_argument for a non-array attribute, or a tensor of the wrong type or
     /// shape.
@@ -84,12 +89,20 @@ class Scene {
     glm::dmat4 LocalTransform(PrimId prim) const;
     glm::dmat4 WorldTransform(PrimId prim) const;
     /// @return The prim's extent in its own space; none when it isn't computed from attributes.
-    /// Cached since `UpdateExtents` when its bucket hasn't changed, computed otherwise.
+    /// Cached since `Update` when its bucket hasn't changed, computed otherwise.
     std::optional<Box> Extent(PrimId prim) const;
-    /// @brief Recomputes the cached extents of the rows that changed since the last update.
-    void UpdateExtents() {
+    /// @brief Brings derived data up to date with the edits since the last update, once per step
+    /// before renderers pull changes: resolves inherited attributes for the subtrees whose
+    /// authored values or prims changed, re-indexes changed relationships, then recomputes the
+    /// changed rows' cached extents.
+    void Update() {
+        Resolve();
+        holders_.Update(store_);
         extents_.Update(store_);
     }
+    /// @return The prims whose relationships target `target` as of the last `Update`, resolved
+    /// material bindings included: what an edit to `target` reaches.
+    std::vector<PrimId> Holders(const Path& target) const;
     /// @return The world box of the prim and its visible descendants of the default purpose.
     /// Prims with extents bound their own subtrees, as UsdGeomBBoxCache prunes at Boundables.
     Box WorldBounds(const Path& path) const;
@@ -127,7 +140,30 @@ class Scene {
     /// @return The attribute's column when the prim authors it, or null.
     const Column* AuthoredColumn(PrimId prim, std::string_view attribute) const;
     /// @return The attribute's value when the prim authors it as a `T`, or null.
-    template <typename T> const T* Authored(PrimId prim, std::string_view attribute) const;
+    template <typename T> const T* Authored(PrimId prim, std::string_view attribute) const {
+        const Column* column = AuthoredColumn(prim, attribute);
+        if (column == nullptr || column->values->Type() != kColumnType<T>) {
+            return nullptr;
+        }
+        return &store_.Read<T>(store_.PrimBucket(prim), column->attribute)[store_.PrimRow(prim)];
+    }
+    std::optional<Value> CellValue(PrimId prim, const Column* column) const;
+
+    /// Resolves every inherited attribute for the subtrees changed since the last resolve.
+    void Resolve();
+    /// @return The paths of the prims whose subtrees resolve `attribute` again: those added, reset
+    /// or with it changed.
+    BitSet ResolveRoots(const ChangeSet& changes, AttributeId attribute) const;
+    /// @return What `attribute` resolves to from the prim's own value: null when it doesn't
+    /// author it, or authors "inherited".
+    template <typename T> const T* Inheritable(PrimId prim, AttributeId attribute) const;
+    /// @return The value `path` inherits from its ancestors.
+    template <typename T> T Above(PathId path, AttributeId attribute, const T& fallback) const;
+    /// Resolves `attribute` over the subtree at `root`, descending past a prim only while its
+    /// resolved value changes or it is one of `roots`, which it clears as it reaches them.
+    template <typename T>
+    void ResolveSubtree(PathId root, AttributeId attribute, AttributeId resolved, const T& fallback,
+                        BitSet& roots);
     const AttributeDef* Declared(BucketId bucket, AttributeId attribute) const;
     /// @return Whether the prim's type or an applied API schema leaves the attribute's namespace
     /// open; any attribute for a prim without a type.
@@ -142,10 +178,14 @@ class Scene {
     void AddTo(Box& bounds, PathId path, const glm::dmat4& parent, bool visibleOnly) const;
 
     PrimStore store_;
+    /// The store version inherited attributes were last resolved at.
+    std::uint64_t resolved_ = 0;
+    Token inherited_ = 0;
     Token invisible_ = 0;
     Token defaultPurpose_ = 0;
     std::vector<BucketSchema> buckets_;
     ExtentCache extents_;
+    HolderIndex holders_;
 };
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/schema.cpp

@@ -175,6 +175,28 @@ const SchemaDef* FindSchema(std::string_view name) {
     return found != schemas.end() ? *found : nullptr;
 }
 
+std::span<const AttributeDef* const> InheritedAttributes() {
+    static const std::vector<const AttributeDef*> kInherited = [] {
+        std::vector<const AttributeDef*> inherited;
+        for (const SchemaDef* schema : Schemas()) {
+            for (const AttributeDef& def : schema->attributes) {
+                if (def.meta.inherited) {
+                    inherited.push_back(&def);
+                }
+            }
+        }
+        return inherited;
+    }();
+    return kInherited;
+}
+
+const AttributeDef* FindInherited(std::string_view name) {
+    const std::span<const AttributeDef* const> inherited = InheritedAttributes();
+    const auto found =
+        std::ranges::find_if(inherited, [&](const AttributeDef* def) { return def->name == name; });
+    return found != inherited.end() ? *found : nullptr;
+}
+
 ApiName ApiName::Parse(std::string_view api) {
     const std::size_t colon = api.find(':');
     const std::string_view name = api.substr(0, colon);

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/schema.h

@@ -5,12 +5,14 @@
 
 #include "ernie/geometry/bounds.h"
 #include "ernie/scene/storage.h"
+#include "ernie/scene/tokens.h"
 #include "ernie/scene/value.h"
 
 #include <array>
 #include <cstdint>
 #include <optional>
 #include <span>
+#include <string>
 #include <string_view>
 #include <vector>
 
@@ -87,7 +89,8 @@ struct AttributeMeta {
     /// The ranks a tensor may have, as a dense grid's 3; none for flat or vector arrays.
     std::vector<std::int64_t> ranks{};
     Dirty dirty = Dirty::Params;
-    /// Resolved from the nearest authoring ancestor.
+    /// Resolved from the nearest ancestor authoring it (other than as "inherited") into its
+    /// `ResolvedName` column.
     bool inherited = false;
 };
 
@@ -234,6 +237,15 @@ struct SchemaDef {
 std::span<const SchemaDef* const> Schemas();
 /// @return The schema named `name`, or null.
 const SchemaDef* FindSchema(std::string_view name);
+/// @return Every attribute declared inherited, once each.
+std::span<const AttributeDef* const> InheritedAttributes();
+/// @return The inherited attribute named `name`, or null.
+const AttributeDef* FindInherited(std::string_view name);
+/// @return The column holding an inherited attribute's resolved values:
+/// `ernie:resolved:visibility`.
+inline std::string ResolvedName(std::string_view attribute) {
+    return std::string(tokens::kResolvedPrefix) + std::string(attribute);
+}
 
 /// What a multiple-apply schema's attribute names hold in place of the instance's name.
 inline constexpr std::string_view kInstanceName = "__INSTANCE_NAME__";

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/schemas/geom.h

@@ -20,15 +20,15 @@
     X(std::string, Visibility, "visibility", "inherited",                                          \
       "\"invisible\" hides the prim and its descendants.",                                         \
       .group = "Prim", .options = {tokens::kInherited, tokens::kInvisible},                        \
-      .dirty = Dirty::Visibility)                                                                  \
+      .dirty = Dirty::Visibility, .inherited = true)                                               \
     X(std::string, Purpose, "purpose", "default",                                                  \
-      "Which renders include it: default, render, proxy or guide; inherited when default.",        \
+      "Which renders include it and its descendants: default, render, proxy or guide.",            \
       .group = "Prim",                                                                             \
       .options = {tokens::kDefault, tokens::kRender, tokens::kProxy, tokens::kGuide},              \
-      .dirty = Dirty::Visibility)                                                                  \
+      .dirty = Dirty::Visibility, .inherited = true)                                               \
     X(int, World, "ernie:world", -1,                                                               \
       "The batch world the prim and its descendants are in; -1 for every world.",                  \
-      .group = "Prim", .lower = AtLeast(-1.0), .inherited = true)
+      .group = "Prim", .lower = AtLeast(-1.0), .dirty = Dirty::Visibility, .inherited = true)
 
 #define ERNIE_XFORMABLE_ATTRIBUTES(X)                                                              \
     X(std::vector<std::string>, XformOpOrder, "xformOpOrder", std::vector<std::string>{},         \

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/schemas/shade.h

@@ -16,7 +16,7 @@
 #define ERNIE_MATERIAL_BINDING_API_ATTRIBUTES(X)                                                   \
     X(Path, MaterialBinding, "material:binding", Path(),                                           \
       "The Material the prim and its descendants are drawn with.", .label = "Material",            \
-      .group = "Material", .dirty = Dirty::Material)
+      .group = "Material", .dirty = Dirty::Material, .inherited = true)
 
 #define ERNIE_SHADER_ATTRIBUTES(X)                                                                 \
     X(std::string, Id, "info:id", "",                                                              \

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/storage.h

@@ -361,6 +361,25 @@ class PrimStore {
         }
         return &Values<T>(*column)[slot.row];
     }
+    /// @brief Writes a value derived from others into a column the bucket has, leaving it
+    /// unauthored and touching the row only when the value changes.
+    /// @return Whether it changed; false too when the bucket has no such column.
+    template <typename T> bool Derive(PrimId prim, AttributeId attribute, const T& value) {
+        const SlotData& slot = Slot(prim);
+        Bucket& bucket = *buckets_[slot.bucket];
+        const auto found = bucket.columnIndex.find(attribute);
+        if (found == bucket.columnIndex.end()) {
+            return false;
+        }
+        Column& column = bucket.columns[found->second];
+        T& cell = Values<T>(column)[slot.row];
+        if (cell == value) {
+            return false;
+        }
+        cell = value;
+        Touch(slot.bucket, column, slot.row, slot.row + 1, Next());
+        return true;
+    }
     /// @brief Unauthors an attribute, putting its fallback back.
     void Clear(PrimId prim, AttributeId attribute);
 

{ernie_renderer-0.2.0.dev40 → ernie_renderer-0.2.0.dev43}/ernie/scene/tokens.h

@@ -19,6 +19,8 @@ inline constexpr std::string_view kOrient = "xformOp:orient";
 inline constexpr std::string_view kScale = "xformOp:scale";
 inline constexpr std::string_view kResetXformStack = "!resetXformStack!";
 inline constexpr std::string_view kInvertPrefix = "!invert!";
+/// The namespace of inherited attributes' resolved values, which only the scene writes.
+inline constexpr std::string_view kResolvedPrefix = "ernie:resolved:";
 
 inline constexpr std::string_view kInherited = "inherited";
 inline constexpr std::string_view kInvisible = "invisible";