verdant 0.3.0

A WIP windowing and rendering library, aiming to be lightweight, performant, and powerful.
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

use std::{io, sync::PoisonError};

#[cfg(feature = "image")]
use image::ImageError;
use thiserror::Error;
use wgpu::{CreateSurfaceError, RequestAdapterError, RequestDeviceError};
use winit::error::{EventLoopError, RequestError};

#[derive(Debug, Error)]
pub enum Error {
    // init errors
    #[error("Failed to find a GPU adapter: {0}")]
    NoAdapterFound(#[from] RequestAdapterError),

    #[error("Failed to request a device: {0}")]
    DeviceRequestFailed(#[from] RequestDeviceError),

    // window errors
    #[error("Failed to create window: {0}")]
    WindowCreationFailed(#[from] RequestError),

    #[error("Failed to create surface: {0}")]
    SurfaceCreationFailed(#[from] CreateSurfaceError),

    // image errors
    #[error("Blit region (at x: {x}, y: {y}, size: {width}x{height}) exceeds target dimensions ({img_width}x{img_height})")]
    BlitOutOfBounds {
        x: u32,
        y: u32,
        width: u32,
        height: u32,
        img_width: u32,
        img_height: u32,
    },

    #[error("Blit source buffer is too small: expected at least {expected} bytes, but got {actual} bytes")]
    BlitBufferTooSmall {
        expected: usize,
        actual: usize,
    },

    #[error("Read region (at x: {x}, y: {y}, size: {width}x{height}) exceeds source dimensions ({img_width}x{img_height})")]
    ReadOutOfBounds {
        x: u32,
        y: u32,
        width: u32,
        height: u32,
        img_width: u32,
        img_height: u32,
    },

    #[error("Read destination buffer is too small: expected at least {expected} bytes, but got {actual} bytes")]
    ReadBufferTooSmall {
        expected: usize,
        actual: usize,
    },

    #[error("Image source buffer is too small: expected at least {expected} bytes, but got {actual} bytes")]
    ImageBufferTooSmall {
        expected: usize,
        actual: usize,
    },

    #[cfg(feature = "image")]
    #[error("Image error: {0}")]
    ImageError(#[from] ImageError),

    // text errors
    #[error("Text was too big to fit in atlas")]
    TextTooBig,

    // misc errors
    #[error("IO error: {0}")]
    IOError(#[from] io::Error),

    #[error("Font error: {0}")]
    FontError(&'static str),

    #[error("Event loop error: {0}")]
    EventLoopError(#[from] EventLoopError),

    #[error("Poisoned lock error: {0}")]
    PoisonError(String),
}

impl<T> From<PoisonError<T>> for Error {
    fn from(error: PoisonError<T>) -> Self {
        Error::PoisonError(error.to_string())
    }
}