hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/src/rendering/raytracing/backends/vulkan/device.comp

@@ -0,0 +1,970 @@
+// Vulkan device programs for the RLtools raytracing renderer, compiled once per entry point
+// (ENTRY_RGB / ENTRY_DEPTH / ENTRY_COLLISION / ENTRY_SEGMENTATION / ENTRY_NORMALS / ENTRY_FLOW /
+// ENTRY_FLOW_FORWARD / ENTRY_RESOLVE). This file is a
+// function-for-function mirror of backends/metal/device.metal (which mirrors
+// backends/optix/device_impl.h) — keep the shading logic in sync; the golden-image parity
+// suite is the drift detector. Metal's RGBTracer<DEPTH> template recursion is restructured
+// here as shade_*_local + SecondaryRequest because GLSL forbids recursion: the leaf trace
+// shades without secondary rays (= DEPTH=1 behavior).
+// Struct layouts (LaunchParams, MeshRecord, InstanceData) and binding/spec-constant indices
+// must match include/rl_tools/rendering/raytracing/backends/vulkan/context.h.
+#version 460
+#extension GL_EXT_ray_query : require
+#extension GL_EXT_buffer_reference : require
+#extension GL_EXT_nonuniform_qualifier : require
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout(constant_id = 0) const bool fc_srgb_output = false;
+layout(constant_id = 1) const bool fc_motion_blur = false;
+layout(constant_id = 2) const int fc_motion_samples = 1;
+layout(constant_id = 3) const int fc_aa_grid = 1;
+layout(constant_id = 4) const bool fc_checker_background = false;
+layout(constant_id = 5) const bool fc_load_textures = false;
+layout(constant_id = 6) const bool fc_normal_shading = false;
+layout(constant_id = 7) const bool fc_metallic_reflections = false;
+layout(constant_id = 8) const bool fc_pbr_shading = false;
+layout(constant_id = 9) const bool fc_punctual_light_shadows = false;
+layout(constant_id = 10) const int fc_overlay_count = 0;
+layout(constant_id = 11) const bool fc_semantic_segmentation = false;
+layout(constant_id = 12) const bool fc_has_observation = false;
+// dynamic motion blur: the motion loop runs at submit level (one dispatch per sample against
+// per-sample overlay TLAS state); each pass reads its shutter time from the push constant and
+// adds its linear mean into the accumulation buffers, resolved by ENTRY_RESOLVE
+layout(constant_id = 13) const bool fc_dynamic_motion_blur = false;
+layout(constant_id = 14) const bool fc_resolve_rgb = false;
+
+#if defined(ENTRY_RGB)
+layout(push_constant) uniform PushConstants{ float shutter_t; } push;
+#endif
+
+layout(std430, set = 0, binding = 0) readonly buffer LaunchParamsBuffer{
+    uint fb_width;
+    uint fb_height;
+    uint cam_width;
+    uint cam_height;
+    uint grid_cols;
+    uint num_cameras;
+    uint num_probes;
+    uint num_scene_lights;
+    float max_dist;
+    float ambient_color[3];
+    float miss_color_0[3];
+    float miss_color_1[3];
+    uint first_overlay_instance;
+    uint num_overlay_slots;
+    float padding[1];
+} params;
+
+struct Camera{
+    float pos[3];
+    float dir_00[3];
+    float dir_du[3];
+    float dir_dv[3];
+};
+
+layout(std430, set = 0, binding = 1) readonly buffer CamerasCloseBuffer{ Camera cameras_close[]; };
+layout(set = 0, binding = 8) uniform accelerationStructureEXT tlas;
+layout(std430, set = 0, binding = 13) readonly buffer OverlayAttachmentsBuffer{ uint overlay_attachments[]; };
+layout(std430, set = 0, binding = 14) readonly buffer OverlayNumActiveBuffer{ uint overlay_num_active[]; };
+layout(set = 0, binding = 15) uniform accelerationStructureEXT overlay_tlas[];
+
+#if defined(ENTRY_RGB)
+layout(std430, set = 0, binding = 2) readonly buffer CamerasOpenBuffer{ Camera cameras_open[]; };
+#endif
+
+#if defined(ENTRY_RGB) || defined(ENTRY_RESOLVE)
+layout(std430, set = 0, binding = 18) buffer RgbAccumulationBuffer{ float rgb_accumulation[]; };
+#endif
+#if defined(ENTRY_RESOLVE)
+layout(std430, set = 0, binding = 3) writeonly buffer ResolveFrameBuffer{ uint fb[]; };
+layout(std430, set = 0, binding = 17) writeonly buffer ResolveObservationBuffer{ float observation[]; };
+#endif
+
+#if defined(ENTRY_RGB) || defined(ENTRY_NORMALS)
+layout(buffer_reference, std430, buffer_reference_align = 4) readonly buffer IntArray{ int v[]; };
+layout(buffer_reference, std430, buffer_reference_align = 4) readonly buffer FloatArray{ float v[]; };
+
+struct MeshRecord{
+    IntArray index;
+    FloatArray vertices;
+    FloatArray tex_coord;
+    FloatArray normal;
+    uint texture;
+    uint normal_map;
+    uint metallic_roughness_map;
+    uint emissive_map;
+    uint occlusion_map;
+    float color[3];
+    float metallic;
+    float roughness;
+    float opacity;
+    float emissive[3];
+    float alpha_cutoff;
+    int alpha_mode;
+    int has_texture;
+    int has_normal_map;
+    int has_metallic_roughness_map;
+    int has_emissive_map;
+    int has_occlusion_map;
+    int has_tex_coord;
+    int has_normals;
+    int unlit;
+};
+
+struct InstanceData{
+    float object_to_world[12]; // 3x4 row-major [R|t]
+    float world_to_object[12];
+    uint identity;
+    uint padding0;
+    uint padding1;
+    uint padding2;
+};
+
+layout(std430, set = 0, binding = 4) readonly buffer MeshRecordsBuffer{ MeshRecord meshes[]; };
+layout(std430, set = 0, binding = 11) readonly buffer InstanceRecordBaseBuffer{ uint instance_record_base[]; };
+layout(std430, set = 0, binding = 12) readonly buffer InstanceDataBuffer{ InstanceData instance_data[]; };
+
+vec3 transform_point_to_world(int instance, vec3 p){
+    const float m[12] = instance_data[instance].object_to_world;
+    return vec3(m[0]*p.x + m[1]*p.y + m[2]*p.z + m[3],
+                m[4]*p.x + m[5]*p.y + m[6]*p.z + m[7],
+                m[8]*p.x + m[9]*p.y + m[10]*p.z + m[11]);
+}
+#endif
+
+#if defined(ENTRY_RGB)
+struct SceneLight{
+    int type; // 0=directional, 1=point, 2=spot
+    float position[3];
+    float direction[3];
+    float color[3];
+    float attenuation_constant;
+    float attenuation_linear;
+    float attenuation_quadratic;
+    float cos_inner_cone;
+    float cos_outer_cone;
+};
+
+layout(std430, set = 0, binding = 3) writeonly buffer FrameBuffer{ uint fb[]; };
+layout(std430, set = 0, binding = 5) readonly buffer SceneLightsBuffer{ SceneLight scene_lights[]; };
+layout(std430, set = 0, binding = 17) writeonly buffer ObservationBuffer{ float observation[]; };
+layout(set = 0, binding = 28) uniform sampler2D scene_textures[];
+
+// normals transform with the inverse-transpose: multiply by the world_to_object columns
+vec3 transform_normal_to_world(int instance, vec3 n){
+    const float m[12] = instance_data[instance].world_to_object;
+    return vec3(m[0]*n.x + m[4]*n.y + m[8]*n.z,
+                m[1]*n.x + m[5]*n.y + m[9]*n.z,
+                m[2]*n.x + m[6]*n.y + m[10]*n.z);
+}
+#endif
+
+#if defined(ENTRY_DEPTH)
+layout(std430, set = 0, binding = 9) writeonly buffer DepthBuffer{ uint depth_out[]; };
+#endif
+
+#if defined(ENTRY_SEGMENTATION)
+layout(std430, set = 0, binding = 10) writeonly buffer SegmentationBuffer{ uint segmentation_out[]; };
+layout(std430, set = 0, binding = 16) readonly buffer InstanceClassesBuffer{ uint instance_classes[]; };
+#endif
+
+#if defined(ENTRY_NORMALS)
+layout(std430, set = 0, binding = 19) writeonly buffer NormalsBuffer{ float normals_out[]; };
+#endif
+
+#if defined(ENTRY_FLOW)
+layout(std430, set = 0, binding = 20) writeonly buffer FlowBuffer{ float flow_out[]; };
+layout(std430, set = 0, binding = 22) writeonly buffer FlowStatusBuffer{ uint flow_status_out[]; };
+#endif
+#if defined(ENTRY_FLOW_FORWARD)
+layout(std430, set = 0, binding = 23) writeonly buffer FlowBuffer{ float flow_out[]; };
+layout(std430, set = 0, binding = 24) writeonly buffer FlowStatusBuffer{ uint flow_status_out[]; };
+#endif
+#if defined(ENTRY_FLOW) || defined(ENTRY_FLOW_FORWARD)
+layout(std430, set = 0, binding = 21) readonly buffer FlowDeltasBuffer{ float flow_deltas[]; };
+layout(std430, set = 0, binding = 25) readonly buffer CamerasPreviousBuffer{ Camera cameras_previous[]; };
+layout(std430, set = 0, binding = 26) readonly buffer OverlayNumActivePreviousBuffer{ uint overlay_num_active_previous[]; };
+layout(set = 0, binding = 27) uniform accelerationStructureEXT overlay_tlas_previous[];
+#endif
+
+#if defined(ENTRY_COLLISION)
+struct CollisionResult{
+    float distance;
+    int hit;
+};
+layout(std430, set = 0, binding = 6) readonly buffer ProbeDirectionsBuffer{ float probe_directions[]; };
+layout(std430, set = 0, binding = 7) writeonly buffer CollisionResultsBuffer{ CollisionResult collision_results[]; };
+#endif
+
+vec3 camera_pos(Camera cam){ return vec3(cam.pos[0], cam.pos[1], cam.pos[2]); }
+vec3 camera_dir_00(Camera cam){ return vec3(cam.dir_00[0], cam.dir_00[1], cam.dir_00[2]); }
+vec3 camera_dir_du(Camera cam){ return vec3(cam.dir_du[0], cam.dir_du[1], cam.dir_du[2]); }
+vec3 camera_dir_dv(Camera cam){ return vec3(cam.dir_dv[0], cam.dir_dv[1], cam.dir_dv[2]); }
+
+struct Hit{
+    bool valid;
+    float t;
+    int instance_id;
+    int geometry_index;
+    int primitive_index;
+    vec2 bary;
+};
+
+Hit trace_single(accelerationStructureEXT as, vec3 origin, vec3 direction, float tmin, float tmax, uint flags){
+    rayQueryEXT rq;
+    rayQueryInitializeEXT(rq, as, flags, 0xffu, origin, tmin, direction, tmax);
+    while(rayQueryProceedEXT(rq)){}
+    Hit hit;
+    hit.valid = rayQueryGetIntersectionTypeEXT(rq, true) == gl_RayQueryCommittedIntersectionTriangleEXT;
+    if(hit.valid){
+        hit.t = rayQueryGetIntersectionTEXT(rq, true);
+        hit.instance_id = rayQueryGetIntersectionInstanceCustomIndexEXT(rq, true);
+        hit.geometry_index = rayQueryGetIntersectionGeometryIndexEXT(rq, true);
+        hit.primitive_index = rayQueryGetIntersectionPrimitiveIndexEXT(rq, true);
+        hit.bary = rayQueryGetIntersectionBarycentricsEXT(rq, true);
+    }
+    return hit;
+}
+
+// min-t composition of the shared world and the overlays attached to this camera; at
+// fc_overlay_count == 0 the loop specializes away and this is a plain intersect
+Hit intersect_composed(int camera, vec3 origin, vec3 direction, float tmin, float tmax, bool accept_any){
+    const uint flags = accept_any ? (gl_RayFlagsOpaqueEXT | gl_RayFlagsTerminateOnFirstHitEXT) : gl_RayFlagsOpaqueEXT;
+    Hit best = trace_single(tlas, origin, direction, tmin, tmax, flags);
+    for(int k = 0; k < fc_overlay_count; k++){
+        if(accept_any && best.valid){
+            return best;
+        }
+        const uint overlay = overlay_attachments[camera * fc_overlay_count + k];
+        if(overlay == 0xFFFFFFFFu){ continue; }
+        if(overlay_num_active[overlay] == 0u){ continue; }
+        const float clamped_tmax = best.valid ? best.t : tmax;
+        Hit hit = trace_single(overlay_tlas[nonuniformEXT(overlay)], origin, direction, tmin, clamped_tmax, flags);
+        if(hit.valid){
+            best = hit;
+        }
+    }
+    return best;
+}
+
+struct PixelLaunchContext{
+    int cam_idx;
+    int local_x;
+    int local_y;
+    int fb_offset;
+    bool valid;
+};
+
+PixelLaunchContext pixel_launch_context(uvec2 pixel_id){
+    PixelLaunchContext ctx;
+    const int tile_col = int(pixel_id.x / params.cam_width);
+    const int tile_row = int(pixel_id.y / params.cam_height);
+    ctx.cam_idx = tile_row * int(params.grid_cols) + tile_col;
+    ctx.local_x = int(pixel_id.x) - tile_col * int(params.cam_width);
+    ctx.local_y = int(pixel_id.y) - tile_row * int(params.cam_height);
+    ctx.fb_offset = ctx.cam_idx * int(params.cam_width) * int(params.cam_height) + ctx.local_y * int(params.cam_width) + ctx.local_x;
+    ctx.valid = pixel_id.x < params.fb_width && pixel_id.y < params.fb_height && ctx.cam_idx < int(params.num_cameras);
+    return ctx;
+}
+
+#if defined(ENTRY_RGB) || defined(ENTRY_RESOLVE)
+uint make_8bit(float f){
+    return uint(min(255, max(0, int(f * 256.0))));
+}
+
+uint make_rgba(vec3 color){
+    return (make_8bit(color.x) << 0) | (make_8bit(color.y) << 8) | (make_8bit(color.z) << 16) | (0xffu << 24);
+}
+
+float linear_to_srgb(float x){
+    if(x <= 0.0031308){
+        return 12.92 * x;
+    }
+    return 1.055 * pow(x, 1.0 / 2.4) - 0.055;
+}
+
+uint make_srgb_rgba_from_linear(vec3 color){
+    color.x = linear_to_srgb(min(max(color.x, 0.0), 1.0));
+    color.y = linear_to_srgb(min(max(color.y, 0.0), 1.0));
+    color.z = linear_to_srgb(min(max(color.z, 0.0), 1.0));
+    return make_rgba(color);
+}
+
+uint make_linear_rgba_from_linear(vec3 color){
+    color.x = min(max(color.x, 0.0), 1.0);
+    color.y = min(max(color.y, 0.0), 1.0);
+    color.z = min(max(color.z, 0.0), 1.0);
+    return make_rgba(color);
+}
+#endif
+
+#if defined(ENTRY_RGB)
+vec3 miss_color(uvec2 pixel_id){
+    if(fc_checker_background){
+        int checker_pattern = (int(pixel_id.x) / 8) ^ (int(pixel_id.y) / 8);
+        if((checker_pattern & 1) != 0){
+            return vec3(params.miss_color_1[0], params.miss_color_1[1], params.miss_color_1[2]);
+        }
+        return vec3(params.miss_color_0[0], params.miss_color_0[1], params.miss_color_0[2]);
+    }
+    return vec3(params.miss_color_0[0], params.miss_color_0[1], params.miss_color_0[2]);
+}
+
+bool trace_shadow_occluded(int camera, vec3 pos, vec3 direction, float max_dist){
+    Hit hit = intersect_composed(camera, pos, direction, 1e-3, max_dist, true);
+    return hit.valid;
+}
+#endif
+
+#if defined(ENTRY_RGB) || defined(ENTRY_NORMALS)
+ivec3 fetch_index(int mesh, int primitive){
+    return ivec3(meshes[mesh].index.v[3 * primitive], meshes[mesh].index.v[3 * primitive + 1], meshes[mesh].index.v[3 * primitive + 2]);
+}
+vec3 fetch_vertex(int mesh, int i){
+    return vec3(meshes[mesh].vertices.v[3 * i], meshes[mesh].vertices.v[3 * i + 1], meshes[mesh].vertices.v[3 * i + 2]);
+}
+#endif
+
+#if defined(ENTRY_RGB)
+vec2 fetch_tex_coord(int mesh, int i){
+    return vec2(meshes[mesh].tex_coord.v[2 * i], meshes[mesh].tex_coord.v[2 * i + 1]);
+}
+vec3 fetch_normal(int mesh, int i){
+    return vec3(meshes[mesh].normal.v[3 * i], meshes[mesh].normal.v[3 * i + 1], meshes[mesh].normal.v[3 * i + 2]);
+}
+vec4 sample_texture(uint texture_index, vec2 tc){
+    return textureLod(scene_textures[nonuniformEXT(texture_index)], tc, 0.0);
+}
+
+struct SecondaryRequest{
+    bool want_reflection;
+    vec3 reflect_dir;
+    float reflection_weight; // basic: fresnel factor, pbr: blend weight
+    bool want_transparency;
+    float alpha;
+    int alpha_mode;
+    vec3 hit_point;
+    vec3 ray_dir;
+};
+
+vec3 shade_basic_local(Hit hit, vec3 ray_origin, vec3 ray_dir, out SecondaryRequest request){
+    const int mesh = int(instance_record_base[hit.instance_id]) + hit.geometry_index;
+    request.want_reflection = false;
+    request.want_transparency = false;
+
+    vec3 base_color = vec3(meshes[mesh].color[0], meshes[mesh].color[1], meshes[mesh].color[2]);
+    vec3 normal_geometric = vec3(0.0, 0.0, 1.0);
+
+    if(fc_load_textures || fc_normal_shading || fc_metallic_reflections){
+        const ivec3 index = fetch_index(mesh, hit.primitive_index);
+
+        if(fc_normal_shading || fc_metallic_reflections){
+            vec3 vertex_a = fetch_vertex(mesh, index.x);
+            vec3 vertex_b = fetch_vertex(mesh, index.y);
+            vec3 vertex_c = fetch_vertex(mesh, index.z);
+            if(instance_data[hit.instance_id].identity == 0u){
+                vertex_a = transform_point_to_world(hit.instance_id, vertex_a);
+                vertex_b = transform_point_to_world(hit.instance_id, vertex_b);
+                vertex_c = transform_point_to_world(hit.instance_id, vertex_c);
+            }
+            normal_geometric = normalize(cross(vertex_b - vertex_a, vertex_c - vertex_a));
+        }
+
+        if(fc_load_textures){
+            if(meshes[mesh].has_texture != 0 && meshes[mesh].has_tex_coord != 0){
+                const vec2 bary = hit.bary;
+                const vec2 tc
+                    = (1.0 - bary.x - bary.y) * fetch_tex_coord(mesh, index.x)
+                    +        bary.x           * fetch_tex_coord(mesh, index.y)
+                    +               bary.y    * fetch_tex_coord(mesh, index.z);
+                vec4 tex_color = sample_texture(meshes[mesh].texture, tc);
+                base_color = tex_color.xyz * vec3(meshes[mesh].color[0], meshes[mesh].color[1], meshes[mesh].color[2]);
+            }
+        }
+    }
+
+    if(meshes[mesh].unlit != 0){
+        return base_color;
+    }
+
+    vec3 direct = base_color;
+    if(fc_normal_shading){
+        direct = (0.2 + 0.8 * abs(dot(ray_dir, normal_geometric))) * base_color;
+    }
+
+    if(fc_metallic_reflections){
+        if(meshes[mesh].metallic > 0.0){
+            vec3 hit_point = ray_origin + ray_dir * hit.t;
+            vec3 n = dot(ray_dir, normal_geometric) > 0.0 ? -normal_geometric : normal_geometric;
+            float cos_theta = abs(dot(ray_dir, n));
+            request.want_reflection = true;
+            request.reflect_dir = ray_dir - 2.0 * dot(ray_dir, n) * n;
+            request.reflection_weight = meshes[mesh].metallic * (0.04 + 0.96 * pow(1.0 - cos_theta, 5.0));
+            request.hit_point = hit_point;
+            request.ray_dir = ray_dir;
+        }
+    }
+    return direct;
+}
+
+vec3 shade_pbr_local(Hit hit, vec3 ray_origin, vec3 ray_dir, uvec2 pixel_id, int camera, out SecondaryRequest request){
+    const int mesh = int(instance_record_base[hit.instance_id]) + hit.geometry_index;
+    request.want_reflection = false;
+    request.want_transparency = false;
+
+    const bool instance_identity = instance_data[hit.instance_id].identity != 0u;
+    const ivec3 index = fetch_index(mesh, hit.primitive_index);
+    vec3 vertex_a = fetch_vertex(mesh, index.x);
+    vec3 vertex_b = fetch_vertex(mesh, index.y);
+    vec3 vertex_c = fetch_vertex(mesh, index.z);
+    if(!instance_identity){
+        vertex_a = transform_point_to_world(hit.instance_id, vertex_a);
+        vertex_b = transform_point_to_world(hit.instance_id, vertex_b);
+        vertex_c = transform_point_to_world(hit.instance_id, vertex_c);
+    }
+    const vec2 bary = hit.bary;
+    const float w0 = 1.0 - bary.x - bary.y;
+
+    const vec3 edge1 = vertex_b - vertex_a;
+    const vec3 edge2 = vertex_c - vertex_a;
+    const vec3 normal_geometric = normalize(cross(edge1, edge2));
+
+    vec3 N;
+    if(meshes[mesh].has_normals != 0){
+        vec3 normal_interpolated = w0 * fetch_normal(mesh, index.x) + bary.x * fetch_normal(mesh, index.y) + bary.y * fetch_normal(mesh, index.z);
+        if(!instance_identity){
+            normal_interpolated = transform_normal_to_world(hit.instance_id, normal_interpolated);
+        }
+        N = normalize(normal_interpolated);
+    }
+    else{
+        N = normal_geometric;
+    }
+
+    if(dot(ray_dir, N) > 0.0){
+        N = -N;
+    }
+
+    const bool has_tex_coord = meshes[mesh].has_tex_coord != 0;
+    const vec2 tc = has_tex_coord
+        ? w0 * fetch_tex_coord(mesh, index.x) + bary.x * fetch_tex_coord(mesh, index.y) + bary.y * fetch_tex_coord(mesh, index.z)
+        : vec2(0.0);
+
+    vec3 base_color = vec3(meshes[mesh].color[0], meshes[mesh].color[1], meshes[mesh].color[2]);
+    float alpha = meshes[mesh].opacity;
+    if(meshes[mesh].has_texture != 0 && has_tex_coord){
+        vec4 tex_color = sample_texture(meshes[mesh].texture, tc);
+        base_color = tex_color.xyz * vec3(meshes[mesh].color[0], meshes[mesh].color[1], meshes[mesh].color[2]);
+        alpha *= tex_color.w;
+    }
+
+    vec3 hit_point = ray_origin + ray_dir * hit.t;
+
+    vec3 color = base_color;
+    if(meshes[mesh].unlit == 0){
+        float metallic = meshes[mesh].metallic;
+        float roughness = meshes[mesh].roughness;
+        if(meshes[mesh].has_metallic_roughness_map != 0 && has_tex_coord){
+            vec4 mr_sample = sample_texture(meshes[mesh].metallic_roughness_map, tc);
+            roughness = mr_sample.y * meshes[mesh].roughness;
+            metallic = mr_sample.z * meshes[mesh].metallic;
+        }
+
+        if(meshes[mesh].has_normal_map != 0 && has_tex_coord){
+            const vec2 tc0 = fetch_tex_coord(mesh, index.x);
+            const vec2 tc1 = fetch_tex_coord(mesh, index.y);
+            const vec2 tc2 = fetch_tex_coord(mesh, index.z);
+            const vec2 duv1 = tc1 - tc0;
+            const vec2 duv2 = tc2 - tc0;
+            float det = duv1.x * duv2.y - duv2.x * duv1.y;
+            if(abs(det) > 1e-8){
+                float inv_det = 1.0 / det;
+                vec3 T = normalize(inv_det * (duv2.y * edge1 - duv1.y * edge2));
+                T = normalize(T - dot(T, N) * N);
+                vec3 B = cross(N, T);
+                vec4 nm_sample = sample_texture(meshes[mesh].normal_map, vec2(w0 * tc0.x + bary.x * tc1.x + bary.y * tc2.x, w0 * tc0.y + bary.x * tc1.y + bary.y * tc2.y));
+                vec3 n_tangent = vec3(nm_sample.x * 2.0 - 1.0, -(nm_sample.y * 2.0 - 1.0), nm_sample.z * 2.0 - 1.0);
+                N = normalize(T * n_tangent.x + B * n_tangent.y + N * n_tangent.z);
+            }
+        }
+
+        roughness = max(roughness, 0.04);
+        float roughness_alpha = roughness * roughness;
+        float alpha2 = roughness_alpha * roughness_alpha;
+        float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;
+
+        vec3 V = -ray_dir;
+        float NdotV = max(dot(N, V), 1e-4);
+        vec3 F0 = vec3(0.04) * (1.0 - metallic) + base_color * metallic;
+
+        vec3 Lo = vec3(0.0);
+        for(int li = 0; li < int(params.num_scene_lights); li++){
+            vec3 Lc = vec3(scene_lights[li].color[0], scene_lights[li].color[1], scene_lights[li].color[2]);
+            vec3 L;
+            float attenuation = 1.0;
+            float light_distance = 1e20;
+
+            if(scene_lights[li].type == 0){
+                L = vec3(scene_lights[li].direction[0], scene_lights[li].direction[1], scene_lights[li].direction[2]);
+            }
+            else{
+                vec3 to_light = vec3(scene_lights[li].position[0], scene_lights[li].position[1], scene_lights[li].position[2]) - hit_point;
+                float dist = length(to_light);
+                light_distance = max(dist - 1e-3, 0.0);
+                L = to_light * (1.0 / max(dist, 1e-6));
+                attenuation = 1.0 / (scene_lights[li].attenuation_constant + scene_lights[li].attenuation_linear * dist + scene_lights[li].attenuation_quadratic * dist * dist);
+                if(scene_lights[li].type == 2){
+                    vec3 spot_dir = vec3(scene_lights[li].direction[0], scene_lights[li].direction[1], scene_lights[li].direction[2]);
+                    float cos_angle = dot(-L, spot_dir);
+                    float denom = scene_lights[li].cos_inner_cone - scene_lights[li].cos_outer_cone;
+                    float spot_t = (cos_angle - scene_lights[li].cos_outer_cone) / (abs(denom) > 1e-6 ? denom : 1e-6);
+                    attenuation *= max(min(spot_t, 1.0), 0.0);
+                }
+            }
+
+            float NdotL = max(dot(N, L), 0.0);
+            if(NdotL <= 0.0){
+                continue;
+            }
+            if(fc_punctual_light_shadows){
+                if(scene_lights[li].type != 0 && trace_shadow_occluded(camera, hit_point + N * 2e-3, L, light_distance)){
+                    continue;
+                }
+            }
+
+            vec3 H = normalize(V + L);
+            float NdotH = max(dot(N, H), 0.0);
+            float VdotH = max(dot(V, H), 0.0);
+
+            float denom_D = NdotH * NdotH * (alpha2 - 1.0) + 1.0;
+            float D = alpha2 / (3.14159265 * denom_D * denom_D);
+
+            float G1_V = NdotV / (NdotV * (1.0 - k) + k);
+            float G1_L = NdotL / (NdotL * (1.0 - k) + k);
+            float G = G1_V * G1_L;
+
+            float pow5 = pow(1.0 - VdotH, 5.0);
+            vec3 F = F0 + (vec3(1.0) - F0) * pow5;
+
+            vec3 specular = D * G * F * (1.0 / (4.0 * NdotV * NdotL + 1e-4));
+            vec3 kd = (vec3(1.0) - F) * (1.0 - metallic);
+            vec3 diffuse = kd * base_color * (1.0 / 3.14159265);
+
+            Lo = Lo + (diffuse + specular) * Lc * (attenuation * NdotL);
+        }
+
+        float occlusion = 1.0;
+        if(meshes[mesh].has_occlusion_map != 0 && has_tex_coord){
+            vec4 ao_sample = sample_texture(meshes[mesh].occlusion_map, tc);
+            occlusion = ao_sample.x;
+        }
+
+        vec3 emissive_color;
+        if(meshes[mesh].has_emissive_map != 0 && has_tex_coord){
+            vec4 em_sample = sample_texture(meshes[mesh].emissive_map, tc);
+            emissive_color = em_sample.xyz * vec3(meshes[mesh].emissive[0], meshes[mesh].emissive[1], meshes[mesh].emissive[2]);
+        }
+        else{
+            emissive_color = vec3(meshes[mesh].emissive[0], meshes[mesh].emissive[1], meshes[mesh].emissive[2]);
+        }
+
+        vec3 ambient = vec3(params.ambient_color[0], params.ambient_color[1], params.ambient_color[2]) * base_color * ((1.0 - metallic) * occlusion);
+        color = ambient + Lo + emissive_color;
+
+        if(metallic > 0.1){
+            float fresnel_refl = F0.x + (1.0 - F0.x) * pow(1.0 - max(dot(V, N), 0.0), 5.0);
+            request.want_reflection = true;
+            request.reflect_dir = ray_dir - 2.0 * dot(ray_dir, N) * N;
+            request.reflection_weight = fresnel_refl * (1.0 - roughness);
+        }
+
+    }
+
+    bool transparent = (meshes[mesh].alpha_mode == 2 && alpha < 0.99) || (meshes[mesh].alpha_mode == 1 && alpha < meshes[mesh].alpha_cutoff);
+    if(transparent){
+        request.want_transparency = true;
+    }
+    request.alpha = alpha;
+    request.alpha_mode = meshes[mesh].alpha_mode;
+    request.hit_point = hit_point;
+    request.ray_dir = ray_dir;
+
+    return color;
+}
+
+vec3 trace_leaf(int camera, vec3 origin, vec3 direction, float tmin, uvec2 pixel_id){
+    Hit hit = intersect_composed(camera, origin, direction, tmin, 1e20, false);
+    if(!hit.valid){
+        return miss_color(pixel_id);
+    }
+    SecondaryRequest request;
+    if(fc_pbr_shading){
+        return shade_pbr_local(hit, origin, direction, pixel_id, camera, request);
+    }
+    return shade_basic_local(hit, origin, direction, request);
+}
+
+vec3 trace_primary(int camera, vec3 origin, vec3 direction, float tmin, float tmax, uvec2 pixel_id){
+    Hit hit = intersect_composed(camera, origin, direction, tmin, tmax, false);
+    if(!hit.valid){
+        return miss_color(pixel_id);
+    }
+    SecondaryRequest request;
+    if(fc_pbr_shading){
+        vec3 color = shade_pbr_local(hit, origin, direction, pixel_id, camera, request);
+        if(request.want_reflection){
+            vec3 reflected_color = trace_leaf(camera, request.hit_point, request.reflect_dir, 1e-3, pixel_id);
+            color = color * (1.0 - request.reflection_weight) + reflected_color * request.reflection_weight;
+        }
+        if(request.want_transparency){
+            vec3 behind_color = trace_leaf(camera, request.hit_point, request.ray_dir, 1e-5, pixel_id);
+            if(request.alpha_mode == 1){
+                color = behind_color;
+            }
+            else{
+                color = color * request.alpha + behind_color * (1.0 - request.alpha);
+            }
+        }
+        return color;
+    }
+    vec3 direct = shade_basic_local(hit, origin, direction, request);
+    if(fc_metallic_reflections && request.want_reflection){
+        vec3 reflected_color = trace_leaf(camera, request.hit_point, request.reflect_dir, 1e-3, pixel_id);
+        float fresnel = request.reflection_weight;
+        return direct * ((1.0 - fresnel) + fresnel * reflected_color);
+    }
+    return direct;
+}
+
+void main(){
+    const uvec2 pixel_id = gl_GlobalInvocationID.xy;
+    const PixelLaunchContext ctx = pixel_launch_context(pixel_id);
+    if(!ctx.valid){
+        return;
+    }
+
+    vec3 accumulated = vec3(0.0);
+    const float inv_aa_grid = 1.0 / float(fc_aa_grid);
+    const int motion_samples = fc_dynamic_motion_blur ? 1 : fc_motion_samples;
+    for(int motion_i = 0; motion_i < motion_samples; motion_i++){
+        vec3 pos;
+        vec3 dir_00;
+        vec3 dir_du;
+        vec3 dir_dv;
+        if(fc_motion_blur){
+            Camera cam_open = cameras_open[ctx.cam_idx];
+            Camera cam_close = cameras_close[ctx.cam_idx];
+            const float shutter_t = fc_dynamic_motion_blur ? push.shutter_t : (float(motion_i) + 0.5) * (1.0 / float(fc_motion_samples));
+            pos = mix(camera_pos(cam_open), camera_pos(cam_close), shutter_t);
+            dir_00 = mix(camera_dir_00(cam_open), camera_dir_00(cam_close), shutter_t);
+            dir_du = mix(camera_dir_du(cam_open), camera_dir_du(cam_close), shutter_t);
+            dir_dv = mix(camera_dir_dv(cam_open), camera_dir_dv(cam_close), shutter_t);
+        }
+        else{
+            Camera cam = cameras_close[ctx.cam_idx];
+            pos = camera_pos(cam);
+            dir_00 = camera_dir_00(cam);
+            dir_du = camera_dir_du(cam);
+            dir_dv = camera_dir_dv(cam);
+        }
+        for(int aa_y = 0; aa_y < fc_aa_grid; aa_y++){
+            for(int aa_x = 0; aa_x < fc_aa_grid; aa_x++){
+                const vec2 screen = (vec2(ctx.local_x, ctx.local_y) + vec2((float(aa_x) + 0.5) * inv_aa_grid, (float(aa_y) + 0.5) * inv_aa_grid)) / vec2(params.cam_width, params.cam_height);
+                const vec3 direction = normalize(dir_00 + screen.x * dir_du + screen.y * dir_dv);
+                accumulated += trace_primary(ctx.cam_idx, pos, direction, 0.0, 1e30, pixel_id);
+            }
+        }
+    }
+    const int samples = motion_samples * fc_aa_grid * fc_aa_grid;
+    const vec3 color = accumulated * (1.0 / float(samples));
+    if(fc_dynamic_motion_blur){
+        // one pass of the launch-level motion loop: add this pass's linear mean (each
+        // invocation owns its pixel — no atomics); ENTRY_RESOLVE averages and quantizes
+        rgb_accumulation[ctx.fb_offset * 3 + 0] += color.x;
+        rgb_accumulation[ctx.fb_offset * 3 + 1] += color.y;
+        rgb_accumulation[ctx.fb_offset * 3 + 2] += color.z;
+        return;
+    }
+    if(fc_has_observation){
+        // the observation is the frame-buffer color before 8-bit quantization
+        vec3 obs_color = clamp(color, 0.0, 1.0);
+        if(fc_srgb_output){
+            obs_color = vec3(linear_to_srgb(obs_color.x), linear_to_srgb(obs_color.y), linear_to_srgb(obs_color.z));
+        }
+        observation[ctx.fb_offset * 3 + 0] = obs_color.x;
+        observation[ctx.fb_offset * 3 + 1] = obs_color.y;
+        observation[ctx.fb_offset * 3 + 2] = obs_color.z;
+    }
+    if(fc_srgb_output){
+        fb[ctx.fb_offset] = make_srgb_rgba_from_linear(color);
+    }
+    else{
+        fb[ctx.fb_offset] = make_linear_rgba_from_linear(color);
+    }
+}
+#endif
+
+#if defined(ENTRY_DEPTH)
+void main(){
+    const PixelLaunchContext ctx = pixel_launch_context(gl_GlobalInvocationID.xy);
+    if(!ctx.valid){
+        return;
+    }
+    Camera cam = cameras_close[ctx.cam_idx];
+    const vec2 screen = (vec2(ctx.local_x, ctx.local_y) + vec2(0.5)) / vec2(params.cam_width, params.cam_height);
+    const vec3 direction = normalize(camera_dir_00(cam) + screen.x * camera_dir_du(cam) + screen.y * camera_dir_dv(cam));
+    const vec3 normal = normalize(cross(camera_dir_du(cam), camera_dir_dv(cam)));
+    const Hit hit = intersect_composed(ctx.cam_idx, camera_pos(cam), direction, 0.0, 1e30, false);
+    if(hit.valid){
+        depth_out[ctx.fb_offset] = floatBitsToUint(hit.t * abs(dot(direction, normal)));
+    }
+    else{
+        depth_out[ctx.fb_offset] = 0x7f800000u;
+    }
+}
+#endif
+
+#if defined(ENTRY_RESOLVE)
+// divides the accumulated linear radiance by the sample count and writes the declared outputs
+// with the same transfer curve + quantization as the single-dispatch path
+void main(){
+    const uvec2 pixel_id = gl_GlobalInvocationID.xy;
+    const PixelLaunchContext ctx = pixel_launch_context(pixel_id);
+    if(!ctx.valid){
+        return;
+    }
+    const float inv_samples = 1.0 / float(fc_motion_samples);
+    if(fc_resolve_rgb){
+        const vec3 color = vec3(
+            rgb_accumulation[ctx.fb_offset * 3 + 0],
+            rgb_accumulation[ctx.fb_offset * 3 + 1],
+            rgb_accumulation[ctx.fb_offset * 3 + 2]) * inv_samples;
+        if(fc_has_observation){
+            vec3 obs_color = clamp(color, 0.0, 1.0);
+            if(fc_srgb_output){
+                obs_color = vec3(linear_to_srgb(obs_color.x), linear_to_srgb(obs_color.y), linear_to_srgb(obs_color.z));
+            }
+            observation[ctx.fb_offset * 3 + 0] = obs_color.x;
+            observation[ctx.fb_offset * 3 + 1] = obs_color.y;
+            observation[ctx.fb_offset * 3 + 2] = obs_color.z;
+        }
+        if(fc_srgb_output){
+            fb[ctx.fb_offset] = make_srgb_rgba_from_linear(color);
+        }
+        else{
+            fb[ctx.fb_offset] = make_linear_rgba_from_linear(color);
+        }
+    }
+}
+#endif
+
+#if defined(ENTRY_COLLISION)
+void main(){
+    const int cam_idx = int(gl_GlobalInvocationID.x);
+    const int probe_idx = int(gl_GlobalInvocationID.y);
+
+    if(cam_idx >= int(params.num_cameras) || probe_idx >= int(params.num_probes)){
+        return;
+    }
+
+    Camera cam = cameras_close[cam_idx];
+
+    vec3 dir;
+    if(probe_idx == 0){
+        dir = normalize(camera_dir_00(cam) + 0.5 * camera_dir_du(cam) + 0.5 * camera_dir_dv(cam));
+    }
+    else{
+        dir = vec3(probe_directions[3 * probe_idx], probe_directions[3 * probe_idx + 1], probe_directions[3 * probe_idx + 2]);
+    }
+
+    Hit hit = intersect_composed(cam_idx, camera_pos(cam), dir, 1e-3, params.max_dist, false);
+
+    CollisionResult result;
+    if(!hit.valid){
+        result.distance = uintBitsToFloat(0x7f800000u);
+        result.hit = 0;
+    }
+    else{
+        result.distance = hit.t;
+        result.hit = 1;
+    }
+    collision_results[cam_idx * int(params.num_probes) + probe_idx] = result;
+}
+#endif
+
+#if defined(ENTRY_SEGMENTATION)
+// single-sample by design: instance labels cannot be averaged, so anti-aliasing and motion
+// blur do not apply (shutter-close camera, pixel-center ray)
+void main(){
+    const uvec2 pixel_id = gl_GlobalInvocationID.xy;
+    const PixelLaunchContext ctx = pixel_launch_context(pixel_id);
+    if(!ctx.valid){
+        return;
+    }
+    Camera cam = cameras_close[ctx.cam_idx];
+    const vec2 screen = (vec2(ctx.local_x, ctx.local_y) + vec2(0.5, 0.5)) / vec2(params.cam_width, params.cam_height);
+    const vec3 direction = normalize(camera_dir_00(cam) + screen.x * camera_dir_du(cam) + screen.y * camera_dir_dv(cam));
+    Hit hit = intersect_composed(ctx.cam_idx, camera_pos(cam), direction, 0.0, 1e30, false);
+    segmentation_out[ctx.fb_offset] = hit.valid ? (fc_semantic_segmentation ? instance_classes[uint(hit.instance_id)] : uint(hit.instance_id)) : 0xFFFFFFFFu;
+}
+#endif
+
+#if defined(ENTRY_NORMALS)
+// single-sample by design: unit normals cannot be averaged, so anti-aliasing and motion blur
+// do not apply (shutter-close camera, pixel-center ray); world-frame geometric normal,
+// oriented against the ray, zero on miss
+void main(){
+    const uvec2 pixel_id = gl_GlobalInvocationID.xy;
+    const PixelLaunchContext ctx = pixel_launch_context(pixel_id);
+    if(!ctx.valid){
+        return;
+    }
+    Camera cam = cameras_close[ctx.cam_idx];
+    const vec2 screen = (vec2(ctx.local_x, ctx.local_y) + vec2(0.5, 0.5)) / vec2(params.cam_width, params.cam_height);
+    const vec3 direction = normalize(camera_dir_00(cam) + screen.x * camera_dir_du(cam) + screen.y * camera_dir_dv(cam));
+    Hit hit = intersect_composed(ctx.cam_idx, camera_pos(cam), direction, 0.0, 1e30, false);
+    vec3 normal = vec3(0.0);
+    if(hit.valid){
+        const int mesh = int(instance_record_base[hit.instance_id]) + hit.geometry_index;
+        const ivec3 index = fetch_index(mesh, hit.primitive_index);
+        vec3 vertex_a = fetch_vertex(mesh, index.x);
+        vec3 vertex_b = fetch_vertex(mesh, index.y);
+        vec3 vertex_c = fetch_vertex(mesh, index.z);
+        if(instance_data[hit.instance_id].identity == 0u){
+            vertex_a = transform_point_to_world(hit.instance_id, vertex_a);
+            vertex_b = transform_point_to_world(hit.instance_id, vertex_b);
+            vertex_c = transform_point_to_world(hit.instance_id, vertex_c);
+        }
+        normal = normalize(cross(vertex_b - vertex_a, vertex_c - vertex_a));
+        if(dot(direction, normal) > 0.0){
+            normal = -normal;
+        }
+    }
+    normals_out[ctx.fb_offset * 3 + 0] = normal.x;
+    normals_out[ctx.fb_offset * 3 + 1] = normal.y;
+    normals_out[ctx.fb_offset * 3 + 2] = normal.z;
+}
+#endif
+
+#if defined(ENTRY_FLOW) || defined(ENTRY_FLOW_FORWARD)
+// FlowStatus codes (rl_tools/rendering/raytracing/types.h)
+const uint FLOW_STATUS_VALID = 0u;
+const uint FLOW_STATUS_MISS = 1u;
+const uint FLOW_STATUS_BEHIND = 2u;
+const uint FLOW_STATUS_OUT_OF_FRAME = 3u;
+const uint FLOW_STATUS_OCCLUDED = 4u;
+const float FLOW_VISIBILITY_EPSILON = 1e-4;
+#if defined(ENTRY_FLOW_FORWARD)
+const bool SOURCE_PREVIOUS = true;
+#else
+const bool SOURCE_PREVIOUS = false;
+#endif
+
+vec3 apply_flow_delta(uint base, vec3 p){
+    return vec3(
+        flow_deltas[base + 0]*p.x + flow_deltas[base + 1]*p.y + flow_deltas[base + 2]*p.z + flow_deltas[base + 3],
+        flow_deltas[base + 4]*p.x + flow_deltas[base + 5]*p.y + flow_deltas[base + 6]*p.z + flow_deltas[base + 7],
+        flow_deltas[base + 8]*p.x + flow_deltas[base + 9]*p.y + flow_deltas[base + 10]*p.z + flow_deltas[base + 11]);
+}
+
+// intersect_composed against one instant's overlay set: the current one (overlay_tlas) or the
+// previous one (overlay_tlas_previous, flow only)
+Hit intersect_composed_instant(bool previous, int camera, vec3 origin, vec3 direction, float tmin, float tmax, bool accept_any){
+    const uint flags = accept_any ? (gl_RayFlagsOpaqueEXT | gl_RayFlagsTerminateOnFirstHitEXT) : gl_RayFlagsOpaqueEXT;
+    Hit best = trace_single(tlas, origin, direction, tmin, tmax, flags);
+    for(int k = 0; k < fc_overlay_count; k++){
+        if(accept_any && best.valid){
+            return best;
+        }
+        const uint overlay = overlay_attachments[camera * fc_overlay_count + k];
+        if(overlay == 0xFFFFFFFFu){ continue; }
+        const uint num_active = previous ? overlay_num_active_previous[overlay] : overlay_num_active[overlay];
+        if(num_active == 0u){ continue; }
+        const float clamped_tmax = best.valid ? best.t : tmax;
+        Hit hit;
+        if(previous){
+            hit = trace_single(overlay_tlas_previous[nonuniformEXT(overlay)], origin, direction, tmin, clamped_tmax, flags);
+        }
+        else{
+            hit = trace_single(overlay_tlas[nonuniformEXT(overlay)], origin, direction, tmin, clamped_tmax, flags);
+        }
+        if(hit.valid){
+            best = hit;
+        }
+    }
+    return best;
+}
+
+// world point → screen fraction through the linear camera model: solves
+// dir_00 + screen_x·dir_du + screen_y·dir_dv = lambda·(point − pos) by Cramer's rule;
+// returns false for a degenerate basis or a point at/behind the camera (lambda <= 0)
+bool project_camera(Camera cam, vec3 point, out float screen_x, out float screen_y){
+    const vec3 direction = point - camera_pos(cam);
+    const vec3 dir_du = camera_dir_du(cam);
+    const vec3 dir_dv = camera_dir_dv(cam);
+    const vec3 negative_direction = -direction;
+    const vec3 cross_dv_negative_direction = cross(dir_dv, negative_direction);
+    const float det = dot(dir_du, cross_dv_negative_direction);
+    if(det > -1e-12 && det < 1e-12){
+        return false;
+    }
+    const float inv_det = 1.0 / det;
+    const vec3 b = -camera_dir_00(cam);
+    screen_x = dot(b, cross_dv_negative_direction) * inv_det;
+    screen_y = dot(dir_du, cross(b, negative_direction)) * inv_det;
+    const float lambda = dot(dir_du, cross(dir_dv, b)) * inv_det;
+    return lambda > 0.0;
+}
+
+// two-instant flow, one direction per entry point (mirror of the generic render_flow_frame):
+// single-sample from the source pixel centre against the source instant; the hit point is
+// carried to the target instant by its slot's delta, projected through the target camera, and
+// tested for visibility from the target camera against the target instant with the relative
+// margin FLOW_VISIBILITY_EPSILON. Status priority MISS, BEHIND, OUT_OF_FRAME, OCCLUDED, VALID;
+// the vector is zero for MISS and BEHIND and the geometric flow otherwise
+void main(){
+    const uvec2 pixel_id = gl_GlobalInvocationID.xy;
+    const PixelLaunchContext ctx = pixel_launch_context(pixel_id);
+    if(!ctx.valid){
+        return;
+    }
+    Camera cam = SOURCE_PREVIOUS ? cameras_previous[ctx.cam_idx] : cameras_close[ctx.cam_idx];
+    Camera cam_target = SOURCE_PREVIOUS ? cameras_close[ctx.cam_idx] : cameras_previous[ctx.cam_idx];
+    const uint source_first_overlay_instance = params.first_overlay_instance + (SOURCE_PREVIOUS ? params.num_overlay_slots : 0u);
+    const uint delta_slab = SOURCE_PREVIOUS ? params.num_overlay_slots * 12u : 0u;
+    const vec2 screen = (vec2(ctx.local_x, ctx.local_y) + vec2(0.5, 0.5)) / vec2(params.cam_width, params.cam_height);
+    const vec3 direction = normalize(camera_dir_00(cam) + screen.x * camera_dir_du(cam) + screen.y * camera_dir_dv(cam));
+    Hit hit = intersect_composed_instant(SOURCE_PREVIOUS, ctx.cam_idx, camera_pos(cam), direction, 0.0, 1e30, false);
+    vec2 flow = vec2(0.0);
+    uint status = FLOW_STATUS_MISS;
+    if(hit.valid){
+        vec3 point = camera_pos(cam) + direction * hit.t;
+        if(fc_overlay_count > 0 && uint(hit.instance_id) >= source_first_overlay_instance){
+            point = apply_flow_delta(delta_slab + (uint(hit.instance_id) - source_first_overlay_instance) * 12u, point);
+        }
+        float target_x;
+        float target_y;
+        if(!project_camera(cam_target, point, target_x, target_y)){
+            status = FLOW_STATUS_BEHIND;
+        }
+        else{
+            flow = vec2(target_x * float(params.cam_width) - (float(ctx.local_x) + 0.5),
+                        target_y * float(params.cam_height) - (float(ctx.local_y) + 0.5));
+            if(target_x < 0.0 || target_x >= 1.0 || target_y < 0.0 || target_y >= 1.0){
+                status = FLOW_STATUS_OUT_OF_FRAME;
+            }
+            else{
+                const vec3 to_point = point - camera_pos(cam_target);
+                const float len = length(to_point);
+                const vec3 visibility_direction = to_point * (1.0 / len);
+                Hit occluder = intersect_composed_instant(!SOURCE_PREVIOUS, ctx.cam_idx, camera_pos(cam_target), visibility_direction, 0.0, len * (1.0 - FLOW_VISIBILITY_EPSILON), true);
+                status = occluder.valid ? FLOW_STATUS_OCCLUDED : FLOW_STATUS_VALID;
+            }
+        }
+    }
+    flow_out[ctx.fb_offset * 2 + 0] = flow.x;
+    flow_out[ctx.fb_offset * 2 + 1] = flow.y;
+    flow_status_out[ctx.fb_offset] = status;
+}
+#endif