Struct batbox::Color

#[repr(C)]pub struct Color<T> {
    pub r: T,
    pub g: T,
    pub b: T,
    pub a: T,
}

Fields

r: T

g: T

b: T

a: T

Implementations

impl<T: ColorComponent> Color<T>

pub const WHITE: Self

pub const BLACK: Self

pub const GRAY: Self

pub const TRANSPARENT_WHITE: Self

pub const TRANSPARENT_BLACK: Self

pub const RED: Self

pub const GREEN: Self

pub const BLUE: Self

pub const CYAN: Self

pub const MAGENTA: Self

pub const YELLOW: Self

impl<T: ColorComponent> Color<T>

pub fn rgb(r: T, g: T, b: T) -> Self

pub fn rgba(r: T, g: T, b: T, a: T) -> Self

pub fn convert<U: ColorComponent>(self) -> Color<U>

Trait Implementations

impl<T: ColorComponent + ApproxEq> ApproxEq for Color<T>

fn approx_distance_to(&self, other: &Self) -> f32

fn approx_eq(&self, other: &Self) -> bool

fn approx_eq_eps(&self, other: &Self, eps: f32) -> bool

impl<T: Clone> Clone for Color<T>

fn clone(&self) -> Color<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy> Copy for Color<T>

impl<T: Debug> Debug for Color<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: ColorComponent> Deref for Color<T>

type Target = [T; 4]

The resulting type after dereferencing.

fn deref(&self) -> &[T; 4]

Dereferences the value.

impl<T: ColorComponent> DerefMut for Color<T>

fn deref_mut(&mut self) -> &mut [T; 4]

Mutably dereferences the value.

impl<'de, T> Deserialize<'de> for Color<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: ColorComponent> Display for Color<T>

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: ColorComponent + Eq> Eq for Color<T>

impl<T: ColorComponent + Eq> PartialEq<Color<T>> for Color<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Schematic for Color<T> where
    T: Schematic + 'static,
    T: Schematic + 'static,
    T: Schematic + 'static,
    T: Schematic + 'static,
    T: Schematic, 

fn create_schema() -> Schema

impl<T> Serialize for Color<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> Trans for Color<T> where
    T: Trans,
    T: Trans,
    T: Trans,
    T: Trans, 

fn write_to(&self, writer: &mut dyn Write) -> Result<()>

fn read_from(reader: &mut dyn Read) -> Result<Self>