hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/benchmark/CMakeLists.txt

@@ -0,0 +1,110 @@
+add_executable(rendering_raytracing_benchmark benchmark.cpp)
+target_link_libraries(rendering_raytracing_benchmark
+    PRIVATE
+        RLtools::RLtools
+        rendering_raytracing_backend
+        rendering_raytracing_stb
+)
+
+add_executable(rendering_raytracing_benchmark_64 EXCLUDE_FROM_ALL benchmark.cpp)
+target_link_libraries(rendering_raytracing_benchmark_64
+    PRIVATE
+        RLtools::RLtools
+        rendering_raytracing_backend
+        rendering_raytracing_stb
+)
+target_compile_definitions(rendering_raytracing_benchmark_64 PRIVATE
+    RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_WIDTH=64
+    RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_HEIGHT=64
+)
+
+function(add_rendering_raytracing_benchmark_dynamic SUFFIX)
+    cmake_parse_arguments(ARG "" "SHADING;OUTPUT_MODE;AA;MB;CONSUME;TILE;NUM_CAMERAS" "" ${ARGN})
+    set(TARGET_NAME rendering_raytracing_benchmark_dynamic_${SUFFIX})
+    add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL benchmark_dynamic.cpp)
+    if(ARG_OUTPUT_MODE AND ARG_OUTPUT_MODE EQUAL 1)
+        set(BACKEND_TARGET rendering_raytracing_backend_depth)
+    else()
+        set(BACKEND_TARGET rendering_raytracing_backend)
+    endif()
+    target_link_libraries(${TARGET_NAME} PRIVATE RLtools::RLtools ${BACKEND_TARGET} rendering_raytracing_stb)
+    foreach(OPTION SHADING OUTPUT_MODE AA MB CONSUME TILE NUM_CAMERAS)
+        if(DEFINED ARG_${OPTION})
+            if(OPTION STREQUAL "AA")
+                set(DEFINE_NAME AA_GRID)
+            elseif(OPTION STREQUAL "MB")
+                set(DEFINE_NAME MB_SAMPLES)
+            else()
+                set(DEFINE_NAME ${OPTION})
+            endif()
+            target_compile_definitions(${TARGET_NAME} PRIVATE RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_DYNAMIC_${DEFINE_NAME}=${ARG_${OPTION}})
+        endif()
+    endforeach()
+endfunction()
+
+add_rendering_raytracing_benchmark_dynamic(low SHADING 0)
+add_rendering_raytracing_benchmark_dynamic(medium SHADING 1)
+add_rendering_raytracing_benchmark_dynamic(high SHADING 2)
+add_rendering_raytracing_benchmark_dynamic(veryhigh SHADING 3)
+add_rendering_raytracing_benchmark_dynamic(high_aa2 SHADING 2 AA 2)
+add_rendering_raytracing_benchmark_dynamic(high_mb4 SHADING 2 MB 4)
+add_rendering_raytracing_benchmark_dynamic(high_rgbd SHADING 2 OUTPUT_MODE 1)
+add_rendering_raytracing_benchmark_dynamic(high_consume SHADING 2 CONSUME 1)
+add_rendering_raytracing_benchmark_dynamic(high_tile2 SHADING 2 TILE 2)
+add_rendering_raytracing_benchmark_dynamic(high_n256 SHADING 2 NUM_CAMERAS 256)
+
+add_executable(rendering_raytracing_benchmark_depth EXCLUDE_FROM_ALL benchmark.cpp)
+target_link_libraries(rendering_raytracing_benchmark_depth
+    PRIVATE
+        RLtools::RLtools
+        rendering_raytracing_backend_depth
+        rendering_raytracing_stb
+)
+target_compile_definitions(rendering_raytracing_benchmark_depth PRIVATE RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE=2)
+
+add_executable(rendering_raytracing_benchmark_rgbd EXCLUDE_FROM_ALL benchmark.cpp)
+target_link_libraries(rendering_raytracing_benchmark_rgbd
+    PRIVATE
+        RLtools::RLtools
+        rendering_raytracing_backend_depth
+        rendering_raytracing_stb
+)
+target_compile_definitions(rendering_raytracing_benchmark_rgbd PRIVATE RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE=1)
+
+if(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED MATCHES "^(OPTIX|METAL|VULKAN)$")
+    set(RL_TOOLS_RENDERING_RAYTRACING_SIM_BENCHMARK_NUM_ENVS "4096" CACHE STRING "Compile-time camera count for the render benchmark")
+    if(NOT RL_TOOLS_RENDERING_RAYTRACING_SIM_BENCHMARK_NUM_ENVS MATCHES "^[1-9][0-9]*$")
+        message(FATAL_ERROR "RL_TOOLS_RENDERING_RAYTRACING_SIM_BENCHMARK_NUM_ENVS must be a positive integer")
+    endif()
+
+    function(add_rendering_raytracing_sim_target target_name shading mode)
+        set(SIM_SHADING ${shading})
+        set(SIM_MODE ${mode})
+        if(mode STREQUAL "frame")
+            set(SIM_NUM_CAMERAS 1)
+            set(SIM_RESOLUTION 1000)
+        else()
+            set(SIM_NUM_CAMERAS ${RL_TOOLS_RENDERING_RAYTRACING_SIM_BENCHMARK_NUM_ENVS})
+            set(SIM_RESOLUTION 64)
+        endif()
+        set(CONFIG_DIR "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_config")
+        configure_file(simulator_matrix_config.h.in "${CONFIG_DIR}/simulator_matrix_config.h" @ONLY)
+        add_executable(${target_name} EXCLUDE_FROM_ALL simulator_matrix.cpp)
+        target_include_directories(${target_name} PRIVATE "${CONFIG_DIR}")
+        target_link_libraries(${target_name} PRIVATE RLtools::RLtools
+            rendering_raytracing_backend rendering_raytracing_backend_depth rendering_raytracing_stb)
+    endfunction()
+
+    foreach(PROFILE Medium High Low VeryHigh)
+        string(TOLOWER "${PROFILE}" SUFFIX)
+        if(PROFILE STREQUAL "VeryHigh")
+            set(SUFFIX very_high)
+        endif()
+        add_rendering_raytracing_sim_target(rendering_raytracing_sim_benchmark_${SUFFIX} ${PROFILE} benchmark)
+        add_rendering_raytracing_sim_target(rendering_raytracing_procthor_frame_${SUFFIX} ${PROFILE} frame)
+    endforeach()
+    add_rendering_raytracing_sim_target(rendering_raytracing_sim_benchmark_sweep Medium sweep)
+endif()
+
+add_executable(rendering_raytracing_rig_benchmark EXCLUDE_FROM_ALL rig.cpp)
+target_link_libraries(rendering_raytracing_rig_benchmark PRIVATE RLtools::RLtools rendering_raytracing_backend rendering_raytracing_stb)

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/benchmark/README.md

