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

{ernie_renderer-0.2.0.dev121 → 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.dev121 → 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 ".dev121" 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.dev121 → ernie_renderer-0.2.0.dev135}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev121
+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.dev121 → 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.dev121 → ernie_renderer-0.2.0.dev135}/ernie/app/viewer.cpp

@@ -97,7 +97,12 @@ Viewer::Viewer(const Scene& scene, const ViewerOptions& options)
         ERNIE_ZONE("Set up the device scene");
         arenas_ = std::make_unique<Arenas>(*context_, MemoryUse::Device, "scene columns",
                                            std::uint64_t{16} << 20);
-        deviceScene_ = std::make_unique<DeviceScene>(*context_, *arenas_, scene, ShaderCompiler());
+        const ShaderCompiler compiler;
+        deviceScene_ = std::make_unique<DeviceScene>(*context_, *arenas_, scene, compiler);
+        if (deviceScene_->Tracer() != nullptr) {
+            heap_ = std::make_unique<BindlessHeap>(*context_);
+            camera_ = std::make_unique<CameraPass>(*context_, compiler, *heap_);
+        }
         sampler_ = std::make_unique<Sampler>(
             *context_, SamplerDescription{.filter = Filter::Nearest, .address = Address::Clamp},
             "viewport");
@@ -162,6 +167,7 @@ bool Viewer::Step() {
         Ticket drawn;
         {
             ERNIE_ZONE("Run the frame");
+            deviceScene_->Follow(shell_->Camera().Eye());
             drawn =
                 deviceScene_->Execute([&](graph::Graph& graph) { AddPasses(graph, data, *target); },
                                       {}, target->semaphores);
@@ -185,6 +191,9 @@ void Viewer::ShowViewport() {
         context_->Main().Last().Wait();
         if (viewport_) {
             renderer_->RemoveTexture(viewportTexture_);
+            if (heap_) {
+                heap_->RemoveStorageImage(viewportImage_);
+            }
         }
         viewport_ = std::make_unique<DeviceImage>(
             *context_,
@@ -193,6 +202,9 @@ void Viewer::ShowViewport() {
                              .usage = ImageUsage::Sampled | ImageUsage::Storage},
             "Viewport");
         viewportTexture_ = renderer_->AddTexture(viewport_->View(), sampler_->Handle());
+        if (heap_) {
+            viewportImage_ = heap_->AddStorageImage(*viewport_);
+        }
     }
     ImGui::GetBackgroundDrawList()->AddImage(viewportTexture_, position,
                                              {position.x + size.x, position.y + size.y});
@@ -200,18 +212,30 @@ void Viewer::ShowViewport() {
 
 void Viewer::AddPasses(graph::Graph& graph, ImDrawData& data, const FrameTarget& target) {
     graph::Image viewport = graph.Import(*viewport_, "viewport");
-    // Until a renderer draws it, the viewport is the theme's colour.
-    graph.Add(
-        "Viewport", graph::Kind::Copy,
-        [&](graph::PassBuilder& pass) { viewport = pass.Write(viewport, graph::Use::CopyDst); },
-        [this, viewport](graph::PassContext& pass) {
-            const glm::vec4 colour = shell_->GetTheme().viewport;
-            const VkClearColorValue clear{.float32 = {colour.r, colour.g, colour.b, colour.a}};
-            const VkImageSubresourceRange all{
-                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1};
-            vkCmdClearColorImage(pass.commands, pass.Get(viewport).Handle(), pass.Layout(viewport),
-                                 &clear, 1, &all);
-        });
+    if (camera_) {
+        const OrbitCamera& orbit = shell_->Camera();
+        CameraOutputs outputs{.colour = viewport,
+                              .colourIndex = viewportImage_,
+                              .background = glm::vec3(shell_->GetTheme().viewport)};
+        camera_->Add(graph,
+                     {.cameraToWorld = orbit.Transform(),
+                      .verticalFov = orbit.verticalFov,
+                      .size = glm::uvec2(viewport_->Description().extent)},
+                     outputs);
+        viewport = *outputs.colour;
+    } else {
+        graph.Add(
+            "Viewport", graph::Kind::Copy,
+            [&](graph::PassBuilder& pass) { viewport = pass.Write(viewport, graph::Use::CopyDst); },
+            [this, viewport](graph::PassContext& pass) {
+                const glm::vec4 colour = shell_->GetTheme().viewport;
+                const VkClearColorValue clear{.float32 = {colour.r, colour.g, colour.b, colour.a}};
+                const VkImageSubresourceRange all{
+                    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1};
+                vkCmdClearColorImage(pass.commands, pass.Get(viewport).Handle(),
+                                     pass.Layout(viewport), &clear, 1, &all);
+            });
+    }
     graph.Add(
         "UI", graph::Kind::Raster,
         [&](graph::PassBuilder& pass) {

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

@@ -6,7 +6,9 @@
 
 #include "ernie/app/imgui_backend.h"
 #include "ernie/app/ui.h"
+#include "ernie/device/bindless.h"
 #include "ernie/render/device_scene.h"
+#include "ernie/render/rt/camera_pass.h"
 
 #include <glm/vec2.hpp>
 
@@ -39,9 +41,9 @@ struct ViewerOptions {
     ShellOptions shell;
 };
 
-/// @brief The viewer on a scene. Each frame takes input, draws the shell's UI, clears the frame
-/// to the theme's viewport colour, draws the UI over it and presents it. Drive it on the thread
-/// that made it.
+/// @brief The viewer on a scene. Each frame takes input, draws the shell's UI, traces the orbit
+/// camera into the viewport (or clears it to the theme's colour on devices without ray queries),
+/// draws the UI over it and presents it. Drive it on the thread that made it.
 class Viewer {
   public:
     /// @param scene Read by the panels; must outlive the viewer.
@@ -87,10 +89,14 @@ class Viewer {
     std::unique_ptr<Shell> shell_;
     std::unique_ptr<Arenas> arenas_;
     std::unique_ptr<DeviceScene> deviceScene_;
-    /// The image the viewport is rendered into, and the UI's texture of it.
+    /// The heap and pass tracing the viewport; null without ray queries.
+    std::unique_ptr<BindlessHeap> heap_;
+    std::unique_ptr<CameraPass> camera_;
+    /// The image the viewport is rendered into, the UI's texture of it, and its storage slot.
     std::unique_ptr<Sampler> sampler_;
     std::unique_ptr<DeviceImage> viewport_;
     ImTextureID viewportTexture_ = 0;
+    BindlessIndex viewportImage_;
     /// The frames the device may still be drawing, oldest first.
     std::deque<Ticket> inFlight_;
     std::uint64_t frames_ = 0;

{ernie_renderer-0.2.0.dev121 → 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.dev121 → 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.dev121 → 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.dev121 → 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.dev121 → 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.dev121 → 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.dev121 → 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.dev121 → 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