@gridspace/raster-path 1.0.2

package/src/shaders/planar-rasterize.wgsl

@@ -0,0 +1,213 @@
+// Planar rasterization with spatial partitioning
+// Sentinel value for empty cells (far below any real geometry)
+const EMPTY_CELL: f32 = -1e10;
+
+struct Uniforms {
+    bounds_min_x: f32,
+    bounds_min_y: f32,
+    bounds_min_z: f32,
+    bounds_max_x: f32,
+    bounds_max_y: f32,
+    bounds_max_z: f32,
+    step_size: f32,
+    grid_width: u32,
+    grid_height: u32,
+    triangle_count: u32,
+    filter_mode: u32,  // 0 = UPWARD (terrain, keep highest), 1 = DOWNWARD (tool, keep lowest)
+    spatial_grid_width: u32,
+    spatial_grid_height: u32,
+    spatial_cell_size: f32,
+}
+
+@group(0) @binding(0) var<storage, read> triangles: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output_points: array<f32>;
+@group(0) @binding(2) var<storage, read_write> valid_mask: array<u32>;
+@group(0) @binding(3) var<uniform> uniforms: Uniforms;
+@group(0) @binding(4) var<storage, read> spatial_cell_offsets: array<u32>;
+@group(0) @binding(5) var<storage, read> spatial_triangle_indices: array<u32>;
+
+// Fast 2D bounding box check for XY plane
+fn ray_hits_triangle_bbox_2d(ray_x: f32, ray_y: f32, v0: vec3<f32>, v1: vec3<f32>, v2: vec3<f32>) -> bool {
+    // Add small epsilon to catch near-misses (mesh vertex gaps, FP rounding)
+    let epsilon = 0.001;  // 1 micron tolerance
+    let min_x = min(min(v0.x, v1.x), v2.x) - epsilon;
+    let max_x = max(max(v0.x, v1.x), v2.x) + epsilon;
+    let min_y = min(min(v0.y, v1.y), v2.y) - epsilon;
+    let max_y = max(max(v0.y, v1.y), v2.y) + epsilon;
+
+    return ray_x >= min_x && ray_x <= max_x && ray_y >= min_y && ray_y <= max_y;
+}
+
+// Ray-triangle intersection using Möller-Trumbore algorithm
+fn ray_triangle_intersect(
+    ray_origin: vec3<f32>,
+    ray_dir: vec3<f32>,
+    v0: vec3<f32>,
+    v1: vec3<f32>,
+    v2: vec3<f32>
+) -> vec2<f32> {  // Returns (hit: 0.0 or 1.0, z: intersection_z)
+    // Larger epsilon needed because near-parallel triangles (small 'a') amplify errors via f=1/a
+    let EPSILON = 0.0001;
+
+    // Early rejection using 2D bounding box (very cheap!)
+    if (!ray_hits_triangle_bbox_2d(ray_origin.x, ray_origin.y, v0, v1, v2)) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    // Calculate edges
+    let edge1 = v1 - v0;
+    let edge2 = v2 - v0;
+
+    // Cross product: ray_dir × edge2
+    let h = cross(ray_dir, edge2);
+
+    // Dot product: edge1 · h
+    let a = dot(edge1, h);
+
+    if (a > -EPSILON && a < EPSILON) {
+        return vec2<f32>(0.0, 0.0); // Ray parallel to triangle
+    }
+
+    let f = 1.0 / a;
+
+    // s = ray_origin - v0
+    let s = ray_origin - v0;
+
+    // u = f * (s · h)
+    let u = f * dot(s, h);
+
+    // Allow tolerance for edges/vertices to ensure watertight coverage
+    if (u < -EPSILON || u > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    // Cross product: s × edge1
+    let q = cross(s, edge1);
+
+    // v = f * (ray_dir · q)
+    let v = f * dot(ray_dir, q);
+
+    // Allow tolerance for edges/vertices to ensure watertight coverage
+    if (v < -EPSILON || u + v > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    // t = f * (edge2 · q)
+    let t = f * dot(edge2, q);
+
+    if (t > EPSILON) {
+        // Intersection found - calculate Z coordinate
+        let intersection_z = ray_origin.z + ray_dir.z * t;
+        return vec2<f32>(1.0, intersection_z);
+    }
+
+    return vec2<f32>(0.0, 0.0);
+}
+
+@compute @workgroup_size(16, 16)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let grid_x = global_id.x;
+    let grid_y = global_id.y;
+
+    if (grid_x >= uniforms.grid_width || grid_y >= uniforms.grid_height) {
+        return;
+    }
+
+    // Calculate world position for this grid point (center of cell)
+    let world_x = uniforms.bounds_min_x + f32(grid_x) * uniforms.step_size;
+    let world_y = uniforms.bounds_min_y + f32(grid_y) * uniforms.step_size;
+
+    // Initialize best_z based on filter mode
+    var best_z: f32;
+    if (uniforms.filter_mode == 0u) {
+        best_z = -1e10;  // Terrain: keep highest Z
+    } else {
+        best_z = 1e10;   // Tool: keep lowest Z
+    }
+
+    var found = false;
+
+    // Ray from below mesh pointing up (+Z direction)
+    let ray_origin = vec3<f32>(world_x, world_y, uniforms.bounds_min_z - 1.0);
+    let ray_dir = vec3<f32>(0.0, 0.0, 1.0);
+
+    // Find which spatial grid cell this ray belongs to
+    let spatial_cell_x = u32((world_x - uniforms.bounds_min_x) / uniforms.spatial_cell_size);
+    let spatial_cell_y = u32((world_y - uniforms.bounds_min_y) / uniforms.spatial_cell_size);
+
+    // Clamp to spatial grid bounds
+    let clamped_cx = min(spatial_cell_x, uniforms.spatial_grid_width - 1u);
+    let clamped_cy = min(spatial_cell_y, uniforms.spatial_grid_height - 1u);
+
+    let spatial_cell_idx = clamped_cy * uniforms.spatial_grid_width + clamped_cx;
+
+    // Get triangle range for this cell
+    let start_idx = spatial_cell_offsets[spatial_cell_idx];
+    let end_idx = spatial_cell_offsets[spatial_cell_idx + 1u];
+
+    // Test only triangles in this spatial cell
+    for (var idx = start_idx; idx < end_idx; idx++) {
+        let tri_idx = spatial_triangle_indices[idx];
+        let tri_base = tri_idx * 9u;
+
+        // Read triangle vertices (already in local space and rotated if needed)
+        let v0 = vec3<f32>(
+            triangles[tri_base],
+            triangles[tri_base + 1u],
+            triangles[tri_base + 2u]
+        );
+        let v1 = vec3<f32>(
+            triangles[tri_base + 3u],
+            triangles[tri_base + 4u],
+            triangles[tri_base + 5u]
+        );
+        let v2 = vec3<f32>(
+            triangles[tri_base + 6u],
+            triangles[tri_base + 7u],
+            triangles[tri_base + 8u]
+        );
+
+        let result = ray_triangle_intersect(ray_origin, ray_dir, v0, v1, v2);
+        let hit = result.x;
+        let intersection_z = result.y;
+
+        if (hit > 0.5) {
+            if (uniforms.filter_mode == 0u) {
+                // Terrain: keep highest
+                if (intersection_z > best_z) {
+                    best_z = intersection_z;
+                    found = true;
+                }
+            } else {
+                // Tool: keep lowest
+                if (intersection_z < best_z) {
+                    best_z = intersection_z;
+                    found = true;
+                }
+            }
+        }
+    }
+
+    // Write output based on filter mode
+    let output_idx = grid_y * uniforms.grid_width + grid_x;
+
+    if (uniforms.filter_mode == 0u) {
+        // Terrain: Dense output (Z-only, sentinel value for empty cells)
+        if (found) {
+            output_points[output_idx] = best_z;
+        } else {
+            output_points[output_idx] = EMPTY_CELL;
+        }
+    } else {
+        // Tool: Sparse output (X, Y, Z triplets with valid mask)
+        output_points[output_idx * 3u] = f32(grid_x);
+        output_points[output_idx * 3u + 1u] = f32(grid_y);
+        output_points[output_idx * 3u + 2u] = best_z;
+
+        if (found) {
+            valid_mask[output_idx] = 1u;
+        } else {
+            valid_mask[output_idx] = 0u;
+        }
+    }
+}

package/src/shaders/planar-toolpath.wgsl

@@ -0,0 +1,83 @@
+// Planar toolpath generation
+// Sentinel value for empty terrain cells (must match rasterize shader)
+const EMPTY_CELL: f32 = -1e10;
+const MAX_F32: f32 = 3.402823466e+38;
+
+struct SparseToolPoint {
+    x_offset: i32,
+    y_offset: i32,
+    z_value: f32,
+    padding: f32,
+}
+
+struct Uniforms {
+    terrain_width: u32,
+    terrain_height: u32,
+    tool_count: u32,
+    x_step: u32,
+    y_step: u32,
+    oob_z: f32,
+    points_per_line: u32,
+    num_scanlines: u32,
+    y_offset: u32,  // Offset to center Y position (for single-scanline radial mode)
+}
+
+@group(0) @binding(0) var<storage, read> terrain_map: array<f32>;
+@group(0) @binding(1) var<storage, read> sparse_tool: array<SparseToolPoint>;
+@group(0) @binding(2) var<storage, read_write> output_path: array<f32>;
+@group(0) @binding(3) var<uniform> uniforms: Uniforms;
+
+@compute @workgroup_size(16, 16)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let scanline = global_id.y;
+    let point_idx = global_id.x;
+
+    if (scanline >= uniforms.num_scanlines || point_idx >= uniforms.points_per_line) {
+        return;
+    }
+
+    let tool_center_x = i32(point_idx * uniforms.x_step);
+    let tool_center_y = i32(scanline * uniforms.y_step) + i32(uniforms.y_offset);
+
+    // var max_collision_z = -MAX_F32;  // Track maximum collision height
+    var max_collision_z = uniforms.oob_z;  // Track maximum collision height
+    var found_collision = false;
+
+    for (var i = 0u; i < uniforms.tool_count; i++) {
+        let tool_point = sparse_tool[i];
+        let terrain_x = tool_center_x + tool_point.x_offset;
+        let terrain_y = tool_center_y + tool_point.y_offset;
+
+        // Bounds check: X must always be in bounds
+        if (terrain_x < 0 || terrain_x >= i32(uniforms.terrain_width)) {
+            continue;
+        }
+
+        // Bounds check: Y must be within terrain strip bounds
+        // For single-scanline OUTPUT mode, the tool center is at Y=0 but the terrain
+        // strip contains the full Y range (tool width), so tool offsets access different Y rows
+        if (terrain_y < 0 || terrain_y >= i32(uniforms.terrain_height)) {
+            continue;
+        }
+
+        let terrain_idx = u32(terrain_y) * uniforms.terrain_width + u32(terrain_x);
+        let terrain_z = terrain_map[terrain_idx];
+
+        // Check if terrain cell has geometry (not empty sentinel value)
+        if (terrain_z > EMPTY_CELL + 1.0) {
+            // Tool z_value is positive offset from tip (tip=0, shaft=+50)
+            // Subtract from terrain to find where tool center needs to be
+            let collision_z = terrain_z + tool_point.z_value;
+            max_collision_z = max(max_collision_z, collision_z);
+            found_collision = true;
+        }
+    }
+
+    var output_z = uniforms.oob_z;
+    if (found_collision) {
+        output_z = max_collision_z;
+    }
+
+    let output_idx = scanline * uniforms.points_per_line + point_idx;
+    output_path[output_idx] = output_z;
+}

package/src/shaders/radial-raster-v2.wgsl

@@ -0,0 +1,195 @@
+// Radial V2 rasterization with X-bucketing and rotating ray planes
+// Sentinel value for empty cells (far below any real geometry)
+const EMPTY_CELL: f32 = -1e10;
+const PI: f32 = 3.14159265359;
+
+struct Uniforms {
+    resolution: f32,           // Grid step size (mm)
+    angle_step: f32,           // Radians between angles
+    num_angles: u32,           // Total number of angular strips
+    max_radius: f32,           // Ray origin distance from X-axis (maxHypot * 1.01)
+    tool_width: f32,           // Tool width in mm
+    grid_y_height: u32,        // Tool width in pixels (toolWidth / resolution)
+    bucket_width: f32,         // Width of each X-bucket (mm)
+    bucket_grid_width: u32,    // Bucket width in pixels
+    global_min_x: f32,         // Global minimum X coordinate
+    z_floor: f32,              // Z value for empty cells
+    filter_mode: u32,          // 0 = max Z (terrain), 1 = min Z (tool)
+    num_buckets: u32,          // Total number of X-buckets
+    start_angle: f32,          // Starting angle offset in radians (for batching)
+}
+
+struct BucketInfo {
+    min_x: f32,                // Bucket X range start (mm)
+    max_x: f32,                // Bucket X range end (mm)
+    start_index: u32,          // Index into triangle_indices array
+    count: u32                 // Number of triangles in this bucket
+}
+
+@group(0) @binding(0) var<storage, read> triangles: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+@group(0) @binding(3) var<storage, read> bucket_info: array<BucketInfo>;
+@group(0) @binding(4) var<storage, read> triangle_indices: array<u32>;
+
+// Note: AABB early rejection removed - X-bucketing already provides spatial filtering
+// A proper ray-AABB intersection test would be needed if we wanted bounding box culling,
+// but checking if ray_origin is inside AABB was incorrect and rejected valid triangles
+
+// Ray-triangle intersection using Möller-Trumbore algorithm
+fn ray_triangle_intersect(
+    ray_origin: vec3<f32>,
+    ray_dir: vec3<f32>,
+    v0: vec3<f32>,
+    v1: vec3<f32>,
+    v2: vec3<f32>
+) -> vec2<f32> {  // Returns (hit: 0.0 or 1.0, z: intersection_z)
+    let EPSILON = 0.0001;
+
+    // Calculate edges
+    let edge1 = v1 - v0;
+    let edge2 = v2 - v0;
+
+    // Cross product: ray_dir × edge2
+    let h = cross(ray_dir, edge2);
+
+    // Dot product: edge1 · h
+    let a = dot(edge1, h);
+
+    if (a > -EPSILON && a < EPSILON) {
+        return vec2<f32>(0.0, 0.0); // Ray parallel to triangle
+    }
+
+    let f = 1.0 / a;
+
+    // s = ray_origin - v0
+    let s = ray_origin - v0;
+
+    // u = f * (s · h)
+    let u = f * dot(s, h);
+
+    if (u < -EPSILON || u > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    // Cross product: s × edge1
+    let q = cross(s, edge1);
+
+    // v = f * (ray_dir · q)
+    let v = f * dot(ray_dir, q);
+
+    if (v < -EPSILON || u + v > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    // t = f * (edge2 · q)
+    let t = f * dot(edge2, q);
+
+    if (t > EPSILON) {
+        // Intersection found - return distance along ray (t parameter)
+        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 bucket_idx = global_id.z;
+    let grid_y = global_id.y;
+    let angle_idx = global_id.x;
+
+    // Bounds check
+    if (angle_idx >= uniforms.num_angles ||
+        grid_y >= uniforms.grid_y_height ||
+        bucket_idx >= uniforms.num_buckets) {
+        return;
+    }
+
+    let bucket = bucket_info[bucket_idx];
+    let angle = uniforms.start_angle + (f32(angle_idx) * uniforms.angle_step);
+
+    // Calculate bucket min grid X
+    let bucket_min_grid_x = u32((bucket.min_x - uniforms.global_min_x) / uniforms.resolution);
+
+    // Loop over X within this bucket
+    for (var local_x = 0u; local_x < uniforms.bucket_grid_width; local_x++) {
+        let grid_x = bucket_min_grid_x + local_x;
+        let world_x = uniforms.global_min_x + f32(grid_x) * uniforms.resolution;
+
+        // Rotating top-down scan: normal XY planar scan, rotated around X-axis
+        // Step 1: Define scan position in planar frame (X, Y, Z_above)
+        let scan_x = world_x;
+        let scan_y = f32(grid_y) * uniforms.resolution - uniforms.tool_width / 2.0;
+        let scan_z = uniforms.max_radius;  // Start above the model
+
+        // Step 2: Rotate position (scan_x, scan_y, scan_z) around X-axis by 'angle'
+        // X stays the same, rotate YZ plane: y' = y*cos - z*sin, z' = y*sin + z*cos
+        let ray_origin_x = scan_x;
+        let ray_origin_y = scan_y * cos(angle) - scan_z * sin(angle);
+        let ray_origin_z = scan_y * sin(angle) + scan_z * cos(angle);
+        let ray_origin = vec3<f32>(ray_origin_x, ray_origin_y, ray_origin_z);
+
+        // Step 3: Rotate ray direction (0, 0, -1) around X-axis by 'angle'
+        // X component stays 0, rotate YZ: dy = 0*cos - (-1)*sin = sin, dz = 0*sin + (-1)*cos = -cos
+        let ray_dir = vec3<f32>(0.0, sin(angle), -cos(angle));
+
+        // Initialize best distance (closest hit)
+        var best_t: f32 = 1e10;  // Start with very large distance
+        var found = false;
+
+        // Ray-cast against triangles in this bucket
+        for (var i = 0u; i < bucket.count; i++) {
+            let tri_idx = triangle_indices[bucket.start_index + i];
+            let tri_base = tri_idx * 9u;
+
+            // Read triangle vertices
+            let v0 = vec3<f32>(
+                triangles[tri_base],
+                triangles[tri_base + 1u],
+                triangles[tri_base + 2u]
+            );
+            let v1 = vec3<f32>(
+                triangles[tri_base + 3u],
+                triangles[tri_base + 4u],
+                triangles[tri_base + 5u]
+            );
+            let v2 = vec3<f32>(
+                triangles[tri_base + 6u],
+                triangles[tri_base + 7u],
+                triangles[tri_base + 8u]
+            );
+
+            let result = ray_triangle_intersect(ray_origin, ray_dir, v0, v1, v2);
+            let hit = result.x;
+            let t = result.y;  // Distance along ray
+
+            if (hit > 0.5) {
+                // Keep closest hit (minimum t)
+                if (t < best_t) {
+                    best_t = t;
+                    found = true;
+                }
+            }
+        }
+
+        // Write output
+        // Layout: bucket_idx * numAngles * bucketWidth * gridHeight
+        //       + angle_idx * bucketWidth * gridHeight
+        //       + grid_y * bucketWidth
+        //       + local_x
+        let output_idx = bucket_idx * uniforms.num_angles * uniforms.bucket_grid_width * uniforms.grid_y_height
+                       + angle_idx * uniforms.bucket_grid_width * uniforms.grid_y_height
+                       + grid_y * uniforms.bucket_grid_width
+                       + local_x;
+
+        if (found) {
+            // Terrain height = distance from scan origin minus ray travel distance
+            // Ray started at max_radius from X-axis, traveled best_t distance to hit
+            let terrain_height = uniforms.max_radius - best_t;
+            output[output_idx] = terrain_height;
+        } else {
+            output[output_idx] = uniforms.z_floor;
+        }
+    }
+}