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

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev19}/.github/workflows/ci.yml

@@ -95,6 +95,18 @@ jobs:
           -DERNIE_TEST_PYTHON=python
       - name: Build
         run: cmake --build --preset ci --parallel 4
+      # The installed library used as end users use it: its headers compile alone and a program
+      # links and runs against it. Windows finds ernie.dll on the PATH.
+      - name: Install and build a consumer
+        shell: bash
+        run: |
+          prefix="$RUNNER_TEMP/ernie"
+          cmake --install build/ci --prefix "$prefix" --component runtime
+          cmake --install build/ci --prefix "$prefix" --component dev
+          cmake -S tests/consumer -B build/consumer -G Ninja -DCMAKE_BUILD_TYPE=Release \
+            "-DCMAKE_PREFIX_PATH=$prefix"
+          cmake --build build/consumer
+          PATH="$prefix/bin:$PATH" ctest --test-dir build/consumer --output-on-failure
       # The build tree without objects, for this platform's test job; tar keeps file modes.
       - name: Pack the build tree
         shell: bash
@@ -334,11 +346,16 @@ jobs:
         run: |
           dnf install -y -q rpm-build
           command -v ninja >/dev/null || pipx install -q ninja
+      # One build; each format installs the library where its distributions look for it, as the
+      # build image (RHEL's lib64) is not where Debian and Ubuntu look.
       - name: Build
         run: |
           cmake --preset package
           cmake --build --preset package --parallel 4
-          cd build/package && cpack -G "DEB;RPM;TGZ"
+          cd build/package
+          cmake "-DCMAKE_INSTALL_LIBDIR=lib/$(uname -m)-linux-gnu" . && cpack -G DEB
+          cmake -DCMAKE_INSTALL_LIBDIR=lib64 . && cpack -G RPM
+          cmake -DCMAKE_INSTALL_LIBDIR=lib . && cpack -G TGZ
       - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: packages-linux-${{ matrix.arch }}
@@ -360,6 +377,8 @@ jobs:
         image: ["ubuntu:22.04", "ubuntu:24.04", "debian:12", "rockylinux/rockylinux:9"]
     container: ${{ matrix.image }}
     steps:
+      # The consumer project; checked out first, as checkout clears the workspace.
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           name: packages-linux-${{ matrix.arch }}
@@ -367,10 +386,16 @@ jobs:
         if: ${{ !startsWith(matrix.image, 'rockylinux') }}
         run: |
           apt-get update
