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

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

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

@@ -39,3 +39,13 @@ function(ernie_fetch name)
     set(${lower}_SOURCE_DIR "${${lower}_SOURCE_DIR}" PARENT_SCOPE)
     set(${lower}_BINARY_DIR "${${lower}_BINARY_DIR}" PARENT_SCOPE)
 endfunction()
+
+# Builds third-party targets without warnings: their code is not Ernie's to fix.
+function(ernie_quiet_third_party)
+    foreach(target ${ARGN})
+        get_target_property(type ${target} TYPE)
+        if(NOT type STREQUAL "INTERFACE_LIBRARY")
+            target_compile_options(${target} PRIVATE "$<IF:$<CXX_COMPILER_ID:MSVC>,/w,-w>")
+        endif()
+    endforeach()
+endfunction()

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev40}/cmake/third_party/openexr.cmake

@@ -50,6 +50,7 @@ foreach(
     OpenEXRConfig
 )
     if(TARGET ${target})
+        ernie_quiet_third_party(${target})
         get_target_property(directories ${target} INTERFACE_INCLUDE_DIRECTORIES)
         if(directories)
             set_property(

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

@@ -18,6 +18,7 @@ add_library(
     schemas/mesh.cpp
     schemas/planet.cpp
     schemas/registry.cpp
+    schemas/render.cpp
     schemas/shade.cpp
     schemas/vol.cpp
 )

{ernie_renderer-0.2.0.dev35 → 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 {
@@ -300,19 +310,27 @@ BucketId Scene::FindOrAddBucket(const SchemaDef* schema, std::vector<Token> apis
         return *found;
     }
     BucketSchema entry{schema, {}};
+    const std::vector<ApiName> allApis = AllApis(schema, key.apiSchemas);
+    // The type's fallback overrides win over its API schemas', as USD's do.
+    const auto fallback = [&](const AttributeDef& def, const std::string& name) -> const Value& {
+        const Value* override = schema != nullptr ? schema->FallbackOverride(name) : nullptr;
+        for (auto api = allApis.begin(); override == nullptr && api != allApis.end(); ++api) {
+            override = api->schema->FallbackOverride(name);
+        }
+        return override != nullptr ? *override : def.fallback;
+    };
     std::vector<ColumnLayout> layout;
     const auto add = [&](const SchemaDef& declaring, const ApiName& api) {
         for (const AttributeDef* def : declaring.AllAttributes()) {
             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));
+            layout.push_back(MakeLayout(paths, *def, name, fallback(*def, name)));
             entry.declared.emplace(layout.back().attribute, def);
         }
     };
     if (schema != nullptr) {
         add(*schema, {});
     }
-    for (const ApiName& api : AllApis(schema, key.apiSchemas)) {
+    for (const ApiName& api : allApis) {
         add(*api.schema, api);
     }
     const BucketId bucket = store_.AddBucket(key, layout);
@@ -333,7 +351,16 @@ const std::vector<Token>& Scene::Apis(PrimId prim) const {
 }
 
 void Scene::ApplyApi(PrimId prim, std::string_view api) {
-    ApiName::Parse(api);
+    const ApiName parsed = ApiName::Parse(api);
+    const std::vector<std::string_view>& allowed = parsed.schema->appliesTo;
+    const SchemaDef* type = Schema(prim);
+    if (!allowed.empty() && std::ranges::none_of(allowed, [&](std::string_view name) {
+            return type != nullptr && type->IsA(*FindSchema(name));
+        })) {
+        throw std::invalid_argument(std::string(api) + " applies only to " +
+                                    std::string(allowed.front()) + " prims, not " +
+                                    Describe(*this, prim));
+    }
     std::vector<Token> apis = Apis(prim);
     apis.push_back(store_.Tokens().Intern(api));
     MoveTo(prim, Schema(prim), std::move(apis));
@@ -356,12 +383,24 @@ bool Scene::HasApi(PrimId prim, std::string_view api) const {
 
 std::vector<ApiName> Scene::AllApis(const SchemaDef* schema, std::span<const Token> applied) const {
     std::vector<ApiName> apis;
+    // Each API schema once, followed by those built into it (MeshLightAPI's LightAPI, LightAPI's
+    // light-link collections).
+    const auto add = [&](const auto& self, std::string_view name) -> void {
+        const ApiName api = ApiName::Parse(name);
+        if (std::ranges::find(apis, api) != apis.end()) {
+            return;
+        }
+        apis.push_back(api);
+        for (const std::string_view builtin : api.schema->AllBuiltinApis()) {
+            self(self, builtin);
+        }
+    };
     for (const std::string_view builtin :
          schema != nullptr ? schema->AllBuiltinApis() : std::vector<std::string_view>{}) {
-        apis.push_back(ApiName::Parse(builtin));
+        add(add, builtin);
     }
     for (const Token token : applied) {
-        apis.push_back(ApiName::Parse(store_.Tokens().Text(token)));
+        add(add, store_.Tokens().Text(token));
     }
     return apis;
 }
@@ -371,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 {
@@ -429,4 +477,18 @@ ColumnType Scene::TypeForUndeclared(PrimId prim, std::string_view attribute,
     return *type;
 }
 
+std::optional<PrimId> ExtentRows::Resolve(const Target& target) const {
+    return target.path != kNoPath ? store.Find(target.path) : std::nullopt;
+}
+
+std::optional<Box> ExtentRows::ExtentInRowSpace(PrimId other, std::uint32_t row) const {
+    const std::optional<Box> extent = scene->Extent(other);
+    if (!extent) {
+        return std::nullopt;
+    }
+    const PrimId own = store.GetBucket(bucket).prims[row];
+    return extent->Transformed(glm::inverse(scene->WorldTransform(own)) *
+                               scene->WorldTransform(other));
+}
+
 }  // namespace ernie

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

@@ -121,10 +121,13 @@ 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.
+    /// @return A type's built-in API schemas, then the applied ones, each with those built into it,
+    /// each once.
     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.
@@ -132,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.dev35 → ernie_renderer-0.2.0.dev40}/ernie/scene/schema.h

@@ -127,12 +127,35 @@ struct ExtentRows {
     std::string_view Text(Token token) const {
         return store.Paths().Names().Text(token);
     }
+    /// @return The live prim a relationship targets, or none.
+    std::optional<PrimId> Resolve(const Target& target) const;
+    /// @return Another prim's extent brought into a row's own space through the transforms
+    /// between, or none when it has none.
+    std::optional<Box> ExtentInRowSpace(PrimId other, std::uint32_t row) const;
 };
 
 /// Computes the extents of a bucket's rows [begin, end) into `out`, one box each, in each prim's
 /// own space. Written as a loop over columns, as the GPU kernels are.
 using ExtentFunction = void (*)(const ExtentRows& rows, RowRange range, std::span<Box> out);
 
+/// @brief Fills `out` with `extent(row)` for each row of `range`: the loop every extent function
+/// runs.
+template <typename Extent>
+void ComputeRows(RowRange range, std::span<Box> out, const Extent& extent) {
+    for (std::uint32_t row = range.begin; row < range.end; ++row) {
+        out[row - range.begin] = extent(row);
+    }
+}
+
+/// The extent function of prims centred on their origin. `kHalves(rows)` reads the columns once
+/// and returns each row's half-size by row.
+template <auto kHalves>
+void CentredExtent(const ExtentRows& rows, RowRange range, std::span<Box> out) {
+    const auto half = kHalves(rows);
+    ComputeRows(range, out,
+                [&](std::uint32_t row) { return Box::Around(glm::dvec3(0.0), half(row)); });
+}
+
 /// @brief How a prim type is bounded, as USD's Boundable and non-Boundable bases divide them.
 struct ExtentRule {
     enum class Kind : std::uint8_t {
@@ -179,6 +202,8 @@ struct SchemaDef {
     /// Fallbacks the type changes for attributes of its bases or built-in schemas, as
     /// DistantLight's brighter intensity.
     std::vector<std::pair<std::string_view, Value>> fallbackOverrides;
+    /// The prim types an API schema may be applied to, as MeshLightAPI's Mesh; any when empty.
+    std::vector<std::string_view> appliesTo;
 
     bool IsA(const SchemaDef& other) const;
     bool IsOpen(std::string_view attribute) const;
@@ -224,6 +249,7 @@ struct ApiName {
     std::string Attribute(std::string_view declared) const;
     /// @return The name `Parse` reads.
     std::string ToString() const;
+    bool operator==(const ApiName&) const = default;
 };
 
 /// @brief Checks a value against a declared attribute's limits and options; the scene checks its

ernie_renderer-0.2.0.dev40/ernie/scene/schemas/camera.cpp

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file camera.cpp
+/// @brief The camera's registry entry and Ernie's camera API schemas'.
+#include "ernie/scene/schemas/camera.h"
+
+namespace ernie {
+
+ERNIE_DEFINE_SCHEMA(Camera, Concrete, kNoExtent, ERNIE_CAMERA_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(ErnieLensAPI, SingleApply, kInheritExtent, ERNIE_LENS_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(ErniePolarizerAPI, SingleApply, kInheritExtent, ERNIE_POLARIZER_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(ErnieSensorAPI, SingleApply, kInheritExtent, ERNIE_SENSOR_API_ATTRIBUTES)
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/camera.h

@@ -114,12 +114,8 @@
 
 #define ERNIE_SENSOR_API_ATTRIBUTES(X)                                                             \
     X(glm::dvec2, SpectralRange, "ernie:spectral:range", glm::dvec2(380.0, 780.0),                 \
-      "Wavelengths in nm the sensor sees.", .group = "Sensor", .lower = Above(0.0))                \
-    X(int, SpectralBands, "ernie:spectral:bands", 16, "Bands across the range.",                   \
-      .group = "Sensor", .lower = AtLeast(1.0))                                                    \
-    X(std::string, SpectralMode, "ernie:spectral:mode", "spectral",                                \
-      "spectral: bands over the range; rgb: three bands of linear sRGB, faster.",                  \
-      .group = "Sensor", .options = {"spectral", "rgb"})                                           \
+      "Wavelengths in nm the sensor responds to; its products sample them in bands.",              \
+      .group = "Sensor", .lower = Above(0.0))                                                      \
     X(std::string, SensorType, "ernie:sensor:type", "rgb", "A colour or a mono sensor.",           \
       .group = "Sensor", .options = {"rgb", "mono"})                                               \
     X(bool, SensorNoise, "ernie:sensor:noise", true, "Whether it adds the noise below.",           \
@@ -155,30 +151,15 @@
 
 namespace ernie {
 
-ERNIE_SCHEMA_ACCESSORS(Camera, Xformable, ERNIE_CAMERA_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(ErnieLensAPI, SchemaView, ERNIE_LENS_API_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(ErniePolarizerAPI, SchemaView, ERNIE_POLARIZER_API_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(ErnieSensorAPI, SchemaView, ERNIE_SENSOR_API_ATTRIBUTES);
-
-/// A view looking down -z, y up, with a lens and film.
-class Camera : public CameraAccessors<Camera, Xformable> {
-    ERNIE_SCHEMA_BODY(Camera, Xformable)
-    ERNIE_SCHEMA_DEFINE(Camera)
-};
-
-/// A camera's lens beyond USD's: fisheyes, distortion, vignetting and chromatic aberration.
-class ErnieLensAPI : public ErnieLensAPIAccessors<ErnieLensAPI, SchemaView> {
-    ERNIE_API_SCHEMA_BODY(ErnieLensAPI)
-};
-
-/// A polarizer in front of a camera's lens, or a polarization sensor's mosaic.
-class ErniePolarizerAPI : public ErniePolarizerAPIAccessors<ErniePolarizerAPI, SchemaView> {
-    ERNIE_API_SCHEMA_BODY(ErniePolarizerAPI)
-};
-
-/// A camera's sensor: its spectral bands, noise, ADC and quantum efficiency.
-class ErnieSensorAPI : public ErnieSensorAPIAccessors<ErnieSensorAPI, SchemaView> {
-    ERNIE_API_SCHEMA_BODY(ErnieSensorAPI)
-};
+ERNIE_CONCRETE_SCHEMA(Camera, Xformable, ERNIE_CAMERA_ATTRIBUTES,
+                      "A view looking down -z, y up, with a lens and film.");
+ERNIE_API_SCHEMA(ErnieLensAPI, ERNIE_LENS_API_ATTRIBUTES,
+                 "A camera's lens beyond USD's: fisheyes, distortion, vignetting and chromatic "
+                 "aberration.");
+ERNIE_API_SCHEMA(ErniePolarizerAPI, ERNIE_POLARIZER_API_ATTRIBUTES,
+                 "A polarizer in front of a camera's lens, or a polarization sensor's mosaic.");
+ERNIE_API_SCHEMA(ErnieSensorAPI, ERNIE_SENSOR_API_ATTRIBUTES,
+                 "A camera's sensor: its spectral range, noise, ADC and quantum efficiency; its "
+                 "products set how finely the range is sampled.");
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/collection.cpp

@@ -5,7 +5,6 @@
 
 namespace ernie {
 
-ERNIE_DEFINE_SCHEMA(CollectionAPI, "CollectionAPI", nullptr, MultipleApply, kInheritExtent,
-                    "A named set of prims.", ERNIE_COLLECTION_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(CollectionAPI, MultipleApply, kInheritExtent, ERNIE_COLLECTION_API_ATTRIBUTES)
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev40}/ernie/scene/schemas/collection.h

@@ -36,11 +36,7 @@ template <> struct ChoiceTokens<ExpansionRule> {
                                                              "expandPrimsAndProperties"};
 };
 
-ERNIE_SCHEMA_ACCESSORS(CollectionAPI, SchemaView, ERNIE_COLLECTION_API_ATTRIBUTES);
-
-/// A named set of prims, as light linking and material collections use them.
-class CollectionAPI : public CollectionAPIAccessors<CollectionAPI, SchemaView> {
-    ERNIE_API_SCHEMA_BODY(CollectionAPI)
-};
+ERNIE_API_SCHEMA(CollectionAPI, ERNIE_COLLECTION_API_ATTRIBUTES,
+                 "A named set of prims, as light linking and material collections use them.");
 
 }  // namespace ernie

ernie_renderer-0.2.0.dev40/ernie/scene/schemas/geom.cpp

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file geom.cpp
+/// @brief UsdGeom's registry entries and the implicit shapes' extents, as UsdGeom computes them.
+#include "ernie/scene/schemas/geom.h"
+
+namespace ernie {
+namespace {
+
+/// @return The axis index (0, 1, 2) of an `axis` token.
+int AxisIndex(const ExtentRows& rows, Token axis) {
+    return rows.Text(axis).front() - 'X';
+}
+
+auto CubeHalves(const ExtentRows& rows) {
+    return [size = rows.Column<double>(Cube::kSize)](std::uint32_t row) {
+        return glm::dvec3(0.5 * size[row]);
+    };
+}
+
+auto SphereHalves(const ExtentRows& rows) {
+    return [radius = rows.Column<double>(Sphere::kRadius)](std::uint32_t row) {
+        return glm::dvec3(radius[row]);
+    };
+}
+
+/// Cylinders, cones and capsules: a radius about the axis; capsules' caps add it along the axis.
+template <bool kCapped> auto RoundHalves(const ExtentRows& rows) {
+    return [&rows, radius = rows.Column<double>(Cylinder::kRadius),
+            height = rows.Column<double>(Cylinder::kHeight),
+            axis = rows.Column<Token>(Cylinder::kAxis)](std::uint32_t row) {
+        glm::dvec3 half(radius[row]);
+        half[AxisIndex(rows, axis[row])] = 0.5 * height[row] + (kCapped ? radius[row] : 0.0);
+        return half;
+    };
+}
+
+auto PlaneHalves(const ExtentRows& rows) {
+    return [&rows, width = rows.Column<double>(Plane::kWidth),
+            length = rows.Column<double>(Plane::kLength),
+            axis = rows.Column<Token>(Plane::kAxis)](std::uint32_t row) {
+        const int normal = AxisIndex(rows, axis[row]);
+        // Width lies along x, or z for an X normal; length along y, or z for a Y normal.
+        glm::dvec3 half(0.0);
+        half[normal == 0 ? 2 : 0] = 0.5 * width[row];
+        half[normal == 1 ? 2 : 1] = 0.5 * length[row];
+        return half;
+    };
+}
+
+}  // namespace
+
+ERNIE_DEFINE_SCHEMA(Imageable, Abstract, kInheritExtent, ERNIE_IMAGEABLE_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Xformable, Abstract, kInheritExtent, ERNIE_XFORMABLE_ATTRIBUTES,
+                    .openNamespaces = {tokens::kXformOpPrefix})
+ERNIE_DEFINE_SCHEMA(Boundable, Abstract, kInheritExtent, ERNIE_BOUNDABLE_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Gprim, Abstract, kInheritExtent, ERNIE_GPRIM_ATTRIBUTES,
+                    .openNamespaces = {tokens::kPrimvarsPrefix})
+// Grouping prims are where custom data lives, so they take attributes of any name.
+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_SPHERE_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Cylinder, Concrete, ComputedExtent(CentredExtent<RoundHalves<false>>),
+                    ERNIE_CYLINDER_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Cone, Concrete, ComputedExtent(CentredExtent<RoundHalves<false>>),
+                    ERNIE_CYLINDER_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Capsule, Concrete, ComputedExtent(CentredExtent<RoundHalves<true>>),
+                    ERNIE_CAPSULE_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Plane, Concrete, ComputedExtent(CentredExtent<PlaneHalves>),
+                    ERNIE_PLANE_ATTRIBUTES)
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev35 → 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 {};
     }
@@ -99,85 +141,32 @@ template <> struct ChoiceTokens<Axis> {
     static constexpr std::array<std::string_view, 3> kTokens{"X", "Y", "Z"};
 };
 
-ERNIE_SCHEMA_ACCESSORS(Imageable, SchemaView, ERNIE_IMAGEABLE_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Xformable, Imageable, ERNIE_XFORMABLE_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Boundable, Xformable, ERNIE_BOUNDABLE_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Gprim, Boundable, ERNIE_GPRIM_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Xform, Xformable, ERNIE_NO_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Scope, Imageable, ERNIE_NO_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Cube, Gprim, ERNIE_CUBE_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Sphere, Gprim, ERNIE_SPHERE_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Cylinder, Gprim, ERNIE_CYLINDER_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Cone, Gprim, ERNIE_CYLINDER_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Capsule, Gprim, ERNIE_CAPSULE_ATTRIBUTES);
-ERNIE_SCHEMA_ACCESSORS(Plane, Gprim, ERNIE_PLANE_ATTRIBUTES);
-
-/// What every prim has: visibility, purpose and the world it is in.
-class Imageable : public ImageableAccessors<Imageable, SchemaView> {
-    ERNIE_SCHEMA_BODY(Imageable, SchemaView)
-};
-
-/// What has a transform, composed from its xformOps.
-class Xformable : public XformableAccessors<Xformable, Imageable> {
-    ERNIE_SCHEMA_BODY(Xformable, Imageable)
-};
-
-/// What has an extent in its own space, computed from its attributes.
-class Boundable : public BoundableAccessors<Boundable, Xformable> {
-    ERNIE_SCHEMA_BODY(Boundable, Xformable)
-};
-
-/// Geometry, drawn in a display colour or with a bound material.
-class Gprim : public GprimAccessors<Gprim, Boundable> {
-    ERNIE_SCHEMA_BODY(Gprim, Boundable)
-};
-
-/// A transform grouping its children.
-class Xform : public XformAccessors<Xform, Xformable> {
-    ERNIE_SCHEMA_BODY(Xform, Xformable)
-    ERNIE_SCHEMA_DEFINE(Xform)
-};
-
-/// A grouping without a transform of its own.
-class Scope : public ScopeAccessors<Scope, Imageable> {
-    ERNIE_SCHEMA_BODY(Scope, Imageable)
-    ERNIE_SCHEMA_DEFINE(Scope)
-};
-
-/// A box centred on its origin, `size` along each axis.
-class Cube : public CubeAccessors<Cube, Gprim> {
-    ERNIE_SCHEMA_BODY(Cube, Gprim)
-    ERNIE_SCHEMA_DEFINE(Cube)
-};
-
-/// A sphere centred on its origin.
-class Sphere : public SphereAccessors<Sphere, Gprim> {
-    ERNIE_SCHEMA_BODY(Sphere, Gprim)
-    ERNIE_SCHEMA_DEFINE(Sphere)
-};
-
-/// A capped cylinder along its axis.
-class Cylinder : public CylinderAccessors<Cylinder, Gprim> {
-    ERNIE_SCHEMA_BODY(Cylinder, Gprim)
-    ERNIE_SCHEMA_DEFINE(Cylinder)
-};
-
-/// A capped cone along its axis, its apex at +height / 2.
-class Cone : public ConeAccessors<Cone, Gprim> {
-    ERNIE_SCHEMA_BODY(Cone, Gprim)
-    ERNIE_SCHEMA_DEFINE(Cone)
-};
-
-/// A cylinder with hemispherical caps along its axis.
-class Capsule : public CapsuleAccessors<Capsule, Gprim> {
-    ERNIE_SCHEMA_BODY(Capsule, Gprim)
-    ERNIE_SCHEMA_DEFINE(Capsule)
-};
-
-/// A one-sided rectangle facing along its axis.
-class Plane : public PlaneAccessors<Plane, Gprim> {
-    ERNIE_SCHEMA_BODY(Plane, Gprim)
-    ERNIE_SCHEMA_DEFINE(Plane)
-};
+ERNIE_SCHEMA(Imageable, SchemaView, ERNIE_IMAGEABLE_ATTRIBUTES,
+             "What every prim has: visibility, purpose and the world it is in.");
+ERNIE_SCHEMA(Xformable, Imageable, ERNIE_XFORMABLE_ATTRIBUTES,
+             "What has a transform, composed from its xformOps.");
+ERNIE_SCHEMA(Boundable, Xformable, ERNIE_BOUNDABLE_ATTRIBUTES,
+             "What has an extent in its own space, computed from its attributes.");
+ERNIE_SCHEMA(Gprim, Boundable, ERNIE_GPRIM_ATTRIBUTES,
+             "Geometry, drawn in a display colour or with a bound material.");
+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_CONCRETE_SCHEMA(Cylinder, Gprim, ERNIE_CYLINDER_ATTRIBUTES,
+                      "A capped cylinder along its axis.");
+ERNIE_CONCRETE_SCHEMA(Cone, Gprim, ERNIE_CYLINDER_ATTRIBUTES,
+                      "A capped cone along its axis, its apex at +height / 2.");
+ERNIE_CONCRETE_SCHEMA(Capsule, Gprim, ERNIE_CAPSULE_ATTRIBUTES,
+                      "A cylinder with hemispherical caps along its axis.");
+ERNIE_CONCRETE_SCHEMA(Plane, Gprim, ERNIE_PLANE_ATTRIBUTES,
+                      "A one-sided rectangle facing along its axis.");
 
 }  // namespace ernie