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

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

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

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

@@ -16,6 +16,7 @@ add_library(
     schemas/laser.cpp
     schemas/lux.cpp
     schemas/mesh.cpp
+    schemas/planet.cpp
     schemas/registry.cpp
     schemas/shade.cpp
     schemas/vol.cpp

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

@@ -82,10 +82,15 @@ std::string ArrayProblem(const AttributeDef& def, const Tensor& array) {
     if (def.meta.integer ? !integer : !floating) {
         return def.meta.integer ? "must hold integers" : "must hold float32 or float64 numbers";
     }
-    if (def.meta.rank != 0) {
-        return array.Rank() == def.meta.rank
-                   ? std::string()
-                   : "must have " + std::to_string(def.meta.rank) + " dimensions";
+    if (const std::vector<std::int64_t>& ranks = def.meta.ranks; !ranks.empty()) {
+        if (std::ranges::find(ranks, static_cast<std::int64_t>(array.Rank())) != ranks.end()) {
+            return {};
+        }
+        std::string list;
+        for (const std::int64_t rank : ranks) {
+            list += (list.empty() ? "" : " or ") + std::to_string(rank);
+        }
+        return "must have " + list + " dimensions";
     }
     const std::int64_t components = def.meta.components;
     const bool rows =

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

@@ -84,8 +84,8 @@ struct AttributeMeta {
     bool bytes = false;
     /// A tensor's vector size: (n, components) or flat; 0 for a flat array.
     std::uint8_t components = 0;
-    /// A tensor's fixed rank, as a dense grid's 3; 0 for flat or vector arrays.
-    std::uint8_t rank = 0;
+    /// The ranks a tensor may have, as a dense grid's 3; none for flat or vector arrays.
+    std::vector<std::int64_t> ranks{};
     Dirty dirty = Dirty::Params;
     /// Resolved from the nearest authoring ancestor.
     bool inherited = false;

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

@@ -88,7 +88,7 @@
     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)                                                                  \
+      .group = "Lens", .ranks = {3})                                                               \
     X(int, LensRaysStep, "ernie:lens:raysStep", 8, "Pixels between the lens's rays.",              \
       .group = "Lens", .lower = AtLeast(1.0))
 

{ernie_renderer-0.2.0.dev32 → ernie_renderer-0.2.0.dev35}/ernie/scene/schemas/laser.h

@@ -68,7 +68,7 @@
       .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)                                                               \
+      .group = "Pattern", .ranks = {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))                                                \

{ernie_renderer-0.2.0.dev32 → ernie_renderer-0.2.0.dev35}/ernie/scene/schemas/lux.h

@@ -29,10 +29,6 @@
       "Tints it by its colour temperature too.", .group = "Light")                                 \
     X(double, ColorTemperature, "inputs:colorTemperature", 6500.0, "Kelvin, a black body's.",      \
       .group = "Light", .lower = Above(0.0), .finite = true)                                       \
-    X(std::vector<float>, Spectrum, "ernie:spectrum", std::vector<float>{},                        \
-      "(nm, value) pairs of a physical spectrum: W m^-2 nm^-1 for a distant light, W sr^-1 nm^-1 " \
-      "for a sphere, W m^-2 sr^-1 nm^-1 for a rect, disk or dome.",                                \
-      .group = "Spectrum")                                                                         \
     X(double, PolarizationDegree, "ernie:polarization:degree", 0.0,                                \
       "The fraction of its light linearly polarized.", .label = "Polarized",                       \
       .group = "Polarization", .lower = AtLeast(0.0), .upper = AtMost(1.0))                        \
@@ -58,15 +54,16 @@
 
 #define ERNIE_BOUNDABLE_LIGHT_BASE_ATTRIBUTES(X)                                                   \
     X(double, Power, "ernie:power", 0.0,                                                           \
-      "Radiant flux in watts over 360 to 830 nm, in place of the intensity when set.",             \
+      "Radiant flux in watts, scaling the illuminant's spectral shape; authored, it sets the "     \
+      "brightness unless photometric values are authored.",                                        \
       .group = "Light", .lower = AtLeast(0.0), .finite = true)
 
 #define ERNIE_DISTANT_LIGHT_ATTRIBUTES(X)                                                          \
     X(double, Angle, "inputs:angle", 0.53, "Angular diameter in degrees; the Sun's is 0.53.",      \
       .group = "Light", .lower = AtLeast(0.0), .upper = AtMost(360.0))                             \
     X(double, Irradiance, "ernie:irradiance", 1361.0,                                              \
-      "W m^-2 at normal incidence, the Sun's at 1 au; authored, or with a spectrum, the light is " \
-      "physical.",                                                                                 \
+      "W m^-2 at normal incidence (the Sun's at 1 au), scaling the illuminant's spectral shape; "  \
+      "authored, it sets the brightness unless photometric values are authored.",                 \
       .group = "Light", .lower = AtLeast(0.0), .finite = true)
 
 #define ERNIE_DISK_LIGHT_ATTRIBUTES(X)                                                             \
