use super::gpu;
use std::collections::HashMap;
use super::{MarkTarget, DEPTH_FORMAT};
const SHADER: &str = crate::wgsl!(
r#"
struct Clear {
color : vec4<f32>,
// x: the depth written.
depth : vec4<f32>,
};
@group(0) @binding(0) var<uniform> clear : Clear;
@vertex
fn vs(@builtin(vertex_index) i : u32) -> @builtin(position) vec4<f32> {
let uv = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
return vec4<f32>(uv * 2.0 - 1.0, clear.depth.x, 1.0);
}
@fragment
fn fs() -> @location(0) vec4<f32> {
return clear.color;
}
"#
);
type Key = (wgpu::TextureFormat, u32, bool, bool, bool);
pub(crate) struct Clearer {
module: gpu::ShaderModule,
layout: gpu::BindGroupLayout,
pipeline_layout: gpu::PipelineLayout,
pipelines: HashMap<Key, gpu::RenderPipeline>,
}
impl Clearer {
pub(crate) fn new(device: &gpu::Device) -> Self {
let module = device.create_shader_module(gpu::ShaderModuleDescriptor {
label: Some("threers rect clear"),
source: gpu::ShaderSource::Wgsl(SHADER.into()),
});
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("threers rect clear bgl"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let pipeline_layout = device.create_pipeline_layout(&gpu::PipelineLayoutDescriptor {
label: Some("threers rect clear layout"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
Self {
module,
layout,
pipeline_layout,
pipelines: HashMap::new(),
}
}
fn pipeline(&mut self, device: &gpu::Device, key: Key) -> &gpu::RenderPipeline {
let (format, samples, has_depth, color, depth) = (key.0, key.1, key.2, key.3, key.4);
let (module, layout) = (&self.module, &self.pipeline_layout);
self.pipelines.entry(key).or_insert_with(|| {
device.create_render_pipeline(&gpu::RenderPipelineDescriptor {
label: Some("threers rect clear"),
layout: Some(layout),
vertex: gpu::VertexState {
module,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[],
},
fragment: Some(gpu::FragmentState {
module,
entry_point: Some("fs"),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format,
blend: None,
write_mask: if color {
wgpu::ColorWrites::ALL
} else {
wgpu::ColorWrites::empty()
},
})],
}),
primitive: wgpu::PrimitiveState::default(),
depth_stencil: has_depth.then(|| wgpu::DepthStencilState {
format: DEPTH_FORMAT,
depth_write_enabled: Some(depth),
depth_compare: Some(wgpu::CompareFunction::Always),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: wgpu::MultisampleState {
count: samples,
..Default::default()
},
multiview_mask: None,
cache: None,
})
})
}
pub(crate) fn clear(
&mut self,
device: &gpu::Device,
queue: &gpu::Queue,
target: &MarkTarget,
color: Option<wgpu::Color>,
depth: Option<f32>,
) {
let depth = depth.filter(|_| target.depth.is_some());
if color.is_none() && depth.is_none() {
return;
}
let c = color.unwrap_or(wgpu::Color::TRANSPARENT);
let uniform: [f32; 8] = [
c.r as f32,
c.g as f32,
c.b as f32,
c.a as f32,
depth.unwrap_or(1.0),
0.0,
0.0,
0.0,
];
let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("threers rect clear values"),
contents: bytemuck::cast_slice(&uniform),
usage: wgpu::BufferUsages::UNIFORM,
});
let bind = device.create_bind_group(&gpu::BindGroupDescriptor {
label: Some("threers rect clear bg"),
layout: &self.layout,
entries: &[gpu::BindGroupEntry {
binding: 0,
resource: buffer.as_entire_binding(),
}],
});
let key = (
target.format,
target.samples,
target.depth.is_some(),
color.is_some(),
depth.is_some(),
);
let pipeline = self.pipeline(device, key).clone();
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("threers rect clear"),
});
{
let mut pass = super::MarkRenderer::begin_target_pass(&mut encoder, target);
pass.set_pipeline(&pipeline);
pass.set_bind_group(0, &bind, &[]);
pass.draw(0..3, 0..1);
}
queue.submit(Some(encoder.finish()));
}
}