ernie-renderer 0.1.0.dev189__tar.gz → 0.1.0.dev196__tar.gz

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/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 ".dev189" CACHE STRING "Pre-release suffix of Ernie's version, such as .dev12")
+set(ERNIE_VERSION_SUFFIX ".dev196" CACHE STRING "Pre-release suffix of Ernie's version, such as .dev12")
 # cmake-format: on
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.1.0.dev189
+Version: 0.1.0.dev196
 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

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/cmake/third_party/slang.cmake

@@ -67,3 +67,7 @@ file(
     "${slang_library_dir}/slang-compiler.dll"
     "${slang_library_dir}/slang-glslang.dll")
 set(ERNIE_SLANG_RUNTIME_DIR "${slang_library_dir}")
+# Windows has no rpath: a program finds its DLLs beside it, so the build's programs get Slang's.
+if(WIN32 AND CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+    file(COPY ${ERNIE_SLANG_RUNTIME} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+endif()

ernie_renderer-0.1.0.dev196/demos/batched/batch_camera.cpp

@@ -0,0 +1,399 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Benchmarks batched cameras for reinforcement learning: one environment ("world") per view, each
+// a clone of the first, with camera poses that change every step on the GPU, and reports the time
+// per step and views rendered per second. The C++ twin of batch_camera.py.
+//
+//     ernie --demo batched/batch_camera [--views 1024] [--bands 3] [--minimal texturedDiffuse]
+//         [--viewer null] [--sweep] [--output views.png]
+//
+// Each environment holds a few boxes and spheres over a shared ground under a sun with shadows.
+// The views orbit their environment, a step's poses arrive as a CUDA array, and the observations
+// stay on the GPU (a step mapped with MapDevice::Gpu), the way a training loop consumes them.
+// Spectral bands (ernie:spectralBands) set most of the shading and sensor cost; RGB observations
+// need few. --minimal draws with minimal shading (ernie:minimal:mode) instead: one forward pass
+// straight into the observations, with no spectral shading or sensor filters; "none" renders
+// black colour and distances alone.
+//
+// Each frame is one batch step, timed after a few steps' warm-up; --sweep first times 256, 1024
+// and 4096 views at 3 and 16 bands, each in a scene of its own. The environments are clones at
+// the origin, so the viewer shows them as one. --output writes 16 views of the last step, spread
+// round the orbit, as a contact sheet.
+
+#include "ernie/app/demo.h"
+#include "ernie/device/compute_interop.h"
+#include "ernie/scene/base_schemas.h"
+#include "ernie/scene/camera_schemas.h"
+#include "ernie/scene/geometry_schemas.h"
+#include "ernie/scene/light_schemas.h"
+#include "ernie/scene/render_schemas.h"
+#include "ernie/scene/xform.h"
+#include "util.h"
+
+#include <glm/gtc/constants.hpp>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace {
+
+using namespace ernie;
+using demos::Check;
+using Clock = std::chrono::steady_clock;
+
+constexpr int kSize = 64;
+constexpr int kSteps = 60;  // distinct poses, cycled
+constexpr int kWarmup = 5;  // steps before timing: uploads, pipelines, allocations
+
+// An environment's things, cubes and spheres in turn: their colours and where they stand, the
+// same in batch_camera.py.
+struct Thing {
+    glm::dvec3 colour;
+    double x;
+    double y;
+};
+constexpr std::array<Thing, 6> kThings = {{
+    {{0.700, 0.918, 0.821}, -1.649, -1.199},
+    {{0.899, 0.204, 0.857}, 1.782, -0.192},
+    {{0.442, 0.423, 0.404}, -0.330, 0.027},
+    {{0.643, 0.996, 0.834}, 0.733, 2.934},
+    {{0.372, 0.328, 0.690}, -2.736, -2.786},
+    {{0.612, 0.573, 0.934}, 0.775, 0.085},
+}};
+
+constexpr std::array<const char*, 4> kMinimalModes = {"off", "none", "constantDiffuse",
+                                                      "texturedDiffuse"};
+
+const Path kCamera("/World/Camera");
+const Path kProduct("/Render/BatchCamera");
+
+void BuildScene(Scene& scene, int worlds, int bands) {
+    GroundPlane::Define(scene, "/World/Ground");
+    DistantLight::Define(scene, "/World/Sun").SetTransform(DistantLightTransform({0.4, -0.6, 0.7}));
+    Xform::Define(scene, "/Envs/Env0");
+    for (std::size_t i = 0; i < kThings.size(); ++i) {
+        const Path thing("/Envs/Env0/Thing" + std::to_string(i));
+        if (i % 2 == 0) {
+            Cube::Define(scene, thing).SetDisplayColor(kThings[i].colour);
+        } else {
+            Sphere::Define(scene, thing).SetDisplayColor(kThings[i].colour);
+        }
+        SetXform(scene, thing, {.translate = glm::dvec3(kThings[i].x, kThings[i].y, 0.5)});
+    }
+    for (int world = 0; world < worlds; ++world) {
+        const Path env("/Envs/Env" + std::to_string(world));
+        if (world > 0) {
+            scene.Clone("/Envs/Env0", env);
+        }
+        Xform(scene, env).SetWorld(world);
+    }
+    Camera::Define(scene, kCamera).SetFocalLength(18.0).SetSpectralBands(bands);
+}
+
+/// One pose per view, circling its environment from its own heading: float32 (views, 4, 4) in
+/// the math convention, rows of four.
+Tensor Orbit(int views, double angle) {
+    std::vector<float> poses;
+    poses.reserve(static_cast<std::size_t>(views) * 16);
+    for (int v = 0; v < views; ++v) {
+        const double heading = angle + 2.0 * glm::pi<double>() * v / views;
+        const glm::dmat4 pose =
+            LookAtTransform({8.0 * std::cos(heading), 8.0 * std::sin(heading), 5.0},
+                            {0.0, 0.0, 0.5}, {0.0, 0.0, 1.0});
+        for (int row = 0; row < 4; ++row) {
+            for (int col = 0; col < 4; ++col) {
+                poses.push_back(static_cast<float>(pose[col][row]));
+            }
+        }
+    }
+    return Tensor::Copy<float>(poses, {views, 4, 4});
+}
+
+/// The render vars a batch renders: distances besides the black colour of minimal "none".
+std::vector<std::string> RenderVars(const std::string& minimal) {
+    if (minimal == "none") {
+        return {"LdrColor", "DistanceToCamera"};
+    }
+    return {"LdrColor"};
+}
+
+/// A product rendering `views` views through the camera, one world each, as Python's
+/// ernie.batch.BatchCamera defines it: minimal shading unless `minimal` is "off".
+void DefineBatch(Scene& scene, int views, const std::string& minimal) {
+    std::vector<Path> vars;
+    for (const std::string& name : RenderVars(minimal)) {
+        const Path var = kProduct.Child("Vars").Child(name);
+        RenderVar::Define(scene, var).SetSourceName(name);
+        vars.push_back(var);
+    }
+    RenderProduct product = RenderProduct::Define(scene, kProduct)
+                                .SetCamera(kCamera)
+                                .SetResolution({kSize, kSize})
+                                .SetOrderedVars(vars);
+    if (minimal != "off") {
+        product.SetMinimalMode(minimal);
+    }
+    std::vector<std::int32_t> worlds(static_cast<std::size_t>(views));
+    for (int v = 0; v < views; ++v) {
+        worlds[static_cast<std::size_t>(v)] = v;
+    }
+    Camera(scene, kCamera)
+        .SetPoses(Orbit(views, 0.0))
+        .SetWorlds(Tensor::Copy<std::int32_t>(worlds, {views}));
+}
+
+/// Every step's poses, in CUDA memory, as a simulator would hand them over.
+std::vector<Tensor> UploadPoses(ComputeInterop& compute, int views) {
+    std::vector<Tensor> poses;
+    for (int s = 0; s < kSteps; ++s) {
+        poses.push_back(compute.Upload(Orbit(views, 0.03 * s)));
+    }
+    return poses;
+}
+
+/// Renders a step with `poses` and returns each render var's observations on the GPU, without
+/// waiting for the render.
+std::map<std::string, Tensor> StepBatch(Renderer& renderer, Scene& scene, const Tensor& poses) {
+    Camera(scene, kCamera).SetPoses(poses);
+    const Path products[] = {kProduct};
+    StepOperation operation = renderer.StepAsync(scene, products);
+    RenderProductSetOutputs outputs = operation.Outputs();
+    std::map<std::string, Tensor> observations;
+    for (auto& [name, var] : outputs.at(kProduct).vars) {
+        observations.emplace(name, var.Map(MapDevice::Gpu).tensor);
+    }
+    return observations;
+}
+
+ComputeInterop& RequireCuda(Renderer& renderer) {
+    ComputeInterop* compute = renderer.Delegate().Compute();
+    if (compute == nullptr) {
+        throw std::runtime_error("This demo needs CUDA interop");
+    }
+    return *compute;
+}
+
+/// Seconds per step of `views` views at `bands` bands, in a scene of their own.
+double Benchmark(Renderer& renderer, int views, int bands, const std::string& minimal) {
+    Scene scene;
+    BuildScene(scene, views, bands);
+    DefineBatch(scene, views, minimal);
+    ComputeInterop& compute = RequireCuda(renderer);
+    const std::vector<Tensor> poses = UploadPoses(compute, views);
+    for (int s = 0; s < kWarmup; ++s) {
+        StepBatch(renderer, scene, poses[static_cast<std::size_t>(s)]);
+    }
+    const Clock::time_point start = Clock::now();
+    std::map<std::string, Tensor> observations;
+    for (const Tensor& pose : poses) {
+        observations = StepBatch(renderer, scene, pose);
+    }
+    compute.Download(observations.at("LdrColor"));  // the last step has finished
+    return std::chrono::duration<double>(Clock::now() - start).count() / kSteps;
+}
+
+void PrintRate(int views, int bands, double perStep, const std::string& note = {}) {
+    std::printf("%6d views, %2d bands: %7.2f ms per step, %10.0f views per second%s\n", views,
+                bands, perStep * 1e3, views / perStep, note.c_str());
+}
+
+class BatchCameraDemo : public app::Demo {
+  public:
+    BatchCameraDemo(app::Viewer* viewer, const app::DemoOptions& options) : Demo(viewer, options) {
+        numFrames = kWarmup + kSteps;
+        bool sweep = false;
+        ParseOptions(options.extra, sweep);
+        Renderer& renderer = GetRenderer();
+        ComputeInterop& compute = RequireCuda(renderer);
+        std::printf("%s, %d x %d LdrColor observations\n", renderer.DeviceName().c_str(), kSize,
+                    kSize);
+        if (sweep) {
+            for (const int bands : {3, 16}) {
+                for (const int views : {256, 1024, 4096}) {
+                    PrintRate(views, bands, Benchmark(renderer, views, bands, "off"));
+                }
+            }
+            // Minimal shading has no spectral bands to speak of: one row per mode.
+            for (std::size_t m = 1; m < kMinimalModes.size(); ++m) {
+                for (const int views : {256, 1024, 4096}) {
+                    PrintRate(views, 3, Benchmark(renderer, views, 3, kMinimalModes[m]),
+                              std::string(", minimal ") + kMinimalModes[m]);
+                }
+            }
+        }
+        BuildScene(GetScene(), views_, bands_);
+        DefineBatch(GetScene(), views_, minimal_);
+        poses_ = UploadPoses(compute, views_);
+    }
+
+    void Step() override {
+        if (frame == kWarmup) {
+            Images();  // the warm-up has finished
+            timerStart_ = Clock::now();
+            timedSteps_ = 0;
+        }
+        observations_ =
+            StepBatch(GetRenderer(), GetScene(), poses_[static_cast<std::size_t>(frame % kSteps)]);
+        if (timerStart_) {
+            ++timedSteps_;
+        }
+    }
+
+    // Without a viewer the batch step is the render.
+    void Render() override {
+        if (GetViewer() != nullptr) {
+            GetViewer()->Step();
+        }
+    }
+
+    void SaveOutput(const std::filesystem::path& path) override {
+        Report();
+        // 16 views spread round the orbit; neighbouring views differ by only a few degrees.
+        const Tensor images = Images();
+        const auto* texels = static_cast<const std::uint8_t*>(images.Data());
+        const int stride = std::max(views_ / 16, 1);
+        Tensor sheet = Tensor::Zeros(DType::UInt8, {4 * kSize, 4 * kSize, 4});
+        auto* to = static_cast<std::uint8_t*>(sheet.Data());
+        for (int i = 0; i < 16 && i * stride < views_; ++i) {
+            const int r = i / 4;
+            const int c = i % 4;
+            for (int y = 0; y < kSize; ++y) {
+                std::memcpy(to + ((r * kSize + y) * 4 * kSize + c * kSize) * 4,
+                            texels +
+                                ((static_cast<std::size_t>(i * stride) * kSize + y) * kSize) * 4,
+                            kSize * 4);
+            }
+        }
+        app::WritePng(path, sheet);
+    }
+
+    void Close() override {
+        Report();
+    }
+
+    void TestFinal() override {
+        Report();
+        const Tensor images = Images();
+        Check(images.Shape() == std::vector<std::int64_t>{views_, kSize, kSize, 4},
+              "the observations should hold a view per environment");
+        const std::size_t pixels = static_cast<std::size_t>(views_) * kSize * kSize;
+        // The values the checks look at: colours, or for minimal "none" (black by design) the
+        // distances in tenths of a metre, as the colours' scale.
+        std::vector<double> values(pixels * 3);
+        const auto* texels = static_cast<const std::uint8_t*>(images.Data());
+        if (minimal_ == "none") {
+            for (std::size_t i = 0; i < pixels; ++i) {
+                Check(texels[i * 4] == 0 && texels[i * 4 + 1] == 0 && texels[i * 4 + 2] == 0,
+                      "minimal none renders no colour");
+            }
+            const Tensor distances =
+                RequireCuda(GetRenderer()).Download(observations_.at("DistanceToCamera"));
+            const auto* metres = static_cast<const float*>(distances.Data());
+            for (std::size_t i = 0; i < pixels; ++i) {
+                const double tenths =
+                    std::isfinite(metres[i]) ? std::min(10.0 * metres[i], 255.0) : 0.0;
+                values[i * 3] = values[i * 3 + 1] = values[i * 3 + 2] = tenths;
+            }
+        } else {
+            for (std::size_t i = 0; i < pixels; ++i) {
+                for (int c = 0; c < 3; ++c) {
+                    values[i * 3 + c] = texels[i * 4 + c];
+                }
+            }
+        }
+        double sum = 0.0;
+        double squares = 0.0;
+        for (const double value : values) {
+            sum += value;
+            squares += value * value;
+        }
+        const double mean = sum / static_cast<double>(values.size());
+        Check(std::sqrt(squares / static_cast<double>(values.size()) - mean * mean) > 1.0,
+              "the views should not render flat");
+        // Views from opposite headings see their environment from opposite sides.
+        if (views_ > 1) {
+            const std::size_t view = static_cast<std::size_t>(kSize) * kSize * 3;
+            const std::size_t opposite = static_cast<std::size_t>(views_ / 2) * view;
+            double largest = 0.0;
+            for (std::size_t i = 0; i < view; ++i) {
+                largest = std::max(largest, std::abs(values[i] - values[opposite + i]));
+            }
+            Check(largest > 16.0, "views from opposite headings should differ");
+        }
+    }
+
+  private:
+    /// --views, --bands, --minimal and --sweep among the demo's own arguments.
+    void ParseOptions(const std::vector<std::string>& extra, bool& sweep) {
+        for (std::size_t i = 0; i < extra.size(); ++i) {
+            const auto value = [&]() -> const std::string& {
+                if (i + 1 >= extra.size()) {
+                    throw std::invalid_argument(extra[i] + " needs a value");
+                }
+                return extra[++i];
+            };
+            if (extra[i] == "--views") {
+                views_ = std::stoi(value());
+            } else if (extra[i] == "--bands") {
+                bands_ = std::stoi(value());
+            } else if (extra[i] == "--minimal") {
+                minimal_ = value();
+                if (std::find(kMinimalModes.begin(), kMinimalModes.end(), minimal_) ==
+                    kMinimalModes.end()) {
+                    throw std::invalid_argument("--minimal is off, none, constantDiffuse or "
+                                                "texturedDiffuse, not " +
+                                                minimal_);
+                }
+            } else if (extra[i] == "--sweep") {
+                sweep = true;
+            } else {
+                throw std::invalid_argument("Unknown option " + extra[i]);
+            }
+        }
+        if (views_ < 1) {
+            throw std::invalid_argument("--views needs at least one view");
+        }
+    }
+
+    /// The last step's views, uint8 (views, kSize, kSize, 4) on the host, waiting for the render.
+    Tensor Images() {
+        return RequireCuda(GetRenderer()).Download(observations_.at("LdrColor"));
+    }
+
+    /// Prints the time per step since the warm-up, once the last step has finished; before the
+    /// output and the test, so that their downloads are not counted.
+    void Report() {
+        if (observations_.empty() || timedSteps_ == 0) {
+            return;
+        }
+        Images();  // the last step has finished
+        const double perStep =
+            std::chrono::duration<double>(Clock::now() - *timerStart_).count() / timedSteps_;
+        std::string note = minimal_ == "off" ? std::string() : ", minimal " + minimal_;
+        note += GetViewer() == nullptr ? "" : " (with the viewer drawing)";
+        PrintRate(views_, bands_, perStep, note);
+        timedSteps_ = 0;
+    }
+
+    int views_ = 1024;
+    int bands_ = 3;
+    std::string minimal_ = "off";
+    std::vector<Tensor> poses_;
+    std::map<std::string, Tensor> observations_;
+    std::optional<Clock::time_point> timerStart_;
+    int timedSteps_ = 0;
+};
+
+}  // namespace
+
+ERNIE_REGISTER_DEMO(BatchCameraDemo, "batched", "batch camera",
+                    "A view per environment rendered in batches, timed per step.");

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/demos/batched/batch_camera.py

@@ -17,7 +17,7 @@ one forward pass straight into the observations, with no spectral shading or sen
 Each frame is one batch step, timed after a few steps' warm-up; `--sweep` first times 256, 1024
 and 4096 views at 3 and 16 bands, each in a scene of its own. The environments are clones at the
 origin, so the viewer shows them as one. `--output` writes 16 views of the last step, spread round
-the orbit, as a contact sheet.
+the orbit, as a contact sheet. The Python twin of batch_camera.cpp.
 """
 
 import time
@@ -33,6 +33,17 @@ SIZE = 64
 STEPS = 60  # distinct poses, cycled
 WARMUP = 5  # steps before timing: uploads, pipelines, allocations
 
+# An environment's things, cubes and spheres in turn: their colours and where they stand, the
+# same in batch_camera.cpp.
+THINGS = [
+    ((0.700, 0.918, 0.821), (-1.649, -1.199)),
+    ((0.899, 0.204, 0.857), (1.782, -0.192)),
+    ((0.442, 0.423, 0.404), (-0.330, 0.027)),
+    ((0.643, 0.996, 0.834), (0.733, 2.934)),
+    ((0.372, 0.328, 0.690), (-2.736, -2.786)),
+    ((0.612, 0.573, 0.934), (0.775, 0.085)),
+]
+
 
 def build_scene(scene, worlds, bands):
     scene.define("/World/Ground", ernie.GroundPlane)
@@ -40,11 +51,9 @@ def build_scene(scene, worlds, bands):
         tokens.TRANSFORM, ernie.distant_light_transform((0.4, -0.6, 0.7))
     )
     env0 = scene.define("/Envs/Env0", ernie.Xform)
-    rng = np.random.default_rng(7)
-    for i in range(6):
+    for i, (colour, (x, y)) in enumerate(THINGS):
         shape = ernie.Cube if i % 2 == 0 else ernie.Sphere
-        env0.define(f"Thing{i}", shape, display_color=tuple(rng.uniform(0.2, 1.0, 3)),
-                    translate=(*rng.uniform(-3.0, 3.0, 2), 0.5))
+        env0.define(f"Thing{i}", shape, display_color=colour, translate=(x, y, 0.5))
     for world in range(worlds):
         env = env0 if world == 0 else ernie.Xform(scene.clone("/Envs/Env0", f"/Envs/Env{world}"))
         env.world = world

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/demos/lighting/illuminants.cpp

@@ -131,10 +131,12 @@ class IlluminantsDemo : public app::Demo {
             .SetPhotometricPower(1600.0)
             .SetPhysicalCustomIlluminant(Fluorescent())
             .SetTransform(LookAtTransform({-1.2, 0.6, 2.9}, {-0.25, 1.0, 1.0}, {0.0, 1.0, 0.0}));
+        // ISO 400, f/2, 1/125 s: the spot's lumens fill only its 40 degree cone, so the wall in it
+        // is bright; the cone's centre just clips.
         Camera::Define(scene, "/World/Camera")
             .SetFocalLength(18.0)
             .SetSensorNoise(false)
-            .SetExposureTime(1.0 / 15.0)
+            .SetExposureTime(1.0 / 125.0)
             .SetExposureIso(400.0)
             .SetExposureFStop(2.0)
             .SetTransform(LookAtTransform({0.0, -2.6, 1.3}, {0.0, 1.0, 1.2}, {0.0, 0.0, 1.0}));

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/demos/lighting/illuminants.py

@@ -92,8 +92,10 @@ class Demo(ernie.demo.Demo):
                                  physical_custom_illuminant=fluorescent()).set(
             tokens.TRANSFORM,
             ernie.look_at_transform((-1.2, 0.6, 2.9), (-0.25, 1.0, 1.0), (0.0, 1.0, 0.0)))
+        # ISO 400, f/2, 1/125 s: the spot's lumens fill only its 40 degree cone, so the wall in
+        # it is bright; the cone's centre just clips.
         camera = world.define("Camera", ernie.Camera, focal_length=18.0, sensor_noise=False,
-                              exposure_time=1.0 / 15.0, exposure_iso=400.0,
+                              exposure_time=1.0 / 125.0, exposure_iso=400.0,
                               exposure_f_stop=2.0).set(
             tokens.TRANSFORM, ernie.look_at_transform((0.0, -2.6, 1.3), (0.0, 1.0, 1.2)))
         self.scene.define("/Render/Settings", ernie.RenderSettings, camera=camera,

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/ernie/app/cli.cpp

@@ -92,14 +92,12 @@ int ErnieMain(std::span<const std::string> args, std::string_view version) {
                     std::string(kUsage).c_str(), std::string(DemoOptionsHelp()).c_str());
         return 0;
     }
-    // The first argument that is no option is a scene file.
+    // Without --demo, a first argument that is no option is a scene file; the other arguments are
+    // the demo's own (such as --views 64).
     std::filesystem::path file;
-    for (auto it = options.extra.begin(); it != options.extra.end(); ++it) {
-        if (!it->starts_with("-")) {
-            file = *it;
-            options.extra.erase(it);
-            break;
-        }
+    if (options.demo.empty() && !options.extra.empty() && !options.extra.front().starts_with("-")) {
+        file = options.extra.front();
+        options.extra.erase(options.extra.begin());
     }
     std::vector<DemoInfo> demos = RegisteredDemos();
     if (options.list) {

{ernie_renderer-0.1.0.dev189 → ernie_renderer-0.1.0.dev196}/ernie/kernel/raster/shading.slang

@@ -147,6 +147,13 @@ struct ShadingConstants {
     // width, height, the terrain's prim id and 1 when there is one.
     float4 horizonGrid;
     uint4 horizonInfo;
+    // The terrain's heights (`terrainHeights`): their cell size, the frame origin's height
+    // (subtracted from the terrain's), the no-data value and 1 when there is one; their width
+    // and height.
+    float4 heightsGrid;
+    uint4 heightsSize;
+    // The heights above the ground the horizon map's levels see from, in height units.
+    float4 horizonLevels;
 }
 
 [[vk::binding(0, 0)]] StructuredBuffer<ShadingUniforms> shadingViews;
@@ -549,35 +556,85 @@ float4 occlusionSlice(float3 n, float3 tangent, float3 v, float2 horizons) {
     return float4(projectedLength * (t0 * tangent + t1 * v), projectedLength * arc);
 }
 
-// The terrain's horizon map (terrain_horizon.slang): per texel, the tangents of the horizon's
-// elevation towards azimuths 0 to 135 degrees (layer 0) and 180 to 315 (layer 1), before
-// vertical exaggeration.
+// The terrain's horizon map (terrain_horizon.slang): per texel and level (a height above the
+// ground, `ShadingConstants::horizonLevels`), the tangents of the horizon's elevation towards
+// azimuths 0 to 135 degrees (layer 2 level) and 180 to 315 (layer 2 level + 1), before vertical
+// exaggeration.
 [[vk::binding(19, 0)]] Texture2DArray<float4> horizonMap;
+// The terrain's heights, before exaggeration, rows from its north edge.
+[[vk::binding(21, 0)]] Texture2D<float> terrainHeights;
 
-// The horizon tangents around texel `texel` (clamped to the map), as eight values.
-void horizonTexel(int2 texel, out float4 first, out float4 second) {
-    let at = clamp(texel, int2(0), int2(pass.horizonInfo.xy) - 1);
-    first = horizonMap.Load(int4(at, 0, 0));
-    second = horizonMap.Load(int4(at, 1, 0));
+static const uint kHorizonLevels = 4;
+
+// The horizon tangents of level `level` around texel `texel` (clamped to the map), as eight
+// values, bilinear at fraction `f` towards the next texels.
+void horizonAround(int2 texel, float2 f, uint level, out float4 first, out float4 second) {
+    let last = int2(pass.horizonInfo.xy) - 1;
+    float4 a[2], b[2], c[2], d[2];
+    for (uint side = 0; side < 2; ++side) {
+        let layer = 2 * level + side;
+        a[side] = horizonMap.Load(int4(clamp(texel, int2(0), last), layer, 0));
+        b[side] = horizonMap.Load(int4(clamp(texel + int2(1, 0), int2(0), last), layer, 0));
+        c[side] = horizonMap.Load(int4(clamp(texel + int2(0, 1), int2(0), last), layer, 0));
+        d[side] = horizonMap.Load(int4(clamp(texel + int2(1, 1), int2(0), last), layer, 0));
+    }
+    first = lerp(lerp(a[0], b[0], f.x), lerp(c[0], d[0], f.x), f.y);
+    second = lerp(lerp(a[1], b[1], f.x), lerp(c[1], d[1], f.x), f.y);
 }
 
-// The dome's visibility and bent normal over terrain at world point `world` (relative to the
-// frame's origin) with unit normal `n`, from the terrain's horizon map: the horizons around the
-// point (bilinear in its texels), in four vertical slices whose horizons to either side are the
-// map's opposite azimuths, integrated as `occlusionSlice` does about the vertical. They see the
-// whole terrain, on screen or not, at the map's resolution.
-float4 terrainOcclusion(float3 world, float3 n) {
+// How far world point `world` (relative to the frame's origin) stands above the terrain under
+// it, in height units (before exaggeration): bilinear in the heights. False off the terrain or
+// over no-data.
+bool aboveTerrain(float3 world, out float above) {
+    above = 0.0;
+    let grid = pass.horizonGrid;
+    let size = int2(pass.heightsSize.xy);
+    let cell = float2(world.x - grid.x, grid.y - world.y) / pass.heightsGrid.x - 0.5;
+    if (any(cell < -0.5) || any(cell > float2(size) - 0.5)) {
+        return false;
+    }
+    let base = int2(floor(cell));
+    let f = saturate(cell - float2(base));
+    float h[4];
+    for (uint k = 0; k < 4; ++k) {
+        let at = clamp(base + int2(k & 1, k >> 1), int2(0), size - 1);
+        h[k] = terrainHeights.Load(int3(at, 0));
+        if ((pass.heightsGrid.w > 0.5 && h[k] == pass.heightsGrid.z) || isnan(h[k])) {
+            return false;
+        }
+    }
+    let ground = lerp(lerp(h[0], h[1], f.x), lerp(h[2], h[3], f.x), f.y);
+    above = (world.z + pass.heightsGrid.y) / grid.w - ground;
+    return true;
+}
+
+// The dome's visibility and bent normal at world point `world` (relative to the frame's origin)
+// with unit normal `n`, `above` height units over the terrain (0 on it), from the terrain's
+// horizon map: the horizons around the point (bilinear in its texels, linear between the levels
+// bracketing `above`, extrapolated past the highest), in four vertical slices whose horizons to
+// either side are the map's opposite azimuths, integrated as `occlusionSlice` does about the
+// vertical. They see the whole terrain, on screen or not, at the map's resolution.
+float4 terrainOcclusion(float3 world, float3 n, float above) {
     let grid = pass.horizonGrid;
     let cell = float2(world.x - grid.x, grid.y - world.y) / grid.z - 0.5;
     let base = int2(floor(cell));
     let f = cell - float2(base);
-    float4 a0, a1, b0, b1, c0, c1, d0, d1;
-    horizonTexel(base, a0, a1);
-    horizonTexel(base + int2(1, 0), b0, b1);
-    horizonTexel(base + int2(0, 1), c0, c1);
-    horizonTexel(base + int2(1, 1), d0, d1);
-    let first = lerp(lerp(a0, b0, f.x), lerp(c0, d0, f.x), f.y) * grid.w;
-    let second = lerp(lerp(a1, b1, f.x), lerp(c1, d1, f.x), f.y) * grid.w;
+    uint lower = 0;
+    while (lower + 2 < kHorizonLevels && above > pass.horizonLevels[lower + 1]) {
+        lower += 1;
+    }
+    float4 first, second;
+    horizonAround(base, f, lower, first, second);
+    if (above > 0.0) {
+        float4 upperFirst, upperSecond;
+        horizonAround(base, f, lower + 1, upperFirst, upperSecond);
+        let span = pass.horizonLevels[lower + 1] - pass.horizonLevels[lower];
+        let t = span > 0.0 ? (above - pass.horizonLevels[lower]) / span : 0.0;
+        first = max(lerp(first, upperFirst, t), float4(-100.0));
+        second = max(lerp(second, upperSecond, t), float4(-100.0));
+    }
+    first *= grid.w;
+    second *= grid.w;
     // Elevation tangents as cosines of the angle from the vertical: sin(atan(t)).
     let up = float3(0.0, 0.0, 1.0);
     let towards = first * rsqrt(1.0 + first * first);
@@ -627,12 +684,17 @@ void occlusionMain(uint3 id : SV_DispatchThreadID) {
     let v = viewVector(ndc.xy, world);
     let n = facingNormal(normalize(gNormal.Load(pixel).xyz), v);
     var occlusion = domeOcclusion(int2(id.xy), id.z, world, ndc.z, n, v);
-    // Over terrain, the horizon map's occlusion too, which sees the whole terrain: the less
-    // visible of the two (as Unreal combines distance field and screen-space occlusion).
-    if (pass.horizonInfo.w != 0 && gIds.Load(pixel).y == pass.horizonInfo.z) {
-        let terrain = terrainOcclusion(world, n);
-        if (terrain.w < occlusion.w) {
-            occlusion = terrain;
+    // Over terrain, and on what stands over it, the horizon map's occlusion too, which sees the
+    // whole terrain: the less visible of the two (as Unreal combines distance field and
+    // screen-space occlusion).
+    if (pass.horizonInfo.w != 0) {
+        float above = 0.0;
+        let onTerrain = gIds.Load(pixel).y == pass.horizonInfo.z;
+        if (onTerrain || aboveTerrain(world, above)) {
+            let terrain = terrainOcclusion(world, n, onTerrain ? 0.0 : max(above, 0.0));
+            if (terrain.w < occlusion.w) {
+                occlusion = terrain;
+            }
         }
     }
     occlusionRaw[id] = occlusion;