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

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

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

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

@@ -13,6 +13,7 @@ add_library(
     schemas/collection.cpp
     schemas/geom.cpp
     schemas/instancer.cpp
+    schemas/laser.cpp
     schemas/lux.cpp
     schemas/mesh.cpp
     schemas/registry.cpp

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

@@ -16,14 +16,15 @@
 namespace ernie {
 namespace {
 
-/// @return A column layout for the attribute `name` holding `def`'s fallback in unauthored rows.
-ColumnLayout MakeLayout(PathTable& paths, const AttributeDef& def, std::string_view name) {
+/// @return A column layout for the attribute `name` holding `fallback` in unauthored rows.
+ColumnLayout MakeLayout(PathTable& paths, const AttributeDef& def, std::string_view name,
+                        const Value& fallback) {
     const AttributeId attribute = paths.Names().Intern(name);
     return WithColumnType(def.type, [&]<typename T>(std::type_identity<T>) {
         if constexpr (std::is_same_v<T, Tensor>) {
             return ColumnLayout::Of<T>(attribute);
         } else {
-            return ColumnLayout::Of<T>(attribute, ToElement<T>(paths, def.fallback).value_or(T{}));
+            return ColumnLayout::Of<T>(attribute, ToElement<T>(paths, fallback).value_or(T{}));
         }
     });
 }
@@ -302,15 +303,16 @@ BucketId Scene::FindOrAddBucket(const SchemaDef* schema, std::vector<Token> apis
     std::vector<ColumnLayout> layout;
     const auto add = [&](const SchemaDef& declaring, const ApiName& api) {
         for (const AttributeDef* def : declaring.AllAttributes()) {
-            layout.push_back(MakeLayout(paths, *def, api.Attribute(def->name)));
+            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));
             entry.declared.emplace(layout.back().attribute, def);
         }
     };
     if (schema != nullptr) {
         add(*schema, {});
     }
-    for (const Token token : key.apiSchemas) {
-        const ApiName api = ApiName::Parse(paths.Names().Text(token));
+    for (const ApiName& api : AllApis(schema, key.apiSchemas)) {
         add(*api.schema, api);
     }
     const BucketId bucket = store_.AddBucket(key, layout);
@@ -348,8 +350,20 @@ bool Scene::RemoveApi(PrimId prim, std::string_view api) {
 }
 
 bool Scene::HasApi(PrimId prim, std::string_view api) const {
-    const std::optional<Token> token = store_.Tokens().Find(api);
-    return token && std::ranges::find(Apis(prim), *token) != Apis(prim).end();
+    return std::ranges::any_of(AllApis(Schema(prim), Apis(prim)),
+                               [&](const ApiName& name) { return name.ToString() == api; });
+}
+
+std::vector<ApiName> Scene::AllApis(const SchemaDef* schema, std::span<const Token> applied) const {
+    std::vector<ApiName> apis;
+    for (const std::string_view builtin :
+         schema != nullptr ? schema->AllBuiltinApis() : std::vector<std::string_view>{}) {
+        apis.push_back(ApiName::Parse(builtin));
+    }
+    for (const Token token : applied) {
+        apis.push_back(ApiName::Parse(store_.Tokens().Text(token)));
+    }
+    return apis;
 }
 
 std::vector<std::string> Scene::AppliedApis(PrimId prim) const {
@@ -393,9 +407,8 @@ Dirty Scene::Classify(const ChangeSet::Values& change) const {
 bool Scene::TakesUndeclared(PrimId prim, std::string_view attribute) const {
     const SchemaDef* schema = Schema(prim);
     return schema == nullptr || schema->IsOpen(attribute) ||
-           std::ranges::any_of(Apis(prim), [&](Token api) {
-               return ApiName::Parse(store_.Tokens().Text(api)).schema->IsOpen(attribute);
-           });
+           std::ranges::any_of(AllApis(schema, Apis(prim)),
+                               [&](const ApiName& api) { return api.schema->IsOpen(attribute); });
 }
 
 ColumnType Scene::TypeForUndeclared(PrimId prim, std::string_view attribute,

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

@@ -121,6 +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.
+    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;
     const AttributeDef* Declared(BucketId bucket, AttributeId attribute) const;

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

@@ -139,6 +139,24 @@ std::vector<const AttributeDef*> SchemaDef::AllAttributes() const {
     return all;
 }
 
+std::vector<std::string_view> SchemaDef::AllBuiltinApis() const {
+    std::vector<std::string_view> all =
+        base != nullptr ? base->AllBuiltinApis() : std::vector<std::string_view>{};
+    all.insert(all.end(), builtinApis.begin(), builtinApis.end());
+    return all;
+}
+
+const Value* SchemaDef::FallbackOverride(std::string_view attribute) const {
+    const Value* found = nullptr;
+    FirstInLineage([&](const SchemaDef& type) {
+        const auto override = std::ranges::find(type.fallbackOverrides, attribute,
+                                                &std::pair<std::string_view, Value>::first);
+        found = override != type.fallbackOverrides.end() ? &override->second : nullptr;
+        return found != nullptr;
+    });
+    return found;
+}
+
 ExtentRule SchemaDef::Extent() const {
     const SchemaDef* ruled = FirstInLineage(
         [](const SchemaDef& type) { return type.extent.kind != ExtentRule::Kind::Inherit; });

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

@@ -171,9 +171,14 @@ struct SchemaDef {
     SchemaKind kind = SchemaKind::Concrete;
     std::string_view doc;
     std::vector<AttributeDef> attributes;
+    ExtentRule extent;
     /// Namespaces (`xformOp:`) or `*` whose undeclared attributes the type takes.
     std::vector<std::string_view> openNamespaces;
-    ExtentRule extent;
+    /// API schemas every prim of the type has, as UsdLux's lights have `CollectionAPI:lightLink`.
+    std::vector<std::string_view> builtinApis;
+    /// 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;
 
     bool IsA(const SchemaDef& other) const;
     bool IsOpen(std::string_view attribute) const;
@@ -181,6 +186,11 @@ struct SchemaDef {
     const AttributeDef* Find(std::string_view attribute) const;
     /// @return Every attribute, the bases' first.
     std::vector<const AttributeDef*> AllAttributes() const;
+    /// @return The built-in API schemas of the type and its bases.
+    std::vector<std::string_view> AllBuiltinApis() const;
+    /// @return The fallback the type or its nearest base gives an attribute in place of its
+    /// declaration's, or null.
+    const Value* FallbackOverride(std::string_view attribute) const;
     /// @return The rule, the nearest base's when inherited.
     ExtentRule Extent() const;
 

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

@@ -0,0 +1,20 @@
+// 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, "Camera", &Xformable::Definition(), Concrete, kNoExtent,
+                    "A view looking down -z, y up, with a lens and film.", ERNIE_CAMERA_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(ErnieLensAPI, "ErnieLensAPI", nullptr, SingleApply, kInheritExtent,
+                    "A camera's lens beyond USD's: fisheyes, distortion, vignetting and colour.",
+                    ERNIE_LENS_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(ErniePolarizerAPI, "ErniePolarizerAPI", nullptr, SingleApply, kInheritExtent,
+                    "A polarizer in front of a camera's lens, or a polarization sensor's mosaic.",
+                    ERNIE_POLARIZER_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(ErnieSensorAPI, "ErnieSensorAPI", nullptr, SingleApply, kInheritExtent,
+                    "A camera's sensor: its spectral bands, noise, ADC and quantum efficiency.",
+                    ERNIE_SENSOR_API_ATTRIBUTES)
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev32/ernie/scene/schemas/camera.h

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file camera.h
+/// @brief UsdGeomCamera: a view's projection, lens and exposure.
+///
+/// References:
+/// - Pixar, UsdGeomCamera, https://openusd.org/release/api/class_usd_geom_camera.html
+#pragma once
+
+#include "ernie/scene/schemas/geom.h"
+
+// clang-format off
+// Lens lengths are metres, whatever a USD stage's scale: USD's tenths of a scene unit are
+// converted on import and export.
+#define ERNIE_LENS_LENGTH(X, Name, usdName, fallback, text)                                        \
+    X(double, Name, usdName, fallback, text ", metres.", .group = "Lens", .lower = AtLeast(0.0),   \
+      .finite = true)
+
+#define ERNIE_CAMERA_ATTRIBUTES(X)                                                                 \
+    X(std::string, Projection, "projection", "perspective", "How it projects the scene.",          \
+      .group = "Lens", .options = {"perspective", "orthographic"})                                 \
+    ERNIE_LENS_LENGTH(X, HorizontalAperture, "horizontalAperture", 0.020955, "Film width")         \
+    ERNIE_LENS_LENGTH(X, VerticalAperture, "verticalAperture", 0.0152908, "Film height")           \
+    X(double, HorizontalApertureOffset, "horizontalApertureOffset", 0.0,                           \
+      "The film's offset from the lens axis along x, metres.", .group = "Lens", .finite = true)    \
+    X(double, VerticalApertureOffset, "verticalApertureOffset", 0.0,                               \
+      "The film's offset from the lens axis along y, metres.", .group = "Lens", .finite = true)    \
+    ERNIE_LENS_LENGTH(X, FocalLength, "focalLength", 0.05, "The lens's focal length")              \
+    X(glm::dvec2, ClippingRange, "clippingRange", glm::dvec2(1.0, 1000000.0),                      \
+      "Near and far distances in metres.", .group = "Lens", .lower = Above(0.0))                   \
+    X(Tensor, ClippingPlanes, "clippingPlanes", Tensor(),                                          \
+      "(n, 4) planes (a, b, c, d) keeping points where a x + b y + c z + d >= 0.",                 \
+      .group = "Lens", .components = 4)                                                            \
+    X(double, FStop, "fStop", 0.0, "The lens's f-number; 0 for a pinhole, all in focus.",          \
+      .group = "Lens", .lower = AtLeast(0.0))                                                      \
+    X(double, FocusDistance, "focusDistance", 0.0, "Metres to the plane in focus.",                \
+      .group = "Lens", .lower = AtLeast(0.0))                                                      \
+    X(std::string, StereoRole, "stereoRole", "mono", "Which eye it is.", .group = "Lens",          \
+      .options = {"mono", "left", "right"})                                                        \
+    X(double, ShutterOpen, "shutter:open", 0.0, "Frames from the time code the shutter opens.",   \
+      .group = "Shutter")                                                                          \
+    X(double, ShutterClose, "shutter:close", 0.0, "Frames from the time code it closes.",          \
+      .group = "Shutter")                                                                          \
+    X(double, Exposure, "exposure", 0.0, "Stops of exposure added to the image.",                  \
+      .group = "Exposure", .finite = true)                                                         \
+    X(double, ExposureIso, "exposure:iso", 100.0, "The sensor's ISO speed.", .group = "Exposure",  \
+      .lower = Above(0.0))                                                                         \
+    X(double, ExposureTime, "exposure:time", 1.0, "Seconds of exposure.", .group = "Exposure",     \
+      .lower = AtLeast(0.0))                                                                       \
+    X(double, ExposureFStop, "exposure:fStop", 1.0, "The f-number exposure is computed with.",     \
+      .group = "Exposure", .lower = Above(0.0))                                                    \
+    X(double, ExposureResponsivity, "exposure:responsivity", 1.0, "The sensor's responsivity.",    \
+      .group = "Exposure", .lower = AtLeast(0.0))                                                  \
+    X(std::string, ExposureMode, "ernie:exposure:mode", "manual",                                  \
+      "auto keys the image to middle grey from the metered scene, after the settings above.",      \
+      .group = "Exposure", .options = {"manual", "auto"})                                          \
+    X(double, ExposureAdaptation, "ernie:exposure:adaptation", 0.0,                                \
+      "Frames auto exposure takes to cover 63% of a change; 0 at once.", .group = "Exposure",      \
+      .lower = AtLeast(0.0))                                                                       \
+    X(int, ShutterSamples, "ernie:shutter:samples", 8, "Sub-frames rendered across the shutter.",  \
+      .group = "Shutter", .lower = AtLeast(1.0))                                                   \
+    X(double, ShutterRolling, "ernie:shutter:rolling", 0.0,                                        \
+      "Frames between the top row's exposure and the bottom row's; 0 global.", .group = "Shutter", \
+      .lower = AtLeast(0.0))                                                                       \
+    X(std::string, Scan, "ernie:camera:scan", "frame",                                             \
+      "pushbroom: a line scanner whose rows run from the last frame's pose to this one's.",        \
+      .group = "Shutter", .options = {"frame", "pushbroom"})                                       \
+    X(double, PushbroomLineOffset, "ernie:pushbroom:lineOffset", 0.0,                              \
+      "Metres from the principal point to the pushbroom's detector line.",                         \
+      .group = "Shutter", .finite = true)
+
+#define ERNIE_LENS_API_ATTRIBUTES(X)                                                               \
+    X(std::string, LensProjection, "ernie:lens:projection", "perspective",                         \
+      "Rectilinear, or a Kannala-Brandt fisheye.", .group = "Lens",                                \
+      .options = {"perspective", "fisheye"})                                                       \
+    X(std::vector<float>, LensDistortion, "ernie:lens:distortion", std::vector<float>{},           \
+      "Brown-Conrady k1 k2 k3 p1 p2; missing ones are 0.", .group = "Lens")                        \
+    X(std::vector<float>, LensFisheye, "ernie:lens:fisheye", std::vector<float>{},                 \
+      "Kannala-Brandt k1 k2 k3 k4 of a fisheye; none is equidistant.", .group = "Lens")            \
+    X(bool, LensVignetting, "ernie:lens:vignetting", false, "Natural falloff off axis.",           \
+      .group = "Lens")                                                                             \
+    X(double, LensTransmission, "ernie:lens:transmission", 1.0, "The fraction of light passed.",   \
+      .group = "Lens", .lower = AtLeast(0.0), .upper = AtMost(1.0))                                \
+    X(std::vector<float>, LensChromaticScale, "ernie:lens:chromatic:scale", std::vector<float>{},  \
+      "(nm, scale) pairs: lateral colour, the image's scale per wavelength.", .group = "Lens")     \
+    X(std::vector<float>, LensChromaticFocus, "ernie:lens:chromatic:focus", std::vector<float>{},  \
+      "(nm, metres) pairs: axial colour, the focal length's shift per wavelength.",                \
+      .group = "Lens")                                                                             \
+    X(Tensor, LensRays, "ernie:lens:rays", Tensor(),                                               \
+      "float32 (rows, columns, 3) unit directions every rays step pixels, in place of the "        \
+      "projection and distortion.",                                                                \
+      .group = "Lens", .rank = 3)                                                                  \
+    X(int, LensRaysStep, "ernie:lens:raysStep", 8, "Pixels between the lens's rays.",              \
+      .group = "Lens", .lower = AtLeast(1.0))
+
+#define ERNIE_POLARIZER_API_ATTRIBUTES(X)                                                          \
+    X(std::string, PolarizerType, "ernie:polarizer:type", "linear",                                \
+      "linear in front of the lens, or a mosaic of 90, 45 / 135, 0 degree polarizers over 2 x 2 "  \
+      "pixels, as a polarization sensor's.",                                                       \
+      .group = "Polarizer", .options = {"linear", "mosaic"})                                       \
+    X(double, PolarizerAngle, "ernie:polarizer:angle", 0.0,                                        \
+      "Degrees from the image's +x towards +y to a linear polarizer's axis.", .group = "Polarizer", \
+      .finite = true)                                                                              \
+    X(double, PolarizerExtinction, "ernie:polarizer:extinction", 1000.0,                           \
+      "Light passed along the axis over light passed across it.", .group = "Polarizer",            \
+      .lower = AtLeast(1.0))                                                                       \
+    X(double, PolarizerTransmission, "ernie:polarizer:transmission", 0.85,                         \
+      "The fraction of light polarized along the axis passed.", .group = "Polarizer",              \
+      .lower = AtLeast(0.0), .upper = AtMost(1.0))
+
+#define ERNIE_SENSOR_QE(X, Name, usdName, channel)                                                 \
+    X(std::vector<float>, Name, usdName, std::vector<float>{},                                     \
+      "(nm, electrons per photon) pairs of the " channel "; unset keeps the generic curve.",       \
+      .group = "Sensor")
+
+#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"})                                           \
+    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.",           \
+      .group = "Sensor")                                                                           \
+    X(double, SensorFullWell, "ernie:sensor:fullWell", 20000.0, "Electrons a pixel holds.",        \
+      .group = "Sensor", .lower = Above(0.0))                                                      \
+    X(double, SensorReadNoise, "ernie:sensor:readNoise", 3.0, "Electrons, standard deviation.",    \
+      .group = "Sensor", .lower = AtLeast(0.0))                                                    \
+    X(double, SensorDarkCurrent, "ernie:sensor:darkCurrent", 0.1, "Electrons per second.",         \
+      .group = "Sensor", .lower = AtLeast(0.0))                                                    \
+    X(double, SensorPrnu, "ernie:sensor:prnu", 0.005,                                              \
+      "Standard deviation of each pixel's relative gain.", .group = "Sensor",                      \
+      .lower = AtLeast(0.0))                                                                       \
+    X(double, SensorDsnu, "ernie:sensor:dsnu", 0.5,                                                \
+      "Electrons, standard deviation of each pixel's offset.", .group = "Sensor",                  \
+      .lower = AtLeast(0.0))                                                                       \
+    X(double, SensorElectronsPerDn, "ernie:sensor:electronsPerDn", 0.0,                            \
+      "At ISO 100; 0 for the full well over the ADC range.", .group = "Sensor",                    \
+      .lower = AtLeast(0.0))                                                                       \
+    X(int, SensorAdcBits, "ernie:sensor:adcBits", 12, "The ADC's bits.", .group = "Sensor",        \
+      .lower = AtLeast(1.0), .upper = AtMost(32.0))                                                \
+    X(double, SensorBlackLevel, "ernie:sensor:blackLevel", 0.0, "DN added to every pixel.",        \
+      .group = "Sensor", .lower = AtLeast(0.0))                                                    \
+    X(double, SensorPixelPitch, "ernie:sensor:pixelPitch", 5.0,                                    \
+      "Micrometres, of orthographic cameras.", .group = "Sensor", .lower = Above(0.0))             \
+    X(int, SensorSeed, "ernie:sensor:seed", 0, "The seed of the sensor's noise.",                  \
+      .group = "Sensor")                                                                           \
+    ERNIE_SENSOR_QE(X, SensorQeR, "ernie:sensor:qe:r", "red channel")                              \
+    ERNIE_SENSOR_QE(X, SensorQeG, "ernie:sensor:qe:g", "green channel")                            \
+    ERNIE_SENSOR_QE(X, SensorQeB, "ernie:sensor:qe:b", "blue channel")                             \
+    ERNIE_SENSOR_QE(X, SensorQeMono, "ernie:sensor:qe:mono", "mono channel")
+// clang-format on
+
+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)
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev30 → ernie_renderer-0.2.0.dev32}/ernie/scene/schemas/geom.cpp

@@ -65,18 +65,20 @@ ERNIE_DEFINE_SCHEMA(Imageable, "Imageable", nullptr, Abstract, kInheritExtent,
                     ERNIE_IMAGEABLE_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(Xformable, "Xformable", &Imageable::Definition(), Abstract, kInheritExtent,
                     "What has a transform, composed from its xformOps.", ERNIE_XFORMABLE_ATTRIBUTES,
-                    tokens::kXformOpPrefix)
+                    .openNamespaces = {tokens::kXformOpPrefix})
 ERNIE_DEFINE_SCHEMA(Boundable, "Boundable", &Xformable::Definition(), Abstract, kInheritExtent,
                     "What has an extent in its own space, computed from its attributes.",
                     ERNIE_BOUNDABLE_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(Gprim, "Gprim", &Boundable::Definition(), Abstract, kInheritExtent,
                     "Geometry, drawn in a display colour or with a bound material.",
-                    ERNIE_GPRIM_ATTRIBUTES, tokens::kPrimvarsPrefix)
+                    ERNIE_GPRIM_ATTRIBUTES, .openNamespaces = {tokens::kPrimvarsPrefix})
 // Grouping prims are where custom data lives, so they take attributes of any name.
 ERNIE_DEFINE_SCHEMA(Xform, tokens::kXform, &Xformable::Definition(), Concrete, kDescendantsExtent,
-                    "A transform grouping its children.", ERNIE_NO_ATTRIBUTES, "*")
+                    "A transform grouping its children.", ERNIE_NO_ATTRIBUTES,
+                    .openNamespaces = {"*"})
 ERNIE_DEFINE_SCHEMA(Scope, tokens::kScope, &Imageable::Definition(), Concrete, kDescendantsExtent,
-                    "A grouping without a transform of its own.", ERNIE_NO_ATTRIBUTES, "*")
+                    "A grouping without a transform of its own.", ERNIE_NO_ATTRIBUTES,
+                    .openNamespaces = {"*"})
 ERNIE_DEFINE_SCHEMA(Cube, tokens::kCube, &Gprim::Definition(), Concrete, ComputedExtent(CubeExtent),
                     "A box centred on its origin, size along each axis.", ERNIE_CUBE_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(Sphere, tokens::kSphere, &Gprim::Definition(), Concrete,

{ernie_renderer-0.2.0.dev30 → ernie_renderer-0.2.0.dev32}/ernie/scene/schemas/instancer.cpp

@@ -88,6 +88,6 @@ void InstancerExtent(const ExtentRows& rows, RowRange range, std::span<Box> out)
 ERNIE_DEFINE_SCHEMA(PointInstancer, tokens::kPointInstancer, &Boundable::Definition(), Concrete,
                     ComputedFromOtherPrims(InstancerExtent),
                     "Prototypes placed at instances, bounded by their bounds at each instance.",
-                    ERNIE_POINT_INSTANCER_ATTRIBUTES, tokens::kPrimvarsPrefix)
+                    ERNIE_POINT_INSTANCER_ATTRIBUTES, .openNamespaces = {tokens::kPrimvarsPrefix})
 
 }  // namespace ernie

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

@@ -0,0 +1,29 @@
+// 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 {
+
+void LaserExtent(const ExtentRows& rows, RowRange range, std::span<Box> out) {
+    const auto aperture = rows.Column<double>(LaserLight::kApertureRadius);
+    const auto waist = rows.Column<glm::dvec2>(LaserLight::kWaistRadius);
+    for (std::uint32_t row = range.begin; row < range.end; ++row) {
+        const double radius = std::max({aperture[row], waist[row].x, waist[row].y});
+        out[row - range.begin] = Box::Around(glm::dvec3(0.0), {radius, radius, 0.0});
+    }
+}
+
+}  // namespace
+
+ERNIE_DEFINE_SCHEMA(LaserLight, "LaserLight", &BoundableLightBase::Definition(), Concrete,
+                    ComputedExtent(LaserExtent),
+                    "A laser along -z: a Gaussian beam and its pattern.",
+                    ERNIE_LASER_LIGHT_ATTRIBUTES,
+                    .fallbackOverrides = {{"ernie:power", 0.001},
+                                          {"ernie:polarization:degree", 0.98}})
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev32/ernie/scene/schemas/laser.h

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file laser.h
+/// @brief Ernie's LaserLight: a Gaussian beam from datasheet parameters, and its diffractive
+/// patterns and sequences.
+#pragma once
+
+#include "ernie/scene/schemas/lux.h"
+
+// clang-format off
+#define ERNIE_LASER_COUNT(X, Name, usdName, fallback, text)                                        \
+    X(int, Name, usdName, fallback, text, .group = "Pattern", .lower = AtLeast(1.0))
+
+#define ERNIE_LASER_LIGHT_ATTRIBUTES(X)                                                            \
+    X(double, Wavelength, "ernie:laser:wavelength", 532.0, "Centre wavelength, nm.",               \
+      .group = "Laser", .lower = Above(0.0), .finite = true)                                       \
+    X(double, Linewidth, "ernie:laser:linewidth", 0.1, "Spectral width (FWHM), nm.",              \
+      .group = "Laser", .lower = AtLeast(0.0), .finite = true)                                     \
+    X(bool, Speckle, "ernie:laser:speckle", false,                                                 \
+      "Grain on rough surfaces, sized by the camera's aperture.", .group = "Laser")                \
+    X(glm::dvec2, WaistRadius, "ernie:laser:waistRadius", glm::dvec2(0.0005),                      \
+      "1/e^2 radius at the waist along x and y, metres.", .group = "Beam", .lower = Above(0.0),    \
+      .finite = true)                                                                              \
+    X(double, WaistDistance, "ernie:laser:waistDistance", 0.0,                                     \
+      "Metres from the aperture along the beam to its waist.", .group = "Beam", .finite = true)    \
+    X(glm::dvec2, BeamQuality, "ernie:laser:beamQuality", glm::dvec2(1.0),                         \
+      "M^2 along x and y: 1 for an ideal beam.", .label = "M^2", .group = "Beam",                  \
+      .lower = AtLeast(1.0), .finite = true)                                                       \
+    X(double, ApertureRadius, "ernie:laser:apertureRadius", 0.0,                                   \
+      "Metres at which the aperture clips the beam's tails; 0 none.", .group = "Beam",             \
+      .lower = AtLeast(0.0), .finite = true)                                                       \
+    X(std::string, Pattern, "ernie:laser:pattern", "spot",                                         \
+      "The beam itself, a line fanned along x, a grid of beamlets, a field of dots, an image, or " \
+      "a scanned Lissajous figure.",                                                               \
+      .group = "Pattern", .options = {"spot", "line", "grid", "dots", "image", "scan"})            \
+    X(double, FanAngle, "ernie:laser:fanAngle", 60.0, "A line's full angle along x, degrees.",     \
+      .group = "Pattern", .lower = Above(0.0), .upper = Below(170.0))                              \
+    X(std::string, LineProfile, "ernie:laser:lineProfile", "flat",                                 \
+      "Along a line: flat (a Powell lens) or Gaussian, 1/e^2 at the fan's edges.",                 \
+      .group = "Pattern", .options = {"flat", "gaussian"})                                         \
+    ERNIE_LASER_COUNT(X, GridColumns, "ernie:laser:gridColumns", 5, "A grid's beamlets along x.")  \
+    ERNIE_LASER_COUNT(X, GridRows, "ernie:laser:gridRows", 5, "A grid's beamlets along y.")        \
+    X(glm::dvec2, GridPitch, "ernie:laser:gridPitch", glm::dvec2(2.0),                             \
+      "Degrees between a grid's beamlets along x and y.", .group = "Pattern", .lower = Above(0.0)) \
+    ERNIE_LASER_COUNT(X, DotColumns, "ernie:laser:dotColumns", 64, "Dots per tile along x.")       \
+    ERNIE_LASER_COUNT(X, DotRows, "ernie:laser:dotRows", 48, "Dots per tile along y.")             \
+    ERNIE_LASER_COUNT(X, DotTileColumns, "ernie:laser:dotTileColumns", 1,                          \
+                      "Tiles of the same dots along x.")                                           \
+    ERNIE_LASER_COUNT(X, DotTileRows, "ernie:laser:dotTileRows", 1,                                \
+                      "Tiles of the same dots along y.")                                           \
+    X(double, DotJitter, "ernie:laser:dotJitter", 0.9,                                             \
+      "How far a dot strays from its cell's centre, in cells: 0 a regular grid, 1 anywhere.",      \
+      .group = "Pattern", .lower = AtLeast(0.0), .upper = AtMost(1.0))                             \
+    X(int, DotSeed, "ernie:laser:dotSeed", 1, "The seed the dots derive from.",                    \
+      .group = "Pattern", .lower = AtLeast(0.0))                                                   \
+    X(glm::dvec2, ScanFrequencies, "ernie:laser:scanFrequencies", glm::dvec2(3.0, 2.0),            \
+      "A scan's Lissajous turns along x and y each period, swept faster than cameras see.",        \
+      .group = "Pattern", .lower = AtLeast(0.0))                                                   \
+    X(double, ScanPhase, "ernie:laser:scanPhase", 90.0, "A scan's phase along x, degrees.",        \
+      .group = "Pattern", .finite = true)                                                          \
+    X(double, Efficiency, "ernie:laser:efficiency", 1.0,                                           \
+      "The fraction of the power that goes into the pattern.", .group = "Pattern",                 \
+      .lower = AtLeast(0.0), .upper = AtMost(1.0))                                                 \
+    X(double, ZeroOrder, "ernie:laser:zeroOrder", 0.0,                                             \
+      "The fraction of the power left in a beam along the axis.", .group = "Pattern",              \
+      .lower = AtLeast(0.0), .upper = AtMost(1.0))                                                 \
+    X(std::string, PatternImage, "ernie:laser:pattern:image", "",                                  \
+      "The image pattern's relative power (linear), its top towards +y.", .group = "Pattern",      \
+      .asset = true)                                                                               \
+    X(Tensor, PatternImageArray, "ernie:laser:pattern:imageArray", Tensor(),                       \
+      "float32 (rows, columns) pattern image in place of the file, on the host or a device.",      \
+      .group = "Pattern", .rank = 2)                                                               \
+    X(glm::dvec2, PatternFieldOfView, "ernie:laser:pattern:fieldOfView", glm::dvec2(40.0, 30.0),   \
+      "Full angles an image, dots or a scan span along x and y, degrees.", .group = "Pattern",     \
+      .lower = AtLeast(0.0), .upper = Below(170.0))                                                \
+    X(int, SequenceCount, "ernie:laser:sequence:count", 1,                                         \
+      "Patterns shown in turn; 1 for one pattern.", .group = "Time", .lower = AtLeast(1.0))        \
+    X(double, SequencePeriod, "ernie:laser:sequence:period", 1.0 / 30.0,                           \
+      "Seconds each pattern of a sequence shows.", .group = "Time", .lower = Above(0.0),           \
+      .finite = true)                                                                              \
+    X(double, SequenceDelay, "ernie:laser:sequence:delay", 0.0,                                    \
+      "Seconds on the sensor clock the first pattern shows.", .group = "Time", .finite = true)
+// clang-format on
+
+namespace ernie {
+
+ERNIE_SCHEMA_ACCESSORS(LaserLight, BoundableLightBase, ERNIE_LASER_LIGHT_ATTRIBUTES);
+
+/// A laser along -z: a Gaussian beam and its pattern. Its power is `ernie:power`, its pulses
+/// LightAPI's, and its extent the emitter, so framing it frames the device.
+class LaserLight : public LaserLightAccessors<LaserLight, BoundableLightBase> {
+    ERNIE_SCHEMA_BODY(LaserLight, BoundableLightBase)
+    ERNIE_SCHEMA_DEFINE(LaserLight)
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev30 → ernie_renderer-0.2.0.dev32}/ernie/scene/schemas/lux.cpp

@@ -36,14 +36,26 @@ glm::dvec3 CylinderHalf(const ExtentRows& rows, std::uint32_t row) {
 
 }  // namespace
 
+// Every light has LightAPI and its light-linking collections built in: which prims it lights and
+// which cast its shadows, everything unless they say otherwise.
+#define ERNIE_LIGHT_BUILTINS                                                                       \
+    .builtinApis = {"LightAPI", "CollectionAPI:lightLink", "CollectionAPI:shadowLink"},            \
+    .fallbackOverrides = {{"collection:lightLink:includeRoot", true},                              \
+                          {"collection:shadowLink:includeRoot", true}}
+
+ERNIE_DEFINE_SCHEMA(LightAPI, "LightAPI", nullptr, SingleApply, kInheritExtent,
+                    "What every light has: brightness, colour, spectrum, polarization and pulses.",
+                    ERNIE_LIGHT_API_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(BoundableLightBase, "BoundableLightBase", &Boundable::Definition(), Abstract,
-                    kInheritExtent, "A light with a shape, bounded by it.", ERNIE_NO_ATTRIBUTES)
+                    kInheritExtent, "A light with a shape, bounded by it.",
+                    ERNIE_BOUNDABLE_LIGHT_BASE_ATTRIBUTES, ERNIE_LIGHT_BUILTINS)
 ERNIE_DEFINE_SCHEMA(NonboundableLightBase, "NonboundableLightBase", &Xformable::Definition(),
                     Abstract, kUnbounded, "A light at infinity or around everything.",
-                    ERNIE_NO_ATTRIBUTES)
+                    ERNIE_NO_ATTRIBUTES, ERNIE_LIGHT_BUILTINS)
 ERNIE_DEFINE_SCHEMA(DistantLight, "DistantLight", &NonboundableLightBase::Definition(), Concrete,
                     kInheritExtent, "A light from infinitely far along +z, such as the Sun's.",
-                    ERNIE_DISTANT_LIGHT_ATTRIBUTES)
+                    ERNIE_DISTANT_LIGHT_ATTRIBUTES,
+                    .fallbackOverrides = {{"inputs:intensity", 50000.0}})
 ERNIE_DEFINE_SCHEMA(DiskLight, "DiskLight", &BoundableLightBase::Definition(), Concrete,
                     ComputedExtent(CentredExtent<DiskHalf>), "A disk emitting towards -z.",
                     ERNIE_DISK_LIGHT_ATTRIBUTES)
@@ -68,5 +80,17 @@ ERNIE_DEFINE_SCHEMA(ShapingAPI, "ShapingAPI", nullptr, SingleApply, kInheritExte
                     ERNIE_SHAPING_API_ATTRIBUTES)
 ERNIE_DEFINE_SCHEMA(ShadowAPI, "ShadowAPI", nullptr, SingleApply, kInheritExtent,
                     "Controls a light's shadows.", ERNIE_SHADOW_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(PhotometricAreaLightAPI, "PhotometricAreaLightAPI", nullptr, SingleApply,
+                    kInheritExtent, "Photometric units for shaped lights: lumens, or lux.",
+                    ERNIE_PHOTOMETRIC_AREA_LIGHT_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(PhotometricDistantLightAPI, "PhotometricDistantLightAPI", nullptr, SingleApply,
+                    kInheritExtent, "Photometric units for distant lights: lux.",
+                    ERNIE_PHOTOMETRIC_DISTANT_LIGHT_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(PhotometricDomeLightAPI, "PhotometricDomeLightAPI", nullptr, SingleApply,
+                    kInheritExtent, "Photometric units for dome lights: lux.",
+                    ERNIE_PHOTOMETRIC_DOME_LIGHT_API_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(PhysicalLightIlluminantAPI, "PhysicalLightIlluminantAPI", nullptr, SingleApply,
+                    kInheritExtent, "The shape of a light's spectrum.",
+                    ERNIE_PHYSICAL_LIGHT_ILLUMINANT_API_ATTRIBUTES)
 
 }  // namespace ernie