hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/environment/operations_cpu.h

@@ -0,0 +1,270 @@
+#pragma once
+
+#include <rl_tools/operations/cpu_mux.h>
+#include "environment.h"
+
+#include <rl_tools/rendering/raytracing/operations_cpu_mux.h>
+#include <rl_tools/rendering/raytracing/scene/procthor/scene.h>
+#include <rl_tools/rendering/raytracing/scene/procthor/operations_cpu.h>
+
+#include <cmath>
+#include <string>
+
+namespace rl_tools {
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void precompute_indoor_initial_states(DEVICE& device, rl::environments::raytracing_example::Environment<SPEC>& env) {
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        using SCENE_SPEC = rendering::raytracing::scene::SceneSpecification<T, TI>;
+        rendering::raytracing::scene::procthor::Scene<SCENE_SPEC> scene;
+        T fov = SPEC::RAYTRACING_SPEC::COS_FOVY;
+        T aspect = static_cast<T>(SPEC::CAM_WIDTH) / static_cast<T>(SPEC::CAM_HEIGHT);
+        rendering::raytracing::scene::procthor::precompute_indoor_positions(device, scene, *env.renderer, fov, aspect);
+        TI take_n = std::min(scene.num_indoor_positions, rl::environments::raytracing_example::Environment<SPEC>::NUM_INITIAL_STATES);
+        for(TI i = 0; i < take_n; i++){
+            auto& s = env.indoor_initial_states[i];
+            s.position[0] = scene.indoor_positions[i].position[0];
+            s.position[1] = scene.indoor_positions[i].position[1];
+            s.position[2] = scene.indoor_positions[i].position[2];
+            s.velocity[0] = static_cast<T>(0);
+            s.velocity[1] = static_cast<T>(0);
+            s.velocity[2] = static_cast<T>(0);
+            s.yaw = scene.indoor_positions[i].yaw;
+        }
+        env.num_indoor_initial_states = take_n;
+    }
+
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, rl::environments::raytracing_example::Environment<SPEC>& env) {
+        if (env.renderer == nullptr) {
+            env.renderer = new typename rl::environments::raytracing_example::Environment<SPEC>::Renderer{};
+            env.owns_renderer = true;
+            malloc(device, *env.renderer);
+        }
+        if (env.scene == nullptr) {
+            env.scene = new rendering::raytracing::Scene{};
+            env.owns_scene = true;
+        }
+    }
+
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, rl::environments::raytracing_example::Environment<SPEC>& env) {
+        if (env.renderer != nullptr) {
+            free(device, *env.renderer);
+            if (env.owns_renderer) {
+                delete env.renderer;
+            }
+            env.renderer = nullptr;
+            env.owns_renderer = false;
+        }
+        if (env.scene != nullptr) {
+            if (env.owns_scene) {
+                delete env.scene;
+            }
+            env.scene = nullptr;
+            env.owns_scene = false;
+        }
+    }
+
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void init(DEVICE& device, rl::environments::raytracing_example::Environment<SPEC>& env) {
+        utils::assert_exit(device, env.scene_path != nullptr, "raytracing_example::init: scene_path is null");
+        bool loaded;
+        if constexpr (SPEC::RAYTRACING_SPEC::HAS_SEGMENTATION) {
+            rendering::raytracing::ObjectAssembly assembly;
+            loaded = load<typename SPEC::RAYTRACING_SPEC::SHADING, SPEC::RAYTRACING_SPEC::HAS_RGB>(device, assembly, std::string(env.scene_path));
+            if(loaded){
+                add(device, *env.scene, assembly);
+            }
+        }
+        else {
+            loaded = load<typename SPEC::RAYTRACING_SPEC::SHADING, SPEC::RAYTRACING_SPEC::HAS_RGB>(device, *env.scene, std::string(env.scene_path));
+        }
+        utils::assert_exit(device, loaded, "raytracing_example::init: failed to load scene");
+
+        init(device, *env.renderer, *env.scene);
+        {
+            using T = typename SPEC::T;
+            const T up[3] = {0, 0, 1};
+            generate_cameras(device, *env.renderer, env.renderer->scene_center, env.renderer->camera_radius, up, SPEC::RAYTRACING_SPEC::COS_FOVY);
+        }
+        generate_probe_directions(device, *env.renderer);
+        precompute_indoor_initial_states(device, env);
+    }
+
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void initial_parameters(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, rl::environments::raytracing_example::Parameters<SPEC>& parameters) {
+        parameters.scene_translation[0] = 0;
+        parameters.scene_translation[1] = 0;
+        parameters.scene_translation[2] = 0;
+        parameters.base_height = 0;
+    }
+
+    template <typename DEVICE, typename SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void sample_initial_parameters(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, rl::environments::raytracing_example::Parameters<SPEC>& parameters, RNG& rng) {
+        initial_parameters(device, env, parameters);
+    }
+
+    template <typename DEVICE, typename SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void sample_initial_state(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, rl::environments::raytracing_example::Parameters<SPEC>& parameters, rl::environments::raytracing_example::State<SPEC>& state, RNG& rng) {
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+
+        utils::assert_exit(device, env.num_indoor_initial_states > 0, "raytracing_example::sample_initial_state: no indoor initial states available");
+        const TI index = random::uniform_int_distribution(device.random, static_cast<TI>(0), static_cast<TI>(env.num_indoor_initial_states - 1), rng);
+        state = env.indoor_initial_states[index];
+        state.position[2] = parameters.base_height;
+        state.velocity[0] = static_cast<T>(0);
+        state.velocity[1] = static_cast<T>(0);
+        state.velocity[2] = static_cast<T>(0);
+    }
+
+    template <typename DEVICE, typename SPEC, typename ACTION_SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT typename SPEC::T step(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, rl::environments::raytracing_example::Parameters<SPEC>& parameters, const rl::environments::raytracing_example::State<SPEC>& state, const Matrix<ACTION_SPEC>& action, rl::environments::raytracing_example::State<SPEC>& next_state, RNG& rng) {
+        using T = typename SPEC::T;
+        static_assert(ACTION_SPEC::ROWS == 1);
+        static_assert(ACTION_SPEC::COLS == 3);
+
+        T desired_vx = get(action, 0, 0) * env.max_velocity;
+        T desired_vy = get(action, 0, 1) * env.max_velocity;
+        T yaw_rate = get(action, 0, 2);
+
+        T alpha = env.acceleration * env.dt;
+        if (alpha > static_cast<T>(1)) {
+            alpha = static_cast<T>(1);
+        }
+
+        next_state.velocity[0] = state.velocity[0] + alpha * (desired_vx - state.velocity[0]);
+        next_state.velocity[1] = state.velocity[1] + alpha * (desired_vy - state.velocity[1]);
+        next_state.velocity[2] = 0;
+
+        next_state.position[0] = state.position[0] + next_state.velocity[0] * env.dt;
+        next_state.position[1] = state.position[1] + next_state.velocity[1] * env.dt;
+        next_state.position[2] = parameters.base_height;
+        next_state.yaw = state.yaw + yaw_rate * env.dt;
+
+        return env.dt;
+    }
+
+    template <typename DEVICE, typename SPEC, typename ACTION_SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT typename SPEC::T reward(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, rl::environments::raytracing_example::Parameters<SPEC>& parameters, const rl::environments::raytracing_example::State<SPEC>& state, const Matrix<ACTION_SPEC>& action, const rl::environments::raytracing_example::State<SPEC>& next_state, RNG& rng) {
+        using T = typename SPEC::T;
+        const T v = std::sqrt(next_state.velocity[0] * next_state.velocity[0] + next_state.velocity[1] * next_state.velocity[1]);
+        const T control = std::abs(get(action, 0, 0)) + std::abs(get(action, 0, 1)) + static_cast<T>(0.1) * std::abs(get(action, 0, 2));
+        return v - static_cast<T>(0.05) * control;
+    }
+
+    template <typename DEVICE, typename SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT bool terminated(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, rl::environments::raytracing_example::Parameters<SPEC>& parameters, const rl::environments::raytracing_example::State<SPEC>& state, RNG& rng) {
+        return false;
+    }
+
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void observe(DEVICE& device, rl::environments::raytracing_example::Environment<SPEC>& env, const rl::environments::raytracing_example::Parameters<SPEC>& parameters, const rl::environments::raytracing_example::State<SPEC>& state, const rl::environments::raytracing_example::ObservationRGB<SPEC>&, Matrix<OBS_SPEC>& observation, RNG& rng) {
+        static_assert(OBS_SPEC::ROWS == 1);
+        static_assert(OBS_SPEC::COLS == rl::environments::raytracing_example::ObservationRGB<SPEC>::DIM);
+
+        using T = typename SPEC::T;
+        const T position[3] = {
+            parameters.scene_translation[0] + state.position[0],
+            parameters.scene_translation[1] + state.position[1],
+            parameters.scene_translation[2] + state.position[2] + env.eye_height
+        };
+        const T look_at[3] = {
+            position[0] + env.look_ahead * std::cos(state.yaw),
+            position[1] + env.look_ahead * std::sin(state.yaw),
+            position[2]
+        };
+        const T up[3] = {0, 0, 1};
+        const auto camera = make_camera_data(position, look_at, up,
+            SPEC::RAYTRACING_SPEC::COS_FOVY,
+            static_cast<T>(SPEC::CAM_WIDTH) / static_cast<T>(SPEC::CAM_HEIGHT));
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+        cudaMemcpy(data(cameras(device, *env.renderer)), &camera, sizeof(camera), cudaMemcpyHostToDevice);
+#else
+        std::memcpy(data(cameras(device, *env.renderer)), &camera, sizeof(camera));
+#endif
+        render(device, *env.renderer);
+
+        std::vector<uint32_t> frame_staging((size_t)SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT);
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+        cudaMemcpy(frame_staging.data(), data(frame_buffer(device, *env.renderer)), frame_staging.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost);
+#else
+        std::memcpy(frame_staging.data(), data(frame_buffer(device, *env.renderer)), frame_staging.size() * sizeof(uint32_t));
+#endif
+        for (typename SPEC::TI i = 0; i < static_cast<typename SPEC::TI>(SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT); i++) {
+            set(observation, 0, i, static_cast<typename OBS_SPEC::T>(frame_staging[i]));
+        }
+    }
+
+    template <typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT rendering::raytracing::Camera<typename SPEC::T> make_camera_for_state(const rl::environments::raytracing_example::Environment<SPEC>& env, const rl::environments::raytracing_example::Parameters<SPEC>& parameters, const rl::environments::raytracing_example::State<SPEC>& state) {
+        using T = typename SPEC::T;
+        const T cy = std::cos(state.yaw);
+        const T sy = std::sin(state.yaw);
+
+        const T position[3] = {
+            parameters.scene_translation[0] + state.position[0],
+            parameters.scene_translation[1] + state.position[1],
+            parameters.scene_translation[2] + state.position[2] + env.eye_height
+        };
+
+        const T look_at[3] = {
+            position[0] + env.look_ahead * cy,
+            position[1] + env.look_ahead * sy,
+            position[2]
+        };
+
+        const T up[3] = {0, 0, 1};
+        const T aspect = static_cast<T>(SPEC::CAM_WIDTH) / static_cast<T>(SPEC::CAM_HEIGHT);
+
+        return make_camera_data(position, look_at, up, SPEC::RAYTRACING_SPEC::COS_FOVY, aspect);
+    }
+
+    template <typename DEVICE, typename SPEC, typename PARAMETERS_SPEC, typename STATE_SPEC, typename ACTIONS_SPEC, typename NEXT_STATE_SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void step_batch(DEVICE& device, const rl::environments::raytracing_example::Environment<SPEC>& env, Tensor<PARAMETERS_SPEC>& parameters, const Tensor<STATE_SPEC>& states, const Matrix<ACTIONS_SPEC>& actions, Tensor<NEXT_STATE_SPEC>& next_states, RNG& rng, typename SPEC::TI num_envs) {
+        static_assert(utils::typing::is_same_v<typename PARAMETERS_SPEC::T, rl::environments::raytracing_example::Parameters<SPEC>>);
+        static_assert(utils::typing::is_same_v<typename STATE_SPEC::T, rl::environments::raytracing_example::State<SPEC>>);
+        static_assert(utils::typing::is_same_v<typename NEXT_STATE_SPEC::T, rl::environments::raytracing_example::State<SPEC>>);
+        static_assert(ACTIONS_SPEC::ROWS == SPEC::NUM_ENVS);
+        static_assert(ACTIONS_SPEC::COLS == 3);
+
+        for (typename SPEC::TI env_i = 0; env_i < num_envs; env_i++) {
+            auto& parameters_env = get_ref(device, parameters, env_i);
+            auto& state_env = get_ref(device, states, env_i);
+            auto action_env = row(device, actions, env_i);
+            auto& next_state_env = get_ref(device, next_states, env_i);
+            step(device, env, parameters_env, state_env, action_env, next_state_env, rng);
+        }
+    }
+
+    template <typename DEVICE, typename SPEC, typename PARAMETERS_SPEC, typename STATE_SPEC, typename OUT_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void observe_batch(DEVICE& device, rl::environments::raytracing_example::Environment<SPEC>& env, const Tensor<PARAMETERS_SPEC>& parameters, const Tensor<STATE_SPEC>& states, typename SPEC::TI num_envs, Tensor<OUT_SPEC>& out_pixels) {
+        static_assert(utils::typing::is_same_v<typename PARAMETERS_SPEC::T, rl::environments::raytracing_example::Parameters<SPEC>>);
+        static_assert(utils::typing::is_same_v<typename STATE_SPEC::T, rl::environments::raytracing_example::State<SPEC>>);
+        static_assert(utils::typing::is_same_v<typename OUT_SPEC::T, uint32_t>);
+        static_assert(get<0>(typename OUT_SPEC::SHAPE{}) == SPEC::NUM_ENVS);
+        static_assert(get<1>(typename OUT_SPEC::SHAPE{}) == SPEC::CAM_HEIGHT);
+        static_assert(get<2>(typename OUT_SPEC::SHAPE{}) == SPEC::CAM_WIDTH);
+
+        if (env.renderer == nullptr || num_envs != SPEC::NUM_ENVS) {
+            return;
+        }
+
+        std::vector<rendering::raytracing::Camera<typename SPEC::T>> camera_staging(SPEC::NUM_ENVS);
+        for (typename SPEC::TI env_i = 0; env_i < num_envs; env_i++) {
+            camera_staging[env_i] = make_camera_for_state(env, get_ref(device, parameters, env_i), get_ref(device, states, env_i));
+        }
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+        cudaMemcpy(data(cameras(device, *env.renderer)), camera_staging.data(), num_envs * sizeof(rendering::raytracing::Camera<typename SPEC::T>), cudaMemcpyHostToDevice);
+#else
+        std::memcpy(data(cameras(device, *env.renderer)), camera_staging.data(), num_envs * sizeof(rendering::raytracing::Camera<typename SPEC::T>));
+#endif
+        render(device, *env.renderer);
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+        cudaMemcpy(data(out_pixels), data(frame_buffer(device, *env.renderer)), (size_t)SPEC::NUM_ENVS * SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT * sizeof(uint32_t), cudaMemcpyDeviceToHost);
+#else
+        std::memcpy(data(out_pixels), data(frame_buffer(device, *env.renderer)), (size_t)SPEC::NUM_ENVS * SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT * sizeof(uint32_t));
+#endif
+    }
+}

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

@@ -0,0 +1,276 @@
+#define RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS 0
+
+#define RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB 0
+#define RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGBD 1
+#define RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH 2
+
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE
+#define RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB
+#endif
+
+#include <rl_tools/operations/cpu_mux.h>
+
+#include "environment/environment.h"
+#include "environment/operations_cpu.h"
+
+
+#include <iostream>
+#include <chrono>
+#include <type_traits>
+#include <cmath>
+#include <vector>
+#include <sstream>
+#include <cstdio>
+#include <cstring>
+#include <array>
+
+namespace rlt = rl_tools;
+
+static constexpr bool OUTPUT_RGB = RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH;
+static constexpr bool OUTPUT_DEPTH = RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB;
+
+int main(int argc, char** argv) {
+    bool output_video = false;
+    bool no_probe = false;
+    for (int i = 1; i < argc; i++) {
+        if (std::strcmp(argv[i], "--output-video") == 0) {
+            output_video = true;
+        }
+        else if (std::strcmp(argv[i], "--no-probe") == 0) {
+            no_probe = true;
+        }
+        else {
+            std::cerr << "Unknown argument: " << argv[i] << std::endl;
+            return 1;
+        }
+    }
+
+    using T = float;
+    using TI = typename rlt::devices::DEVICE_FACTORY<>::index_t;
+    static constexpr TI NUM_ENVS = 256;
+    constexpr T PI = static_cast<T>(3.14159265358979323846);
+    using SPEC = rlt::rl::environments::raytracing_example::Specification<T, TI, NUM_ENVS, 64, 64, 64, rlt::rendering::raytracing::Low, false, 1, false, 1, OUTPUT_RGB, OUTPUT_DEPTH>;
+
+    static_assert(std::is_standard_layout_v<rlt::rl::environments::raytracing_example::Parameters<SPEC>>);
+    static_assert(std::is_trivially_copyable_v<rlt::rl::environments::raytracing_example::Parameters<SPEC>>);
+    static_assert(std::is_standard_layout_v<rlt::rl::environments::raytracing_example::State<SPEC>>);
+    static_assert(std::is_trivially_copyable_v<rlt::rl::environments::raytracing_example::State<SPEC>>);
+
+    using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+    using RNG = typename DEVICE::SPEC::RANDOM::ENGINE<>;
+
+    DEVICE device;
+    rlt::init(device);
+    RNG rng;
+    rlt::init(device, rng, 0);
+
+    rlt::rl::environments::raytracing_example::Environment<SPEC> env;
+    env.scene_path = "tests/data/ProcTHOR-Train-1.glb";
+
+    using PARAMETERS_SPEC = rlt::tensor::Specification<rlt::rl::environments::raytracing_example::Parameters<SPEC>, TI, rlt::tensor::Shape<TI, NUM_ENVS>>;
+    using STATE_SPEC = rlt::tensor::Specification<rlt::rl::environments::raytracing_example::State<SPEC>, TI, rlt::tensor::Shape<TI, NUM_ENVS>>;
+    using PIXELS_SPEC = rlt::tensor::Specification<uint32_t, TI, rlt::tensor::Shape<TI, NUM_ENVS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH>>;
+
+    rlt::Tensor<PARAMETERS_SPEC> parameters;
+    rlt::Tensor<STATE_SPEC> states;
+    rlt::Tensor<PIXELS_SPEC> pixels;
+    std::vector<rlt::rl::environments::raytracing_example::State<SPEC>> base_states(NUM_ENVS);
+
+    rlt::malloc(device, parameters);
+    rlt::malloc(device, states);
+    rlt::malloc(device, pixels);
+
+    rlt::malloc(device, env);
+    rlt::init(device, env);
+
+    for (TI env_i = 0; env_i < NUM_ENVS; env_i++) {
+        rlt::rl::environments::raytracing_example::Parameters<SPEC> p;
+        rlt::sample_initial_parameters(device, env, p, rng);
+        rlt::rl::environments::raytracing_example::State<SPEC> s;
+        rlt::sample_initial_state(device, env, p, s, rng);
+        // const T angle = static_cast<T>(env_i) * static_cast<T>(0.01);
+        // s.position[0] = -0.937;
+        // s.position[1] = 1.690;
+        // s.position[2] = 8.410;
+        // s.velocity[0] = 0;
+        // s.velocity[1] = 0;
+        // s.velocity[2] = 0;
+        // s.yaw = angle + static_cast<T>(3.14159265358979323846) / static_cast<T>(2.0);
+        rlt::set(device, parameters, p, env_i);
+        rlt::set(device, states, s, env_i);
+        base_states[env_i] = s;
+    }
+
+
+    constexpr TI STEPS = 1024*4;
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+    if (output_video) {
+        std::cerr << "--output-video requires RGB or RGBD output mode." << std::endl;
+        return 1;
+    }
+#else
+    FILE* mp4_pipe = nullptr;
+    std::vector<uint32_t> per_camera_rgba;
+    std::vector<uint32_t> megaframe_rgba;
+    if (output_video) {
+        constexpr TI GRID_WIDTH = SPEC::RAYTRACING_SPEC::GRID_COLS * SPEC::CAM_WIDTH;
+        constexpr TI GRID_HEIGHT = SPEC::RAYTRACING_SPEC::GRID_ROWS * SPEC::CAM_HEIGHT;
+        per_camera_rgba.resize(static_cast<size_t>(NUM_ENVS) * static_cast<size_t>(SPEC::CAM_WIDTH) * static_cast<size_t>(SPEC::CAM_HEIGHT));
+        megaframe_rgba.resize(static_cast<size_t>(GRID_WIDTH) * static_cast<size_t>(GRID_HEIGHT));
+
+        const double frame_rate = env.dt > 0 ? (1.0 / static_cast<double>(env.dt)) : 30.0;
+        std::ostringstream ffmpeg_cmd;
+        ffmpeg_cmd
+            << "ffmpeg -y -f rawvideo -pixel_format rgba "
+            << "-video_size " << GRID_WIDTH << "x" << GRID_HEIGHT << " "
+            << "-framerate " << frame_rate << " -i - "
+            << "-an -c:v libx264 -pix_fmt yuv420p "
+            << "raytracing_example_megaframe.mp4";
+        mp4_pipe = popen(ffmpeg_cmd.str().c_str(), "w");
+        if (mp4_pipe == nullptr) {
+            std::cerr << "Failed to start ffmpeg." << std::endl;
+            return 1;
+        }
+    }
+#endif
+
+    // camera staging fills while the GPU renders; upload_cameras pushes it into the
+    // backend-native cameras tensor once the previous launch has synced
+    std::vector<rlt::rendering::raytracing::Camera<T>> camera_staging(NUM_ENVS);
+    auto compute_states_and_cameras = [&](TI step_i) {
+        for (TI env_i = 0; env_i < NUM_ENVS; env_i++) {
+            const T yaw_phase = static_cast<T>(0.02 * env_i + 0.08 * step_i);
+            auto s = base_states[env_i];
+            s.velocity[0] = 0;
+            s.velocity[1] = 0;
+            s.velocity[2] = 0;
+            s.yaw = static_cast<T>(0.5) * PI * (static_cast<T>(1) + std::sin(yaw_phase));
+            rlt::set(device, states, s, env_i);
+            camera_staging[env_i] = rlt::make_camera_for_state(env, rlt::get_ref(device, parameters, env_i), s);
+        }
+    };
+    auto upload_cameras = [&]() {
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+        cudaMemcpy(rlt::data(rlt::cameras(device, *env.renderer)), camera_staging.data(), NUM_ENVS * sizeof(rlt::rendering::raytracing::Camera<T>), cudaMemcpyHostToDevice);
+#else
+        std::memcpy(rlt::data(rlt::cameras(device, *env.renderer)), camera_staging.data(), NUM_ENVS * sizeof(rlt::rendering::raytracing::Camera<T>));
+#endif
+    };
+
+    auto do_video_output = [&](TI step_i) -> int {
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+        (void)step_i;
+        return 0;
+#else
+        if (mp4_pipe == nullptr) return 0;
+        constexpr size_t pixel_count = (size_t)NUM_ENVS * SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT;
+        static std::vector<uint32_t> frame_staging(pixel_count);
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+        cudaMemcpy(frame_staging.data(), rlt::data(rlt::frame_buffer(device, *env.renderer)), pixel_count * sizeof(uint32_t), cudaMemcpyDeviceToHost);
+#else
+        std::memcpy(frame_staging.data(), rlt::data(rlt::frame_buffer(device, *env.renderer)), pixel_count * sizeof(uint32_t));
+#endif
+        const uint32_t* per_camera_rgba_ptr = frame_staging.data();
+        for (TI camera_i = 0; camera_i < NUM_ENVS; camera_i++) {
+            const TI col = camera_i % SPEC::RAYTRACING_SPEC::GRID_COLS;
+            const TI row = camera_i / SPEC::RAYTRACING_SPEC::GRID_COLS;
+            const TI offset_x = col * SPEC::CAM_WIDTH;
+            const TI offset_y = row * SPEC::CAM_HEIGHT;
+            for (TI y = 0; y < SPEC::CAM_HEIGHT; y++) {
+                const uint32_t* src = per_camera_rgba_ptr + static_cast<size_t>(camera_i) * SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT + static_cast<size_t>(y) * SPEC::CAM_WIDTH;
+                uint32_t* dst = megaframe_rgba.data() + static_cast<size_t>(offset_y + y) * (SPEC::RAYTRACING_SPEC::GRID_COLS * SPEC::CAM_WIDTH) + offset_x;
+                std::memcpy(dst, src, static_cast<size_t>(SPEC::CAM_WIDTH) * sizeof(uint32_t));
+            }
+        }
+        const size_t bytes = megaframe_rgba.size() * sizeof(uint32_t);
+        const size_t written = fwrite(megaframe_rgba.data(), 1, bytes, mp4_pipe);
+        if (written != bytes) {
+            std::cerr << "Failed writing frame " << step_i << " to ffmpeg." << std::endl;
+            pclose(mp4_pipe);
+            mp4_pipe = nullptr;
+            return 1;
+        }
+        return 0;
+#endif
+    };
+
+    rlt::synchronize(device, *env.renderer);
+    auto t0 = std::chrono::steady_clock::now();
+
+    // Pipelined loop: overlap CPU camera computation with GPU rendering
+    compute_states_and_cameras(0);
+    upload_cameras();
+
+    for (TI step_i = 0; step_i < STEPS; step_i++) {
+        if (no_probe) {
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+            rlt::render_launch(device, *env.renderer);
+#elif RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGBD
+            rlt::render_launch(device, *env.renderer);
+#else
+            rlt::render_launch(device, *env.renderer);
+#endif
+        }
+        else {
+            rlt::render_launch(device, *env.renderer);
+        }
+
+        // Overlap: compute next frame's cameras while GPU renders current frame
+        if (step_i + 1 < STEPS) {
+            compute_states_and_cameras(step_i + 1);
+        }
+
+        if (no_probe) {
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+            rlt::render_sync(device, *env.renderer);
+#elif RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGBD
+            rlt::render_sync(device, *env.renderer);
+#else
+            rlt::render_sync(device, *env.renderer);
+#endif
+        }
+        else {
+            rlt::render_sync(device, *env.renderer);
+        }
+
+        if (int err = do_video_output(step_i)) return err;
+
+        // Upload next frame's cameras (GPU is idle now, buffer is safe to overwrite)
+        if (step_i + 1 < STEPS) {
+            upload_cameras();
+        }
+    }
+    rlt::synchronize(device, *env.renderer);
+    auto t1 = std::chrono::steady_clock::now();
+    const double elapsed = std::chrono::duration<double>(t1 - t0).count();
+
+    const double fps = (static_cast<double>(NUM_ENVS) * STEPS) / elapsed;
+    std::cout << "raytracing_example: " << NUM_ENVS << " envs, " << STEPS << " batched observe steps" << std::endl;
+    std::cout << "elapsed: " << elapsed << " s, effective frame throughput: " << fps << " frames/s" << std::endl;
+
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+    if (mp4_pipe != nullptr) {
+        const int ffmpeg_status = pclose(mp4_pipe);
+        mp4_pipe = nullptr;
+        if (ffmpeg_status != 0) {
+            std::cerr << "ffmpeg exited with status " << ffmpeg_status << std::endl;
+            return 1;
+        }
+        std::cout << "video written: raytracing_example_megaframe.mp4" << std::endl;
+    }
+#endif
+
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+    rlt::save_image(device, *env.renderer, "raytracing_example_grid.png");
+#endif
+#if RL_TOOLS_RENDERING_RAYTRACING_EXAMPLE_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB
+    rlt::save_depth_image(device, *env.renderer, "raytracing_example_depth.png");
+    rlt::save_depth(device, *env.renderer, "raytracing_example_depth.bin");
+#endif
+
+    rlt::free(device, env);
+    rlt::free(device, pixels);
+    rlt::free(device, states);
+    rlt::free(device, parameters);
+    return 0;
+}