@@ -0,0 +1,55 @@
+# Raytracing benchmarks
+
+The simulator benchmark supports OptiX, Metal, and Vulkan through the configured renderer backend. Its default workload matches `python -m hyperdrone.examples.benchmark`: ProcTHOR-Train-1, 4096 static cameras at 64×64, medium RGB, 80° FOV, no probes/AA/motion blur, seed 0, 2 seconds of warmup, and 10 seconds of measurement with synchronization every 10 launches. Python and C++ sample the same orientation distribution using different RNGs.
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --target rendering_raytracing_sim_benchmark_medium -j5
+./build/src/rendering/raytracing/benchmark/rendering_raytracing_sim_benchmark_medium
+```
+
+`AUTO` selects the available backend. Use `-DRL_TOOLS_RENDERING_RAYTRACING_BACKEND=METAL`, `VULKAN`, or `OPTIX` to require one explicitly. OptiX requires CUDA; Vulkan requires headers and `glslangValidator`, plus a device with ray-query support at runtime. Vulkan can run on lavapipe for correctness testing. Neither Metal nor Vulkan requires CUDA.
+
+The default scene resolves `conta:75d1d67a17ecd16bc3a214baa895240da8060df7`, the same content hash as the Python example; `--procthor-path` accepts a file or a conta reference. The procedural `--scene 20_objects` case needs no downloaded scene.
+
+## Targets and cases
+
+Canonical targets are `rendering_raytracing_sim_benchmark_{medium,high,very_high,low}`, `rendering_raytracing_sim_benchmark_sweep`, and `rendering_raytracing_procthor_frame_{medium,high,very_high,low}`. They are built explicitly. RGB and depth share each executable; select `--output rgb|depth|all`.
+
+The render matrix is two scenes × two outputs:
+
+```bash
+./build/src/rendering/raytracing/benchmark/rendering_raytracing_sim_benchmark_medium \
+  --scene all --output all --output-dir /tmp/rltools-render-matrix
+```
+
+Set the compile-time camera count with `-DRL_TOOLS_RENDERING_RAYTRACING_SIM_BENCHMARK_NUM_ENVS=16` for small correctness runs. The normal resolution is 64×64; frame tools use one camera at 1000×1000. Target configuration is generated from `simulator_matrix_config.h.in` by CMake.
+
+The sweep covers resolutions 64–2048, medium/high/low RGB and depth, with AA off and 2×2 AA. Camera count scales to preserve the normal target's pixel count, with a minimum of one camera. `--scene all --output all` produces 96 records. Configuration indices follow the selected outputs, with scenes sharing each configuration index.
+
+```bash
+./build/src/rendering/raytracing/benchmark/rendering_raytracing_sim_benchmark_sweep \
+  --scene all --output all --output-dir /tmp/rltools-render-sweep
+```
+
+For a slice, use `--sweep-config-start` and `--sweep-config-count`; `--cooldown-seconds` defaults to 10 between configurations.
+
+Frame tools accept a position and either a forward vector, look-at point, or quaternion, as shown by `--help`. With no pose arguments, they look from `[-3.92, -5.67, 1.0]` toward the scene center. `--output-png` requires a single output; otherwise artifact names are generated.
+
+## Measurement and results
+
+Warmup completes before timing. Even `--warmup-seconds 0` primes the renderer once. `--iterations N` selects a fixed count instead of duration; the final batch is drained even when it is shorter than `--sync-interval`. Scene loading, image saving, and reporting are outside the measured interval. Vulkan currently waits for the previous submission in each `render_launch`; equal sync intervals do not imply equal queue depth across backends.
+
+Normal, sweep, and frame tools emit one `render-v1` JSON object per result on its own line. Numbers and booleans retain their JSON types; camera vectors are arrays, with unavailable forward/up vectors represented by `null`. Records identify the workload, backend, selected device, scene source, scene content identity, camera configuration, sampling, timing, and verification PNG. Ray throughput counts primary samples; shading may trace additional rays. Frame measurements have workload `frame`; benchmark measurements have workload `render_only`. Extract JSON Lines with `rg '^\{' output.log`. Throughput and elapsed time are also logged to metra when `METRA_URL` is set. Backend, device, workload, scene reference, profile, resolution, camera count, orientation, seed, and sync interval distinguish metric series.
+
+This replaces the old CUDA-specific CSV/JSON layouts. The unused-camera `render_physics` workload and its CUDA bridge, redundant target aliases, separate RGB/depth targets, `--step-mode`, `--gpu-label`, `--warmup-iterations`, and runtime `--num-envs`/`--resolution` options have been removed. Physics benchmarking requires its own execution contract.
+
+## Validation
+
+After building the medium benchmark, sweep, and medium frame targets:
+
+```bash
+.venv/bin/python tests/src/rendering/raytracing/benchmark.py --build-dir build --backend metal --with-procthor
+```
+
+Select the matching backend and omit `--with-procthor` for procedural-only checks. Each subprocess has a 20-second timeout. Vulkan CI uses 16 cameras on lavapipe; production defaults remain 4096.

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

@@ -0,0 +1,180 @@
+#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_BENCHMARK_OUTPUT_MODE
+#define RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB
+#endif
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_WIDTH
+#define RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_WIDTH 128
+#endif
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_HEIGHT
+#define RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_HEIGHT 128
+#endif
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_NUM_CAMERAS
+#define RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_NUM_CAMERAS 4096
+#endif
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_NUM_PROBES
+#define RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_NUM_PROBES 64
+#endif
+
+#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 <rl_tools/rendering/raytracing/save_cpu.h>
+
+#include <string>
+#include <iostream>
+#include <chrono>
+
+namespace rlt = rl_tools;
+
+using T = float;
+static constexpr T FOV = 80;
+using TI = int;
+struct CONFIG: rlt::rendering::raytracing::config::Default<T, TI>{
+    static constexpr TI CAM_WIDTH = RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_WIDTH;
+    static constexpr TI CAM_HEIGHT = RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_HEIGHT;
+    static constexpr TI NUM_CAMERAS = RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_NUM_CAMERAS;
+    static constexpr TI NUM_PROBES = RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_NUM_PROBES;
+    static constexpr bool OUTPUT_RGB = RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH;
+    static constexpr bool OUTPUT_DEPTH = RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB;
+};
+using SPEC = rlt::rendering::raytracing::Specification<CONFIG>;
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+static constexpr double BENCHMARK_SECONDS = 10.0;
+
+int main(int ac, char** av){
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("rl_tools::rendering::raytracing benchmark '" << av[0] << "' starting up");
+
+    // Parse command line
+    std::string model_file;
+    for(int i = 1; i < ac; i++){
+        std::string arg = av[i];
+        if((arg == "-m" || arg == "--model") && i + 1 < ac){
+            model_file = av[++i];
+        } else if(arg == "-h" || arg == "--help"){
+            std::cout << "Usage: " << av[0] << " [options]\n"
+                      << "Options:\n"
+                      << "  -m, --model <file>  Load a 3D model (GLB, OBJ, FBX, etc.)\n"
+                      << "  -h, --help          Show this help message\n";
+            return 0;
+        } else if(arg[0] != '-'){
+            model_file = arg;
+        }
+    }
+
+    DEVICE device;
+    rlt::init(device);
+    rlt::rendering::raytracing::Renderer<SPEC> renderer;
+
+    rlt::malloc(device, renderer);
+
+    if(model_file.empty()){
+        RL_TOOLS_RENDERING_RAYTRACING_LOG_ERR("No model specified. Use --model <file>.");
+        return 1;
+    }
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("Loading model: " << model_file);
+    rlt::rendering::Bundle<T> bundle;
+    if(!rlt::load<typename SPEC::SHADING, SPEC::HAS_RGB>(device, bundle, model_file)){
+        RL_TOOLS_RENDERING_RAYTRACING_LOG_ERR("Failed to load model: " << model_file);
+        return 1;
+    }
+
+    rlt::init(device, renderer, bundle);
+
+    // Generate cameras
+    const T scene_center[3] = {bundle.metadata.center[0], bundle.metadata.center[1], bundle.metadata.center[2]};
+    const T look_up[3] = {0.f, 0.f, 1.f};
+
+    camera_orbit::write(device, renderer, scene_center, (bundle.metadata.max_ray_length / 2), look_up, FOV);
+    rlt::generate_probe_directions(device, renderer);
+
+    // Warmup
+    rlt::render(device, renderer);
+    rlt::probe(device, renderer);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("Warmup launch complete");
+
+    // Benchmark
+    int num_iterations = 0;
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("Starting benchmark (async): " << SPEC::NUM_CAMERAS << " cameras at "
+          << SPEC::CAM_WIDTH << "x" << SPEC::CAM_HEIGHT << " + " << SPEC::NUM_PROBES
+          << " probes/cam for ~" << BENCHMARK_SECONDS << "s ...");
+
+    rlt::render_sync(device, renderer);
+    rlt::probe_sync(device, renderer);
+
+    auto wall_start = std::chrono::high_resolution_clock::now();
+
+    for(;;){
+        rlt::render_launch(device, renderer);
+        rlt::probe_launch(device, renderer);
+        num_iterations++;
+
+        if(num_iterations % 10 == 0){
+            rlt::render_sync(device, renderer);
+            rlt::probe_sync(device, renderer);
+            auto now = std::chrono::high_resolution_clock::now();
+            double elapsed = std::chrono::duration<double>(now - wall_start).count();
+            if(elapsed >= BENCHMARK_SECONDS) break;
+        }
+    }
+
+    rlt::render_sync(device, renderer);
+    rlt::probe_sync(device, renderer);
+
+    auto wall_end = std::chrono::high_resolution_clock::now();
+    double wall_ms = std::chrono::duration<double, std::milli>(wall_end - wall_start).count();
+
+    // Report
+    long long total_frames = (long long)num_iterations * SPEC::NUM_CAMERAS;
+    long long total_rgb_pixels = (long long)SPEC::CAM_WIDTH * SPEC::CAM_HEIGHT * total_frames;
+    long long total_rgb_rays = SPEC::HAS_RGB ? total_rgb_pixels * SPEC::RGB_SAMPLES : 0;
+    long long total_depth_rays = SPEC::HAS_DEPTH ? total_rgb_pixels * SPEC::DEPTH_SAMPLES : 0;
+    long long total_probe_rays = (long long)num_iterations * SPEC::NUM_CAMERAS * SPEC::NUM_PROBES;
+    long long total_rays = total_rgb_rays + total_depth_rays + total_probe_rays;
+    double total_mrays = total_rays / 1e6;
+
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("=== BENCHMARK RESULTS (async) ===");
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Cameras per batch:   " << SPEC::NUM_CAMERAS);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Resolution per cam:  " << SPEC::CAM_WIDTH << "x" << SPEC::CAM_HEIGHT);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Probes per camera:   " << SPEC::NUM_PROBES);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Batch iterations:    " << num_iterations);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Total frames:        " << total_frames);
+#if RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Total RGB pixels:    " << total_rgb_pixels);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  RGB samples/pixel:   " << SPEC::RGB_SAMPLES);
+#endif
+#if RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Depth samples/pixel: " << SPEC::DEPTH_SAMPLES);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Total depth rays:    " << total_depth_rays);
+#endif
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Total probe rays:    " << total_probe_rays);
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Wall-clock time:     " << wall_ms << " ms");
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Avg per iter:        " << wall_ms / num_iterations << " ms");
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Avg per frame:       " << wall_ms / total_frames << " ms");
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Throughput:          " << (total_frames / (wall_ms / 1000.0)) << " frames/sec");
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("  Total MRays/sec:     " << (total_mrays / (wall_ms / 1000.0)));
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("=========================");
+
+    // Save outputs
+#if RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+    const char* out_filename = "owl_test.png";
+#endif
+    const char* probe_out_filename = "owl_probes.bin";
+
+#if RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_DEPTH
+    rlt::save_image(device, renderer, out_filename);
+#endif
+#if RL_TOOLS_RENDERING_RAYTRACING_BENCHMARK_OUTPUT_MODE != RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGB
+    rlt::save_depth_image(device, renderer, "owl_depth.png");
+    rlt::save_depth(device, renderer, "owl_depth.bin");
+#endif
+    rlt::save_probes(device, renderer, probe_out_filename);
+
+    rlt::free(device, renderer);
+
+    RL_TOOLS_RENDERING_RAYTRACING_LOG("seems all went OK; app is done, this should be the last output ...");
+    return 0;
+}