e2 0.1.0

Lightweight 2D rendering toolbox for WGPU
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

use crate::*;

/// Stores GPU context handles, most notably the device and queue.
#[derive(Debug)]
pub struct Context {
    pub instance: wgpu::Instance,
    pub surface: wgpu::Surface,
    pub adapter: wgpu::Adapter,
    pub device: wgpu::Device,
    pub queue: wgpu::Queue,
}

impl Context {
    /// Creates a new [Context], rendering to `window`, selecting a backend from `backends`.
    pub fn new(
        window: &impl raw_window_handle::HasRawWindowHandle,
        backends: wgpu::Backends,
    ) -> Result<Self> {
        let instance = wgpu::Instance::new(backends);
        let surface = unsafe { instance.create_surface(window) };

        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
            power_preference: wgpu::PowerPreference::HighPerformance,
            force_fallback_adapter: false,
            compatible_surface: Some(&surface),
        }))
        .ok_or_else(|| Error::NoSuitableAdapter)?;

        let (device, queue) = pollster::block_on(adapter.request_device(
            &wgpu::DeviceDescriptor {
                label: None,
                features: wgpu::Features::empty(),
                limits: wgpu::Limits::default(),
            },
            None,
        ))?;

        Ok(Context {
            instance,
            surface,
            adapter,
            device,
            queue,
        })
    }

    /// Configures the surface with `width` and `height` in pixels and with `present_mode` presentation.
    pub fn configure_surface(&self, width: u32, height: u32, present_mode: wgpu::PresentMode) {
        self.surface.configure(
            &self.device,
            &wgpu::SurfaceConfiguration {
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
                format: self.surface.get_preferred_format(&self.adapter).unwrap(),
                width,
                height,
                present_mode,
            },
        );
    }

    /// Helper function for [wgpu::Surface::get_current_texture]
    pub fn next_frame(&self) -> Result<wgpu::SurfaceTexture> {
        Ok(self.surface.get_current_texture()?)
    }

    /// Helper function to pad uniform sizes to the next multiple of the minimum uniform buffer alignment.
    pub fn pad_uniform_size(&self, size: u64) -> u64 {
        let min = self.device.limits().min_uniform_buffer_offset_alignment as u64;
        if min > 0 {
            (size + min - 1) & !(min - 1)
        } else {
            size
        }
    }
}