@@ -99,7 +96,7 @@
     X(Tensor, Texture, "ernie:texture", Tensor(),                                                  \
       "float32 (rows, columns, 3 or 4) linear RGB in memory, latitude-longitude about +z, in "     \
       "place of the file.",                                                                        \
-      .group = "Light", .rank = 3)                                                                 \
+      .group = "Light", .ranks = {3})                                                              \
     X(std::vector<Path>, Portals, "portals", std::vector<Path>{},                                  \
       "Portal lights its light enters through.", .group = "Light")                                 \
     X(double, GuideRadius, "guideRadius", 1.0e5, "Metres to the sphere drawn as its guide.",       \
@@ -125,8 +122,9 @@
     X(bool, ShapingIesNormalize, "inputs:shaping:ies:normalize", false,                            \
       "Keeps the profile from changing the light's power.", .group = "Shaping")
 
-// Omniverse's photometric and illuminant schemas (omni.usd.schema.physical_lighting). Authoring any
-// photometric value puts the light in photometric units, which alone then set its brightness.
+// Omniverse's photometric and illuminant schemas (omni.usd.schema.physical_lighting). A light's
+// spectral shape comes from its illuminant alone; its brightness from authored photometric values,
+// else authored ernie:irradiance or ernie:power, else USD's intensity and exposure.
 #define ERNIE_PHOTOMETRIC_SWITCH " Authored, it alone sets the light's brightness."
 
 #define ERNIE_PHOTOMETRIC_AREA_LIGHT_API_ATTRIBUTES(X)                                             \

ernie_renderer-0.2.0.dev35/ernie/scene/schemas/planet.cpp

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file planet.cpp
+/// @brief The planetary prims' registry entries and extents: terrains from their heights and
+/// bodies, atmospheres from their bodies and tops.
+#include "ernie/scene/schemas/planet.h"
+
+#include <algorithm>
+#include <optional>
+#include <vector>
+
+namespace ernie {
+namespace {
+
+/// @return The body a row's relationship names, its extent brought into the row's own space; none
+/// when it names none.
+std::optional<Box> BodyInOwnSpace(const ExtentRows& rows, std::string_view relationship,
+                                  std::uint32_t row) {
+    const Target target = rows.Column<Target>(relationship)[row];
+    const std::optional<PrimId> body =
+        target.path != kNoPath ? rows.store.Find(target.path) : std::nullopt;
+    const std::optional<Box> extent = body ? rows.scene->Extent(*body) : std::nullopt;
+    if (!extent) {
+        return std::nullopt;
+    }
+    const PrimId own = rows.store.GetBucket(rows.bucket).prims[row];
+    return extent->Transformed(glm::inverse(rows.scene->WorldTransform(own)) *
+                               rows.scene->WorldTransform(*body));
+}
+
+/// @return The lowest and highest of a host array's heights; none on a device or when empty.
+std::optional<std::pair<double, double>> HeightRange(const Tensor& heights) {
+    if (heights.Empty() || IsGpu(heights.Location().kind)) {
+        return std::nullopt;
+    }
+    const std::vector<float> values = CopyFloats(heights, "heights");
+    const auto [low, high] = std::ranges::minmax_element(values);
+    return std::pair<double, double>(*low, *high);
+}
+
+/// A plane's footprint: x east from the origin, y south from it, a cell between heights.
+Box PlaneFootprint(const Tensor& heights, glm::dvec2 origin, double cell, double low, double high) {
+    const double rows = static_cast<double>(heights.Shape()[0]);
+    const double columns = static_cast<double>(heights.Shape()[1]);
+    return {{origin.x, origin.y - (rows - 1.0) * cell, low},
+            {origin.x + (columns - 1.0) * cell, origin.y, high}};
+}
+
+void TerrainExtent(const ExtentRows& rows, RowRange range, std::span<Box> out) {
+    const auto heights = rows.Column<Tensor>(Terrain::kHeights);
+    const auto origin = rows.Column<glm::dvec2>(Terrain::kOrigin);
+    const auto cell = rows.Column<double>(Terrain::kCellSize);
+    const auto exaggeration = rows.Column<double>(Terrain::kExaggeration);
+    const auto authored = rows.Column<std::vector<float>>(Boundable::kExtent);
+    for (std::uint32_t row = range.begin; row < range.end; ++row) {
+        const std::optional<std::pair<double, double>> span = HeightRange(heights[row]);
+        const double low = span ? span->first * exaggeration[row] : 0.0;
+        const double high = span ? span->second * exaggeration[row] : 0.0;
+        Box& box = out[row - range.begin];
+        if (const std::optional<Box> body = BodyInOwnSpace(rows, Terrain::kBody, row)) {
+            box = body->Grown(std::max(high, 0.0));
+        } else if (span && heights[row].Rank() == 2) {
+            box = PlaneFootprint(heights[row], origin[row], cell[row], low, high);
+        } else {
+            box = AuthoredExtent(authored[row]);
+        }
+    }
+}
+
+void AtmosphereExtent(const ExtentRows& rows, RowRange range, std::span<Box> out) {
+    const auto top = rows.Column<double>(Atmosphere::kTop);
+    for (std::uint32_t row = range.begin; row < range.end; ++row) {
+        const std::optional<Box> body = BodyInOwnSpace(rows, Atmosphere::kBody, row);
+        out[row - range.begin] = body ? body->Grown(top[row]) : Box();
+    }
+}
+
+}  // namespace
+
+ERNIE_DEFINE_SCHEMA(Terrain, "Terrain", &Gprim::Definition(), Concrete,
+                    ComputedFromOtherPrims(TerrainExtent),
+                    "Heights displacing a body's surface, or a plane.", ERNIE_TERRAIN_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Atmosphere, "Atmosphere", &Xformable::Definition(), Concrete,
+                    ComputedFromOtherPrims(AtmosphereExtent),
+                    "The air around a body: its constituents, haze and clouds.",
+                    ERNIE_ATMOSPHERE_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(StarField, "StarField", &NonboundableLightBase::Definition(), Concrete,
+                    kInheritExtent, "The stars, from a catalogue or arrays, at infinity.",
+                    ERNIE_STAR_FIELD_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(GroundPlane, "GroundPlane", &Gprim::Definition(), Concrete, kUnbounded,
+                    "An infinite plane in its xy plane, facing +z.", ERNIE_GROUND_PLANE_ATTRIBUTES)
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev35/ernie/scene/schemas/planet.h

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file planet.h
+/// @brief Ernie's planetary prims: terrains on bodies or planes, atmospheres around bodies, star
+/// fields and ground planes. A body is any Sphere, an ellipsoid when scaled unevenly.
+#pragma once
+
+#include "ernie/physics/astronomy.h"
+#include "ernie/scene/schemas/lux.h"
+
+// clang-format off
+#define ERNIE_TERRAIN_ATTRIBUTES(X)                                                                \
+    X(Path, Body, "ernie:terrain:body", Path(),                                                    \
+      "The Sphere whose surface the heights displace, along its geodetic normals; unset, a plane " \
+      "in the terrain's xy plane.",                                                                \
+      .group = "Terrain", .dirty = Dirty::Topology)                                                \
+    X(Tensor, Heights, "ernie:terrain:heights", Tensor(),                                          \
+      "float32 (rows, columns) heights in metres, the first row the northern; on a body, "         \
+      "(6, n + 1, n + 1) cube faces.",                                                             \
+      .group = "Terrain", .ranks = {2, 3}, .dirty = Dirty::Points)                                 \
+    X(std::string, HeightsFile, "ernie:terrain:heights:file", "",                                  \
+      "Heights as a raster (TIFF, PDS3, PNG or JPEG) in place of the array, paged as views need "  \
+      "them.",                                                                                     \
+      .group = "Terrain", .asset = true, .dirty = Dirty::Points)                                   \
+    X(double, HeightsUnit, "ernie:terrain:heights:unit", 1.0,                                      \
+      "Metres in a unit of the file's values: 1000 for kilometres.", .group = "Terrain",           \
+      .lower = Above(0.0), .dirty = Dirty::Points)                                                 \
+    X(double, HeightsReference, "ernie:terrain:heights:reference", 0.0,                            \
+      "Metres subtracted from the file's values: the radius, for files of radii.",                 \
+      .group = "Terrain", .finite = true, .dirty = Dirty::Points)                                  \
+    X(double, NoData, "ernie:terrain:noData", 0.0,                                                 \
+      "The height marking missing cells; unauthored, every cell is a height.", .group = "Terrain") \
+    X(glm::dvec2, Origin, "ernie:terrain:origin", glm::dvec2(0.0),                                 \
+      "A plane's north-west corner in its x and y, metres.", .group = "Terrain", .finite = true)   \
+    X(double, CellSize, "ernie:terrain:cellSize", 1.0, "Metres between a plane's heights.",        \
+      .group = "Terrain", .lower = Above(0.0), .finite = true)                                     \
+    X(double, Exaggeration, "ernie:terrain:exaggeration", 1.0, "Scales the heights as drawn.",     \
+      .group = "Terrain", .lower = AtLeast(0.0), .finite = true)                                   \
+    X(double, FinestCell, "ernie:terrain:finestCell", 1.0,                                         \
+      "Metres: a body's LOD refines below its heights, bilinearly, to quads this size; 0 stops at " \
+      "the heights'.",                                                                             \
+      .group = "Terrain", .lower = AtLeast(0.0))                                                   \
+    X(std::string, ColorMode, "ernie:terrain:colorMode", "shaded",                                 \
+      "shaded: its material, lit; colormap: a height ramp, unlit; shadedColormap: both; "          \
+      "hillshade: a GIS hillshade, grey and unlit.",                                               \
+      .group = "Display", .options = {"shaded", "colormap", "shadedColormap", "hillshade"})        \
+    X(double, HillshadeAzimuth, "ernie:terrain:hillshade:azimuth", 315.0,                          \
+      "Degrees clockwise from north of the hillshade's light; GIS's 315, from the north-west.",    \
+      .group = "Display", .lower = AtLeast(0.0), .upper = AtMost(360.0))                           \
+    X(double, HillshadeAltitude, "ernie:terrain:hillshade:altitude", 45.0,                         \
+      "Degrees above the horizon of the hillshade's light.", .group = "Display",                   \
+      .lower = AtLeast(0.0), .upper = AtMost(90.0))
+
+#define ERNIE_ATMOSPHERE_COLUMN(X, Name, usdName, fallback, text)                                  \
+    X(double, Name, usdName, fallback, text, .group = "Atmosphere", .lower = AtLeast(0.0),         \
+      .finite = true)
+
+#define ERNIE_ATMOSPHERE_ATTRIBUTES(X)                                                             \
+    X(Path, Body, "ernie:atmosphere:body", Path(), "The Sphere it surrounds.",                     \
+      .group = "Atmosphere", .dirty = Dirty::Topology)                                             \
+    X(std::string, Preset, "ernie:atmosphere:preset", "earth",                                     \
+      "Its physical model: Earth's air, ozone and haze, or Mars's carbon dioxide and dust.",       \
+      .group = "Atmosphere", .options = {"earth", "mars"})                                         \
+    ERNIE_ATMOSPHERE_COLUMN(X, Top, "ernie:atmosphere:top", 100000.0,                              \
+                            "Metres above the surface it reaches; Earth's 100 km.")                \
+    X(double, GroundAlbedo, "ernie:atmosphere:groundAlbedo", 0.3,                                  \
+      "The ground's reflectance for light scattered in the air.", .group = "Atmosphere",           \
+      .lower = AtLeast(0.0), .upper = AtMost(1.0))                                                 \
+    ERNIE_ATMOSPHERE_COLUMN(X, HazeOpticalDepth, "ernie:atmosphere:hazeOpticalDepth", 0.1,         \
+                            "Earth: the haze's vertical optical depth at 550 nm.")                 \
+    ERNIE_ATMOSPHERE_COLUMN(X, OzoneColumn, "ernie:atmosphere:ozoneColumn", 300.0,                 \
+                            "Earth: total column ozone, Dobson units.")                            \
+    ERNIE_ATMOSPHERE_COLUMN(X, SodiumColumn, "ernie:atmosphere:sodiumColumn", 4e13,                \
+                            "Earth: mesospheric sodium atoms per square metre, lit 92 km up by a " \
+                            "589 nm laser as a guide star.")                                       \
+    ERNIE_ATMOSPHERE_COLUMN(X, DustOpticalDepth, "ernie:atmosphere:dustOpticalDepth", 0.5,         \
+                            "Mars: the dust's vertical optical depth at 880 nm.")                  \
+    ERNIE_ATMOSPHERE_COLUMN(X, CloudTop, "ernie:atmosphere:cloudTop", 0.0,                         \
+                            "Metres below which clouds block light grazing the limb, darkening "   \
+                            "its shadow as in a lunar eclipse; 0 clear.")                          \
+    X(double, CloudCover, "ernie:atmosphere:cloudCover", 0.5,                                      \
+      "The fraction of the limb the clouds cover.", .group = "Atmosphere", .lower = AtLeast(0.0),  \
+      .upper = AtMost(1.0))                                                                        \
+    X(double, PolarizationDegree, "ernie:polarization:degree", 0.75,                               \
+      "The sky's greatest degree of linear polarization, 90 degrees from the sun.",                \
+      .label = "Sky polarization", .group = "Atmosphere", .lower = AtLeast(0.0),                   \
+      .upper = AtMost(1.0))
+
+#define ERNIE_STAR_FIELD_ATTRIBUTES(X)                                                             \
+    X(double, MagnitudeLimit, "ernie:stars:magnitudeLimit", 99.0,                                  \
+      "Stars fainter than this are left out.", .group = "Stars", .finite = true)                   \
+    X(double, ZeroPoint, "ernie:stars:zeroPoint", kMagnitudeZeroLux,                               \
+      "Lux of a magnitude 0 star (Allen's Astrophysical Quantities).", .group = "Stars",           \
+      .lower = Above(0.0))                                                                         \
+    X(Tensor, Magnitude, "ernie:stars:magnitude", Tensor(),                                        \
+      "float32 (stars): apparent visual (Johnson V) magnitudes.", .group = "Stars")                \
+    X(Tensor, RightAscension, "ernie:stars:rightAscension", Tensor(),                              \
+      "float32 (stars), degrees, in the catalogue's frame.", .group = "Stars")                     \
+    X(Tensor, Declination, "ernie:stars:declination", Tensor(),                                    \
+      "float32 (stars), degrees, in the catalogue's frame.", .group = "Stars")                     \
+    X(Tensor, Direction, "ernie:stars:direction", Tensor(),                                        \
+      "float32 (stars, 3) unit directions in its own space, in place of right ascension and "      \
+      "declination.",                                                                              \
+      .group = "Stars", .components = 3)                                                           \
+    X(Tensor, ColorIndex, "ernie:stars:colorIndex", Tensor(),                                      \
+      "float32 (stars): B-V colour indices, giving each star's temperature.", .group = "Stars")    \
+    X(Tensor, Temperature, "ernie:stars:temperature", Tensor(),                                    \
+      "float32 (stars) kelvin, in place of the colour indices; without either, the Sun's 5772 K.", \
+      .group = "Stars")
+
+#define ERNIE_GROUND_PLANE_ATTRIBUTES(X)                                                           \
+    X(bool, Checker, "ernie:checker", false, "Multiplies its material's albedo by checker squares.", \
+      .group = "Ground")                                                                           \
+    X(double, CheckerSize, "ernie:checker:size", 1.0, "Metres along a square's edge.",             \
+      .group = "Ground", .lower = Above(0.0), .finite = true)                                      \
+    X(glm::dvec3, CheckerColor0, "ernie:checker:color0", glm::dvec3(1.0), "Linear RGB.",           \
+      .group = "Ground", .lower = AtLeast(0.0), .color = true)                                     \
+    X(glm::dvec3, CheckerColor1, "ernie:checker:color1", glm::dvec3(0.5), "Linear RGB.",           \
+      .group = "Ground", .lower = AtLeast(0.0), .color = true)
+// clang-format on
+
+namespace ernie {
+
+ERNIE_SCHEMA_ACCESSORS(Terrain, Gprim, ERNIE_TERRAIN_ATTRIBUTES);
+ERNIE_SCHEMA_ACCESSORS(Atmosphere, Xformable, ERNIE_ATMOSPHERE_ATTRIBUTES);
+ERNIE_SCHEMA_ACCESSORS(StarField, NonboundableLightBase, ERNIE_STAR_FIELD_ATTRIBUTES);
+ERNIE_SCHEMA_ACCESSORS(GroundPlane, Gprim, ERNIE_GROUND_PLANE_ATTRIBUTES);
+
+/// Heights displacing a body's surface, or a plane.
+class Terrain : public TerrainAccessors<Terrain, Gprim> {
+    ERNIE_SCHEMA_BODY(Terrain, Gprim)
+    ERNIE_SCHEMA_DEFINE(Terrain)
+};
+
+/// The air around a body: its constituents, haze and clouds.
+class Atmosphere : public AtmosphereAccessors<Atmosphere, Xformable> {
+    ERNIE_SCHEMA_BODY(Atmosphere, Xformable)
+    ERNIE_SCHEMA_DEFINE(Atmosphere)
+};
+
+/// The stars, from a catalogue or arrays, at infinity: a light, unbounded.
+class StarField : public StarFieldAccessors<StarField, NonboundableLightBase> {
+    ERNIE_SCHEMA_BODY(StarField, NonboundableLightBase)
+    ERNIE_SCHEMA_DEFINE(StarField)
+};
+
+/// An infinite plane in its xy plane, facing +z.
+class GroundPlane : public GroundPlaneAccessors<GroundPlane, Gprim> {
+    ERNIE_SCHEMA_BODY(GroundPlane, Gprim)
+    ERNIE_SCHEMA_DEFINE(GroundPlane)
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev32 → ernie_renderer-0.2.0.dev35}/ernie/scene/schemas/registry.cpp

@@ -8,6 +8,7 @@
 #include "ernie/scene/schemas/laser.h"
 #include "ernie/scene/schemas/lux.h"
 #include "ernie/scene/schemas/mesh.h"
+#include "ernie/scene/schemas/planet.h"
 #include "ernie/scene/schemas/shade.h"
 #include "ernie/scene/schemas/vol.h"
 
@@ -52,12 +53,19 @@ std::span<const SchemaDef* const> Schemas() {
         &DomeLight::Definition(),
         &PortalLight::Definition(),
         &LaserLight::Definition(),
+        &Terrain::Definition(),
+        &Atmosphere::Definition(),
+        &StarField::Definition(),
+        &GroundPlane::Definition(),
         &ShapingAPI::Definition(),
         &ShadowAPI::Definition(),
         &PhotometricAreaLightAPI::Definition(),
         &PhotometricDistantLightAPI::Definition(),
         &PhotometricDomeLightAPI::Definition(),
         &PhysicalLightIlluminantAPI::Definition(),
+        &NodeGraph::Definition(),
+        &Material::Definition(),
+        &Shader::Definition(),
         &CollectionAPI::Definition(),
         &MaterialBindingAPI::Definition(),
     };

ernie_renderer-0.2.0.dev35/ernie/scene/schemas/shade.cpp

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file shade.cpp
+/// @brief UsdShade's registry entries and connections.
+#include "ernie/scene/schemas/shade.h"
+
+#include <stdexcept>
+
+namespace ernie {
+namespace {
+
+constexpr std::string_view kConnect = ".connect";
+
+/// Inputs and outputs are open on every connectable prim, as UsdShadeConnectableAPI makes them.
+#define ERNIE_CONNECTABLE .openNamespaces = {"inputs:", "outputs:"}
+
+std::string ConnectionAttribute(std::string_view input) {
+    return std::string(input) + std::string(kConnect);
+}
+
+}  // namespace
+
+ERNIE_DEFINE_SCHEMA(MaterialBindingAPI, "MaterialBindingAPI", nullptr, SingleApply, kInheritExtent,
+                    "Binds a material to a prim and its descendants.",
+                    ERNIE_MATERIAL_BINDING_API_ATTRIBUTES, .openNamespaces = {"material:binding:"})
+ERNIE_DEFINE_SCHEMA(NodeGraph, "NodeGraph", nullptr, Concrete, kNoExtent,
+                    "A network of shaders with the inputs its users set.", ERNIE_NO_ATTRIBUTES,
+                    ERNIE_CONNECTABLE)
+ERNIE_DEFINE_SCHEMA(Material, "Material", &NodeGraph::Definition(), Concrete, kInheritExtent,
+                    "What prims are drawn with: its terminals connect to the shaders computing "
+                    "them.",
+                    ERNIE_NO_ATTRIBUTES)
+ERNIE_DEFINE_SCHEMA(Shader, "Shader", nullptr, Concrete, kNoExtent,
+                    "One node of a network, a model or a texture, by its info:id.",
+                    ERNIE_SHADER_ATTRIBUTES, ERNIE_CONNECTABLE)
+
+void Connect(Scene& scene, const Path& path, std::string_view input, const Connection& source) {
+    scene.Set(path, ConnectionAttribute(input), source.prim.String() + "." + source.output);
+}
+
+std::optional<Connection> FindConnection(const Scene& scene, const Path& path,
+                                         std::string_view input) {
+    const std::optional<Value> value = scene.Get(path, ConnectionAttribute(input));
+    if (!value) {
+        return std::nullopt;
+    }
+    const std::string& text = *value->Get<std::string>();
+    const std::size_t dot =
+        text.find('.', text.rfind('/') == std::string::npos ? 0 : text.rfind('/'));
+    if (dot == std::string::npos || dot + 1 == text.size()) {
+        throw std::invalid_argument("'" + path.String() + "': " + ConnectionAttribute(input) +
+                                    " must be a prim path, a dot and a property, not '" + text +
+                                    "'");
+    }
+    return Connection{Path(text.substr(0, dot)), text.substr(dot + 1)};
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev35/ernie/scene/schemas/shade.h

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file shade.h
+/// @brief UsdShade's schemas.
+///
+/// References:
+/// - Pixar, UsdShade, https://openusd.org/release/api/usd_shade_page_front.html
+#pragma once
+
+#include "ernie/scene/view.h"
+
+#include <optional>
+#include <string>
+#include <string_view>
+
+// clang-format off
+#define ERNIE_MATERIAL_BINDING_API_ATTRIBUTES(X)                                                   \
+    X(Path, MaterialBinding, "material:binding", Path(),                                           \
+      "The Material the prim and its descendants are drawn with.", .label = "Material",            \
+      .group = "Material", .dirty = Dirty::Material)
+
+#define ERNIE_SHADER_ATTRIBUTES(X)                                                                 \
+    X(std::string, Id, "info:id", "",                                                              \
+      "The node it is: UsdPreviewSurface, UsdUVTexture, a primvar reader or an Ernie model.",      \
+      .group = "Shader", .dirty = Dirty::Material)                                                 \
+    X(std::string, ImplementationSource, "info:implementationSource", "id",                        \
+      "Where its definition comes from: its id, a source asset or source code.",                   \
+      .group = "Shader", .options = {"id", "sourceAsset", "sourceCode"}, .dirty = Dirty::Material) \
+    X(std::string, SourceAsset, "info:sourceAsset", "", "A file defining it, as a MaterialX one.", \
+      .group = "Shader", .asset = true, .dirty = Dirty::Material)                                  \
+    X(std::string, SourceCode, "info:sourceCode", "", "Code defining it, as a Slang model's.",     \
+      .group = "Shader", .dirty = Dirty::Material)
+// clang-format on
+
+namespace ernie {
+
+ERNIE_SCHEMA_ACCESSORS(MaterialBindingAPI, SchemaView, ERNIE_MATERIAL_BINDING_API_ATTRIBUTES);
+ERNIE_SCHEMA_ACCESSORS(NodeGraph, SchemaView, ERNIE_NO_ATTRIBUTES);
+ERNIE_SCHEMA_ACCESSORS(Material, NodeGraph, ERNIE_NO_ATTRIBUTES);
+ERNIE_SCHEMA_ACCESSORS(Shader, SchemaView, ERNIE_SHADER_ATTRIBUTES);
+
+/// Binds a material to a prim; `material:binding:<purpose>` binds one for a purpose.
+class MaterialBindingAPI : public MaterialBindingAPIAccessors<MaterialBindingAPI, SchemaView> {
+    ERNIE_API_SCHEMA_BODY(MaterialBindingAPI)
+};
+
+/// A network of shaders with `inputs:` its users set and `outputs:` connected inside it.
+class NodeGraph : public NodeGraphAccessors<NodeGraph, SchemaView> {
+    ERNIE_SCHEMA_BODY(NodeGraph, SchemaView)
+    ERNIE_SCHEMA_DEFINE(NodeGraph)
+};
+
+/// What prims are drawn with: its terminals `outputs:surface`, `outputs:displacement` and
+/// `outputs:volume`, and Ernie's `outputs:ernie:thermal`, `outputs:ernie:lidar` and
+/// `outputs:ernie:radar`, connect to the shaders that compute them.
+class Material : public MaterialAccessors<Material, NodeGraph> {
+    ERNIE_SCHEMA_BODY(Material, NodeGraph)
+    ERNIE_SCHEMA_DEFINE(Material)
+};
+
+/// One node of a network: a model or a texture, by its `info:id`, with its `inputs:` and
+/// `outputs:`.
+class Shader : public ShaderAccessors<Shader, SchemaView> {
+    ERNIE_SCHEMA_BODY(Shader, SchemaView)
+    ERNIE_SCHEMA_DEFINE(Shader)
+};
+
+/// @brief The source of a connection: a shader or graph and one of its outputs.
+struct Connection {
+    Path prim;
+    std::string output;
+    bool operator==(const Connection&) const = default;
+};
+
+/// @brief Connects an input or output of a Material, NodeGraph or Shader to another's output, as
+/// USD's `<input>.connect` holds it: `/Looks/Red/Surface.outputs:surface`.
+void Connect(Scene& scene, const Path& path, std::string_view input, const Connection& source);
+/// @return The input's connection, or none.
+/// @throws std::invalid_argument if its text is not a prim path, a dot and a property name.
+std::optional<Connection> FindConnection(const Scene& scene, const Path& path,
+                                         std::string_view input);
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev32 → ernie_renderer-0.2.0.dev35}/ernie/scene/schemas/vol.h

@@ -40,7 +40,7 @@
 #define ERNIE_DENSE_FIELD_ATTRIBUTES(X)                                                            \
     X(Tensor, Values, "ernie:values", Tensor(),                                                    \
       "float32 (x, y, z) values, z fastest, on the host or a device; 0 is empty.",                 \
-      .group = "Field", .rank = 3, .dirty = Dirty::Points)                                         \
+      .group = "Field", .ranks = {3}, .dirty = Dirty::Points)                                      \
     X(double, VoxelSize, "ernie:voxelSize", 1.0,                                                   \
       "Metres between values: value (i, j, k) lies at the voxel size times (i, j, k).",            \
       .group = "Field", .lower = Above(0.0), .finite = true, .dirty = Dirty::Points)

{ernie_renderer-0.2.0.dev32 → ernie_renderer-0.2.0.dev35}/tests/CMakeLists.txt

@@ -61,8 +61,10 @@ ernie_add_test_suite(
         scene/lux_test.cpp
         scene/mesh_test.cpp
         scene/path_test.cpp
+        scene/planet_test.cpp
         scene/scene_test.cpp
         scene/schema_test.cpp
+        scene/shade_test.cpp
         scene/storage_test.cpp
         scene/vol_test.cpp
         scene/xform_test.cpp

{ernie_renderer-0.2.0.dev32 → ernie_renderer-0.2.0.dev35}/tests/scene/lux_test.cpp

@@ -82,10 +82,12 @@ TEST(Lights, ErnieAttributesSitBesideUsdLuxs) {
     Scene scene;
     SphereLight strobe = SphereLight::Define(scene, "/Strobe");
     strobe.SetPulseRate(30.0).SetPulseTrigger(PulseTrigger::Exposure).SetPower(100.0);
-    strobe.SetSpectrum({400.0f, 1.0f, 700.0f, 0.5f});
+    PhysicalLightIlluminantAPI::Apply(scene, "/Strobe")
+        .SetPhysicalIlluminant("custom")
+        .SetPhysicalCustomIlluminant({400.0f, 1.0f, 700.0f, 0.5f});
     EXPECT_EQ(scene.Get(strobe.Id(), "ernie:pulse:trigger"), Value("exposure"));
-    EXPECT_EQ(scene.Get(strobe.Id(), "ernie:power"), Value(100.0));
-    EXPECT_EQ(strobe.GetSpectrum().size(), 4u);
+    EXPECT_EQ(scene.Get(strobe.Id(), "ernie:power"), Value(100.0)) << "the scale of that shape";
+    EXPECT_FALSE(scene.Get(strobe.Id(), "ernie:spectrum")) << "shape comes from the illuminant";
     EXPECT_EQ(DistantLight::Define(scene, "/Sun").GetIrradiance(), 1361.0);
     EXPECT_THROW(strobe.SetPolarizationDegree(2.0), std::invalid_argument);
 }