Skip to main content

alpha2_render/
present.rs

1//! Presenting rendered frames on a window's surface.
2
3/// The pipeline that copies a rendered texture onto a presentation surface (a canvas, a
4/// `CAMetalLayer`, an Android window), stretched to the surface's size.
5pub struct SurfacePresenter {
6    layout: wgpu::BindGroupLayout,
7    pipeline: wgpu::RenderPipeline,
8    sampler: wgpu::Sampler,
9}
10
11impl SurfacePresenter {
12    /// A presenter drawing into surfaces of `format`.
13    #[must_use]
14    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
15        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
16            label: Some("alpha2 surface presenter layout"),
17            entries: &[
18                wgpu::BindGroupLayoutEntry {
19                    binding: 0,
20                    visibility: wgpu::ShaderStages::FRAGMENT,
21                    ty: wgpu::BindingType::Texture {
22                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
23                        view_dimension: wgpu::TextureViewDimension::D2,
24                        multisampled: false,
25                    },
26                    count: None,
27                },
28                wgpu::BindGroupLayoutEntry {
29                    binding: 1,
30                    visibility: wgpu::ShaderStages::FRAGMENT,
31                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
32                    count: None,
33                },
34            ],
35        });
36        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
37            label: Some("alpha2 surface presenter shader"),
38            source: wgpu::ShaderSource::Wgsl(alpha2_shaders::CANVAS_PRESENT_WGSL.into()),
39        });
40        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
41            label: Some("alpha2 surface presenter pipeline layout"),
42            bind_group_layouts: &[Some(&layout)],
43            immediate_size: 0,
44        });
45        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
46            label: Some("alpha2 surface presenter pipeline"),
47            layout: Some(&pipeline_layout),
48            vertex: wgpu::VertexState {
49                module: &shader,
50                entry_point: Some("vs"),
51                compilation_options: wgpu::PipelineCompilationOptions::default(),
52                buffers: &[],
53            },
54            primitive: wgpu::PrimitiveState::default(),
55            depth_stencil: None,
56            multisample: wgpu::MultisampleState::default(),
57            fragment: Some(wgpu::FragmentState {
58                module: &shader,
59                entry_point: Some("fs"),
60                compilation_options: wgpu::PipelineCompilationOptions::default(),
61                targets: &[Some(wgpu::ColorTargetState {
62                    format,
63                    blend: None,
64                    write_mask: wgpu::ColorWrites::ALL,
65                })],
66            }),
67            multiview_mask: None,
68            cache: None,
69        });
70        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
71            label: Some("alpha2 surface presenter sampler"),
72            mag_filter: wgpu::FilterMode::Linear,
73            min_filter: wgpu::FilterMode::Linear,
74            ..Default::default()
75        });
76        Self {
77            layout,
78            pipeline,
79            sampler,
80        }
81    }
82
83    /// Draws `source` over all of `target` and submits the work.
84    pub fn draw(
85        &self,
86        device: &wgpu::Device,
87        gpu: &alpha2_gpu::GpuContext,
88        source: &wgpu::TextureView,
89        target: &wgpu::TextureView,
90    ) {
91        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
92            label: Some("alpha2 surface presenter bind group"),
93            layout: &self.layout,
94            entries: &[
95                wgpu::BindGroupEntry {
96                    binding: 0,
97                    resource: wgpu::BindingResource::TextureView(source),
98                },
99                wgpu::BindGroupEntry {
100                    binding: 1,
101                    resource: wgpu::BindingResource::Sampler(&self.sampler),
102                },
103            ],
104        });
105        // Submitted before returning, reading only the caller's view: no pooled texture can be
106        // let go of while it is unsubmitted.
107        #[allow(clippy::disallowed_methods)]
108        let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
109            label: Some("alpha2 surface presenter encoder"),
110        });
111        {
112            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
113                label: Some("alpha2 surface presenter pass"),
114                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
115                    view: target,
116                    depth_slice: None,
117                    resolve_target: None,
118                    ops: wgpu::Operations {
119                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
120                        store: wgpu::StoreOp::Store,
121                    },
122                })],
123                depth_stencil_attachment: None,
124                timestamp_writes: None,
125                occlusion_query_set: None,
126                multiview_mask: None,
127            });
128            pass.set_pipeline(&self.pipeline);
129            pass.set_bind_group(0, &bind_group, &[]);
130            pass.draw(0..3, 0..1);
131        }
132        gpu.submit([encoder.finish()]);
133    }
134}