use crate::shading::gbuffer::COLOR;
use crate::view::targets::{attachment, hold};
pub(crate) static COPY: crate::shading::Module = crate::shading::Module {
name: "transmission_copy",
source: include_str!("transmission.wgsl"),
deps: &[&crate::shading::FULLSCREEN_VS],
};
pub(crate) const COPY_FS_ENTRY: &str = "transmission_copy_fs";
pub(crate) const DOWNSAMPLE_FS_ENTRY: &str = "transmission_downsample_fs";
pub(crate) struct Transmission {
layout: wgpu::BindGroupLayout,
copy: wgpu::RenderPipeline,
downsample: wgpu::RenderPipeline,
sampler: wgpu::Sampler,
levels: Option<Levels>,
}
struct Levels {
view: wgpu::TextureView,
first: wgpu::TextureView,
further: Vec<(wgpu::TextureView, wgpu::BindGroup)>,
}
impl Transmission {
pub fn new(device: &wgpu::Device) -> Self {
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("transmission copy source"),
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 module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("transmission copy"),
source: wgpu::ShaderSource::Wgsl(crate::shading::compose(&[©]).into()),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("transmission copy"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let pipeline = |label, fragment| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &module,
entry_point: Some(crate::shading::FULLSCREEN_VS_ENTRY),
compilation_options: Default::default(),
buffers: &[],
},
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some(fragment),
compilation_options: Default::default(),
targets: &[Some(COLOR.into())],
}),
primitive: Default::default(),
depth_stencil: None,
multisample: Default::default(),
multiview_mask: None,
cache: None,
})
};
Self {
copy: pipeline("transmission copy", COPY_FS_ENTRY),
downsample: pipeline("transmission copy downsample", DOWNSAMPLE_FS_ENTRY),
sampler: device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("transmission copy downsample"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
}),
layout,
levels: None,
}
}
pub fn encode(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
composed: &wgpu::TextureView,
timing: Option<&crate::timing::GpuTiming>,
) -> &wgpu::TextureView {
let size = composed.texture().size();
let (layout, sampler) = (&self.layout, &self.sampler);
let levels = hold(&mut self.levels, Levels::texture, size, || {
Levels::new(device, layout, sampler, size)
});
let source = group(device, layout, sampler, composed);
let passes = std::iter::once((&self.copy, &levels.first, &source)).chain(
levels
.further
.iter()
.map(|(target, group)| (&self.downsample, target, group)),
);
for (pipeline, target, group) in passes {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("transmission copy"),
color_attachments: &[attachment(target)],
timestamp_writes: timing.and_then(|t| t.render_pass("transmission copy")),
..Default::default()
});
pass.set_pipeline(pipeline);
pass.set_bind_group(0, group, &[]);
pass.draw(0..3, 0..1);
}
&levels.view
}
}
impl Levels {
fn texture(&self) -> &wgpu::Texture {
self.view.texture()
}
fn new(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
sampler: &wgpu::Sampler,
size: wgpu::Extent3d,
) -> Self {
let count = size.max_mips(wgpu::TextureDimension::D2);
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("transmission copy"),
size,
mip_level_count: count,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: COLOR,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
let level = |level| {
texture.create_view(&wgpu::TextureViewDescriptor {
base_mip_level: level,
mip_level_count: Some(1),
..Default::default()
})
};
Self {
view: texture.create_view(&Default::default()),
first: level(0),
further: (1..count)
.map(|index| {
(
level(index),
group(device, layout, sampler, &level(index - 1)),
)
})
.collect(),
}
}
}
fn group(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
sampler: &wgpu::Sampler,
source: &wgpu::TextureView,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("transmission copy source"),
layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(source),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(sampler),
},
],
})
}