use bytemuck::{Pod, Zeroable};
use wgpu::util::DeviceExt;
use zenthra_core::GlyphInstance;
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct Uniforms {
screen_size: [f32; 2],
_padding: [f32; 2],
}
pub struct TextPipeline {
pipeline: wgpu::RenderPipeline,
uniform_buffer: wgpu::Buffer,
uniform_bg: wgpu::BindGroup,
atlas_bg: Option<wgpu::BindGroup>,
atlas_bgl: wgpu::BindGroupLayout,
instance_buffer: Option<wgpu::Buffer>,
instance_count: u32,
}
impl TextPipeline {
pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
let shader = device.create_shader_module(wgpu::include_wgsl!("shaders/text.wgsl"));
let uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Text Uniform Buffer"),
size: std::mem::size_of::<Uniforms>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let uniform_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Text Uniform BGL"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let uniform_bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Text Uniform BG"),
layout: &uniform_bgl,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: uniform_buffer.as_entire_binding(),
}],
});
let atlas_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Text Atlas BGL"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Text Pipeline Layout"),
bind_group_layouts: &[Some(&uniform_bgl), Some(&atlas_bgl)],
immediate_size: 0,
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Text Pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[GlyphInstance::desc()],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("fs_main"),
targets: &[Some(wgpu::ColorTargetState {
format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: Default::default(),
}),
primitive: wgpu::PrimitiveState::default(),
depth_stencil: None,
multisample: wgpu::MultisampleState::default(),
multiview_mask: None,
cache: None,
});
Self {
pipeline,
uniform_buffer,
uniform_bg,
atlas_bg: None,
atlas_bgl,
instance_buffer: None,
instance_count: 0,
}
}
pub fn set_atlas(&mut self, device: &wgpu::Device, view: &wgpu::TextureView) {
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Text Atlas Sampler"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
self.atlas_bg = Some(device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Text Atlas BG"),
layout: &self.atlas_bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
}));
}
pub fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
width: u32,
height: u32,
instances: &[GlyphInstance],
) {
queue.write_buffer(
&self.uniform_buffer,
0,
bytemuck::bytes_of(&Uniforms {
screen_size: [width as f32, height as f32],
_padding: [0.0; 2],
}),
);
if instances.is_empty() {
self.instance_count = 0;
return;
}
self.instance_buffer = Some(
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Glyph Instance Buffer"),
contents: bytemuck::cast_slice(instances),
usage: wgpu::BufferUsages::VERTEX,
}),
);
self.instance_count = instances.len() as u32;
}
pub fn draw<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>) {
let Some(atlas_bg) = &self.atlas_bg else { return };
if self.instance_count == 0 {
return;
}
let Some(buf) = &self.instance_buffer else { return };
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &self.uniform_bg, &[]);
pass.set_bind_group(1, atlas_bg, &[]);
pass.set_vertex_buffer(0, buf.slice(..));
pass.draw(0..6, 0..self.instance_count);
}
}