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

//! Color value types.

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

/// An RGBA color value.
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize)]
pub struct Rgba(pub f32, pub f32, pub f32, pub f32);

impl Rgba {
    /// Returns a solid black color value.
    pub fn black() -> Rgba {
        Rgba(0.0, 0.0, 0.0, 1.0)
    }

    /// Returns a solid blue color value.
    pub fn blue() -> Rgba {
        Rgba(0.0, 0.0, 1.0, 1.0)
    }

    /// Returns a solid green color value.
    pub fn green() -> Rgba {
        Rgba(0.0, 1.0, 0.0, 1.0)
    }

    /// Returns a solid red color value.
    pub fn red() -> Rgba {
        Rgba(1.0, 0.0, 0.0, 1.0)
    }

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

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

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

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()
    }
}