-          apt-get install -y --no-install-recommends ./*.deb mesa-vulkan-drivers
+          apt-get install -y --no-install-recommends ./*.deb mesa-vulkan-drivers cmake g++ make
       - name: Install
         if: ${{ startsWith(matrix.image, 'rockylinux') }}
-        run: dnf install -y ./*.rpm
+        run: dnf install -y ./*.rpm cmake gcc-c++ make
+      # The -dev package used as end users use it, with the distribution's own compiler and CMake.
+      - name: Build a consumer
+        run: |
+          cmake -S tests/consumer -B /tmp/consumer -DCMAKE_BUILD_TYPE=Release
+          cmake --build /tmp/consumer
+          ctest --test-dir /tmp/consumer --output-on-failure
       # Rocky 9 has no lavapipe for aarch64, so there the program is only run, not given a device.
       - name: Install lavapipe
         if: ${{ startsWith(matrix.image, 'rockylinux') && matrix.arch == 'x86_64' }}

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

@@ -10,20 +10,26 @@ project(
     VERSION 0.2.0
     DESCRIPTION
         "Efficient Renderer for Natural and Interplanetary Environments: a spectral Vulkan ray tracer"
+    HOMEPAGE_URL "https://github.com/alexmaietta/ernie"
     LANGUAGES C CXX
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev13" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev19" 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)
+option(ERNIE_BUILD_BENCHMARKS "Build Ernie's benchmarks" OFF)
 option(ERNIE_BUILD_PYTHON "Build Ernie's Python module" OFF)
 option(ERNIE_BUILD_APP "Build the ernie program" ON)
 option(ERNIE_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
 option(ERNIE_ASSERTS "Keep assertions in optimised builds" OFF)
 option(ERNIE_TRACY "Send profiling zones to the Tracy profiler too" OFF)
 option(ERNIE_COVERAGE "Instrument Ernie for code coverage (GCC or Clang)" OFF)
+option(ERNIE_INSTALL "Install libernie for C++ consumers" ${PROJECT_IS_TOP_LEVEL})
+
+set(CMAKE_INSTALL_DOCDIR "share/doc/ernie" CACHE PATH "Documentation and licences")
+include(GNUInstallDirs)
 
 get_property(ernie_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if(PROJECT_IS_TOP_LEVEL AND NOT ernie_multi_config AND NOT CMAKE_BUILD_TYPE)
@@ -36,9 +42,13 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
-if(ERNIE_BUILD_PYTHON)
-    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif()
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+# Every object goes into the shared library too, and only its public API leaves it: symbols are
+# hidden unless marked ERNIE_API, including those of the dependencies built here.
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
 
 include(cmake/ErnieFetch.cmake)
 include(cmake/third_party/glm.cmake)
@@ -53,6 +63,10 @@ include(cmake/third_party/volk.cmake)
 add_subdirectory(third_party)
 
 add_library(ernie_build_options INTERFACE)
+# All of Ernie's own code is built as the shared library's (ernie_EXPORTS), so ERNIE_API exports
+# there and is harmless in the static library. glm's configuration stays inside Ernie: it changes
+# no layout, but consumers' own glm calls must not see it.
+target_compile_definitions(ernie_build_options INTERFACE ernie_EXPORTS GLM_FORCE_DEPTH_ZERO_TO_ONE)
 if(MSVC)
     target_compile_options(ernie_build_options INTERFACE /W4 /permissive- /Zc:__cplusplus /utf-8)
     # The CRT's "unsafe function" deprecations (getenv, fopen) would fail warnings-as-errors builds.
@@ -89,11 +103,17 @@ if(ERNIE_COVERAGE)
 endif()
 
 add_subdirectory(ernie)
+if(ERNIE_INSTALL)
+    include(cmake/ErnieInstall.cmake)
+endif()
 
 if(ERNIE_BUILD_TESTS)
     enable_testing()
     add_subdirectory(tests)
 endif()
+if(ERNIE_BUILD_BENCHMARKS)
+    add_subdirectory(benchmarks)
+endif()
 
 if(PROJECT_IS_TOP_LEVEL AND NOT SKBUILD)
     include(cmake/ErniePackaging.cmake)

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev19}/CMakePresets.json

@@ -15,6 +15,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "RelWithDebInfo",
         "ERNIE_BUILD_TESTS": "ON",
+        "ERNIE_BUILD_BENCHMARKS": "ON",
         "ERNIE_BUILD_PYTHON": "ON",
         "ERNIE_BUILD_APP": "ON"
       }

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev19}/Dockerfile

@@ -8,7 +8,8 @@ WORKDIR /src
 COPY . .
 RUN cmake -S . -B /build -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt/ernie \
     && cmake --build /build \
-    && cmake --install /build --component app
+    && cmake --install /build --component app \
+    && cmake --install /build --component runtime
 
 FROM ubuntu:24.04
 ARG DEBIAN_FRONTEND=noninteractive
@@ -16,6 +17,8 @@ RUN apt-get update \
     && apt-get install -y --no-install-recommends libvulkan1 mesa-vulkan-drivers \
     && rm -rf /var/lib/apt/lists/*
 COPY --from=build /opt/ernie/bin/ernie /usr/local/bin/ernie
+# Data and the licences of everything the program carries.
+COPY --from=build /opt/ernie/share /usr/local/share
 ENV NVIDIA_DRIVER_CAPABILITIES=graphics,compute,utility
 WORKDIR /work
 ENTRYPOINT ["ernie"]

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev13
+Version: 0.2.0.dev19
 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/benchmarks/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+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/bench.h

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file bench.h
+/// @brief Registering and timing benchmarks, which report against a target and never fail on time.
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+
+/// What a benchmark measured: its fastest run and the time it aims for, in milliseconds.
+struct Timing {
+    double ms = 0.0;
+    double targetMs = 0.0;
+};
+
+struct Benchmark {
+    std::string name;
+    std::function<Timing()> run;
+};
+
+/// @return Every benchmark registered at static initialization.
+inline std::vector<Benchmark>& Registry() {
+    static std::vector<Benchmark> benchmarks;
+    return benchmarks;
+}
+
+/// Registers a benchmark from a namespace-scope `const bool`.
+inline bool Register(std::string name, std::function<Timing()> run) {
+    Registry().push_back({std::move(name), std::move(run)});
+    return true;
+}
+
+/// @brief Times `step` `runs` times, after `setup` before each, to see past a noisy machine.
+/// @return The fastest run, in milliseconds.
+template <typename Setup, typename Step>
+double Fastest(const Setup& setup, const Step& step, int runs = 5) {
+    double best = 1e30;
+    for (int run = 0; run < runs; ++run) {
+        setup();
+        const auto start = std::chrono::steady_clock::now();
+        step();
+        const auto elapsed = std::chrono::steady_clock::now() - start;
+        best = std::min(best, std::chrono::duration<double, std::milli>(elapsed).count());
+    }
+    return best;
+}
+
+}  // namespace ernie::bench

ernie_renderer-0.2.0.dev19/benchmarks/main.cpp

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file main.cpp
+/// @brief Runs the registered benchmarks whose names contain the first argument, and prints each
+/// fastest time beside its target.
+#include "benchmarks/bench.h"
+
+#include <cstdio>
+#include <string_view>
+
+int main(int argc, char** argv) {
+    const std::string_view filter = argc > 1 ? argv[1] : "";
+    std::printf("%-48s %12s %12s\n", "benchmark", "ms", "target ms");
+    for (const ernie::bench::Benchmark& benchmark : ernie::bench::Registry()) {
+        if (benchmark.name.find(filter) == std::string::npos) {
+            continue;
+        }
+        const ernie::bench::Timing timing = benchmark.run();
+        std::printf("%-48s %12.3f %12.3f%s\n", benchmark.name.c_str(), timing.ms, timing.targetMs,
+                    timing.ms > timing.targetMs ? "  over" : "");
+    }
+    return 0;
+}

ernie_renderer-0.2.0.dev19/benchmarks/scene_storage.cpp

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file scene_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 <memory>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+namespace {
+
+constexpr std::uint32_t kPrims = 100'000;
+
+/// 100,000 instanced robots, one per environment, with transforms.
+struct Robots {
+    std::unique_ptr<PrimStore> store;
+    AttributeId transform = 0;
+    BucketId bucket = 0;
+    std::vector<PrimId> prims;
+
+    void Reset() {
+        store = std::make_unique<PrimStore>();
+        transform = store->Tokens().Intern("xformOp:transform");
+        bucket = store->AddBucket(
+            {store->Tokens().Intern("Xform"), {}},
+            std::vector<ColumnLayout>{ColumnLayout::Of<glm::dmat4>(transform, glm::dmat4(1.0))});
+        prims.clear();
+    }
+
+    void Create() {
+        PathTable& paths = store->Paths();
+        const PathId world = paths.Child(kRootPath, "World");
+        const Token robot = store->Tokens().Intern("robot");
+        std::vector<PathId> robots(kPrims);
+        paths.Reserve(2 * kPrims);
+        for (std::uint32_t i = 0; i < kPrims; ++i) {
+            robots[i] = paths.Child(paths.Child(world, "env_" + std::to_string(i)), robot);
+        }
+        prims = store->DefineMany(robots, bucket);
+        const std::span<glm::dmat4> transforms = store->Write<glm::dmat4>(bucket, transform);
+        for (std::uint32_t i = 0; i < kPrims; ++i) {
+            transforms[i] = glm::dmat4(1.0);
+            transforms[i][3] = glm::dvec4(i, 0.0, 0.0, 1.0);
+        }
+    }
+
+    void Fresh() {
+        Reset();
+        Create();
+    }
+};
+
+const bool kCreate = Register("scene.storage.create_100k", [] {
+    Robots robots;
+    return Timing{Fastest([&] { robots.Reset(); }, [&] { robots.Create(); }), 50.0};
+});
+
+const bool kFirstSync = Register("scene.storage.first_sync_100k", [] {
+    Robots robots;
+    return Timing{Fastest([&] { robots.Fresh(); }, [&] { robots.store->ChangesSince(0); }), 50.0};
+});
+
+const bool kOneEdit = Register("scene.storage.one_edit_of_100k", [] {
+    Robots robots;
+    robots.Fresh();
+    std::uint64_t cursor = 0;
+    const double ms =
+        Fastest([&] { cursor = robots.store->Version(); },
+                [&] {
+                    robots.store->Set(robots.prims[54'321], robots.transform, glm::dmat4(2.0));
+                    robots.store->ChangesSince(cursor);
+                });
+    return Timing{ms, 1.0};
+});
+
+const bool kEditAll = Register("scene.storage.edit_all_100k", [] {
+    Robots robots;
+    robots.Fresh();
+    std::uint64_t cursor = 0;
+    const double ms = Fastest([&] { cursor = robots.store->Version(); },
+                              [&] {
+                                  for (glm::dmat4& transform : robots.store->Write<glm::dmat4>(
+                                           robots.bucket, robots.transform)) {
+                                      transform[3].y += 1.0;
+                                  }
+                                  robots.store->ChangesSince(cursor);
+                              });
+    return Timing{ms, 10.0};
+});
+
+const bool kAddRemove = Register("scene.storage.add_remove_1000_of_100k", [] {
+    Robots robots;
+    std::uint64_t cursor = 0;
+    const double ms = Fastest(
+        [&] {
+            robots.Fresh();
+            cursor = robots.store->Version();
+        },
+        [&] {
+            for (std::uint32_t i = 0; i < 1000; ++i) {
+                robots.store->Remove(robots.prims[i * 97]);
+            }
+            PathTable& paths = robots.store->Paths();
+            const PathId spawned = paths.Child(kRootPath, "Spawned");
+            std::vector<PathId> added(1000);
+            for (std::uint32_t i = 0; i < 1000; ++i) {
+                added[i] = paths.Child(spawned, "p" + std::to_string(i));
+            }
+            robots.store->DefineMany(added, robots.bucket);
+            robots.store->ChangesSince(cursor);
+        });
+    return Timing{ms, 5.0};
+});
+
+}  // namespace
+}  // namespace ernie::bench

ernie_renderer-0.2.0.dev19/cmake/ErnieConfig.cmake.in

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# find_package(Ernie): the shared library and its public headers, as Ernie::ernie.
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/ErnieTargets.cmake")
+
+# Public headers use glm: the consumer's own when it has one, else the copy installed with Ernie.
+# Either way one glm reaches each translation unit; ernie/util/glm.h checks its layout.
+find_package(glm CONFIG QUIET)
+if(TARGET glm::glm)
+    target_link_libraries(Ernie::ernie INTERFACE glm::glm)
+else()
+    set_property(
+        TARGET Ernie::ernie
+        APPEND
+        PROPERTY INTERFACE_INCLUDE_DIRECTORIES "@PACKAGE_ERNIE_THIRD_PARTY_INCLUDEDIR@/glm"
+    )
+endif()
+# DLPack, a single versioned C header, always comes from Ernie.
+set_property(
+    TARGET Ernie::ernie
+    APPEND
+    PROPERTY INTERFACE_INCLUDE_DIRECTORIES "@PACKAGE_ERNIE_THIRD_PARTY_INCLUDEDIR@/dlpack"
+)
+
+check_required_components(Ernie)

ernie_renderer-0.2.0.dev19/cmake/ErnieInstall.cmake

@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: BSD-3-Clause
+include(CMakePackageConfigHelpers)
+
+set(ERNIE_THIRD_PARTY_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}/ernie/third_party")
+set(ernie_cmake_dir "${CMAKE_INSTALL_LIBDIR}/cmake/Ernie")
+set(ernie_doc_dir "${CMAKE_INSTALL_DOCDIR}")
+
+install(
+    TARGETS ernie
+    EXPORT ErnieTargets
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT runtime
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT runtime NAMELINK_COMPONENT dev
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT dev
+)
+
+set(ernie_public_headers
+    util/glm.h
+    util/log.h
+    util/file.h
+    util/profiler.h
+    util/tensor.h
+    util/version.h
+    io/ies.h
+    io/image.h
+    io/raster.h
+    io/texture.h
+)
+foreach(header ${ernie_public_headers})
+    get_filename_component(directory "${header}" DIRECTORY)
+    install(
+        FILES "${PROJECT_SOURCE_DIR}/ernie/${header}"
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/ernie/${directory}"
+        COMPONENT dev
+    )
+endforeach()
+install(
+    FILES "${PROJECT_BINARY_DIR}/include/ernie/export.h"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/ernie"
+    COMPONENT dev
+)
+install(
+    DIRECTORY "${glm_SOURCE_DIR}/glm"
+    DESTINATION "${ERNIE_THIRD_PARTY_INCLUDEDIR}/glm"
+    COMPONENT dev
+    FILES_MATCHING
+    PATTERN "*.hpp"
+    PATTERN "*.inl"
+    PATTERN "*.h"
+)
+install(
+    FILES "${dlpack_SOURCE_DIR}/include/dlpack/dlpack.h"
+    DESTINATION "${ERNIE_THIRD_PARTY_INCLUDEDIR}/dlpack/dlpack"
+    COMPONENT dev
+)
+
+install(EXPORT ErnieTargets NAMESPACE Ernie:: DESTINATION "${ernie_cmake_dir}" COMPONENT dev)
+configure_package_config_file(
+    "${PROJECT_SOURCE_DIR}/cmake/ErnieConfig.cmake.in"
+    "${PROJECT_BINARY_DIR}/ErnieConfig.cmake"
+    INSTALL_DESTINATION "${ernie_cmake_dir}"
+    PATH_VARS ERNIE_THIRD_PARTY_INCLUDEDIR
+)
+# 0.x releases keep compatibility within a minor series.
+write_basic_package_version_file(
+    "${PROJECT_BINARY_DIR}/ErnieConfigVersion.cmake"
+    COMPATIBILITY SameMinorVersion
+)
+install(
+    FILES "${PROJECT_BINARY_DIR}/ErnieConfig.cmake" "${PROJECT_BINARY_DIR}/ErnieConfigVersion.cmake"
+    DESTINATION "${ernie_cmake_dir}"
+    COMPONENT dev
+)
+# Relocatable: paths are relative to the .pc file, so an unpacked archive works anywhere.
+file(RELATIVE_PATH ernie_pc_to_prefix "/prefix/${CMAKE_INSTALL_LIBDIR}/pkgconfig" "/prefix")
+configure_file("${PROJECT_SOURCE_DIR}/cmake/ernie.pc.in" "${PROJECT_BINARY_DIR}/ernie.pc" @ONLY)
+install(
+    FILES "${PROJECT_BINARY_DIR}/ernie.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+    COMPONENT dev
+)
+
+# Ernie's licence and those of what the library and its headers carry.
+install(FILES "${PROJECT_SOURCE_DIR}/LICENSE" DESTINATION "${ernie_doc_dir}" COMPONENT runtime)
+set(ernie_notices
+    "basisu|${PROJECT_SOURCE_DIR}/third_party/basisu/LICENSE"
+    "basisu|${PROJECT_SOURCE_DIR}/third_party/basisu/NOTICE"
+    "bc7enc_rdo|${bc7enc_SOURCE_DIR}/LICENSE"
+    "dlpack|${dlpack_SOURCE_DIR}/LICENSE"
+    "glm|${glm_SOURCE_DIR}/copying.txt"
+    "imath|${imath_SOURCE_DIR}/LICENSE.md"
+    "libdeflate|${openexr_SOURCE_DIR}/external/deflate/COPYING"
+    "nanovdb|${PROJECT_SOURCE_DIR}/third_party/nanovdb/LICENSE"
+    "nlohmann_json|${nlohmann_json_SOURCE_DIR}/LICENSE.MIT"
+    "openexr|${openexr_SOURCE_DIR}/LICENSE.md"
+    "openjph|${openexr_SOURCE_DIR}/external/OpenJPH/LICENSE"
+    "stb|${stb_SOURCE_DIR}/LICENSE"
+    "volk|${volk_SOURCE_DIR}/LICENSE.md"
+    "vulkan_headers|${vulkan_headers_SOURCE_DIR}/LICENSE.md"
+    "zstd|${openexr_SOURCE_DIR}/external/zstd/LICENSE"
+)
+# A Debian machine-readable copyright file: Ernie's licence, and where each bundled one is.
+file(READ "${PROJECT_SOURCE_DIR}/LICENSE" ernie_license)
+string(REGEX REPLACE "\n" "\n " ernie_license " ${ernie_license}")
+set(ernie_copyright
+    "Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/\n"
+    "Upstream-Name: Ernie\nSource: ${PROJECT_HOMEPAGE_URL}\n\n"
+    "Files: *\nCopyright: Alex Maietta\nLicense: BSD-3-Clause\n${ernie_license}\n"
+)
+foreach(notice ${ernie_notices})
+    string(REPLACE "|" ";" parts "${notice}")
+    list(GET parts 0 name)
+    list(GET parts 1 file)
+    get_filename_component(file_name "${file}" NAME)
+    install(FILES "${file}" DESTINATION "${ernie_doc_dir}/third_party/${name}" COMPONENT runtime)
+    list(
+        APPEND ernie_copyright
+        "\nFiles: bundled/${name}/*\nCopyright: see the licence\n"
+        "License: see /usr/${ernie_doc_dir}/third_party/${name}/${file_name}\n"
+    )
+endforeach()
+list(JOIN ernie_copyright "" ernie_copyright)
+file(WRITE "${PROJECT_BINARY_DIR}/copyright" "${ernie_copyright}")
+install(FILES "${PROJECT_BINARY_DIR}/copyright" DESTINATION "${ernie_doc_dir}" COMPONENT runtime)

ernie_renderer-0.2.0.dev19/cmake/ErniePackaging.cmake

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# DEB and RPM packages per install component, and one TGZ of everything, through CPack:
+#   runtime  libernie0 / ernie-libs    libernie, share/ernie data, licences and notices
+#   app      ernie / ernie             the ernie program, depending on the runtime package
+#   dev      libernie-dev / ernie-devel headers, the CMake package and pkg-config file
+
+set(CPACK_PACKAGE_NAME ernie)
+set(CPACK_PACKAGE_VERSION "${ERNIE_VERSION}")
+set(CPACK_PACKAGE_VENDOR "Alex Maietta")
+set(CPACK_PACKAGE_CONTACT "Alex Maietta <maiettaalex@gmail.com>")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_DESCRIPTION}")
+set(CPACK_PACKAGE_HOMEPAGE_URL "${PROJECT_HOMEPAGE_URL}")
+set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
+set(CPACK_PACKAGE_DIRECTORY "${PROJECT_BINARY_DIR}/packages")
+# Archives named for their architecture, so x86_64 and aarch64 tarballs can sit side by side.
+set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
+
+set(CPACK_COMPONENTS_ALL runtime app dev)
+set(CPACK_COMPONENT_APP_DEPENDS runtime)
+set(CPACK_COMPONENT_DEV_DEPENDS runtime)
+set(CPACK_COMPONENTS_GROUPING IGNORE)
+set(CPACK_ARCHIVE_COMPONENT_INSTALL OFF)
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+
+set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
+set(CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS ON)
+# Set here, as CPack otherwise asks dpkg, which the manylinux build image lacks.
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")
+    set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE amd64)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64)$")
+    set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE arm64)
+endif()
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME libernie0)
+set(CPACK_DEBIAN_APP_PACKAGE_NAME ernie)
+set(CPACK_DEBIAN_DEV_PACKAGE_NAME libernie-dev)
+# Built on manylinux_2_34 (glibc 2.34, GCC 11's libstdc++), so these are the floors. The library
+# loads the Vulkan loader at run time, a dependency the linker cannot see.
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_DEPENDS "libc6 (>= 2.34), libstdc++6 (>= 11), libvulkan1")
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_RECOMMENDS "mesa-vulkan-drivers")
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_SECTION libs)
+set(CPACK_DEBIAN_APP_PACKAGE_DEPENDS "libc6 (>= 2.34), libstdc++6 (>= 11), libvulkan1")
+set(CPACK_DEBIAN_APP_PACKAGE_SECTION graphics)
+set(CPACK_DEBIAN_DEV_PACKAGE_SECTION libdevel)
+
+set(CPACK_RPM_FILE_NAME RPM-DEFAULT)
+set(CPACK_RPM_PACKAGE_LICENSE "BSD-3-Clause")
+set(CPACK_RPM_RUNTIME_PACKAGE_NAME ernie-libs)
+set(CPACK_RPM_APP_PACKAGE_NAME ernie)
+set(CPACK_RPM_DEV_PACKAGE_NAME ernie-devel)
+set(CPACK_RPM_RUNTIME_PACKAGE_REQUIRES "vulkan-loader")
+set(CPACK_RPM_APP_PACKAGE_REQUIRES "vulkan-loader")
+set(CPACK_RPM_RUNTIME_PACKAGE_GROUP "System Environment/Libraries")
+set(CPACK_RPM_APP_PACKAGE_GROUP "Applications/Graphics")
+set(CPACK_RPM_DEV_PACKAGE_GROUP "Development/Libraries")
+
+include(CPack)

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev19}/cmake/ErnieTesting.cmake

@@ -4,7 +4,7 @@ include_guard(GLOBAL)
 include("${CMAKE_CURRENT_LIST_DIR}/third_party/googletest.cmake")
 include(GoogleTest)
 
-# Hard timeouts per label; the time budgets tests aim for are far smaller.
+# Hard timeouts per label, to catch hangs; timings are tracked by benchmarks/.
 set(ERNIE_TEST_TIMEOUT_unit 10)
 set(ERNIE_TEST_TIMEOUT_gpu 60)
 set(ERNIE_TEST_TIMEOUT_accuracy 120)

ernie_renderer-0.2.0.dev19/cmake/ernie.pc.in

@@ -0,0 +1,10 @@
+prefix=${pcfiledir}/@ernie_pc_to_prefix@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
+
+Name: Ernie
+Description: @PROJECT_DESCRIPTION@
+Version: @ERNIE_VERSION@
+URL: @PROJECT_HOMEPAGE_URL@
+Cflags: -I${includedir} -I${includedir}/ernie/third_party/glm -I${includedir}/ernie/third_party/dlpack
+Libs: -L${libdir} -lernie

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev19}/cmake/third_party/glm.cmake

@@ -8,6 +8,7 @@ set(GLM_BUILD_INSTALL OFF)
 
 ernie_fetch(glm URL https://github.com/g-truc/glm/archive/refs/tags/${ERNIE_DEP_VERSION_glm}.tar.gz)
 
+# Headers only; Ernie's own glm configuration is in ernie_build_options, so it never reaches
+# consumers.
 add_library(ernie_glm INTERFACE)
 target_include_directories(ernie_glm SYSTEM INTERFACE "${glm_SOURCE_DIR}")
-target_compile_definitions(ernie_glm INTERFACE GLM_FORCE_DEPTH_ZERO_TO_ONE)