ernie-renderer 0.2.0.dev22__tar.gz → 0.2.0.dev32__tar.gz

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev32}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev22
+Version: 0.2.0.dev32
 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.dev22 → ernie_renderer-0.2.0.dev32}/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/extents.cpp scene/storage.cpp)
 target_link_libraries(ernie_benchmarks PRIVATE ernie_static ernie_build_options)

ernie_renderer-0.2.0.dev32/benchmarks/scene/extents.cpp

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file extents.cpp
+/// @brief Cached extents at 100,000 prims: the first update, and one edit's.
+#include "benchmarks/bench.h"
+#include "ernie/scene/schemas/geom.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+namespace {
+
+constexpr int kSpheres = 100'000;
+
+std::unique_ptr<Scene> MakeSpheres() {
+    auto scene = std::make_unique<Scene>();
+    for (int i = 0; i < kSpheres; ++i) {
+        scene->Define("/World/Ball_" + std::to_string(i), "Sphere");
+    }
+    return scene;
+}
+
+const bool kFirstUpdate = Register("scene.extents.first_update_100k", [] {
+    std::unique_ptr<Scene> scene;
+    return Timing{Fastest([&] { scene = MakeSpheres(); }, [&] { scene->UpdateExtents(); }), 10.0};
+});
+
+const bool kOneEdit = Register("scene.extents.update_after_one_edit_of_100k", [] {
+    std::unique_ptr<Scene> scene = MakeSpheres();
+    scene->UpdateExtents();
+    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(); });
+    return Timing{ms, 1.0};
+});
+
+}  // namespace
+}  // namespace ernie::bench

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev32}/ernie/io/nanovdb.cpp

@@ -173,9 +173,8 @@ NanoVdbGrid ParseGrid(std::span<const std::uint8_t> bytes) {
     return grid;
 }
 
