use wgpu::util::DeviceExt;
pub(crate) struct Accumulator {
_texture: wgpu::Texture,
view: wgpu::TextureView,
width: u32,
height: u32,
add: wgpu::RenderPipeline,
add_layout: wgpu::BindGroupLayout,
resolve: wgpu::RenderPipeline,
w_add: wgpu::Buffer,
w_res: wgpu::Buffer,
resolve_bg: wgpu::BindGroup,
add_bg: std::cell::RefCell<Option<(u64, wgpu::BindGroup)>>,
out_format: wgpu::TextureFormat,
}
impl Accumulator {
pub fn new(
device: &wgpu::Device,
width: u32,
height: u32,
out_format: wgpu::TextureFormat,
) -> Self {
let encoded = super::shader_applies_transfer(out_format);
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("threers accumulate"),
source: wgpu::ShaderSource::Wgsl(
format!(
"{}\n{}",
crate::renderer::fullscreen::VS,
shader_source(encoded)
)
.into(),
),
});
let mk_layout = |label| {
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some(label),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: false },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
})
};
let add_layout = mk_layout("threers accumulate add layout");
let resolve_layout = mk_layout("threers accumulate resolve layout");
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("threers accumulation buffer"),
size: wgpu::Extent3d {
width: width.max(1),
height: height.max(1),
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba16Float,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
let mk_pipeline = |label, entry, layout: &wgpu::BindGroupLayout, fmt, blend| {
let pl = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some(label),
bind_group_layouts: &[Some(layout)],
immediate_size: 0,
});
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(&pl),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some(crate::renderer::fullscreen::VS_ENTRY),
buffers: &[],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(entry),
targets: &[Some(wgpu::ColorTargetState {
format: fmt,
blend,
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,
})
};
let additive = Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::One,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::One,
operation: wgpu::BlendOperation::Add,
},
});
let add = mk_pipeline(
"threers accumulate add",
"fs_add",
&add_layout,
wgpu::TextureFormat::Rgba16Float,
additive,
);
let resolve = mk_pipeline(
"threers accumulate resolve",
"fs_resolve",
&resolve_layout,
out_format,
Some(wgpu::BlendState::REPLACE),
);
let weight_buf = |label| {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(label),
contents: bytemuck::cast_slice(&[1.0f32, 0.0, 0.0, 0.0]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
})
};
let w_add = weight_buf("threers accumulate add weight");
let w_res = weight_buf("threers accumulate resolve weight");
let resolve_bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("threers accumulate resolve bind"),
layout: &resolve_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: w_res.as_entire_binding(),
},
],
});
Self {
_texture: texture,
view,
width,
height,
add,
add_layout,
resolve,
w_add,
w_res,
resolve_bg,
add_bg: std::cell::RefCell::new(None),
out_format,
}
}
pub fn matches(&self, width: u32, height: u32, out_format: wgpu::TextureFormat) -> bool {
self.width == width && self.height == height && self.out_format == out_format
}
pub fn add_sample(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
src: &wgpu::TextureView,
key: u64,
weight: f32,
clear: bool,
) {
queue.write_buffer(
&self.w_add,
0,
bytemuck::cast_slice(&[weight, 0.0, 0.0, 0.0]),
);
let mut cached = self.add_bg.borrow_mut();
if cached.as_ref().is_none_or(|(k, _)| *k != key) {
*cached = Some((
key,
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("threers accumulate add bind"),
layout: &self.add_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(src),
},
wgpu::BindGroupEntry {
binding: 1,
resource: self.w_add.as_entire_binding(),
},
],
}),
));
}
let bg = &cached.as_ref().unwrap().1;
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("threers accumulate add pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &self.view,
depth_slice: None,
resolve_target: None,
ops: wgpu::Operations {
load: if clear {
wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)
} else {
wgpu::LoadOp::Load
},
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_pipeline(&self.add);
pass.set_bind_group(0, bg, &[]);
pass.draw(0..3, 0..1);
}
pub fn resolve_into(
&self,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
dst: &wgpu::TextureView,
total: f32,
) {
queue.write_buffer(
&self.w_res,
0,
bytemuck::cast_slice(&[1.0 / total.max(1e-6), 0.0, 0.0, 0.0]),
);
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("threers accumulate resolve pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: dst,
depth_slice: None,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_pipeline(&self.resolve);
pass.set_bind_group(0, &self.resolve_bg, &[]);
pass.draw(0..3, 0..1);
}
}
fn shader_source(encoded: bool) -> String {
let (decode, encode) = if encoded {
("srgb_to_linear(c.rgb)", "linear_to_srgb(c.rgb)")
} else {
("c.rgb", "c.rgb")
};
format!(
"{}{}",
SHADER.replace("DECODE", decode).replace("ENCODE", encode),
super::colorspace::WGSL
)
}
const SHADER: &str = crate::wgsl!(
r#"
struct W { weight : f32, _p0 : f32, _p1 : f32, _p2 : f32 };
@group(0) @binding(0) var src : texture_2d<f32>;
@group(0) @binding(1) var<uniform> w : W;
@fragment
fn fs_add(@builtin(position) pos : vec4<f32>) -> @location(0) vec4<f32> {
let c = textureLoad(src, vec2<i32>(pos.xy), 0);
return vec4<f32>(DECODE, c.a) * w.weight;
}
@fragment
fn fs_resolve(@builtin(position) pos : vec4<f32>) -> @location(0) vec4<f32> {
var c = textureLoad(src, vec2<i32>(pos.xy), 0) * w.weight;
// Negative light is filter ringing, not signal, and the encode is undefined
// there.
c = vec4<f32>(max(c.rgb, vec3<f32>(0.0)), clamp(c.a, 0.0, 1.0));
return vec4<f32>(ENCODE, c.a);
}
"#
);