hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rendering/raytracing/backends/optix/overlay_accel.h

@@ -0,0 +1,64 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_OPTIX_OVERLAY_ACCEL_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_OPTIX_OVERLAY_ACCEL_H
+
+#include "../../../../rl_tools.h"
+
+#include <cuda_runtime.h>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+// device-side overlay TLAS path: raw optixAccelBuild over device-resident instance descriptors,
+// bypassing OWL's host-staged instance groups so update_launch never synchronizes the host.
+// Implemented in src/rendering/raytracing/backends/optix/overlay_accel.cu (linked via the
+// rendering_raytracing_backend* targets); this header stays compilable by non-CUDA TUs.
+namespace rl_tools::rendering::raytracing::backends::optix{
+    struct OverlaySlotStructure{
+        unsigned int active;
+        unsigned int object;
+    };
+    static_assert(sizeof(OverlaySlotStructure) == 8, "OverlaySlotStructure layout must match the fill kernel");
+    struct OverlayObjectEntry{
+        unsigned long long traversable;
+        unsigned int sbt_offset;
+        unsigned int segmentation_class;
+    };
+    struct OverlayAccelState;
+
+    // num_instants: 1 for the steady state alone, 2 when flow keeps the previous instant's TLASes
+    // resident next to the current ones — instant i's instances carry the global ids
+    // [num_scene_instances + i * slots, num_scene_instances + (i + 1) * slots)
+    OverlayAccelState* overlay_accel_create(void* optix_device_context, unsigned int num_overlays, unsigned int max_instances, unsigned int num_scene_instances, unsigned long long filler_traversable, unsigned int num_instants);
+    void overlay_accel_destroy(OverlayAccelState* state);
+    // device pointer to the [num_overlays * max_instances] slot structure table (staging target)
+    OverlaySlotStructure* overlay_accel_structure(OverlayAccelState* state);
+    // per-object BLAS traversables + SBT offsets + classes; upload once, after owlBuildSBT
+    void overlay_accel_upload_objects(OverlayAccelState* state, const OverlayObjectEntry* objects, unsigned int num_objects);
+    // per-overlay TLAS handles of one instant; stable across rebuilds (fixed output buffers), valid after create
+    const unsigned long long* overlay_accel_traversables(const OverlayAccelState* state, unsigned int instant);
+    // enqueues the instance fill kernel and one optixAccelBuild per overlay of the given instant
+    // on stream; no host sync. transforms: [num_overlays * max_instances * 12] device
+    // geometry-to-world rows; instance_classes: per global instance id, device — the kernel
+    // maintains the overlay range of instant 0 (null skips the classes: the previous instant
+    // never feeds segmentation). shutter_out (optional device float): the fill kernel stores
+    // shutter_t there on-stream, so per-pass shutter times reach the accumulate ray gens without
+    // per-launch param uploads (which would race: OWL stages launch params through a single
+    // pinned host buffer)
+    void overlay_accel_build(OverlayAccelState* state, const float* transforms, unsigned int* instance_classes, float shutter_t, float* shutter_out, cudaStream_t stream, unsigned int instant);
+    // divides the linear accumulators by num_samples and writes the packed frame buffer (+
+    // observation) / depth buffer with the exact quantization of the single-launch path;
+    // null accumulator pointers skip the corresponding output
+    void overlay_accel_resolve(const float* rgb_accumulation, unsigned int* frame_buffer, float* observation, int srgb_output, const float* depth_accumulation, float* depth_buffer, unsigned int num_pixels, unsigned int num_samples, cudaStream_t stream);
+    // the device half of the host publish: for each of num_slabs slabs slab_stride rows apart,
+    // writes rows[(slab * count + row) * 12] into target[(slab * slab_stride + indices[row]) * 12]
+    void overlay_accel_scatter_rows(const unsigned int* indices, unsigned int count, const float* rows, float* target, unsigned int num_slabs, unsigned int slab_stride, cudaStream_t stream);
+
+    // flow delta table [2][slots][12] from the current and previous transforms slabs and the
+    // slot structure table: slab 0 carries a current-instant point to the previous instant
+    // (world_previous ∘ world_current⁻¹), slab 1 the inverse; identity for inactive slots — the
+    // on-device counterpart of detail::compose_flow_deltas
+    void overlay_accel_compose_flow_deltas(const OverlaySlotStructure* structure, const float* transforms, const float* transforms_previous, float* deltas, unsigned int num_overlays, unsigned int max_instances, cudaStream_t stream);
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,38 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_SPECIALIZATION_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_SPECIALIZATION_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace rendering::raytracing::backends{
+        // single source of the shader specialization/function-constant values consumed by the
+        // Vulkan, Metal, and WebGPU pipelines: the derivation logic lives once so the backends
+        // cannot drift (binding indices and constant names stay per backend)
+        template <typename SPEC>
+        struct SpecializationConstants{
+            static constexpr bool SRGB_OUTPUT = SPEC::SHADING::SRGB_OUTPUT;
+            static constexpr bool MOTION_BLUR = SPEC::ENABLE_MOTION_BLUR;
+            static constexpr int MOTION_SAMPLES = SPEC::ENABLE_MOTION_BLUR ? (int)SPEC::MOTION_BLUR_SAMPLES : 1;
+            static constexpr int AA_GRID = SPEC::ENABLE_ANTI_ALIASING ? (int)SPEC::ANTI_ALIASING_GRID_SIZE : 1;
+            static constexpr bool CHECKER_BACKGROUND = SPEC::SHADING::CHECKER_BACKGROUND;
+            static constexpr bool LOAD_TEXTURES = SPEC::SHADING::LOAD_TEXTURES;
+            static constexpr bool NORMAL_SHADING = SPEC::SHADING::NORMAL_SHADING;
+            static constexpr bool METALLIC_REFLECTIONS = SPEC::SHADING::METALLIC_REFLECTIONS;
+            static constexpr bool PBR_SHADING = SPEC::SHADING::PBR_SHADING;
+            static constexpr bool PUNCTUAL_LIGHT_SHADOWS = SPEC::SHADING::PUNCTUAL_LIGHT_SHADOWS;
+            static constexpr int OVERLAY_COUNT = SPEC::ENABLE_OVERLAYS ? (int)SPEC::MAX_OVERLAYS_PER_CAMERA : 0;
+            static constexpr bool SEMANTIC_SEGMENTATION = SPEC::SEMANTIC_SEGMENTATION;
+            static constexpr bool HAS_OBSERVATION = SPEC::HAS_OBSERVATION;
+            static constexpr bool DYNAMIC_MOTION_BLUR = SPEC::ENABLE_DYNAMIC_MOTION_BLUR;
+            static constexpr bool RESOLVE_RGB = SPEC::ENABLE_DYNAMIC_MOTION_BLUR && SPEC::HAS_RGB;
+            static constexpr bool RESOLVE_DEPTH = SPEC::ENABLE_DYNAMIC_MOTION_BLUR && SPEC::HAS_DEPTH;
+            // WGSL-only consumers (the other shader backends derive these in-shader)
+            static constexpr int NUM_OVERLAYS = (int)SPEC::NUM_OVERLAYS;
+            static constexpr int OVERLAY_CAPACITY = (int)SPEC::MAX_OVERLAY_INSTANCES;
+        };
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,248 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_VULKAN_CONTEXT_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_VULKAN_CONTEXT_H
+
+#include "../../types.h"
+
+#include <vulkan/vulkan.h>
+
+#include <vector>
+#include <cstdint>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::backends::vulkan{
+    // Descriptor bindings shared between the host code and the GLSL kernels in device.comp
+    namespace bindings{
+        constexpr uint32_t LAUNCH_PARAMS = 0;
+        constexpr uint32_t CAMERAS_CLOSE = 1;
+        constexpr uint32_t CAMERAS_OPEN = 2;
+        constexpr uint32_t FRAME_BUFFER = 3;
+        constexpr uint32_t MESH_RECORDS = 4;
+        constexpr uint32_t SCENE_LIGHTS = 5;
+        constexpr uint32_t PROBE_DIRECTIONS = 6;
+        constexpr uint32_t COLLISION_RESULTS = 7;
+        constexpr uint32_t ACCELERATION_STRUCTURE = 8;
+        constexpr uint32_t DEPTH_BUFFER = 9;
+        constexpr uint32_t SEGMENTATION_BUFFER = 10;
+        constexpr uint32_t INSTANCE_RECORD_BASE = 11;
+        constexpr uint32_t INSTANCE_DATA = 12;
+        constexpr uint32_t OVERLAY_ATTACHMENTS = 13;
+        constexpr uint32_t OVERLAY_NUM_ACTIVE = 14;
+        constexpr uint32_t OVERLAY_TLAS = 15;
+        constexpr uint32_t INSTANCE_CLASSES = 16;
+        constexpr uint32_t OBSERVATION = 17;
+        constexpr uint32_t RGB_ACCUMULATOR = 18;
+        constexpr uint32_t DEPTH_ACCUMULATOR = 19;
+        constexpr uint32_t NORMALS_BUFFER = 20;
+        constexpr uint32_t FLOW_BUFFER = 21;
+        constexpr uint32_t FLOW_DELTAS = 22;              // internal [2][slots][12] delta table composed by update()
+        constexpr uint32_t FLOW_STATUS_BUFFER = 23;
+        constexpr uint32_t FLOW_FORWARD_BUFFER = 24;
+        constexpr uint32_t FLOW_FORWARD_STATUS_BUFFER = 25;
+        constexpr uint32_t CAMERAS_PREVIOUS = 26;
+        constexpr uint32_t OVERLAY_NUM_ACTIVE_PREVIOUS = 27;
+        constexpr uint32_t OVERLAY_TLAS_PREVIOUS = 28;    // the previous instant's overlay TLASes (flow visibility / forward primaries)
+        constexpr uint32_t TEXTURES = 29; // variable-descriptor-count binding must have the largest binding number in the set
+        constexpr uint32_t COUNT = 30;
+    }
+    namespace specialization_constants{
+        constexpr uint32_t SRGB_OUTPUT = 0;
+        constexpr uint32_t MOTION_BLUR = 1;
+        constexpr uint32_t MOTION_SAMPLES = 2;
+        constexpr uint32_t AA_GRID = 3;
+        constexpr uint32_t CHECKER_BACKGROUND = 4;
+        constexpr uint32_t LOAD_TEXTURES = 5;
+        constexpr uint32_t NORMAL_SHADING = 6;
+        constexpr uint32_t METALLIC_REFLECTIONS = 7;
+        constexpr uint32_t PBR_SHADING = 8;
+        constexpr uint32_t PUNCTUAL_LIGHT_SHADOWS = 9;
+        constexpr uint32_t OVERLAY_COUNT = 10;
+        constexpr uint32_t SEMANTIC_SEGMENTATION = 11;
+        constexpr uint32_t HAS_OBSERVATION = 12;
+        constexpr uint32_t DYNAMIC_MOTION_BLUR = 13;
+        constexpr uint32_t RESOLVE_RGB = 14;
+        constexpr uint32_t RESOLVE_DEPTH = 15;
+        constexpr uint32_t COUNT = 16;
+    }
+    constexpr uint32_t WORKGROUP_SIZE = 8;
+    constexpr uint32_t MAX_TEXTURE_DESCRIPTORS = 4096;
+
+    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 the previous-instant id shift
+        float padding[1];
+    };
+    static_assert(sizeof(LaunchParams) == 88, "LaunchParams layout must match the GLSL declaration in device.comp");
+
+    struct MeshRecord{
+        uint64_t index;
+        uint64_t vertices;
+        uint64_t tex_coord;
+        uint64_t normal;
+        uint32_t texture;
+        uint32_t normal_map;
+        uint32_t metallic_roughness_map;
+        uint32_t emissive_map;
+        uint32_t occlusion_map;
+        float color[3];
+        float metallic;
+        float roughness;
+        float opacity;
+        float emissive[3];
+        float alpha_cutoff;
+        int32_t alpha_mode;
+        int32_t has_texture;
+        int32_t has_normal_map;
+        int32_t has_metallic_roughness_map;
+        int32_t has_emissive_map;
+        int32_t has_occlusion_map;
+        int32_t has_tex_coord;
+        int32_t has_normals;
+        int32_t unlit;
+    };
+    static_assert(sizeof(MeshRecord) == 128, "MeshRecord layout must match the GLSL declaration in device.comp");
+
+    struct InstanceData{
+        float object_to_world[12]; // 3x4 row-major [R|t]
+        float world_to_object[12];
+        uint32_t identity;
+        uint32_t padding[3];
+    };
+    static_assert(sizeof(InstanceData) == 112, "InstanceData layout must match the GLSL std430 declaration in device.comp");
+
+    struct BufferResource{
+        VkBuffer buffer = VK_NULL_HANDLE;
+        VkDeviceMemory memory = VK_NULL_HANDLE;
+        void* mapped = nullptr;
+        VkDeviceSize size = 0;
+    };
+
+    struct ImageResource{
+        VkImage image = VK_NULL_HANDLE;
+        VkDeviceMemory memory = VK_NULL_HANDLE;
+        VkImageView view = VK_NULL_HANDLE;
+    };
+
+    struct Context{
+        VkInstance instance = VK_NULL_HANDLE;
+        VkPhysicalDevice physical_device = VK_NULL_HANDLE;
+        VkDevice device = VK_NULL_HANDLE;
+        uint32_t queue_family_index = 0;
+        VkDeviceSize min_scratch_alignment = 256;
+        VkQueue queue = VK_NULL_HANDLE;
+        VkCommandPool command_pool = VK_NULL_HANDLE;
+
+        PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = nullptr;
+        PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = nullptr;
+        PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = nullptr;
+        PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = nullptr;
+        PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = nullptr;
+
+        VkDescriptorSetLayout descriptor_set_layout = VK_NULL_HANDLE;
+        VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
+        VkShaderModule module_rgb = VK_NULL_HANDLE;
+        VkShaderModule module_depth = VK_NULL_HANDLE;
+        VkShaderModule module_collision = VK_NULL_HANDLE;
+        VkShaderModule module_segmentation = VK_NULL_HANDLE;
+        VkShaderModule module_normals = VK_NULL_HANDLE;
+        VkShaderModule module_flow = VK_NULL_HANDLE;
+        VkShaderModule module_flow_forward = VK_NULL_HANDLE;
+        VkShaderModule module_resolve = VK_NULL_HANDLE;
+        VkPipeline rgb_pipeline = VK_NULL_HANDLE;
+        VkPipeline depth_pipeline = VK_NULL_HANDLE;
+        VkPipeline collision_pipeline = VK_NULL_HANDLE;
+        VkPipeline segmentation_pipeline = VK_NULL_HANDLE;
+        VkPipeline normals_pipeline = VK_NULL_HANDLE;
+        VkPipeline flow_pipeline = VK_NULL_HANDLE;
+        VkPipeline flow_forward_pipeline = VK_NULL_HANDLE;
+        VkPipeline resolve_pipeline = VK_NULL_HANDLE;
+        VkDescriptorPool descriptor_pool = VK_NULL_HANDLE;
+        VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
+        VkSampler sampler = VK_NULL_HANDLE;
+
+        BufferResource launch_params;
+        BufferResource cameras;
+        BufferResource cameras_open;
+        BufferResource cameras_previous;
+        BufferResource frame_buffer;
+        BufferResource depth_buffer;
+        BufferResource collision_results;
+        BufferResource probe_directions;
+        BufferResource mesh_records;
+        BufferResource scene_lights;
+        BufferResource mesh_data;
+        BufferResource tlas_buffer;
+        BufferResource instance_buffer;
+        BufferResource segmentation_buffer;
+        BufferResource normals_buffer;
+        BufferResource flow_buffer;
+        BufferResource flow_status_buffer;
+        BufferResource flow_forward_buffer;
+        BufferResource flow_forward_status_buffer;
+        BufferResource flow_deltas;
+        BufferResource observation;
+        BufferResource instance_data;
+        BufferResource instance_record_base;
+        BufferResource instance_classes;
+        BufferResource overlay_attachments;
+        BufferResource overlay_num_active;
+        BufferResource overlay_num_active_previous;
+        BufferResource overlay_scratch;
+        BufferResource rgb_accumulator;
+        BufferResource depth_accumulator;
+        BufferResource dummy;
+
+        std::vector<ImageResource> mesh_textures; // index 0 = dummy 1x1 white
+        std::vector<VkAccelerationStructureKHR> blas_list; // one per object
+        std::vector<BufferResource> blas_buffers;
+        std::vector<VkDeviceAddress> blas_addresses;
+        std::vector<uint32_t> object_record_base; // object -> first index into mesh_records
+        std::vector<uint32_t> object_classes; // object -> segmentation_class, consumed by update() for overlay slots
+        uint32_t num_scene_instances = 0;
+        VkAccelerationStructureKHR tlas = VK_NULL_HANDLE;
+        std::vector<VkAccelerationStructureKHR> overlay_tlas; // one per overlay, rebuilt in place by update()
+        std::vector<BufferResource> overlay_tlas_buffers;
+        std::vector<BufferResource> overlay_instance_buffers;
+        std::vector<BufferResource> overlay_sample_instance_buffers; // dynamic motion blur: one per motion sample, NUM_OVERLAYS * MAX_OVERLAY_INSTANCES descriptors each
+        // flow: the previous instant's overlay TLASes, resident next to the current ones and
+        // rebuilt in place from transforms_previous by update() (shifted instance-id range)
+        std::vector<VkAccelerationStructureKHR> overlay_tlas_previous;
+        std::vector<BufferResource> overlay_tlas_previous_buffers;
+        std::vector<BufferResource> overlay_instance_buffers_previous;
+        VkDeviceSize overlay_scratch_stride = 0;
+
+        VkCommandBuffer cb_rgb = VK_NULL_HANDLE;
+        VkCommandBuffer cb_depth = VK_NULL_HANDLE;
+        VkCommandBuffer cb_collision = VK_NULL_HANDLE;
+        VkCommandBuffer cb_segmentation = VK_NULL_HANDLE;
+        VkCommandBuffer cb_normals = VK_NULL_HANDLE;
+        VkCommandBuffer cb_flow = VK_NULL_HANDLE;
+        VkCommandBuffer cb_flow_forward = VK_NULL_HANDLE;
+        VkCommandBuffer cb_dynamic = VK_NULL_HANDLE; // dynamic motion blur frame, re-recorded per render_launch
+        VkFence fence_render = VK_NULL_HANDLE;
+        VkFence fence_collision = VK_NULL_HANDLE;
+        VkFence fence_update = VK_NULL_HANDLE;
+        VkCommandBuffer update_command_buffer = VK_NULL_HANDLE;
+        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/vulkan/device_source.h

@@ -0,0 +1,48 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_VULKAN_DEVICE_SOURCE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RENDERING_RAYTRACING_BACKENDS_VULKAN_DEVICE_SOURCE_H
+
+#include <cstdint>
+#include <cstddef>
+
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_rgb(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_depth(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_collision(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_segmentation(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_normals(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_flow(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_flow_forward(size_t* size_bytes);
+extern "C" const uint32_t* rl_tools_rendering_raytracing_vulkan_device_spirv_resolve(size_t* size_bytes);
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rendering::raytracing::backends::vulkan{
+    inline const uint32_t* device_spirv_rgb(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_rgb(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_depth(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_depth(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_collision(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_collision(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_segmentation(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_segmentation(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_normals(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_normals(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_flow(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_flow(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_flow_forward(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_flow_forward(&size_bytes);
+    }
+    inline const uint32_t* device_spirv_resolve(size_t& size_bytes){
+        return rl_tools_rendering_raytracing_vulkan_device_spirv_resolve(&size_bytes);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif