amethyst_renderer 0.10.4

High-level rendering engine with multiple backends
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Color value types.

use amethyst_core::specs::{Component, DenseVecStorage};

use gfx::shade::{Formatted, ToUniform};
use gfx_core::shade::{BaseType, ContainerType, UniformValue};
use glsl_layout::{vec3, vec4};

/// An RGBA color value.
///
/// ## As a Component
/// If you attach this as a component to an entity then passes should multiply any rendered pixels
/// in the component with this color.  Please note alpha multiplication will only produce
/// transparency if the rendering pass would normally be capable of rendering that entity
/// transparently.
///
/// ## More than a Component
/// This structure has more uses than just as a component, and you'll find it in other places
/// throughout the `amethyst_renderer` API.
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize)]
pub struct Rgba(pub f32, pub f32, pub f32, pub f32);

impl Rgba {
    /// Solid black color value.
    pub const BLACK: Rgba = Rgba(0.0, 0.0, 0.0, 1.0);
    /// Solid blue color value.
    pub const BLUE: Rgba = Rgba(0.0, 0.0, 1.0, 1.0);
    /// Solid green color value.
    pub const GREEN: Rgba = Rgba(0.0, 1.0, 0.0, 1.0);
    /// Solid red color value.
    pub const RED: Rgba = Rgba(1.0, 0.0, 0.0, 1.0);
    /// Transparent color value.
    pub const TRANSPARENT: Rgba = Rgba(0.0, 0.0, 0.0, 0.0);
    /// Solid white color value.
    pub const WHITE: Rgba = Rgba(1.0, 1.0, 1.0, 1.0);

    /// Returns a solid black color value.
    pub fn black() -> Rgba {
        Rgba::BLACK
    }

    /// Returns a solid blue color value.
    pub fn blue() -> Rgba {
        Rgba::BLUE
    }

    /// Returns a solid green color value.
    pub fn green() -> Rgba {
        Rgba::GREEN
    }

    /// Returns a solid red color value.
    pub fn red() -> Rgba {
        Rgba::RED
    }

    /// Returns a transparent color value.
    pub fn transparent() -> Rgba {
        Rgba::TRANSPARENT
    }

    /// Returns a solid white color value.
    pub fn white() -> Rgba {
        Rgba::WHITE
    }
}

impl Default for Rgba {
    fn default() -> Rgba {
        Rgba::black()
    }
}

impl Component for Rgba {
    type Storage = DenseVecStorage<Self>;
}

impl From<[f32; 3]> for Rgba {
    fn from(arr: [f32; 3]) -> Rgba {
        Rgba(arr[0], arr[1], arr[2], 1.0)
    }
}

impl From<[f32; 4]> for Rgba {
    fn from(arr: [f32; 4]) -> Rgba {
        Rgba(arr[0], arr[1], arr[2], arr[3])
    }
}

impl From<(f32, f32, f32)> for Rgba {
    fn from((r, g, b): (f32, f32, f32)) -> Rgba {
        Rgba(r, g, b, 1.0)
    }
}

impl From<(f32, f32, f32, f32)> for Rgba {
    fn from((r, g, b, a): (f32, f32, f32, f32)) -> Rgba {
        Rgba(r, g, b, a)
    }
}

impl From<Rgba> for [f32; 3] {
    fn from(Rgba(r, g, b, _): Rgba) -> [f32; 3] {
        [r, g, b]
    }
}

impl From<Rgba> for [f32; 4] {
    fn from(Rgba(r, g, b, a): Rgba) -> [f32; 4] {
        [r, g, b, a]
    }
}

impl From<Rgba> for (f32, f32, f32) {
    fn from(Rgba(r, g, b, _): Rgba) -> (f32, f32, f32) {
        (r, g, b)
    }
}

impl From<Rgba> for (f32, f32, f32, f32) {
    fn from(Rgba(r, g, b, a): Rgba) -> (f32, f32, f32, f32) {
        (r, g, b, a)
    }
}

impl Formatted for Rgba {
    fn get_format() -> (BaseType, ContainerType) {
        (BaseType::F32, ContainerType::Vector(4))
    }
}

impl ToUniform for Rgba {
    fn convert(self) -> UniformValue {
        UniformValue::F32Vector4(self.into())
    }
}

impl From<Rgba> for vec3 {
    fn from(Rgba(r, g, b, _): Rgba) -> vec3 {
        [r, g, b].into()
    }
}

impl From<Rgba> for vec4 {
    fn from(Rgba(r, g, b, a): Rgba) -> vec4 {
        [r, g, b, a].into()
    }
}