Struct color::AlphaColor

pub struct AlphaColor<T, C> {
    pub c: C,
    pub a: T,
}

Fields

c: C

a: T

Trait Implementations

impl<T, C: ToRgb> ToRgb for AlphaColor<T, C>

fn to_rgb<U: Channel>(&self) -> Rgb<U>

impl<T: Channel, C: ToRgb> ToRgba for AlphaColor<T, C>

fn to_rgba<U: Channel>(&self) -> Rgba<U>

impl<T: Channel, C: Color<T>> Color<T> for AlphaColor<T, C>

fn clamp_s(self, lo: T, hi: T) -> AlphaColor<T, C>

Clamps the components of the color to the range (lo,hi).

fn clamp_c(self, lo: AlphaColor<T, C>, hi: AlphaColor<T, C>) -> AlphaColor<T, C>

Clamps the components of the color component-wise between lo and hi.

fn inverse(self) -> AlphaColor<T, C>

Inverts the color.

fn mix(self, other: Self, value: T) -> Self

impl<T: Clone, C: Clone> Clone for AlphaColor<T, C>

fn clone(&self) -> AlphaColor<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, C: AsMut<[T; 3]>> AsMut<[T; 4]> for AlphaColor<T, C>

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

Performs the conversion.

impl<T, C: AsRef<[T; 3]>> AsRef<[T; 4]> for AlphaColor<T, C>

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

Performs the conversion.

impl<T: PartialEq, C: PartialEq> PartialEq<AlphaColor<T, C>> for AlphaColor<T, C>

fn eq(&self, other: &AlphaColor<T, C>) -> bool

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

fn ne(&self, other: &AlphaColor<T, C>) -> bool

This method tests for !=.

impl<T: Copy, C: Copy> Copy for AlphaColor<T, C>

impl<T: Eq, C: Eq> Eq for AlphaColor<T, C>

impl<T: Debug, C: Debug> Debug for AlphaColor<T, C>

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

Formats the value using the given formatter.

impl<T: Channel + Sub<T, Output = T>, C: Sub<Output = C>> Sub<AlphaColor<T, C>> for AlphaColor<T, C>

type Output = AlphaColor<T, C>

The resulting type after applying the - operator.

fn sub(self, rhs: AlphaColor<T, C>) -> AlphaColor<T, C>

Performs the - operation.

impl<T: Channel, C: Div<Output = C>> Div<AlphaColor<T, C>> for AlphaColor<T, C>

type Output = AlphaColor<T, C>

The resulting type after applying the / operator.

fn div(self, rhs: AlphaColor<T, C>) -> AlphaColor<T, C>

Performs the / operation.

impl<T: Channel + Div<T, Output = T>, C: Div<T, Output = C>> Div<T> for AlphaColor<T, C>

type Output = AlphaColor<T, C>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> AlphaColor<T, C>

Performs the / operation.

impl<T: Channel + Add<T, Output = T>, C: Add<Output = C>> Add<AlphaColor<T, C>> for AlphaColor<T, C>

type Output = AlphaColor<T, C>

The resulting type after applying the + operator.

fn add(self, rhs: AlphaColor<T, C>) -> AlphaColor<T, C>

Performs the + operation.

impl<T: Channel, C: Mul<Output = C>> Mul<AlphaColor<T, C>> for AlphaColor<T, C>

type Output = AlphaColor<T, C>

The resulting type after applying the * operator.

fn mul(self, rhs: AlphaColor<T, C>) -> AlphaColor<T, C>

Performs the * operation.

impl<T: Channel + Mul<T, Output = T>, C: Mul<T, Output = C>> Mul<T> for AlphaColor<T, C>

type Output = AlphaColor<T, C>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> AlphaColor<T, C>

Performs the * operation.

impl<T, C: AsRef<[T; 3]>> Index<usize> for AlphaColor<T, C>

type Output = T

The returned type after indexing.

fn index<'a>(&'a self, index: usize) -> &'a T

Performs the indexing (container[index]) operation.

impl<T, C: AsRef<[T; 3]> + AsMut<[T; 3]>> IndexMut<usize> for AlphaColor<T, C>

fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut T

Performs the mutable indexing (container[index]) operation.

impl<T: Channel + Saturating, C: Saturating> Saturating for AlphaColor<T, C>

fn saturating_add(self, v: AlphaColor<T, C>) -> AlphaColor<T, C>

Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, v: AlphaColor<T, C>) -> AlphaColor<T, C>

Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing.

impl<T, C> Serialize for AlphaColor<T, C> where
    T: Serialize,
    C: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<'de, T, C> Deserialize<'de> for AlphaColor<T, C> where
    T: Deserialize<'de>,
    C: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.