hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/make_drone_glb.py

@@ -0,0 +1,172 @@
+"""Generates drone.glb: a quadrotor with 5 glTF scene-root nodes (body, prop_0..prop_3).
+
+The assembly loader (rl_tools::load(device, ObjectAssembly&, path)) turns each scene-root
+node into one articulated part with the node origin as its pivot, so each prop node sits
+at its hub and spins about its local Z. Geometry is authored in FLU (x forward, y left,
+z up) and swizzled to glTF Y-up on emit; the renderer swizzles back at load time.
+"""
+import json
+import math
+import struct
+import os
+
+SPAN = 0.075            # hub offset in +-x and +-y (FLU, meters)
+BODY_HALF = (0.05, 0.03, 0.015)
+ARM_HALF = (0.053, 0.006, 0.004)
+ARM_Z = 0.008
+POD_HALF = (0.008, 0.008, 0.010)
+POD_Z = 0.012
+PROP_Z = 0.025          # prop plane height above body center (node origin z)
+BLADE_HALF = (0.055, 0.007, 0.0015)
+CAP_HALF = (0.007, 0.007, 0.0025)
+
+BODY_COLOR = (0.42, 0.44, 0.48)
+PROP_FRONT_COLOR = (0.85, 0.25, 0.05)
+PROP_REAR_COLOR = (0.2, 0.2, 0.22)
+
+HUBS = {  # name -> (sx, sy) in FLU
+    "prop_0": (+1, +1),
+    "prop_1": (+1, -1),
+    "prop_2": (-1, +1),
+    "prop_3": (-1, -1),
+}
+
+
+def flu_to_gltf(v):
+    return (v[0], v[2], -v[1])
+
+
+def cuboid(center, half, yaw=0.0):
+    c, s = math.cos(yaw), math.sin(yaw)
+    faces = [
+        ((+1, 0, 0), (0, +1, 0), (0, 0, +1)),
+        ((-1, 0, 0), (0, -1, 0), (0, 0, +1)),
+        ((0, +1, 0), (-1, 0, 0), (0, 0, +1)),
+        ((0, -1, 0), (+1, 0, 0), (0, 0, +1)),
+        ((0, 0, +1), (0, +1, 0), (+1, 0, 0)),
+        ((0, 0, -1), (0, +1, 0), (-1, 0, 0)),
+    ]
+    positions, normals, indices = [], [], []
+    for normal, tangent, bitangent in faces:
+        base = len(positions)
+        for du, dv in ((-1, -1), (+1, -1), (+1, +1), (-1, +1)):
+            local = [
+                (normal[i] + du * tangent[i] + dv * bitangent[i]) * half[i]
+                for i in range(3)
+            ]
+            rotated = (
+                local[0] * c - local[1] * s + center[0],
+                local[0] * s + local[1] * c + center[1],
+                local[2] + center[2],
+            )
+            positions.append(rotated)
+            normals.append((normal[0] * c - normal[1] * s, normal[0] * s + normal[1] * c, normal[2]))
+        indices += [base, base + 1, base + 2, base, base + 2, base + 3]
+    return positions, normals, indices
+
+
+def merge(parts):
+    positions, normals, indices = [], [], []
+    for p, n, i in parts:
+        offset = len(positions)
+        positions += p
+        normals += n
+        indices += [offset + index for index in i]
+    return positions, normals, indices
+
+
+def body_geometry():
+    parts = [cuboid((0, 0, 0), BODY_HALF)]
+    for sx, sy in HUBS.values():
+        hub = (sx * SPAN, sy * SPAN)
+        yaw = math.atan2(hub[1], hub[0])
+        parts.append(cuboid((hub[0] / 2, hub[1] / 2, ARM_Z), ARM_HALF, yaw))
+        parts.append(cuboid((hub[0], hub[1], POD_Z), POD_HALF))
+    return merge(parts)
+
+
+def prop_geometry():
+    return merge([
+        cuboid((0, 0, 0), BLADE_HALF),
+        cuboid((0, 0, -0.001), CAP_HALF),
+    ])
+
+
+def main():
+    meshes = {
+        "body": body_geometry(),
+        "prop_front": prop_geometry(),
+        "prop_rear": prop_geometry(),
+    }
+    materials = [
+        {"name": name, "pbrMetallicRoughness": {"baseColorFactor": [*color, 1.0], "metallicFactor": 0.0, "roughnessFactor": roughness}}
+        for name, color, roughness in [
+            ("body", BODY_COLOR, 0.6),
+            ("prop_front", PROP_FRONT_COLOR, 0.5),
+            ("prop_rear", PROP_REAR_COLOR, 0.5),
+        ]
+    ]
+
+    binary = b""
+    buffer_views = []
+    accessors = []
+    gltf_meshes = []
+    for mesh_index, (name, (positions, normals, indices)) in enumerate(meshes.items()):
+        gltf_positions = [flu_to_gltf(p) for p in positions]
+        gltf_normals = [flu_to_gltf(n) for n in normals]
+        attribute_accessors = {}
+        for attribute, data in (("POSITION", gltf_positions), ("NORMAL", gltf_normals)):
+            payload = b"".join(struct.pack("<fff", *v) for v in data)
+            buffer_views.append({"buffer": 0, "byteOffset": len(binary), "byteLength": len(payload), "target": 34962})
+            accessor = {"bufferView": len(buffer_views) - 1, "componentType": 5126, "count": len(data), "type": "VEC3"}
+            if attribute == "POSITION":
+                accessor["min"] = [min(v[i] for v in data) for i in range(3)]
+                accessor["max"] = [max(v[i] for v in data) for i in range(3)]
+            accessors.append(accessor)
+            attribute_accessors[attribute] = len(accessors) - 1
+            binary += payload
+        payload = b"".join(struct.pack("<H", i) for i in indices)
+        payload += b"\x00" * ((4 - len(payload) % 4) % 4)
+        buffer_views.append({"buffer": 0, "byteOffset": len(binary), "byteLength": len(payload), "target": 34963})
+        accessors.append({"bufferView": len(buffer_views) - 1, "componentType": 5123, "count": len(indices), "type": "SCALAR"})
+        binary += payload
+        gltf_meshes.append({
+            "name": name,
+            "primitives": [{"attributes": attribute_accessors, "indices": len(accessors) - 1, "material": mesh_index}],
+        })
+
+    nodes = [{"mesh": 0, "name": "body"}]
+    for name, (sx, sy) in HUBS.items():
+        nodes.append({
+            "mesh": 1 if sx > 0 else 2,
+            "name": name,
+            "translation": list(flu_to_gltf((sx * SPAN, sy * SPAN, PROP_Z))),
+        })
+
+    gltf = {
+        "asset": {"version": "2.0"},
+        "scene": 0,
+        "scenes": [{"nodes": list(range(len(nodes)))}],
+        "nodes": nodes,
+        "meshes": gltf_meshes,
+        "materials": materials,
+        "buffers": [{"byteLength": len(binary)}],
+        "bufferViews": buffer_views,
+        "accessors": accessors,
+    }
+
+    json_bytes = json.dumps(gltf).encode()
+    json_bytes += b" " * ((4 - len(json_bytes) % 4) % 4)
+    length = 12 + 8 + len(json_bytes) + 8 + len(binary)
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "drone.glb")
+    with open(path, "wb") as handle:
+        handle.write(struct.pack("<III", 0x46546C67, 2, length))
+        handle.write(struct.pack("<II", len(json_bytes), 0x4E4F534A))
+        handle.write(json_bytes)
+        handle.write(struct.pack("<II", len(binary), 0x004E4942))
+        handle.write(binary)
+    print(f"wrote {path} ({length} bytes)")
+
+
+if __name__ == "__main__":
+    main()

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/minimal.cpp

