ernie-renderer 0.2.0.dev153__tar.gz → 0.2.0.dev161__tar.gz

{ernie_renderer-0.2.0.dev153 → ernie_renderer-0.2.0.dev161}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev153" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev161" 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)
@@ -98,6 +98,9 @@ if(ERNIE_COVERAGE)
 endif()
 
 add_subdirectory(ernie)
+if(TARGET ernie_viewer)
+    add_subdirectory(demos)
+endif()
 if(ERNIE_INSTALL)
     include(cmake/ErnieInstall.cmake)
 endif()

{ernie_renderer-0.2.0.dev153 → ernie_renderer-0.2.0.dev161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev153
+Version: 0.2.0.dev161
 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.dev153 → ernie_renderer-0.2.0.dev161}/benchmarks/CMakeLists.txt

@@ -4,6 +4,7 @@ add_executable(
     main.cpp
     device/pose_step.cpp
     render/batch_step.cpp
+    render/hide_seek.cpp
     render/transform_graph.cpp
     scene/extents.cpp
     scene/storage.cpp

ernie_renderer-0.2.0.dev161/benchmarks/render/hide_seek.cpp

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file hide_seek.cpp
+/// @brief Madrona's Hide & Seek benchmark scene rebuilt in Ernie, to compare batch rendering on the
+/// same GPU: each world ±18 m of rooms walled off with doors, 3 to 9 boxes and 2 ramps, and 3
+/// hiders and 3 seekers each looking out through a 100° camera 0.5 m above it, over one shared
+/// ground. Meshes come from madrona_benchmark's data directory (`ERNIE_MADRONA_DATA`), each asset's
+/// arrays shared by every instance, as Madrona's assets are. Madrona counts worlds a second, each
+/// world six views; this reports both.
+#include "benchmarks/bench.h"
+#include "ernie/device/context.h"
+#include "ernie/render/renderer.h"
+#include "ernie/scene/schema/camera.h"
+#include "ernie/scene/schema/geom.h"
+#include "ernie/scene/schema/mesh.h"
+#include "ernie/scene/schema/planet.h"
+#include "ernie/scene/schema/render.h"
+#include "ernie/scene/tokens.h"
+#include "ernie/scene/xform.h"
+
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <random>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+namespace {
+
+constexpr int kAgents = 6;
+constexpr double kBounds = 18.0;
+constexpr double kPi = 3.14159265358979323846;
+
+/// A mesh's arrays, shared by every prim drawing it.
+struct MeshArrays {
+    Tensor points;
+    Tensor counts;
+    Tensor indices;
+};
+
+/// @return An OBJ file's positions and faces; texture and normal indices are skipped.
+MeshArrays ReadObj(const std::filesystem::path& path) {
+    std::ifstream file(path);
+    if (!file) {
+        throw std::runtime_error("Cannot read " + path.string());
+    }
+    std::vector<float> points;
+    std::vector<std::int32_t> counts;
+    std::vector<std::int32_t> indices;
+    std::string line;
+    while (std::getline(file, line)) {
+        std::istringstream words(line);
+        std::string kind;
+        words >> kind;
+        if (kind == "v") {
+            float x = 0.0f;
+            float y = 0.0f;
+            float z = 0.0f;
+            words >> x >> y >> z;
+            points.insert(points.end(), {x, y, z});
+        } else if (kind == "f") {
+            std::int32_t corners = 0;
+            for (std::string corner; words >> corner; ++corners) {
+                indices.push_back(std::stoi(corner.substr(0, corner.find('/'))) - 1);
+            }
+            counts.push_back(corners);
+        }
+    }
+    const auto length = [](const auto& values) { return static_cast<std::int64_t>(values.size()); };
+    return {.points = Tensor::Copy<float>(points, {length(points) / 3, 3}),
+            .counts = Tensor::Copy<std::int32_t>(counts, {length(counts)}),
+            .indices = Tensor::Copy<std::int32_t>(indices, {length(indices)})};
+}
+
+struct Assets {
+    MeshArrays agent;
+    MeshArrays cube;
+    MeshArrays wall;
+    MeshArrays ramp;
+    MeshArrays elongated;
+
+    explicit Assets(const std::filesystem::path& data)
+        : agent(ReadObj(data / "agent_render.obj")), cube(ReadObj(data / "cube_render.obj")),
+          wall(ReadObj(data / "wall_render.obj")), ramp(ReadObj(data / "ramp_render.obj")),
+          elongated(ReadObj(data / "elongated_render.obj")) {}
+};
+
+/// An axis-aligned wall segment of the unit square, from `low` to `high`.
+struct Wall {
+    glm::dvec2 low;
+    glm::dvec2 high;
+
+    bool Horizontal() const {
+        return low.y == high.y;
+    }
+};
+
+/// @return Madrona's walls: the unit square's sides, then cross walls each with a door and doors
+/// cut into walls, as many of each as its generator draws.
+std::vector<Wall> MakeWalls(std::mt19937& random) {
+    std::vector<Wall> walls{{{0, 0}, {1, 0}}, {{0, 0}, {0, 1}}, {{0, 1}, {1, 1}}, {{1, 0}, {1, 1}}};
+    std::uniform_real_distribution<double> unit(0.2, 0.8);
+    const auto cutDoor = [&](std::size_t index) {
+        const Wall wall = walls[index];
+        const double at = unit(random);
+        constexpr double kDoor = 0.08;
+        const glm::dvec2 along = wall.high - wall.low;
+        walls[index] = {wall.low, wall.low + (at - kDoor) * along};
+        walls.push_back({wall.low + (at + kDoor) * along, wall.high});
+    };
+    const int connects = 1 + std::uniform_int_distribution<int>(0, 5)(random);
+    const int doors = 4 + std::uniform_int_distribution<int>(0, 2)(random);
+    for (int i = 0; i < connects; ++i) {
+        const double at = unit(random);
+        walls.push_back(i % 2 == 0 ? Wall{{at, 0}, {at, 1}} : Wall{{0, at}, {1, at}});
+        cutDoor(walls.size() - 1);
+    }
+    for (int i = 0; i < doors; ++i) {
+        cutDoor(std::uniform_int_distribution<std::size_t>(0, walls.size() - 1)(random));
+    }
+    return walls;
+}
+
+/// @brief Defines a mesh prim drawing `arrays`, shared, at `transform` under its world.
+void DefineMesh(Scene& scene, const std::string& path, const MeshArrays& arrays,
+                const glm::dmat4& transform, const glm::dvec3& colour) {
+    Mesh::Define(scene, path);
+    const PrimId prim = scene.Require(path);
+    scene.Write(prim, Mesh::kPoints, arrays.points);
+    scene.Write(prim, Mesh::kFaceVertexCounts, arrays.counts);
+    scene.Write(prim, Mesh::kFaceVertexIndices, arrays.indices);
+    scene.Set(prim, Gprim::kDisplayColor, colour);
+    scene.Set(prim, tokens::kTransform, transform);
+}
+
+glm::dmat4 Placed(const glm::dvec3& at, double yaw, const glm::dvec3& scale = glm::dvec3(1.0)) {
+    return glm::scale(glm::rotate(glm::translate(glm::dmat4(1.0), at), yaw, {0, 0, 1}), scale);
+}
+
+/// @brief Defines one world: its walls, boxes, ramps and agents, and a camera and product an agent.
+void BuildWorld(Scene& scene, const Assets& assets, int world, std::mt19937& random,
+                glm::uvec2 size, const std::vector<Path>& vars, std::vector<Path>& products) {
+    const std::string root = "/World" + std::to_string(world);
+    Xform::Define(scene, root).SetWorld(world);
+    std::uniform_real_distribution<double> spot(-kBounds, kBounds);
+    std::uniform_real_distribution<double> turn(0.0, kPi);
+    int index = 0;
+    for (const Wall& wall : MakeWalls(random)) {
+        const glm::dvec2 low = 2.0 * kBounds * wall.low - kBounds;
+        const glm::dvec2 high = 2.0 * kBounds * wall.high - kBounds;
+        const glm::dvec2 centre = 0.5 * (low + high);
+        const glm::dvec3 scale = wall.Horizontal() ? glm::dvec3(high.x - centre.x, 0.2, 1.0)
+                                                   : glm::dvec3(0.2, high.y - centre.y, 1.0);
+        DefineMesh(scene, root + "/Wall" + std::to_string(index++), assets.wall,
+                   Placed({centre, 0.0}, 0.0, scale), {0.6, 0.6, 0.6});
+    }
+    const int boxes = std::uniform_int_distribution<int>(3, 9)(random);
+    const int elongated = std::uniform_int_distribution<int>(3, boxes)(random);
+    for (int box = 0; box < boxes; ++box) {
+        DefineMesh(scene, root + "/Box" + std::to_string(box),
+                   box < elongated ? assets.elongated : assets.cube,
+                   Placed({spot(random), spot(random), 1.0}, turn(random)), {0.8, 0.5, 0.2});
+    }
+    for (int ramp = 0; ramp < 2; ++ramp) {
+        DefineMesh(scene, root + "/Ramp" + std::to_string(ramp), assets.ramp,
+                   Placed({spot(random), spot(random), 1.0}, turn(random)), {0.3, 0.6, 0.3});
+    }
+    for (int agent = 0; agent < kAgents; ++agent) {
+        const std::string name = root + "/Agent" + std::to_string(agent);
+        const glm::dvec3 at(spot(random), spot(random), 1.0);
+        const double yaw = turn(random);
+        DefineMesh(scene, name, assets.agent, Placed(at, yaw),
+                   agent < 3 ? glm::dvec3(0.2, 0.4, 0.9) : glm::dvec3(0.9, 0.2, 0.2));
+        // Looking along the agent's +y at its eye, 0.5 m up, as Madrona's view does.
+        const glm::dvec3 eye = at + glm::dvec3(0.0, 0.0, 0.5);
+        const glm::dvec3 ahead(-std::sin(yaw), std::cos(yaw), 0.0);
+        const std::string camera = name + "Camera";
+        // A square film 100° high at the default focal length, its near plane past the agent's
+        // own body, which Madrona's views do not see either.
+        Camera::Define(scene, camera)
+            .SetVerticalAperture(2.0 * 0.05 * std::tan(0.5 * 100.0 * kPi / 180.0))
+            .SetHorizontalAperture(2.0 * 0.05 * std::tan(0.5 * 100.0 * kPi / 180.0))
+            .SetClippingRange({1.2, 1e6});
+        scene.Set(camera, tokens::kTransform, LookAtTransform(eye, eye + ahead, {0, 0, 1}));
+        products.emplace_back("/Render/View" + std::to_string(world) + "_" + std::to_string(agent));
+        RenderProduct::Define(scene, products.back())
+            .SetCamera(camera)
+            .SetResolution(glm::dvec2(size))
+            .SetOrderedVars(vars);
+    }
+}
+
+void BuildHideSeek(Scene& scene, const Assets& assets, int worlds, glm::uvec2 size) {
+    GroundPlane::Define(scene, "/Ground");
+    const std::vector<Path> vars{Path("/Render/Vars/Colour"), Path("/Render/Vars/Depth")};
+    RenderVar::Define(scene, vars[0]).SetSourceName(std::string(render_vars::kLdrColor));
+    RenderVar::Define(scene, vars[1]).SetSourceName(std::string(render_vars::kDistanceToCamera));
+    std::mt19937 random(5);
+    std::vector<Path> products;
+    for (int world = 0; world < worlds; ++world) {
+        BuildWorld(scene, assets, world, random, size, vars, products);
+    }
+    RenderSettings::Define(scene, "/Render/Settings").SetProducts(products);
+}
+
+/// @brief Writes the first world's six views side by side as a binary PPM, to check the scene by
+/// eye against Madrona's `--dump-last-frame`.
+void DumpFirstWorld(Renderer& renderer, Scene& scene, std::uint32_t side, const char* path) {
+    const RenderBatch& batch = renderer.Step(scene).front();
+    const Tensor colour = renderer.Read(*batch.Find(render_vars::kLdrColor));
+    const auto* texels = static_cast<const std::uint8_t*>(colour.Data());
+    std::ofstream file(path, std::ios::binary);
+    file << "P6\n" << kAgents * side << " " << side << "\n255\n";
+    for (std::uint32_t row = 0; row < side; ++row) {
+        for (int view = 0; view < kAgents; ++view) {
+            for (std::uint32_t column = 0; column < side; ++column) {
+                const std::size_t at =
+                    4 * ((static_cast<std::size_t>(view) * side + row) * side + column);
+                file.write(reinterpret_cast<const char*>(texels + at), 3);
+            }
+        }
+    }
+    std::printf("  wrote %s\n", path);
+}
+
+Timing StepHideSeek(int worlds, std::uint32_t side, double targetMs) {
+    const char* data = std::getenv("ERNIE_MADRONA_DATA");
+    if (data == nullptr) {
+        std::printf("skipped: set ERNIE_MADRONA_DATA to madrona_benchmark's data directory\n");
+        return {0.0, targetMs};
+    }
+    std::unique_ptr<Renderer> renderer;
+    try {
+        renderer = std::make_unique<Renderer>();
+    } catch (const std::exception& error) {
+        std::printf("skipped: %s\n", error.what());
+        return {0.0, targetMs};
+    }
+    const Assets assets{std::filesystem::path(data)};
+    Scene scene;
+    BuildHideSeek(scene, assets, worlds, glm::uvec2(side));
+    renderer->Step(scene);
+    renderer->Context().WaitIdle();
+    const double ms = Fastest([] {},
+                              [&] {
+                                  renderer->Step(scene);
+                                  renderer->Context().WaitIdle();
+                              });
+    std::printf("  %d worlds, %d views of %u x %u: %.0f worlds, %.0f views a second, on %s\n",
+                worlds, worlds * kAgents, side, side, 1000.0 * worlds / ms,
+                1000.0 * worlds * kAgents / ms, renderer->Context().Info().name.c_str());
+    if (const char* dump = std::getenv("ERNIE_BENCH_DUMP")) {
+        DumpFirstWorld(*renderer, scene, side, dump);
+    }
+    return {ms, targetMs};
+}
+
+bool RegisterHideSeek(int worlds, std::uint32_t side, double targetMs) {
+    return Register("render.hide_seek." + std::to_string(worlds) + "_worlds_" +
+                        std::to_string(side) + "x" + std::to_string(side),
+                    [=] { return StepHideSeek(worlds, side, targetMs); });
+}
+
+// Targets: madrona_benchmark's hideseek_headless step times, ray tracer, on an RTX 5070 Laptop
+// GPU (its step simulates too).
+const bool kHideSeek = RegisterHideSeek(1024, 64, 49.4) && RegisterHideSeek(1024, 128, 149.4) &&
+                       RegisterHideSeek(1024, 256, 501.1) && RegisterHideSeek(4096, 64, 193.5);
+
+}  // namespace
+}  // namespace ernie::bench

ernie_renderer-0.2.0.dev161/cmake/EmbedFile.cmake

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Writes the bytes of INPUT to OUTPUT as a C++ source defining `SYMBOL`, an unsigned char array,
+# and `SYMBOL_size`, both with C linkage, so nothing reads the file at run time.
+# Run as `cmake -DINPUT=... -DOUTPUT=... -DSYMBOL=... -P EmbedFile.cmake`.
+file(READ "${INPUT}" bytes HEX)
+string(LENGTH "${bytes}" hex_length)
+math(EXPR size "${hex_length} / 2")
+string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," bytes "${bytes}")
+string(REGEX REPLACE "((0x[0-9a-f][0-9a-f],){32})" "\\1\n" bytes "${bytes}")
+file(
+    WRITE "${OUTPUT}"
+    "// Generated from ${INPUT}; do not edit.\n#include <cstddef>\n\nextern \"C\" {\n"
+    "extern const unsigned char ${SYMBOL}[];\nextern const std::size_t ${SYMBOL}_size;\n"
+    "const unsigned char ${SYMBOL}[] = {\n${bytes}\n};\n"
+    "const std::size_t ${SYMBOL}_size = ${size};\n}\n"
+)

ernie_renderer-0.2.0.dev161/cmake/third_party/fonts.cmake

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# The viewer's typefaces, as Ernie 1's: Inter (SIL OFL 1.1) for text and Lucide (ISC) for icons,
+# each a single TTF compiled in as a byte array (`kErnieFont_inter`, `kErnieFont_lucide`).
+set(ERNIE_DEP_VERSION_inter v4.1 CACHE STRING "Tag of the Inter typeface to fetch")
+set(ERNIE_DEP_VERSION_lucide 1.52.0 CACHE STRING "Version of lucide-static's icon font to fetch")
+mark_as_advanced(ERNIE_DEP_VERSION_inter ERNIE_DEP_VERSION_lucide)
+
+set(ernie_fonts_dir "${ERNIE_DEPS_DIR}/fonts")
+set(ernie_fonts_generated "${CMAKE_BINARY_DIR}/generated/fonts")
+
+# Downloads `url` to `file` in the fonts directory, checked against `hash`, unless it is there.
+function(ernie_fetch_font file url hash)
+    set(path "${ernie_fonts_dir}/${file}")
+    if(NOT EXISTS "${path}")
+        file(DOWNLOAD "${url}" "${path}" EXPECTED_HASH SHA256=${hash} STATUS status)
+        list(GET status 0 code)
+        if(NOT code EQUAL 0)
+            file(REMOVE "${path}")
+            message(FATAL_ERROR "Fetching ${url} failed: ${status}")
+        endif()
+    endif()
+endfunction()
+
+ernie_fetch_font(
+    "InterVariable-${ERNIE_DEP_VERSION_inter}.ttf"
+    "https://raw.githubusercontent.com/rsms/inter/${ERNIE_DEP_VERSION_inter}/docs/font-files/InterVariable.ttf"
+    4989b125924991b90d05b2d16e0e388c48f7d5bb8b30539bbf9c755278d0ccaf
+)
+ernie_fetch_font(
+    "inter-LICENSE-${ERNIE_DEP_VERSION_inter}.txt"
+    "https://raw.githubusercontent.com/rsms/inter/${ERNIE_DEP_VERSION_inter}/LICENSE.txt"
+    262481e844521b326f5ecd053e59b98c8b2da78c8ee1bdbb6e8174305e54935a
+)
+ernie_fetch_font(
+    "lucide-${ERNIE_DEP_VERSION_lucide}.ttf"
+    "https://cdn.jsdelivr.net/npm/lucide-static@${ERNIE_DEP_VERSION_lucide}/font/lucide.ttf"
+    124ecc64b91a158fc519eefdaaead89a2d9e2c39b6f9c8429c5584c93a0be451
+)
+ernie_fetch_font(
+    "lucide-LICENSE-${ERNIE_DEP_VERSION_lucide}.txt"
+    "https://cdn.jsdelivr.net/npm/lucide-static@${ERNIE_DEP_VERSION_lucide}/LICENSE"
+    b495047bd93a9b06913511076f504daba17d5bbeb3e0650f3bb53a4220329c57
+)
+
+set(ernie_font_sources)
+foreach(
+    font
+    "inter|InterVariable-${ERNIE_DEP_VERSION_inter}.ttf"
+    "lucide|lucide-${ERNIE_DEP_VERSION_lucide}.ttf"
+)
+    string(REPLACE "|" ";" parts "${font}")
+    list(GET parts 0 name)
+    list(GET parts 1 file)
+    set(output "${ernie_fonts_generated}/${name}_font.cpp")
+    add_custom_command(
+        OUTPUT "${output}"
+        COMMAND
+            "${CMAKE_COMMAND}" "-DINPUT=${ernie_fonts_dir}/${file}" "-DOUTPUT=${output}"
+            "-DSYMBOL=kErnieFont_${name}" -P "${PROJECT_SOURCE_DIR}/cmake/EmbedFile.cmake"
+        DEPENDS "${ernie_fonts_dir}/${file}" "${PROJECT_SOURCE_DIR}/cmake/EmbedFile.cmake"
+        COMMENT "Embedding the ${name} font"
+        VERBATIM
+    )
+    list(APPEND ernie_font_sources "${output}")
+endforeach()
+add_library(ernie_fonts STATIC ${ernie_font_sources})
+set_target_properties(ernie_fonts PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set(ernie_font_notices
+    "inter|${ernie_fonts_dir}/inter-LICENSE-${ERNIE_DEP_VERSION_inter}.txt"
+    "lucide|${ernie_fonts_dir}/lucide-LICENSE-${ERNIE_DEP_VERSION_lucide}.txt"
+)

ernie_renderer-0.2.0.dev161/demos/CMakeLists.txt

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# The demos, `<category>/demo_<category>_<name>.cpp`, each registering itself with
+# ERNIE_REGISTER_DEMO; an object library, so the program and tests linking it keep every one.
+add_library(ernie_demos OBJECT basics/demo_basics_bounce.cpp)
+target_link_libraries(ernie_demos PUBLIC ernie_viewer PRIVATE ernie_build_options)
+target_link_libraries(ernie_app PRIVATE ernie_demos)

ernie_renderer-0.2.0.dev161/demos/basics/demo_basics_bounce.cpp

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file demo_basics_bounce.cpp
+/// @brief A ball dropped on the ground, bouncing under gravity, each bounce lower.
+#include "ernie/app/demo.h"
+#include "ernie/scene/schema/camera.h"
+#include "ernie/scene/schema/geom.h"
+#include "ernie/scene/schema/planet.h"
+#include "ernie/scene/schema/render.h"
+#include "ernie/scene/tokens.h"
+#include "ernie/scene/xform.h"
+
+#include <imgui.h>
+
+namespace ernie::app {
+namespace {
+
+class Bounce final : public Demo {
+  public:
+    explicit Bounce(Scene& scene) : Demo(scene) {
+        description = "A ball dropped from 4 m bounces on the ground, losing a share of its speed "
+                      "each bounce.";
+        GroundPlane::Define(scene, "/World/Ground");
+        Sphere::Define(scene, "/World/Ball").SetRadius(kRadius).SetDisplayColor({0.85, 0.35, 0.2});
+        Camera::Define(scene, "/World/Camera");
+        scene.Set("/World/Camera", tokens::kTransform,
+                  LookAtTransform({0.0, -12.0, 4.0}, {0.0, 0.0, 2.0}, {0.0, 0.0, 1.0}));
+        RenderSettings::Define(scene, "/Render/Settings").SetCamera("/World/Camera");
+        Place();
+    }
+
+    void Step() override {
+        velocity_ -= kGravity * fixedDt;
+        height_ += velocity_ * fixedDt;
+        if (height_ < kRadius) {
+            height_ = kRadius;
+            velocity_ = -velocity_ * restitution_;
+        }
+        Place();
+    }
+
+    void Gui() override {
+        ImGui::SliderFloat("Restitution", &restitution_, 0.0f, 1.0f);
+        if (ImGui::Button("Drop Again")) {
+            height_ = 4.0;
+            velocity_ = 0.0;
+        }
+    }
+
+    void TestFinal() override {
+        if (height_ < kRadius - 1e-9) {
+            throw std::runtime_error("The ball fell through the ground");
+        }
+    }
+
+  private:
+    static constexpr double kRadius = 0.5;
+    static constexpr double kGravity = 9.81;
+
+    void Place() {
+        SetXform(GetScene(), "/World/Ball", {.translate = glm::dvec3(0.0, 0.0, height_)});
+    }
+
+    double height_ = 4.0;
+    double velocity_ = 0.0;
+    float restitution_ = 0.8f;
+};
+
+}  // namespace
+
+ERNIE_REGISTER_DEMO(Bounce, "basics", "bounce", "A ball bouncing on the ground, lower each time.");
+
+}  // namespace ernie::app

{ernie_renderer-0.2.0.dev153 → ernie_renderer-0.2.0.dev161}/ernie/app/CMakeLists.txt

@@ -1,13 +1,24 @@
 # SPDX-License-Identifier: BSD-3-Clause
 include("${PROJECT_SOURCE_DIR}/cmake/third_party/glfw.cmake")
 include("${PROJECT_SOURCE_DIR}/cmake/third_party/dear_imgui.cmake")
+include("${PROJECT_SOURCE_DIR}/cmake/third_party/fonts.cmake")
 
 # The viewer: its window, panels and frame loop, a library so tests drive it without a window.
-add_library(ernie_viewer STATIC create.cpp imgui_backend.cpp ui.cpp viewer.cpp)
+add_library(
+    ernie_viewer
+    STATIC
+    capture.cpp
+    create.cpp
+    demo.cpp
+    imgui_backend.cpp
+    timeline.cpp
+    ui.cpp
+    viewer.cpp
+)
 target_link_libraries(
     ernie_viewer
     PUBLIC ernie_static ernie_imgui ernie_volk ernie_vma
-    PRIVATE ernie_build_options
+    PRIVATE ernie_fonts ernie_build_options
 )
 if(TARGET ernie_glfw)
     target_link_libraries(ernie_viewer PRIVATE ernie_imgui_glfw)
@@ -20,7 +31,7 @@ target_link_libraries(ernie_app PRIVATE ernie_viewer ernie_build_options)
 install(TARGETS ernie_app RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT app)
 
 # The licences of what the program carries.
-set(ernie_app_notices "dear_imgui|${dear_imgui_SOURCE_DIR}/LICENSE.txt")
+set(ernie_app_notices "dear_imgui|${dear_imgui_SOURCE_DIR}/LICENSE.txt" ${ernie_font_notices})
 if(glfw_SOURCE_DIR)
     list(APPEND ernie_app_notices "glfw|${glfw_SOURCE_DIR}/LICENSE.md")
 endif()

ernie_renderer-0.2.0.dev161/ernie/app/capture.cpp

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file capture.cpp
+/// @brief Capture names, unique paths, the default folder and ffmpeg's encoding commands.
+#include "ernie/app/capture.h"
+
+#include <array>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <system_error>
+
+namespace ernie::app {
+namespace {
+
+/// @return Whether a file name cannot hold the character on some system.
+bool Forbidden(char c) {
+    return c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' || c == '<' ||
+           c == '>' || c == '|' || static_cast<unsigned char>(c) < 32;
+}
+
+std::tm LocalTime(std::chrono::system_clock::time_point when) {
+    const std::time_t seconds = std::chrono::system_clock::to_time_t(when);
+    std::tm local{};
+#if defined(_WIN32)
+    localtime_s(&local, &seconds);
+#else
+    localtime_r(&seconds, &local);
+#endif
+    return local;
+}
+
+}  // namespace
+
+std::string ExpandCaptureName(std::string_view pattern, const CaptureNameFields& fields) {
+    const std::tm local = LocalTime(fields.when);
+    std::array<char, 16> date{};
+    std::array<char, 16> time{};
+    std::array<char, 32> frame{};
+    std::strftime(date.data(), date.size(), "%Y-%m-%d", &local);
+    std::strftime(time.data(), time.size(), "%H-%M-%S", &local);
+    std::snprintf(frame.data(), frame.size(), "%04lld", static_cast<long long>(fields.frame));
+    std::string name;
+    for (std::size_t i = 0; i < pattern.size(); ++i) {
+        const std::size_t close = pattern.find('}', i);
+        if (pattern[i] == '{' && close != std::string_view::npos) {
+            const std::string_view key = pattern.substr(i + 1, close - i - 1);
+            name += key == "scene"    ? fields.scene
+                    : key == "camera" ? fields.camera
+                    : key == "date"   ? std::string(date.data())
+                    : key == "time"   ? std::string(time.data())
+                    : key == "frame"  ? std::string(frame.data())
+                                      : std::string(pattern.substr(i, close - i + 1));
+            i = close;
+            continue;
+        }
+        name += pattern[i];
+    }
+    for (char& c : name) {
+        if (Forbidden(c)) {
+            c = '_';
+        }
+    }
+    return name.empty() ? std::string("capture") : name;
+}
+
+std::filesystem::path UniquePath(const std::filesystem::path& path) {
+    std::error_code error;
+    if (!std::filesystem::exists(path, error)) {
+        return path;
+    }
+    const std::filesystem::path stem = path.parent_path() / path.stem();
+    const std::string extension = path.extension().string();
+    for (int n = 1;; ++n) {
+        std::filesystem::path next = stem;
+        next += "_" + std::to_string(n) + extension;
+        if (!std::filesystem::exists(next, error)) {
+            return next;
+        }
+    }
+}
+
+std::filesystem::path DefaultCaptureFolder() {
+#if defined(_WIN32)
+    const char* home = std::getenv("USERPROFILE");
+#else
+    const char* home = std::getenv("HOME");
+#endif
+    std::error_code error;
+    if (home != nullptr && *home != '\0') {
+        const std::filesystem::path pictures = std::filesystem::path(home) / "Pictures";
+        if (std::filesystem::is_directory(pictures, error)) {
+            return pictures / "Ernie";
+        }
+    }
+    return std::filesystem::current_path(error) / "captures";
+}
+
+const char* VideoExtension(VideoFormat format) {
+    switch (format) {
+    case VideoFormat::Mp4:
+        return ".mp4";
+    case VideoFormat::ProRes:
+        return ".mov";
+    case VideoFormat::None:
+        break;
+    }
+    return "";
+}
+
+std::vector<std::string> EncodeCommand(const std::filesystem::path& ffmpeg,
+                                       const std::filesystem::path& framePattern, double fps,
+                                       const std::filesystem::path& video, VideoFormat format) {
+    std::array<char, 32> rate{};
+    std::snprintf(rate.data(), rate.size(), "%g", fps);
+    std::vector<std::string> command{ffmpeg.string(), "-hide_banner", "-loglevel",
+                                     "error",         "-y",           "-framerate",
+                                     rate.data(),     "-i",           framePattern.string()};
+    if (format == VideoFormat::ProRes) {
+        // Profile 3: 422 HQ.
+        command.insert(command.end(),
+                       {"-c:v", "prores_ks", "-profile:v", "3", "-pix_fmt", "yuv422p10le"});
+    } else {
+        // Even sizes, which 4:2:0 needs.
+        command.insert(command.end(), {"-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p",
+                                       "-vf", "pad=ceil(iw/2)*2:ceil(ih/2)*2"});
+    }
+    command.push_back(video.string());
+    return command;
+}
+
+}  // namespace ernie::app