agpu 0.1.2

Abstract GPU Project
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::{CommandEncoder, Gpu, GpuError, RenderPassBuilder};
use std::mem::ManuallyDrop;

/// Convenience wrapper for a frame buffer you render to.
/// `Frame` will automatically submit the finished encoder to the queue
/// and present the frame to the screen.
/// This was previously a repesentation of the swap chain
/// but since wgpu 0.11 it now wraps the surface texture
pub struct Frame<'a> {
    /// The gpu handle is ref'd because of the short lifetime of Frame
    pub(crate) gpu: &'a Gpu,
    /// The surface texture provided by the surface
    /// ManuallyDrop because we call `.present()` on it to present to screen
    surface_texture: ManuallyDrop<wgpu::SurfaceTexture>,
    /// The Optional depth texture
    pub depth_texture: crate::TextureView<'a>,
    pub view: crate::TextureView<'a>,
    pub encoder: ManuallyDrop<CommandEncoder>,
    pub delta_time: Option<f32>,
    pub resized_to: Option<(u32, u32)>,
}

impl Frame<'_> {
    pub fn render_pass<'f>(&'f mut self, label: &'f str) -> RenderPassBuilder {
        RenderPassBuilder {
            encoder: &mut self.encoder,
            desc: wgpu::RenderPassDescriptor {
                label: Some(label),
                color_attachments: &[],
                // TODO: This will map to the surface depth
                depth_stencil_attachment: None,
            },
            init_color_attachments: Some(vec![wgpu::RenderPassColorAttachment {
                view: &self.view,
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Load,
                    store: true,
                },
            }]),
            init_pipeline: None,
        }
    }

    pub fn render_pass_cleared<'f>(
        &'f mut self,
        label: &'f str,
        clear_color: u32,
    ) -> RenderPassBuilder {
        let [r, g, b, a] = clear_color.to_be_bytes();
        RenderPassBuilder {
            encoder: &mut self.encoder,
            desc: wgpu::RenderPassDescriptor {
                label: Some(label),
                color_attachments: &[],
                depth_stencil_attachment: None,
            },
            init_color_attachments: Some(vec![wgpu::RenderPassColorAttachment {
                view: &self.view,
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Clear(wgpu::Color {
                        r: r as f64 / 255.0,
                        g: g as f64 / 255.0,
                        b: b as f64 / 255.0,
                        a: a as f64 / 255.0,
                    }),
                    store: true,
                },
            }]),
            init_pipeline: None,
        }
    }

    pub fn create_encoder(&self, label: &str) -> CommandEncoder {
        self.gpu.create_command_encoder(label)
    }
}

impl<'a> Frame<'a> {
    /// Creates a new Frame from the Surface
    /// We
    pub fn new(
        gpu: &'a Gpu,
        surface: &wgpu::Surface,
        depth: wgpu::TextureView,
    ) -> Result<Self, GpuError> {
        let frame = surface
            .get_current_texture()
            .map_err(GpuError::SurfaceError)?;
        let frame_view = frame.texture.create_view(&wgpu::TextureViewDescriptor {
            // TODO: Custom label
            label: Some("Viewport frame view"),
            ..Default::default()
        });
        let mut encoder = gpu.create_command_encoder("Viewport render encoder");

        gpu.begin_profiler_section("Frame start", &mut encoder);

        Ok(Frame {
            gpu,
            surface_texture: ManuallyDrop::new(frame),
            depth_texture: gpu.wrap_view(depth),
            view: gpu.wrap_view(frame_view),
            encoder: ManuallyDrop::new(encoder),
            delta_time: None,
            resized_to: None,
        })
    }
}

/// On drop, we submit the encoder to the queue and present the frame
impl Drop for Frame<'_> {
    fn drop(&mut self) {
        // Take ownership of the encoder field so that it can be consumed by submit()
        // and the frame field so it can be consumed by present()
        // This is safe because we are dropping the struct right after this
        let frame = unsafe { ManuallyDrop::take(&mut self.surface_texture) };

        // First submit the encoder to the queue
        unsafe { ManuallyDrop::drop(&mut self.encoder) };
        // Then present the frame to the screen
        frame.present();
        self.gpu.profiler.clear();
    }
}