wgpu_context 0.4.0

Context for managing WGPU surfaces
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

//! Error type for WGPU Context

use std::error::Error;
use std::fmt::Display;
use wgpu::{PollError, RequestAdapterError, RequestDeviceError};

/// Errors that can occur in WgpuContext.
#[derive(Debug)]
pub enum WgpuContextError {
    /// There is no available device with the features required by Vello.
    NoCompatibleDevice,
    /// Failed to create surface.
    /// See [`wgpu::CreateSurfaceError`] for more information.
    WgpuCreateSurfaceError(wgpu::CreateSurfaceError),
    /// Surface doesn't support the required texture formats.
    /// Make sure that you have a surface which provides one of
    /// `TextureFormat::Rgba8Unorm`
    /// or `TextureFormat::Bgra8Unorm` as texture formats.
    // TODO: Why does this restriction exist?
    UnsupportedSurfaceFormat,
    /// Wgpu failed to request an adapter
    RequestAdapterError(RequestAdapterError),
    /// Wgpu failed to request a device
    RequestDeviceError(RequestDeviceError),
    /// Wgpu failed to poll a device
    PollError(PollError),
}

impl Display for WgpuContextError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NoCompatibleDevice => writeln!(f, "Couldn't find suitable device"),
            Self::WgpuCreateSurfaceError(inner) => {
                writeln!(f, "Couldn't create wgpu surface")?;
                inner.fmt(f)
            }
            Self::UnsupportedSurfaceFormat => {
                writeln!(
                    f,
                    "Couldn't find `Rgba8Unorm` or `Bgra8Unorm` texture formats for surface"
                )
            }
            Self::RequestAdapterError(inner) => {
                writeln!(f, "Couldn't request an adapter: {:#}", inner)
            }
            Self::RequestDeviceError(inner) => {
                writeln!(f, "Couldn't request a device: {:#}", inner)
            }
            Self::PollError(inner) => {
                writeln!(f, "Couldn't poll a device: {:#}", inner)
            }
        }
    }
}

impl Error for WgpuContextError {}
impl From<wgpu::CreateSurfaceError> for WgpuContextError {
    fn from(value: wgpu::CreateSurfaceError) -> Self {
        Self::WgpuCreateSurfaceError(value)
    }
}

impl From<RequestAdapterError> for WgpuContextError {
    fn from(value: RequestAdapterError) -> Self {
        Self::RequestAdapterError(value)
    }
}

impl From<RequestDeviceError> for WgpuContextError {
    fn from(value: RequestDeviceError) -> Self {
        Self::RequestDeviceError(value)
    }
}

impl From<PollError> for WgpuContextError {
    fn from(value: PollError) -> Self {
        Self::PollError(value)
    }
}