@gridspace/raster-path 1.0.7 → 1.0.8

package/src/core/path-radial-v3.js

@@ -0,0 +1,405 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * Path Radial V3 - Bucket-Angle Pipeline with Y-Filtering
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * ALGORITHM CHANGES FROM V2:
+ * ──────────────────────────
+ * V2 (current): Process all angles simultaneously
+ *   - Rotate rays on the fly
+ *   - Test all triangles in bucket (no Y-filtering)
+ *   - Large memory footprint: numAngles × gridWidth × gridHeight
+ *
+ * V3 (this file): Process bucket-by-angle pipeline
+ *   For each bucket:
+ *     For each angle:
+ *       1. Rotate triangles (parallel) → rotated tris + Y-bounds
+ *       2. Rasterize with Y-filter (parallel) → dense terrain strip
+ *       3. Toolpath generation (parallel) → sparse toolpath
+ *
+ * BENEFITS:
+ * ─────────
+ * - Lower memory: Only one angle's data in GPU at a time
+ * - Y-axis filtering: Skip triangles outside tool radius
+ * - Immediate toolpath generation: No need to store all strips
+ * - Better cache locality: Process bucket completely before moving on
+ *
+ * TODO: Memory Safety
+ * ───────────────────
+ * V3 currently does NOT have memory safety checks like V2 does. V2 batches angles
+ * if total memory (numAngles × gridWidth × gridHeight × 4) exceeds 1800MB.
+ *
+ * V3 processes one angle at a time (inherently lower memory), but doesn't check if:
+ *   - Triangle input buffer (triangles.byteLength) exceeds GPU limits
+ *   - Rotated triangles buffer (numTriangles × 11 × 4) exceeds GPU limits
+ *   - Output raster buffer (fullGridWidth × gridHeight × 4) exceeds GPU limits
+ *
+ * This could cause crashes on extremely large models with millions of triangles.
+ * Consider adding checks and batching for triangle buffers if needed.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+import {
+    device, config, debug, diagnostic,
+    cachedRadialV3RotatePipeline,
+    cachedRadialV3BatchedRasterizePipeline
+} from './raster-config.js';
+import {
+    createReusableToolpathBuffers,
+    destroyReusableToolpathBuffers,
+    runToolpathComputeWithBuffers
+} from './path-planar.js';
+import { createSparseToolFromPoints } from './raster-tool.js';
+
+/**
+ * Rotate all triangles in a bucket by a single angle
+ */
+async function rotateTriangles({
+    triangleBuffer,      // GPU buffer with original triangles
+    numTriangles,
+    angle                // Radians
+}) {
+    const rotatePipeline = cachedRadialV3RotatePipeline;
+    if (!rotatePipeline) {
+        throw new Error('Radial V3 pipelines not initialized');
+    }
+
+    // Create output buffer for rotated triangles + bounds
+    // Layout: 11 floats per triangle (v0, v1, v2, y_min, y_max)
+    const outputSize = numTriangles * 11 * 4;
+    const rotatedBuffer = device.createBuffer({
+        size: outputSize,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    });
+
+    // Create uniforms
+    const uniformBuffer = device.createBuffer({
+        size: 8,  // f32 angle + u32 num_triangles
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+
+    const uniformView = new ArrayBuffer(8);
+    const floatView = new Float32Array(uniformView);
+    const uintView = new Uint32Array(uniformView);
+    floatView[0] = angle;
+    uintView[1] = numTriangles;
+
+    new Uint8Array(uniformBuffer.getMappedRange()).set(new Uint8Array(uniformView));
+    uniformBuffer.unmap();
+
+    // Create bind group
+    const bindGroup = device.createBindGroup({
+        layout: rotatePipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: triangleBuffer } },
+            { binding: 1, resource: { buffer: rotatedBuffer } },
+            { binding: 2, resource: { buffer: uniformBuffer } }
+        ]
+    });
+
+    // Dispatch
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(rotatePipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+    passEncoder.dispatchWorkgroups(Math.ceil(numTriangles / 64));
+    passEncoder.end();
+
+    device.queue.submit([commandEncoder.finish()]);
+
+    // Cleanup
+    uniformBuffer.destroy();
+
+    return rotatedBuffer;
+}
+
+/**
+ * Rasterize ALL buckets in one dispatch (batched GPU processing)
+ */
+async function rasterizeAllBuckets({
+    rotatedTrianglesBuffer,
+    buckets,
+    triangleIndices,
+    resolution,
+    toolRadius,
+    fullGridWidth,
+    gridHeight,
+    globalMinX,
+    bucketMinY,
+    zFloor
+}) {
+    const rasterizePipeline = cachedRadialV3BatchedRasterizePipeline;
+    if (!rasterizePipeline) {
+        throw new Error('Radial V3 batched pipeline not initialized');
+    }
+
+    // Create bucket info buffer (all buckets)
+    const bucketInfoSize = buckets.length * 16;  // 4 fields × 4 bytes per bucket
+    const bucketInfoBuffer = device.createBuffer({
+        size: bucketInfoSize,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+
+    const bucketView = new ArrayBuffer(bucketInfoSize);
+    const bucketFloatView = new Float32Array(bucketView);
+    const bucketUintView = new Uint32Array(bucketView);
+
+    for (let i = 0; i < buckets.length; i++) {
+        const bucket = buckets[i];
+        const offset = i * 4;
+        bucketFloatView[offset] = bucket.minX;
+        bucketFloatView[offset + 1] = bucket.maxX;
+        bucketUintView[offset + 2] = bucket.startIndex;
+        bucketUintView[offset + 3] = bucket.count;
+    }
+
+    new Uint8Array(bucketInfoBuffer.getMappedRange()).set(new Uint8Array(bucketView));
+    bucketInfoBuffer.unmap();
+
+    // Create triangle indices buffer
+    const indicesBuffer = device.createBuffer({
+        size: triangleIndices.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+    new Uint32Array(indicesBuffer.getMappedRange()).set(triangleIndices);
+    indicesBuffer.unmap();
+
+    // Create output buffer for full terrain strip
+    const outputSize = fullGridWidth * gridHeight * 4;
+    const outputBuffer = device.createBuffer({
+        size: outputSize,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    });
+
+    // Initialize with zFloor
+    const initData = new Float32Array(fullGridWidth * gridHeight);
+    initData.fill(zFloor);
+    device.queue.writeBuffer(outputBuffer, 0, initData);
+
+    // Create uniforms
+    const uniformBuffer = device.createBuffer({
+        size: 32,  // 8 fields × 4 bytes
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+
+    const uniformView = new ArrayBuffer(32);
+    const floatView = new Float32Array(uniformView);
+    const uintView = new Uint32Array(uniformView);
+
+    floatView[0] = resolution;
+    floatView[1] = toolRadius;
+    uintView[2] = fullGridWidth;
+    uintView[3] = gridHeight;
+    floatView[4] = globalMinX;
+    floatView[5] = bucketMinY;
+    floatView[6] = zFloor;
+    uintView[7] = buckets.length;
+
+    new Uint8Array(uniformBuffer.getMappedRange()).set(new Uint8Array(uniformView));
+    uniformBuffer.unmap();
+
+    // Create bind group
+    const bindGroup = device.createBindGroup({
+        layout: rasterizePipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: rotatedTrianglesBuffer } },
+            { binding: 1, resource: { buffer: outputBuffer } },
+            { binding: 2, resource: { buffer: uniformBuffer } },
+            { binding: 3, resource: { buffer: bucketInfoBuffer } },
+            { binding: 4, resource: { buffer: indicesBuffer } }
+        ]
+    });
+
+    // Dispatch - covers full grid width (all buckets)
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(rasterizePipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+
+    const dispatchX = Math.ceil(fullGridWidth / 8);
+    const dispatchY = Math.ceil(gridHeight / 8);
+    passEncoder.dispatchWorkgroups(dispatchX, dispatchY);
+    passEncoder.end();
+
+    // Read back results
+    const stagingBuffer = device.createBuffer({
+        size: outputSize,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+
+    commandEncoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, outputSize);
+    device.queue.submit([commandEncoder.finish()]);
+
+    await device.queue.onSubmittedWorkDone();
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+    const terrainData = new Float32Array(stagingBuffer.getMappedRange().slice());
+    stagingBuffer.unmap();
+
+    // Cleanup
+    outputBuffer.destroy();
+    stagingBuffer.destroy();
+    uniformBuffer.destroy();
+    bucketInfoBuffer.destroy();
+    indicesBuffer.destroy();
+
+    return terrainData;
+}
+/**
+ * Generate radial toolpaths using bucket-angle pipeline
+ */
+export async function generateRadialToolpathsV3({
+    triangles,
+    bucketData,
+    toolData,
+    resolution,
+    angleStep,
+    numAngles,
+    maxRadius,
+    toolWidth,
+    zFloor,
+    bounds,
+    xStep,
+    yStep
+}) {
+    debug.log('radial-v3-generate-toolpaths', { triangles: triangles.length / 9, numAngles, resolution });
+
+    const pipelineStartTime = performance.now();
+    const allStripToolpaths = [];
+    let totalToolpathPoints = 0;
+
+    // Prepare sparse tool once
+    const sparseToolData = createSparseToolFromPoints(toolData.positions);
+    debug.log(`Created sparse tool: ${sparseToolData.count} points (reusing for all strips)`);
+
+    const toolRadius = toolWidth / 2;
+
+    // Calculate full grid dimensions (all buckets)
+    const bucketMinX = bucketData.buckets[0].minX;
+    const bucketMaxX = bucketData.buckets[bucketData.numBuckets - 1].maxX;
+    const fullWidth = bucketMaxX - bucketMinX;
+    const fullGridWidth = Math.ceil(fullWidth / resolution);
+    const gridHeight = Math.ceil(toolWidth / resolution);
+
+    // OPTIMIZATION: Upload all triangles to GPU ONCE (reused across all angles)
+    debug.log(`Uploading ${triangles.length / 9} triangles to GPU (reused across all angles)...`);
+    const allTrianglesBuffer = device.createBuffer({
+        size: triangles.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+    new Float32Array(allTrianglesBuffer.getMappedRange()).set(triangles);
+    allTrianglesBuffer.unmap();
+
+    // Process angle-by-angle (outer loop)
+    for (let angleIdx = 0; angleIdx < numAngles; angleIdx++) {
+        const angle = -(angleIdx * angleStep * (Math.PI / 180));  // Convert to radians (negative: rotating terrain vs tool)
+        const angleDegrees = angleIdx * angleStep;
+
+        if (diagnostic) {
+            debug.log(`Angle ${angleIdx + 1}/${numAngles}: ${angleDegrees.toFixed(1)}°`);
+        }
+
+        // Report progress
+        if (angleIdx % 10 === 0 || angleIdx === numAngles - 1) {
+            const stripProgress = ((angleIdx + 1) / numAngles) * 98;
+            self.postMessage({
+                type: 'toolpath-progress',
+                data: {
+                    percent: Math.round(stripProgress),
+                    current: angleIdx + 1,
+                    total: numAngles,
+                    layer: angleIdx + 1
+                }
+            });
+        }
+
+        // OPTIMIZATION: Rotate ALL triangles once per angle (batch rotation)
+        const numTotalTriangles = triangles.length / 9;
+        const allRotatedTrianglesBuffer = await rotateTriangles({
+            triangleBuffer: allTrianglesBuffer,
+            numTriangles: numTotalTriangles,
+            angle
+        });
+
+        // OPTIMIZATION: Rasterize ALL buckets in ONE dispatch (no CPU loop!)
+        const fullTerrainStrip = await rasterizeAllBuckets({
+            rotatedTrianglesBuffer: allRotatedTrianglesBuffer,
+            buckets: bucketData.buckets,
+            triangleIndices: bucketData.triangleIndices,
+            resolution,
+            toolRadius,
+            fullGridWidth,
+            gridHeight,
+            globalMinX: bucketMinX,
+            bucketMinY: -toolWidth / 2,
+            zFloor
+        });
+
+        // Cleanup rotated buffer (created per angle)
+        allRotatedTrianglesBuffer.destroy();
+
+        // Step 3: Generate toolpath for this complete angle strip
+        const reusableToolpathBuffers = createReusableToolpathBuffers(
+            fullGridWidth,
+            gridHeight,
+            sparseToolData,
+            xStep,
+            gridHeight
+        );
+
+        const stripToolpathResult = await runToolpathComputeWithBuffers(
+            fullTerrainStrip,
+            fullGridWidth,
+            gridHeight,
+            xStep,
+            gridHeight,
+            zFloor,
+            reusableToolpathBuffers,
+            pipelineStartTime
+        );
+
+        destroyReusableToolpathBuffers(reusableToolpathBuffers);
+
+        allStripToolpaths.push({
+            angle: angleDegrees,
+            pathData: stripToolpathResult.pathData,
+            numScanlines: stripToolpathResult.numScanlines,
+            pointsPerLine: stripToolpathResult.pointsPerLine,
+            terrainBounds: {
+                min: { x: bucketMinX, y: -toolWidth / 2, z: zFloor },
+                max: { x: bucketMaxX, y: toolWidth / 2, z: bounds.max.z }
+            }
+        });
+
+        totalToolpathPoints += stripToolpathResult.pathData.length;
+    }
+
+    // Cleanup triangles buffer (reused across all angles)
+    allTrianglesBuffer.destroy();
+    debug.log(`Destroyed reusable triangle buffer`);
+
+    const pipelineTotalTime = performance.now() - pipelineStartTime;
+    debug.log(`Complete radial V3 toolpath: ${allStripToolpaths.length} strips, ${totalToolpathPoints} total points in ${pipelineTotalTime.toFixed(0)}ms`);
+
+    // Send final 100% progress
+    self.postMessage({
+        type: 'toolpath-progress',
+        data: {
+            percent: 100,
+            current: bucketData.numBuckets * numAngles,
+            total: bucketData.numBuckets * numAngles,
+            layer: numAngles
+        }
+    });
+
+    return {
+        strips: allStripToolpaths,
+        totalPoints: totalToolpathPoints,
+        numStrips: allStripToolpaths.length
+    };
+}

package/src/core/raster-config.js

@@ -65,6 +65,10 @@ export let cachedRadialBatchPipeline = null;
 export let cachedRadialBatchShaderModule = null;
 export let cachedTracingPipeline = null;
 export let cachedTracingShaderModule = null;
+export let cachedRadialV3RotatePipeline = null;
+export let cachedRadialV3RotateShaderModule = null;
+export let cachedRadialV3BatchedRasterizePipeline = null;
+export let cachedRadialV3BatchedRasterizeShaderModule = null;
 
 // Constants
 export const EMPTY_CELL = -1e10;
@@ -97,6 +101,8 @@ const rasterizeShaderCode = 'SHADER:planar-rasterize';
 const toolpathShaderCode = 'SHADER:planar-toolpath';
 const radialRasterizeShaderCode = 'SHADER:radial-raster';
 const tracingShaderCode = 'SHADER:tracing-toolpath';
+const radialV3RotateShaderCode = 'SHADER:radial-rotate-triangles';
+const radialV3BatchedRasterizeShaderCode = 'SHADER:radial-rasterize-batched';
 
 // Initialize WebGPU device in worker context
 export async function initWebGPU() {
@@ -167,6 +173,24 @@ export async function initWebGPU() {
             compute: { module: cachedTracingShaderModule, entryPoint: 'main' },
         });
 
+        // Pre-compile radial V3 rotate shader module
+        cachedRadialV3RotateShaderModule = device.createShaderModule({ code: radialV3RotateShaderCode });
+
+        // Pre-create radial V3 rotate pipeline
+        cachedRadialV3RotatePipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: cachedRadialV3RotateShaderModule, entryPoint: 'main' },
+        });
+
+        // Pre-compile radial V3 batched rasterize shader module
+        cachedRadialV3BatchedRasterizeShaderModule = device.createShaderModule({ code: radialV3BatchedRasterizeShaderCode });
+
+        // Pre-create radial V3 batched rasterize pipeline
+        cachedRadialV3BatchedRasterizePipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: cachedRadialV3BatchedRasterizeShaderModule, entryPoint: 'main' },
+        });
+
         // Store device capabilities
         deviceCapabilities = {
             maxStorageBufferBindingSize: device.limits.maxStorageBufferBindingSize,

package/src/core/raster-path.js

@@ -111,6 +111,7 @@ export class RasterPath {
             gpuMemorySafetyMargin: config.gpuMemorySafetyMargin ?? 0.8,
             autoTiling: config.autoTiling ?? true,
             batchDivisor: config.batchDivisor ?? 1, // For testing batching overhead
+            radialV3: config.radialV3 ?? false, // Use radial V3 pipeline (rotate-filter-toolpath)
             debug: config.debug,
             quiet: config.quiet
         };
@@ -531,9 +532,13 @@ export class RasterPath {
                 resolve(data);
             };
 
-            // Send entire pipeline to worker
+            // Send entire pipeline to worker (use V3 if configured)
+            const messageType = this.config.radialV3
+                ? 'radial-generate-toolpaths-v3'
+                : 'radial-generate-toolpaths';
+
             this.#sendMessage(
-                'radial-generate-toolpaths',
+                messageType,
                 {
                     triangles: triangles,
                     bucketData,

package/src/core/raster-worker.js

@@ -54,6 +54,7 @@ import { initWebGPU, setConfig, updateConfig, deviceCapabilities, debug, device
 import { rasterizeMesh } from './raster-planar.js';
 import { generateToolpath } from './path-planar.js';
 import { generateRadialToolpaths } from './path-radial.js';
+import { generateRadialToolpathsV3 } from './path-radial-v3.js';
 import { generateTracingToolpaths, createReusableTracingBuffers, destroyReusableTracingBuffers } from './path-tracing.js';
 import { calibrateGPU } from './workload-calibrate.js';
 
@@ -128,6 +129,15 @@ self.onmessage = async function(e) {
                 }, toolpathTransferBuffers);
                 break;
 
+            case 'radial-generate-toolpaths-v3':
+                const radialV3ToolpathResult = await generateRadialToolpathsV3(data);
+                const v3ToolpathTransferBuffers = radialV3ToolpathResult.strips.map(strip => strip.pathData.buffer);
+                self.postMessage({
+                    type: 'radial-toolpaths-complete',
+                    data: radialV3ToolpathResult
+                }, v3ToolpathTransferBuffers);
+                break;
+
             case 'tracing-generate-toolpaths':
                 const tracingResult = await generateTracingToolpaths({
                     paths: data.paths,

package/src/shaders/radial-rasterize-batched.wgsl

@@ -0,0 +1,164 @@
+// Radial V3 batched bucket rasterization
+// Processes ALL buckets in one dispatch - GPU threads find their bucket
+
+const EPSILON: f32 = 0.0001;
+
+struct Uniforms {
+    resolution: f32,         // Grid step size (mm)
+    tool_radius: f32,        // Tool radius for Y-filtering
+    full_grid_width: u32,    // Full grid width (all buckets)
+    grid_height: u32,        // Number of Y cells
+    global_min_x: f32,       // Global minimum X coordinate
+    bucket_min_y: f32,       // Y-axis start (typically -tool_width/2)
+    z_floor: f32,            // Z value for empty cells
+    num_buckets: u32,        // Number of buckets
+}
+
+struct BucketInfo {
+    min_x: f32,              // Bucket X range start
+    max_x: f32,              // Bucket X range end
+    start_index: u32,        // Index into triangle_indices array
+    count: u32,              // Number of triangles in this bucket
+}
+
+@group(0) @binding(0) var<storage, read> rotated_triangles: array<f32>;   // ALL rotated triangles + bounds
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;        // Full-width output grid
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+@group(0) @binding(3) var<storage, read> all_buckets: array<BucketInfo>;  // All bucket descriptors
+@group(0) @binding(4) var<storage, read> triangle_indices: array<u32>;    // All triangle indices
+
+// Simplified ray-triangle intersection for downward rays
+fn ray_triangle_intersect_downward(
+    ray_origin: vec3<f32>,
+    v0: vec3<f32>,
+    v1: vec3<f32>,
+    v2: vec3<f32>
+) -> vec2<f32> {  // Returns (hit: 0.0 or 1.0, t: distance along ray)
+    let ray_dir = vec3<f32>(0.0, 0.0, -1.0);
+
+    let edge1 = v1 - v0;
+    let edge2 = v2 - v0;
+    let h = cross(ray_dir, edge2);
+    let a = dot(edge1, h);
+
+    if (a > -EPSILON && a < EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let f = 1.0 / a;
+    let s = ray_origin - v0;
+    let u = f * dot(s, h);
+
+    if (u < -EPSILON || u > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let q = cross(s, edge1);
+    let v = f * dot(ray_dir, q);
+
+    if (v < -EPSILON || u + v > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let t = f * dot(edge2, q);
+
+    if (t > EPSILON) {
+        return vec2<f32>(1.0, t);
+    }
+
+    return vec2<f32>(0.0, 0.0);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let grid_x = global_id.x;
+    let grid_y = global_id.y;
+
+    // Bounds check
+    if (grid_x >= uniforms.full_grid_width || grid_y >= uniforms.grid_height) {
+        return;
+    }
+
+    // Calculate world position
+    let world_x = uniforms.global_min_x + f32(grid_x) * uniforms.resolution;
+    let world_y = uniforms.bucket_min_y + f32(grid_y) * uniforms.resolution;
+
+    // FIND WHICH BUCKET THIS X POSITION BELONGS TO
+    // Simple linear search (could be binary search for many buckets)
+    var bucket_idx = 0u;
+    var found_bucket = false;
+    for (var i = 0u; i < uniforms.num_buckets; i++) {
+        if (world_x >= all_buckets[i].min_x && world_x < all_buckets[i].max_x) {
+            bucket_idx = i;
+            found_bucket = true;
+            break;
+        }
+    }
+
+    // If not in any bucket, write floor and return
+    if (!found_bucket) {
+        let output_idx = grid_y * uniforms.full_grid_width + grid_x;
+        output[output_idx] = uniforms.z_floor;
+        return;
+    }
+
+    let bucket = all_buckets[bucket_idx];
+
+    // Fixed downward ray from high above
+    let ray_origin = vec3<f32>(world_x, world_y, 1000.0);
+
+    // Track best (closest) hit
+    var best_z = uniforms.z_floor;
+
+    // Test triangles in this bucket with Y-bounds filtering
+    for (var i = 0u; i < bucket.count; i++) {
+        // Get triangle index from bucket's index array
+        let tri_idx = triangle_indices[bucket.start_index + i];
+
+        // Read Y-bounds first (cheaper than reading all vertices)
+        let base = tri_idx * 11u;
+        let y_min = rotated_triangles[base + 9u];
+        let y_max = rotated_triangles[base + 10u];
+
+        // Y-bounds check: skip triangles that don't overlap this ray's Y position
+        if (y_max < world_y - uniforms.tool_radius ||
+            y_min > world_y + uniforms.tool_radius) {
+            continue;
+        }
+
+        // Read rotated vertices
+        let v0 = vec3<f32>(
+            rotated_triangles[base],
+            rotated_triangles[base + 1u],
+            rotated_triangles[base + 2u]
+        );
+        let v1 = vec3<f32>(
+            rotated_triangles[base + 3u],
+            rotated_triangles[base + 4u],
+            rotated_triangles[base + 5u]
+        );
+        let v2 = vec3<f32>(
+            rotated_triangles[base + 6u],
+            rotated_triangles[base + 7u],
+            rotated_triangles[base + 8u]
+        );
+
+        let result = ray_triangle_intersect_downward(ray_origin, v0, v1, v2);
+        let hit = result.x;
+        let t = result.y;
+
+        if (hit > 0.5) {
+            // Calculate Z position of intersection
+            let hit_z = ray_origin.z - t;
+
+            // Keep highest (max Z) hit
+            if (hit_z > best_z) {
+                best_z = hit_z;
+            }
+        }
+    }
+
+    // Write to FULL-WIDTH output (no stitching needed!)
+    let output_idx = grid_y * uniforms.full_grid_width + grid_x;
+    output[output_idx] = best_z;
+}