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

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/.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 (QA-072). 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.dev16}/CMakeLists.txt

@@ -10,11 +10,12 @@ 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 ".dev16" 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)
@@ -24,6 +25,10 @@ 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 +41,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 +62,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,6 +102,9 @@ if(ERNIE_COVERAGE)
 endif()
 
 add_subdirectory(ernie)
+if(ERNIE_INSTALL)
+    include(cmake/ErnieInstall.cmake)
+endif()
 
 if(ERNIE_BUILD_TESTS)
     enable_testing()

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/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.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev13
+Version: 0.2.0.dev16
 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.dev16/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.dev16/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.dev16/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.dev16/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.dev16}/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)

ernie_renderer-0.2.0.dev16/ernie/CMakeLists.txt

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: BSD-3-Clause
+include(GenerateExportHeader)
+
+# The installed library: every layer's objects in one shared library, exporting only the public
+# API (ERNIE_API) and hiding its dependencies. Defined first, as `ernie/export.h` is generated from
+# it.
+add_library(ernie SHARED)
+add_library(Ernie::ernie ALIAS ernie)
+# MSVC warns that exported classes' standard library members need "dll-interface" (C4251, C4275);
+# Ernie's C++ ABI already requires consumers to use the same compiler and runtime, so they match.
+set(ernie_export_msvc "#ifdef _MSC_VER\n#pragma warning(disable : 4251 4275)\n#endif")
+generate_export_header(
+    ernie
+    EXPORT_MACRO_NAME ERNIE_API
+    EXPORT_FILE_NAME "${PROJECT_BINARY_DIR}/include/ernie/export.h"
+    CUSTOM_CONTENT_FROM_VARIABLE ernie_export_msvc
+)
+set_target_properties(
+    ernie
+    PROPERTIES VERSION "${PROJECT_VERSION}" SOVERSION "${PROJECT_VERSION_MAJOR}"
+)
+
+# One object library per layer; a layer links only the layers below it.
+add_subdirectory(util)
+add_subdirectory(physics)
+add_subdirectory(io)
+add_subdirectory(scene)
+add_subdirectory(device)
+add_subdirectory(graph)
+add_subdirectory(render)
+
+set(ernie_layers
+    ernie_util
+    ernie_physics
+    ernie_io
+    ernie_scene
+    ernie_device
+    ernie_graph
+    ernie_render
+)
+target_link_libraries(ernie PRIVATE ${ernie_layers} ernie_build_options)
+target_include_directories(
+    ernie
+    INTERFACE
+        "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
+        "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>"
+        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+# Public headers use glm and DLPack; installed, ErnieConfig.cmake supplies them instead.
+target_link_libraries(ernie INTERFACE "$<BUILD_INTERFACE:ernie_glm;ernie_dlpack>")
+target_compile_features(ernie INTERFACE cxx_std_20)
+# Archives linked in keep their symbols to themselves.
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    target_link_options(ernie PRIVATE "LINKER:--exclude-libs,ALL")
+endif()
+
+# The same objects as one static library, for in-tree programs and tests, which may also reach
+# internal APIs, and for the Python module, which carries everything itself.
+add_library(ernie_static STATIC)
+target_link_libraries(ernie_static PUBLIC ${ernie_layers})
+# Its objects export the API (ERNIE_API), so on Windows every program linking it would also write
+# an import library; the ernie program's would collide with libernie's own ernie.lib and ernie.exp.
+target_link_options(ernie_static INTERFACE "$<$<CXX_COMPILER_ID:MSVC>:/NOIMPLIB;/NOEXP>")
+
+if(ERNIE_BUILD_APP)
+    add_subdirectory(app)
+endif()
+if(ERNIE_BUILD_PYTHON)
+    add_subdirectory(python)
+endif()

ernie_renderer-0.2.0.dev16/ernie/app/CMakeLists.txt

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_executable(ernie_app main.cpp)
+set_target_properties(ernie_app PROPERTIES OUTPUT_NAME ernie)
+target_link_libraries(ernie_app PRIVATE ernie_static ernie_build_options)
+install(TARGETS ernie_app RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT app)

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/device/CMakeLists.txt

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: BSD-3-Clause
-add_library(ernie_device STATIC vulkan_devices.cpp)
+add_library(ernie_device OBJECT vulkan_devices.cpp)
 target_link_libraries(ernie_device PUBLIC ernie_util PRIVATE ernie_volk ernie_build_options)

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/io/CMakeLists.txt

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 add_library(
     ernie_io
-    STATIC
+    OBJECT
     ies.cpp
     image.cpp
     nanovdb.cpp

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/io/ies.h

@@ -3,7 +3,9 @@
 /// @brief IES LM-63 photometric profiles of luminaires.
 #pragma once
 
-#include <glm/glm.hpp>
+#include "ernie/export.h"
+
+#include "ernie/util/glm.h"
 
 #include <filesystem>
 #include <string_view>
@@ -33,7 +35,7 @@ enum class IesType {
 /// @brief How a lamp's output changes as its luminaire tilts.
 /// From TILT=INCLUDE or a tilt file; for lamps sensitive to burning
 /// position, such as metal halide.
-struct IesTilt {
+struct ERNIE_API IesTilt {
     /// Lamp position: 1 vertical, 2 horizontal along x (0 degree
     /// plane), 3 horizontal along y (90 degree plane); 0 for none.
     int geometry = 0;
@@ -72,7 +74,7 @@ struct IesTilt {
 /// - G. Ward, Radiance ies2rad, source.cal and tilt.cal (type B
 ///   coordinates and tilt angles),
 ///   https://github.com/NREL/Radiance/tree/master/src/cv
-struct IesProfile {
+struct ERNIE_API IesProfile {
     /// The photometric type.
     IesType type = IesType::C;
     /// Vertical angles, in degrees, increasing.
@@ -108,12 +110,12 @@ struct IesProfile {
 /// @throws std::invalid_argument If the text is not LM-63, has an
 ///         unknown type, or has angles out of order.
 /// @throws std::runtime_error If a tilt file cannot be read.
-IesProfile ParseIes(std::string_view text, const std::filesystem::path& directory = {});
+ERNIE_API IesProfile ParseIes(std::string_view text, const std::filesystem::path& directory = {});
 
 /// @brief Reads and parses an IES file; tilt files resolve beside it.
 /// @param path The file.
 /// @return The profile.
 /// @throws std::runtime_error If it cannot be read.
-IesProfile ReadIes(const std::filesystem::path& path);
+ERNIE_API IesProfile ReadIes(const std::filesystem::path& path);
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/io/image.cpp

@@ -3,7 +3,7 @@
 /// @brief Image loading, EXR writing, sRGB conversion and mip chains.
 #include "ernie/io/image.h"
 
-#include "ernie/util/profile.h"
+#include "ernie/util/profiler.h"
 #include "ernie/util/text.h"
 
 #include <ImfChannelList.h>

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/io/image.h

@@ -3,9 +3,11 @@
 /// @brief Float RGBA images: loading, EXR output, sRGB and mips.
 #pragma once
 
+#include "ernie/export.h"
+
 #include "ernie/util/tensor.h"
 
-#include <glm/glm.hpp>
+#include "ernie/util/glm.h"
 
 #include <cstdint>
 #include <filesystem>
@@ -41,14 +43,14 @@ inline constexpr float kMinNormalZ = 0.05f;
 /// @brief Packs a slope deviation into [0, 1) for 8-bit storage.
 /// @param sigma The deviation, 0 or more.
 /// @return sigma / (1 + sigma), finest near 0.
-float EncodeSlopeDeviation(float sigma);
+ERNIE_API float EncodeSlopeDeviation(float sigma);
 /// @brief Inverts `EncodeSlopeDeviation`.
 /// @param encoded The stored value.
 /// @return The slope deviation.
-float DecodeSlopeDeviation(float encoded);
+ERNIE_API float DecodeSlopeDeviation(float encoded);
 
 /// @brief An RGBA image of linear floats, rows top to bottom.
-struct Image {
+struct ERNIE_API Image {
     /// Width, in pixels.
     std::uint32_t width = 0;
     /// Height, in pixels.
@@ -86,12 +88,12 @@ struct Image {
 /// @return The image.
 /// @throws std::runtime_error If the file cannot be read or decoded,
 ///         or is not .png, .jpg, .jpeg or .exr.
-Image LoadImageFile(const std::filesystem::path& path, ImageEncoding encoding);
+ERNIE_API Image LoadImageFile(const std::filesystem::path& path, ImageEncoding encoding);
 
 /// @brief Tests for a .png, .jpg or .jpeg extension, in any case.
 /// @param path The file.
 /// @return Whether it is a PNG or JPEG, read by stb.
-bool IsPngOrJpeg(const std::filesystem::path& path);
+ERNIE_API bool IsPngOrJpeg(const std::filesystem::path& path);
 
 /// @brief Writes a CPU tensor as a ZIP-compressed OpenEXR file.
 /// Channels are float32, or uint32 for uint32 data such as ids;
@@ -102,16 +104,16 @@ bool IsPngOrJpeg(const std::filesystem::path& path);
 ///              bottom.
 /// @throws std::invalid_argument For another rank or type.
 /// @throws std::runtime_error If the file cannot be written.
-void WriteExr(const std::filesystem::path& path, const Tensor& image);
+ERNIE_API void WriteExr(const std::filesystem::path& path, const Tensor& image);
 
 /// @brief Decodes one sRGB channel to linear (IEC 61966-2-1).
 /// @param value The encoded value in [0, 1].
 /// @return The linear value.
-float SrgbToLinear(float value);
+ERNIE_API float SrgbToLinear(float value);
 /// @brief Encodes one linear channel to sRGB (IEC 61966-2-1).
 /// @param value The linear value in [0, 1].
 /// @return The encoded value.
-float LinearToSrgb(float value);
+ERNIE_API float LinearToSrgb(float value);
 
 /// @brief Builds the mip chain down to 1 x 1.
 /// Level n is max(1, floor(size / 2^n)) per side, as WebGPU expects;
@@ -124,13 +126,13 @@ float LinearToSrgb(float value);
 /// - M. Toksvig, "Mipmapping Normal Maps", Journal of Graphics Tools
 ///   10(3), 2005.
 /// - M. Olano and D. Baker, "LEAN Mapping", I3D 2010.
-std::vector<Image> MipChain(const Image& image, MipFilter filter);
+ERNIE_API std::vector<Image> MipChain(const Image& image, MipFilter filter);
 
 /// @brief Quantises to 8-bit RGBA.
 /// @param image    The image.
 /// @param encoding `Srgb` encodes rgb as sRGB; alpha stays linear.
 /// @return Four bytes per pixel.
-std::vector<std::uint8_t> ToRgba8(const Image& image, ImageEncoding encoding);
+ERNIE_API std::vector<std::uint8_t> ToRgba8(const Image& image, ImageEncoding encoding);
 
 /// @brief A texture tensor as an image.
 /// @details Grey replicates into rgb and a missing alpha reads as 1.
@@ -139,6 +141,6 @@ std::vector<std::uint8_t> ToRgba8(const Image& image, ImageEncoding encoding);
 /// @param encoding How uint8 colour is encoded: sRGB or linear.
 /// @return The image.
 /// @throws std::invalid_argument For another kind of tensor.
-Image ImageFromTensor(const Tensor& tensor, ImageEncoding encoding);
+ERNIE_API Image ImageFromTensor(const Tensor& tensor, ImageEncoding encoding);
 
 }  // namespace ernie

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/io/nanovdb.cpp

@@ -4,7 +4,7 @@
 #include "ernie/io/nanovdb.h"
 
 #include "ernie/util/bytes.h"
-#include "ernie/util/mapped_file.h"
+#include "ernie/util/file.h"
 
 #define PNANOVDB_C
 #include <PNanoVDB.h>

{ernie_renderer-0.2.0.dev13 → ernie_renderer-0.2.0.dev16}/ernie/io/raster.cpp

@@ -8,7 +8,7 @@
 
 #include "ernie/util/bytes.h"
 #include "ernie/util/file.h"
-#include "ernie/util/profile.h"
+#include "ernie/util/profiler.h"
 #include "ernie/util/text.h"
 
 #include <stb_image.h>