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

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

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

@@ -300,19 +300,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 +341,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 +373,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;
 }
@@ -429,4 +458,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.dev37}/ernie/scene/scene.h

@@ -121,7 +121,8 @@ 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;

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev37}/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.dev37/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.dev37}/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.dev37}/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.dev37}/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.dev37/ernie/scene/schemas/geom.cpp

@@ -0,0 +1,76 @@
+// 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(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.dev37}/ernie/scene/schemas/geom.h

@@ -99,85 +99,27 @@ 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_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

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev37}/ernie/scene/schemas/instancer.cpp

@@ -42,6 +42,36 @@ glm::dmat4 InstanceTransform(std::span<const float> position, std::span<const fl
     return m;
 }
 
+/// One row's instances: its prototypes' boxes, each placed at the instances that use it.
+struct Instances {
+    std::vector<Box> prototypes;
+    std::vector<std::int64_t> indices;
+    std::vector<float> positions;
+    std::vector<float> rotations;
+    std::vector<float> scales;
+    bool wFirst = false;
+
+    Box Bounds() const {
+        Box box;
+        for (std::size_t i = 0; i < positions.size() / 3; ++i) {
+            const std::int64_t p = i < indices.size() ? indices[i] : 0;
+            if (p >= 0 && static_cast<std::size_t>(p) < prototypes.size()) {
+                box.Extend(prototypes[static_cast<std::size_t>(p)].Transformed(InstanceTransform(
+                    Part(positions, i, 3), Part(rotations, i, 4), Part(scales, i, 3), wFirst)));
+            }
+        }
+        return box;
+    }
+
+  private:
+    /// @return Instance i's `n` values, or none when the array is unset or too short.
+    static std::span<const float> Part(const std::vector<float>& values, std::size_t i,
+                                       std::size_t n) {
+        return values.size() >= (i + 1) * n ? std::span(values).subspan(i * n, n)
+                                            : std::span<const float>();
+    }
+};
+
 void InstancerExtent(const ExtentRows& rows, RowRange range, std::span<Box> out) {
     const auto prototypes = rows.Column<std::vector<Target>>(PointInstancer::kPrototypes);
     const auto indices = rows.Column<Tensor>(PointInstancer::kProtoIndices);
@@ -50,44 +80,30 @@ void InstancerExtent(const ExtentRows& rows, RowRange range, std::span<Box> out)
     const auto scales = rows.Column<Tensor>(PointInstancer::kScales);
     const auto order = rows.Column<Token>(PointInstancer::kQuaternionOrder);
     const auto authored = rows.Column<std::vector<float>>(Boundable::kExtent);
-    for (std::uint32_t row = range.begin; row < range.end; ++row) {
-        Box& box = out[row - range.begin] = Box();
+    ComputeRows(range, out, [&](std::uint32_t row) {
         if (!OnHost({&indices[row], &positions[row], &orientations[row], &scales[row]})) {
-            box = AuthoredExtent(authored[row]);
-            continue;
+            return AuthoredExtent(authored[row]);
         }
-        const std::vector<Box> protoBoxes = Map(prototypes[row], [&](const Target& target) {
-            const std::optional<PrimId> prim = rows.store.Find(target.path);
-            return prim ? rows.scene->BoundsInParent(*prim) : Box();
-        });
-        const std::vector<float> xyz = FloatsOrNone(positions[row], 3, "positions");
-        const std::vector<float> rotations = FloatsOrNone(orientations[row], 4, "orientations");
-        const std::vector<float> scaling = FloatsOrNone(scales[row], 3, "scales");
-        const std::vector<std::int64_t> proto = indices[row].Empty()
-                                                    ? std::vector<std::int64_t>{}
-                                                    : CopyInts(indices[row], "protoIndices");
-        const bool wFirst = rows.Text(order[row]) == "wxyz";
-        const std::size_t count = xyz.size() / 3;
-        for (std::size_t i = 0; i < count; ++i) {
-            const std::int64_t p = i < proto.size() ? proto[i] : 0;
-            if (p < 0 || static_cast<std::size_t>(p) >= protoBoxes.size()) {
-                continue;
-            }
-            const auto part = [&](const std::vector<float>& values, std::size_t n) {
-                return values.size() >= (i + 1) * n ? std::span(values).subspan(i * n, n)
-                                                    : std::span<const float>();
-            };
-            box.Extend(protoBoxes[static_cast<std::size_t>(p)].Transformed(
-                InstanceTransform(part(xyz, 3), part(rotations, 4), part(scaling, 3), wFirst)));
-        }
-    }
+        const Instances instances{
+            .prototypes = Map(prototypes[row],
+                              [&](const Target& target) {
+                                  const std::optional<PrimId> prim = rows.Resolve(target);
+                                  return prim ? rows.scene->BoundsInParent(*prim) : Box();
+                              }),
+            .indices = indices[row].Empty() ? std::vector<std::int64_t>{}
+                                            : CopyInts(indices[row], "protoIndices"),
+            .positions = FloatsOrNone(positions[row], 3, "positions"),
+            .rotations = FloatsOrNone(orientations[row], 4, "orientations"),
+            .scales = FloatsOrNone(scales[row], 3, "scales"),
+            .wFirst = rows.Text(order[row]) == "wxyz",
+        };
+        return instances.Bounds();
+    });
 }
 
 }  // namespace
 