-// The grids of a raw buffer: each GridData header gives its grid's
-// size.
-std::vector<NanoVdbGrid> RawGrids(std::span<const std::uint8_t> bytes) {
+// The grids of a raw buffer, or only their headers: each GridData header gives its grid's size.
+std::vector<NanoVdbGrid> RawGrids(std::span<const std::uint8_t> bytes, bool headsOnly = false) {
     std::vector<NanoVdbGrid> grids;
     std::size_t offset = 0;
     while (offset + PNANOVDB_GRID_SIZE <= bytes.size()) {
@@ -189,7 +188,11 @@ std::vector<NanoVdbGrid> RawGrids(std::span<const std::uint8_t> bytes) {
         if (size < PNANOVDB_GRID_SIZE || offset + size > bytes.size()) {
             throw std::runtime_error("NanoVDB grid size runs past its data");
         }
-        grids.push_back(ParseGrid(bytes.subspan(offset, size)));
+        const std::span<const std::uint8_t> grid =
+            bytes.subspan(offset, static_cast<std::size_t>(size));
+        grids.push_back(headsOnly ? NanoVdbGridHead(grid.first(std::min(
+                                        static_cast<std::size_t>(size), kNanoVdbHeadBytes)))
+                                  : ParseGrid(grid));
         offset += size;
     }
     if (grids.empty()) {
@@ -234,6 +237,10 @@ std::vector<NanoVdbGrid> ParseNanoVdbGrids(std::span<const std::uint8_t> bytes)
     return RawGrids(bytes);
 }
 
+std::vector<NanoVdbGrid> ParseNanoVdbHeads(std::span<const std::uint8_t> bytes) {
+    return RawGrids(bytes, true);
+}
+
 NanoVdbGrid NanoVdbGridHead(std::span<const std::uint8_t> head) {
     const auto magic = ReadLittleEndian<std::uint64_t>(head, 0);
     if (magic != kMagicNumber && magic != kMagicGrid) {
@@ -247,8 +254,9 @@ NanoVdbGrid NanoVdbGridHead(std::span<const std::uint8_t> head) {
     return grid;
 }
 
-std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path) {
-    // Grids are copied out of the mapping into buffers aligned for PNanoVDB.
+static std::vector<NanoVdbGrid> ReadGrids(const std::filesystem::path& path, bool headsOnly) {
+    // Grids are copied out of the mapping into buffers aligned for PNanoVDB; heads touch only the
+    // pages holding them.
     const MappedFile file(path);
     const std::span<const std::uint8_t> data(
         reinterpret_cast<const std::uint8_t*>(file.Bytes().data()), file.Bytes().size());
@@ -256,7 +264,7 @@ std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path) {
     try {
         const auto magic = ReadLittleEndian<std::uint64_t>(data, 0);
         if (magic == kMagicGrid) {
-            return RawGrids(data);
+            return RawGrids(data, headsOnly);
         }
         if (magic != kMagicNumber && magic != kMagicFile) {
             throw std::runtime_error("not a NanoVDB file");
@@ -267,7 +275,7 @@ std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path) {
         if (MajorVersion(ReadLittleEndian<std::uint32_t>(data, 8)) != kMajorVersion &&
             MajorVersion(ReadLittleEndian<std::uint32_t>(data, PNANOVDB_GRID_OFF_VERSION)) ==
                 kMajorVersion) {
-            return RawGrids(data);
+            return RawGrids(data, headsOnly);
         }
         std::vector<NanoVdbGrid> grids;
         std::size_t offset = 0;
@@ -296,7 +304,7 @@ std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path) {
                 if (offset + size > data.size()) {
                     throw std::runtime_error("grid runs past the file's end");
                 }
-                std::vector<NanoVdbGrid> one = RawGrids(data.subspan(offset, size));
+                std::vector<NanoVdbGrid> one = RawGrids(data.subspan(offset, size), headsOnly);
                 grids.insert(grids.end(), std::make_move_iterator(one.begin()),
                              std::make_move_iterator(one.end()));
                 offset += size;
@@ -315,6 +323,14 @@ std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path) {
     }
 }
 
+std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path) {
+    return ReadGrids(path, false);
+}
+
+std::vector<NanoVdbGrid> ReadNanoVdbHeads(const std::filesystem::path& path) {
+    return ReadGrids(path, true);
+}
+
 const NanoVdbGrid* FindNanoVdbGrid(std::span<const NanoVdbGrid> grids, std::string_view name,
                                    int index) {
     // An index into the caller's grids, which cppcheck follows where

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev32}/ernie/io/nanovdb.h

@@ -95,12 +95,20 @@ struct NanoVdbGrid {
 ///         `nanovdb_convert` without `-z`/`-b`).
 std::vector<NanoVdbGrid> ReadNanoVdb(const std::filesystem::path& path);
 
+/// @brief Reads the headers of a NanoVDB file's grids (names, types, bounds and transforms)
+/// without their voxels, as `NanoVdbGridHead` does for each grid.
+/// @throws std::runtime_error As `ReadNanoVdb`.
+std::vector<NanoVdbGrid> ReadNanoVdbHeads(const std::filesystem::path& path);
+
 /// @brief Splits a raw in-memory NanoVDB buffer into its grids.
 /// @param bytes Grids back to back, as Warp's `Volume.array()`.
 /// @return The grids.
 /// @throws std::runtime_error If it does not start with a version 32
 ///         NanoVDB grid.
 std::vector<NanoVdbGrid> ParseNanoVdbGrids(std::span<const std::uint8_t> bytes);
+/// @brief Reads the headers of a raw buffer's grids, without copying their voxels.
+/// @throws std::runtime_error As `ParseNanoVdbGrids`.
+std::vector<NanoVdbGrid> ParseNanoVdbHeads(std::span<const std::uint8_t> bytes);
 
 /// Bytes at a grid's start holding its header, tree and root, root
 /// statistics included.

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev32}/ernie/scene/CMakeLists.txt

@@ -2,15 +2,22 @@
 add_library(
     ernie_scene
     OBJECT
+    extent_cache.cpp
     path.cpp
     schema.cpp
     scene.cpp
     storage.cpp
     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/registry.cpp
     schemas/shade.cpp
+    schemas/vol.cpp
 )
 target_link_libraries(ernie_scene PUBLIC ernie_physics ernie_io PRIVATE ernie_build_options)

ernie_renderer-0.2.0.dev32/ernie/scene/extent_cache.cpp

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file extent_cache.cpp
+/// @brief Replaying row changes into the extent boxes and recomputing stale runs.
+#include "ernie/scene/extent_cache.h"
+
+#include <algorithm>
+
+namespace ernie {
+
+void ExtentCache::Track(BucketId bucket, ExtentFunction compute) {
+    buckets_.resize(std::max<std::size_t>(buckets_.size(), bucket + 1));
+    buckets_[bucket].compute = 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)) {
+            Replay(buckets_[rows.bucket], rows.change);
+        }
+    }
+    for (const ChangeSet::Values& values : changes.values) {
+        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_) {
+            Refresh(buckets_[bucket], store, bucket);
+        }
+    }
+    cursor_ = changes.version;
+}
+
+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()) {
+        return std::nullopt;
+    }
+    return buckets_[bucket].boxes[row];
+}
+
+void ExtentCache::Replay(Entry& entry, const StructuralChange& change) {
+    using Kind = StructuralChange::Kind;
+    if (change.kind == Kind::Added) {
+        Resize(entry, change.row + change.count);
+        entry.stale.SetRange(change.row, change.row + change.count);
+    } else if (change.kind == Kind::Moved) {
+        // Recomputed, not copied: the moved row's own value edits are reported at its old place.
+        entry.stale.Set(change.row);
+        Resize(entry, change.from);
+    } else if (change.row + 1 == entry.boxes.size()) {
+        // Removing the last row moves nothing; otherwise the Moved that follows shrinks it.
+        Resize(entry, change.row);
+    }
+}
+
+void ExtentCache::Resize(Entry& entry, std::uint32_t rows) {
+    entry.boxes.resize(rows);
+    entry.stale.Resize(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)},
+                      std::span(entry.boxes).subspan(begin, end - begin));
+    });
+    entry.stale.Clear();
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev32/ernie/scene/extent_cache.h

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file extent_cache.h
+/// @brief Prims' extents kept per bucket and refreshed for the rows that changed.
+#pragma once
+
+#include "ernie/geometry/bounds.h"
+#include "ernie/scene/schema.h"
+#include "ernie/scene/storage.h"
+#include "ernie/util/bytes.h"
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace ernie {
+
+/// @brief The extents of every bucket with an extent function, a box per row. `Update` replays
+/// the buckets' row changes and recomputes only the rows whose values or places changed.
+class ExtentCache {
+  public:
+    /// Tracks a bucket, computing its extents with `compute`; null for a bucket without them.
+    void Track(BucketId bucket, ExtentFunction compute);
+    /// Brings every tracked bucket up to the store's version.
+    void Update(const PrimStore& store);
+    /// @return A row's extent, or none when its bucket changed since `Update` or has none.
+    std::optional<Box> Find(const PrimStore& store, BucketId bucket, std::uint32_t row) const;
+
+  private:
+    struct Entry {
+        ExtentFunction compute = nullptr;
+        std::vector<Box> boxes;
+        BitSet stale;
+    };
+
+    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);
+
+    std::vector<Entry> buckets_;
+    std::uint64_t cursor_ = 0;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev32}/ernie/scene/scene.cpp

