mugltf 0.1.2

Minimal glTF 2.0 asset loader for Rust
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
127
128
129
130
131
132
133

//! Error types.

use super::Id;
use alloc::boxed::Box;
use core::fmt;

/// Error type.
#[cfg(feature = "std")]
pub type Error = dyn std::error::Error;
/// Error type.
#[cfg(not(feature = "std"))]
pub type Error = dyn core::any::Any;

/// Error when parsing a glTF / GLB file.
#[derive(Debug, Default)]
pub struct ParseGltfError {
    kind: ParseGltfErrorKind,
    #[allow(unused)]
    error: Option<Box<Error>>,
}

impl ParseGltfError {
    /// Creates a new `ParseGLBError`.
    #[inline]
    pub fn new<E: Into<Box<Error>>>(kind: ParseGltfErrorKind, error: E) -> Self {
        Self {
            kind,
            error: Some(error.into()),
        }
    }
}

impl fmt::Display for ParseGltfError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.kind {
            ParseGltfErrorKind::InvalidHeader => write!(f, "invalid GLB header"),
            ParseGltfErrorKind::UnsupportedVersion => write!(f, "unsupported glTF version"),
            ParseGltfErrorKind::InvalidChunkHeader => write!(f, "invalid GLB chunk header"),
            ParseGltfErrorKind::InvalidChunk => write!(f, "invalid GLB chunk data"),
            ParseGltfErrorKind::MissingJson => write!(f, "missing glTF JSON content"),
            _ => write!(f, "invalid GLB"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for ParseGltfError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(self.error.as_ref()?.as_ref())
    }
}

/// The kind of glTF parsing error.
#[derive(Clone, Copy, Debug)]
pub enum ParseGltfErrorKind {
    InvalidHeader,
    UnsupportedVersion,
    InvalidChunkHeader,
    InvalidChunk,
    InvalidJson,
    MissingJson,
    Other,
}

impl Default for ParseGltfErrorKind {
    fn default() -> Self {
        Self::Other
    }
}

impl From<ParseGltfErrorKind> for ParseGltfError {
    fn from(kind: ParseGltfErrorKind) -> Self {
        Self { kind, error: None }
    }
}

/// Error when loading resources for a glTF file.
#[derive(Debug, Default)]
pub struct LoadGltfResourceError {
    kind: LoadGltfResourceErrorKind,
    #[allow(unused)]
    error: Option<Box<Error>>,
}

impl LoadGltfResourceError {
    /// Creates a new `LoadGltfResourceError`.
    #[inline]
    pub fn new<E: Into<Box<Error>>>(kind: LoadGltfResourceErrorKind, error: E) -> Self {
        Self {
            kind,
            error: Some(error.into()),
        }
    }
}

impl fmt::Display for LoadGltfResourceError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.kind {
            LoadGltfResourceErrorKind::LoadBufferError(id) => write!(f, "failed to load buffer {}", id),
            LoadGltfResourceErrorKind::LoadImageError(id) => write!(f, "failed to load image {}", id),
            LoadGltfResourceErrorKind::ParseGltfError => write!(f, "failed to parse glTF or GLB file"),
            _ => write!(f, "failed to load resource"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for LoadGltfResourceError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(self.error.as_ref()?.as_ref())
    }
}

/// The kind of glTF resource loading error.
#[derive(Clone, Copy, Debug)]
pub enum LoadGltfResourceErrorKind {
    LoadImageError(Id),
    LoadBufferError(Id),
    LoadError,
    ParseGltfError,
}

impl Default for LoadGltfResourceErrorKind {
    fn default() -> Self {
        Self::LoadError
    }
}

impl From<LoadGltfResourceErrorKind> for LoadGltfResourceError {
    fn from(kind: LoadGltfResourceErrorKind) -> Self {
        Self { kind, error: None }
    }
}