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 std::error::Error as StdError;
use std::fmt::{Display, Formatter};
use std::fmt::Result as FmtResult;
use std::result::Result as StdResult;
use gfx;
use gfx_core;
pub type Result<T> = StdResult<T, Error>;
#[derive(Debug)]
pub enum Error {
BufferCreation(gfx::buffer::CreationError),
NoSuchTarget(String),
PassInit(gfx::PipelineStateError<String>),
PipelineCreation(gfx_core::pso::CreationError),
PoolCreation(String),
ProgramCreation(gfx::shade::ProgramError),
ResViewCreation(gfx::ResourceViewError),
TargetCreation(gfx::CombinedError),
TextureCreation(gfx::texture::CreationError),
WindowDestroyed,
}
impl StdError for Error {
fn description(&self) -> &str {
match *self {
Error::BufferCreation(_) => "Failed to create buffer!",
Error::NoSuchTarget(_) => "Target with this name does not exist!",
Error::PassInit(_) => "Failed to initialize render pass!",
Error::PipelineCreation(_) => "Failed to create PSO!",
Error::PoolCreation(_) => "Failed to create thread pool!",
Error::ProgramCreation(_) => "Failed to create shader program!",
Error::ResViewCreation(_) => "Failed to create resource view!",
Error::TargetCreation(_) => "Failed to create render target!",
Error::TextureCreation(_) => "Failed to create texture!",
Error::WindowDestroyed => "Window has been destroyed!",
}
}
fn cause(&self) -> Option<&StdError> {
match *self {
Error::BufferCreation(ref e) => Some(e),
Error::PassInit(ref e) => Some(e),
Error::PipelineCreation(ref e) => Some(e),
Error::ProgramCreation(ref e) => Some(e),
Error::ResViewCreation(ref e) => Some(e),
Error::TargetCreation(ref e) => Some(e),
Error::TextureCreation(ref e) => Some(e),
_ => None,
}
}
}
impl Display for Error {
fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
match *self {
Error::BufferCreation(ref e) => write!(fmt, "Buffer creation failed: {}", e),
Error::NoSuchTarget(ref e) => write!(fmt, "Nonexistent target: {}", e),
Error::PassInit(ref e) => write!(fmt, "Pass initialization failed: {}", e),
Error::PipelineCreation(ref e) => write!(fmt, "PSO creation failed: {}", e),
Error::PoolCreation(ref e) => write!(fmt, "Thread pool creation failed: {}", e),
Error::ProgramCreation(ref e) => write!(fmt, "Program compilation failed: {}", e),
Error::ResViewCreation(ref e) => write!(fmt, "Resource view creation failed: {}", e),
Error::TargetCreation(ref e) => write!(fmt, "Target creation failed: {}", e),
Error::TextureCreation(ref e) => write!(fmt, "Texture creation failed: {}", e),
Error::WindowDestroyed => write!(fmt, "Window has been destroyed"),
}
}
}
impl From<gfx::CombinedError> for Error {
fn from(e: gfx::CombinedError) -> Error {
Error::TargetCreation(e)
}
}
impl From<gfx::PipelineStateError<String>> for Error {
fn from(e: gfx::PipelineStateError<String>) -> Error {
Error::PassInit(e)
}
}
impl From<gfx::ResourceViewError> for Error {
fn from(e: gfx::ResourceViewError) -> Error {
Error::ResViewCreation(e)
}
}
impl From<gfx::buffer::CreationError> for Error {
fn from(e: gfx::buffer::CreationError) -> Error {
Error::BufferCreation(e)
}
}
impl From<gfx::shade::ProgramError> for Error {
fn from(e: gfx::shade::ProgramError) -> Error {
Error::ProgramCreation(e)
}
}
impl From<gfx::texture::CreationError> for Error {
fn from(e: gfx::texture::CreationError) -> Error {
Error::TextureCreation(e)
}
}
impl From<gfx_core::pso::CreationError> for Error {
fn from(e: gfx_core::pso::CreationError) -> Error {
Error::PipelineCreation(e)
}
}