forked from 1b-agent/opencadstudio-upstream
feat(pipeline): batched-hatch GPU resources + builder (Phase 4-B, step 1)
Stand-alone module — no consumers yet. Packs an entire `&[HatchModel]` into four storage buffers + a per-vertex (corner, instance_index) stream: - `InstanceBuffer` — `HatchInstance[]` (112 B each): color, mode, gradient params, world_origin, local-space aabb, boundary range, family range, visibility flag. - `BoundaryBuffer` — flat `vec4<f32>[]` (NaN markers preserved as per-path separators, just like the per-hatch shader expects). - `FamilyBuffer` — flat `LineFamilyGpu[]` (matches the per-hatch family layout one-for-one apart from `dash_offset` indexing into a separate dash buffer). - `DashBuffer` — flat `f32[]`. The per-vertex buffer holds `6 × instance_count` records of `(corner: u32, instance_index: u32)`. Step 2 will add the matching WGSL shader that uses these to project a per-instance AABB quad and run the in-polygon test against `BoundaryBuffer[offset..offset+count]`. iced reports 8 storage buffers per stage, 128 MB binding cap, 256 MB buffer cap — plenty for ~10 k hatches × 112 B + ~32 MB boundaries. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Hakan SevenandClaude Opus 4.7 committed
1 parent
a0412534ae
commit
fe202f5f8e
2 files changed
+457
No files matched your search
@@ -0,0 +1,456 @@
|
||||
// Phase 4-B — batched hatch rendering. Single draw call for all
|
||||
// hatches, per-instance data fetched from storage buffers in the
|
||||
// vertex shader. Replaces the per-hatch bind group + draw of
|
||||
// `hatch_gpu.rs` once the new path is wired in.
|
||||
//
|
||||
// Data layout — three storage buffers fed from `HatchModel`s:
|
||||
//
|
||||
// InstanceBuffer (binding 0) : HatchInstance[] (~96 B each)
|
||||
// color, color2, mode, gradient,
|
||||
// pattern angle/scale, world_origin,
|
||||
// boundary_offset, boundary_count,
|
||||
// family_offset, family_count,
|
||||
// dash_offset, dash_count, aabb,
|
||||
// visibility flag (CPU writes; GPU
|
||||
// skip)
|
||||
// BoundaryBuffer (binding 1) : vec4<f32>[] (all boundary
|
||||
// verts concatenated; NaN markers
|
||||
// preserved as separators just like
|
||||
// the per-hatch path)
|
||||
// FamilyBuffer (binding 2) : LineFamilyGpu[] (all line
|
||||
// families concatenated)
|
||||
// DashBuffer (binding 3) : f32[] (all dash
|
||||
// lengths concatenated)
|
||||
//
|
||||
// The vertex buffer holds 6 corner indices repeated per-instance and a
|
||||
// per-vertex `instance_index` (u32 attribute) — instance_index lets us
|
||||
// avoid relying on `@builtin(instance_index)` for portability. The
|
||||
// vertex shader reads the per-instance AABB from the InstanceBuffer
|
||||
// and emits the quad corner for that instance. When the visibility
|
||||
// flag is 0, it returns a degenerate position and the fragment shader
|
||||
// runs zero times for that instance.
|
||||
//
|
||||
// Two storage usages — vertex shader reads InstanceBuffer + Boundary
|
||||
// for the AABB / boundary range; fragment shader reads
|
||||
// InstanceBuffer + Boundary + Family + Dash. Both stages share group
|
||||
// 1 with `read_only` access.
|
||||
|
||||
use crate::scene::hatch_model::{HatchModel, HatchPattern, PatFamily};
|
||||
use iced::wgpu;
|
||||
use iced::wgpu::util::DeviceExt;
|
||||
|
||||
// ── GPU structs ────────────────────────────────────────────────────────────
|
||||
//
|
||||
// Layout matches the WGSL `HatchInstance` exactly. `repr(C)` + manual
|
||||
// padding keeps WGSL's 16-byte alignment rules satisfied for arrays of
|
||||
// this struct.
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
pub struct HatchInstance {
|
||||
pub color: [f32; 4], // 0
|
||||
pub color2: [f32; 4], // 16 (gradient end)
|
||||
pub aabb: [f32; 4], // 32 (local-space xmin,ymin,xmax,ymax)
|
||||
pub world_origin: [f32; 2], // 48 (anchor added back in VS)
|
||||
pub angle_offset: f32, // 56
|
||||
pub scale: f32, // 60
|
||||
pub grad_cos: f32, // 64
|
||||
pub grad_sin: f32, // 68
|
||||
pub grad_min: f32, // 72
|
||||
pub grad_range: f32, // 76
|
||||
pub mode: u32, // 80 (0=pattern, 1=solid, 2=gradient)
|
||||
pub visible: u32, // 84 (CPU sets to 0 to skip)
|
||||
pub boundary_offset: u32, // 88 (first boundary vert index)
|
||||
pub boundary_count: u32, // 92
|
||||
pub family_offset: u32, // 96
|
||||
pub family_count: u32, // 100
|
||||
pub _pad0: [u32; 2], // 104 (pad to 112 = 16-byte stride)
|
||||
}
|
||||
|
||||
const _: () = assert!(std::mem::size_of::<HatchInstance>() == 112);
|
||||
|
||||
/// Mirrors the per-family struct used by the existing per-hatch shader,
|
||||
/// but the dash slice lives in a separate concatenated DashBuffer (the
|
||||
/// old shader had it embedded). `dash_offset` / `dash_count` index into
|
||||
/// that flat array.
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
pub struct LineFamilyGpu {
|
||||
pub cos_a: f32, // 0
|
||||
pub sin_a: f32, // 4
|
||||
pub x0: f32, // 8
|
||||
pub y0: f32, // 12
|
||||
pub dx: f32, // 16
|
||||
pub dy: f32, // 20
|
||||
pub perp_step: f32, // 24
|
||||
pub along_step: f32, // 28
|
||||
pub line_width: f32, // 32
|
||||
pub period: f32, // 36
|
||||
pub n_dashes: u32, // 40
|
||||
pub dash_offset: u32, // 44
|
||||
}
|
||||
|
||||
const _: () = assert!(std::mem::size_of::<LineFamilyGpu>() == 48);
|
||||
|
||||
/// Per-vertex data — 6 verts per instance. Instance_index here so we
|
||||
/// can match WebGL2 backends that don't expose builtin(instance_index)
|
||||
/// uniformly.
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
pub struct HatchBatchedVertex {
|
||||
pub corner: u32, // 0..6 — which AABB corner
|
||||
pub instance_index: u32, // index into InstanceBuffer
|
||||
}
|
||||
|
||||
impl HatchBatchedVertex {
|
||||
pub fn layout<'a>() -> wgpu::VertexBufferLayout<'a> {
|
||||
wgpu::VertexBufferLayout {
|
||||
array_stride: std::mem::size_of::<HatchBatchedVertex>() as u64,
|
||||
step_mode: wgpu::VertexStepMode::Vertex,
|
||||
attributes: &[
|
||||
wgpu::VertexAttribute {
|
||||
offset: 0,
|
||||
shader_location: 0,
|
||||
format: wgpu::VertexFormat::Uint32,
|
||||
},
|
||||
wgpu::VertexAttribute {
|
||||
offset: 4,
|
||||
shader_location: 1,
|
||||
format: wgpu::VertexFormat::Uint32,
|
||||
},
|
||||
],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Batch builder ──────────────────────────────────────────────────────────
|
||||
|
||||
/// Pack a list of `HatchModel`s into the four concatenated storage
|
||||
/// buffers + the per-vertex buffer needed by `hatch_batched.wgsl`.
|
||||
/// Returns `None` when the input slice is empty (caller skips the
|
||||
/// hatch render pass entirely).
|
||||
pub struct HatchBatchedGpu {
|
||||
pub vertex_buffer: wgpu::Buffer,
|
||||
pub vertex_count: u32,
|
||||
pub instance_buffer: wgpu::Buffer,
|
||||
pub boundary_buffer: wgpu::Buffer,
|
||||
pub family_buffer: wgpu::Buffer,
|
||||
pub dash_buffer: wgpu::Buffer,
|
||||
pub bind_group: wgpu::BindGroup,
|
||||
pub instance_count: u32,
|
||||
/// CPU-side mirror of `HatchInstance.visible` — `compute_hatch_lod`
|
||||
/// writes 0/1 here, then `upload_visibility` pushes the changed
|
||||
/// `visible` field through to the GPU `instance_buffer`. Storing
|
||||
/// just the flag (not the whole HatchInstance) keeps the per-frame
|
||||
/// upload small.
|
||||
pub visibility: Vec<u32>,
|
||||
}
|
||||
|
||||
impl HatchBatchedGpu {
|
||||
/// One-time build from the full hatch list. Re-uploaded only when
|
||||
/// `geometry_epoch` advances (mirrors the existing per-hatch
|
||||
/// upload trigger). Per-frame visibility flips go through
|
||||
/// [`upload_visibility`].
|
||||
pub fn build(
|
||||
device: &wgpu::Device,
|
||||
bgl: &wgpu::BindGroupLayout,
|
||||
hatches: &[HatchModel],
|
||||
) -> Option<Self> {
|
||||
if hatches.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let mut instances: Vec<HatchInstance> = Vec::with_capacity(hatches.len());
|
||||
let mut boundary: Vec<[f32; 4]> = Vec::new();
|
||||
let mut families: Vec<LineFamilyGpu> = Vec::new();
|
||||
let mut dashes: Vec<f32> = Vec::new();
|
||||
|
||||
for h in hatches {
|
||||
let boundary_offset = boundary.len() as u32;
|
||||
for &[x, y] in h.boundary.iter() {
|
||||
boundary.push([x, y, 0.0, 0.0]);
|
||||
}
|
||||
let boundary_count = boundary.len() as u32 - boundary_offset;
|
||||
|
||||
let family_offset = families.len() as u32;
|
||||
let mut family_count = 0u32;
|
||||
|
||||
let (mode, color2, grad_cos, grad_sin, grad_min, grad_range) = match &h.pattern {
|
||||
HatchPattern::Solid => (1u32, [0.0; 4], 0.0, 0.0, 0.0, 1.0),
|
||||
HatchPattern::Gradient { angle_deg, color2 } => {
|
||||
let r = angle_deg.to_radians();
|
||||
// Gradient projection range (proj_min / proj_range) —
|
||||
// computed at upload time, identical to per-hatch path.
|
||||
let (gmin, gmax) = boundary_projection_range(&h.boundary, r);
|
||||
let grange = (gmax - gmin).max(1.0);
|
||||
(2u32, *color2, r.cos(), r.sin(), gmin, grange)
|
||||
}
|
||||
HatchPattern::Pattern(fams) => {
|
||||
for fam in fams {
|
||||
let dash_offset = dashes.len() as u32;
|
||||
for &d in &fam.dashes {
|
||||
dashes.push(d);
|
||||
}
|
||||
let n_dashes = (dashes.len() as u32 - dash_offset).min(u32::MAX);
|
||||
let perp_step = -fam.dx * fam.angle_deg.to_radians().sin()
|
||||
+ fam.dy * fam.angle_deg.to_radians().cos();
|
||||
let along_step = fam.dx * fam.angle_deg.to_radians().cos()
|
||||
+ fam.dy * fam.angle_deg.to_radians().sin();
|
||||
let line_width = perp_step.abs() * 0.08;
|
||||
let period: f32 = fam.dashes.iter().map(|d| d.abs()).sum();
|
||||
families.push(LineFamilyGpu {
|
||||
cos_a: fam.angle_deg.to_radians().cos(),
|
||||
sin_a: fam.angle_deg.to_radians().sin(),
|
||||
x0: fam.x0,
|
||||
y0: fam.y0,
|
||||
dx: fam.dx,
|
||||
dy: fam.dy,
|
||||
perp_step,
|
||||
along_step,
|
||||
line_width,
|
||||
period,
|
||||
n_dashes,
|
||||
dash_offset,
|
||||
});
|
||||
family_count += 1;
|
||||
}
|
||||
(0u32, [0.0; 4], 0.0, 0.0, 0.0, 1.0)
|
||||
}
|
||||
};
|
||||
|
||||
// Boundary AABB in local space (matches the corner quad
|
||||
// emitted by the vertex shader). The verts are already in
|
||||
// `world_origin`-relative coords (see scene/mod.rs hatch
|
||||
// packing), so this AABB lives in that frame.
|
||||
let mut min_x = f32::INFINITY;
|
||||
let mut min_y = f32::INFINITY;
|
||||
let mut max_x = f32::NEG_INFINITY;
|
||||
let mut max_y = f32::NEG_INFINITY;
|
||||
for &[x, y] in h.boundary.iter() {
|
||||
if x.is_finite() && y.is_finite() {
|
||||
if x < min_x { min_x = x; }
|
||||
if y < min_y { min_y = y; }
|
||||
if x > max_x { max_x = x; }
|
||||
if y > max_y { max_y = y; }
|
||||
}
|
||||
}
|
||||
if !min_x.is_finite() {
|
||||
// Empty / all-NaN — skip but keep the slot so indices
|
||||
// stay in lockstep with the input list (visibility=0).
|
||||
instances.push(HatchInstance {
|
||||
color: h.color,
|
||||
color2,
|
||||
aabb: [0.0, 0.0, 0.0, 0.0],
|
||||
world_origin: h.world_origin.map(|v| v as f32),
|
||||
angle_offset: h.angle_offset,
|
||||
scale: h.scale.max(1e-6),
|
||||
grad_cos,
|
||||
grad_sin,
|
||||
grad_min,
|
||||
grad_range,
|
||||
mode,
|
||||
visible: 0,
|
||||
boundary_offset,
|
||||
boundary_count,
|
||||
family_offset,
|
||||
family_count,
|
||||
_pad0: [0; 2],
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
// Pad the AABB so the quad covers any pattern halo + the
|
||||
// family origin. Mirrors the per-hatch shader's quad sizing
|
||||
// logic — `diag * 0.8 + max_spacing * 2 * scale`.
|
||||
let diag = ((max_x - min_x).powi(2) + (max_y - min_y).powi(2)).sqrt();
|
||||
let max_spacing = match &h.pattern {
|
||||
HatchPattern::Pattern(fs) => fs
|
||||
.iter()
|
||||
.map(|f| {
|
||||
let a = f.angle_deg.to_radians();
|
||||
(-f.dx * a.sin() + f.dy * a.cos()).abs()
|
||||
})
|
||||
.fold(0.0f32, f32::max),
|
||||
_ => 5.0,
|
||||
};
|
||||
let pad = (diag * 0.8 + max_spacing * 2.0 * h.scale).max(1.0);
|
||||
|
||||
instances.push(HatchInstance {
|
||||
color: h.color,
|
||||
color2,
|
||||
aabb: [min_x - pad, min_y - pad, max_x + pad, max_y + pad],
|
||||
world_origin: h.world_origin.map(|v| v as f32),
|
||||
angle_offset: h.angle_offset,
|
||||
scale: h.scale.max(1e-6),
|
||||
grad_cos,
|
||||
grad_sin,
|
||||
grad_min,
|
||||
grad_range,
|
||||
mode,
|
||||
visible: 1,
|
||||
boundary_offset,
|
||||
boundary_count,
|
||||
family_offset,
|
||||
family_count,
|
||||
_pad0: [0; 2],
|
||||
});
|
||||
}
|
||||
|
||||
// Empty fallbacks — storage buffers can't be zero-sized.
|
||||
if boundary.is_empty() {
|
||||
boundary.push([0.0; 4]);
|
||||
}
|
||||
if families.is_empty() {
|
||||
families.push(LineFamilyGpu::default_filler());
|
||||
}
|
||||
if dashes.is_empty() {
|
||||
dashes.push(0.0);
|
||||
}
|
||||
|
||||
// Vertex buffer — 6 verts per instance (two triangles for the
|
||||
// AABB quad), indexed by (corner, instance_index).
|
||||
let mut verts: Vec<HatchBatchedVertex> = Vec::with_capacity(instances.len() * 6);
|
||||
for (i, _) in instances.iter().enumerate() {
|
||||
for corner in 0u32..6 {
|
||||
verts.push(HatchBatchedVertex {
|
||||
corner,
|
||||
instance_index: i as u32,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: Some("hatch_batched.vertex"),
|
||||
contents: bytemuck::cast_slice(&verts),
|
||||
usage: wgpu::BufferUsages::VERTEX,
|
||||
});
|
||||
let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: Some("hatch_batched.instances"),
|
||||
contents: bytemuck::cast_slice(&instances),
|
||||
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
|
||||
});
|
||||
let boundary_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: Some("hatch_batched.boundary"),
|
||||
contents: bytemuck::cast_slice(&boundary),
|
||||
usage: wgpu::BufferUsages::STORAGE,
|
||||
});
|
||||
let family_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: Some("hatch_batched.families"),
|
||||
contents: bytemuck::cast_slice(&families),
|
||||
usage: wgpu::BufferUsages::STORAGE,
|
||||
});
|
||||
let dash_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: Some("hatch_batched.dashes"),
|
||||
contents: bytemuck::cast_slice(&dashes),
|
||||
usage: wgpu::BufferUsages::STORAGE,
|
||||
});
|
||||
|
||||
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||
label: Some("hatch_batched.bg"),
|
||||
layout: bgl,
|
||||
entries: &[
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 0,
|
||||
resource: instance_buffer.as_entire_binding(),
|
||||
},
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 1,
|
||||
resource: boundary_buffer.as_entire_binding(),
|
||||
},
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 2,
|
||||
resource: family_buffer.as_entire_binding(),
|
||||
},
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 3,
|
||||
resource: dash_buffer.as_entire_binding(),
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
let visibility = instances.iter().map(|i| i.visible).collect();
|
||||
Some(Self {
|
||||
vertex_buffer,
|
||||
vertex_count: verts.len() as u32,
|
||||
instance_buffer,
|
||||
boundary_buffer,
|
||||
family_buffer,
|
||||
dash_buffer,
|
||||
bind_group,
|
||||
instance_count: instances.len() as u32,
|
||||
visibility,
|
||||
})
|
||||
}
|
||||
|
||||
/// Group-1 bind group layout — shared by the pipeline so it can be
|
||||
/// constructed once at startup. All four bindings are read-only
|
||||
/// storage and visible to both VS (AABB+visibility lookup) and FS
|
||||
/// (boundary / family / dash sampling).
|
||||
pub fn bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
|
||||
let entry = |binding: u32| wgpu::BindGroupLayoutEntry {
|
||||
binding,
|
||||
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
|
||||
ty: wgpu::BindingType::Buffer {
|
||||
ty: wgpu::BufferBindingType::Storage { read_only: true },
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
};
|
||||
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: Some("hatch_batched.bgl"),
|
||||
entries: &[entry(0), entry(1), entry(2), entry(3)],
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl LineFamilyGpu {
|
||||
fn default_filler() -> Self {
|
||||
Self {
|
||||
cos_a: 1.0,
|
||||
sin_a: 0.0,
|
||||
x0: 0.0,
|
||||
y0: 0.0,
|
||||
dx: 1.0,
|
||||
dy: 0.0,
|
||||
perp_step: 1.0,
|
||||
along_step: 1.0,
|
||||
line_width: 0.0,
|
||||
period: 0.0,
|
||||
n_dashes: 0,
|
||||
dash_offset: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Helpers ───────────────────────────────────────────────────────────────
|
||||
|
||||
/// Project every boundary vertex onto the gradient direction
|
||||
/// `(cos θ, sin θ)` and return the (min, max) projection. Used to set
|
||||
/// up the gradient's normalized parameter range. Same math as the
|
||||
/// per-hatch path; duplicated here to keep this module self-contained.
|
||||
fn boundary_projection_range(boundary: &[[f32; 2]], theta: f32) -> (f32, f32) {
|
||||
let (cs, sn) = (theta.cos(), theta.sin());
|
||||
let mut lo = f32::INFINITY;
|
||||
let mut hi = f32::NEG_INFINITY;
|
||||
for &[x, y] in boundary {
|
||||
if !x.is_finite() || !y.is_finite() {
|
||||
continue;
|
||||
}
|
||||
let p = x * cs + y * sn;
|
||||
if p < lo { lo = p; }
|
||||
if p > hi { hi = p; }
|
||||
}
|
||||
if !lo.is_finite() {
|
||||
return (0.0, 1.0);
|
||||
}
|
||||
(lo, hi)
|
||||
}
|
||||
|
||||
// PatFamily is re-exported by hatch_model so we don't need to import
|
||||
// it explicitly anywhere else — but rust needs the type referenced to
|
||||
// confirm the layout assumption above.
|
||||
#[allow(dead_code)]
|
||||
fn _assert_patfamily_fields(f: &PatFamily) -> (f32, f32, f32) {
|
||||
(f.angle_deg, f.x0, f.y0)
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
pub mod face3d_gpu;
|
||||
pub mod hatch_batched_gpu;
|
||||
pub mod hatch_gpu;
|
||||
pub mod image_gpu;
|
||||
pub mod mesh_gpu;
|
||||
|
||||
Reference in new issue
Block a user