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

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/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 ".dev196" CACHE STRING "Pre-release suffix of Ernie's version, such as .dev12")
+set(ERNIE_VERSION_SUFFIX ".dev202" 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.dev196 → ernie_renderer-0.1.0.dev202}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.1.0.dev196
+Version: 0.1.0.dev202
 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
@@ -37,7 +37,7 @@ Description-Content-Type: text/markdown
 
 Ernie is a physically accurate, real-time, spectral renderer for interplanetary environments.
 
-We provide C++ and Python APIs and a Hydra-like scene API. It is a Vulkan 1.3 rasterizer that runs on Linux today, with Windows and macOS on the way. Ernie is designed around physical quantities rather than artistic parameters: lights, materials and cameras are described the way they are measured, so a render can be compared against a real instrument. For reinforcement learning, Ernie renders batches of cameras in one step, shares data zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), and has a fast mode with simpler shading.
+We provide C++ and Python APIs and a Hydra-like scene API. It is a Vulkan 1.3 rasterizer that runs on Linux, and builds on Windows and macOS (experimental: not yet tested there). Ernie is designed around physical quantities rather than artistic parameters: lights, materials and cameras are described the way they are measured, so a render can be compared against a real instrument. For reinforcement learning, Ernie renders batches of cameras in one step, shares data zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), and has a fast mode with simpler shading.
 
 Ernie's key features related to planetary robotics and sensing:
 

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/README.md

@@ -6,7 +6,7 @@
 
 Ernie is a physically accurate, real-time, spectral renderer for interplanetary environments.
 
-We provide C++ and Python APIs and a Hydra-like scene API. It is a Vulkan 1.3 rasterizer that runs on Linux today, with Windows and macOS on the way. Ernie is designed around physical quantities rather than artistic parameters: lights, materials and cameras are described the way they are measured, so a render can be compared against a real instrument. For reinforcement learning, Ernie renders batches of cameras in one step, shares data zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), and has a fast mode with simpler shading.
+We provide C++ and Python APIs and a Hydra-like scene API. It is a Vulkan 1.3 rasterizer that runs on Linux, and builds on Windows and macOS (experimental: not yet tested there). Ernie is designed around physical quantities rather than artistic parameters: lights, materials and cameras are described the way they are measured, so a render can be compared against a real instrument. For reinforcement learning, Ernie renders batches of cameras in one step, shares data zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), and has a fast mode with simpler shading.
 
 Ernie's key features related to planetary robotics and sensing:
 

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

@@ -28,8 +28,6 @@
 #include "ernie/scene/xform.h"
 #include "util.h"
 
-#include <imgui.h>
-
 #include <algorithm>
 #include <array>
 #include <cmath>
@@ -146,20 +144,15 @@ class IlluminantsDemo : public app::Demo {
             .SetAmbient(0.0);
         LightWith(0);
 
+        // The demo's option, in the Demos panel: the illuminant.
+        std::vector<std::string> names;
+        for (const Illuminant& illuminant : kIlluminants) {
+            names.emplace_back(illuminant.name);
+        }
+        Widgets().Combo("Illuminant", std::move(names), 0,
+                        [this](std::size_t index) { LightWith(static_cast<int>(index)); });
         if (viewer != nullptr) {
-            // In the viewer, a panel switches the illuminant.
             viewer->SetActiveCamera("/World/Camera");
-            viewer->AddPanel("Illuminant", app::Dock::Right, [this](app::Viewer&) {
-                int index = illuminant_;
-                for (int i = 0; i < static_cast<int>(kIlluminants.size()); ++i) {
-                    if (ImGui::RadioButton(kIlluminants[i].name, i == index)) {
-                        index = i;
-                    }
-                }
-                if (index != illuminant_) {
-                    LightWith(index);
-                }
-            });
         }
     }
 

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

@@ -102,14 +102,11 @@ class Demo(ernie.demo.Demo):
                           resolution=(448, 300), ambient=0.0)
         self.light_with(0)
 
+        # The demo's option, in the Demos panel: the illuminant.
+        self.widgets.combo("Illuminant", [name for name, _, _ in ILLUMINANTS], 0,
+                           on_change=self.light_with)
         if viewer is not None:
-            # In the viewer, a panel switches the illuminant.
-            from ernie.app import Dock
-
             viewer.active_camera = camera.path
-            panel = viewer.add_panel("Illuminant", Dock.RIGHT)
-            panel.combo("Illuminant", [name for name, _, _ in ILLUMINANTS], 0,
-                        on_change=self.light_with)
 
     def light_with(self, index):
         _, illuminant, kelvin = ILLUMINANTS[index]

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/demos/viewer/sun_panel.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: BSD-3-Clause
-// Opens the viewer on a scene built in code, with a panel of its own that moves the sun. The C++
-// twin of sun_panel.py.
+// Opens the viewer on a scene built in code, with options in the Demos panel that move the sun.
+// The C++ twin of sun_panel.py.
 //
 //     ernie --demo viewer/sun_panel [--viewer null --output sun.png]
 
@@ -43,15 +43,15 @@ class SunPanelDemo : public app::Demo {
             .SetFocalLength(24.0)
             .SetTransform(LookAtTransform({0.0, -14.0, 6.0}, {0.0, 0.0, 0.5}, {0.0, 0.0, 1.0}));
         AimSun();
-        if (viewer != nullptr) {
-            // Panels draw with Dear ImGui and edit the scene, which the next frame renders.
-            viewer->AddPanel("Sun", app::Dock::Left, [this](app::Viewer&) {
-                bool changed = ImGui::SliderFloat("Elevation", &elevation_, 1.0f, 90.0f);
-                changed |= ImGui::SliderFloat("Azimuth", &azimuth_, 0.0f, 360.0f);
-                if (changed) {
-                    AimSun();
-                }
-            });
+    }
+
+    // The demo's options, in the Demos panel: sliders drawn with Dear ImGui that move the sun,
+    // which the next frame renders.
+    void Gui() override {
+        bool changed = ImGui::SliderFloat("Elevation", &elevation_, 1.0f, 90.0f);
+        changed |= ImGui::SliderFloat("Azimuth", &azimuth_, 0.0f, 360.0f);
+        if (changed) {
+            AimSun();
         }
     }
 
@@ -76,4 +76,4 @@ class SunPanelDemo : public app::Demo {
 }  // namespace
 
 ERNIE_REGISTER_DEMO(SunPanelDemo, "viewer", "sun panel",
-                    "A scene built in code, with a panel of its own that moves the sun.");
+                    "A scene built in code, with options that move the sun.");

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/demos/viewer/sun_panel.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
-"""Opens the viewer on a scene built in code, with a panel of its own that moves the sun. The
-Python twin of sun_panel.cpp.
+"""Opens the viewer on a scene built in code, with options in the Demos panel that move the sun.
+The Python twin of sun_panel.cpp.
 
     python -m ernie.demos viewer/sun_panel [--viewer null --output sun.png]
 """
@@ -31,14 +31,11 @@ class Demo(ernie.demo.Demo):
         self.elevation = 45.0
         self.azimuth = 30.0
         self.aim_sun()
-        if viewer is not None:
-            from ernie.app import Dock
-
-            panel = viewer.add_panel("Sun", Dock.LEFT)
-            panel.slider("Elevation", 1.0, 90.0, self.elevation,
-                         on_change=lambda value: self.aim_sun(elevation=value))
-            panel.slider("Azimuth", 0.0, 360.0, self.azimuth,
-                         on_change=lambda value: self.aim_sun(azimuth=value))
+        # The demo's options, in the Demos panel: sliders that move the sun.
+        self.widgets.slider("Elevation", 1.0, 90.0, self.elevation,
+                            on_change=lambda value: self.aim_sun(elevation=value))
+        self.widgets.slider("Azimuth", 0.0, 360.0, self.azimuth,
+                            on_change=lambda value: self.aim_sun(azimuth=value))
 
     def aim_sun(self, elevation=None, azimuth=None):
         self.elevation = self.elevation if elevation is None else elevation

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/docs/getting-started/demos.md

@@ -24,7 +24,7 @@ python -m ernie.demos lighting/illuminants    # one by name, with its options af
 
 From a checkout, run the files themselves (`PYTHONPATH=build/python python demos/lighting/illuminants.py`), or a C++ demo's own program, which `-DERNIE_BUILD_DEMOS=ON` builds as `demo_<category>_<name>` (`build/bin/demo_lighting_illuminants`).
 
-Each opens the viewer with a Demos panel on the left. Its menu lists the demos in the same language, by category; choosing one clears the scene and builds that demo in the same window. The panel also pauses, single-steps and resets the demo.
+Each opens the viewer with a Demos panel at the bottom, a tab beside the Log and Stats. It lists the demos in the same language under a collapsing header per category; choosing one clears the scene and builds that demo in the same window. Below the list it pauses, single-steps and resets the running demo, describes it, and shows its options.
 
 Every demo takes these options:
 
@@ -76,10 +76,9 @@ class Demo(ernie.demo.Demo):
             tokens.TRANSFORM, ernie.distant_light_transform((0.4, -0.6, 0.7)))
         world.define("Camera", ernie.Camera).set(
             tokens.TRANSFORM, ernie.look_at_transform((0, -8, 3), (0, 0, 0.5)))
-        if viewer is not None:
-            panel = viewer.add_panel("Ball")
-            panel.slider("Radius", 0.1, 2.0, 0.5,
-                         on_change=lambda value: self.ball.set(radius=value))
+        # The demo's options, shown in the Demos panel.
+        self.widgets.slider("Radius", 0.1, 2.0, 0.5,
+                            on_change=lambda value: self.ball.set(radius=value))
 
     def step(self):
         self.ball.set(translate=(2.0 * self.time, 0, 0.5))
@@ -94,7 +93,8 @@ if __name__ == "__main__":
 
 What to know:
 
-- `viewer` is `None` under `--viewer null`, so put panels and other viewer calls under `if viewer is not None`. Give the scene a camera of its own: without a viewer, and in tests, the scene renders through it.
+- A demo's own controls go in the Demos panel's Options section: add widgets to `self.widgets` (sliders, checkboxes, combos, buttons, plots), which works with or without a viewer. C++ demos can also override `Gui()` and draw there with Dear ImGui, as Newton's examples' `gui(ui)` does.
+- `viewer` is `None` under `--viewer null`, so put other viewer calls (such as `active_camera`) under `if viewer is not None`. Give the scene a camera of its own: without a viewer, and in tests, the scene renders through it.
 - In a window `frame_dt` is the real time since the last frame (at most `max_frame_dt`). Without one it is `fixed_dt`, so runs repeat exactly. `self.time` is the demo's clock at the start of the step.
 - A demo uses the viewer as any application does: `add_panel`, `on_frame`, `add_hud_item`, `active_camera`, `viewport_display`. A demo registers in a scope of its own (`Viewer.scope`), so when the Demos panel switches away, what it added is removed, and the viewport's display settings are restored. A camera, lighting or RenderSettings it chooses is kept over the viewer's reset of its session.
 - Add your own options by overriding the class method `create_parser`, adding to what `super().create_parser()` returns. Give every option a default: the Demos panel opens demos with their defaults.
@@ -119,7 +119,7 @@ class BallDemo : public ernie::app::Demo {
         : Demo(viewer, options) {
         numFrames = 120;
         ernie::Sphere::Define(GetScene(), "/World/Ball").SetRadius(0.5);
-        // ... a sun and a camera, and a panel when GetViewer() is not null
+        // ... a sun, a camera, and options: Widgets().Slider(...), or override Gui()
     }
 
     void Step() override {

ernie_renderer-0.1.0.dev202/docs/js/sidebar.js

@@ -0,0 +1,29 @@
+// The readthedocs theme brings the current page's sidebar entry into view with scrollIntoView(),
+// which scrolls every scrollable ancestor, the page included, so the page jumps to line up with the
+// entry. Keep the theme's highlighting and expanding, but scroll only the sidebar, and only when
+// the entry is out of its view.
+(function () {
+  var nav = window.SphinxRtdTheme && window.SphinxRtdTheme.Navigation;
+  if (!nav || typeof nav.reset !== "function") {
+    return;
+  }
+  var reset = nav.reset;
+  nav.reset = function () {
+    var scrollIntoView = Element.prototype.scrollIntoView;
+    Element.prototype.scrollIntoView = function () {
+      var sidebar = document.querySelector("div.wy-side-scroll");
+      if (!sidebar || !sidebar.contains(this)) {
+        return scrollIntoView.apply(this, arguments);
+      }
+      var top = this.getBoundingClientRect().top - sidebar.getBoundingClientRect().top;
+      if (top < 0 || top > sidebar.clientHeight - this.offsetHeight) {
+        sidebar.scrollTop += top - sidebar.clientHeight / 3;
+      }
+    };
+    try {
+      return reset.apply(this, arguments);
+    } finally {
+      Element.prototype.scrollIntoView = scrollIntoView;
+    }
+  };
+})();

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/ernie/app/demo.cpp

@@ -3,6 +3,7 @@
 
 #include "ernie/app/panel.h"
 
+#include <imgui.h>
 #include <stb_image_write.h>
 
 #include <algorithm>
@@ -199,6 +200,19 @@ void Demo::TestFinal() {
 
 void Demo::Close() {}
 
+void Demo::Gui() {}
+
+WidgetPanel& Demo::Widgets() {
+    return *SharedWidgets();
+}
+
+std::shared_ptr<WidgetPanel> Demo::SharedWidgets() {
+    if (!widgets_) {
+        widgets_ = std::make_shared<WidgetPanel>("Options", Dock::Floating);
+    }
+    return widgets_;
+}
+
 std::uint64_t Demo::NumFrames() const {
     return numFrames;
 }
@@ -320,12 +334,12 @@ struct DemoRunner::State {
     Viewer::Gizmo gizmo = Viewer::Gizmo::None;
     bool gizmoLocal = false;
 
-    // The Demos panel and what it asked for during the last frame.
-    WidgetPanel* panel = nullptr;
-    WidgetPanel::Id status = 0;
-    WidgetPanel::Id about = 0;
+    // The Demos panel, the demo it shows, and what it asked for during the last frame.
+    Panel* panel = nullptr;
+    Demo* running = nullptr;
+    std::string about;  ///< The running demo's description.
+    bool paused = false;
     std::optional<std::size_t> switchTo;
-    std::optional<bool> pausedRequest;
     bool resetRequested = false;
     bool singleStep = false;
 
@@ -340,11 +354,9 @@ struct DemoRunner::State {
     }
 
     void Announce(Demo& demo) {
-        const std::string description = DescriptionOf(demo);
-        viewer->Log(LogLevel::Info, "Demo: " + (description.empty() ? "untitled" : description));
-        if (panel != nullptr) {
-            panel->Set(about, description);
-        }
+        running = &demo;
+        about = DescriptionOf(demo);
+        viewer->Log(LogLevel::Info, "Demo: " + (about.empty() ? "untitled" : about));
     }
 
     std::string DescriptionOf(Demo& demo) const {
@@ -355,35 +367,77 @@ struct DemoRunner::State {
         return description;
     }
 
-    void AddPanel(Demo& demo) {
+    void AddPanel() {
         const std::uint64_t previous = viewer->Scope();
         viewer->SetScope(0);
-        panel = &viewer->AddWidgetPanel("Demos", Dock::Left);
-        if (catalog.empty()) {
-            panel->Text("No other demos");
-        } else {
-            std::vector<std::string> labels;
-            for (const DemoInfo& info : catalog) {
-                labels.push_back(info.Label());
-            }
-            panel->Combo("Demo", std::move(labels), current,
-                         [this](std::size_t index) { switchTo = index; });
+        // In the bottom dock with the Log and Stats, the Log staying in front.
+        panel = &viewer->AddPanel("Demos", Dock::Bottom, [this](Viewer& v) { DrawPanel(v); });
+        if (viewer->FindPanel("Log") != nullptr) {
+            viewer->FocusPanel("Log");
         }
-        panel->Separator();
-        panel->Checkbox("Paused", options.paused, [this](bool on) { pausedRequest = on; });
-        panel->Button("Step", [this] { singleStep = true; });
-        panel->Button("Reset", [this] { resetRequested = true; });
-        status = panel->Text("");
-        panel->Separator();
-        about = panel->Text(DescriptionOf(demo));
         viewer->SetScope(previous);
     }
 
+    /// The Demos panel, after Newton's example browser: a menu of the demos with a node per
+    /// category, the running demo's controls and description, and its own options.
+    void DrawPanel(Viewer& v) {
+        // A collapsing header per category, the catalogue listing each category's demos
+        // together; the running demo's opens first.
+        for (std::size_t first = 0; first < catalog.size();) {
+            const std::string& category = catalog[first].category;
+            std::size_t end = first;
+            while (end < catalog.size() && catalog[end].category == category) {
+                ++end;
+            }
+            ImGui::SetNextItemOpen(current >= first && current < end, ImGuiCond_Appearing);
+            if (ImGui::CollapsingHeader(category.c_str())) {
+                ImGui::Indent();
+                for (std::size_t i = first; i < end; ++i) {
+                    if (ImGui::Selectable(catalog[i].name.c_str(),
+                                          i == current && running != nullptr)) {
+                        switchTo = i;
+                    }
+                }
+                ImGui::Unindent();
+            }
+            first = end;
+        }
+        ImGui::SeparatorText(running != nullptr && current < catalog.size()
+                                 ? catalog[current].Label().c_str()
+                                 : "No demo");
+        ImGui::Checkbox("Paused", &paused);
+        ImGui::SameLine();
+        if (ImGui::Button("Step")) {
+            singleStep = true;
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Reset")) {
+            resetRequested = true;
+        }
+        if (running == nullptr) {
+            return;
+        }
+        ImGui::SameLine();
+        ImGui::TextDisabled("frame %llu, %.2f s", static_cast<unsigned long long>(running->frame),
+                            running->time);
+        if (!about.empty()) {
+            ImGui::TextWrapped("%s", about.c_str());
+        }
+        ImGui::SeparatorText("Options");
+        ImGui::PushID("options");
+        running->Widgets().Draw(v);
+        running->Gui();
+        ImGui::PopID();
+    }
+
     /// Replaces `old` with a new build of the catalogue's demo `index`; null, with the error in
     /// the log, if it cannot be built.
     std::shared_ptr<Demo> Load(std::shared_ptr<Demo> old, std::size_t index) {
+        running = nullptr;
         if (old) {
             old->Close();
+            // Its widgets' callbacks may hold it (in Python, a cycle through C++).
+            old->Widgets().Clear();
         }
         viewer->RemoveScope(scope);
         RestoreDisplay();
@@ -407,9 +461,7 @@ struct DemoRunner::State {
             viewer->RemoveScope(scope);
             viewer->ClearScene();
             viewer->ResetSession();
-            if (panel != nullptr) {
-                panel->Set(about, std::string());
-            }
+            about.clear();
             return nullptr;
         }
     }
@@ -417,6 +469,7 @@ struct DemoRunner::State {
     /// Removes the running demo's registrations and the panel, which hold the demo (and in
     /// Python, through it the viewer).
     void Release() {
+        running = nullptr;
         if (!viewer) {
             return;
         }
@@ -519,20 +572,18 @@ std::shared_ptr<Demo> DemoRunner::Run(std::shared_ptr<Demo> demo) {
     try {
         if (viewer != nullptr) {
             viewer->ResetSession();
-            if (o.Windowed() && !o.test) {
-                s.AddPanel(*demo);
+            // The Demos panel, also in a hidden viewer, whose window captures show it; not in
+            // test runs, which check one demo.
+            if (!o.test) {
+                s.AddPanel();
             }
             s.Announce(*demo);
         }
-        bool paused = o.paused && o.Windowed();
+        s.paused = o.paused && o.Windowed();
         std::optional<Clock::time_point> timerStart;
         std::uint64_t timedFrames = 0;
         Clock::time_point last = Clock::now();
         while (viewer == nullptr || viewer->IsOpen()) {
-            if (s.pausedRequest) {
-                paused = *s.pausedRequest;
-                s.pausedRequest.reset();
-            }
             if (s.switchTo || s.resetRequested) {
                 const std::size_t index = s.switchTo.value_or(s.current);
                 s.switchTo.reset();
@@ -543,13 +594,6 @@ std::shared_ptr<Demo> DemoRunner::Run(std::shared_ptr<Demo> demo) {
                 viewer->Step();
                 continue;
             }
-            if (s.panel != nullptr) {
-                char status[96];
-                std::snprintf(status, sizeof(status), "frame %llu, %.2f s%s",
-                              static_cast<unsigned long long>(demo->frame), demo->time,
-                              paused ? "  (paused)" : "");
-                s.panel->Set(s.status, std::string(status));
-            }
             const std::optional<std::uint64_t> limit =
                 o.numFrames ? o.numFrames
                             : (o.Windowed() ? std::nullopt
@@ -563,8 +607,8 @@ std::shared_ptr<Demo> DemoRunner::Run(std::shared_ptr<Demo> demo) {
                                            demo->MaxFrameDt())
                                 : demo->FixedDt();
             last = now;
-            bool stepping = !paused;
-            if (paused && s.singleStep) {
+            bool stepping = !s.paused;
+            if (s.paused && s.singleStep) {
                 stepping = true;
                 s.singleStep = false;
             }
@@ -621,8 +665,13 @@ std::shared_ptr<Demo> DemoRunner::Run(std::shared_ptr<Demo> demo) {
         std::fflush(stdout);
         if (demo) {
             demo->Close();
+            // Its widgets' callbacks may hold it (in Python, a cycle through C++).
+            demo->Widgets().Clear();
         }
     } catch (...) {
+        if (demo) {
+            demo->Widgets().Clear();
+        }
         s.Release();
         throw;
     }

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/ernie/app/demo.h

@@ -106,6 +106,20 @@ class Demo {
     /// replaces it; for timing reports and the like.
     virtual void Close();
 
+    /// Draws the demo's own controls with Dear ImGui (`#include <imgui.h>`) in the Demos panel's
+    /// Options section each frame, after its `Widgets`, as Newton's examples' `gui(ui)` does;
+    /// nothing by default. Runs only in a viewer.
+    virtual void Gui();
+
+    /// The demo's controls in the Demos panel's Options section, as widgets (sliders, checkboxes,
+    /// combos) rather than ImGui calls, as Python demos add theirs (`widgets`). Add them in the
+    /// constructor, with or without a viewer; the runner drops them, with their callbacks, when
+    /// the demo ends or is replaced.
+    WidgetPanel& Widgets();
+
+    /// `Widgets` shared, for holders that may outlive the demo, such as its Python wrapper.
+    std::shared_ptr<WidgetPanel> SharedWidgets();
+
     /// Frames to run without a window when `--num-frames` is not given: `numFrames`.
     virtual std::uint64_t NumFrames() const;
     /// Seconds a step advances without a window, for runs that repeat: `fixedDt`.
@@ -160,6 +174,7 @@ class Demo {
     DemoOptions options_;
     std::shared_ptr<Scene> ownScene_;
     std::shared_ptr<Renderer> renderer_;
+    std::shared_ptr<WidgetPanel> widgets_;
     Tensor image_;
     bool untestedSteps_ = false;
     bool untestedFinal_ = false;

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/ernie/kernel/CMakeLists.txt

@@ -21,6 +21,7 @@ set(ernie_shaders
     film/filter_defect_pixels.slang=kFilterDefectPixelsSlang
     film/filter_demosaic.slang=kFilterDemosaicSlang
     film/filter_detector_pattern.slang=kFilterDetectorPatternSlang
+    film/filter_flare.slang=kFilterFlareSlang
     film/filter_glare.slang=kFilterGlareSlang
     film/filter_jpeg.slang=kFilterJpegSlang
     film/filter_lag.slang=kFilterLagSlang
@@ -29,6 +30,7 @@ set(ernie_shaders
     film/filter_readout_taps.slang=kFilterReadoutTapsSlang
     film/filter_smear.slang=kFilterSmearSlang
     film/filter_spectral_transmission.slang=kFilterSpectralTransmissionSlang
+    film/filter_stray_light.slang=kFilterStrayLightSlang
     film/filter_tdi.slang=kFilterTdiSlang
     film/filter_temporal_average.slang=kFilterTemporalAverageSlang
     film/filter_tone_curve.slang=kFilterToneCurveSlang

{ernie_renderer-0.1.0.dev196 → ernie_renderer-0.1.0.dev202}/ernie/kernel/embedded_shaders.h

@@ -44,6 +44,7 @@ extern const char kFilterDemosaicSlang[];
 extern const char kFilterJpegSlang[];
 extern const char kFilterSmearSlang[];
 extern const char kFilterDetectorPatternSlang[];
+extern const char kFilterFlareSlang[];
 extern const char kFilterGlareSlang[];
 extern const char kFilterLagSlang[];
 extern const char kFilterMeasuredQeSlang[];
@@ -52,6 +53,7 @@ extern const char kFilterReadoutTapsSlang[];
 extern const char kFilterTdiSlang[];
 extern const char kFilterTemporalAverageSlang[];
 extern const char kFilterSpectralTransmissionSlang[];
+extern const char kFilterStrayLightSlang[];
 extern const char kFilterToneCurveSlang[];
 extern const char kFilterWhiteBalanceSlang[];