@@ -16,14 +16,15 @@
 namespace ernie {
 namespace {
 
-/// @return A column layout for the attribute `name` holding `def`'s fallback in unauthored rows.
-ColumnLayout MakeLayout(PathTable& paths, const AttributeDef& def, std::string_view name) {
+/// @return A column layout for the attribute `name` holding `fallback` in unauthored rows.
+ColumnLayout MakeLayout(PathTable& paths, const AttributeDef& def, std::string_view name,
+                        const Value& fallback) {
     const AttributeId attribute = paths.Names().Intern(name);
     return WithColumnType(def.type, [&]<typename T>(std::type_identity<T>) {
         if constexpr (std::is_same_v<T, Tensor>) {
             return ColumnLayout::Of<T>(attribute);
         } else {
-            return ColumnLayout::Of<T>(attribute, ToElement<T>(paths, def.fallback).value_or(T{}));
+            return ColumnLayout::Of<T>(attribute, ToElement<T>(paths, fallback).value_or(T{}));
         }
     });
 }
@@ -136,7 +137,7 @@ std::vector<Path> Scene::Prims(std::string_view type) const {
 
 void Scene::Set(PrimId prim, std::string_view attribute, const Value& value) {
     const AttributeId token = store_.Tokens().Intern(attribute);
-    const AttributeDef* def = Declared(prim, token);
+    const AttributeDef* def = Declared(store_.PrimBucket(prim), token);
     if (def != nullptr) {
         Validate(*def, attribute, value, PrimPath(prim));
     }
@@ -155,6 +156,27 @@ void Scene::Set(const Path& path, std::string_view attribute, const Value& value
     Set(Require(path), attribute, value);
 }
 
+void Scene::Write(PrimId prim, std::string_view attribute, Tensor array) {
+    const AttributeId token = store_.Tokens().Intern(attribute);
+    const AttributeDef* def = Declared(store_.PrimBucket(prim), token);
+    if (def == nullptr && !TakesUndeclared(prim, attribute)) {
+        throw std::invalid_argument(Describe(*this, prim) + " has no attribute '" +
+                                    std::string(attribute) + "'");
+    }
+    if (def != nullptr) {
+        ValidateArray(*def, attribute, array, PrimPath(prim));
+    }
+    store_.Set(prim, token, std::move(array));
+}
+
+const Tensor* Scene::Read(PrimId prim, std::string_view attribute) const {
+    const Column* column = AuthoredColumn(prim, attribute);
+    if (column == nullptr || column->values->Type() != ColumnType::Tensor) {
+        return nullptr;
+    }
+    return &store_.Read<Tensor>(store_.PrimBucket(prim), column->attribute)[store_.PrimRow(prim)];
+}
+
 std::optional<Value> Scene::Get(PrimId prim, std::string_view attribute) const {
     const Column* column = AuthoredColumn(prim, attribute);
     if (column == nullptr) {
@@ -216,9 +238,13 @@ std::optional<Box> Scene::Extent(PrimId prim) const {
     if (rule.kind != ExtentRule::Kind::Computed) {
         return std::nullopt;
     }
+    const BucketId bucket = store_.PrimBucket(prim);
     const std::uint32_t row = store_.PrimRow(prim);
+    if (const std::optional<Box> cached = extents_.Find(store_, bucket, row)) {
+        return cached;
+    }
     Box extent;
-    rule.compute({store_, store_.PrimBucket(prim)}, {row, row + 1}, std::span(&extent, 1));
+    rule.compute({store_, bucket, this}, {row, row + 1}, std::span(&extent, 1));
     return extent;
 }
 
@@ -229,23 +255,31 @@ Box Scene::WorldBounds(const Path& path) const {
     const glm::dmat4 above =
         parent == kRootPath ? glm::dmat4(1.0) : WorldTransform(*store_.Find(parent));
     Box bounds;
-    AddTo(bounds, id, above);
+    AddTo(bounds, id, above, true);
     return bounds;
 }
 
-void Scene::AddTo(Box& bounds, PathId path, const glm::dmat4& parent) const {
+Box Scene::BoundsInParent(PrimId prim) const {
+    Box bounds;
+    AddTo(bounds, store_.PrimPath(prim), glm::dmat4(1.0), false);
+    return bounds;
+}
+
+void Scene::AddTo(Box& bounds, PathId path, const glm::dmat4& parent, bool visibleOnly) const {
     const PrimId prim = *store_.Find(path);
-    if (LeavesOutOfBounds(prim)) {
+    if (visibleOnly && LeavesOutOfBounds(prim)) {
         return;
     }
     const glm::dmat4 local = LocalTransform(prim);
     const glm::dmat4 world = ResetsXformStack(*this, prim) ? local : parent * local;
+    // A prim with an extent bounds what it is made of, so its children aren't added again.
     if (const std::optional<Box> extent = Extent(prim)) {
         bounds.Extend(extent->Transformed(world));
+        return;
     }
     store_.Paths().ForEachChild(path, [&](PathId child) {
         if (store_.Find(child)) {
-            AddTo(bounds, child, world);
+            AddTo(bounds, child, world, visibleOnly);
         }
     });
 }
@@ -269,20 +303,24 @@ BucketId Scene::FindOrAddBucket(const SchemaDef* schema, std::vector<Token> apis
     std::vector<ColumnLayout> layout;
     const auto add = [&](const SchemaDef& declaring, const ApiName& api) {
         for (const AttributeDef* def : declaring.AllAttributes()) {
-            layout.push_back(MakeLayout(paths, *def, api.Attribute(def->name)));
+            const std::string name = api.Attribute(def->name);
+            const Value* override = schema != nullptr ? schema->FallbackOverride(name) : nullptr;
+            layout.push_back(MakeLayout(paths, *def, name, override ? *override : def->fallback));
             entry.declared.emplace(layout.back().attribute, def);
         }
     };
     if (schema != nullptr) {
         add(*schema, {});
     }
-    for (const Token token : key.apiSchemas) {
-        const ApiName api = ApiName::Parse(paths.Names().Text(token));
+    for (const ApiName& api : AllApis(schema, key.apiSchemas)) {
         add(*api.schema, api);
     }
     const BucketId bucket = store_.AddBucket(key, layout);
     buckets_.resize(std::max<std::size_t>(buckets_.size(), bucket + 1));
     buckets_[bucket] = std::move(entry);
+    const ExtentRule rule = schema != nullptr ? schema->Extent() : kNoExtent;
+    const bool cached = rule.kind == ExtentRule::Kind::Computed && !rule.readsOtherPrims;
+    extents_.Track(bucket, cached ? rule.compute : nullptr);
     return bucket;
 }
 
@@ -312,8 +350,20 @@ bool Scene::RemoveApi(PrimId prim, std::string_view api) {
 }
 
 bool Scene::HasApi(PrimId prim, std::string_view api) const {
-    const std::optional<Token> token = store_.Tokens().Find(api);
-    return token && std::ranges::find(Apis(prim), *token) != Apis(prim).end();
+    return std::ranges::any_of(AllApis(Schema(prim), Apis(prim)),
+                               [&](const ApiName& name) { return name.ToString() == api; });
+}
+
+std::vector<ApiName> Scene::AllApis(const SchemaDef* schema, std::span<const Token> applied) const {
+    std::vector<ApiName> apis;
+    for (const std::string_view builtin :
+         schema != nullptr ? schema->AllBuiltinApis() : std::vector<std::string_view>{}) {
+        apis.push_back(ApiName::Parse(builtin));
+    }
+    for (const Token token : applied) {
+        apis.push_back(ApiName::Parse(store_.Tokens().Text(token)));
+    }
+    return apis;
 }
 
 std::vector<std::string> Scene::AppliedApis(PrimId prim) const {
@@ -338,18 +388,27 @@ const Column* Scene::AuthoredColumn(PrimId prim, std::string_view attribute) con
     return column != nullptr && column->authored.Test(store_.PrimRow(prim)) ? column : nullptr;
 }
 
-const AttributeDef* Scene::Declared(PrimId prim, AttributeId attribute) const {
-    const auto& declared = buckets_[store_.PrimBucket(prim)].declared;
+const AttributeDef* Scene::Declared(BucketId bucket, AttributeId attribute) const {
+    const auto& declared = buckets_[bucket].declared;
     const auto found = declared.find(attribute);
     return found != declared.end() ? found->second : nullptr;
 }
 
+Dirty Scene::Classify(const ChangeSet::Values& change) const {
+    if (const AttributeDef* def = Declared(change.bucket, change.attribute)) {
+        return def->meta.dirty;
+    }
+    const std::string_view name = store_.Tokens().Text(change.attribute);
+    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 {
     const SchemaDef* schema = Schema(prim);
     return schema == nullptr || schema->IsOpen(attribute) ||
-           std::ranges::any_of(Apis(prim), [&](Token api) {
-               return ApiName::Parse(store_.Tokens().Text(api)).schema->IsOpen(attribute);
-           });
+           std::ranges::any_of(AllApis(schema, Apis(prim)),
+                               [&](const ApiName& api) { return api.schema->IsOpen(attribute); });
 }
 
 ColumnType Scene::TypeForUndeclared(PrimId prim, std::string_view attribute,

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev32}/ernie/scene/scene.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "ernie/geometry/bounds.h"
+#include "ernie/scene/extent_cache.h"
 #include "ernie/scene/schema.h"
 #include "ernie/scene/storage.h"
 #include "ernie/scene/value.h"
@@ -67,6 +68,12 @@ 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;
+    /// @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.
+    void Write(PrimId prim, std::string_view attribute, Tensor array);
+    /// @return The authored array, or null.
+    const Tensor* Read(PrimId prim, std::string_view attribute) const;
     /// @return Whether the attribute was authored.
     bool Clear(PrimId prim, std::string_view attribute);
     bool IsAuthored(PrimId prim, std::string_view attribute) const;
@@ -77,9 +84,18 @@ 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.
     std::optional<Box> Extent(PrimId prim) const;
+    /// @brief Recomputes the cached extents of the rows that changed since the last update.
+    void UpdateExtents() {
+        extents_.Update(store_);
+    }
     /// @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;
+    /// @return The box of a prim's subtree in its parent's space, whatever its visibility: what a
+    /// point instancer places at each instance.
+    Box BoundsInParent(PrimId prim) const;
 
     PrimStore& Store() {
         return store_;
@@ -90,6 +106,9 @@ class Scene {
     std::uint64_t Version() const {
         return store_.Version();
     }
+    /// @return What a column change means to renderers: the attribute's declared category, or for
+    /// undeclared ones Transform for xformOps, Primvars for primvars and Params for the rest.
+    Dirty Classify(const ChangeSet::Values& change) const;
 
   private:
     struct BucketSchema {
@@ -102,22 +121,26 @@ class Scene {
     /// Moves a prim to the bucket of its type and `apis`.
     void MoveTo(PrimId prim, const SchemaDef* schema, std::vector<Token> apis);
     const std::vector<Token>& Apis(PrimId prim) const;
+    /// @return A type's built-in API schemas, then the applied ones.
+    std::vector<ApiName> AllApis(const SchemaDef* schema, std::span<const Token> applied) const;
     /// @return The attribute's column when the prim authors it, or null.
     const Column* AuthoredColumn(PrimId prim, std::string_view attribute) const;
-    const AttributeDef* Declared(PrimId prim, AttributeId attribute) const;
+    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.
     bool TakesUndeclared(PrimId prim, std::string_view attribute) const;
     ColumnType TypeForUndeclared(PrimId prim, std::string_view attribute, const Value& value) const;
     /// @return Whether the prim and its subtree are invisible or of a purpose bounds leave out.
     bool LeavesOutOfBounds(PrimId prim) const;
-    /// Adds the visible default-purpose extents of a subtree under `parent`'s world transform.
-    void AddTo(Box& bounds, PathId path, const glm::dmat4& parent) const;
+    /// Adds a subtree's extents under `parent`'s transform; with `visibleOnly`, only its visible
+    /// default-purpose prims'.
+    void AddTo(Box& bounds, PathId path, const glm::dmat4& parent, bool visibleOnly) const;
 
     PrimStore store_;
     Token invisible_ = 0;
     Token defaultPurpose_ = 0;
     std::vector<BucketSchema> buckets_;
+    ExtentCache extents_;
 };
 
 }  // namespace ernie