-ERNIE_DEFINE_SCHEMA(PointInstancer, tokens::kPointInstancer, &Boundable::Definition(), Concrete,
-                    ComputedFromOtherPrims(InstancerExtent),
-                    "Prototypes placed at instances, bounded by their bounds at each instance.",
+ERNIE_DEFINE_SCHEMA(PointInstancer, Concrete, ComputedFromOtherPrims(InstancerExtent),
                     ERNIE_POINT_INSTANCER_ATTRIBUTES, .openNamespaces = {tokens::kPrimvarsPrefix})
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev35 → ernie_renderer-0.2.0.dev37}/ernie/scene/schemas/instancer.h

@@ -52,12 +52,7 @@ template <> struct ChoiceTokens<QuaternionOrder> {
     static constexpr std::array<std::string_view, 2> kTokens{"xyzw", "wxyz"};
 };
 
-ERNIE_SCHEMA_ACCESSORS(PointInstancer, Boundable, ERNIE_POINT_INSTANCER_ATTRIBUTES);
-
-/// Prototypes placed at instances, bounded by their bounds at each instance.
-class PointInstancer : public PointInstancerAccessors<PointInstancer, Boundable> {
-    ERNIE_SCHEMA_BODY(PointInstancer, Boundable)
-    ERNIE_SCHEMA_DEFINE(PointInstancer)
-};
+ERNIE_CONCRETE_SCHEMA(PointInstancer, Boundable, ERNIE_POINT_INSTANCER_ATTRIBUTES,
+                      "Prototypes placed at instances, bounded by their bounds at each instance.");
 
 }  // namespace ernie

ernie_renderer-0.2.0.dev37/ernie/scene/schemas/laser.cpp

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file laser.cpp
+/// @brief The laser's registry entry and extent: its emitter, the larger of its aperture and waist.
+#include "ernie/scene/schemas/laser.h"
+
+#include <algorithm>
+
+namespace ernie {
+namespace {
+
+auto EmitterHalves(const ExtentRows& rows) {
+    return [aperture = rows.Column<double>(LaserLight::kApertureRadius),
+            waist = rows.Column<glm::dvec2>(LaserLight::kWaistRadius)](std::uint32_t row) {
+        const double radius = std::max({aperture[row], waist[row].x, waist[row].y});
+        return glm::dvec3(radius, radius, 0.0);
+    };
+}
+
+}  // namespace
+
+ERNIE_DEFINE_SCHEMA(LaserLight, Concrete, ComputedExtent(CentredExtent<EmitterHalves>),
+                    ERNIE_LASER_LIGHT_ATTRIBUTES,
+                    .fallbackOverrides = {{"ernie:power", 0.001},
+                                          {"ernie:polarization:degree", 0.98}})
+
+}  // namespace ernie