ernie-renderer 0.2.0.dev19__tar.gz → 0.2.0.dev21__tar.gz

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/CMakeLists.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev19
+Version: 0.2.0.dev21
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/benchmarks/CMakeLists.txt

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: BSD-3-Clause
-add_executable(ernie_benchmarks main.cpp scene_storage.cpp)
+add_executable(ernie_benchmarks main.cpp scene/storage.cpp)
 target_link_libraries(ernie_benchmarks PRIVATE ernie_static ernie_build_options)

ernie_renderer-0.2.0.dev19/benchmarks/scene_storage.cpp → ernie_renderer-0.2.0.dev21/benchmarks/scene/storage.cpp

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: BSD-3-Clause
-/// @file scene_storage.cpp
+/// @file storage.cpp
 /// @brief The prim store at 100,000 prims: create, first sync, one edit, edit all, add and remove.
-#include "benchmarks/bench.h"
 #include "ernie/scene/storage.h"
+#include "benchmarks/bench.h"
 
 #include <memory>
 #include <string>

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/ernie/CMakeLists.txt

@@ -22,6 +22,7 @@ set_target_properties(
 
 # One object library per layer; a layer links only the layers below it.
 add_subdirectory(util)
+add_subdirectory(geometry)
 add_subdirectory(physics)
 add_subdirectory(io)
 add_subdirectory(scene)
@@ -31,6 +32,7 @@ add_subdirectory(render)
 
 set(ernie_layers
     ernie_util
+    ernie_geometry
     ernie_physics
     ernie_io
     ernie_scene

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/ernie/device/vulkan_devices.cpp

@@ -2,11 +2,11 @@
 /// @file vulkan_devices.cpp
 /// @brief Lists Vulkan devices through a short-lived instance.
 #include "ernie/device/vulkan_devices.h"
+#include "ernie/util/algorithm.h"
 
 #include <volk.h>
 
 #include <algorithm>
-#include <iterator>
 #include <stdexcept>
 #include <string_view>
 
@@ -107,10 +107,7 @@ std::vector<VulkanDeviceInfo> ListVulkanDevices() {
     std::vector<VkPhysicalDevice> devices(count);
     vkEnumeratePhysicalDevices(instance.Get(), &count, devices.data());
 
-    std::vector<VulkanDeviceInfo> infos;
-    infos.reserve(devices.size());
-    std::ranges::transform(devices, std::back_inserter(infos), ReadDeviceInfo);
-    return infos;
+    return Map(devices, ReadDeviceInfo);
 }
 
 const char* ToString(VulkanDeviceType type) {

ernie_renderer-0.2.0.dev21/ernie/geometry/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(ernie_geometry INTERFACE)
+target_link_libraries(ernie_geometry INTERFACE ernie_util)

ernie_renderer-0.2.0.dev21/ernie/geometry/bounds.h

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file bounds.h
+/// @brief Axis-aligned boxes in double precision.
+#pragma once
+
+#include <glm/glm.hpp>
+
+#include <cmath>
+#include <limits>
+
+namespace ernie {
+
+/// @brief An axis-aligned box; the default one is empty and grows to hold what it is given.
+struct Box {
+    glm::dvec3 min{std::numeric_limits<double>::infinity()};
+    glm::dvec3 max{-std::numeric_limits<double>::infinity()};
+
+    static Box Around(const glm::dvec3& center, const glm::dvec3& halfSize) {
+        return {center - halfSize, center + halfSize};
+    }
+
+    bool Empty() const {
+        return !(min.x <= max.x && min.y <= max.y && min.z <= max.z);
+    }
+    glm::dvec3 Center() const {
+        return 0.5 * (min + max);
+    }
+    glm::dvec3 Size() const {
+        return Empty() ? glm::dvec3(0.0) : max - min;
+    }
+
+    Box& Extend(const glm::dvec3& point) {
+        min = glm::min(min, point);
+        max = glm::max(max, point);
+        return *this;
+    }
+    Box& Extend(const Box& other) {
+        if (!other.Empty()) {
+            min = glm::min(min, other.min);
+            max = glm::max(max, other.max);
+        }
+        return *this;
+    }
+    Box Grown(double margin) const {
+        return Empty() ? *this : Box{min - margin, max + margin};
+    }
+
+    /// @return The box holding this one after `transform` (Arvo's method, exact for affine maps).
+    Box Transformed(const glm::dmat4& transform) const {
+        if (Empty()) {
+            return *this;
+        }
+        const glm::dvec3 translation(transform[3]);
+        Box out{translation, translation};
+        for (int column = 0; column < 3; ++column) {
+            for (int row = 0; row < 3; ++row) {
+                const double a = transform[column][row] * min[column];
+                const double b = transform[column][row] * max[column];
+                out.min[row] += std::min(a, b);
+                out.max[row] += std::max(a, b);
+            }
+        }
+        return out;
+    }
+
+    bool operator==(const Box&) const = default;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/ernie/io/CMakeLists.txt

@@ -10,7 +10,7 @@ add_library(
 )
 target_link_libraries(
     ernie_io
-    PUBLIC ernie_util
+    PUBLIC ernie_geometry
     PRIVATE
         ernie_build_options
         ernie_basisu

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/ernie/io/nanovdb.cpp

@@ -222,22 +222,12 @@ bool NanoVdbGrid::Vector() const {
     return type == NanoVdbType::Vec3f;
 }
 
-void NanoVdbGrid::GridBounds(glm::dvec3& min, glm::dvec3& max) const {
-    min = glm::dvec3(std::numeric_limits<double>::infinity());
-    max = -min;
+Box NanoVdbGrid::GridBounds() const {
     if (Empty()) {
-        min = max = glm::dvec3(indexToGrid[3]);
-        return;
-    }
-    const glm::dvec3 lo = glm::dvec3(indexMin) - 1.0;
-    const glm::dvec3 hi = glm::dvec3(indexMax) + 1.0;
-    for (int corner = 0; corner < 8; ++corner) {
-        const glm::dvec3 index{(corner & 1) != 0 ? hi.x : lo.x, (corner & 2) != 0 ? hi.y : lo.y,
-                               (corner & 4) != 0 ? hi.z : lo.z};
-        const glm::dvec3 point = glm::dvec3(indexToGrid * glm::dvec4(index, 1.0));
-        min = glm::min(min, point);
-        max = glm::max(max, point);
+        const glm::dvec3 origin(indexToGrid[3]);
+        return {origin, origin};
     }
+    return Box{glm::dvec3(indexMin) - 1.0, glm::dvec3(indexMax) + 1.0}.Transformed(indexToGrid);
 }
 
 std::vector<NanoVdbGrid> ParseNanoVdbGrids(std::span<const std::uint8_t> bytes) {

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/ernie/io/nanovdb.h

@@ -3,6 +3,8 @@
 /// @brief NanoVDB grids: reading .nvdb/.vdb files and building grids.
 #pragma once
 
+#include "ernie/geometry/bounds.h"
+
 #include <glm/glm.hpp>
 
 #include <cstdint>
@@ -79,11 +81,9 @@ struct NanoVdbGrid {
     bool Scalar() const;
     /// @return Whether volumes sample a 3-vector per voxel.
     bool Vector() const;
-    /// @brief Active bounds in the grid frame, grown by a voxel on
-    /// each side for trilinear sampling.
-    /// @param min Receives the lower corner.
-    /// @param max Receives the upper corner.
-    void GridBounds(glm::dvec3& min, glm::dvec3& max) const;
+    /// @return Active bounds in the grid frame, grown by a voxel on each side for trilinear
+    /// sampling; the grid's origin when it has no active voxels.
+    Box GridBounds() const;
 };
 
 /// @brief Reads every grid of a NanoVDB file, in file order.

ernie_renderer-0.2.0.dev21/ernie/scene/CMakeLists.txt

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(
+    ernie_scene
+    OBJECT
+    path.cpp
+    schema.cpp
+    scene.cpp
+    storage.cpp
+    view.cpp
+    xform.cpp
+    schemas/geom.cpp
+    schemas/registry.cpp
+)
+target_link_libraries(ernie_scene PUBLIC ernie_physics ernie_io PRIVATE ernie_build_options)

ernie_renderer-0.2.0.dev21/ernie/scene/convert.h

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file convert.h
+/// @brief Conversions between `Value`s and column elements.
+#pragma once
+
+#include "ernie/scene/storage.h"
+#include "ernie/scene/value.h"
+#include "ernie/util/algorithm.h"
+
+#include <cmath>
+#include <optional>
+#include <type_traits>
+#include <vector>
+
+namespace ernie {
+
+/// @return A number of any width, or none.
+inline std::optional<double> ToNumber(const Value& value) {
+    if (const auto* d = value.Get<double>()) {
+        return *d;
+    }
+    if (const auto* f = value.Get<float>()) {
+        return *f;
+    }
+    if (const auto* i = value.Get<int>()) {
+        return *i;
+    }
+    return std::nullopt;
+}
+
+/// @return A vector of N doubles from one of floats, doubles or (for two) ints, or none.
+template <glm::length_t N> std::optional<glm::vec<N, double>> ToVector(const Value& value) {
+    if (const auto* d = value.Get<glm::vec<N, double>>()) {
+        return *d;
+    }
+    if (const auto* f = value.Get<glm::vec<N, float>>()) {
+        return glm::vec<N, double>(*f);
+    }
+    if constexpr (N == 2) {
+        if (const auto* i = value.Get<glm::ivec2>()) {
+            return glm::dvec2(*i);
+        }
+    }
+    return std::nullopt;
+}
+
+/// @return The numbers of a number, or the components of a vector; none for other values.
+inline std::vector<double> ToNumbers(const Value& value) {
+    if (const std::optional<double> number = ToNumber(value)) {
+        return {*number};
+    }
+    const auto components = [](const auto& vector) {
+        std::vector<double> numbers(static_cast<std::size_t>(vector.length()));
+        for (glm::length_t i = 0; i < vector.length(); ++i) {
+            numbers[static_cast<std::size_t>(i)] = vector[i];
+        }
+        return numbers;
+    };
+    if (const auto v = ToVector<2>(value)) {
+        return components(*v);
+    }
+    if (const auto v = ToVector<3>(value)) {
+        return components(*v);
+    }
+    if (const auto v = ToVector<4>(value)) {
+        return components(*v);
+    }
+    return {};
+}
+
+/// @return `value` as a column element, interning tokens and paths; none if it is another kind.
+template <typename T> std::optional<T> ToElement(PathTable& paths, const Value& value) {
+    if constexpr (std::is_same_v<T, std::uint8_t>) {
+        if (const auto* b = value.Get<bool>()) {
+            return static_cast<std::uint8_t>(*b);
+        }
+        if (const auto* i = value.Get<int>(); i && (*i == 0 || *i == 1)) {
+            return static_cast<std::uint8_t>(*i);
+        }
+    } else if constexpr (std::is_same_v<T, std::int32_t>) {
+        if (const std::optional<double> n = ToNumber(value); n && std::trunc(*n) == *n) {
+            return static_cast<std::int32_t>(*n);
+        }
+    } else if constexpr (std::is_same_v<T, double>) {
+        return ToNumber(value);
+    } else if constexpr (std::is_same_v<T, glm::dvec2> || std::is_same_v<T, glm::dvec3> ||
+                         std::is_same_v<T, glm::dvec4>) {
+        return ToVector<T::length()>(value);
+    } else if constexpr (std::is_same_v<T, glm::dquat>) {
+        if (const auto* q = value.Get<glm::dquat>()) {
+            return *q;
+        }
+    } else if constexpr (std::is_same_v<T, glm::dmat4>) {
+        if (const auto* m = value.Get<glm::dmat4>()) {
+            return *m;
+        }
+    } else if constexpr (std::is_same_v<T, Token>) {
+        if (const auto* text = value.Get<std::string>()) {
+            return paths.Names().Intern(*text);
+        }
+    } else if constexpr (std::is_same_v<T, Target>) {
+        if (const auto* path = value.Get<Path>()) {
+            return Target{path->IsEmpty() ? kNoPath : paths.Intern(*path)};
+        }
+    } else if constexpr (std::is_same_v<T, std::vector<Target>>) {
+        if (const auto* path = value.Get<Path>()) {
+            return std::vector<Target>{{paths.Intern(*path)}};
+        }
+        if (const auto* list = value.Get<std::vector<Path>>()) {
+            return Map(*list, [&](const Path& path) { return Target{paths.Intern(path)}; });
+        }
+    } else if constexpr (std::is_same_v<T, std::vector<float>>) {
+        if (const auto* floats = value.Get<std::vector<float>>()) {
+            return *floats;
+        }
+        if (const std::optional<double> n = ToNumber(value)) {
+            return std::vector<float>{static_cast<float>(*n)};
+        }
+    } else if constexpr (std::is_same_v<T, std::vector<Token>>) {
+        if (const auto* texts = value.Get<std::vector<std::string>>()) {
+            return Map(*texts, [&](const std::string& text) { return paths.Names().Intern(text); });
+        }
+        // An empty list, as Python and JSON pass one.
+        if (const auto* floats = value.Get<std::vector<float>>(); floats && floats->empty()) {
+            return std::vector<Token>{};
+        }
+    }
+    return std::nullopt;
+}
+
+/// @return A column element as a `Value`; tensors have none.
+template <typename T> Value ToValue(const PathTable& paths, const T& element) {
+    if constexpr (std::is_same_v<T, std::uint8_t>) {
+        return element != 0;
+    } else if constexpr (std::is_same_v<T, std::int32_t>) {
+        return static_cast<int>(element);
+    } else if constexpr (std::is_same_v<T, Token>) {
+        return std::string(paths.Names().Text(element));
+    } else if constexpr (std::is_same_v<T, Target>) {
+        return element.path == kNoPath ? Path() : paths.ToPath(element.path);
+    } else if constexpr (std::is_same_v<T, std::vector<Target>>) {
+        return Map(element, [&](const Target& target) { return paths.ToPath(target.path); });
+    } else if constexpr (std::is_same_v<T, std::vector<Token>>) {
+        return Map(element, [&](Token token) { return std::string(paths.Names().Text(token)); });
+    } else if constexpr (std::is_same_v<T, Tensor>) {
+        return Value();
+    } else {
+        return element;
+    }
+}
+
+/// @return The column type an undeclared attribute's first value makes, or none.
+inline std::optional<ColumnType> InferColumnType(const Value& value) {
+    return std::visit(
+        [](const auto& v) -> std::optional<ColumnType> {
+            using V = std::decay_t<decltype(v)>;
+            if constexpr (std::is_same_v<V, bool>) {
+                return ColumnType::Bool;
+            } else if constexpr (std::is_same_v<V, int>) {
+                return ColumnType::Int;
+            } else if constexpr (std::is_same_v<V, float> || std::is_same_v<V, double>) {
+                return ColumnType::Double;
+            } else if constexpr (std::is_same_v<V, glm::ivec2> || std::is_same_v<V, glm::vec2> ||
+                                 std::is_same_v<V, glm::dvec2>) {
+                return ColumnType::Vec2;
+            } else if constexpr (std::is_same_v<V, glm::vec3> || std::is_same_v<V, glm::dvec3>) {
+                return ColumnType::Vec3;
+            } else if constexpr (std::is_same_v<V, glm::vec4> || std::is_same_v<V, glm::dvec4>) {
+                return ColumnType::Vec4;
+            } else if constexpr (std::is_same_v<V, glm::dquat>) {
+                return ColumnType::Quat;
+            } else if constexpr (std::is_same_v<V, glm::dmat4>) {
+                return ColumnType::Matrix;
+            } else if constexpr (std::is_same_v<V, std::string>) {
+                return ColumnType::TokenValue;
+            } else if constexpr (std::is_same_v<V, Path>) {
+                return ColumnType::Relationship;
+            } else if constexpr (std::is_same_v<V, std::vector<Path>>) {
+                return ColumnType::Relationships;
+            } else if constexpr (std::is_same_v<V, std::vector<float>>) {
+                return ColumnType::FloatArray;
+            } else if constexpr (std::is_same_v<V, std::vector<std::string>>) {
+                return ColumnType::TokenArray;
+            } else {
+                return std::nullopt;
+            }
+        },
+        value.Raw());
+}
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev19 → ernie_renderer-0.2.0.dev21}/ernie/scene/path.h

@@ -113,6 +113,13 @@ class PathTable {
     PathId NextSibling(PathId id) const {
         return nodes_[id].nextSibling;
     }
+    /// Calls `visit(child)` for each child of `id`, in the order they were added.
+    template <typename Visit> void ForEachChild(PathId id, const Visit& visit) const {
+        for (PathId child = nodes_[id].firstChild; child != kNoPath;
+             child = nodes_[child].nextSibling) {
+            visit(child);
+        }
+    }
     /// @return Whether `id` is `ancestor` or lies below it.
     bool HasPrefix(PathId id, PathId ancestor) const;