@@ -0,0 +1,82 @@
+#include <rl_tools/operations/cpu_mux.h>
+#include <rl_tools/rendering/raytracing/operations_cpu_mux.h>
+#include <rl_tools/rendering/datasets/glb/operations_cpu.h>
+#include <rl_tools/rendering/raytracing/save_cpu.h>
+
+#include <cmath>
+#include <iostream>
+#include <string>
+
+namespace rlt = rl_tools;
+
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+using T = float;
+static constexpr T FOV = 80;
+using TI = typename DEVICE::index_t;
+
+struct CONFIG: rlt::rendering::raytracing::config::Default<T, TI>{
+    static constexpr TI CAM_WIDTH = 256, CAM_HEIGHT = 256, NUM_CAMERAS = 8, NUM_PROBES = 1;
+    using SHADING = rlt::rendering::raytracing::High;
+};
+using SPEC = rlt::rendering::raytracing::Specification<CONFIG>;
+using Renderer = rlt::rendering::raytracing::Renderer<SPEC>;
+
+int main(int argc, char** argv){
+    const std::string scene_path = argc > 1 ? argv[1] : "tests/data/ProcTHOR-Train-1.glb";
+    const std::string output_prefix = argc > 2 ? argv[2] : "minimal";
+
+    DEVICE device;
+    rlt::init(device);
+
+    Renderer renderer;
+    rlt::malloc(device, renderer);
+
+    rlt::rendering::Bundle<T> bundle;
+    if(!rlt::load<typename SPEC::SHADING, SPEC::HAS_RGB>(device, bundle, scene_path)){
+        std::cerr << "Failed to load scene: " << scene_path << std::endl;
+        rlt::free(device, renderer);
+        return 1;
+    }
+    rlt::init(device, renderer, bundle);
+
+    // panorama: one camera per yaw from an interior point of the default scene (FLU frame)
+    constexpr T PI = static_cast<T>(3.14159265358979323846);
+    constexpr T aspect = static_cast<T>(SPEC::CAM_WIDTH) / static_cast<T>(SPEC::CAM_HEIGHT);
+    constexpr T position[3] = {static_cast<T>(-6.28), static_cast<T>(-4.18), static_cast<T>(1.5)};
+    const T up[3] = {0, 0, 1};
+    rlt::Tensor<typename Renderer::CAMERA_TENSOR_SPEC> camera_staging;
+    rlt::malloc(device, camera_staging);
+    for(TI camera_i = 0; camera_i < SPEC::NUM_CAMERAS; camera_i++){
+        const T angle = 2 * PI * static_cast<T>(camera_i) / static_cast<T>(SPEC::NUM_CAMERAS);
+        const T look_at[3] = {
+            position[0] + std::cos(angle),
+            position[1] + std::sin(angle),
+            position[2]
+        };
+        rlt::set(device, camera_staging, rlt::make_camera_data(position, look_at, up, FOV, aspect), camera_i);
+    }
+    rlt::copy(device, renderer.device, camera_staging, rlt::cameras(device, renderer));
+
+    rlt::render(device, renderer);
+
+    rlt::Tensor<typename decltype(renderer.frame_buffer)::SPEC> frame_buffer;
+    rlt::malloc(device, frame_buffer);
+    rlt::copy(renderer.device, device, rlt::frame_buffer(device, renderer), frame_buffer);
+
+    int status = 0;
+    for(TI camera_i = 0; camera_i < SPEC::NUM_CAMERAS; camera_i++){
+        const std::string path = output_prefix + "_" + std::to_string(camera_i) + ".png";
+        if(stbi_write_png(path.c_str(), SPEC::CAM_WIDTH, SPEC::CAM_HEIGHT, 4, rlt::data(frame_buffer) + camera_i * SPEC::CAM_PIXELS, SPEC::CAM_WIDTH * 4) == 0){
+            std::cerr << "Failed to write " << path << std::endl;
+            status = 1;
+        }
+        else{
+            std::cout << "Wrote " << path << std::endl;
+        }
+    }
+
+    rlt::free(device, camera_staging);
+    rlt::free(device, frame_buffer);
+    rlt::free(device, renderer);
+    return status;
+}

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/minimal_overlay.cpp

@@ -0,0 +1,137 @@
+#include <rl_tools/operations/cpu_mux.h>
+#include <rl_tools/rendering/raytracing/operations_cpu_mux.h>
+#include <rl_tools/rendering/datasets/glb/operations_cpu.h>
+#include <rl_tools/rendering/raytracing/save_cpu.h>
+
+#include <cmath>
+#include <iostream>
+#include <string>
+
+namespace rlt = rl_tools;
+
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+using T = float;
+static constexpr T FOV = 80;
+using TI = typename DEVICE::index_t;
+
+struct CONFIG: rlt::rendering::raytracing::config::Default<T, TI>{
+    static constexpr TI CAM_WIDTH = 512, CAM_HEIGHT = 512, NUM_CAMERAS = 2, NUM_PROBES = 1;
+    using SHADING = rlt::rendering::raytracing::High;
+    static constexpr TI NUM_OVERLAYS = 3;
+    static constexpr TI MAX_OVERLAY_INSTANCES = 5;
+    static constexpr TI MAX_OVERLAYS_PER_CAMERA = 3;
+};
+using SPEC = rlt::rendering::raytracing::Specification<CONFIG>;
+using Renderer = rlt::rendering::raytracing::Renderer<SPEC>;
+
+void yaw_transform(const T position[3], T yaw, float transform[12]){
+    const float half = static_cast<float>(yaw) / 2;
+    const float quaternion_wxyz[4] = {std::cos(half), 0, 0, std::sin(half)};
+    const float position_float[3] = {static_cast<float>(position[0]), static_cast<float>(position[1]), static_cast<float>(position[2])};
+    rlt::make_transform(position_float, quaternion_wxyz, transform);
+}
+
+int render_and_save(DEVICE& device, Renderer& renderer, const std::string& output_prefix, const std::string& suffix){
+    rlt::render(device, renderer);
+    rlt::Tensor<typename decltype(renderer.frame_buffer)::SPEC> frame_buffer;
+    rlt::malloc(device, frame_buffer);
+    rlt::copy(renderer.device, device, rlt::frame_buffer(device, renderer), frame_buffer);
+    int status = 0;
+    for(TI camera_i = 0; camera_i < SPEC::NUM_CAMERAS; camera_i++){
+        const std::string path = output_prefix + "_camera_" + std::to_string(camera_i) + suffix + ".png";
+        if(stbi_write_png(path.c_str(), SPEC::CAM_WIDTH, SPEC::CAM_HEIGHT, 4, rlt::data(frame_buffer) + camera_i * SPEC::CAM_PIXELS, SPEC::CAM_WIDTH * 4) == 0){
+            std::cerr << "Failed to write " << path << std::endl;
+            status = 1;
+        }
+        else{
+            std::cout << "Wrote " << path << std::endl;
+        }
+    }
+    rlt::free(device, frame_buffer);
+    return status;
+}
+
+int main(int argc, char** argv){
+    const std::string scene_path = argc > 1 ? argv[1] : "tests/data/ProcTHOR-Train-1.glb";
+    const std::string output_prefix = argc > 2 ? argv[2] : "minimal_overlay";
+
+    DEVICE device;
+    rlt::init(device);
+
+    Renderer renderer;
+    rlt::malloc(device, renderer);
+
+    rlt::rendering::Bundle<T> bundle;
+    if(!rlt::load<typename SPEC::SHADING, SPEC::HAS_RGB>(device, bundle, scene_path)){
+        std::cerr << "Failed to load scene: " << scene_path << std::endl;
+        rlt::free(device, renderer);
+        return 1;
+    }
+    constexpr T LIGHT_INTENSITY_SCALE = 6;
+    for(auto& light : bundle.scene.lights){
+        for(TI channel_i = 0; channel_i < 3; channel_i++){
+            light.color[channel_i] *= LIGHT_INTENSITY_SCALE;
+        }
+    }
+
+    rlt::rendering::raytracing::AssetPool pool;
+    const std::string drone_paths[3] = {"tests/data/x500.glb", "tests/data/savagebee_pusher.glb", "tests/data/soft.glb"};
+    rlt::rendering::raytracing::AssetHandle drone_assets[3];
+    for(TI drone_i = 0; drone_i < 3; drone_i++){
+        rlt::rendering::raytracing::ObjectAssembly assembly;
+        if(!rlt::load<typename SPEC::SHADING, SPEC::HAS_RGB>(device, assembly, drone_paths[drone_i])){
+            std::cerr << "Failed to load drone: " << drone_paths[drone_i] << std::endl;
+            rlt::free(device, renderer);
+            return 1;
+        }
+        drone_assets[drone_i] = rlt::add(device, pool, assembly);
+    }
+
+    rlt::init(device, renderer, bundle, pool);
+
+    // drones A and B face each other across the living room (FLU frame) with a clear sight
+    // line; the shared drone hovers off to the side of that line. Each camera aims straight at
+    // the other 3rd-person drone, so it would be dead center in frame — the overlay
+    // attachments are the only thing removing it
+    constexpr T PI = static_cast<T>(3.14159265358979323846);
+    constexpr T drone_a_position[3] = {static_cast<T>(-6.3), static_cast<T>(-4.5), static_cast<T>(1.6)};
+    constexpr T drone_b_position[3] = {static_cast<T>(-4.3), static_cast<T>(-4.5), static_cast<T>(1.6)};
+    constexpr T drone_shared_position[3] = {static_cast<T>(-5.3), static_cast<T>(-5.35), static_cast<T>(2.0)};
+
+    float transform[12];
+    yaw_transform(drone_a_position, 0, transform);
+    rlt::spawn(device, renderer, rlt::rendering::raytracing::OverlayIndex{0}, drone_assets[0], transform);
+    yaw_transform(drone_b_position, PI, transform);
+    rlt::spawn(device, renderer, rlt::rendering::raytracing::OverlayIndex{1}, drone_assets[1], transform);
+    yaw_transform(drone_shared_position, PI / 2, transform);
+    rlt::spawn(device, renderer, rlt::rendering::raytracing::OverlayIndex{2}, drone_assets[2], transform);
+
+    rlt::attach(device, renderer, 0, rlt::rendering::raytracing::OverlayIndex{0});
+    rlt::attach(device, renderer, 0, rlt::rendering::raytracing::OverlayIndex{2});
+    rlt::attach(device, renderer, 1, rlt::rendering::raytracing::OverlayIndex{1});
+    rlt::attach(device, renderer, 1, rlt::rendering::raytracing::OverlayIndex{2});
+    rlt::update(device, renderer);
+
+    constexpr T aspect = static_cast<T>(SPEC::CAM_WIDTH) / static_cast<T>(SPEC::CAM_HEIGHT);
+    const T up[3] = {0, 0, 1};
+    const T camera_0_position[3] = {drone_a_position[0] - static_cast<T>(1.0), drone_a_position[1], drone_a_position[2] + static_cast<T>(0.8)};
+    const T camera_1_position[3] = {drone_b_position[0] + static_cast<T>(1.0), drone_b_position[1], drone_b_position[2] + static_cast<T>(0.8)};
+    rlt::Tensor<typename Renderer::CAMERA_TENSOR_SPEC> camera_staging;
+    rlt::malloc(device, camera_staging);
+    rlt::set(device, camera_staging, rlt::make_camera_data(camera_0_position, drone_b_position, up, FOV, aspect), 0);
+    rlt::set(device, camera_staging, rlt::make_camera_data(camera_1_position, drone_a_position, up, FOV, aspect), 1);
+    rlt::copy(device, renderer.device, camera_staging, rlt::cameras(device, renderer));
+    rlt::free(device, camera_staging);
+
+    int status = render_and_save(device, renderer, output_prefix, "");
+
+    // proof shot: attach the remaining overlay to each camera — the other 3rd-person drone
+    // appears dead center, exactly where the first render filtered it out
+    rlt::attach(device, renderer, 0, rlt::rendering::raytracing::OverlayIndex{1});
+    rlt::attach(device, renderer, 1, rlt::rendering::raytracing::OverlayIndex{0});
+    rlt::update(device, renderer);
+    status |= render_and_save(device, renderer, output_prefix, "_all");
+
+    rlt::free(device, renderer);
+    return status;
+}

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/motion_blur.cpp

@@ -0,0 +1,232 @@
+#define RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS 1
+
+#include <rl_tools/operations/cpu_mux.h>
+#include <rl_tools/rendering/raytracing/operations_cpu_mux.h>
+#include "../camera_orbit.h"
+#include <rl_tools/rendering/datasets/glb/operations_cpu.h>
+
+
+#include <array>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace rlt = rl_tools;
+
+using T = float;
+static constexpr T FOV = 80;
+using TI = typename rlt::devices::DEVICE_FACTORY<>::index_t;
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+
+static constexpr TI CAM_WIDTH = 256;
+static constexpr TI CAM_HEIGHT = 144;
+static constexpr TI NUM_CAMERAS = 1;
+static constexpr TI NUM_PROBES = 1;
+static constexpr TI NUM_PANELS = 6;
+
+template <TI SAMPLES>
+struct RendererConfig: rlt::rendering::raytracing::config::Default<T, TI>{
+    static constexpr TI CAM_WIDTH = ::CAM_WIDTH, CAM_HEIGHT = ::CAM_HEIGHT, NUM_CAMERAS = ::NUM_CAMERAS, NUM_PROBES = ::NUM_PROBES;
+    static constexpr bool ENABLE_MOTION_BLUR = SAMPLES > 1;
+    static constexpr TI MOTION_BLUR_SAMPLES = SAMPLES;
+};
+template <TI SAMPLES>
+using RendererSpec = rlt::rendering::raytracing::Specification<RendererConfig<SAMPLES>>;
+
+template <typename SPEC>
+using Renderer = rlt::rendering::raytracing::Renderer<SPEC>;
+
+struct Options {
+    std::string scene_path = "tests/data/ProcTHOR-Train-1.glb";
+    std::string output_path = "raytracing_motion_blur_levels.mp4";
+    int frames = 120;
+    double fps = 30.0;
+};
+
+Options parse_options(int argc, char** argv) {
+    Options options;
+    for (int i = 1; i < argc; i++) {
+        if ((std::strcmp(argv[i], "--scene") == 0 || std::strcmp(argv[i], "-s") == 0) && i + 1 < argc) {
+            options.scene_path = argv[++i];
+        }
+        else if ((std::strcmp(argv[i], "--output") == 0 || std::strcmp(argv[i], "-o") == 0) && i + 1 < argc) {
+            options.output_path = argv[++i];
+        }
+        else if (std::strcmp(argv[i], "--frames") == 0 && i + 1 < argc) {
+            options.frames = std::atoi(argv[++i]);
+        }
+        else if (std::strcmp(argv[i], "--fps") == 0 && i + 1 < argc) {
+            options.fps = std::atof(argv[++i]);
+        }
+        else if (std::strcmp(argv[i], "--help") == 0 || std::strcmp(argv[i], "-h") == 0) {
+            std::cout << "Usage: " << argv[0] << " [--scene <path.glb>] [--output <path.mp4>] [--frames <n>] [--fps <fps>]\n";
+            std::exit(0);
+        }
+        else {
+            std::cerr << "Unknown argument: " << argv[i] << std::endl;
+            std::exit(1);
+        }
+    }
+    return options;
+}
+
+template <typename SPEC>
+void setup_renderer(DEVICE& device, Renderer<SPEC>& renderer, const rlt::rendering::Bundle<T>& bundle) {
+    rlt::malloc(device, renderer);
+    rlt::init(device, renderer, bundle);
+
+    const T up[3] = {0, 0, 1};
+    camera_orbit::write(device, renderer, bundle.metadata.center, (bundle.metadata.max_ray_length / 2), up, FOV);
+}
+
+rlt::rendering::raytracing::Camera<T> make_orbit_camera(const rlt::rendering::SceneMetadata<T>& metadata, T angle) {
+    const T center[3] = {
+        metadata.center[0],
+        metadata.center[1],
+        metadata.center[2]
+    };
+    const T camera_radius = (metadata.max_ray_length / 2);
+    const T radius = camera_radius > T{0} ? camera_radius * T{0.65} : T{3};
+    const T position[3] = {
+        center[0] + radius * std::cos(angle),
+        center[1] + radius * std::sin(angle),
+        center[2] + metadata.half_extent[2] * T{0.25} + radius * T{0.15}
+    };
+    const T look_at[3] = {
+        center[0],
+        center[1],
+        center[2] + metadata.half_extent[2] * T{0.10}
+    };
+    const T up[3] = {0, 0, 1};
+    const T aspect = static_cast<T>(CAM_WIDTH) / static_cast<T>(CAM_HEIGHT);
+    return rlt::make_camera_data(position, look_at, up, FOV, aspect);
+}
+
+template <typename SPEC>
+void render_panel(DEVICE& device, Renderer<SPEC>& renderer, const rlt::rendering::raytracing::Camera<T>& camera_open, const rlt::rendering::raytracing::Camera<T>& camera_close, std::vector<uint32_t>& panel) {
+    auto camera_close_staging = camera_close;
+    rlt::Tensor<typename decltype(renderer.cameras)::SPEC> camera_alias;
+    camera_alias._data = &camera_close_staging;
+    rlt::copy(device, renderer.device, camera_alias, rlt::cameras(device, renderer));
+    if constexpr (SPEC::ENABLE_MOTION_BLUR) {
+        auto camera_open_staging = camera_open;
+        camera_alias._data = &camera_open_staging;
+        rlt::copy(device, renderer.device, camera_alias, rlt::cameras_open(device, renderer));
+    }
+
+    rlt::render(device, renderer);
+
+    panel.resize(static_cast<size_t>(CAM_WIDTH) * static_cast<size_t>(CAM_HEIGHT));
+    rlt::Tensor<typename decltype(renderer.frame_buffer)::SPEC> frame_alias;
+    frame_alias._data = panel.data();
+    rlt::copy(renderer.device, device, rlt::frame_buffer(device, renderer), frame_alias);
+}
+
+void copy_panel(const std::vector<uint32_t>& panel, std::vector<uint32_t>& frame, TI panel_i) {
+    constexpr TI OUT_WIDTH = CAM_WIDTH * NUM_PANELS;
+    for (TI y = 0; y < CAM_HEIGHT; y++) {
+        const uint32_t* src = panel.data() + static_cast<size_t>(y) * CAM_WIDTH;
+        uint32_t* dst = frame.data() + static_cast<size_t>(y) * OUT_WIDTH + static_cast<size_t>(panel_i) * CAM_WIDTH;
+        std::memcpy(dst, src, static_cast<size_t>(CAM_WIDTH) * sizeof(uint32_t));
+    }
+}
+
+int main(int argc, char** argv) {
+    const Options options = parse_options(argc, argv);
+
+    DEVICE device;
+    rlt::init(device);
+
+    Renderer<RendererSpec<1>> renderer_1;
+    Renderer<RendererSpec<2>> renderer_2;
+    Renderer<RendererSpec<4>> renderer_4;
+    Renderer<RendererSpec<8>> renderer_8;
+    Renderer<RendererSpec<16>> renderer_16;
+    Renderer<RendererSpec<32>> renderer_32;
+
+    rlt::rendering::Bundle<T> bundle;
+    if (!rlt::load<rlt::rendering::raytracing::Medium, true>(device, bundle, options.scene_path)) {
+        std::cerr << "Failed to load scene: " << options.scene_path << std::endl;
+        return 1;
+    }
+    setup_renderer(device, renderer_1, bundle);
+    setup_renderer(device, renderer_2, bundle);
+    setup_renderer(device, renderer_4, bundle);
+    setup_renderer(device, renderer_8, bundle);
+    setup_renderer(device, renderer_16, bundle);
+    setup_renderer(device, renderer_32, bundle);
+
+    constexpr TI OUT_WIDTH = CAM_WIDTH * NUM_PANELS;
+    constexpr TI OUT_HEIGHT = CAM_HEIGHT;
+
+    std::ostringstream ffmpeg_cmd;
+    ffmpeg_cmd
+        << "ffmpeg -y -f rawvideo -pixel_format rgba "
+        << "-video_size " << OUT_WIDTH << "x" << OUT_HEIGHT << " "
+        << "-framerate " << options.fps << " -i - "
+        << "-an -c:v libx264 -pix_fmt yuv420p "
+        << options.output_path;
+
+    FILE* mp4_pipe = popen(ffmpeg_cmd.str().c_str(), "w");
+    if (mp4_pipe == nullptr) {
+        std::cerr << "Failed to start ffmpeg." << std::endl;
+        return 1;
+    }
+
+    std::cout << "Writing " << options.output_path << std::endl;
+    std::cout << "Panels left-to-right: 1, 2, 4, 8, 16, 32 samples" << std::endl;
+
+    std::vector<uint32_t> panel;
+    std::vector<uint32_t> frame(static_cast<size_t>(OUT_WIDTH) * static_cast<size_t>(OUT_HEIGHT));
+
+    const T angle_per_frame = T{0.030};
+    const T shutter_angle = T{0.220};
+
+    for (int frame_i = 0; frame_i < options.frames; frame_i++) {
+        const T close_angle = static_cast<T>(frame_i) * angle_per_frame;
+        const auto camera_open = make_orbit_camera(bundle.metadata, close_angle - shutter_angle);
+        const auto camera_close = make_orbit_camera(bundle.metadata, close_angle);
+
+        render_panel(device, renderer_1, camera_open, camera_close, panel);
+        copy_panel(panel, frame, 0);
+        render_panel(device, renderer_2, camera_open, camera_close, panel);
+        copy_panel(panel, frame, 1);
+        render_panel(device, renderer_4, camera_open, camera_close, panel);
+        copy_panel(panel, frame, 2);
+        render_panel(device, renderer_8, camera_open, camera_close, panel);
+        copy_panel(panel, frame, 3);
+        render_panel(device, renderer_16, camera_open, camera_close, panel);
+        copy_panel(panel, frame, 4);
+        render_panel(device, renderer_32, camera_open, camera_close, panel);
+        copy_panel(panel, frame, 5);
+
+        const size_t bytes = frame.size() * sizeof(uint32_t);
+        const size_t written = std::fwrite(frame.data(), 1, bytes, mp4_pipe);
+        if (written != bytes) {
+            std::cerr << "Failed writing frame " << frame_i << " to ffmpeg." << std::endl;
+            pclose(mp4_pipe);
+            return 1;
+        }
+    }
+
+    const int ffmpeg_status = pclose(mp4_pipe);
+    if (ffmpeg_status != 0) {
+        std::cerr << "ffmpeg exited with status " << ffmpeg_status << std::endl;
+        return 1;
+    }
+
+    rlt::free(device, renderer_32);
+    rlt::free(device, renderer_16);
+    rlt::free(device, renderer_8);
+    rlt::free(device, renderer_4);
+    rlt::free(device, renderer_2);
+    rlt::free(device, renderer_1);
+
+    std::cout << "video written: " << options.output_path << std::endl;
+    return 0;
+}