hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/backends/webgpu/bvh_sah.h

@@ -0,0 +1,182 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_WEBGPU_BVH_SAH_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_WEBGPU_BVH_SAH_H
+
+// Deterministic binned-SAH BVH builder: 16 bins on the largest centroid axis, stable
+// order-preserving partition (fixed bin count, min/max-only bounds accumulation — no
+// order-dependent float sums), drop-in signature-compatible with generic::build_bvh_nodes.
+// The generic median-split builder remains the baseline (RL_TOOLS_WEBGPU_BVH=median) and is
+// still used for the per-frame overlay TLAS rebuilds.
+#include "../generic/operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::backends::webgpu{
+    namespace sah{
+        template <typename TI> constexpr TI NUM_BINS = 16;
+        template <typename TI> constexpr TI MAX_LEAF_SIZE = 4;
+
+        template <typename T>
+        T half_area(const T bounds_min[3], const T bounds_max[3]){
+            const T dx = bounds_max[0] - bounds_min[0];
+            const T dy = bounds_max[1] - bounds_min[1];
+            const T dz = bounds_max[2] - bounds_min[2];
+            return dx * dy + dy * dz + dz * dx;
+        }
+    }
+
+    template <typename T, typename TI>
+    TI build_bvh_nodes_sah(generic::BVHNode<T, TI>* nodes, TI* primitives, TI* temp_primitives, const T* primitive_bounds_min, const T* primitive_bounds_max, const T* centroids, TI count){
+        namespace constants = generic::constants;
+        if(count == 0){
+            return 0;
+        }
+        TI node_count = 1;
+        generic::BVHBuildEntry<TI> stack[constants::BUILD_STACK_SIZE<TI>];
+        TI stack_pointer = 0;
+        stack[stack_pointer++] = {0, 0, count};
+        while(stack_pointer > 0){
+            const generic::BVHBuildEntry<TI> entry = stack[--stack_pointer];
+            generic::BVHNode<T, TI>& node = nodes[entry.node];
+            for(int axis = 0; axis < 3; axis++){
+                node.bounds_min[axis] = (T)1e30;
+                node.bounds_max[axis] = (T)-1e30;
+            }
+            T centroid_min[3] = {(T)1e30, (T)1e30, (T)1e30};
+            T centroid_max[3] = {(T)-1e30, (T)-1e30, (T)-1e30};
+            for(TI i = 0; i < entry.count; i++){
+                const TI primitive = primitives[entry.start + i];
+                for(int axis = 0; axis < 3; axis++){
+                    node.bounds_min[axis] = generic::minimum(node.bounds_min[axis], primitive_bounds_min[3 * primitive + axis]);
+                    node.bounds_max[axis] = generic::maximum(node.bounds_max[axis], primitive_bounds_max[3 * primitive + axis]);
+                    centroid_min[axis] = generic::minimum(centroid_min[axis], centroids[3 * primitive + axis]);
+                    centroid_max[axis] = generic::maximum(centroid_max[axis], centroids[3 * primitive + axis]);
+                }
+            }
+            bool leaf = entry.count <= 1 || stack_pointer + 2 > constants::BUILD_STACK_SIZE<TI>;
+            int split_axis = 0;
+            T max_extent = (T)0;
+            if(!leaf){
+                for(int axis = 0; axis < 3; axis++){
+                    const T extent = centroid_max[axis] - centroid_min[axis];
+                    if(extent > max_extent){
+                        max_extent = extent;
+                        split_axis = axis;
+                    }
+                }
+                if(max_extent <= (T)0 && entry.count <= sah::MAX_LEAF_SIZE<TI>){
+                    leaf = true;
+                }
+            }
+            TI num_left = 0;
+            if(!leaf && max_extent > (T)0){
+                constexpr TI BINS = sah::NUM_BINS<TI>;
+                TI bin_counts[BINS] = {};
+                T bin_bounds_min[BINS][3];
+                T bin_bounds_max[BINS][3];
+                for(TI bin = 0; bin < BINS; bin++){
+                    for(int axis = 0; axis < 3; axis++){
+                        bin_bounds_min[bin][axis] = (T)1e30;
+                        bin_bounds_max[bin][axis] = (T)-1e30;
+                    }
+                }
+                const T bin_scale = (T)BINS / max_extent;
+                for(TI i = 0; i < entry.count; i++){
+                    const TI primitive = primitives[entry.start + i];
+                    TI bin = (TI)((centroids[3 * primitive + split_axis] - centroid_min[split_axis]) * bin_scale);
+                    bin = bin < BINS ? bin : BINS - 1;
+                    bin_counts[bin]++;
+                    for(int axis = 0; axis < 3; axis++){
+                        bin_bounds_min[bin][axis] = generic::minimum(bin_bounds_min[bin][axis], primitive_bounds_min[3 * primitive + axis]);
+                        bin_bounds_max[bin][axis] = generic::maximum(bin_bounds_max[bin][axis], primitive_bounds_max[3 * primitive + axis]);
+                    }
+                }
+                // sweep the BINS - 1 split planes: prefix areas left-to-right, suffix right-to-left
+                T left_area[BINS - 1];
+                TI left_count[BINS - 1];
+                {
+                    T sweep_min[3] = {(T)1e30, (T)1e30, (T)1e30};
+                    T sweep_max[3] = {(T)-1e30, (T)-1e30, (T)-1e30};
+                    TI sweep_count = 0;
+                    for(TI bin = 0; bin < BINS - 1; bin++){
+                        sweep_count += bin_counts[bin];
+                        for(int axis = 0; axis < 3; axis++){
+                            sweep_min[axis] = generic::minimum(sweep_min[axis], bin_bounds_min[bin][axis]);
+                            sweep_max[axis] = generic::maximum(sweep_max[axis], bin_bounds_max[bin][axis]);
+                        }
+                        left_area[bin] = sah::half_area(sweep_min, sweep_max);
+                        left_count[bin] = sweep_count;
+                    }
+                }
+                TI best_plane = 0;
+                T best_cost = (T)1e30;
+                {
+                    T sweep_min[3] = {(T)1e30, (T)1e30, (T)1e30};
+                    T sweep_max[3] = {(T)-1e30, (T)-1e30, (T)-1e30};
+                    TI sweep_count = 0;
+                    for(TI plane = BINS - 1; plane > 0; plane--){
+                        sweep_count += bin_counts[plane];
+                        for(int axis = 0; axis < 3; axis++){
+                            sweep_min[axis] = generic::minimum(sweep_min[axis], bin_bounds_min[plane][axis]);
+                            sweep_max[axis] = generic::maximum(sweep_max[axis], bin_bounds_max[plane][axis]);
+                        }
+                        const TI num_l = left_count[plane - 1];
+                        const TI num_r = sweep_count;
+                        if(num_l == 0 || num_r == 0){
+                            continue;
+                        }
+                        const T cost = left_area[plane - 1] * (T)num_l + sah::half_area(sweep_min, sweep_max) * (T)num_r;
+                        if(cost < best_cost){
+                            best_cost = cost;
+                            best_plane = plane;
+                        }
+                    }
+                }
+                const T parent_area = sah::half_area(node.bounds_min, node.bounds_max);
+                const bool split_worthwhile = best_plane > 0
+                    && (entry.count > sah::MAX_LEAF_SIZE<TI> || (parent_area > (T)0 && (T)1 + best_cost / parent_area < (T)entry.count));
+                if(split_worthwhile){
+                    // stable order-preserving partition through temp_primitives, like the generic builder
+                    for(TI i = 0; i < entry.count; i++){
+                        const TI primitive = primitives[entry.start + i];
+                        TI bin = (TI)((centroids[3 * primitive + split_axis] - centroid_min[split_axis]) * bin_scale);
+                        bin = bin < BINS ? bin : BINS - 1;
+                        if(bin < best_plane) temp_primitives[num_left++] = primitive;
+                    }
+                    TI num_total = num_left;
+                    for(TI i = 0; i < entry.count; i++){
+                        const TI primitive = primitives[entry.start + i];
+                        TI bin = (TI)((centroids[3 * primitive + split_axis] - centroid_min[split_axis]) * bin_scale);
+                        bin = bin < BINS ? bin : BINS - 1;
+                        if(!(bin < best_plane)) temp_primitives[num_total++] = primitive;
+                    }
+                    for(TI i = 0; i < entry.count; i++){
+                        primitives[entry.start + i] = temp_primitives[i];
+                    }
+                }
+            }
+            if(num_left == 0){
+                // no worthwhile SAH split: leaf when small enough, deterministic halving otherwise
+                // (zero centroid extent or a degenerate binning cannot be split spatially)
+                if(entry.count <= sah::MAX_LEAF_SIZE<TI> || stack_pointer + 2 > constants::BUILD_STACK_SIZE<TI>){
+                    node.left_or_first = entry.start;
+                    node.count = entry.count;
+                    continue;
+                }
+                num_left = entry.count / 2;
+            }
+            const TI left_child = node_count++;
+            const TI right_child = node_count++;
+            node.left_or_first = left_child;
+            node.count = 0;
+            stack[stack_pointer++] = {right_child, entry.start + num_left, entry.count - num_left};
+            stack[stack_pointer++] = {left_child, entry.start, num_left};
+        }
+        return node_count;
+    }
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/backends/webgpu/context.h

