ernie-renderer 0.1.0.dev266__tar.gz → 0.1.0.dev309__tar.gz

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/.github/workflows/ci.yml

@@ -155,6 +155,13 @@ jobs:
           include-hidden-files: true
           if-no-files-found: ignore
           retention-days: 30
+      # The data the demos fetch (LOLA's terrain and the like) into their
+      # cache, kept between runs rather than downloaded by each.
+      - uses: actions/cache@v6
+        with:
+          path: ~/.cache/ernie
+          key: demo-data-${{ hashFiles('demos/**') }}
+          restore-keys: demo-data-
       - name: Test on lavapipe
         run: |
           VK_DRIVER_FILES=$(find /usr/share/vulkan/icd.d -name 'lvp_icd*.json' | head -n1)
@@ -483,7 +490,7 @@ jobs:
         run: |
           dnf install -y -q --enablerepo=crb libX11-devel libXrandr-devel libXinerama-devel \
             libXcursor-devel libXi-devel libXext-devel wayland-devel wayland-protocols-devel \
-            libxkbcommon-devel rpm-build
+            libxkbcommon-devel libcurl-devel rpm-build
           dnf install -y -q epel-release
           dnf install -y -q ccache
           command -v ninja >/dev/null || pipx install -q ninja
@@ -507,6 +514,9 @@ jobs:
             cpack --preset package-$kind
           done
           ccache --show-stats
+          # rpmbuild finds the libraries the binaries link, libcurl
+          # among them.
+          rpm -qpR build/package-rpm/packages/*.rpm | grep -F libcurl.so
           mkdir packages
           cp build/package-deb/packages/*.deb build/package-deb/packages/*.tar.gz \
             build/package-rpm/packages/*.rpm packages/
@@ -531,29 +541,42 @@ jobs:
         include:
           - image: ubuntu:22.04
             install: apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq
-            packages: ./packages/*.deb mesa-vulkan-drivers cmake g++ make
+            packages: ./packages/*.deb
+            tools: mesa-vulkan-drivers cmake g++ make
           - image: ubuntu:24.04
             install: apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq
-            packages: ./packages/*.deb mesa-vulkan-drivers cmake g++ make
+            packages: ./packages/*.deb
+            tools: mesa-vulkan-drivers cmake g++ make
           - image: debian:12
             install: apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq
-            packages: ./packages/*.deb mesa-vulkan-drivers cmake g++ make
+            packages: ./packages/*.deb
+            tools: mesa-vulkan-drivers cmake g++ make
           - image: rockylinux:9
             install: dnf install -y -q
-            packages: ./packages/*.rpm mesa-vulkan-drivers cmake gcc-c++ make
+            packages: ./packages/*.rpm
+            tools: mesa-vulkan-drivers cmake gcc-c++ make
           - image: fedora:latest
             install: dnf install -y -q
-            packages: ./packages/*.rpm mesa-vulkan-drivers cmake gcc-c++ make
+            packages: ./packages/*.rpm
+            tools: mesa-vulkan-drivers cmake gcc-c++ make
     steps:
       - uses: actions/checkout@v7
       - uses: actions/download-artifact@v8
         with:
           name: packages-linux-x86_64
           path: packages
+      # Ernie's packages alone first, so the program runs on what they
+      # pull in themselves (the build tools bring libcurl, for one).
       - name: Install the packages
         run: ${{ matrix.install }} ${{ matrix.packages }}
       - name: Run the viewer
-        run: ernie --version
+        run: |
+          if ldd "$(command -v ernie)" | grep "not found"; then
+            exit 1
+          fi
+          ernie --version
+      - name: Install the build tools
+        run: ${{ matrix.install }} ${{ matrix.tools }}
       - name: Build and run an application against them
         run: |
           cmake -S ernie/test/install -B consumer -DCMAKE_BUILD_TYPE=Release

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/CMakeLists.txt

@@ -17,7 +17,7 @@ project(
 # reads it here too (pyproject.toml), and the packages turn it into "~dev12".
 # One line, as CI rewrites it and the wheel's version regex reads it.
 # cmake-format: off
-set(ERNIE_VERSION_SUFFIX ".dev266" CACHE STRING "Pre-release suffix of Ernie's version, such as .dev12")
+set(ERNIE_VERSION_SUFFIX ".dev309" CACHE STRING "Pre-release suffix of Ernie's version, such as .dev12")
 # cmake-format: on
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
@@ -136,6 +136,12 @@ endif()
 
 add_subdirectory(ernie)
 
+# The demos' libcurl, found before the packaging so the packages can
+# depend on it.
+if(TARGET ernie_app)
+    include(cmake/third_party/curl.cmake)
+endif()
+
 if(ERNIE_INSTALL)
     include(cmake/ErnieInstall.cmake)
     include(cmake/ErniePackaging.cmake)

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/CONTRIBUTING.md

@@ -81,7 +81,7 @@ Packages: `cmake --preset package-deb` (or `package-rpm`), then `cmake --build -
 - Each module in `ernie/` is a library that depends only on the modules before it (see `ernie/CMakeLists.txt`). Headers sit next to their sources and are included as `"ernie/<module>/<file>.h"`.
 - Document public API with `///` comments. When code implements a published technique, cite it in a `References:` list in the doc comment.
 - Scene attributes use physical units (meters, kelvin, lux and so on). Say which unit in the doc comment.
-- Demos go in `demos/<category>/` as a pair, `<name>.cpp` and `<name>.py`, the same demo in each language (registered with `ERNIE_REGISTER_DEMO` in C++); only `demos/interop/` is Python alone. `ernie/test/python/test_demos.py` checks every pair renders the same image.
+- Demos go in `demos/<category>/` as a pair, `demo_<category>_<name>.cpp` and `demo_<category>_<name>.py`, the same demo in each language (registered with `ERNIE_REGISTER_DEMO(Class, "<category>", "<name>", ...)` in C++); only `demos/interop/` is Python alone. The file stem is the demo's name everywhere: `ernie --demo demo_<category>_<name>`, `python -m ernie.demos demo_<category>_<name>` and its own program. `ernie/test/python/test_demos.py` checks every pair renders the same image.
 - Tests are named `<module>_<topic>_test.cpp`. GPU tests use the `_gpu_test.cpp` suffix.
 
 ## Pull requests

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.1.0.dev266
+Version: 0.1.0.dev309
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a spectral Vulkan renderer with a USD-style scene and batched cameras
 Keywords: rendering,spectral,vulkan,planetary,space,sensor-simulation,reinforcement-learning,robotics
 Author: Alex Maietta
@@ -35,7 +35,11 @@ Description-Content-Type: text/markdown
 
 > 🚧 **This project is in active beta development.** This means the API is unstable, features may be added or removed, and breaking changes are likely to occur frequently and without notice as the design is refined.
 
-[![CI](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml) [![Release](https://img.shields.io/github/v/release/alexmaietta/ernie?include_prereleases&sort=semver&color=orange)](https://github.com/alexmaietta/ernie/releases) [![PyPI](https://img.shields.io/pypi/v/ernie-renderer?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/ernie-renderer/) [![Docs](https://img.shields.io/badge/docs-latest-8A2BE2)](https://alexmaietta.github.io/ernie/) [![License](https://img.shields.io/badge/license-BSD--3--Clause-2E8B57)](LICENSE)
+[![CI](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml)
+[![Release](https://img.shields.io/github/v/release/alexmaietta/ernie?include_prereleases&sort=semver&color=orange)](https://github.com/alexmaietta/ernie/releases)
+[![PyPI](https://img.shields.io/pypi/v/ernie-renderer?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/ernie-renderer/)
+[![Docs](https://img.shields.io/badge/docs-latest-8A2BE2)](https://alexmaietta.github.io/ernie/)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-2E8B57)](LICENSE)
 
 # Efficient Renderer for Natural and Interplanetary Environments (Ernie)
 
@@ -43,7 +47,7 @@ Description-Content-Type: text/markdown
 
 Ernie is a physically accurate, real-time, spectral renderer for interplanetary environments.
 
-It is a Vulkan rasterizer for Linux, Windows and macOS (through MoltenVK), with C++ and Python APIs and a Hydra-like scene API. Ernie is designed around physical quantities, efficient batched rendering and modularity.
+It is a Vulkan rasterizer for Linux, Windows and macOS (through MoltenVK), with C++ and Python APIs and a Hydra-like scene API. Ernie is designed around physical quantities, efficient batched rendering, and user experience.
 
 Ernie is built to be customized and to work alongside other tools. You can add your own BRDFs, sensor filters and light patterns. Rendered outputs and scene attributes (transforms, mesh vertices, light parameters and more) are shared zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), which makes Ernie a good fit for real-time physics simulation and reinforcement learning. Support for OpenUSD and glTF scenes, and for MDL and MaterialX materials, is planned.
 
@@ -52,7 +56,7 @@ Its key features are aimed at planetary robotics and sensing:
 - **Cameras and sensors**
   - Exposure, aperture, motion blur, rolling shutter, lens distortion and vignetting.
   - Perspective, fisheye and orthographic projections, and line-scan pushbroom cameras like LROC's.
-  - Real sensor specs: quantum efficiency curves, full well, read noise, dark current, PRNU, DSNU, gain and ADC bit depth.
+  - Quantum efficiency curves, full well, read noise, dark current, PRNU, DSNU, gain and ADC bit depth.
   - USGS CSM camera models for non-standard instruments.
   - Sensor filter chains (noise models, lens flare, vignetting), with your own filters written in Slang.
 - **Planetary environments**
@@ -71,7 +75,7 @@ Its key features are aimed at planetary robotics and sensing:
   - A floating origin, so large scenes keep their precision.
 - **Tools**
   - A viewer with customizable panels, to drive your own simulations and workflows.
-  - Debug drawing: labels, trajectories and overlays in the scene.
+  - Debug drawing for labels, trajectories and overlays in the scene.
 
 For a more detailed overview of the features, see our [documentation](https://alexmaietta.github.io/ernie/).
 
@@ -203,6 +207,13 @@ Planned future examples.
 - Illuminants across the same scene
 - Laser lines competing with sunlight
 
+**Lasers**
+
+- Lasers from 405 to 940 nm seen by RGB, narrowband, NIR and wideband cameras (`demo_lasers_wavelengths`)
+- A projector's patterns: spot, line, grid, dots, fringes and rings written in Slang (`demo_lasers_patterns`)
+- A pulsed line laser against long, in-step and between-pulse exposures (`demo_lasers_pulsed`)
+- Gray-code structured light decoded to projector columns (`demo_lasers_structured_light`)
+
 **Star Field**
 
 - Hipparcos star catalog

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/README.md

@@ -1,6 +1,10 @@
 > 🚧 **This project is in active beta development.** This means the API is unstable, features may be added or removed, and breaking changes are likely to occur frequently and without notice as the design is refined.
 
-[![CI](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml) [![Release](https://img.shields.io/github/v/release/alexmaietta/ernie?include_prereleases&sort=semver&color=orange)](https://github.com/alexmaietta/ernie/releases) [![PyPI](https://img.shields.io/pypi/v/ernie-renderer?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/ernie-renderer/) [![Docs](https://img.shields.io/badge/docs-latest-8A2BE2)](https://alexmaietta.github.io/ernie/) [![License](https://img.shields.io/badge/license-BSD--3--Clause-2E8B57)](LICENSE)
+[![CI](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml)
+[![Release](https://img.shields.io/github/v/release/alexmaietta/ernie?include_prereleases&sort=semver&color=orange)](https://github.com/alexmaietta/ernie/releases)
+[![PyPI](https://img.shields.io/pypi/v/ernie-renderer?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/ernie-renderer/)
+[![Docs](https://img.shields.io/badge/docs-latest-8A2BE2)](https://alexmaietta.github.io/ernie/)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-2E8B57)](LICENSE)
 
 # Efficient Renderer for Natural and Interplanetary Environments (Ernie)
 
@@ -8,7 +12,7 @@
 
 Ernie is a physically accurate, real-time, spectral renderer for interplanetary environments.
 
-It is a Vulkan rasterizer for Linux, Windows and macOS (through MoltenVK), with C++ and Python APIs and a Hydra-like scene API. Ernie is designed around physical quantities, efficient batched rendering and modularity.
+It is a Vulkan rasterizer for Linux, Windows and macOS (through MoltenVK), with C++ and Python APIs and a Hydra-like scene API. Ernie is designed around physical quantities, efficient batched rendering, and user experience.
 
 Ernie is built to be customized and to work alongside other tools. You can add your own BRDFs, sensor filters and light patterns. Rendered outputs and scene attributes (transforms, mesh vertices, light parameters and more) are shared zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), which makes Ernie a good fit for real-time physics simulation and reinforcement learning. Support for OpenUSD and glTF scenes, and for MDL and MaterialX materials, is planned.
 
@@ -17,7 +21,7 @@ Its key features are aimed at planetary robotics and sensing:
 - **Cameras and sensors**
   - Exposure, aperture, motion blur, rolling shutter, lens distortion and vignetting.
   - Perspective, fisheye and orthographic projections, and line-scan pushbroom cameras like LROC's.
-  - Real sensor specs: quantum efficiency curves, full well, read noise, dark current, PRNU, DSNU, gain and ADC bit depth.
+  - Quantum efficiency curves, full well, read noise, dark current, PRNU, DSNU, gain and ADC bit depth.
   - USGS CSM camera models for non-standard instruments.
   - Sensor filter chains (noise models, lens flare, vignetting), with your own filters written in Slang.
 - **Planetary environments**
@@ -36,7 +40,7 @@ Its key features are aimed at planetary robotics and sensing:
   - A floating origin, so large scenes keep their precision.
 - **Tools**
   - A viewer with customizable panels, to drive your own simulations and workflows.
-  - Debug drawing: labels, trajectories and overlays in the scene.
+  - Debug drawing for labels, trajectories and overlays in the scene.
 
 For a more detailed overview of the features, see our [documentation](https://alexmaietta.github.io/ernie/).
 
@@ -168,6 +172,13 @@ Planned future examples.
 - Illuminants across the same scene
 - Laser lines competing with sunlight
 
+**Lasers**
+
+- Lasers from 405 to 940 nm seen by RGB, narrowband, NIR and wideband cameras (`demo_lasers_wavelengths`)
+- A projector's patterns: spot, line, grid, dots, fringes and rings written in Slang (`demo_lasers_patterns`)
+- A pulsed line laser against long, in-step and between-pulse exposures (`demo_lasers_pulsed`)
+- Gray-code structured light decoded to projector columns (`demo_lasers_structured_light`)
+
 **Star Field**
 
 - Hipparcos star catalog

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/cmake/ErniePackaging.cmake

@@ -97,6 +97,12 @@ else()
         CPACK_DEBIAN_PACKAGE_DEPENDS
         ", libc6 (>= ${ernie_glibc}), libstdc++6 (>= 11), libgcc-s1 (>= 3.4)"
     )
+    # The system's libcurl, which the demos link (curl.cmake): renamed
+    # libcurl4t64 in Debian 13 and Ubuntu 24.04.
+    if(TARGET ernie_curl AND CURL_FOUND)
+        string(APPEND CPACK_DEBIAN_PACKAGE_DEPENDS
+               ", libcurl4t64 | libcurl4")
+    endif()
 endif()
 # Recommended rather than required, so headless servers can leave the window libraries out
 # (`apt install --no-install-recommends`).

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/cmake/third_party/curl.cmake

@@ -1,3 +1,6 @@
+# Included before the packaging (CMakeLists.txt) and by the demos.
+include_guard(GLOBAL)
+
 set(ERNIE_DEP_VERSION_curl
     curl-8_18_0
     CACHE STRING "Tag of curl to fetch when the system has no libcurl.")

{ernie_renderer-0.1.0.dev266 → ernie_renderer-0.1.0.dev309}/demos/CMakeLists.txt

@@ -1,8 +1,9 @@
 # SPDX-License-Identifier: BSD-3-Clause
-# Ernie's demos, by category: demos/<category>/<name>.cpp beside <name>.py, the same demo in each
-# language (interop/ is Python only). Each C++ demo registers itself (ERNIE_REGISTER_DEMO), and
-# their objects go into the `ernie` program and the Python module, whose Demos panels list them.
-# With ERNIE_BUILD_DEMOS each is also a program of its own, demo_<category>_<name>.
+# Ernie's demos, by category: demos/<category>/demo_<category>_<name>.cpp beside its .py, the
+# same demo in each language (interop/ is Python only), named by that stem. Each C++ demo
+# registers itself (ERNIE_REGISTER_DEMO), and their objects go into the `ernie` program and the
+# Python module, whose Demos panels list them. With ERNIE_BUILD_DEMOS each is also a program of
+# its own, named as its files.
 
 file(GLOB ernie_demo_cpp CONFIGURE_DEPENDS
      "${CMAKE_CURRENT_SOURCE_DIR}/*/*.cpp")
@@ -45,11 +46,18 @@ if(ERNIE_BUILD_DEMOS)
         get_filename_component(name "${source}" NAME_WE)
         get_filename_component(directory "${source}" DIRECTORY)
         get_filename_component(category "${directory}" NAME)
-        set(program "demo_${category}_${name}")
+        # The demo's id and program: its file's stem,
+        # demo_<category>_<name> (a file of the former <name> form
+        # gets the prefix).
+        if(name MATCHES "^demo_${category}_")
+            set(program "${name}")
+        else()
+            set(program "demo_${category}_${name}")
+        endif()
         add_executable(${program} main.cpp
                                   $<TARGET_OBJECTS:ernie_demos>)
-        target_compile_definitions(
-            ${program} PRIVATE ERNIE_DEMO_ID="${category}/${name}")
+        target_compile_definitions(${program}
+                                   PRIVATE ERNIE_DEMO_ID="${program}")
         target_link_libraries(
             ${program} PRIVATE ernie_app ernie_build_options
                                ${ernie_demo_links})

ernie_renderer-0.1.0.dev266/demos/atmosphere/earth.cpp → ernie_renderer-0.1.0.dev309/demos/atmosphere/demo_atmosphere_earth.cpp

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: BSD-3-Clause
-// Earth's atmosphere from the ground and from orbit: a blue noon sky,
-// a red sunset, and the planet's limb from the International Space
-// Station's 400 km, under the Sun's measured spectrum (TSIS-1) at
-// 1361 W/m^2.
+// Earth's atmosphere from the ground and from orbit: a noon sky, a
+// sunset and the limb from the ISS.
 
 #include "ernie/app/demo.h"
 #include "ernie/scene/base_schemas.h"

ernie_renderer-0.1.0.dev266/demos/atmosphere/earth.py → ernie_renderer-0.1.0.dev309/demos/atmosphere/demo_atmosphere_earth.py

@@ -1,8 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
-"""Earth's atmosphere from the ground and from orbit: a blue noon sky,
-a red sunset, and the planet's limb from the International Space
-Station's 400 km, under the Sun's measured spectrum (TSIS-1) at
-1361 W/m^2."""
+"""Earth's atmosphere from the ground and from orbit: a noon sky, a
+sunset and the limb from the ISS."""
 
 import math
 

ernie_renderer-0.1.0.dev309/demos/atmosphere/demo_atmosphere_eclipse.cpp

@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Solar eclipses by a CelestialBody Moon: partial and annular through
+// a solar filter, totality from the ground, and its shadow from
+// orbit.
+
+#include "ernie/app/demo.h"
+#include "ernie/scene/base_schemas.h"
+#include "ernie/scene/camera_schemas.h"
+#include "ernie/scene/light_schemas.h"
+#include "ernie/scene/render_schemas.h"
+#include "ernie/scene/terrain_schemas.h"
+#include "ernie/scene/tokens.h"
+#include "ernie/scene/xform.h"
+#include "util.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <numbers>
+#include <string>
+#include <vector>
+
+namespace {
+
+using namespace ernie;
+using demos::Check;
+
+constexpr double kPi = std::numbers::pi;
+constexpr double kSunElevation = 40.0;  // degrees
+
+/// A camera, an exposure, and the Moon's distance and offset from the
+/// sun (towards the zenith).
+struct View {
+    const char* name;
+    glm::dvec3 eye;
+    double elevation;  ///< Of the camera's aim, degrees, towards +x.
+    glm::dvec3 up;
+    double focalLength;   ///< Millimetres.
+    double moonDistance;  ///< Metres.
+    double moonOffset;    ///< Degrees.
+    double fStop;
+    double exposureTime;  ///< Seconds, at ISO 100.
+    double filter;        ///< Stops; -13.3 is an ND 4.0 solar filter.
+};
+
+// At 360,000 km the Moon covers the sun; at 405,500 km it leaves a
+// ring.
+const std::array<View, 4> kViews = {{
+    {"Partial, through a solar filter",
+     {0.0, 0.0, 2.0},
+     kSunElevation,
+     {0.0, 0.0, 1.0},
+     1200.0,
+     384400e3,
+     0.3,
+     16.0,
+     1.0 / 1000.0,
+     -13.3},
+    {"Annular, through a solar filter",
+     {0.0, 0.0, 2.0},
+     kSunElevation,
+     {0.0, 0.0, 1.0},
+     1200.0,
+     405500e3,
+     0.0,
+     16.0,
+     1.0 / 1000.0,
+     -13.3},
+    {"Totality, from the ground",
+     {0.0, 0.0, 2.0},
+     22.0,
+     {0.0, 0.0, 1.0},
+     14.0,
+     360000e3,
+     0.0,
+     2.8,
+     1.0 / 2.0,
+     0.0},
+    {"The Moon's shadow from geostationary orbit",
+     {0.0, 0.0, 35786e3},
+     -90.0,
+     {1.0, 0.0, 0.0},
+     100.0,
+     360000e3,
+     0.0,
+     16.0,
+     1.0 / 125.0,
+     0.0},
+}};
+
+/// The mean linear colour of rows [top, bottom) and columns [left,
+/// right) of a uint8 (rows, cols, 4) image.
+glm::dvec3 RegionLinearRgb(const Tensor& image, std::int64_t top,
+                           std::int64_t bottom, std::int64_t left,
+                           std::int64_t right) {
+    const std::int64_t cols = image.Shape()[1];
+    const auto* pixels =
+        static_cast<const std::uint8_t*>(image.Data());
+    glm::dvec3 sum(0.0);
+    for (std::int64_t row = top; row < bottom; ++row) {
+        for (std::int64_t col = left; col < right; ++col) {
+            const std::uint8_t* p = pixels + (row * cols + col) * 4;
+            sum += demos::SrgbToLinear(glm::dvec3(p[0], p[1], p[2]) /
+                                       255.0);
+        }
+    }
+    return sum / static_cast<double>((bottom - top) * (right - left));
+}
+
+double Luminance(glm::dvec3 rgb) {
+    return 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
+}
+
+/// The pixels of a uint8 (rows, cols, 4) image brighter than half
+/// white.
+int BrightPixels(const Tensor& image) {
+    const auto* pixels =
+        static_cast<const std::uint8_t*>(image.Data());
+    const std::int64_t count = image.Shape()[0] * image.Shape()[1];
+    int bright = 0;
+    for (std::int64_t i = 0; i < count; ++i) {
+        bright += pixels[i * 4 + 1] > 128 ? 1 : 0;
+    }
+    return bright;
+}
+
+class EclipseDemo : public app::Demo {
+  public:
+    EclipseDemo(app::Viewer* viewer, const app::DemoOptions& options)
+        : Demo(viewer, options) {
+        numFrames = 1;
+        Scene& scene = GetScene();
+        Xform::Define(scene, "/World");
+        Atmosphere::Define(scene, "/World/Air")
+            .SetPreset(std::string(tokens::kEarth));
+        DistantLight::Define(scene, "/World/Sun")
+            .SetIrradiance(1361.0)
+            .SetPhysicalIlluminant(std::string(tokens::kSun))
+            .SetAngle(0.53);
+        const double e = kSunElevation * kPi / 180.0;
+        DistantLight(scene, "/World/Sun")
+            .SetTransform(DistantLightTransform(
+                {std::cos(e), 0.0, std::sin(e)}));
+        // The Moon: its mean radius and normal albedo.
+        CelestialBody::Define(scene, "/World/Moon")
+            .SetRadius(1737.4e3)
+            .SetAlbedo(glm::dvec3(0.12));
+        Camera::Define(scene, "/World/Camera")
+            .SetSensorNoise(false)
+            .SetExposureIso(100.0);
+        RenderSettings::Define(scene, "/Render/Settings")
+            .SetCamera(Path("/World/Camera"))
+            .SetResolution({480, 320})
+            .SetAmbient(0.0);
+        Show(0);
+
+        std::vector<std::string> names;
+        for (const View& view : kViews) {
+            names.emplace_back(view.name);
+        }
+        Widgets().Combo("View", std::move(names), 0,
+                        [this](std::size_t index) {
+                            Show(static_cast<int>(index));
+                        });
+        Widgets().Slider(
+            "Moon offset", -1.0, 1.0, kViews[0].moonOffset,
+            [this](double degrees) {
+                MoonAt(kViews[static_cast<std::size_t>(view_)]
+                           .moonDistance,
+                       degrees);
+            });
+        if (viewer != nullptr) {
+            viewer->SetActiveCamera("/World/Camera");
+        }
+    }
+
+    /// The four views side by side.
+    void SaveOutput(const std::filesystem::path& path) override {
+        app::WritePng(path, demos::SideBySide(RenderAll()));
+    }
+
+    void TestFinal() override {
+        const std::vector<Tensor> images = RenderAll();
+        for (std::size_t i = 0; i < images.size(); ++i) {
+            const glm::dvec3 mean = demos::MeanLinearRgb(images[i]);
+            std::printf("%s: mean linear RGB %.4f %.4f %.4f\n",
+                        kViews[i].name, mean.r, mean.g, mean.b);
+        }
+        // A crescent and a ring: less of the sun than its whole disc.
+        const int whole = BrightPixels(RenderWithoutMoon(0));
+        const int crescent = BrightPixels(images[0]);
+        const int ring = BrightPixels(images[1]);
+        std::printf("bright pixels: whole %d, crescent %d, ring %d\n",
+                    whole, crescent, ring);
+        Check(crescent > 0 && crescent < 0.8 * whole,
+              "the partial eclipse should leave a crescent");
+        Check(ring > 0 && ring < 0.3 * whole,
+              "the annular eclipse should leave a thin ring");
+        // The ring: dark at the Moon's centre.
+        const std::int64_t rows = images[1].Shape()[0];
+        const std::int64_t cols = images[1].Shape()[1];
+        Check(Luminance(RegionLinearRgb(images[1], rows / 2 - 2,
+                                        rows / 2 + 2, cols / 2 - 2,
+                                        cols / 2 + 2)) < 0.01,
+              "the Moon should be dark against the sun");
+        // Totality: a dark sky, brightest along the horizon.
+        const Tensor day = RenderWithoutMoon(2);
+        const double total =
+            Luminance(demos::MeanLinearRgb(images[2]));
+        const double daylight = Luminance(demos::MeanLinearRgb(day));
+        std::printf("totality %.5f of daylight\n", total / daylight);
+        Check(total < 0.05 * daylight,
+              "totality should darken the sky");
+        const double horizon = Luminance(RegionLinearRgb(
+            images[2], rows - rows / 5, rows, 0, cols));
+        const double overhead = Luminance(
+            RegionLinearRgb(images[2], 0, rows / 5, 0, cols));
+        std::printf("totality: horizon %.5f, top %.5f\n", horizon,
+                    overhead);
+        Check(horizon > 2.0 * overhead,
+              "the horizon should glow in totality");
+        // From orbit: a dark umbra under the camera.
+        const double umbra = Luminance(
+            RegionLinearRgb(images[3], rows / 2 - 2, rows / 2 + 2,
+                            cols / 2 - 2, cols / 2 + 2));
+        const double around = Luminance(
+            RegionLinearRgb(images[3], 0, rows / 8, 0, cols));
+        std::printf("from orbit: umbra %.5f, around %.5f\n", umbra,
+                    around);
+        Check(umbra < 0.1 * around,
+              "the umbra should be dark from orbit");
+    }
+
+  private:
+    void Show(int index) {
+        view_ = index;
+        const View& view = kViews[static_cast<std::size_t>(index)];
+        const double a = view.elevation * kPi / 180.0;
+        Camera(GetScene(), "/World/Camera")
+            .SetFocalLength(view.focalLength)
+            .SetExposureFStop(view.fStop)
+            .SetExposureTime(view.exposureTime)
+            .SetExposure(view.filter)
+            .SetTransform(LookAtTransform(
+                view.eye,
+                view.eye + glm::dvec3(std::cos(a), 0.0, std::sin(a)),
+                view.up));
+        MoonAt(view.moonDistance, view.moonOffset);
+    }
+
+    /// The Moon `distance` from the world's origin, `degrees` from
+    /// the sun's direction towards the zenith.
+    void MoonAt(double distance, double degrees) {
+        const double e = (kSunElevation + degrees) * kPi / 180.0;
+        SetXform(GetScene(), "/World/Moon",
+                 {.translate = distance * glm::dvec3(std::cos(e), 0.0,
+                                                     std::sin(e))});
+    }
+
+    /// View `index` with the Moon far from the sun; leaves the view
+    /// as it was.
+    Tensor RenderWithoutMoon(int index) {
+        const int current = view_;
+        Show(index);
+        MoonAt(kViews[static_cast<std::size_t>(index)].moonDistance,
+               -30.0);
+        Tensor image = GetRenderer().Render(GetScene());
+        Show(current);
+        return image;
+    }
+
+    /// The scene from each view in turn, RGBA uint8; leaves the view
+    /// as it was.
+    std::vector<Tensor> RenderAll() {
+        const int current = view_;
+        std::vector<Tensor> images;
+        for (int i = 0; i < static_cast<int>(kViews.size()); ++i) {
+            Show(i);
+            images.push_back(GetRenderer().Render(GetScene()));
+        }
+        Show(current);
+        return images;
+    }
+
+    int view_ = 0;
+};
+
+}  // namespace
+
+ERNIE_REGISTER_DEMO(EclipseDemo, "atmosphere", "eclipse",
+                    "Solar eclipses: partial, annular and total from "
+                    "the ground, and the Moon's shadow from orbit.");