Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

10.9 KB
Raw Blame
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),
                },
            ],
        })
    }
}