hyperray 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,314 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_SAVE_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_SAVE_CPU_H
+
+#include "operations_cpu_common.h"
+
+// Opt-in save verbs (deliberately not part of operations_cpu_mux.h): include this header after
+// the backend operations header in targets that write debug images/binaries. The verbs are
+// backend-generic — copy(renderer.device, device, ...) orders the readback after the renderer's
+// in-flight work and bridges the backend memory domain.
+//
+// STATIC gives the stb implementation internal linkage so multiple TUs of one binary may include
+// this header without duplicate-symbol link errors; RL_TOOLS_STB_IMAGE_WRITE_PROVIDED arbitrates
+// with other stb-write-providing headers (e.g. the test golden_io.h) so the implementation lands
+// exactly once per TU regardless of include order (stb's implementation section has no include
+// guard).
+#ifndef RL_TOOLS_STB_IMAGE_WRITE_PROVIDED
+#define RL_TOOLS_STB_IMAGE_WRITE_PROVIDED
+#define STB_IMAGE_WRITE_STATIC
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+#endif
+
+#include <vector>
+#include <type_traits>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace rendering::raytracing::detail{
+        template <typename SPEC, typename DEVICE>
+        void write_grid_png(DEVICE& device, const uint32_t* fb, const char* filename){
+            using TI = typename SPEC::TI;
+            constexpr TI cam_pixels = SPEC::CAM_PIXELS;
+            constexpr int grid_width = SPEC::GRID_COLS * SPEC::CAM_WIDTH;
+            constexpr int grid_height = SPEC::GRID_ROWS * SPEC::CAM_HEIGHT;
+            std::vector<uint32_t> grid_image(grid_width * grid_height, 0);
+
+            for(int i = 0; i < (int)SPEC::NUM_CAMERAS; i++){
+                int col = i % SPEC::GRID_COLS;
+                int row = i / SPEC::GRID_COLS;
+                int offset_x = col * SPEC::CAM_WIDTH;
+                int offset_y = row * SPEC::CAM_HEIGHT;
+
+                for(int y = 0; y < (int)SPEC::CAM_HEIGHT; y++){
+                    memcpy(&grid_image[(offset_y + y) * grid_width + offset_x],
+                           &fb[i * cam_pixels + y * SPEC::CAM_WIDTH],
+                           SPEC::CAM_WIDTH * sizeof(uint32_t));
+                }
+            }
+
+            stbi_write_png(filename, grid_width, grid_height, 4,
+                           grid_image.data(), grid_width * sizeof(uint32_t));
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "Written grid image (", SPEC::GRID_COLS, "x", SPEC::GRID_ROWS,
+                   " cameras, ", grid_width, "x", grid_height, " px) to ", filename);
+        }
+
+        template <typename SPEC, typename DEVICE>
+        void write_segmentation_grid_png(DEVICE& device, const uint32_t* segmentation, const char* filename){
+            constexpr typename SPEC::TI num_pixels = SPEC::NUM_CAMERAS * SPEC::CAM_PIXELS;
+            std::vector<uint32_t> colored(num_pixels);
+            for(size_t pixel_i = 0; pixel_i < (size_t)num_pixels; pixel_i++){
+                colored[pixel_i] = segmentation_id_to_rgba(segmentation[pixel_i]);
+            }
+            write_grid_png<SPEC>(device, colored.data(), filename);
+        }
+
+        template <typename SPEC, typename DEVICE>
+        void write_normals_grid_png(DEVICE& device, const float* normals_host, const char* filename){
+            constexpr typename SPEC::TI num_pixels = SPEC::NUM_CAMERAS * SPEC::CAM_PIXELS;
+            std::vector<uint32_t> colored(num_pixels);
+            for(size_t pixel_i = 0; pixel_i < (size_t)num_pixels; pixel_i++){
+                colored[pixel_i] = normal_to_rgba(&normals_host[pixel_i * 3]);
+            }
+            write_grid_png<SPEC>(device, colored.data(), filename);
+        }
+
+        // direction → hue, magnitude → saturation against the per-image maximum. Advisory
+        // review image only (the normalization is content-dependent, like depth.png); the
+        // machine-compared flow target is the float binary.
+        template <typename SPEC, typename DEVICE>
+        void write_flow_grid_png(DEVICE& device, const float* flow_host, const char* filename){
+            constexpr typename SPEC::TI num_pixels = SPEC::NUM_CAMERAS * SPEC::CAM_PIXELS;
+            float max_magnitude = 0;
+            for(size_t pixel_i = 0; pixel_i < (size_t)num_pixels; pixel_i++){
+                const float u = flow_host[pixel_i * 2 + 0];
+                const float v = flow_host[pixel_i * 2 + 1];
+                max_magnitude = std::max(max_magnitude, std::sqrt(u * u + v * v));
+            }
+            std::vector<uint32_t> colored(num_pixels);
+            for(size_t pixel_i = 0; pixel_i < (size_t)num_pixels; pixel_i++){
+                colored[pixel_i] = flow_to_rgba(flow_host[pixel_i * 2 + 0], flow_host[pixel_i * 2 + 1], max_magnitude);
+            }
+            write_grid_png<SPEC>(device, colored.data(), filename);
+        }
+
+        template <typename SPEC, typename DEVICE>
+        void write_flow_status_grid_png(DEVICE& device, const uint32_t* status_host, const char* filename){
+            constexpr typename SPEC::TI num_pixels = SPEC::NUM_CAMERAS * SPEC::CAM_PIXELS;
+            std::vector<uint32_t> colored(num_pixels);
+            for(size_t pixel_i = 0; pixel_i < (size_t)num_pixels; pixel_i++){
+                colored[pixel_i] = flow_status_to_rgba(status_host[pixel_i]);
+            }
+            write_grid_png<SPEC>(device, colored.data(), filename);
+        }
+
+        template <typename SPEC, typename DEVICE>
+        void write_depth_grid_png(DEVICE& device, const float* depth_host, const char* filename){
+            using TI = typename SPEC::TI;
+            constexpr TI cam_pixels = SPEC::CAM_PIXELS;
+            constexpr int grid_width = SPEC::GRID_COLS * SPEC::CAM_WIDTH;
+            constexpr int grid_height = SPEC::GRID_ROWS * SPEC::CAM_HEIGHT;
+            std::vector<uint32_t> grid_image(grid_width * grid_height, 0);
+            constexpr size_t depth_count = (size_t)SPEC::NUM_CAMERAS * SPEC::CAM_PIXELS;
+            float min_valid_depth = std::numeric_limits<float>::max();
+            float max_valid_depth = std::numeric_limits<float>::lowest();
+            for(size_t depth_i = 0; depth_i < depth_count; depth_i++){
+                const float depth = depth_host[depth_i];
+                if(!is_miss(depth) && depth >= 0.f){
+                    min_valid_depth = std::min(min_valid_depth, depth);
+                    max_valid_depth = std::max(max_valid_depth, depth);
+                }
+            }
+            const bool has_valid_depth = min_valid_depth <= max_valid_depth;
+            const float valid_depth_range = has_valid_depth ? max_valid_depth - min_valid_depth : 0.f;
+
+            for(int i = 0; i < (int)SPEC::NUM_CAMERAS; i++){
+                int col = i % SPEC::GRID_COLS;
+                int row = i / SPEC::GRID_COLS;
+                int offset_x = col * SPEC::CAM_WIDTH;
+                int offset_y = row * SPEC::CAM_HEIGHT;
+
+                for(int y = 0; y < (int)SPEC::CAM_HEIGHT; y++){
+                    for(int x = 0; x < (int)SPEC::CAM_WIDTH; x++){
+                        const float depth = depth_host[i * cam_pixels + y * SPEC::CAM_WIDTH + x];
+                        uint8_t value = 0;
+                        if(has_valid_depth && !is_miss(depth) && depth >= 0.f){
+                            const float normalized = fminf(fmaxf((depth - min_valid_depth) / (valid_depth_range + 1e-6f), 0.f), 1.f);
+                            value = static_cast<uint8_t>(normalized * 255.f);
+                        }
+                        grid_image[(offset_y + y) * grid_width + offset_x + x] =
+                            (0xFFu << 24) | (uint32_t(value) << 16) | (uint32_t(value) << 8) | uint32_t(value);
+                    }
+                }
+            }
+
+            stbi_write_png(filename, grid_width, grid_height, 4,
+                           grid_image.data(), grid_width * sizeof(uint32_t));
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "Written depth image (", SPEC::GRID_COLS, "x", SPEC::GRID_ROWS,
+                   " cameras, ", grid_width, "x", grid_height, " px) to ", filename);
+        }
+
+        template <typename SPEC, typename DEVICE>
+        void write_depth_bin(DEVICE& device, const float* depth_host, const char* filename){
+            constexpr size_t depth_count = (size_t)SPEC::NUM_CAMERAS * SPEC::CAM_PIXELS;
+            FILE* f = fopen(filename, "wb");
+            if(f){
+                int nc = SPEC::NUM_CAMERAS;
+                int h = SPEC::CAM_HEIGHT;
+                int w = SPEC::CAM_WIDTH;
+                fwrite(&nc, sizeof(int), 1, f);
+                fwrite(&h, sizeof(int), 1, f);
+                fwrite(&w, sizeof(int), 1, f);
+                fwrite(depth_host, sizeof(float), depth_count, f);
+                fclose(f);
+                log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "Written depth data (", depth_count, " values) to ", filename);
+            }
+        }
+
+        template <typename SPEC, typename DEVICE>
+        void write_probes_bin_and_log(DEVICE& device, const CollisionResult* probe_results, const char* filename){
+            int total_hits = 0;
+            float min_hit_dist = 1e30f, max_hit_dist = 0.f;
+            double sum_hit_dist = 0.0;
+            for(int i = 0; i < (int)(SPEC::NUM_CAMERAS * SPEC::NUM_PROBES); i++){
+                if(probe_results[i].hit){
+                    total_hits++;
+                    sum_hit_dist += probe_results[i].distance;
+                    if(probe_results[i].distance < min_hit_dist){
+                        min_hit_dist = probe_results[i].distance;
+                    }
+                    if(probe_results[i].distance > max_hit_dist){
+                        max_hit_dist = probe_results[i].distance;
+                    }
+                }
+            }
+
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "=== COLLISION PROBE RESULTS ===");
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "  Total probes:  ", SPEC::NUM_CAMERAS * SPEC::NUM_PROBES);
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "  Hits:          ", total_hits,
+                   " (", (100.0 * total_hits / (SPEC::NUM_CAMERAS * SPEC::NUM_PROBES)), "%)");
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "  Misses:        ", (SPEC::NUM_CAMERAS * SPEC::NUM_PROBES - total_hits));
+            if(total_hits > 0){
+                log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "  Min hit dist:  ", min_hit_dist);
+                log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "  Max hit dist:  ", max_hit_dist);
+                log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "  Avg hit dist:  ", (sum_hit_dist / total_hits));
+            }
+            log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "===============================");
+
+            {
+                FILE* f = fopen(filename, "wb");
+                if(f){
+                    int nc = SPEC::NUM_CAMERAS, np = SPEC::NUM_PROBES;
+                    fwrite(&nc, sizeof(int), 1, f);
+                    fwrite(&np, sizeof(int), 1, f);
+                    fwrite(probe_results, sizeof(CollisionResult),
+                           (size_t)SPEC::NUM_CAMERAS * SPEC::NUM_PROBES, f);
+                    fclose(f);
+                    log(device, device.logger, devices::logging::Verbosity::info, rendering::raytracing::LOG_PREFIX, "Written probe data (", SPEC::NUM_CAMERAS * SPEC::NUM_PROBES,
+                           " results) to ", filename);
+                }
+            }
+        }
+
+        template <typename DEVICE, typename SPEC, typename BACKEND, typename TENSOR, typename ELEMENT>
+        void save_staging(DEVICE& device, Renderer<SPEC, BACKEND>& renderer, const TENSOR& tensor, std::vector<ELEMENT>& storage){
+            using TENSOR_SPEC = typename TENSOR::SPEC;
+            static_assert(std::is_same<ELEMENT, typename TENSOR_SPEC::T>::value, "save staging element type must match the tensor element type");
+            storage.resize(TENSOR_SPEC::SIZE);
+            Tensor<tensor::Specification<ELEMENT, typename TENSOR_SPEC::TI, typename TENSOR_SPEC::SHAPE>> staging;
+            staging._data = storage.data();
+            copy(renderer.device, device, tensor, staging);
+        }
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_RGB, "save_image requires an RGB-capable renderer specification");
+        std::vector<uint32_t> frame_buffer_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.frame_buffer, frame_buffer_host);
+        rendering::raytracing::detail::write_grid_png<SPEC>(device, frame_buffer_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_segmentation_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_SEGMENTATION, "save_segmentation_image requires a segmentation-capable renderer specification");
+        std::vector<uint32_t> segmentation_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.segmentation_buffer, segmentation_host);
+        rendering::raytracing::detail::write_segmentation_grid_png<SPEC>(device, segmentation_host.data(), filename);
+        std::ofstream metadata(std::string(filename) + ".json");
+        metadata << "{\"segmentation_mode\":\"" << (SPEC::SEMANTIC_SEGMENTATION ? "semantic" : "instance") << "\",\"background_id\":4294967295}\n";
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_normals_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_NORMALS, "save_normals_image requires a normals-capable renderer specification");
+        std::vector<float> normals_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.normals_buffer, normals_host);
+        rendering::raytracing::detail::write_normals_grid_png<SPEC>(device, normals_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_flow_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_FLOW, "save_flow_image requires a flow-capable renderer specification");
+        std::vector<float> flow_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.flow_buffer, flow_host);
+        rendering::raytracing::detail::write_flow_grid_png<SPEC>(device, flow_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_flow_status_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_FLOW, "save_flow_status_image requires a flow-capable renderer specification");
+        std::vector<uint32_t> status_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.flow_status_buffer, status_host);
+        rendering::raytracing::detail::write_flow_status_grid_png<SPEC>(device, status_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_flow_forward_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_FLOW_FORWARD, "save_flow_forward_image requires a forward-flow renderer specification");
+        std::vector<float> flow_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.flow_forward_buffer, flow_host);
+        rendering::raytracing::detail::write_flow_grid_png<SPEC>(device, flow_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_flow_forward_status_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_FLOW_FORWARD, "save_flow_forward_status_image requires a forward-flow renderer specification");
+        std::vector<uint32_t> status_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.flow_forward_status_buffer, status_host);
+        rendering::raytracing::detail::write_flow_status_grid_png<SPEC>(device, status_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_depth_image(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_DEPTH, "save_depth_image requires a depth-capable renderer specification");
+        std::vector<float> depth_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.depth_buffer, depth_host);
+        rendering::raytracing::detail::write_depth_grid_png<SPEC>(device, depth_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_depth(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+        static_assert(SPEC::HAS_DEPTH, "save_depth requires a depth-capable renderer specification");
+        std::vector<float> depth_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.depth_buffer, depth_host);
+        rendering::raytracing::detail::write_depth_bin<SPEC>(device, depth_host.data(), filename);
+    }
+
+    template <typename DEVICE, typename SPEC, typename BACKEND>
+    void save_probes(DEVICE& device, rendering::raytracing::Renderer<SPEC, BACKEND>& renderer, const char* filename){
+#if RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS
+        (void)device; (void)renderer; (void)filename;
+        log(device, device.logger, devices::logging::Verbosity::warning, rendering::raytracing::LOG_PREFIX, "save_probes skipped: probe rays are disabled.");
+#else
+        std::vector<rendering::raytracing::CollisionResult> collision_results_host;
+        rendering::raytracing::detail::save_staging(device, renderer, renderer.collision_results, collision_results_host);
+        rendering::raytracing::detail::write_probes_bin_and_log<SPEC>(device, collision_results_host.data(), filename);
+#endif
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,44 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_SCENE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_SCENE_H
+
+#include "types.h"
+#include "../scene.h"
+
+#include <cstdint>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace rendering::raytracing{
+        using rendering::Texture;
+        using rendering::Mesh;
+        using rendering::Object;
+        using rendering::ObjectAssembly;
+        using rendering::AssetPool;
+        using rendering::AssetHandle;
+        using rendering::Instance;
+        using rendering::Scene;
+        using rendering::SceneMetadata;
+        using rendering::Bundle;
+
+        struct Placement{
+            size_t first_instance; // parts are placed as consecutive instances
+            size_t num_instances;
+        };
+
+        struct OverlayIndex{
+            size_t index;
+        };
+
+        // returned by spawn: the contiguous slot run holding one instantiated asset
+        struct OverlayPlacement{
+            size_t first_slot;
+            size_t num_parts;
+            size_t first_part; // into the renderer's flattened per-part tables (for rigid moves)
+        };
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,25 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_TRANSFORMS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_TRANSFORMS_GENERIC_H
+
+#include "../../rl_tools.h"
+#include "../transforms.h"
+
+
+// the renderer's internal name for the shared 3x4 transform helpers (host verbs and device kernels)
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace rendering::raytracing::detail{
+        using rendering::compose_transforms;
+        using rendering::transform_is_identity;
+        using rendering::transform_point;
+        using rendering::transform_vector;
+        using rendering::invert_transform;
+        using rendering::quaternion_from_transform;
+        using rendering::rotate_by_quaternion;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,45 @@
+#include "../../version.h"
+#include "../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_TYPES_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_TYPES_H
+
+#include "../types.h"
+#include "../camera.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    // the raytracing namespace consumes the rendering-level content/camera vocabulary under its own name
+    namespace rendering::raytracing{
+        using rendering::SceneLight;
+        using rendering::CollisionResult;
+        using rendering::Camera;
+        using rendering::ShadingOptions;
+        using rendering::Low;
+        using rendering::Medium;
+        using rendering::High;
+        using rendering::VeryHigh;
+        using rendering::degrees_to_radians;
+        namespace vec3 = rendering::vec3;
+
+        // per-pixel flow status, one uint32 next to each flow vector. Priority is the listed
+        // order: the first condition that holds decides. MISS and BEHIND carry a zero vector;
+        // OUT_OF_FRAME and OCCLUDED retain the geometric flow, so the status is the mask.
+        // Cross-backend contract mirrored as literals in the CUDA, GLSL, MSL and WGSL sources.
+        struct FlowStatus{
+            static constexpr unsigned int VALID = 0;
+            static constexpr unsigned int MISS = 1;         // primary ray misses the scene
+            static constexpr unsigned int BEHIND = 2;       // carried point at or behind the other camera
+            static constexpr unsigned int OUT_OF_FRAME = 3; // projects outside the other image; visibility ray skipped
+            static constexpr unsigned int OCCLUDED = 4;     // visibility ray from the other camera hits before the carried point
+        };
+        // relative margin of the flow visibility ray: any hit with t < L * (1 - epsilon) along
+        // the segment from the other camera to the carried point (length L) means occluded.
+        // Shared constant, mirrored in the device sources.
+        template <typename T>
+        constexpr T FLOW_VISIBILITY_EPSILON = (T)1e-4;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/rig/operations_cpu.h

@@ -0,0 +1,119 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RIG_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RIG_OPERATIONS_CPU_H
+
+#include "operations_generic.h"
+#include "../scene.h"
+
+#include <cstdint>
+#include <cstring>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace rendering::rig::detail {
+        // exponent-bit inspection: survives fast-math, which may fold arithmetic finiteness tests
+        template <typename T>
+        bool is_finite(T value){
+            static_assert(sizeof(T) == 4 || sizeof(T) == 8, "is_finite expects an IEEE-754 single or double");
+            using BITS = utils::typing::conditional_t<sizeof(T) == 4, uint32_t, uint64_t>;
+            BITS bits;
+            std::memcpy(&bits, &value, sizeof(bits));
+            constexpr BITS EXPONENT = sizeof(T) == 4 ? (BITS)0x7f800000u : (BITS)0x7ff0000000000000ull;
+            return (bits & EXPONENT) != EXPONENT;
+        }
+        template <typename T>
+        bool is_finite(const T* values, unsigned count){
+            for(unsigned i = 0; i < count; i++){
+                if(!is_finite(values[i])){
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    // validates the declaration (parents before children, finite frames, nonzero axes),
+    // normalizes the axes and assigns the coordinate offsets
+    template <typename DEVICE, typename SPEC>
+    bool init(DEVICE& device, rendering::rig::Model<SPEC>& model){
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        using Joint = rendering::rig::Joint;
+        if(model.num_links == 0 || model.num_links > SPEC::MAX_LINKS || model.num_parts > SPEC::MAX_PARTS){
+            return false;
+        }
+        model.num_coordinates = 0;
+        for(TI link_i = 0; link_i < model.num_links; link_i++){
+            auto& link = model.links[link_i];
+            if((link.parent != SPEC::BASE && link.parent >= link_i) || !rendering::rig::detail::is_finite(link.origin, 12)){
+                return false;
+            }
+            link.coordinate = model.num_coordinates;
+            if(link.joint == Joint::FIXED){
+                continue;
+            }
+            if(link.joint == Joint::SPHERICAL){
+                model.num_coordinates += 4;
+                continue;
+            }
+            if(link.joint != Joint::REVOLUTE && link.joint != Joint::PRISMATIC){
+                return false;
+            }
+            const T norm = math::sqrt(device.math, link.axis[0]*link.axis[0] + link.axis[1]*link.axis[1] + link.axis[2]*link.axis[2]);
+            if(!rendering::rig::detail::is_finite(norm) || norm <= 0){
+                return false;
+            }
+            for(auto& component : link.axis){
+                component /= norm;
+            }
+            model.num_coordinates += 1;
+        }
+        for(TI part_i = 0; part_i < model.num_parts; part_i++){
+            const auto& part = model.parts[part_i];
+            if(part.link >= model.num_links || !rendering::rig::detail::is_finite(part.offset, 12)){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // one fixed link per assembly part at the part's rest frame (relative to its parent part when
+    // the loader recorded one): evaluated at the default coordinates it reproduces the placement
+    // set_transform renders; joints are declared by editing the links afterwards
+    template <typename DEVICE, typename SPEC>
+    bool init(DEVICE& device, rendering::rig::Model<SPEC>& model, const rendering::ObjectAssembly& assembly){
+        using TI = typename SPEC::TI;
+        if(assembly.parts.size() > SPEC::MAX_LINKS || assembly.parts.size() > SPEC::MAX_PARTS){
+            return false;
+        }
+        model.num_links = (TI)assembly.parts.size();
+        model.num_parts = (TI)assembly.parts.size();
+        for(TI part_i = 0; part_i < model.num_parts; part_i++){
+            const auto& part = assembly.parts[part_i];
+            model.links[part_i] = rendering::rig::Link<SPEC>{};
+            model.parts[part_i] = rendering::rig::Part<SPEC>{};
+            model.parts[part_i].link = part_i;
+            float origin[12];
+            if(part.parent == rendering::ObjectAssembly::Part::NO_PARENT){
+                std::memcpy(origin, part.transform, sizeof(origin));
+            }
+            else{
+                if(part.parent >= part_i){
+                    return false;
+                }
+                model.links[part_i].parent = (TI)part.parent;
+                float parent_inverse[12];
+                rendering::invert_transform(assembly.parts[part.parent].transform, parent_inverse);
+                rendering::compose_transforms(parent_inverse, part.transform, origin);
+            }
+            for(unsigned element = 0; element < 12; element++){
+                model.links[part_i].origin[element] = origin[element];
+            }
+        }
+        return init(device, model);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif