Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use bytemuck::{Pod, Zeroable};
use wgpu::util::DeviceExt;
use super::SourceBindGroups;
use crate::ProjectUniforms;
pub struct BlurLayer {
pub blur_amount: f64,
sampler: wgpu::Sampler,
uniforms_buffer_h: wgpu::Buffer,
uniforms_buffer_v: wgpu::Buffer,
pipeline: BlurPipeline,
cached_uniforms: Option<BlurUniforms>,
result: Option<(BlurResultKey, wgpu::Texture)>,
bind_groups: SourceBindGroups,
}
/// Everything the blurred background depends on. While it matches, the
/// previous frame's blurred background is still exact and two full-frame
/// gaussian passes collapse into one texture copy. On a software rasterizer
/// those passes are most of the frame's cost.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct BlurResultKey {
pub background_generation: u64,
pub blur_amount_bits: u64,
pub output_size: (u32, u32),
pub texture_size: (u32, u32),
}
impl BlurLayer {
pub fn new(device: &wgpu::Device) -> Self {
let make_buffer = |direction: f32| {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("BackgroundBlur Uniform Buffer"),
contents: bytemuck::cast_slice(&[BlurUniforms {
direction,
..Default::default()
}]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
})
};
Self {
blur_amount: 0.0,
sampler: device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Nearest,
..Default::default()
}),
uniforms_buffer_h: make_buffer(0.0),
uniforms_buffer_v: make_buffer(1.0),
pipeline: BlurPipeline::new(device),
cached_uniforms: None,
result: None,
bind_groups: SourceBindGroups::default(),
}
}
pub fn cached_result(&self, key: BlurResultKey) -> Option<&wgpu::Texture> {
self.result
.as_ref()
.filter(|(cached, _)| *cached == key)
.map(|(_, texture)| texture)
}
pub fn clear_result(&mut self) {
self.result = None;
}
#[cfg(test)]
pub fn has_cached_result(&self) -> bool {
self.result.is_some()
}
pub fn store_result(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
key: BlurResultKey,
source: &wgpu::Texture,
) {
let size = source.size();
let reusable = self
.result
.take()
.map(|(_, texture)| texture)
.filter(|texture| texture.size() == size && texture.format() == source.format());
let texture = reusable.unwrap_or_else(|| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some("Blurred Background Cache"),
size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: source.format(),
usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
})
});
encoder.copy_texture_to_texture(source.as_image_copy(), texture.as_image_copy(), size);
self.result = Some((key, texture));
}
pub fn prepare(&mut self, queue: &wgpu::Queue, uniforms: &ProjectUniforms) {
self.blur_amount = uniforms.project.background.blur;
if self.blur_amount <= 0.0 {
return;
}
let blur_strength = uniforms.project.background.blur as f32 / 100.0;
let blur_uniform = BlurUniforms {
output_size: [uniforms.output_size.0 as f32, uniforms.output_size.1 as f32],
blur_strength,
direction: 0.0,
};
if self.cached_uniforms.as_ref() != Some(&blur_uniform) {
queue.write_buffer(
&self.uniforms_buffer_h,
0,
bytemuck::cast_slice(&[blur_uniform]),
);
queue.write_buffer(
&self.uniforms_buffer_v,
0,
bytemuck::cast_slice(&[BlurUniforms {
direction: 1.0,
..blur_uniform
}]),
);
self.cached_uniforms = Some(blur_uniform);
}
}
pub fn retain_views(&mut self, views: [&wgpu::TextureView; 2]) {
self.bind_groups.retain_views(views);
}
#[cfg(test)]
pub fn bind_groups_created(&self) -> usize {
self.bind_groups.created()
}
pub fn render_h(
&mut self,
pass: &mut wgpu::RenderPass<'_>,
device: &wgpu::Device,
source_texture: &wgpu::TextureView,
) {
self.render_pass(pass, device, source_texture, false);
}
pub fn render_v(
&mut self,
pass: &mut wgpu::RenderPass<'_>,
device: &wgpu::Device,
source_texture: &wgpu::TextureView,
) {
self.render_pass(pass, device, source_texture, true);
}
fn render_pass(
&mut self,
pass: &mut wgpu::RenderPass<'_>,
device: &wgpu::Device,
source_texture: &wgpu::TextureView,
vertical: bool,
) {
let uniforms_buffer = if vertical {
&self.uniforms_buffer_v
} else {
&self.uniforms_buffer_h
};
let bind_group = self
.bind_groups
.get_or_create(uniforms_buffer, source_texture, || {
self.pipeline
.bind_group(device, uniforms_buffer, source_texture, &self.sampler)
});
pass.set_pipeline(&self.pipeline.render_pipeline);
pass.set_bind_group(0, bind_group, &[]);
pass.draw(0..4, 0..1);
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Pod, Zeroable, Default, PartialEq)]
pub struct BlurUniforms {
output_size: [f32; 2],
blur_strength: f32,
direction: f32,
}
pub struct BlurPipeline {
pub bind_group_layout: wgpu::BindGroupLayout,
pub render_pipeline: wgpu::RenderPipeline,
}
impl BlurPipeline {
pub fn new(device: &wgpu::Device) -> Self {
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("background-blur Bind Group Layout"),
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,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
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: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Background Blur Shader"),
source: wgpu::ShaderSource::Wgsl(
include_str!("../shaders/background-blur.wgsl").into(),
),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Background Blur Pipeline Layout"),
bind_group_layouts: &[&bind_group_layout],
push_constant_ranges: &[],
});
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Background Blur Pipeline"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[],
compilation_options: wgpu::PipelineCompilationOptions {
constants: &[],
zero_initialize_workgroup_memory: false,
},
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("fs_main"),
targets: &[Some(wgpu::ColorTargetState {
format: wgpu::TextureFormat::Rgba8Unorm,
blend: Some(wgpu::BlendState::REPLACE),
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: wgpu::PipelineCompilationOptions {
constants: &[],
zero_initialize_workgroup_memory: false,
},
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: Some(wgpu::Face::Back),
polygon_mode: wgpu::PolygonMode::Fill,
unclipped_depth: false,
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState::default(),
multiview: None,
cache: None,
});
Self {
bind_group_layout,
render_pipeline,
}
}
pub fn bind_group(
&self,
device: &wgpu::Device,
uniform_buffer: &wgpu::Buffer,
texture_view: &wgpu::TextureView,
sampler: &wgpu::Sampler,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("BackgroundBlur Bind Group"),
layout: &self.bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform_buffer.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(texture_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(sampler),
},
],
})
}
}