game_toolkit_gfx/
primitives.rs

1use bytemuck::{Pod, Zeroable};
2use wgpu::util::DeviceExt;
3
4use crate::target::Targets;
5
6#[repr(C)]
7#[derive(Copy, Clone, Pod, Zeroable)]
8struct PrimVertex {
9    pos: [f32; 2],
10}
11
12const QUAD_VERTS: &[PrimVertex] = &[
13    PrimVertex { pos: [0.0, 0.0] },
14    PrimVertex { pos: [1.0, 0.0] },
15    PrimVertex { pos: [1.0, 1.0] },
16    PrimVertex { pos: [0.0, 1.0] },
17];
18const QUAD_INDICES: &[u16] = &[0, 1, 2, 0, 2, 3];
19
20#[repr(C)]
21#[derive(Copy, Clone, Pod, Zeroable, Debug)]
22pub struct CircleInstance {
23    pub center: [f32; 2],
24    pub radius: f32,
25    /// `0.0` = filled disk; `>0` = ring of that pixel thickness (outer = radius).
26    pub thickness: f32,
27    pub color: [f32; 4],
28}
29
30pub(crate) struct PrimitiveBatcher {
31    quad_vb: wgpu::Buffer,
32    quad_ib: wgpu::Buffer,
33    instance_vb: wgpu::Buffer,
34    capacity: usize,
35    pipeline: wgpu::RenderPipeline,
36    pending: Vec<(i16, CircleInstance)>,
37}
38
39impl PrimitiveBatcher {
40    pub fn new(
41        device: &wgpu::Device,
42        surface_format: wgpu::TextureFormat,
43        camera_bgl: &wgpu::BindGroupLayout,
44        sample_count: u32,
45        depth_format: Option<wgpu::TextureFormat>,
46    ) -> Self {
47        let quad_vb = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
48            label: Some("prim.quad_vb"),
49            contents: bytemuck::cast_slice(QUAD_VERTS),
50            usage: wgpu::BufferUsages::VERTEX,
51        });
52        let quad_ib = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
53            label: Some("prim.quad_ib"),
54            contents: bytemuck::cast_slice(QUAD_INDICES),
55            usage: wgpu::BufferUsages::INDEX,
56        });
57        let capacity = 1024usize;
58        let instance_vb = device.create_buffer(&wgpu::BufferDescriptor {
59            label: Some("prim.circle_instances"),
60            size: (capacity * std::mem::size_of::<CircleInstance>()) as u64,
61            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
62            mapped_at_creation: false,
63        });
64
65        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
66            label: Some("prim.circle.shader"),
67            source: wgpu::ShaderSource::Wgsl(include_str!("circle.wgsl").into()),
68        });
69        let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
70            label: Some("prim.layout"),
71            bind_group_layouts: &[Some(camera_bgl)],
72            immediate_size: 0,
73        });
74
75        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
76            label: Some("prim.circle.pipeline"),
77            layout: Some(&layout),
78            vertex: wgpu::VertexState {
79                module: &shader,
80                entry_point: Some("vs_main"),
81                compilation_options: Default::default(),
82                buffers: &[
83                    wgpu::VertexBufferLayout {
84                        array_stride: std::mem::size_of::<PrimVertex>() as u64,
85                        step_mode: wgpu::VertexStepMode::Vertex,
86                        attributes: &wgpu::vertex_attr_array![0 => Float32x2],
87                    },
88                    wgpu::VertexBufferLayout {
89                        array_stride: std::mem::size_of::<CircleInstance>() as u64,
90                        step_mode: wgpu::VertexStepMode::Instance,
91                        attributes: &wgpu::vertex_attr_array![
92                            2 => Float32x2,
93                            3 => Float32,
94                            4 => Float32,
95                            5 => Float32x4,
96                        ],
97                    },
98                ],
99            },
100            fragment: Some(wgpu::FragmentState {
101                module: &shader,
102                entry_point: Some("fs_main"),
103                compilation_options: Default::default(),
104                targets: &[Some(wgpu::ColorTargetState {
105                    format: surface_format,
106                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
107                    write_mask: wgpu::ColorWrites::ALL,
108                })],
109            }),
110            primitive: wgpu::PrimitiveState::default(),
111            depth_stencil: depth_format.map(crate::target::no_write_depth),
112            multisample: crate::target::multisample(sample_count),
113            multiview_mask: None,
114            cache: None,
115        });
116
117        Self {
118            quad_vb,
119            quad_ib,
120            instance_vb,
121            capacity,
122            pipeline,
123            pending: Vec::new(),
124        }
125    }
126
127    pub fn push(&mut self, layer: i16, inst: CircleInstance) {
128        self.pending.push((layer, inst));
129    }
130
131    /// Record every layer that has pending circles, for cross-batcher interleaving.
132    pub fn collect_layers(&self, out: &mut std::collections::BTreeSet<i16>) {
133        out.extend(self.pending.iter().map(|(layer, _)| *layer));
134    }
135
136    /// Sort all pending circles by layer and upload them in one write. Must run before any
137    /// [`PrimitiveBatcher::draw_layer`]; see [`SpriteBatcher::upload`] for why the buffer is
138    /// written exactly once per frame rather than per layer pass.
139    pub fn upload(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
140        if self.pending.is_empty() {
141            return;
142        }
143        self.pending.sort_by_key(|(layer, _)| *layer);
144        if self.pending.len() > self.capacity {
145            self.capacity = self.pending.len().next_power_of_two();
146            self.instance_vb = device.create_buffer(&wgpu::BufferDescriptor {
147                label: Some("prim.circle_instances"),
148                size: (self.capacity * std::mem::size_of::<CircleInstance>()) as u64,
149                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
150                mapped_at_creation: false,
151            });
152        }
153        let flat: Vec<CircleInstance> = self.pending.iter().map(|(_, c)| *c).collect();
154        queue.write_buffer(&self.instance_vb, 0, bytemuck::cast_slice(&flat));
155    }
156
157    /// Draw the circles on `layer` (already uploaded by [`PrimitiveBatcher::upload`]) into the
158    /// already-cleared target.
159    pub fn draw_layer(
160        &self,
161        layer: i16,
162        encoder: &mut wgpu::CommandEncoder,
163        targets: &Targets,
164        camera_bg: &wgpu::BindGroup,
165    ) {
166        // `pending` is sorted by layer, so this layer's circles are a contiguous range.
167        let lo = self.pending.partition_point(|(l, _)| *l < layer);
168        let hi = self.pending.partition_point(|(l, _)| *l <= layer);
169        if lo == hi {
170            return;
171        }
172
173        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
174            label: Some("prim.circle.pass"),
175            color_attachments: &[Some(targets.color_attachment(wgpu::LoadOp::Load))],
176            depth_stencil_attachment: targets.depth_attachment(wgpu::LoadOp::Load),
177            occlusion_query_set: None,
178            timestamp_writes: None,
179            multiview_mask: None,
180        });
181        pass.set_pipeline(&self.pipeline);
182        pass.set_bind_group(0, camera_bg, &[]);
183        pass.set_vertex_buffer(0, self.quad_vb.slice(..));
184        pass.set_index_buffer(self.quad_ib.slice(..), wgpu::IndexFormat::Uint16);
185        pass.set_vertex_buffer(1, self.instance_vb.slice(..));
186        pass.draw_indexed(0..6, 0, lo as u32..hi as u32);
187    }
188
189    pub fn clear(&mut self) {
190        self.pending.clear();
191    }
192}
game_toolkit_gfx/primitives.rs

game_toolkit_gfx/
primitives.rs
