hyperverse 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,121 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RIG_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RIG_OPERATIONS_GENERIC_H
+
+#include "rig.h"
+#include "../transforms.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace rendering::rig {
+        template <typename DEVICE, typename SPEC>
+        RL_TOOLS_FUNCTION_PLACEMENT void joint_transform(DEVICE& device, const Link<SPEC>& link, const typename SPEC::T* coordinates, typename SPEC::T out[12]){
+            using T = typename SPEC::T;
+            for(unsigned element = 0; element < 12; element++){
+                out[element] = element % 5 == 0 ? (T)1 : (T)0;
+            }
+            if(link.joint == Joint::FIXED){
+                return;
+            }
+            const T* q = coordinates + link.coordinate;
+            if(link.joint == Joint::PRISMATIC){
+                for(unsigned axis = 0; axis < 3; axis++){
+                    out[axis * 4 + 3] = link.axis[axis] * q[0];
+                }
+            }
+            else if(link.joint == Joint::SPHERICAL){
+                const T norm = math::sqrt(device.math, q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
+                const T w = q[0] / norm, x = q[1] / norm, y = q[2] / norm, z = q[3] / norm;
+                out[0] = 1 - 2*(y*y + z*z); out[1] = 2*(x*y - w*z);     out[2]  = 2*(x*z + w*y);
+                out[4] = 2*(x*y + w*z);     out[5] = 1 - 2*(x*x + z*z); out[6]  = 2*(y*z - w*x);
+                out[8] = 2*(x*z - w*y);     out[9] = 2*(y*z + w*x);     out[10] = 1 - 2*(x*x + y*y);
+            }
+            else{
+                const T c = math::cos(device.math, q[0]);
+                const T s = math::sin(device.math, q[0]);
+                const T v = (T)1 - c;
+                const T x = link.axis[0], y = link.axis[1], z = link.axis[2];
+                out[0] = c + x*x*v;   out[1] = x*y*v - z*s; out[2]  = x*z*v + y*s;
+                out[4] = y*x*v + z*s; out[5] = c + y*y*v;   out[6]  = y*z*v - x*s;
+                out[8] = z*x*v - y*s; out[9] = z*y*v + x*s; out[10] = c + z*z*v;
+            }
+        }
+    }
+
+    // poses: num_parts geometry-to-world transforms, 12 values each, in part order
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void evaluate(DEVICE& device, const rendering::rig::Model<SPEC>& model, const typename SPEC::T base[12], const typename SPEC::T* coordinates, rendering::rig::Buffer<SPEC>& buffer, typename SPEC::T* poses){
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        for(TI link_i = 0; link_i < model.num_links; link_i++){
+            const auto& link = model.links[link_i];
+            const T* parent = link.parent == SPEC::BASE ? base : buffer.link_poses[link.parent];
+            T joint[12], frame[12];
+            rendering::rig::joint_transform(device, link, coordinates, joint);
+            rendering::compose_transforms(parent, link.origin, frame);
+            rendering::compose_transforms(frame, joint, buffer.link_poses[link_i]);
+        }
+        for(TI part_i = 0; part_i < model.num_parts; part_i++){
+            const auto& part = model.parts[part_i];
+            rendering::compose_transforms(buffer.link_poses[part.link], part.offset, poses + part_i * 12);
+        }
+    }
+
+    // coordinates between two states at t: scalar joints lerp (a revolute joint keeps every
+    // revolution between the states), spherical joints slerp along the shorter arc
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void interpolate(DEVICE& device, const rendering::rig::Model<SPEC>& model, const typename SPEC::T* open, const typename SPEC::T* close, typename SPEC::T t, typename SPEC::T* out){
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        for(TI coordinate = 0; coordinate < model.num_coordinates; coordinate++){
+            out[coordinate] = open[coordinate] + t * (close[coordinate] - open[coordinate]);
+        }
+        for(TI link_i = 0; link_i < model.num_links; link_i++){
+            const auto& link = model.links[link_i];
+            if(link.joint != rendering::rig::Joint::SPHERICAL){
+                continue;
+            }
+            const T* a = open + link.coordinate;
+            const T* b = close + link.coordinate;
+            const T norm_a = math::sqrt(device.math, a[0]*a[0] + a[1]*a[1] + a[2]*a[2] + a[3]*a[3]);
+            const T norm_b = math::sqrt(device.math, b[0]*b[0] + b[1]*b[1] + b[2]*b[2] + b[3]*b[3]);
+            T cosine = (a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]) / (norm_a * norm_b);
+            const T sign = cosine < 0 ? (T)-1 : (T)1;
+            cosine *= sign;
+            T weight_a = (T)1 - t;
+            T weight_b = t;
+            if(cosine < (T)0.9995){
+                const T angle = math::acos(device.math, cosine);
+                const T sine = math::sin(device.math, angle);
+                weight_a = math::sin(device.math, ((T)1 - t) * angle) / sine;
+                weight_b = math::sin(device.math, t * angle) / sine;
+            }
+            for(unsigned component = 0; component < 4; component++){
+                out[link.coordinate + component] = weight_a * a[component] / norm_a + weight_b * sign * b[component] / norm_b;
+            }
+        }
+    }
+
+    // num_samples poses per part at the shutter times (sample + 0.5) / num_samples, sample s at
+    // samples + s * sample_stride (12 values per part), plus the poses at t = 1 in close; the
+    // base follows the constant-twist screw between base_open and base_close, the coordinates
+    // interpolate before the kinematics
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void sample(DEVICE& device, const rendering::rig::Model<SPEC>& model, const typename SPEC::T base_open[12], const typename SPEC::T base_close[12], const typename SPEC::T* coordinates_open, const typename SPEC::T* coordinates_close, typename SPEC::TI num_samples, rendering::rig::Buffer<SPEC>& buffer, typename SPEC::T* samples, typename SPEC::TI sample_stride, typename SPEC::T* close){
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        static_assert(utils::typing::is_same_v<T, float>, "rig::sample interpolates the base with the float transform helpers");
+        for(TI sample_i = 0; sample_i < num_samples; sample_i++){
+            const T t = ((T)sample_i + (T)0.5) / (T)num_samples;
+            T base[12];
+            rendering::screw_interpolate(base_open, base_close, t, base);
+            interpolate(device, model, coordinates_open, coordinates_close, t, buffer.coordinates);
+            evaluate(device, model, base, buffer.coordinates, buffer, samples + sample_i * sample_stride);
+        }
+        evaluate(device, model, base_close, coordinates_close, buffer, close);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,70 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RIG_RIG_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RIG_RIG_H
+
+#include "../../rl_tools.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::rig {
+    enum class Joint { FIXED, REVOLUTE, PRISMATIC, SPHERICAL };
+
+    // Rigid-link tree over 3x4 row-major [R|t] transforms, links declared parent before child:
+    // world_link = world_parent ∘ origin ∘ joint(coordinates), world_geometry = world_link ∘ offset.
+    // Fixed capacity keeps the model a plain value, so a kernel parameter, a copied payload and a
+    // host object are one type. Revolute and prismatic joints take one coordinate (radians,
+    // metres) about/along the unit axis in the joint frame, spherical joints a wxyz quaternion.
+    template <typename T_T, typename T_TI, T_TI T_MAX_LINKS, T_TI T_MAX_PARTS>
+    struct Specification {
+        using T = T_T;
+        using TI = T_TI;
+        static constexpr TI MAX_LINKS = T_MAX_LINKS;
+        static constexpr TI MAX_PARTS = T_MAX_PARTS;
+        static constexpr TI MAX_COORDINATES = 4 * MAX_LINKS;
+        static constexpr TI BASE = ~(TI)0; // parent of a root link
+    };
+
+    template <typename T_SPEC>
+    struct Link {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        TI parent = SPEC::BASE;
+        Joint joint = Joint::FIXED;
+        T axis[3] = {0, 0, 1};
+        T origin[12] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0}; // parent link frame -> joint frame
+        TI coordinate = 0;                                   // first coordinate, assigned by init
+    };
+
+    template <typename T_SPEC>
+    struct Part {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        TI link = 0;
+        T offset[12] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0}; // link frame -> geometry frame
+    };
+
+    template <typename T_SPEC>
+    struct Model {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        Link<SPEC> links[SPEC::MAX_LINKS];
+        Part<SPEC> parts[SPEC::MAX_PARTS];
+        TI num_links = 0;
+        TI num_parts = 0;
+        TI num_coordinates = 0;
+    };
+
+    template <typename T_SPEC>
+    struct Buffer {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        T link_poses[SPEC::MAX_LINKS][12];
+        T coordinates[SPEC::MAX_COORDINATES];
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,134 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_SCENE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_SCENE_H
+
+#include "types.h"
+
+#include <vector>
+#include <string>
+#include <cstdint>
+#include <map>
+#include <memory>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace rendering{
+        struct Texture{
+            std::vector<uint8_t> pixels; // RGBA8
+            int width = 0;
+            int height = 0;
+            bool present() const {
+                return !pixels.empty() && width > 0 && height > 0;
+            }
+        };
+
+        struct Mesh{
+            std::vector<float> vertices; // vec3f flat
+            std::vector<int> indices;    // vec3i flat
+            std::vector<float> tex_coords; // vec2f flat
+            std::vector<float> normals;
+            float color[3];
+            Texture texture;
+            Texture normal_map;
+            Texture metallic_roughness_map;
+            Texture emissive_map;
+            Texture occlusion_map;
+            float metallic = 0.0f;
+            float roughness = 1.0f;
+            float emissive[3] = {0, 0, 0};
+            float opacity = 1.0f;
+            int alpha_mode = 0;
+            float alpha_cutoff = 0.5f;
+            bool unlit = false;
+        };
+
+        struct SegmentationTaxonomy{
+            std::string name;
+            std::map<uint32_t, std::string> classes;
+        };
+
+        struct Object{
+            std::vector<Mesh> meshes;
+            std::vector<SceneLight> lights; // object-local frame; transformed by the instance placing the object
+            uint32_t segmentation_class = 0;
+            std::shared_ptr<const SegmentationTaxonomy> segmentation_taxonomy;
+            bool segmentation_class_valid = true; // false when welding erased class boundaries
+            std::string name; // the glTF root node's name for assembly parts; empty otherwise
+        };
+
+        // Load product of a split GLB: one part per selected glTF node (the scene roots by
+        // default), each an Object in the node's local frame plus the node's placement within the
+        // assembly frame. The part list stays flat (the Scene is a flat instance list); a part
+        // whose node sits inside another selected node records that part as its parent, which is
+        // what rig::init turns into a joint origin.
+        struct ObjectAssembly{
+            struct Part{
+                static constexpr size_t NO_PARENT = ~(size_t)0;
+                size_t object;       // index into ObjectAssembly::objects
+                float transform[12]; // part frame relative to the assembly frame, 3x4 row-major [R|t]
+                size_t parent = NO_PARENT;
+            };
+            std::vector<Object> objects;
+            std::vector<Part> parts;
+        };
+
+        // Assets available to dynamic overlays: registered before init (BLASes built once, frozen
+        // after), instantiated per step via spawn. Must outlive rendering, like Scene; a boundary
+        // that outlives its caller (e.g. language bindings) must own copies of both.
+        struct AssetPool{
+            std::vector<ObjectAssembly> assemblies;
+        };
+        struct AssetHandle{
+            size_t index;
+        };
+
+        struct Instance{
+            size_t object;        // index into Scene::objects
+            float transform[12];  // object→world, 3x4 row-major [R|t]
+            bool identity;
+        };
+
+        // Host-side truth about what is rendered; produced by the datasets layer, consumed by the
+        // renderer. The scene must stay alive while the renderer uses it: the generic backend
+        // renders directly from the mesh memory owned here.
+        struct Scene{
+            // background + ambient as content: filled by dataset loaders (or authored), resolved
+            // by the renderer at init. DEFAULT keeps the backend's historical behavior; GRADIENT
+            // and EQUIRECT are declared for datasets to carry — backends that cannot render them
+            // yet fall back to a solid horizon background.
+            struct Environment{
+                enum class Mode { DEFAULT, SOLID, GRADIENT, EQUIRECT };
+                Mode mode = Mode::DEFAULT;
+                float horizon[3] = {0, 0, 0};  // SOLID: the background; GRADIENT: horizon endpoint
+                float zenith[3] = {0, 0, 0};   // GRADIENT: zenith endpoint
+                float ambient[3] = {0.10f, 0.10f, 0.10f};
+                Texture equirect;              // EQUIRECT panorama; not yet consumed by the backends
+            };
+            std::vector<Object> objects;
+            std::vector<Instance> instances;
+            std::vector<SceneLight> lights;
+            Environment environment;
+        };
+
+        // loader-authoritative scene facts: the renderer consumes max_ray_length (probe budget,
+        // depth miss sentinel), producers consume the bounds (camera rigs, free-space search),
+        // and content_hash (SHA-1 hex, the conta identity) keys AssetLibrary deduplication
+        template <typename T>
+        struct SceneMetadata{
+            T center[3] = {0, 0, 0};
+            T half_extent[3] = {0, 0, 0};
+            T max_ray_length = 0;
+            std::string content_hash;
+        };
+
+        template <typename T>
+        struct Bundle{
+            Scene scene;
+            SceneMetadata<T> metadata;
+        };
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/segmentation_cpu.h

@@ -0,0 +1,145 @@
+#include "../version.h"
+#include "../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_SEGMENTATION_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_SEGMENTATION_CPU_H
+
+#include "scene.h"
+#include <stdexcept>
+#include <type_traits>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template <typename DEVICE, typename CONTAINER>
+    auto segmentation_objects(DEVICE&, CONTAINER& container){
+        using Object = std::conditional_t<std::is_const_v<CONTAINER>, const rendering::Object, rendering::Object>;
+        std::vector<Object*> objects;
+        if constexpr(std::is_same_v<std::remove_const_t<CONTAINER>, rendering::Object>){
+            objects.push_back(&container);
+        }
+        else if constexpr(std::is_same_v<std::remove_const_t<CONTAINER>, rendering::AssetPool>){
+            for(auto& assembly : container.assemblies){
+                for(auto& object : assembly.objects){
+                    objects.push_back(&object);
+                }
+            }
+        }
+        else{
+            for(auto& object : container.objects){
+                objects.push_back(&object);
+            }
+        }
+        return objects;
+    }
+
+    template <typename DEVICE>
+    void validate_segmentation_taxonomy(DEVICE&, const rendering::SegmentationTaxonomy& taxonomy){
+        if(taxonomy.name.empty() || !taxonomy.classes.count(0)){
+            throw std::invalid_argument("semantic segmentation: taxonomy must have a name and class 0");
+        }
+        for(const auto& entry : taxonomy.classes){
+            if(entry.first == 0xFFFFFFFFu || entry.second.empty()){
+                throw std::invalid_argument("semantic segmentation: invalid taxonomy class");
+            }
+        }
+    }
+
+    template <typename DEVICE, typename OBJECT>
+    std::shared_ptr<const rendering::SegmentationTaxonomy> segmentation_taxonomy(DEVICE& device, const std::vector<OBJECT*>& objects){
+        std::shared_ptr<const rendering::SegmentationTaxonomy> taxonomy;
+        for(const auto* object : objects){
+            const auto& candidate = object->segmentation_taxonomy;
+            if(candidate){
+                if(candidate != taxonomy){
+                    validate_segmentation_taxonomy(device, *candidate);
+                    if(taxonomy && (candidate->name != taxonomy->name || candidate->classes != taxonomy->classes)){
+                        throw std::invalid_argument("semantic segmentation: incompatible taxonomies; remap classes before composition");
+                    }
+                }
+                taxonomy = candidate;
+            }
+        }
+        return taxonomy;
+    }
+
+    template <typename DEVICE, typename CONTAINER>
+    std::shared_ptr<const rendering::SegmentationTaxonomy> segmentation_taxonomy(DEVICE& device, const CONTAINER& container){
+        return segmentation_taxonomy(device, segmentation_objects(device, container));
+    }
+
+    template <typename DEVICE>
+    void validate_segmentation_class(DEVICE&, uint32_t id, const std::shared_ptr<const rendering::SegmentationTaxonomy>& taxonomy){
+        if(id == 0xFFFFFFFFu || (taxonomy && !taxonomy->classes.count(id))){
+            throw std::invalid_argument("semantic segmentation: class ID is reserved or absent from the taxonomy");
+        }
+    }
+
+    template <typename DEVICE, typename OBJECT>
+    void validate_semantic_segmentation(DEVICE& device, const std::vector<OBJECT*>& objects){
+        const auto taxonomy = segmentation_taxonomy(device, objects);
+        for(const auto* object : objects){
+            if(!object->segmentation_class_valid){
+                throw std::invalid_argument("semantic segmentation: welded classes; load with SceneRoots (Python: preserve_instances=True) or explicitly assign one class");
+            }
+            validate_segmentation_class(device, object->segmentation_class, taxonomy);
+        }
+    }
+
+    template <typename DEVICE>
+    void validate_semantic_segmentation(DEVICE& device, const rendering::Scene& scene, const rendering::AssetPool& pool){
+        auto objects = segmentation_objects(device, scene);
+        const auto pool_objects = segmentation_objects(device, pool);
+        objects.insert(objects.end(), pool_objects.begin(), pool_objects.end());
+        validate_semantic_segmentation(device, objects);
+    }
+
+    template <typename DEVICE>
+    void assign_segmentation_class(DEVICE& device, rendering::Object& object, uint32_t id, std::shared_ptr<const rendering::SegmentationTaxonomy> taxonomy){
+        if(taxonomy){
+            validate_segmentation_taxonomy(device, *taxonomy);
+        }
+        validate_segmentation_class(device, id, taxonomy);
+        object.segmentation_class = id;
+        object.segmentation_taxonomy = std::move(taxonomy);
+        object.segmentation_class_valid = true;
+    }
+
+    template <typename DEVICE>
+    void assign_segmentation_class(DEVICE& device, rendering::Object& object, uint32_t id){
+        assign_segmentation_class(device, object, id, object.segmentation_taxonomy);
+    }
+
+    template <typename DEVICE, typename CONTAINER>
+    void assign_segmentation_class(DEVICE& device, CONTAINER& container, size_t object_index, uint32_t id){
+        assign_segmentation_class(device, container.objects.at(object_index), id, segmentation_taxonomy(device, container));
+    }
+
+    template <typename DEVICE>
+    void assign_segmentation_class(DEVICE& device, rendering::AssetPool& pool, size_t asset_index, size_t object_index, uint32_t id){
+        assign_segmentation_class(device, pool.assemblies.at(asset_index).objects.at(object_index), id, segmentation_taxonomy(device, pool));
+    }
+
+    // Complete remaps are transactional; assigning one class is the explicit way to replace
+    // boundaries lost by welding. A null target taxonomy selects unnamed numeric classes.
+    template <typename DEVICE, typename CONTAINER>
+    void remap_segmentation_classes(DEVICE& device, CONTAINER& container, const std::map<uint32_t, uint32_t>& mapping, std::shared_ptr<const rendering::SegmentationTaxonomy> taxonomy){
+        auto objects = segmentation_objects(device, container);
+        validate_semantic_segmentation(device, objects);
+        if(taxonomy){
+            validate_segmentation_taxonomy(device, *taxonomy);
+        }
+        for(const auto* object : objects){
+            const auto entry = mapping.find(object->segmentation_class);
+            if(entry == mapping.end()){
+                throw std::invalid_argument("semantic segmentation: incomplete class remapping");
+            }
+            validate_segmentation_class(device, entry->second, taxonomy);
+        }
+        for(auto* object : objects){
+            object->segmentation_class = mapping.at(object->segmentation_class);
+            object->segmentation_taxonomy = taxonomy;
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/transforms.h

@@ -0,0 +1,204 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_TRANSFORMS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_TRANSFORMS_H
+
+#include "../rl_tools.h"
+
+#include <math.h>
+
+
+// freestanding 3x4 row-major [R|t] transform math on the content model, shared by the datasets
+// layer (bounds, instance welding), the rig (forward kinematics) and the renderer (uploads,
+// device producers; CUDA kernels define RL_TOOLS_FUNCTION_PLACEMENT before including this header)
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace rendering{
+        template <typename T>
+        RL_TOOLS_FUNCTION_PLACEMENT void compose_transforms(const T a[12], const T b[12], T out[12]){
+            for(int row = 0; row < 3; row++){
+                for(int column = 0; column < 3; column++){
+                    out[row * 4 + column] = a[row * 4] * b[column] + a[row * 4 + 1] * b[4 + column] + a[row * 4 + 2] * b[8 + column];
+                }
+                out[row * 4 + 3] = a[row * 4] * b[3] + a[row * 4 + 1] * b[7] + a[row * 4 + 2] * b[11] + a[row * 4 + 3];
+            }
+        }
+
+        RL_TOOLS_FUNCTION_PLACEMENT inline bool transform_is_identity(const float transform[12]){
+            const float identity[12] = {1,0,0,0, 0,1,0,0, 0,0,1,0};
+            for(int element = 0; element < 12; element++){
+                if(transform[element] != identity[element]){
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        RL_TOOLS_FUNCTION_PLACEMENT inline void transform_point(const float transform[12], const float point[3], float out[3]){
+            for(int row = 0; row < 3; row++){
+                out[row] = transform[row * 4 + 0] * point[0] + transform[row * 4 + 1] * point[1] + transform[row * 4 + 2] * point[2] + transform[row * 4 + 3];
+            }
+        }
+
+        RL_TOOLS_FUNCTION_PLACEMENT inline void transform_vector(const float transform[12], const float vector[3], float out[3]){
+            for(int row = 0; row < 3; row++){
+                out[row] = transform[row * 4 + 0] * vector[0] + transform[row * 4 + 1] * vector[1] + transform[row * 4 + 2] * vector[2];
+            }
+        }
+
+        RL_TOOLS_FUNCTION_PLACEMENT inline void invert_transform(const float transform[12], float out[12]){
+            const float a = transform[0], b = transform[1], c = transform[2];
+            const float d = transform[4], e = transform[5], f = transform[6];
+            const float g = transform[8], h = transform[9], i = transform[10];
+            const float cofactor_a = e*i - f*h;
+            const float cofactor_b = f*g - d*i;
+            const float cofactor_c = d*h - e*g;
+            const float inv_det = 1.0f / (a*cofactor_a + b*cofactor_b + c*cofactor_c);
+            out[0] = cofactor_a * inv_det; out[1] = (c*h - b*i) * inv_det; out[2]  = (b*f - c*e) * inv_det;
+            out[4] = cofactor_b * inv_det; out[5] = (a*i - c*g) * inv_det; out[6]  = (c*d - a*f) * inv_det;
+            out[8] = cofactor_c * inv_det; out[9] = (b*g - a*h) * inv_det; out[10] = (a*e - b*d) * inv_det;
+            out[3]  = -(out[0]*transform[3] + out[1]*transform[7] + out[2] *transform[11]);
+            out[7]  = -(out[4]*transform[3] + out[5]*transform[7] + out[6] *transform[11]);
+            out[11] = -(out[8]*transform[3] + out[9]*transform[7] + out[10]*transform[11]);
+        }
+
+        RL_TOOLS_FUNCTION_PLACEMENT inline void quaternion_from_transform(const float m[12], float q[4]){
+            const float trace = m[0] + m[5] + m[10];
+            if(trace > 0){
+                const float s = sqrtf(trace + 1.0f) * 2;
+                q[0] = 0.25f * s;
+                q[1] = (m[9] - m[6]) / s;
+                q[2] = (m[2] - m[8]) / s;
+                q[3] = (m[4] - m[1]) / s;
+            }
+            else if(m[0] > m[5] && m[0] > m[10]){
+                const float s = sqrtf(1.0f + m[0] - m[5] - m[10]) * 2;
+                q[0] = (m[9] - m[6]) / s;
+                q[1] = 0.25f * s;
+                q[2] = (m[1] + m[4]) / s;
+                q[3] = (m[2] + m[8]) / s;
+            }
+            else if(m[5] > m[10]){
+                const float s = sqrtf(1.0f + m[5] - m[0] - m[10]) * 2;
+                q[0] = (m[2] - m[8]) / s;
+                q[1] = (m[1] + m[4]) / s;
+                q[2] = 0.25f * s;
+                q[3] = (m[6] + m[9]) / s;
+            }
+            else{
+                const float s = sqrtf(1.0f + m[10] - m[0] - m[5]) * 2;
+                q[0] = (m[4] - m[1]) / s;
+                q[1] = (m[2] + m[8]) / s;
+                q[2] = (m[6] + m[9]) / s;
+                q[3] = 0.25f * s;
+            }
+        }
+
+        RL_TOOLS_FUNCTION_PLACEMENT inline void rotate_by_quaternion(const float q[4], const float v[3], float out[3]){
+            const float w = q[0], x = q[1], y = q[2], z = q[3];
+            const float ux = y*v[2] - z*v[1], uy = z*v[0] - x*v[2], uz = x*v[1] - y*v[0];
+            const float uux = y*uz - z*uy, uuy = z*ux - x*uz, uuz = x*uy - y*ux;
+            out[0] = v[0] + 2*(w*ux + uux);
+            out[1] = v[1] + 2*(w*uy + uuy);
+            out[2] = v[2] + 2*(w*uz + uuz);
+        }
+
+        // constant-twist (screw motion) interpolation between two rigid 3x4 transforms: the
+        // rotation follows the shortest-arc slerp path and the translation follows the screw of
+        // the relative motion, so a fixed rotation axis line stays fixed — a translation lerp
+        // instead would cut the chord and displace an off-origin pivot (e.g. a spinning prop hub)
+        // at mid-shutter samples. The single interpolant behind set_transform_pair and the rig's
+        // base motion, so every consumer derives identical per-sample matrices from the same
+        // shutter pair. Exact for constant-velocity rigid motion below 180 degrees per shutter
+        // interval — faster motion must supply per-sample transforms directly.
+        RL_TOOLS_FUNCTION_PLACEMENT inline void screw_interpolate(const float a[12], const float b[12], float t, float out[12]){
+            float qa[4], qb[4];
+            quaternion_from_transform(a, qa);
+            quaternion_from_transform(b, qb);
+            float relative[4] = {
+                 qb[0]*qa[0] + qb[1]*qa[1] + qb[2]*qa[2] + qb[3]*qa[3],
+                -qb[0]*qa[1] + qb[1]*qa[0] - qb[2]*qa[3] + qb[3]*qa[2],
+                -qb[0]*qa[2] + qb[1]*qa[3] + qb[2]*qa[0] - qb[3]*qa[1],
+                -qb[0]*qa[3] - qb[1]*qa[2] + qb[2]*qa[1] + qb[3]*qa[0]
+            };
+            if(relative[0] < 0){
+                for(int i = 0; i < 4; i++){
+                    relative[i] = -relative[i];
+                }
+            }
+            {
+                const float norm = sqrtf(relative[0]*relative[0] + relative[1]*relative[1] + relative[2]*relative[2] + relative[3]*relative[3]);
+                for(int i = 0; i < 4; i++){
+                    relative[i] /= norm;
+                }
+            }
+            const float sin_half_angle = sqrtf(relative[1]*relative[1] + relative[2]*relative[2] + relative[3]*relative[3]);
+            const float translation_a[3] = {a[3], a[7], a[11]};
+            float translation_a_relative[3];
+            rotate_by_quaternion(relative, translation_a, translation_a_relative);
+            const float displacement[3] = {b[3] - translation_a_relative[0], b[7] - translation_a_relative[1], b[11] - translation_a_relative[2]};
+            float relative_t[4];
+            float translation_relative_t[3];
+            if(sin_half_angle > 1e-3f){
+                const float half_angle = atan2f(sin_half_angle, relative[0]);
+                const float axis[3] = {relative[1] / sin_half_angle, relative[2] / sin_half_angle, relative[3] / sin_half_angle};
+                const float sin_t_half = sinf(t * half_angle);
+                relative_t[0] = cosf(t * half_angle);
+                relative_t[1] = axis[0] * sin_t_half;
+                relative_t[2] = axis[1] * sin_t_half;
+                relative_t[3] = axis[2] * sin_t_half;
+                const float displacement_along_axis = displacement[0]*axis[0] + displacement[1]*axis[1] + displacement[2]*axis[2];
+                const float perpendicular[3] = {displacement[0] - displacement_along_axis*axis[0], displacement[1] - displacement_along_axis*axis[1], displacement[2] - displacement_along_axis*axis[2]};
+                const float axis_cross_perpendicular[3] = {
+                    axis[1]*perpendicular[2] - axis[2]*perpendicular[1],
+                    axis[2]*perpendicular[0] - axis[0]*perpendicular[2],
+                    axis[0]*perpendicular[1] - axis[1]*perpendicular[0]
+                };
+                const float cot_half_angle = relative[0] / sin_half_angle;
+                float center[3], center_rotated[3];
+                for(int i = 0; i < 3; i++){
+                    center[i] = 0.5f * (perpendicular[i] + cot_half_angle * axis_cross_perpendicular[i]);
+                }
+                rotate_by_quaternion(relative_t, center, center_rotated);
+                for(int i = 0; i < 3; i++){
+                    translation_relative_t[i] = center[i] - center_rotated[i] + t * displacement_along_axis * axis[i];
+                }
+            }
+            else{
+                relative_t[0] = 1 + t * (relative[0] - 1);
+                relative_t[1] = t * relative[1];
+                relative_t[2] = t * relative[2];
+                relative_t[3] = t * relative[3];
+                const float norm = sqrtf(relative_t[0]*relative_t[0] + relative_t[1]*relative_t[1] + relative_t[2]*relative_t[2] + relative_t[3]*relative_t[3]);
+                for(int i = 0; i < 4; i++){
+                    relative_t[i] /= norm;
+                }
+                for(int i = 0; i < 3; i++){
+                    translation_relative_t[i] = t * displacement[i];
+                }
+            }
+            float q[4] = {
+                relative_t[0]*qa[0] - relative_t[1]*qa[1] - relative_t[2]*qa[2] - relative_t[3]*qa[3],
+                relative_t[0]*qa[1] + relative_t[1]*qa[0] + relative_t[2]*qa[3] - relative_t[3]*qa[2],
+                relative_t[0]*qa[2] - relative_t[1]*qa[3] + relative_t[2]*qa[0] + relative_t[3]*qa[1],
+                relative_t[0]*qa[3] + relative_t[1]*qa[2] - relative_t[2]*qa[1] + relative_t[3]*qa[0]
+            };
+            const float norm = sqrtf(q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
+            for(int i = 0; i < 4; i++){
+                q[i] /= norm;
+            }
+            const float w = q[0], x = q[1], y = q[2], z = q[3];
+            out[0] = 1 - 2*(y*y + z*z); out[1] = 2*(x*y - w*z);     out[2]  = 2*(x*z + w*y);
+            out[4] = 2*(x*y + w*z);     out[5] = 1 - 2*(x*x + z*z); out[6]  = 2*(y*z - w*x);
+            out[8] = 2*(x*z - w*y);     out[9] = 2*(y*z + w*x);     out[10] = 1 - 2*(x*x + y*y);
+            float translation_a_rotated[3];
+            rotate_by_quaternion(relative_t, translation_a, translation_a_rotated);
+            out[3]  = translation_a_rotated[0] + translation_relative_t[0];
+            out[7]  = translation_a_rotated[1] + translation_relative_t[1];
+            out[11] = translation_a_rotated[2] + translation_relative_t[2];
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif