ernie-renderer 0.2.0.dev127__tar.gz → 0.2.0.dev135__tar.gz

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/.github/workflows/ci.yml

@@ -145,7 +145,7 @@ jobs:
       - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
           python-version: "3.12"
-      - run: python -m pip install pytest jsonschema
+      - run: python -m pip install pytest jsonschema numpy pillow
       - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           name: build-${{ matrix.os }}
@@ -190,7 +190,7 @@ jobs:
       - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
           python-version: "3.12"
-      - run: python -m pip install nanobind ninja pytest gcovr
+      - run: python -m pip install nanobind ninja pytest gcovr numpy pillow
       - uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: .deps

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev127
+Version: 0.2.0.dev135
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause
@@ -9,8 +9,10 @@ Project-URL: Homepage, https://github.com/alexmaietta/ernie
 Project-URL: Repository, https://github.com/alexmaietta/ernie
 Project-URL: Issues, https://github.com/alexmaietta/ernie/issues
 Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pillow; extra == "test"
 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.

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/cmake/ErnieInstall.cmake

@@ -42,7 +42,10 @@ else()
 endif()
 
 set(ernie_public_headers
+    util/algorithm.h
+    util/bytes.h
     util/glm.h
+    util/hash_index.h
     util/log.h
     util/file.h
     util/profiler.h
@@ -52,6 +55,31 @@ set(ernie_public_headers
     io/image.h
     io/raster.h
     io/texture.h
+    geometry/bounds.h
+    physics/astronomy.h
+    scene/convert.h
+    scene/extent_cache.h
+    scene/holder_index.h
+    scene/path.h
+    scene/scene.h
+    scene/schema.h
+    scene/storage.h
+    scene/time_samples.h
+    scene/tokens.h
+    scene/value.h
+    scene/view.h
+    scene/xform.h
+    scene/schema/camera.h
+    scene/schema/collection.h
+    scene/schema/geom.h
+    scene/schema/instancer.h
+    scene/schema/lux.h
+    scene/schema/mesh.h
+    scene/schema/planet.h
+    scene/schema/render.h
+    scene/schema/shade.h
+    scene/schema/vol.h
+    render/renderer.h
 )
 foreach(header ${ernie_public_headers})
     get_filename_component(directory "${header}" DIRECTORY)

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/app/viewer.h

@@ -7,8 +7,8 @@
 #include "ernie/app/imgui_backend.h"
 #include "ernie/app/ui.h"
 #include "ernie/device/bindless.h"
-#include "ernie/render/camera_pass.h"
 #include "ernie/render/device_scene.h"
+#include "ernie/render/rt/camera_pass.h"
 
 #include <glm/vec2.hpp>
 

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/device/column.h

@@ -5,6 +5,8 @@
 #pragma once
 
 #include "ernie/device/arena.h"
+#include "ernie/device/staging.h"
+#include "ernie/util/algorithm.h"
 #include "ernie/util/tensor.h"
 
 #include <cstdint>
@@ -104,4 +106,15 @@ class DeviceColumn {
     BufferRange range_;
 };
 
+/// @brief Stages `rows` of a host mirror into the same rows of `column`. The rows are sorted and
+/// made unique in place, and those past the mirror's end dropped; the caller clears them.
+template <typename T>
+void StageRows(Uploader& uploader, const DeviceColumn& column, const std::vector<T>& host,
+               std::vector<std::uint32_t>& rows) {
+    SortUnique(rows);
+    std::erase_if(rows, [&](std::uint32_t row) { return row >= host.size(); });
+    uploader.WriteRows(column.Storage(), column.Range().offset, column.RowBytes(),
+                       std::as_bytes(std::span(host)), rows);
+}
+
 }  // namespace ernie

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/device/shader_compiler.cpp

@@ -98,8 +98,12 @@ std::vector<std::uint32_t> ShaderCompiler::Spirv(std::span<const ShaderModule> m
     ERNIE_ZONE("Compile Slang to SPIR-V");
     const Slang::ComPtr<slang::IBlob> code =
         session_->Compile(modules, entryPoint, SLANG_SPIRV, "spirv_1_6");
-    std::vector<std::uint32_t> words(code->getBufferSize() / 4);
-    std::memcpy(words.data(), code->getBufferPointer(), words.size() * 4);
+    constexpr std::size_t kWord = sizeof(std::uint32_t);
+    if (code->getBufferSize() % kWord != 0) {
+        throw std::runtime_error("Slang's SPIR-V is not whole 32-bit words");
+    }
+    std::vector<std::uint32_t> words(code->getBufferSize() / kWord);
+    std::memcpy(words.data(), code->getBufferPointer(), code->getBufferSize());
     return words;
 }
 

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/device/vulkan.cpp

@@ -42,8 +42,9 @@ const std::array kExtensions{
 /// - Vulkan does not promise `fma` rounds once (lavapipe does not): double-float products split
 ///   their operands instead.
 void WorkAroundDrivers(VkDriverId driver, DeviceCapabilities& capabilities) {
-#if defined(__APPLE__)
-    // Homebrew's lavapipe crashes or hangs building and tracing acceleration structures.
+#if defined(__aarch64__) || defined(_M_ARM64)
+    // lavapipe on arm64 crashes or hangs building and tracing acceleration structures: Homebrew's
+    // on macOS, and Mesa 24's on Ubuntu 24.04.
     if (driver == VK_DRIVER_ID_MESA_LLVMPIPE) {
         capabilities.rayQuery = false;
     }

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/graph/graph.cpp

@@ -230,7 +230,8 @@ Image Graph::Import(DeviceImage& image, std::string_view name) {
 }
 
 Buffer Graph::Import(const DeviceColumn& column, std::string_view name) {
-    return Import(column.Storage(), column.Range().offset, column.Bytes(), name);
+    return Import(column.Storage(), column.Range().offset, column.Bytes(),
+                  name.empty() ? column.Name() : name);
 }
 
 Acceleration Graph::Import(const AccelerationStructure& structure) {
@@ -562,4 +563,25 @@ std::string Graph::Dot() const {
     return dot.str();
 }
 
+void AddUploadPass(Graph& graph, std::string_view name, Uploader& uploader,
+                   std::span<Buffer> targets) {
+    if (!uploader.Staged()) {
+        return;
+    }
+    graph.Add(
+        name, Kind::Copy,
+        [&](PassBuilder& pass) {
+            for (Buffer& target : targets) {
+                if (target.Valid()) {
+                    target = pass.Write(target, Use::CopyDst);
+                }
+            }
+        },
+        [&uploader](PassContext& pass) {
+            for (std::shared_ptr<const ernie::Buffer>& staging : uploader.Record(pass.commands)) {
+                pass.Keep(std::move(staging));
+            }
+        });
+}
+
 }  // namespace ernie::graph

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/graph/graph.h

@@ -173,8 +173,9 @@ class Graph {
     /// resource. The image outlives `Execute`'s work.
     /// @return The handle of its latest version.
     Image Import(DeviceImage& image, std::string_view name);
-    /// @brief Uses a column's rows, as kernels, CUDA or Warp write them.
-    Buffer Import(const DeviceColumn& column, std::string_view name);
+    /// @brief Uses a column's rows, as kernels, CUDA or Warp write them, under `name` or the
+    /// column's own.
+    Buffer Import(const DeviceColumn& column, std::string_view name = {});
     /// @brief Uses a range of a buffer owned outside the graph.
     Buffer Import(const ernie::Buffer& buffer, std::uint64_t offset, std::uint64_t size,
                   std::string_view name);
@@ -322,4 +323,10 @@ class Graph {
     bool flushEachPass_ = false;
 };
 
+/// @brief Adds a copy pass recording what `uploader` staged into `targets`, which later passes then
+/// see written; invalid handles among them are skipped. The staging buffers live until the graph's
+/// work is done. Nothing is added when nothing is staged.
+void AddUploadPass(Graph& graph, std::string_view name, Uploader& uploader,
+                   std::span<Buffer> targets);
+
 }  // namespace ernie::graph

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/python/CMakeLists.txt

@@ -4,7 +4,16 @@ include("${PROJECT_SOURCE_DIR}/cmake/third_party/nanobind.cmake")
 # The package is assembled in the build tree, so tests import it with PYTHONPATH=<build>/python.
 set(ernie_package_dir "${PROJECT_BINARY_DIR}/python/ernie")
 
-nanobind_add_module(_ernie STABLE_ABI NB_STATIC module.cpp device.cpp dlpack.cpp scene.cpp)
+nanobind_add_module(
+    _ernie
+    STABLE_ABI
+    NB_STATIC
+    module.cpp
+    device.cpp
+    dlpack.cpp
+    render.cpp
+    scene.cpp
+)
 target_link_libraries(
     _ernie
     PRIVATE ernie_static ernie_volk ernie_vma ernie_json ernie_build_options

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/python/ernie/__init__.py

@@ -3,17 +3,25 @@
 
 from ernie import _ernie
 from ernie._ernie import (
+    PRIM_TYPES,
     DeviceColumn,
     DeviceContext,
     Prim,
+    Renderer,
     Scene,
     SceneArray,
     VulkanDeviceInfo,
     VulkanDeviceType,
     __version__,
+    distant_light_transform,
+    look_at_transform,
+    tokens,
     vulkan_devices,
 )
 
+# Each prim type by its name, for scene.define("/World/Rock", ernie.Sphere).
+globals().update({name: name for name in PRIM_TYPES})
+
 
 def cuda_allocator():
     """PyTorch's allocator for tensors Ernie shares in place with ``DeviceContext.wrap``.
@@ -33,14 +41,20 @@ def cuda_allocator():
 
 
 __all__ = [
+    "PRIM_TYPES",
     "DeviceColumn",
     "DeviceContext",
     "Prim",
+    "Renderer",
     "Scene",
     "SceneArray",
     "VulkanDeviceInfo",
     "VulkanDeviceType",
     "__version__",
     "cuda_allocator",
+    "distant_light_transform",
+    "look_at_transform",
+    "tokens",
     "vulkan_devices",
+    *PRIM_TYPES,
 ]

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/python/module.cpp

@@ -3,6 +3,7 @@
 /// @brief The _ernie Python extension module.
 #include "ernie/device/device.h"
 #include "ernie/python/device.h"
+#include "ernie/python/render.h"
 #include "ernie/python/scene.h"
 #include "ernie/util/version.h"
 
@@ -35,6 +36,7 @@ NB_MODULE(_ernie, module) {
 
     ernie::python::BindDevice(module);
     ernie::python::BindScene(module);
+    ernie::python::BindRender(module);
 
     module.def("vulkan_devices", &ernie::ListVulkanDevices,
                "Lists the Vulkan devices of the installed drivers.");

ernie_renderer-0.2.0.dev135/ernie/python/render.cpp

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file render.cpp
+/// @brief Python bindings of the renderer: a scene's render settings rendered to a NumPy image.
+#include "ernie/python/render.h"
+
+#include "ernie/render/renderer.h"
+
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/string.h>
+
+#include <array>
+#include <string>
+
+namespace nb = nanobind;
+
+namespace ernie::python {
+
+void BindRender(nb::module_& module) {
+    nb::class_<Renderer>(module, "Renderer",
+                         "A device and what it keeps of the scene it last rendered, so rendering "
+                         "the same scene again costs only what changed.")
+        .def(
+            "__init__",
+            [](Renderer* self, const std::string& device, bool validation) {
+                new (self) Renderer(RendererOptions{.device = device, .validation = validation});
+            },
+            nb::kw_only(), nb::arg("device") = "", nb::arg("validation") = false,
+            "Opens a device that ray traces: by UUID or part of its name, or the best one.")
+        .def(
+            "render",
+            [](Renderer& self, const Scene& scene) {
+                // The array owns the rendered tensor, so its bytes are copied once, off the device.
+                auto* image = new Tensor(self.Render(scene));
+                const nb::capsule owner(
+                    image, [](void* tensor) noexcept { delete static_cast<Tensor*>(tensor); });
+                const std::vector<std::int64_t>& shape = image->Shape();
+                const std::array<std::size_t, 3> dimensions{static_cast<std::size_t>(shape[0]),
+                                                            static_cast<std::size_t>(shape[1]),
+                                                            static_cast<std::size_t>(shape[2])};
+                return nb::ndarray<nb::numpy, std::uint8_t, nb::ndim<3>>(
+                    static_cast<std::uint8_t*>(image->Data()), 3, dimensions.data(), owner);
+            },
+            nb::arg("scene"),
+            "Renders the camera of the scene's first RenderSettings at its resolution: LdrColor "
+            "as a (height, width, 4) uint8 NumPy array.");
+}
+
+}  // namespace ernie::python

ernie_renderer-0.2.0.dev135/ernie/python/render.h

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file render.h
+/// @brief Binding the renderer to Python.
+#pragma once
+
+#include <nanobind/nanobind.h>
+
+namespace ernie::python {
+
+/// @brief Adds `Renderer` to the module.
+void BindRender(nanobind::module_& module);
+
+}  // namespace ernie::python

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/python/scene.cpp

@@ -9,9 +9,12 @@
 #include "ernie/scene/json.h"
 #include "ernie/scene/json_value.h"
 #include "ernie/scene/scene.h"
+#include "ernie/scene/schema.h"
+#include "ernie/scene/tokens.h"
 #include "ernie/scene/xform.h"
 #include "ernie/util/algorithm.h"
 
+#include <nanobind/stl/array.h>
 #include <nanobind/stl/filesystem.h>
 #include <nanobind/stl/optional.h>
 #include <nanobind/stl/string.h>
@@ -34,16 +37,28 @@ namespace nb = nanobind;
 namespace ernie::python {
 namespace {
 
-/// A prim of a scene, as long as it is not removed.
+/// A prim of a scene, as long as it is not removed; it keeps its scene alive.
 struct Prim {
     PrimId id;
+    nb::object scene;
+
+    Scene& Owner() const {
+        return nb::cast<Scene&>(scene);
+    }
 };
 
+Prim MakePrim(Scene& scene, PrimId id) {
+    return {id, nb::find(&scene)};
+}
+
 /// A prim, or the path of one.
 using Target = std::variant<Prim, std::string>;
 
 PrimId Resolve(const Scene& scene, const Target& target) {
     if (const Prim* prim = std::get_if<Prim>(&target)) {
+        if (&prim->Owner() != &scene) {
+            throw nb::value_error("The prim is another scene's");
+        }
         if (!scene.Store().Alive(prim->id)) {
             throw nb::value_error("The prim has been removed");
         }
@@ -170,19 +185,70 @@ XformOps ReadXformArguments(const nb::object& translate, const nb::object& rotat
     return ReadXform(xform);
 }
 
+/// Authors an attribute from a Python value: an array is shared in place, anything else read as
+/// scene files read it.
+void SetValue(Scene& scene, PrimId prim, const std::string& attribute, const nb::handle& value) {
+    if (IsArray(value)) {
+        Tensor array = TakeTensor(nb::borrow(value), nb::none());
+        Attempt(scene, prim, attribute, [&] { scene.Write(prim, attribute, std::move(array)); });
+        return;
+    }
+    const Json json = ToJson(value);
+    Attempt(scene, prim, attribute, [&] { LoadAttribute(scene, prim, attribute, json); });
+}
+
+using Vector3 = std::array<double, 3>;
+
+glm::dvec3 ToDvec3(const Vector3& v) {
+    return {v[0], v[1], v[2]};
+}
+
+/// The `define` keywords that author transform ops rather than attributes.
+constexpr std::array<std::string_view, 5> kXformKeywords{"translate", "rotate", "rotation_order",
+                                                         "orient", "scale"};
+
+/// @return The transform ops `define`'s keywords author, or none when they author no op.
+std::optional<XformOps> TakeXformKeywords(const nb::kwargs& keywords) {
+    const auto keyword = [&](const char* name) {
+        return keywords.contains(name) ? nb::object(keywords[name]) : nb::none();
+    };
+    const nb::object order = keyword("rotation_order");
+    XformOps xform =
+        ReadXformArguments(keyword("translate"), keyword("rotate"),
+                           order.is_none() ? std::string("XYZ") : nb::cast<std::string>(order),
+                           keyword("orient"), keyword("scale"));
+    if (!xform.translate && !xform.rotate && !xform.orient && !xform.scale) {
+        return std::nullopt;
+    }
+    return xform;
+}
+
 }  // namespace
 
 void BindScene(nb::module_& module) {
     nb::class_<Prim>(module, "Prim", "A prim of a scene, valid until it is removed.")
-        .def("__eq__", [](const Prim& self, const Prim& other) { return self.id == other.id; })
+        .def("__eq__",
+             [](const Prim& self, const Prim& other) {
+                 return self.id == other.id && self.scene.is(other.scene);
+             })
         .def("__hash__",
              [](const Prim& self) {
                  return (static_cast<std::uint64_t>(self.id.generation) << 32) | self.id.slot;
              })
-        .def("__repr__", [](const Prim& self) {
-            return "Prim(" + std::to_string(self.id.slot) + ", " +
-                   std::to_string(self.id.generation) + ")";
-        });
+        .def("__repr__",
+             [](const Prim& self) {
+                 return "Prim(" + std::to_string(self.id.slot) + ", " +
+                        std::to_string(self.id.generation) + ")";
+             })
+        .def(
+            "set",
+            [](const Prim& self, const std::string& attribute, const nb::object& value) {
+                Scene& scene = self.Owner();
+                SetValue(scene, Resolve(scene, self), attribute, value);
+                return self;
+            },
+            nb::arg("attribute"), nb::arg("value"),
+            "Authors an attribute as `Scene.set` does, returning the prim to set more.");
 
     nb::class_<SceneArray>(module, "SceneArray",
                            "An array attribute's values, shared in place through DLPack.")
@@ -207,19 +273,32 @@ void BindScene(nb::module_& module) {
         .def(nb::init<>())
         .def(
             "define",
-            [](Scene& self, const std::string& path, const std::string& type) {
-                return Prim{self.Define(Path(path), type)};
+            [](Scene& self, const std::string& path, const std::string& type,
+               const nb::kwargs& attributes) {
+                const PrimId prim = self.Define(Path(path), type);
+                for (const auto& [key, value] : attributes) {
+                    const std::string name = nb::cast<std::string>(key);
+                    if (std::ranges::find(kXformKeywords, name) == kXformKeywords.end()) {
+                        SetValue(self, prim, name, value);
+                    }
+                }
+                if (const std::optional<XformOps> xform = TakeXformKeywords(attributes)) {
+                    SetXform(self, Path(path), *xform);
+                }
+                return MakePrim(self, prim);
             },
-            nb::arg("path"), nb::arg("type") = "",
-            "Defines a prim of a concrete type, or none, with its missing ancestors.")
+            nb::arg("path"), nb::arg("type") = "", nb::arg("attributes"),
+            "Defines a prim of a concrete type, or none, with its missing ancestors. Keywords "
+            "author its transform ops (translate, rotate, rotation_order, orient, scale, as "
+            "`set_xform`) and attributes by name (radius=2.0), as `set` does.")
         .def(
             "remove", [](Scene& self, const std::string& path) { return self.Remove(Path(path)); },
             nb::arg("path"), "Removes a prim and its descendants; whether there was one.")
         .def(
             "find",
-            [](const Scene& self, const std::string& path) -> std::optional<Prim> {
+            [](Scene& self, const std::string& path) -> std::optional<Prim> {
                 const std::optional<PrimId> prim = self.Find(Path(path));
-                return prim ? std::optional<Prim>(Prim{*prim}) : std::nullopt;
+                return prim ? std::optional<Prim>(MakePrim(self, *prim)) : std::nullopt;
             },
             nb::arg("path"), "The prim at a path, or None.")
         .def("__contains__",
@@ -265,15 +344,7 @@ void BindScene(nb::module_& module) {
             "set",
             [](Scene& self, const Target& target, const std::string& attribute,
                const nb::object& value) {
-                const PrimId prim = Resolve(self, target);
-                if (IsArray(value)) {
-                    Tensor array = TakeTensor(value, nb::none());
-                    Attempt(self, prim, attribute,
-                            [&] { self.Write(prim, attribute, std::move(array)); });
-                    return;
-                }
-                const Json json = ToJson(value);
-                Attempt(self, prim, attribute, [&] { LoadAttribute(self, prim, attribute, json); });
+                SetValue(self, Resolve(self, target), attribute, value);
             },
             nb::arg("prim"), nb::arg("attribute"), nb::arg("value"),
             "Authors an attribute: a number, string, sequence for a vector, quaternion "
@@ -370,6 +441,39 @@ void BindScene(nb::module_& module) {
             "save",
             [](const Scene& self, const std::filesystem::path& path) { SaveSceneFile(self, path); },
             nb::arg("path"), "Writes the scene to a scene file.");
+
+    // Each prim type by its name, for `scene.define(path, ernie.Sphere)`.
+    nb::list types;
+    for (const SchemaDef* schema : Schemas()) {
+        if (schema->kind == SchemaKind::Concrete) {
+            const std::string name(schema->name);
+            module.attr(name.c_str()) = name;
+            types.append(name);
+        }
+    }
+    module.attr("PRIM_TYPES") = nb::tuple(types);
+
+    nb::module_ names = module.def_submodule("tokens", "Names the scene's code shares.");
+    names.attr("TRANSFORM") = std::string(tokens::kTransform);
+    names.attr("TRANSLATE") = std::string(tokens::kTranslate);
+    names.attr("ORIENT") = std::string(tokens::kOrient);
+    names.attr("SCALE") = std::string(tokens::kScale);
+    names.attr("XFORM_OP_ORDER") = std::string(tokens::kXformOpOrder);
+
+    module.def(
+        "look_at_transform",
+        [](const Vector3& eye, const Vector3& target, const Vector3& up) {
+            return TransformRows(LookAtTransform(ToDvec3(eye), ToDvec3(target), ToDvec3(up)));
+        },
+        nb::arg("eye"), nb::arg("target"), nb::arg("up") = Vector3{0.0, 0.0, 1.0},
+        "A camera's transform at `eye` looking at `target`, as 4 rows: cameras look down -z.");
+    module.def(
+        "distant_light_transform",
+        [](const Vector3& towardLight) {
+            return TransformRows(DistantLightTransform(ToDvec3(towardLight)));
+        },
+        nb::arg("toward_light"),
+        "A distant light's transform shining from the direction to its source, as 4 rows.");
 }
 
 }  // namespace ernie::python

{ernie_renderer-0.2.0.dev127 → ernie_renderer-0.2.0.dev135}/ernie/render/CMakeLists.txt

@@ -2,12 +2,13 @@
 add_library(
     ernie_render
     OBJECT
-    camera_pass.cpp
     device_scene.cpp
     geometry.cpp
     instances.cpp
     prim_rows.cpp
+    renderer.cpp
     rt/bottom_levels.cpp
+    rt/camera_pass.cpp
     rt/ray_tracer.cpp
     rt/top_levels.cpp
     scene_columns.cpp