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

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

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

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

@@ -169,12 +169,16 @@ void Scene::Write(PrimId prim, std::string_view attribute, Tensor array) {
     store_.Set(prim, token, std::move(array));
 }
 
-const Tensor* Scene::Read(PrimId prim, std::string_view attribute) const {
+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() != ColumnType::Tensor) {
+    if (column == nullptr || column->values->Type() != kColumnType<T>) {
         return nullptr;
     }
-    return &store_.Read<Tensor>(store_.PrimBucket(prim), column->attribute)[store_.PrimRow(prim)];
+    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 {
@@ -277,11 +281,17 @@ void Scene::AddTo(Box& bounds, PathId path, const glm::dmat4& parent, bool visib
         bounds.Extend(extent->Transformed(world));
         return;
     }
+    bool loaded = false;
     store_.Paths().ForEachChild(path, [&](PathId child) {
         if (store_.Find(child)) {
+            loaded = true;
             AddTo(bounds, child, world, visibleOnly);
         }
     });
+    // A model whose subtree isn't loaded is bounded by its hint.
+    if (!loaded) {
+        bounds.Extend(ExtentsHint(prim, !visibleOnly).Transformed(world));
+    }
 }
 
 PrimId Scene::Require(const Path& path) const {
@@ -400,15 +410,24 @@ std::vector<std::string> Scene::AppliedApis(PrimId prim) const {
 }
 
 bool Scene::LeavesOutOfBounds(PrimId prim) const {
-    const auto token = [&](std::string_view attribute) -> std::optional<Token> {
-        const Column* column = AuthoredColumn(prim, attribute);
-        return column ? std::optional(store_.Read<Token>(store_.PrimBucket(prim),
-                                                         column->attribute)[store_.PrimRow(prim)])
-                      : std::nullopt;
-    };
+    const Token* visibility = Authored<Token>(prim, Imageable::kVisibility);
     // Purpose is inherited, so a subtree under another purpose is left out whole.
-    const std::optional<Token> purpose = token(Imageable::kPurpose);
-    return token(Imageable::kVisibility) == invisible_ || (purpose && *purpose != defaultPurpose_);
+    const Token* purpose = Authored<Token>(prim, Imageable::kPurpose);
+    return (visibility && *visibility == invisible_) || (purpose && *purpose != defaultPurpose_);
+}
+
+Box Scene::ExtentsHint(PrimId prim, bool allPurposes) const {
+    const auto* hint = Authored<std::vector<float>>(prim, GeomModelAPI::kExtentsHint);
+    if (hint == nullptr) {
+        return {};
+    }
+    // Six floats per purpose, the default purpose first.
+    const std::size_t floats = allPurposes ? hint->size() : std::min<std::size_t>(6, hint->size());
+    Box box;
+    for (std::size_t i = 0; i + 6 <= floats; i += 6) {
+        box.Extend(AuthoredExtent(std::span(*hint).subspan(i, 6)));
+    }
+    return box;
 }
 
 const Column* Scene::AuthoredColumn(PrimId prim, std::string_view attribute) const {

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

@@ -126,6 +126,8 @@ class Scene {
     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;
+    /// @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;
     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.
@@ -133,6 +135,8 @@ class Scene {
     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;
+    /// @return GeomModelAPI's extentsHint: the default purpose's box, or with `allPurposes`, all.
+    Box ExtentsHint(PrimId prim, bool allPurposes) 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;

{ernie_renderer-0.2.0.dev37 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/geom.cpp

@@ -60,6 +60,8 @@ ERNIE_DEFINE_SCHEMA(Xform, Concrete, kDescendantsExtent, ERNIE_NO_ATTRIBUTES,
                     .openNamespaces = {"*"})
 ERNIE_DEFINE_SCHEMA(Scope, Concrete, kDescendantsExtent, ERNIE_NO_ATTRIBUTES,
                     .openNamespaces = {"*"})
+ERNIE_DEFINE_SCHEMA(GeomModelAPI, SingleApply, kInheritExtent, ERNIE_MODEL_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(GeomSubset, Concrete, kNoExtent, ERNIE_SUBSET_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(Cube, Concrete, ComputedExtent(CentredExtent<CubeHalves>),
                     ERNIE_CUBE_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(Sphere, Concrete, ComputedExtent(CentredExtent<SphereHalves>),

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

@@ -10,6 +10,7 @@
 #include "ernie/scene/view.h"
 
 #include <array>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -51,6 +52,47 @@
       "The winding of its front faces.", .group = "Geometry",                                      \
       .options = {"rightHanded", "leftHanded"}, .dirty = Dirty::Topology)
 
+#define ERNIE_CARD_TEXTURE(X, Name, usdName)                                                       \
+    X(std::string, Name, usdName, "", "The image on the card facing this way.", .group = "Model",  \
+      .asset = true, .dirty = Dirty::Params)
+
+#define ERNIE_MODEL_API_ATTRIBUTES(X)                                                              \
+    X(std::string, DrawMode, "model:drawMode", "inherited",                                        \
+      "Draws the subtree as itself, or as a stand-in: its origin axes, its bounds or cards.",      \
+      .group = "Model", .options = {"origin", "bounds", "cards", "default", "inherited"},          \
+      .dirty = Dirty::Visibility)                                                                  \
+    X(bool, ApplyDrawMode, "model:applyDrawMode", false,                                           \
+      "Whether this prim's draw mode replaces its subtree.", .group = "Model",                     \
+      .dirty = Dirty::Visibility)                                                                  \
+    X(glm::dvec3, DrawModeColor, "model:drawModeColor", glm::dvec3(0.18),                          \
+      "Linear RGB of the stand-in.", .group = "Model", .lower = AtLeast(0.0), .color = true,       \
+      .dirty = Dirty::Params)                                                                      \
+    X(std::string, CardGeometry, "model:cardGeometry", "cross",                                    \
+      "Cards through the centre, on the bounds' faces, or as the textures place them.",            \
+      .group = "Model", .options = {"cross", "box", "fromTexture"}, .dirty = Dirty::Params)        \
+    X(std::string, CardVisibility, "model:cardVisibility", "inherited",                            \
+      "Every textured card, or only one per axis.", .group = "Model",                              \
+      .options = {"full", "simple", "inherited"}, .dirty = Dirty::Params)                          \
+    ERNIE_CARD_TEXTURE(X, CardTextureXPos, "model:cardTextureXPos")                                \
+    ERNIE_CARD_TEXTURE(X, CardTextureYPos, "model:cardTextureYPos")                                \
+    ERNIE_CARD_TEXTURE(X, CardTextureZPos, "model:cardTextureZPos")                                \
+    ERNIE_CARD_TEXTURE(X, CardTextureXNeg, "model:cardTextureXNeg")                                \
+    ERNIE_CARD_TEXTURE(X, CardTextureYNeg, "model:cardTextureYNeg")                                \
+    ERNIE_CARD_TEXTURE(X, CardTextureZNeg, "model:cardTextureZNeg")                                \
+    X(std::vector<float>, ExtentsHint, "extentsHint", std::vector<float>{},                        \
+      "The subtree's local bounds per purpose (default, render, proxy, guide), six floats each, "  \
+      "read while it isn't loaded.", .group = "Model")
+
+#define ERNIE_SUBSET_ATTRIBUTES(X)                                                                 \
+    X(std::string, ElementType, "elementType", "face", "What its indices count.",                  \
+      .group = "Subset", .options = {"face", "point", "edge", "segment", "tetrahedron"},           \
+      .dirty = Dirty::Topology)                                                                    \
+    X(Tensor, Indices, "indices", Tensor(), "The elements in the subset.", .group = "Subset",      \
+      .integer = true, .dirty = Dirty::Topology)                                                   \
+    X(std::string, FamilyName, "familyName", "",                                                   \
+      "The family of subsets it is one of, as materialBind for per-face materials.",               \
+      .group = "Subset", .dirty = Dirty::Topology)
+
 #define ERNIE_SHAPE_LENGTH .group = "Shape", .lower = AtLeast(0.0), .finite = true
 
 #define ERNIE_AXIS_ATTRIBUTE(X)                                                                    \
@@ -86,7 +128,7 @@ namespace ernie {
 
 /// @return A Boundable's authored `extent` (min x, y, z, max x, y, z), which extent functions
 /// read while the data they bound isn't on the host; empty when unset.
-inline Box AuthoredExtent(const std::vector<float>& extent) {
+inline Box AuthoredExtent(std::span<const float> extent) {
     if (extent.size() != 6) {
         return {};
     }
@@ -110,6 +152,11 @@ ERNIE_SCHEMA(Gprim, Boundable, ERNIE_GPRIM_ATTRIBUTES,
 ERNIE_CONCRETE_SCHEMA(Xform, Xformable, ERNIE_NO_ATTRIBUTES, "A transform grouping its children.");
 ERNIE_CONCRETE_SCHEMA(Scope, Imageable, ERNIE_NO_ATTRIBUTES,
                       "A grouping without a transform of its own.");
+ERNIE_API_SCHEMA(GeomModelAPI, ERNIE_MODEL_API_ATTRIBUTES,
+                 "A model's stand-ins and the bounds hint used while its subtree isn't loaded.");
+ERNIE_CONCRETE_SCHEMA(GeomSubset, SchemaView, ERNIE_SUBSET_ATTRIBUTES,
+                      "Some faces, points, edges, segments or tetrahedra of its parent, to bind a "
+                      "material to or select.");
 ERNIE_CONCRETE_SCHEMA(Cube, Gprim, ERNIE_CUBE_ATTRIBUTES,
                       "A box centred on its origin, size along each axis.");
 ERNIE_CONCRETE_SCHEMA(Sphere, Gprim, ERNIE_SPHERE_ATTRIBUTES, "A sphere centred on its origin.");

{ernie_renderer-0.2.0.dev37 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/mesh.cpp

@@ -3,14 +3,16 @@
 /// @brief Point-based geometry's registry entries and extents, as UsdGeom computes them.
 #include "ernie/scene/schemas/mesh.h"
 
+#include <algorithm>
 #include <optional>
 #include <vector>
 
 namespace ernie {
 namespace {
 
-/// @return The box of a CPU tensor's points, each grown by half its width (one per point, one for
-/// all, or none); none for an empty tensor or one on a device.
+/// @return The box of a CPU tensor's points, each grown by half its width when there is one per
+/// point, else by half the widest (as UsdGeomCurves does); none for an empty tensor or one on a
+/// device.
 std::optional<Box> BoundPoints(const Tensor& points, const Tensor& widths) {
     if (points.Empty() || IsGpu(points.Location().kind) ||
         (!widths.Empty() && IsGpu(widths.Location().kind))) {
@@ -20,10 +22,9 @@ std::optional<Box> BoundPoints(const Tensor& points, const Tensor& widths) {
     const std::vector<float> diameters =
         widths.Empty() ? std::vector<float>{} : CopyFloats(widths, "widths");
     const auto count = static_cast<std::size_t>(xyz.Elements() / 3);
+    const double widest = diameters.empty() ? 0.0 : *std::ranges::max_element(diameters);
     const auto half = [&](std::size_t i) {
-        return diameters.size() == count ? 0.5 * diameters[i]
-               : diameters.size() == 1   ? 0.5 * diameters[0]
-                                         : 0.0;
+        return 0.5 * (diameters.size() == count ? diameters[i] : widest);
     };
     Box box;
     const auto extend = [&]<typename T>(const T* data) {
@@ -40,7 +41,8 @@ std::optional<Box> BoundPoints(const Tensor& points, const Tensor& widths) {
     return box;
 }
 
-/// Meshes from their points; point clouds grown by their widths.
+/// Meshes from their points; point clouds and curves grown by their widths. Curves are bounded by
+/// their control points, which hold every basis but catmullRom and Hermite closely, as in USD.
 template <bool kWidths>
 void PointBasedExtent(const ExtentRows& rows, RowRange range, std::span<Box> out) {
     const auto points = rows.Column<Tensor>(PointBased::kPoints);
@@ -58,5 +60,10 @@ ERNIE_DEFINE_SCHEMA(PointBased, Abstract, kInheritExtent, ERNIE_POINT_BASED_ATTR
 ERNIE_DEFINE_SCHEMA(Mesh, Concrete, ComputedExtent(PointBasedExtent<false>), ERNIE_MESH_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(Points, Concrete, ComputedExtent(PointBasedExtent<true>),
                     ERNIE_POINTS_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Curves, Abstract, ComputedExtent(PointBasedExtent<true>),
+                    ERNIE_CURVES_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(BasisCurves, Concrete, kInheritExtent, ERNIE_BASIS_CURVES_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(NurbsCurves, Concrete, kInheritExtent, ERNIE_NURBS_CURVES_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(HermiteCurves, Concrete, kInheritExtent, ERNIE_HERMITE_CURVES_ATTRIBUTES)
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev37 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/mesh.h

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: BSD-3-Clause
 /// @file mesh.h
-/// @brief UsdGeom's point-based geometry: meshes and point clouds.
+/// @brief UsdGeom's point-based geometry: meshes, point clouds and curves.
 ///
 /// References:
-/// - Pixar, UsdGeomMesh and UsdGeomPoints, https://openusd.org/release/api/usd_geom_page_front.html
+/// - Pixar, UsdGeomMesh, UsdGeomPoints and UsdGeomCurves,
+///   https://openusd.org/release/api/usd_geom_page_front.html
 #pragma once
 
 #include "ernie/scene/schemas/geom.h"
@@ -52,13 +53,46 @@
     ERNIE_MESH_INDICES(X, CreaseLengths, "creaseLengths", "The number of points of each crease.") \
     X(Tensor, CreaseSharpnesses, "creaseSharpnesses", Tensor(),                                    \
       "The sharpness of each crease, or of each crease edge.", .group = "Subdivision",             \
-      .dirty = Dirty::Topology)
+      .dirty = Dirty::Topology)                                                                    \
+    X(int, SubdivisionRefineLevel, "ernie:subdivision:refineLevel", 1,                             \
+      "Uniform refinement of the surface: 2^level segments along each control edge.",              \
+      .label = "Refine level", .group = "Subdivision", .lower = AtLeast(0.0),                      \
+      .upper = AtMost(8.0), .dirty = Dirty::Topology)
+
+#define ERNIE_WIDTHS_ATTRIBUTE(X, text)                                                            \
+    X(Tensor, Widths, "widths", Tensor(), text, .group = "Geometry", .dirty = Dirty::Points)
 
 #define ERNIE_POINTS_ATTRIBUTES(X)                                                                 \
-    X(Tensor, Widths, "widths", Tensor(), "Diameters in metres: one per point, or one for all.",   \
-      .group = "Geometry", .dirty = Dirty::Points)                                                 \
+    ERNIE_WIDTHS_ATTRIBUTE(X, "Diameters in metres: one per point, or one for all.")               \
     X(Tensor, Ids, "ids", Tensor(), "int64 ids that follow points across time samples.",           \
       .group = "Geometry", .integer = true, .dirty = Dirty::Topology)
+
+#define ERNIE_CURVES_ATTRIBUTES(X)                                                                 \
+    ERNIE_MESH_INDICES(X, CurveVertexCounts, "curveVertexCounts",                                  \
+                       "The number of points of each curve.")                                      \
+    ERNIE_WIDTHS_ATTRIBUTE(X, "Diameters in metres: per point, per segment end, or one for all.")
+
+#define ERNIE_BASIS_CURVES_ATTRIBUTES(X)                                                           \
+    X(std::string, Type, "type", "cubic", "Linear segments, or cubic ones by the basis.",          \
+      .group = "Topology", .options = {"linear", "cubic"}, .dirty = Dirty::Topology)               \
+    X(std::string, Basis, "basis", "bezier", "The cubic basis.", .group = "Topology",              \
+      .options = {"bezier", "bspline", "catmullRom"}, .dirty = Dirty::Topology)                    \
+    X(std::string, Wrap, "wrap", "nonperiodic",                                                    \
+      "Open curves, closed ones, or open ones through their end points.", .group = "Topology",     \
+      .options = {"nonperiodic", "periodic", "pinned"}, .dirty = Dirty::Topology)
+
+#define ERNIE_NURBS_CURVES_ATTRIBUTES(X)                                                           \
+    ERNIE_MESH_INDICES(X, Order, "order", "The order (degree + 1) of each curve.")                 \
+    X(Tensor, Knots, "knots", Tensor(), "Each curve's knots, curveVertexCount + order of them.",   \
+      .group = "Topology", .dirty = Dirty::Topology)                                               \
+    X(Tensor, Ranges, "ranges", Tensor(), "(n, 2) parametric range drawn of each curve.",          \
+      .group = "Topology", .components = 2, .dirty = Dirty::Topology)                              \
+    X(Tensor, PointWeights, "pointWeights", Tensor(), "Rational weights, one per point.",          \
+      .group = "Geometry", .dirty = Dirty::Points)
+
+#define ERNIE_HERMITE_CURVES_ATTRIBUTES(X)                                                         \
+    X(Tensor, Tangents, "tangents", Tensor(), "(n, 3) tangent of each point.",                     \
+      .group = "Geometry", .components = 3, .dirty = Dirty::Points)
 // clang-format on
 
 namespace ernie {
@@ -68,5 +102,13 @@ ERNIE_CONCRETE_SCHEMA(Mesh, PointBased, ERNIE_MESH_ATTRIBUTES,
                       "A polygon mesh, or the control mesh of a subdivision surface.");
 ERNIE_CONCRETE_SCHEMA(Points, PointBased, ERNIE_POINTS_ATTRIBUTES,
                       "A point cloud of spheres, each its own width.");
+ERNIE_SCHEMA(Curves, PointBased, ERNIE_CURVES_ATTRIBUTES,
+             "Batched curves, each a run of points, swept by its widths.");
+ERNIE_CONCRETE_SCHEMA(BasisCurves, Curves, ERNIE_BASIS_CURVES_ATTRIBUTES,
+                      "Linear or cubic curves: hair, fur, cables and wires.");
+ERNIE_CONCRETE_SCHEMA(NurbsCurves, Curves, ERNIE_NURBS_CURVES_ATTRIBUTES,
+                      "Rational B-spline curves of any order.");
+ERNIE_CONCRETE_SCHEMA(HermiteCurves, Curves, ERNIE_HERMITE_CURVES_ATTRIBUTES,
+                      "Cubic curves through their points with a tangent at each.");
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev37 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/registry.cpp

@@ -23,6 +23,8 @@ std::span<const SchemaDef* const> Schemas() {
         &Gprim::Definition(),
         &Xform::Definition(),
         &Scope::Definition(),
+        &GeomModelAPI::Definition(),
+        &GeomSubset::Definition(),
         &Cube::Definition(),
         &Sphere::Definition(),
         &Cylinder::Definition(),
@@ -32,6 +34,10 @@ std::span<const SchemaDef* const> Schemas() {
         &PointBased::Definition(),
         &Mesh::Definition(),
         &Points::Definition(),
+        &Curves::Definition(),
+        &BasisCurves::Definition(),
+        &NurbsCurves::Definition(),
+        &HermiteCurves::Definition(),
         &PointInstancer::Definition(),
         &Volume::Definition(),
         &FieldBase::Definition(),

{ernie_renderer-0.2.0.dev37 → ernie_renderer-0.2.0.dev40}/tests/scene/mesh_test.cpp

@@ -41,6 +41,8 @@ TEST(Mesh, ArraysAreSharedAndCheckedForTypeAndShape) {
     scene.Write(mesh.Id(), "primvars:st", Floats({0, 0, 1, 0, 0, 1}, {3, 2}));
     EXPECT_NE(scene.Read(mesh.Id(), "primvars:st"), nullptr) << "primvars take any name";
     EXPECT_EQ(mesh.GetSubdivisionScheme(), "catmullClark") << "USD's fallback";
+    EXPECT_EQ(mesh.GetSubdivisionRefineLevel(), 1);
+    EXPECT_THROW(mesh.SetSubdivisionRefineLevel(9), std::invalid_argument);
 }
 
 TEST(Mesh, ExtentsBoundPointsAndPointCloudsTheirWidths) {
@@ -62,6 +64,25 @@ TEST(Mesh, ExtentsBoundPointsAndPointCloudsTheirWidths) {
     EXPECT_EQ(scene.Extent(cloud.Id())->max, glm::dvec3(10.5, 0.5, 0.5)) << "one width for all";
 }
 
+TEST(Curves, ExtentsBoundControlPointsGrownByTheWidestWidth) {
+    Scene scene;
+    BasisCurves hair = BasisCurves::Define(scene, "/Hair");
+    EXPECT_EQ(hair.GetType(), "cubic") << "USD's fallback";
+    hair.SetCurveVertexCounts(Tensor::Copy<std::int32_t>(std::vector<std::int32_t>{4}, {1}));
+    hair.SetPoints(Floats({0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 1}, {4, 3}));
+    hair.SetWidths(Floats({0.2f, 0.4f}, {2}));
+    const Box box = *scene.Extent(hair.Id());
+    EXPECT_NEAR(box.min.x, -0.2, 1e-6) << "varying widths grow by the widest";
+    EXPECT_NEAR(box.max.z, 1.2, 1e-6);
+
+    NurbsCurves nurbs = NurbsCurves::Define(scene, "/Nurbs");
+    nurbs.SetPoints(Floats({0, 0, 0, 1, 1, 1}, {2, 3}));
+    EXPECT_EQ(scene.Extent(nurbs.Id())->max, glm::dvec3(1.0)) << "no widths";
+    EXPECT_THROW(HermiteCurves::Define(scene, "/Hermite").SetTangents(Floats({1, 0}, {1, 2})),
+                 std::invalid_argument)
+        << "tangents are threes";
+}
+
 TEST(Mesh, PointsTheHostCannotReadFallBackToTheAuthoredExtent) {
     Scene scene;
     Mesh mesh = Mesh::Define(scene, "/Tri");

{ernie_renderer-0.2.0.dev37 → ernie_renderer-0.2.0.dev40}/tests/scene/schema_test.cpp

@@ -101,6 +101,34 @@ TEST(Extent, WorldBoundsGatherVisibleDescendantsThroughTheirTransforms) {
     EXPECT_TRUE(scene.WorldBounds("/World/Hidden").Empty());
 }
 
+TEST(Extent, ModelsWithoutLoadedDescendantsAreBoundedByTheirHint) {
+    Scene scene;
+    Xform::Define(scene, "/World");
+    SetXform(scene, "/World", {.translate = glm::dvec3(10.0, 0.0, 0.0)});
+    Xform::Define(scene, "/World/Rover");
+    GeomModelAPI::Apply(scene, "/World/Rover")
+        .SetExtentsHint({-1, -1, 0, 1, 1, 2, -5, -5, -5, 5, 5, 5});
+    ExpectBox(scene.WorldBounds("/World"), {9.0, -1.0, 0.0}, {11.0, 1.0, 2.0});
+    SCOPED_TRACE("bounds in the parent take every purpose's box");
+    ExpectBox(scene.BoundsInParent(*scene.Find("/World/Rover")), glm::dvec3(-5.0), glm::dvec3(5.0));
+    Sphere::Define(scene, "/World/Rover/Body").SetRadius(0.5);
+    SCOPED_TRACE("loaded descendants replace the hint");
+    ExpectBox(scene.WorldBounds("/World"), {9.5, -0.5, -0.5}, {10.5, 0.5, 0.5});
+    Sphere(scene, "/World/Rover/Body").SetVisibility("invisible");
+    EXPECT_TRUE(scene.WorldBounds("/World").Empty()) << "hidden, not unloaded";
+}
+
+TEST(Extent, SubsetsAreNotBounded) {
+    Scene scene;
+    Cube::Define(scene, "/Box");
+    GeomSubset subset = GeomSubset::Define(scene, "/Box/Top");
+    subset.SetIndices(Tensor::Copy<std::int32_t>(std::vector<std::int32_t>{4}, {1}))
+        .SetFamilyName("materialBind");
+    EXPECT_EQ(subset.GetElementType(), "face");
+    EXPECT_FALSE(scene.Extent(subset.Id()));
+    ExpectBox(scene.WorldBounds("/Box"), glm::dvec3(-1.0), glm::dvec3(1.0));
+}
+
 TEST(Extent, ResettingTheStackDropsAncestorsFromWorldBounds) {
     Scene scene;
     Xform::Define(scene, "/World");