hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/operations_cpu_mux.h

@@ -0,0 +1,19 @@
+#include "../../version.h"
+#include "../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_OPERATIONS_CPU_MUX_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_OPERATIONS_CPU_MUX_H
+
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_METAL)
+    #include "backends/metal/operations_cpu.h"
+#elif defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+    #include "backends/optix/operations_cuda.h"
+#elif defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_VULKAN)
+    #include "backends/vulkan/operations_cpu.h"
+#elif defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_GENERIC)
+    #include "backends/generic/operations_cpu.h"
+#else
+    #error "RLtools raytracing: no backend configured (RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX, RL_TOOLS_RENDERING_RAYTRACING_BACKEND_METAL, RL_TOOLS_RENDERING_RAYTRACING_BACKEND_VULKAN, or RL_TOOLS_RENDERING_RAYTRACING_BACKEND_GENERIC)"
+#endif
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/renderer.h

@@ -0,0 +1,376 @@
+#include "../../version.h"
+#include "../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_RENDERER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_RENDERER_H
+
+#include "types.h"
+#include "scene.h"
+#include "../../containers/tensor/tensor.h"
+
+#include <vector>
+#include <deque>
+#include <cstdint>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace rendering::raytracing{
+
+        template <
+            bool T_LOAD_TEXTURES,
+            bool T_NORMAL_SHADING,
+            bool T_METALLIC_REFLECTIONS,
+            bool T_SRGB_OUTPUT,
+            bool T_CHECKER_BACKGROUND,
+            bool T_PBR_SHADING,
+            bool T_PUNCTUAL_LIGHT_SHADOWS = false
+        >
+        struct ShadingOptions{
+            static constexpr bool LOAD_TEXTURES = T_LOAD_TEXTURES;
+            static constexpr bool NORMAL_SHADING = T_NORMAL_SHADING;
+            static constexpr bool METALLIC_REFLECTIONS = T_METALLIC_REFLECTIONS;
+            static constexpr bool SRGB_OUTPUT = T_SRGB_OUTPUT;
+            static constexpr bool CHECKER_BACKGROUND = T_CHECKER_BACKGROUND;
+            static constexpr bool PBR_SHADING = T_PBR_SHADING;
+            static constexpr bool PUNCTUAL_LIGHT_SHADOWS = T_PUNCTUAL_LIGHT_SHADOWS;
+        };
+
+        using Medium = ShadingOptions<true, true, true, true, true, false>;
+        using High = ShadingOptions<true, true, true, true, false, true>;
+        using VeryHigh = ShadingOptions<true, true, true, true, false, true, true>;
+        using Low = ShadingOptions<false, false, false, false, false, false>;
+
+        using BasicShading = Medium;
+        using HighFidelityShading = High;
+        using VeryHighFidelityShading = VeryHigh;
+        using FastFlatShading = Low;
+
+        namespace config{
+            // Fringe defaults only: the required geometry — CAM_WIDTH, CAM_HEIGHT, NUM_CAMERAS,
+            // NUM_PROBES — is deliberately absent from this base, so a missing (or misspelled)
+            // required member fails to compile instead of silently falling back to a default.
+            template <typename T_T, typename T_TI>
+            struct Default{
+                using T = T_T;
+                using TI = T_TI;
+                using SHADING = Medium;
+                static constexpr bool OUTPUT_RGB = true;
+                static constexpr bool OUTPUT_DEPTH = false;
+                // segmentation writes one uint32 instance index per pixel (miss = 0xFFFFFFFF),
+                // always single-sample from the shutter-close camera: labels cannot be averaged,
+                // so anti-aliasing and motion-blur settings do not apply to it
+                static constexpr bool OUTPUT_SEGMENTATION = false;
+                static constexpr bool SEMANTIC_SEGMENTATION = false;
+                // normals writes the world-frame (FLU) geometric unit normal of the hit surface,
+                // oriented against the ray, as float3 per pixel (miss = 0,0,0); like segmentation
+                // it is always single-sample from the shutter-close camera: unit normals cannot
+                // be averaged, so anti-aliasing and motion-blur settings do not apply to it
+                static constexpr bool OUTPUT_NORMALS = false;
+                static constexpr bool ENABLE_MOTION_BLUR = false;
+                static constexpr T_TI MOTION_BLUR_SAMPLES = 1;
+                // dynamic motion blur renders MOTION_BLUR_SAMPLES sequential passes per frame,
+                // rebuilding the overlay acceleration structures from per-sample transforms
+                // (transforms_motion) between passes and accumulating linear radiance on the
+                // device — overlays blur, not just the camera. Requires motion blur + overlays.
+                static constexpr bool ENABLE_DYNAMIC_MOTION_BLUR = false;
+                static constexpr bool ENABLE_ANTI_ALIASING = false;
+                static constexpr T_TI ANTI_ALIASING_GRID_SIZE = 1;
+                static constexpr T_TI NUM_OVERLAYS = 0;
+                static constexpr T_TI MAX_OVERLAY_INSTANCES = 0;
+                static constexpr T_TI MAX_OVERLAYS_PER_CAMERA = 0;
+                // spec-driven observation output: the RGB ray gen writes OBSERVATION_T pixels
+                // ([0,1] linear or sRGB per SHADING) directly — no format-conversion pass. The
+                // packed frame buffer remains the video/golden output.
+                static constexpr bool OUTPUT_OBSERVATION = false;
+                using OBSERVATION_T = float;
+            };
+        }
+
+        template <typename T_CONFIG>
+        struct Specification{
+            using CONFIG = T_CONFIG;
+            using T = typename CONFIG::T;
+            using TI = typename CONFIG::TI;
+            using SHADING = typename CONFIG::SHADING;
+            static constexpr bool HAS_RGB = CONFIG::OUTPUT_RGB;
+            static constexpr bool HAS_DEPTH = CONFIG::OUTPUT_DEPTH;
+            static constexpr bool HAS_SEGMENTATION = CONFIG::OUTPUT_SEGMENTATION;
+            static constexpr bool HAS_NORMALS = CONFIG::OUTPUT_NORMALS;
+            static constexpr bool ENABLE_DEPTH = HAS_DEPTH;
+            static constexpr bool ENABLE_RGB = HAS_RGB;
+            static constexpr TI CAM_WIDTH = CONFIG::CAM_WIDTH;
+            static constexpr TI CAM_HEIGHT = CONFIG::CAM_HEIGHT;
+            static constexpr TI NUM_CAMERAS = CONFIG::NUM_CAMERAS;
+            static constexpr TI NUM_PROBES = CONFIG::NUM_PROBES;
+            static_assert(CAM_WIDTH > 0 && CAM_HEIGHT > 0 && NUM_CAMERAS > 0, "camera geometry must be nonzero");
+            static_assert(HAS_RGB || HAS_DEPTH || HAS_SEGMENTATION || HAS_NORMALS || NUM_PROBES > 0, "the renderer must produce at least one output (an image target or collision probes)");
+            static constexpr TI MOTION_BLUR_SAMPLES = CONFIG::MOTION_BLUR_SAMPLES;
+            static constexpr bool ENABLE_MOTION_BLUR = CONFIG::ENABLE_MOTION_BLUR && MOTION_BLUR_SAMPLES > 1;
+            static_assert(MOTION_BLUR_SAMPLES >= 1, "MOTION_BLUR_SAMPLES must be at least 1");
+            static_assert(!ENABLE_MOTION_BLUR || MOTION_BLUR_SAMPLES == 2 || MOTION_BLUR_SAMPLES == 4 || MOTION_BLUR_SAMPLES == 8 || MOTION_BLUR_SAMPLES == 16 || MOTION_BLUR_SAMPLES == 32, "MOTION_BLUR_SAMPLES must be one of 2, 4, 8, 16, or 32");
+            static constexpr TI ANTI_ALIASING_GRID_SIZE = CONFIG::ANTI_ALIASING_GRID_SIZE;
+            static constexpr bool ENABLE_ANTI_ALIASING = CONFIG::ENABLE_ANTI_ALIASING && ANTI_ALIASING_GRID_SIZE > 1;
+            static constexpr TI ANTI_ALIASING_SAMPLES = ENABLE_ANTI_ALIASING ? ANTI_ALIASING_GRID_SIZE * ANTI_ALIASING_GRID_SIZE : 1;
+            static constexpr TI RGB_SAMPLES = (ENABLE_MOTION_BLUR ? MOTION_BLUR_SAMPLES : 1) * ANTI_ALIASING_SAMPLES;
+            static constexpr TI DEPTH_SAMPLES = RGB_SAMPLES;
+            static_assert(ANTI_ALIASING_GRID_SIZE >= 1, "ANTI_ALIASING_GRID_SIZE must be at least 1");
+            static_assert(!ENABLE_ANTI_ALIASING || ANTI_ALIASING_GRID_SIZE == 2 || ANTI_ALIASING_GRID_SIZE == 3 || ANTI_ALIASING_GRID_SIZE == 4, "ANTI_ALIASING_GRID_SIZE must be one of 2, 3, or 4");
+            static constexpr TI GRID_COLS = [](){
+                TI cols = 1;
+                while(cols * cols < NUM_CAMERAS) cols++;
+                return cols;
+            }();
+            static constexpr TI GRID_ROWS = (NUM_CAMERAS + GRID_COLS - 1) / GRID_COLS;
+            static constexpr TI FB_WIDTH = GRID_COLS * CAM_WIDTH;
+            static constexpr TI FB_HEIGHT = GRID_ROWS * CAM_HEIGHT;
+            static constexpr TI CAM_PIXELS = CAM_WIDTH * CAM_HEIGHT;
+            static constexpr T BENCHMARK_SECONDS = 10.0;
+            static constexpr T COS_FOVY = 1.3962634015954636;
+            // dynamic overlays: per-camera dynamic content composed onto the static shared world
+            static constexpr TI NUM_OVERLAYS = CONFIG::NUM_OVERLAYS;
+            static constexpr TI MAX_OVERLAY_INSTANCES = CONFIG::MAX_OVERLAY_INSTANCES;
+            static constexpr TI MAX_OVERLAYS_PER_CAMERA = CONFIG::MAX_OVERLAYS_PER_CAMERA;
+            static constexpr bool ENABLE_OVERLAYS = NUM_OVERLAYS > 0 && MAX_OVERLAY_INSTANCES > 0 && MAX_OVERLAYS_PER_CAMERA > 0;
+            static constexpr bool SEMANTIC_SEGMENTATION = CONFIG::SEMANTIC_SEGMENTATION; // segmentation output carries Object::segmentation_class instead of the instance id
+            static_assert(!SEMANTIC_SEGMENTATION || HAS_SEGMENTATION, "SEMANTIC_SEGMENTATION requires OUTPUT_SEGMENTATION");
+            static_assert(ENABLE_OVERLAYS || (NUM_OVERLAYS == 0 && MAX_OVERLAY_INSTANCES == 0 && MAX_OVERLAYS_PER_CAMERA == 0), "overlay constants must be all zero (disabled) or all nonzero");
+            static constexpr bool ENABLE_DYNAMIC_MOTION_BLUR = CONFIG::ENABLE_DYNAMIC_MOTION_BLUR && ENABLE_MOTION_BLUR && ENABLE_OVERLAYS;
+            static_assert(!CONFIG::ENABLE_DYNAMIC_MOTION_BLUR || (ENABLE_MOTION_BLUR && ENABLE_OVERLAYS), "ENABLE_DYNAMIC_MOTION_BLUR requires ENABLE_MOTION_BLUR (MOTION_BLUR_SAMPLES > 1) and overlays");
+            static constexpr bool HAS_OBSERVATION = CONFIG::OUTPUT_OBSERVATION;
+            using OBSERVATION_T = typename CONFIG::OBSERVATION_T;
+            static constexpr TI OBSERVATION_CHANNELS = 3;
+            static_assert(!HAS_OBSERVATION || HAS_RGB, "OUTPUT_OBSERVATION requires OUTPUT_RGB (the RGB ray gen writes it)");
+        };
+
+        namespace backends {
+            struct None {};
+            struct Generic {};
+            struct Optix {};
+            struct Metal {};
+            struct Vulkan {};
+
+            template <typename T_BACKEND>
+            struct Name;
+            template <> struct Name<None>    { static constexpr const char* VALUE = "none"; };
+            template <> struct Name<Generic> { static constexpr const char* VALUE = "generic"; };
+            template <> struct Name<Optix>   { static constexpr const char* VALUE = "optix"; };
+            template <> struct Name<Metal>   { static constexpr const char* VALUE = "metal"; };
+            template <> struct Name<Vulkan>  { static constexpr const char* VALUE = "vulkan"; };
+
+            template <typename T_BACKEND>
+            constexpr const char* name(){
+                return Name<T_BACKEND>::VALUE;
+            }
+
+#if defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_METAL)
+            using Default = Metal;
+#elif defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)
+            using Default = Optix;
+#elif defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_VULKAN)
+            using Default = Vulkan;
+#elif defined(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_GENERIC)
+            using Default = Generic;
+#else
+            using Default = None;
+#endif
+
+            template <typename T_BACKEND, typename T_SPEC>
+            struct RendererState;
+
+            template <typename T_BACKEND, typename T_SPEC>
+            struct LibraryState;
+
+            template <typename T_BACKEND, typename T_SPEC>
+            struct SceneState;
+        }
+
+        // shared scene store: renderers malloc'd against a library share one backend context and
+        // one geometry/texture/BLAS build per unique scene — init(device, renderer, library,
+        // path) deduplicates by file content hash and returns the unique-scene index, so callers
+        // key their own per-scene data off it. The library owns the host scenes its builds
+        // reference (deque: stable addresses). On backends without cross-renderer sharing
+        // (generic/Metal/Vulkan) each renderer still builds its own device copy — the caller
+        // code is uniform, the sharing is a backend property.
+        template <typename T_SPEC, typename T_BACKEND = backends::Default>
+        struct AssetLibrary {
+            using SPEC = T_SPEC;
+            using BACKEND = T_BACKEND;
+            using TI = typename SPEC::TI;
+            using BACKEND_STATE = backends::LibraryState<BACKEND, SPEC>;
+            using SCENE_STATE = backends::SceneState<BACKEND, SPEC>;
+            BACKEND_STATE* backend = nullptr;
+            std::deque<Scene> scenes;
+            std::deque<SCENE_STATE*> assets;
+            std::vector<uint64_t> hashes;
+            AssetPool pool;
+        };
+
+        template <typename T_SPEC, bool T_ENABLE_MOTION_BLUR>
+        struct MotionBlurRendererStorage {};
+
+        template <typename T_SPEC>
+        struct MotionBlurRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using T = typename SPEC::T;
+            using TI = typename SPEC::TI;
+            using CAMERA_TENSOR_SPEC = tensor::Specification<Camera<T>, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS>, true>;
+            Tensor<CAMERA_TENSOR_SPEC> cameras_open;
+        };
+
+        template <typename T_SPEC, bool T_HAS_RGB>
+        struct RGBRendererStorage {};
+
+        template <typename T_SPEC>
+        struct RGBRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using TI = typename SPEC::TI;
+            using FB_TENSOR_SPEC = tensor::Specification<uint32_t, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH>, true>;
+            Tensor<FB_TENSOR_SPEC> frame_buffer;
+        };
+
+        template <typename T_SPEC, bool T_HAS_DEPTH>
+        struct DepthRendererStorage {};
+
+        template <typename T_SPEC>
+        struct DepthRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using T = typename SPEC::T;
+            using TI = typename SPEC::TI;
+            using DEPTH_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH>, true>;
+            Tensor<DEPTH_TENSOR_SPEC> depth_buffer;
+        };
+
+        template <typename T_SPEC, bool T_HAS_SEGMENTATION>
+        struct SegmentationRendererStorage {};
+
+        template <typename T_SPEC>
+        struct SegmentationRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using TI = typename SPEC::TI;
+            using SEGMENTATION_TENSOR_SPEC = tensor::Specification<uint32_t, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH>, true>;
+            Tensor<SEGMENTATION_TENSOR_SPEC> segmentation_buffer;
+        };
+
+        template <typename T_SPEC, bool T_HAS_NORMALS>
+        struct NormalsRendererStorage {};
+
+        template <typename T_SPEC>
+        struct NormalsRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using TI = typename SPEC::TI;
+            using NORMALS_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH, 3>, true>;
+            Tensor<NORMALS_TENSOR_SPEC> normals_buffer;
+        };
+
+        template <typename T_SPEC, bool T_HAS_OBSERVATION>
+        struct ObservationRendererStorage {};
+
+        template <typename T_SPEC>
+        struct ObservationRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using TI = typename SPEC::TI;
+            using OBSERVATION_TENSOR_SPEC = tensor::Specification<typename SPEC::OBSERVATION_T, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH, SPEC::OBSERVATION_CHANNELS>, true>;
+            Tensor<OBSERVATION_TENSOR_SPEC> observation;
+        };
+
+        template <typename T_SPEC, bool T_ENABLE_OVERLAYS>
+        struct OverlayRendererStorage {};
+
+        template <typename T_SPEC>
+        struct OverlayRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using TI = typename SPEC::TI;
+            static constexpr TI INVALID_OVERLAY = ~(TI)0;
+
+            struct OverlaySlot {
+                TI object = 0;          // global object index (scene objects + pool objects)
+                TI pose_slot = 0;       // root slot of the owning placement; the root's transforms entry moves the whole placement
+                float part_local[12];   // static attachment (part -> assembly), captured at spawn
+                float transform_entry[12]; // host mirror of the transforms-tensor entry (root: pose, non-root: articulation in the part frame)
+                bool active = false;
+            };
+            struct OverlayState {
+                OverlaySlot slots[SPEC::MAX_OVERLAY_INSTANCES];
+                bool dirty = false;
+            };
+            // pool assemblies flattened at init so spawn needs no pool access in the hot path
+            struct AssetRecord {
+                TI first_part;          // into asset_part_objects/asset_part_transforms
+                TI num_parts;
+            };
+            OverlayState overlays[SPEC::NUM_OVERLAYS];
+            // dynamic transform input consumed by update(): entry [o][s] is the placement pose at
+            // its root slot and a part-frame articulation elsewhere (world = pose ∘ part_local ∘
+            // articulation). Backend-native residency (device memory on OptiX) — access via
+            // transforms(device, renderer); host verbs stage through the slot mirrors instead.
+            using TRANSFORMS_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, SPEC::NUM_OVERLAYS, SPEC::MAX_OVERLAY_INSTANCES, 12>, true>;
+            Tensor<TRANSFORMS_TENSOR_SPEC> transforms;
+            TI attachments[SPEC::NUM_CAMERAS * SPEC::MAX_OVERLAYS_PER_CAMERA];
+            bool attachments_dirty = false;
+            // the flattened pool tables live on the renderer (not in backend state) because the
+            // backend-independent host verbs (spawn, set_transform) consume them
+            std::vector<AssetRecord> assets;
+            std::vector<TI> asset_part_objects;      // global object index per part
+            std::vector<float> asset_part_transforms; // 12 per part, assembly-local
+        };
+
+        template <typename T_SPEC, bool T_ENABLE_DYNAMIC_MOTION_BLUR>
+        struct DynamicMotionBlurRendererStorage {};
+
+        template <typename T_SPEC>
+        struct DynamicMotionBlurRendererStorage<T_SPEC, true> {
+            using SPEC = T_SPEC;
+            using TI = typename SPEC::TI;
+            // per-sample overlay transform input consumed by the dynamic-motion-blur render loop:
+            // sample-major so slab s (base + s * NUM_OVERLAYS * MAX_OVERLAY_INSTANCES * 12) has
+            // the exact layout of the transforms tensor and feeds the same build path. Row
+            // semantics match transforms (root: pose, non-root: part-frame articulation).
+            using TRANSFORMS_MOTION_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, SPEC::MOTION_BLUR_SAMPLES, SPEC::NUM_OVERLAYS, SPEC::MAX_OVERLAY_INSTANCES, 12>, true>;
+            Tensor<TRANSFORMS_MOTION_TENSOR_SPEC> transforms_motion;
+            // device-producer input: shutter-open (index 0) and shutter-close (index 1) entries
+            // per slot, expanded into transforms_motion (and the close state into transforms) by
+            // expand_motion_transforms — on OptiX both the producer write and the expansion stay
+            // on the device, so a sim kernel can drive dynamic blur with no host data path
+            using TRANSFORMS_PAIR_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, 2, SPEC::NUM_OVERLAYS, SPEC::MAX_OVERLAY_INSTANCES, 12>, true>;
+            Tensor<TRANSFORMS_PAIR_TENSOR_SPEC> transforms_pair;
+            // host mirror of transforms_motion for the verb path (the tensor is device-resident
+            // on OptiX); staged per dirty overlay, same ownership contract as transform_entry
+            std::vector<float> transforms_motion_staging;
+            bool transforms_motion_dirty[SPEC::NUM_OVERLAYS] = {};
+            // linear-radiance accumulators, resolved into the packed frame buffer / depth buffer
+            // after the last sample pass; allocated only for the enabled outputs
+            using RGB_ACCUMULATOR_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH, 3>, true>;
+            Tensor<RGB_ACCUMULATOR_TENSOR_SPEC> rgb_accumulator;
+            using DEPTH_ACCUMULATOR_TENSOR_SPEC = tensor::Specification<float, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::CAM_HEIGHT, SPEC::CAM_WIDTH>, true>;
+            Tensor<DEPTH_ACCUMULATOR_TENSOR_SPEC> depth_accumulator;
+        };
+
+        template <typename T_SPEC, typename T_BACKEND = backends::Default>
+        struct Renderer: MotionBlurRendererStorage<T_SPEC, T_SPEC::ENABLE_MOTION_BLUR>, RGBRendererStorage<T_SPEC, T_SPEC::HAS_RGB>, DepthRendererStorage<T_SPEC, T_SPEC::HAS_DEPTH>, SegmentationRendererStorage<T_SPEC, T_SPEC::HAS_SEGMENTATION>, NormalsRendererStorage<T_SPEC, T_SPEC::HAS_NORMALS>, ObservationRendererStorage<T_SPEC, T_SPEC::HAS_OBSERVATION>, OverlayRendererStorage<T_SPEC, T_SPEC::ENABLE_OVERLAYS>, DynamicMotionBlurRendererStorage<T_SPEC, T_SPEC::ENABLE_DYNAMIC_MOTION_BLUR>{
+            using SPEC = T_SPEC;
+            using BACKEND = T_BACKEND;
+            using BACKEND_STATE = backends::RendererState<BACKEND, SPEC>;
+            using T = typename SPEC::T;
+            using TI = typename SPEC::TI;
+
+            // camera input consumed directly by render/probe: backend-native residency (device
+            // memory on OptiX, host on generic, shared/mapped on Metal/Vulkan) — access via
+            // cameras(device, renderer); under motion blur this is the shutter-close camera and
+            // cameras_open holds the shutter-open pose (see cameras_open/cameras_close accessors)
+            using CAMERA_TENSOR_SPEC = tensor::Specification<Camera<T>, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS>, true>;
+            Tensor<CAMERA_TENSOR_SPEC> cameras;
+
+            using COLLISION_TENSOR_SPEC = tensor::Specification<CollisionResult, TI, tensor::Shape<TI, SPEC::NUM_CAMERAS, SPEC::NUM_PROBES>, true>;
+            Tensor<COLLISION_TENSOR_SPEC> collision_results;
+
+            T scene_center[3] = {0, 0, 0};
+            T scene_half_extent[3] = {0, 0, 0};
+            T camera_radius = 0;
+
+            BACKEND_STATE* backend = nullptr;
+        };
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/scene/procthor/operations_cpu.h

@@ -0,0 +1,226 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_SCENE_PROCTHOR_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_SCENE_PROCTHOR_OPERATIONS_CPU_H
+
+#include "scene.h"
+#include "../../renderer.h"
+#include "../../operations_cpu_mux.h"
+
+#include <array>
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+#include <limits>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::scene::procthor {
+    template <typename T, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT T radical_inverse(TI n, TI base) {
+        T inv_base = static_cast<T>(1) / static_cast<T>(base);
+        T inv = inv_base;
+        T result = static_cast<T>(0);
+        while (n > 0) {
+            const TI digit = n % base;
+            result += static_cast<T>(digit) * inv;
+            inv *= inv_base;
+            n /= base;
+        }
+        return result;
+    }
+
+    template <typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T frac(T x) {
+        return x - std::floor(x);
+    }
+
+    template <typename DEVICE, typename SCENE_SPEC, typename RENDERER_SPEC, typename BACKEND>
+    void precompute_indoor_positions(DEVICE& device, Scene<SCENE_SPEC>& scene, rendering::raytracing::Renderer<RENDERER_SPEC, BACKEND>& renderer, typename SCENE_SPEC::T fov, typename SCENE_SPEC::T aspect) {
+        using T = typename SCENE_SPEC::T;
+        using TI = typename SCENE_SPEC::TI;
+        constexpr TI NUM_CAMERAS = RENDERER_SPEC::NUM_CAMERAS;
+        constexpr TI NUM_PROBES = RENDERER_SPEC::NUM_PROBES;
+
+        scene.config.scene_center[0] = renderer.scene_center[0];
+        scene.config.scene_center[1] = renderer.scene_center[1];
+        scene.config.scene_center[2] = renderer.scene_center[2];
+        scene.config.scene_radius = renderer.camera_radius;
+
+        const T center[3] = {renderer.scene_center[0], renderer.scene_center[1], renderer.scene_center[2]};
+        const T half_extent[3] = {renderer.scene_half_extent[0], renderer.scene_half_extent[1], renderer.scene_half_extent[2]};
+
+        RL_TOOLS_RENDERING_RAYTRACING_LOG("precompute_indoor_positions: center=[" << center[0] << "," << center[1] << "," << center[2] << "] half_extent=[" << half_extent[0] << "," << half_extent[1] << "," << half_extent[2] << "]");
+        utils::assert_exit(device, data(collision_results(device, renderer)) != nullptr, "precompute_indoor_positions: collision results buffer is null");
+
+        struct Candidate {
+            IndoorPosition<T> position;
+            T score;
+        };
+
+        constexpr T PI = static_cast<T>(3.14159265358979323846);
+        constexpr T MIN_CLEARANCE = static_cast<T>(1.0);
+        constexpr TI MAX_TOTAL_TESTED = 4096;
+        constexpr TI MAX_BATCHES = (MAX_TOTAL_TESTED + NUM_CAMERAS - 1) / NUM_CAMERAS;
+        constexpr TI MIN_REQUIRED_POSITIONS = 50;
+        const T max_half = std::max({half_extent[0], half_extent[1], half_extent[2]});
+        const T max_dist = max_half > static_cast<T>(1)
+            ? static_cast<T>(2) * max_half
+            : static_cast<T>(20);
+        const T look_ahead = static_cast<T>(1);
+        const T search_half_extent[3] = {
+            std::max(static_cast<T>(0), half_extent[0] - MIN_CLEARANCE),
+            std::max(static_cast<T>(0), half_extent[1] - MIN_CLEARANCE),
+            std::max(static_cast<T>(0), half_extent[2] - MIN_CLEARANCE)
+        };
+
+        std::vector<Candidate> candidates;
+        candidates.reserve(static_cast<size_t>(MAX_BATCHES) * static_cast<size_t>(NUM_CAMERAS));
+
+        std::array<IndoorPosition<T>, NUM_CAMERAS> batch_positions{};
+        std::vector<rendering::raytracing::Camera<T>> camera_staging(NUM_CAMERAS);
+        TI total_tested = 0, no_hits = 0, failed_hit_ratio = 0, failed_avg_dist = 0, failed_min_dist = 0;
+        T best_min_hit_dist = 0;
+
+        for (TI batch_i = 0; batch_i < MAX_BATCHES && candidates.size() < MIN_REQUIRED_POSITIONS; batch_i++) {
+            for (TI camera_i = 0; camera_i < NUM_CAMERAS; camera_i++) {
+                const TI candidate_i = batch_i * NUM_CAMERAS + camera_i + 1;
+                const T hx = radical_inverse<T>(candidate_i, static_cast<TI>(2));
+                const T hy = radical_inverse<T>(candidate_i, static_cast<TI>(3));
+                const T hz = radical_inverse<T>(candidate_i, static_cast<TI>(5));
+                const T hw = radical_inverse<T>(candidate_i, static_cast<TI>(7));
+
+                const T yaw = static_cast<T>(2) * PI * hw;
+
+                auto& pos = batch_positions[camera_i];
+                pos.position[0] = center[0] + (hx * static_cast<T>(2) - static_cast<T>(1)) * search_half_extent[0];
+                pos.position[1] = center[1] + (hy * static_cast<T>(2) - static_cast<T>(1)) * search_half_extent[1];
+                pos.position[2] = center[2] + (hz * static_cast<T>(2) - static_cast<T>(1)) * search_half_extent[2];
+                pos.yaw = yaw;
+                pos.score = static_cast<T>(0);
+
+                const T cam_position[3] = {pos.position[0], pos.position[1], pos.position[2]};
+                const T cam_look_at[3] = {
+                    pos.position[0] + look_ahead * std::cos(pos.yaw),
+                    pos.position[1] + look_ahead * std::sin(pos.yaw),
+                    pos.position[2]
+                };
+                const T cam_up[3] = {0, 0, 1};
+                camera_staging[camera_i] = make_camera_data(cam_position, cam_look_at, cam_up, fov, aspect);
+            }
+
+            copy_to_renderer(device, renderer, camera_staging.data(), data(cameras(device, renderer)), NUM_CAMERAS);
+            probe(device, renderer);
+
+            std::vector<rendering::raytracing::CollisionResult> probe_staging((size_t)NUM_CAMERAS * NUM_PROBES);
+            copy_from_renderer(device, renderer, data(collision_results(device, renderer)), probe_staging.data(), probe_staging.size());
+            const rendering::raytracing::CollisionResult* probe_results = probe_staging.data();
+            for (TI camera_i = 0; camera_i < NUM_CAMERAS; camera_i++) {
+                const rendering::raytracing::CollisionResult* camera_probes = probe_results + static_cast<size_t>(camera_i) * static_cast<size_t>(NUM_PROBES);
+                TI hit_count = 0;
+                TI very_near_hit_count = 0;
+                // finite sentinel: infinity() is undefined behavior under -ffast-math and breaks the min tracking on Apple clang
+                T min_hit_dist = std::numeric_limits<T>::max();
+                T sum_hit_dist = static_cast<T>(0);
+
+                for (TI probe_i = 0; probe_i < NUM_PROBES; probe_i++) {
+                    const rendering::raytracing::CollisionResult& probe = camera_probes[probe_i];
+                    if (probe.hit) {
+                        const T dist = static_cast<T>(probe.distance);
+                        hit_count++;
+                        sum_hit_dist += dist;
+                        if (dist < min_hit_dist) {
+                            min_hit_dist = dist;
+                        }
+                        if (dist < static_cast<T>(0.25)) {
+                            very_near_hit_count++;
+                        }
+                    }
+                }
+
+                total_tested++;
+                if (hit_count == 0) {
+                    no_hits++;
+                    continue;
+                }
+
+                const T hit_ratio = static_cast<T>(hit_count) / static_cast<T>(NUM_PROBES);
+                const T avg_hit_dist = sum_hit_dist / static_cast<T>(hit_count);
+                const T avg_dist_norm = avg_hit_dist / max_dist;
+                const T near_ratio = static_cast<T>(very_near_hit_count) / static_cast<T>(NUM_PROBES);
+                const T forward_dist = static_cast<T>(camera_probes[0].distance);
+                const bool forward_open = camera_probes[0].hit && forward_dist > static_cast<T>(0.6) && forward_dist < static_cast<T>(6.0);
+
+                const T score =
+                    static_cast<T>(2.0) * hit_ratio
+                    - static_cast<T>(1.1) * avg_dist_norm
+                    - static_cast<T>(0.8) * near_ratio
+                    + (forward_open ? static_cast<T>(0.15) : static_cast<T>(0));
+
+                if(hit_ratio <= static_cast<T>(0.72)) failed_hit_ratio++;
+                else if(avg_dist_norm >= static_cast<T>(0.45)) failed_avg_dist++;
+                else if(min_hit_dist <= MIN_CLEARANCE){ failed_min_dist++; if(min_hit_dist > best_min_hit_dist) best_min_hit_dist = min_hit_dist; }
+
+                const bool indoor_like =
+                    hit_ratio > static_cast<T>(0.72) &&
+                    avg_dist_norm < static_cast<T>(0.45) &&
+                    min_hit_dist > MIN_CLEARANCE;
+
+                if (indoor_like) {
+                    auto pos = batch_positions[camera_i];
+                    pos.score = score;
+                    candidates.push_back({pos, score});
+                }
+            }
+        }
+
+        std::sort(candidates.begin(), candidates.end(), [](const Candidate& a, const Candidate& b) {
+            return a.score > b.score;
+        });
+
+        const TI take_n = std::min(static_cast<TI>(candidates.size()), SCENE_SPEC::MAX_INDOOR_POSITIONS);
+        for (TI i = 0; i < take_n; i++) {
+            scene.indoor_positions[i] = candidates[i].position;
+        }
+        scene.num_indoor_positions = take_n;
+
+        RL_TOOLS_RENDERING_RAYTRACING_LOG("precompute_indoor_positions: tested=" << total_tested << " no_hits=" << no_hits << " failed_hit_ratio=" << failed_hit_ratio << " failed_avg_dist=" << failed_avg_dist << " failed_min_dist=" << failed_min_dist << " (best_min_hit=" << best_min_hit_dist << ") accepted=" << scene.num_indoor_positions);
+        utils::assert_exit(device, scene.num_indoor_positions > 0, "precompute_indoor_positions: no valid indoor positions found");
+    }
+
+    template <typename DEVICE, typename SCENE_SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT IndoorPosition<typename SCENE_SPEC::T> sample_indoor_position(DEVICE& device, const Scene<SCENE_SPEC>& scene, RNG& rng) {
+        using TI = typename SCENE_SPEC::TI;
+        if (scene.num_indoor_positions == 0) {
+            return {};
+        }
+        const TI index = random::uniform_int_distribution(device.random, static_cast<TI>(0), static_cast<TI>(scene.num_indoor_positions - 1), rng);
+        return scene.indoor_positions[index];
+    }
+
+    template <typename DEVICE, typename RENDERER_SPEC, typename BACKEND>
+    RL_TOOLS_FUNCTION_PLACEMENT typename RENDERER_SPEC::T evaluate_clearance(DEVICE& device, rendering::raytracing::Renderer<RENDERER_SPEC, BACKEND>& renderer, typename RENDERER_SPEC::TI camera_index) {
+        using T = typename RENDERER_SPEC::T;
+        constexpr auto NUM_PROBES = RENDERER_SPEC::NUM_PROBES;
+        if (data(renderer.collision_results) == nullptr) {
+            return std::numeric_limits<T>::max();
+        }
+        std::vector<rendering::raytracing::CollisionResult> probe_staging(NUM_PROBES);
+        copy_from_renderer(device, renderer, data(renderer.collision_results) + (size_t)camera_index * NUM_PROBES, probe_staging.data(), NUM_PROBES);
+        const rendering::raytracing::CollisionResult* camera_probes = probe_staging.data();
+        T min_dist = std::numeric_limits<T>::max();
+        for (typename RENDERER_SPEC::TI probe_i = 0; probe_i < NUM_PROBES; probe_i++) {
+            if (camera_probes[probe_i].hit) {
+                T dist = static_cast<T>(camera_probes[probe_i].distance);
+                if (dist < min_dist) {
+                    min_dist = dist;
+                }
+            }
+        }
+        return min_dist;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/scene/procthor/scene.h

@@ -0,0 +1,25 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_SCENE_PROCTHOR_SCENE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_SCENE_PROCTHOR_SCENE_H
+
+#include "../scene.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::scene::procthor {
+    template <typename T_SPEC>
+    struct Scene {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+
+        IndoorPosition<T> indoor_positions[SPEC::MAX_INDOOR_POSITIONS];
+        TI num_indoor_positions = 0;
+
+        SceneConfig<T> config;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif