ernie-renderer 0.2.0.dev21__tar.gz → 0.2.0.dev30__tar.gz

{ernie_renderer-0.2.0.dev21 → ernie_renderer-0.2.0.dev30}/CMakeLists.txt

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

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

@@ -2,13 +2,21 @@
 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/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.dev30/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.dev30/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.dev21 → ernie_renderer-0.2.0.dev30}/ernie/scene/scene.cpp

@@ -7,6 +7,7 @@
 #include "ernie/scene/schemas/geom.h"
 #include "ernie/scene/tokens.h"
 #include "ernie/scene/xform.h"
+#include "ernie/util/algorithm.h"
 
 #include <algorithm>
 #include <stdexcept>
@@ -15,9 +16,9 @@
 namespace ernie {
 namespace {
 
-/// @return A column layout holding `fallback` in unauthored rows.
-ColumnLayout MakeLayout(PathTable& paths, const AttributeDef& def) {
-    const AttributeId attribute = paths.Names().Intern(def.name);
+/// @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) {
+    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);
@@ -38,7 +39,7 @@ std::string Describe(const Scene& scene, PrimId prim) {
 Scene::Scene()
     : invisible_(store_.Tokens().Intern(tokens::kInvisible)),
       defaultPurpose_(store_.Tokens().Intern(tokens::kDefault)) {
-    BucketFor(nullptr);
+    FindOrAddBucket(nullptr, {});
 }
 
 PrimId Scene::Define(const Path& path, std::string_view type) {
@@ -57,12 +58,11 @@ PrimId Scene::Define(const Path& path, std::string_view type) {
             store_.Define(above, 0);
         }
     }
-    const BucketId bucket = BucketFor(schema);
     if (const std::optional<PrimId> existing = store_.Find(id)) {
-        store_.Move(*existing, bucket);
+        MoveTo(*existing, schema, Apis(*existing));
         return *existing;
     }
-    return store_.Define(id, bucket);
+    return store_.Define(id, FindOrAddBucket(schema, {}));
 }
 
 bool Scene::Remove(const Path& path) {
@@ -136,9 +136,9 @@ 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, value, PrimPath(prim));
+        Validate(*def, attribute, value, PrimPath(prim));
     }
     const ColumnType type = def != nullptr ? def->type : TypeForUndeclared(prim, attribute, value);
     WithColumnType(type, [&]<typename T>(std::type_identity<T>) {
@@ -155,6 +155,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 +237,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 +254,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;
+}
+
+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) const {
+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);
         }
     });
 }
@@ -258,26 +291,71 @@ PrimId Scene::Require(const Path& path) const {
     return *prim;
 }
 
-BucketId Scene::BucketFor(const SchemaDef* schema) {
-    if (const auto found = bucketBySchema_.find(schema); found != bucketBySchema_.end()) {
-        return found->second;
-    }
+BucketId Scene::FindOrAddBucket(const SchemaDef* schema, std::vector<Token> apis) {
     PathTable& paths = store_.Paths();
+    const BucketKey key{paths.Names().Intern(schema != nullptr ? schema->name : ""),
+                        std::move(apis)};
+    if (const std::optional<BucketId> found = store_.FindBucket(key)) {
+        return *found;
+    }
     BucketSchema entry{schema, {}};
     std::vector<ColumnLayout> layout;
-    for (const AttributeDef* def :
-         schema != nullptr ? schema->AllAttributes() : std::vector<const AttributeDef*>{}) {
-        layout.push_back(MakeLayout(paths, *def));
-        entry.declared.emplace(layout.back().attribute, def);
+    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)));
+            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));
+        add(*api.schema, api);
     }
-    const Token type = paths.Names().Intern(schema != nullptr ? schema->name : "");
-    const BucketId bucket = store_.AddBucket({type, {}}, layout);
+    const BucketId bucket = store_.AddBucket(key, layout);
     buckets_.resize(std::max<std::size_t>(buckets_.size(), bucket + 1));
     buckets_[bucket] = std::move(entry);
-    bucketBySchema_.emplace(schema, bucket);
+    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;
 }
 
+void Scene::MoveTo(PrimId prim, const SchemaDef* schema, std::vector<Token> apis) {
+    store_.Move(prim, FindOrAddBucket(schema, std::move(apis)));
+}
+
+const std::vector<Token>& Scene::Apis(PrimId prim) const {
+    return store_.GetBucket(store_.PrimBucket(prim)).key.apiSchemas;
+}
+
+void Scene::ApplyApi(PrimId prim, std::string_view api) {
+    ApiName::Parse(api);
+    std::vector<Token> apis = Apis(prim);
+    apis.push_back(store_.Tokens().Intern(api));
+    MoveTo(prim, Schema(prim), std::move(apis));
+}
+
+bool Scene::RemoveApi(PrimId prim, std::string_view api) {
+    if (!HasApi(prim, api)) {
+        return false;
+    }
+    std::vector<Token> apis = Apis(prim);
+    std::erase(apis, *store_.Tokens().Find(api));
+    MoveTo(prim, Schema(prim), std::move(apis));
+    return true;
+}
+
+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();
+}
+
+std::vector<std::string> Scene::AppliedApis(PrimId prim) const {
+    return Map(Apis(prim), [&](Token token) { return std::string(store_.Tokens().Text(token)); });
+}
+
 bool Scene::LeavesOutOfBounds(PrimId prim) const {
     const auto token = [&](std::string_view attribute) -> std::optional<Token> {
         const Column* column = AuthoredColumn(prim, attribute);
@@ -296,16 +374,33 @@ 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);
+           });
+}
+
 ColumnType Scene::TypeForUndeclared(PrimId prim, std::string_view attribute,
                                     const Value& value) const {
-    const SchemaDef* schema = Schema(prim);
-    if (schema != nullptr && !schema->IsOpen(attribute)) {
+    if (!TakesUndeclared(prim, attribute)) {
         throw std::invalid_argument(Describe(*this, prim) + " has no attribute '" +
                                     std::string(attribute) + "'");
     }