Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use wgpu::util::DeviceExt;
#[repr(C)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct BlurUniforms {
direction: [f32; 2],
texel_size: [f32; 2],
intensity: f32,
_padding: f32,
_padding2: [f32; 2],
}
pub struct BlurPipeline {
blur_pipeline: wgpu::RenderPipeline,
blur_bind_group_layout: wgpu::BindGroupLayout,
sampler: wgpu::Sampler,
uniforms: Option<BlurUniformBuffers>,
}
struct BlurUniformBuffers {
dimensions: (u32, u32),
intensity: f32,
horizontal: wgpu::Buffer,
vertical: wgpu::Buffer,
}
pub struct BlurPassInputs<'a> {
pub source: &'a wgpu::TextureView,
pub intermediate: &'a wgpu::TextureView,
pub output: &'a wgpu::TextureView,
pub width: u32,
pub height: u32,
pub intensity: f32,
}
impl BlurPipeline {
pub fn new(device: &wgpu::Device) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Gaussian Blur Shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/gaussian_blur.wgsl").into()),
});
let blur_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Blur Bind Group Layout"),
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,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::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(&wgpu::PipelineLayoutDescriptor {
label: Some("Blur Pipeline Layout"),
bind_group_layouts: &[&blur_bind_group_layout],
push_constant_ranges: &[],
});
let blur_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Blur Pipeline"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("fs_main"),
targets: &[Some(wgpu::ColorTargetState {
format: wgpu::TextureFormat::Rgba16Float,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: Default::default(),
}),
primitive: wgpu::PrimitiveState::default(),
depth_stencil: None,
multisample: Default::default(),
multiview: None,
cache: None,
});
let 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,
..Default::default()
});
Self {
blur_pipeline,
blur_bind_group_layout,
sampler,
uniforms: None,
}
}
pub fn blur_two_pass(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
inputs: BlurPassInputs<'_>,
) {
let BlurPassInputs {
source,
intermediate,
output,
width,
height,
intensity,
} = inputs;
if self.uniforms.as_ref().is_none_or(|uniforms| {
uniforms.dimensions != (width, height) || uniforms.intensity != intensity
}) {
let create_uniform = |label, direction| {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(label),
contents: bytemuck::bytes_of(&BlurUniforms {
direction,
texel_size: [1.0 / width as f32, 1.0 / height as f32],
intensity,
_padding: 0.0,
_padding2: [0.0, 0.0],
}),
usage: wgpu::BufferUsages::UNIFORM,
})
};
self.uniforms = Some(BlurUniformBuffers {
dimensions: (width, height),
intensity,
horizontal: create_uniform("Blur H Uniform", [1.0, 0.0]),
vertical: create_uniform("Blur V Uniform", [0.0, 1.0]),
});
}
let uniforms = self.uniforms.as_ref().expect("uniforms initialized above");
let h_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Blur H Bind Group"),
layout: &self.blur_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(source),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&self.sampler),
},
wgpu::BindGroupEntry {
binding: 2,
resource: uniforms.horizontal.as_entire_binding(),
},
],
});
{
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Blur Horizontal Pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: intermediate,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
});
pass.set_pipeline(&self.blur_pipeline);
pass.set_bind_group(0, &h_bind_group, &[]);
pass.draw(0..3, 0..1);
}
let v_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Blur V Bind Group"),
layout: &self.blur_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(intermediate),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&self.sampler),
},
wgpu::BindGroupEntry {
binding: 2,
resource: uniforms.vertical.as_entire_binding(),
},
],
});
{
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Blur Vertical Pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: output,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
});
pass.set_pipeline(&self.blur_pipeline);
pass.set_bind_group(0, &v_bind_group, &[]);
pass.draw(0..3, 0..1);
}
}
}
pub struct CompositePipeline {
pipeline: wgpu::RenderPipeline,
cutout_pipeline: wgpu::RenderPipeline,
background_pipeline: wgpu::RenderPipeline,
bind_group_layout: wgpu::BindGroupLayout,
sampler: wgpu::Sampler,
}
pub struct CompositePassInputs<'a> {
pub sharp: &'a wgpu::TextureView,
pub blurred: &'a wgpu::TextureView,
pub mask: &'a wgpu::TextureView,
pub matte: &'a wgpu::TextureView,
pub output: &'a wgpu::TextureView,
}
impl CompositePipeline {
pub fn new(device: &wgpu::Device, output_format: wgpu::TextureFormat) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Mask Composite Shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/mask_composite.wgsl").into()),
});
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Composite Bind Group Layout"),
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::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::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 3,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 4,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Composite Pipeline Layout"),
bind_group_layouts: &[&bind_group_layout],
push_constant_ranges: &[],
});
let create_pipeline = |entry_point, format| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Composite Pipeline"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(entry_point),
targets: &[Some(wgpu::ColorTargetState {
format,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: Default::default(),
}),
primitive: wgpu::PrimitiveState::default(),
depth_stencil: None,
multisample: Default::default(),
multiview: None,
cache: None,
})
};
let pipeline = create_pipeline("fs_main", output_format);
let cutout_pipeline = create_pipeline("fs_cutout", output_format);
let background_pipeline =
create_pipeline("fs_background", wgpu::TextureFormat::Rgba16Float);
let 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,
..Default::default()
});
Self {
pipeline,
cutout_pipeline,
background_pipeline,
bind_group_layout,
sampler,
}
}
pub fn composite(
&self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
inputs: CompositePassInputs<'_>,
remove_background: bool,
) {
let pipeline = if remove_background {
&self.cutout_pipeline
} else {
&self.pipeline
};
self.draw(device, encoder, inputs, pipeline);
}
pub fn prepare_background(
&self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
inputs: CompositePassInputs<'_>,
) {
self.draw(device, encoder, inputs, &self.background_pipeline);
}
fn draw(
&self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
inputs: CompositePassInputs<'_>,
pipeline: &wgpu::RenderPipeline,
) {
let CompositePassInputs {
sharp: sharp_view,
blurred: blurred_view,
mask: mask_view,
matte: matte_view,
output: output_view,
} = inputs;
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Composite Bind Group"),
layout: &self.bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(sharp_view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(blurred_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(mask_view),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::Sampler(&self.sampler),
},
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::TextureView(matte_view),
},
],
});
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Composite Pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: output_view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
});
pass.set_pipeline(pipeline);
pass.set_bind_group(0, &bind_group, &[]);
pass.draw(0..3, 0..1);
}
}