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

{ernie_renderer-0.2.0.dev22 → 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 ".dev22" 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.dev22 → ernie_renderer-0.2.0.dev30}/PKG-INFO

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

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

@@ -136,7 +136,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 +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);
         }
     });
 }
@@ -283,6 +316,9 @@ BucketId Scene::FindOrAddBucket(const SchemaDef* schema, std::vector<Token> apis
     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;
 }
 
@@ -338,12 +374,22 @@ 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) ||

{ernie_renderer-0.2.0.dev22 → ernie_renderer-0.2.0.dev30}/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 {
@@ -104,20 +123,22 @@ class Scene {
     const std::vector<Token>& Apis(PrimId prim) 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

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

@@ -68,6 +68,44 @@ std::string Problem(const AttributeDef& def, const Value& value) {
     return {};
 }
 
+/// @return Why `array` doesn't fit the tensor attribute, or empty when it does.
+std::string ArrayProblem(const AttributeDef& def, const Tensor& array) {
+    if (def.type != ColumnType::Tensor) {
+        return "takes one value, not an array; set it";
+    }
+    if (def.meta.bytes) {
+        return {};
+    }
+    const DType type = array.Type();
+    const bool integer = type == DType::Int32 || type == DType::Int64 || type == DType::UInt32;
+    const bool floating = type == DType::Float32 || type == DType::Float64;
+    if (def.meta.integer ? !integer : !floating) {
+        return def.meta.integer ? "must hold integers" : "must hold float32 or float64 numbers";
+    }
+    if (def.meta.rank != 0) {
+        return array.Rank() == def.meta.rank
+                   ? std::string()
+                   : "must have " + std::to_string(def.meta.rank) + " dimensions";
+    }
+    const std::int64_t components = def.meta.components;
+    const bool rows =
+        array.Rank() == 2 && array.Shape()[1] == std::max<std::int64_t>(components, 1);
+    const bool flat =
+        array.Rank() == 1 && array.Elements() % std::max<std::int64_t>(components, 1) == 0;
+    if (!rows && !flat) {
+        return components > 1 ? "must be (n, " + std::to_string(components) + ") or flat"
+                              : "must be flat";
+    }
+    return {};
+}
+
+void ThrowIf(const std::string& problem, std::string_view attribute, const Path& path) {
+    if (!problem.empty()) {
+        throw std::invalid_argument("'" + path.String() + "': '" + std::string(attribute) + "' " +
+                                    problem);
+    }
+}
+
 }  // namespace
 
 bool SchemaDef::IsA(const SchemaDef& other) const {
@@ -145,10 +183,12 @@ std::string ApiName::ToString() const {
 
 void Validate(const AttributeDef& def, std::string_view attribute, const Value& value,
               const Path& path) {
-    if (const std::string problem = Problem(def, value); !problem.empty()) {
-        throw std::invalid_argument("'" + path.String() + "': '" + std::string(attribute) + "' " +
-                                    problem);
-    }
+    ThrowIf(Problem(def, value), attribute, path);
+}
+
+void ValidateArray(const AttributeDef& def, std::string_view attribute, const Tensor& array,
+                   const Path& path) {
+    ThrowIf(ArrayProblem(def, array), attribute, path);
 }
 
 }  // namespace ernie

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

@@ -30,6 +30,20 @@ enum class Dirty : std::uint32_t {
     Visibility = 1u << 8,
 };
 
+constexpr Dirty operator|(Dirty a, Dirty b) {
+    return static_cast<Dirty>(static_cast<std::uint32_t>(a) | static_cast<std::uint32_t>(b));
+}
+constexpr Dirty operator&(Dirty a, Dirty b) {
+    return static_cast<Dirty>(static_cast<std::uint32_t>(a) & static_cast<std::uint32_t>(b));
+}
+constexpr Dirty& operator|=(Dirty& a, Dirty b) {
+    return a = a | b;
+}
+/// @return Whether `bits` has any of `flags`.
+constexpr bool Any(Dirty bits, Dirty flags) {
+    return (bits & flags) != Dirty::None;
+}
+
 /// @brief A limit of an attribute's numbers, inclusive or not.
 struct Bound {
     double value = 0.0;
@@ -64,6 +78,14 @@ struct AttributeMeta {
     std::vector<std::string_view> options{};
     bool color = false;
     bool asset = false;
+    /// A tensor of integers rather than floats.
+    bool integer = false;
+    /// A tensor of raw bytes, in elements of any type.
+    bool bytes = false;
+    /// A tensor's vector size: (n, components) or flat; 0 for a flat array.
+    std::uint8_t components = 0;
+    /// A tensor's fixed rank, as a dense grid's 3; 0 for flat or vector arrays.
+    std::uint8_t rank = 0;
     Dirty dirty = Dirty::Params;
     /// Resolved from the nearest authoring ancestor.
     bool inherited = false;
@@ -88,10 +110,14 @@ enum class SchemaKind : std::uint8_t {
     MultipleApply,
 };
 
-/// @brief A bucket's prims as an extent function reads them: columns by attribute name.
+class Scene;
+
+/// @brief A bucket's prims as an extent function reads them: columns by attribute name, and the
+/// scene for rules that read other prims.
 struct ExtentRows {
     const PrimStore& store;
     BucketId bucket = 0;
+    const Scene* scene = nullptr;
 
     /// @return The column of a declared attribute.
     template <typename T> std::span<const T> Column(std::string_view attribute) const {
@@ -123,7 +149,13 @@ struct ExtentRule {
     };
     Kind kind = Kind::Inherit;
     ExtentFunction compute = nullptr;
+    /// Reads other prims (a volume its fields), so it is computed afresh rather than cached.
+    bool readsOtherPrims = false;
 };
+/// An extent from other prims' (a volume's from its fields).
+constexpr ExtentRule ComputedFromOtherPrims(ExtentFunction compute) {
+    return {ExtentRule::Kind::Computed, compute, true};
+}
 constexpr ExtentRule ComputedExtent(ExtentFunction compute) {
     return {ExtentRule::Kind::Computed, compute};
 }
@@ -190,6 +222,10 @@ struct ApiName {
 /// @throws std::invalid_argument naming the prim, the attribute and the reason.
 void Validate(const AttributeDef& def, std::string_view attribute, const Value& value,
               const Path& path);
+/// @brief Checks an array for a declared tensor attribute: its element type and vector size.
+/// @throws std::invalid_argument naming the prim, the attribute and the reason.
+void ValidateArray(const AttributeDef& def, std::string_view attribute, const Tensor& array,
+                   const Path& path);
 
 /// @brief The tokens of an enum a token attribute takes, in enumerator order.
 template <typename E> struct ChoiceTokens;