@@ -0,0 +1,303 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_WEBGPU_CONTEXT_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_WEBGPU_CONTEXT_H
+
+#include "../../types.h"
+#include "../generic/operations_generic.h"
+
+#include <webgpu/webgpu.h>
+
+#include <vector>
+#include <cstdint>
+
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS
+#define RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS 0
+#endif
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::backends::webgpu{
+    // Bind group 0 layout shared between the host code and the WGSL kernels in device.wgsl.
+    // Standard WebGPU has no acceleration structures and no buffer device addresses, so relative
+    // to the Vulkan backend the TLAS/overlay-TLAS bindings become BVH storage buffers and the
+    // MeshRecord addresses become element offsets into one packed SCENE_GEOMETRY buffer.
+    // Exactly 8 storage buffers: browsers tier maxStorageBuffersPerShaderStage down to the spec
+    // default of 8 regardless of hardware, so the small per-frame inputs live as sections of the
+    // FRAME_INPUTS arena and every output is a section of the OUTPUTS arena, both addressed by
+    // element offsets carried in LaunchParams (the SCENE_GEOMETRY pattern). Mesh records live in
+    // SCENE_GEOMETRY (shading-only after the packed-triangle intersection path) so the
+    // leaf-ordered TRIANGLES stream keeps its own vec4-typed binding. LaunchParams itself is
+    // read-only storage, not uniform — see the binding comment in device.wgsl.
+    namespace bindings{
+        constexpr uint32_t LAUNCH_PARAMS = 0;
+        constexpr uint32_t DISPATCH_PARAMS = 1; // dynamic-offset uniform: {shutter_t, overlay_region}
+        constexpr uint32_t SCENE_GEOMETRY = 2;  // u32-addressed: mesh data, triangle tables, TLAS leaf permutation, object records, sRGB LUT, mesh records, scene lights, instance classes
+        constexpr uint32_t TEXTURE_DATA = 3;    // packed RGBA8 texels, one u32 each, sampled in the shader
+        constexpr uint32_t BVH_NODES = 4;       // per-object BLAS slices, the scene TLAS, then the per-region overlay TLASes
+        constexpr uint32_t TRIANGLES = 5;       // leaf-ordered packed triangles: 3 x vec4 {vertex.xyz, w: bitcast global id / 0 / 0}
+        constexpr uint32_t INSTANCE_DATA = 6;
+        constexpr uint32_t FRAME_INPUTS = 7;    // cameras, overlay attachments/meta/primitives, flow deltas, probe directions
+        constexpr uint32_t OUTPUTS = 8;         // frame buffer, depth, segmentation, normals, flow, observation, accumulators, collision results
+        constexpr uint32_t COUNT = 9;
+        constexpr uint32_t STORAGE_COUNT = 8;
+    }
+    // must match the @workgroup_size of every entry point in device.wgsl
+    constexpr uint32_t WORKGROUP_SIZE_X = 8;
+    constexpr uint32_t WORKGROUP_SIZE_Y = 4;
+    // must match TRAVERSAL_STACK_SIZE in device.wgsl; the ordered traversal pushes at most one
+    // entry per tree level, so the host asserts every built tree's depth against this bound
+    constexpr uint32_t TRAVERSAL_STACK_SIZE = 48;
+    // one 256-byte slot per dynamic-motion-blur sample (+ slot 0 for the shutter-close state);
+    // 256 is a multiple of every legal minUniformBufferOffsetAlignment
+    constexpr uint32_t DISPATCH_PARAMS_STRIDE = 256;
+    constexpr uint32_t ABSENT = 0xFFFFFFFFu;
+
+    using BVHNode = generic::BVHNode<float, uint32_t>;
+    static_assert(sizeof(BVHNode) == 32, "BVHNode layout must match the WGSL declaration in device.wgsl");
+    static_assert(sizeof(rendering::raytracing::SceneLight) == 60, "SceneLight layout must match load_scene_light in device.wgsl");
+    static_assert(sizeof(rendering::raytracing::Camera<float>) == 48, "Camera layout must match load_camera in device.wgsl");
+    static_assert(sizeof(rendering::raytracing::CollisionResult) == 8, "CollisionResult must span two OUTPUTS words");
+
+    struct LaunchParams{
+        uint32_t fb_width;
+        uint32_t fb_height;
+        uint32_t cam_width;
+        uint32_t cam_height;
+        uint32_t grid_cols;
+        uint32_t num_cameras;
+        uint32_t num_probes;
+        uint32_t num_scene_lights;
+        float max_depth;
+        float max_dist;
+        float ambient_color[3];
+        float miss_color_0[3];
+        float miss_color_1[3];
+        uint32_t first_overlay_instance; // global instance ids >= this index the flow-delta table
+        uint32_t num_overlay_slots;      // NUM_OVERLAYS * MAX_OVERLAY_INSTANCES: flow-delta slab stride and per-region id shift
+        uint32_t triangle_mesh_offset;   // u32 elements into SCENE_GEOMETRY
+        uint32_t triangle_local_offset;
+        uint32_t object_records_offset;  // stride 4 per object: {node_offset, node_count, first_triangle, 0}
+        uint32_t tlas_node_offset;       // BVHNode elements into BVH_NODES
+        uint32_t tlas_node_count;
+        uint32_t tlas_primitive_offset;  // u32 elements into SCENE_GEOMETRY
+        uint32_t srgb_lut_offset;        // 256 f32 elements into SCENE_GEOMETRY: sRGB texel -> linear
+        uint32_t mesh_records_offset;    // 30 words per record, into SCENE_GEOMETRY
+        uint32_t scene_lights_offset;    // 15 words per light, into SCENE_GEOMETRY
+        uint32_t instance_classes_offset;
+        uint32_t overlay_node_offset;    // BVHNode elements into BVH_NODES
+        uint32_t attachments_offset;     // u32 elements into FRAME_INPUTS
+        uint32_t overlay_meta_offset;    // per region x overlay: {num_active, num_tlas_nodes}
+        uint32_t overlay_primitives_offset;
+        uint32_t flow_deltas_offset;     // [2][slots][12] f32 elements into FRAME_INPUTS
+        uint32_t probe_directions_offset;
+        uint32_t cameras_offset;         // shutter-close cameras, then the shutter-open set for camera-pair specs
+        uint32_t cameras_previous_offset; // flow: the previous instant's camera set
+        uint32_t out_frame_buffer;       // u32 elements into OUTPUTS
+        uint32_t out_depth;
+        uint32_t out_segmentation;
+        uint32_t out_normals;
+        uint32_t out_flow;
+        uint32_t out_flow_status;
+        uint32_t out_flow_forward;
+        uint32_t out_flow_forward_status;
+        uint32_t out_observation;
+        uint32_t out_rgb_accumulator;
+        uint32_t out_depth_accumulator;
+        uint32_t out_collision;
+    };
+    static_assert(sizeof(LaunchParams) == 204, "LaunchParams layout must match the WGSL declaration in device.wgsl");
+
+    struct TextureRef{
+        uint32_t offset; // texel index into TEXTURE_DATA, ABSENT = no texture
+        uint32_t width;
+        uint32_t height;
+    };
+    static_assert(sizeof(TextureRef) == 12, "TextureRef layout must match the WGSL declaration in device.wgsl");
+
+    struct MeshRecord{
+        uint32_t index_offset;     // u32 elements into SCENE_GEOMETRY (i32 data)
+        uint32_t vertex_offset;    // f32 data
+        uint32_t tex_coord_offset; // ABSENT = no tex coords
+        uint32_t normal_offset;    // ABSENT = no normals
+        TextureRef texture;
+        TextureRef normal_map;
+        TextureRef metallic_roughness_map;
+        TextureRef emissive_map;
+        TextureRef occlusion_map;
+        float color[3];
+        float metallic;
+        float roughness;
+        float opacity;
+        float emissive[3];
+        float alpha_cutoff;
+        int32_t alpha_mode;
+        int32_t unlit;
+    };
+    static_assert(sizeof(MeshRecord) == 124, "MeshRecord layout must match load_mesh_record in device.wgsl");
+
+    struct InstanceData{
+        float object_to_world[12]; // 3x4 row-major [R|t]
+        float world_to_object[12];
+        uint32_t object;
+        uint32_t identity;
+        uint32_t padding[2];
+    };
+    static_assert(sizeof(InstanceData) == 112, "InstanceData layout must match the WGSL declaration in device.wgsl");
+
+    struct DispatchParams{
+        float shutter_t;
+        uint32_t overlay_region; // 0 = shutter-close state, 1 + s = dynamic-motion-blur sample s (the flow passes address the previous-instant region themselves)
+        uint32_t padding[2];
+    };
+    static_assert(sizeof(DispatchParams) == 16, "DispatchParams layout must match the WGSL declaration in device.wgsl");
+
+    // section offsets (u32 elements) of the SPEC-sized FRAME_INPUTS and OUTPUTS arenas: the
+    // single source for buffer sizing, the LaunchParams offset fields, and the host's
+    // queueWriteBuffer/clear/copy offsets
+    template <typename SPEC>
+    struct BufferLayout{
+        // overlay BVH regions: 0 = current state, 1 + s = dynamic-motion-blur sample s, then the
+        // flow previous-instant region (FLOW_PREVIOUS_REGION) appended last so the existing
+        // region and instance-id ranges keep their indices
+        static constexpr uint32_t MOTION_REGIONS = SPEC::ENABLE_DYNAMIC_MOTION_BLUR ? (uint32_t)SPEC::MOTION_BLUR_SAMPLES : 0;
+        static constexpr uint32_t FLOW_PREVIOUS_REGION = 1 + MOTION_REGIONS;
+        static constexpr uint32_t OVERLAY_REGIONS = SPEC::ENABLE_OVERLAYS ? 1 + MOTION_REGIONS + (SPEC::HAS_FLOW_OVERLAYS ? 1 : 0) : 0;
+        static constexpr uint32_t ATTACHMENTS_WORDS = SPEC::ENABLE_OVERLAYS ? (uint32_t)SPEC::NUM_CAMERAS * (uint32_t)SPEC::MAX_OVERLAYS_PER_CAMERA : 0;
+        static constexpr uint32_t OVERLAY_META_WORDS = OVERLAY_REGIONS * (uint32_t)SPEC::NUM_OVERLAYS * 2;
+        static constexpr uint32_t OVERLAY_PRIMITIVES_WORDS = OVERLAY_REGIONS * (uint32_t)SPEC::NUM_OVERLAYS * (uint32_t)SPEC::MAX_OVERLAY_INSTANCES;
+        static constexpr uint32_t FLOW_DELTAS_WORDS = SPEC::HAS_FLOW_OVERLAYS ? 2 * (uint32_t)SPEC::NUM_OVERLAYS * (uint32_t)SPEC::MAX_OVERLAY_INSTANCES * 12 : 0;
+#if !RL_TOOLS_RENDERING_RAYTRACING_DISABLE_PROBE_RAYS
+        static constexpr uint32_t PROBE_DIRECTIONS_WORDS = (uint32_t)SPEC::NUM_PROBES * 3;
+        static constexpr uint32_t COLLISION_WORDS = (uint32_t)SPEC::NUM_CAMERAS * (uint32_t)SPEC::NUM_PROBES * 2;
+#else
+        static constexpr uint32_t PROBE_DIRECTIONS_WORDS = 0;
+        static constexpr uint32_t COLLISION_WORDS = 0;
+#endif
+        static constexpr uint32_t CAMERA_SET_WORDS = (uint32_t)SPEC::NUM_CAMERAS * 12;
+        static constexpr uint32_t CAMERAS_WORDS = (1 + (SPEC::HAS_CAMERA_PAIR ? 1 : 0) + (SPEC::HAS_FLOW ? 1 : 0)) * CAMERA_SET_WORDS;
+        static constexpr uint32_t CAMERAS_OFFSET = 0;
+        static constexpr uint32_t CAMERAS_PREVIOUS_OFFSET = CAMERAS_OFFSET + (SPEC::HAS_CAMERA_PAIR ? 2 : 1) * CAMERA_SET_WORDS; // after the close (and open) sets
+        static constexpr uint32_t ATTACHMENTS_OFFSET = CAMERAS_OFFSET + CAMERAS_WORDS;
+        static constexpr uint32_t OVERLAY_META_OFFSET = ATTACHMENTS_OFFSET + ATTACHMENTS_WORDS;
+        static constexpr uint32_t OVERLAY_PRIMITIVES_OFFSET = OVERLAY_META_OFFSET + OVERLAY_META_WORDS;
+        static constexpr uint32_t FLOW_DELTAS_OFFSET = OVERLAY_PRIMITIVES_OFFSET + OVERLAY_PRIMITIVES_WORDS;
+        static constexpr uint32_t PROBE_DIRECTIONS_OFFSET = FLOW_DELTAS_OFFSET + FLOW_DELTAS_WORDS;
+        static constexpr uint32_t FRAME_INPUTS_WORDS = PROBE_DIRECTIONS_OFFSET + PROBE_DIRECTIONS_WORDS;
+
+        static constexpr uint32_t CAM_PIXEL_WORDS = (uint32_t)SPEC::NUM_CAMERAS * (uint32_t)SPEC::CAM_PIXELS;
+        static constexpr uint32_t FRAME_BUFFER_WORDS = SPEC::HAS_RGB ? CAM_PIXEL_WORDS : 0;
+        static constexpr uint32_t DEPTH_WORDS = SPEC::HAS_DEPTH ? CAM_PIXEL_WORDS : 0;
+        static constexpr uint32_t SEGMENTATION_WORDS = SPEC::HAS_SEGMENTATION ? CAM_PIXEL_WORDS : 0;
+        static constexpr uint32_t NORMALS_WORDS = SPEC::HAS_NORMALS ? CAM_PIXEL_WORDS * 3 : 0;
+        static constexpr uint32_t FLOW_WORDS = SPEC::HAS_FLOW ? CAM_PIXEL_WORDS * 2 : 0;
+        static constexpr uint32_t FLOW_STATUS_WORDS = SPEC::HAS_FLOW ? CAM_PIXEL_WORDS : 0;
+        static constexpr uint32_t FLOW_FORWARD_WORDS = SPEC::HAS_FLOW_FORWARD ? CAM_PIXEL_WORDS * 2 : 0;
+        static constexpr uint32_t FLOW_FORWARD_STATUS_WORDS = SPEC::HAS_FLOW_FORWARD ? CAM_PIXEL_WORDS : 0;
+        static constexpr uint32_t OBSERVATION_WORDS = SPEC::HAS_OBSERVATION ? CAM_PIXEL_WORDS * (uint32_t)SPEC::OBSERVATION_CHANNELS : 0;
+        static constexpr uint32_t RGB_ACCUMULATOR_WORDS = (SPEC::ENABLE_DYNAMIC_MOTION_BLUR && SPEC::HAS_RGB) ? CAM_PIXEL_WORDS * 3 : 0;
+        static constexpr uint32_t DEPTH_ACCUMULATOR_WORDS = (SPEC::ENABLE_DYNAMIC_MOTION_BLUR && SPEC::HAS_DEPTH) ? CAM_PIXEL_WORDS : 0;
+        static constexpr uint32_t FRAME_BUFFER_OFFSET = 0;
+        static constexpr uint32_t DEPTH_OFFSET = FRAME_BUFFER_OFFSET + FRAME_BUFFER_WORDS;
+        static constexpr uint32_t SEGMENTATION_OFFSET = DEPTH_OFFSET + DEPTH_WORDS;
+        static constexpr uint32_t NORMALS_OFFSET = SEGMENTATION_OFFSET + SEGMENTATION_WORDS;
+        static constexpr uint32_t FLOW_OFFSET = NORMALS_OFFSET + NORMALS_WORDS;
+        static constexpr uint32_t FLOW_STATUS_OFFSET = FLOW_OFFSET + FLOW_WORDS;
+        static constexpr uint32_t FLOW_FORWARD_OFFSET = FLOW_STATUS_OFFSET + FLOW_STATUS_WORDS;
+        static constexpr uint32_t FLOW_FORWARD_STATUS_OFFSET = FLOW_FORWARD_OFFSET + FLOW_FORWARD_WORDS;
+        static constexpr uint32_t OBSERVATION_OFFSET = FLOW_FORWARD_STATUS_OFFSET + FLOW_FORWARD_STATUS_WORDS;
+        static constexpr uint32_t RGB_ACCUMULATOR_OFFSET = OBSERVATION_OFFSET + OBSERVATION_WORDS;
+        static constexpr uint32_t DEPTH_ACCUMULATOR_OFFSET = RGB_ACCUMULATOR_OFFSET + RGB_ACCUMULATOR_WORDS;
+        static constexpr uint32_t COLLISION_OFFSET = DEPTH_ACCUMULATOR_OFFSET + DEPTH_ACCUMULATOR_WORDS;
+        static constexpr uint32_t OUTPUTS_WORDS = COLLISION_OFFSET + COLLISION_WORDS;
+    };
+
+    struct BufferResource{
+        WGPUBuffer buffer = nullptr;
+        uint64_t size = 0;
+    };
+
+    // staging -> host-tensor readback registered in malloc; lets the in-flight settle run against
+    // the Context alone (the renderer memory-domain copy has no SPEC)
+    struct ReadbackTarget{
+        BufferResource* staging = nullptr;
+        void* destination = nullptr;
+        size_t bytes = 0;
+    };
+
+    struct Context{
+        WGPUInstance instance = nullptr;
+        WGPUAdapter adapter = nullptr;
+        WGPUDevice device = nullptr;
+        WGPUQueue queue = nullptr;
+        uint32_t max_storage_buffers_per_shader_stage = 0;
+        uint64_t max_storage_buffer_binding_size = 0;
+
+        WGPUShaderModule module = nullptr;
+        WGPUBindGroupLayout bind_group_layout = nullptr;
+        WGPUPipelineLayout pipeline_layout = nullptr;
+        WGPUComputePipeline rgb_pipeline = nullptr;
+        WGPUComputePipeline depth_pipeline = nullptr;
+        WGPUComputePipeline collision_pipeline = nullptr;
+        WGPUComputePipeline segmentation_pipeline = nullptr;
+        WGPUComputePipeline normals_pipeline = nullptr;
+        WGPUComputePipeline flow_pipeline = nullptr;
+        WGPUComputePipeline flow_forward_pipeline = nullptr;
+        WGPUComputePipeline resolve_pipeline = nullptr;
+        WGPUBindGroup bind_group = nullptr; // recreated per init (scene buffers change)
+
+        BufferResource launch_params;
+        BufferResource scene_geometry;
+        BufferResource texture_data;
+        BufferResource bvh_nodes;
+        BufferResource triangles;
+        BufferResource instance_data;
+        BufferResource frame_inputs;
+        BufferResource outputs;
+        BufferResource dispatch_params;
+
+        BufferResource staging_frame_buffer;
+        BufferResource staging_depth;
+        BufferResource staging_segmentation;
+        BufferResource staging_normals;
+        BufferResource staging_flow;
+        BufferResource staging_flow_status;
+        BufferResource staging_flow_forward;
+        BufferResource staging_flow_forward_status;
+        BufferResource staging_observation;
+        BufferResource staging_collision;
+        std::vector<ReadbackTarget> render_readbacks;
+        std::vector<ReadbackTarget> probe_readbacks;
+        std::vector<float> flow_deltas_host; // flow: [2][slots][12], composed by update() and written into FRAME_INPUTS
+
+        // scene-dependent arena offsets mirrored from LaunchParams for the per-update writes
+        uint32_t instance_classes_offset = 0;
+        uint32_t overlay_node_offset = 0;
+
+        // host mirrors consumed by the per-update overlay rebuilds (queueWriteBuffer sources)
+        std::vector<InstanceData> instance_data_host;
+        std::vector<uint32_t> instance_classes_host;
+        std::vector<uint32_t> object_classes;        // object -> segmentation_class
+        std::vector<uint32_t> object_node_offset;    // object -> BVHNode elements into BVH_NODES
+        std::vector<uint32_t> object_node_count;
+        std::vector<uint32_t> object_primitive_offset;
+        std::vector<float> object_root_bounds_min;   // 3 per object, BLAS root AABB for instance world bounds
+        std::vector<float> object_root_bounds_max;
+        std::vector<BVHNode> overlay_nodes_host;     // all regions, one 2*capacity slice per (region, overlay)
+        std::vector<uint32_t> overlay_primitives_host;
+        std::vector<uint32_t> overlay_meta_host;
+        std::vector<float> overlay_bounds_min;       // scratch indexed by global instance id
+        std::vector<float> overlay_bounds_max;
+        std::vector<float> overlay_centroids;
+        std::vector<uint32_t> overlay_temp_primitives;
+        uint32_t num_scene_instances = 0;
+        uint32_t total_instances = 0;
+
+        bool render_in_flight = false;
+        bool collision_in_flight = false;
+        bool pipelines_built = false;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/backends/webgpu/device_source.h

@@ -0,0 +1,17 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_WEBGPU_DEVICE_SOURCE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_WEBGPU_DEVICE_SOURCE_H
+
+extern "C" const char rl_tools_rendering_raytracing_webgpu_device_source[];
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::backends::webgpu{
+    inline const char* device_source(){
+        return rl_tools_rendering_raytracing_webgpu_device_source;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif