Struct color::AlphaColor

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

Fields

c: C

a: T

Implementations

impl<T, C> AlphaColor<T, C>

pub const fn new(c: C, a: T) -> AlphaColor<T, C>

impl<T: Channel, S: TransferFunction> AlphaColor<T, Rgb<T, S>>

pub fn from_hex(hex: u32) -> Rgba<T, S>

pub fn rg(&self) -> Rg<T, S>

pub fn rb(&self) -> Rg<T, S>

pub fn gr(&self) -> Rg<T, S>

pub fn gb(&self) -> Rg<T, S>

pub fn br(&self) -> Rg<T, S>

pub fn bg(&self) -> Rg<T, S>

pub fn ar(&self) -> Rg<T, S>

pub fn ag(&self) -> Rg<T, S>

pub fn ab(&self) -> Rg<T, S>

pub fn ra(&self) -> Rg<T, S>

pub fn ga(&self) -> Rg<T, S>

pub fn ba(&self) -> Rg<T, S>

pub fn rgb(&self) -> Rgb<T, S>

pub fn rbg(&self) -> Rgb<T, S>

pub fn bgr(&self) -> Rgb<T, S>

pub fn brg(&self) -> Rgb<T, S>

pub fn grb(&self) -> Rgb<T, S>

pub fn gbr(&self) -> Rgb<T, S>

pub fn rga(&self) -> Rgb<T, S>

pub fn rba(&self) -> Rgb<T, S>

pub fn bra(&self) -> Rgb<T, S>

pub fn bga(&self) -> Rgb<T, S>

pub fn gra(&self) -> Rgb<T, S>

pub fn gba(&self) -> Rgb<T, S>

pub fn arg(&self) -> Rgb<T, S>

pub fn arb(&self) -> Rgb<T, S>

pub fn agr(&self) -> Rgb<T, S>

pub fn agb(&self) -> Rgb<T, S>

pub fn abr(&self) -> Rgb<T, S>

pub fn abg(&self) -> Rgb<T, S>

pub fn rag(&self) -> Rgb<T, S>

pub fn rab(&self) -> Rgb<T, S>

pub fn gar(&self) -> Rgb<T, S>

pub fn gab(&self) -> Rgb<T, S>

pub fn bar(&self) -> Rgb<T, S>

pub fn bag(&self) -> Rgb<T, S>

pub fn rgba(&self) -> Rgba<T, S>

pub fn rbga(&self) -> Rgba<T, S>

pub fn grba(&self) -> Rgba<T, S>

pub fn gbra(&self) -> Rgba<T, S>

pub fn brga(&self) -> Rgba<T, S>

pub fn bgra(&self) -> Rgba<T, S>

pub fn argb(&self) -> Rgba<T, S>

pub fn arbg(&self) -> Rgba<T, S>

pub fn agrb(&self) -> Rgba<T, S>

pub fn agbr(&self) -> Rgba<T, S>

pub fn abrg(&self) -> Rgba<T, S>

pub fn abgr(&self) -> Rgba<T, S>

pub fn ragb(&self) -> Rgba<T, S>

pub fn rabg(&self) -> Rgba<T, S>

pub fn garb(&self) -> Rgba<T, S>

pub fn gabr(&self) -> Rgba<T, S>

pub fn barg(&self) -> Rgba<T, S>

pub fn bagr(&self) -> Rgba<T, S>

pub fn rgab(&self) -> Rgba<T, S>

pub fn rbag(&self) -> Rgba<T, S>

pub fn grab(&self) -> Rgba<T, S>

pub fn gbar(&self) -> Rgba<T, S>

pub fn brag(&self) -> Rgba<T, S>

pub fn bgar(&self) -> Rgba<T, S>

impl<T: Channel, S: TransferFunction> AlphaColor<T, Rgb<T, S>>

pub fn to_standard<S2: TransferFunction>(&self) -> Rgba<T, S2>

pub fn to_linear(&self) -> Rgba<T, LinearRgb>

Trait Implementations

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, C: AsMut<[T; 3]>> AsMut<[T; 4]> for AlphaColor<T, C>

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

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

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: 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: Debug, C: Debug> Debug for AlphaColor<T, C>

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

Formats the value using the given formatter.

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.

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, 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, 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: 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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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<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, C: ToLuma> ToLuma for AlphaColor<T, C>

type Standard = <C as ToLuma>::Standard

fn to_luma<U: Channel>(&self) -> Luma<U, Self::Standard>

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

type Standard = <C as ToRgb>::Standard

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

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

type Standard = <C as ToRgb>::Standard

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

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

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

impl<T, C> StructuralEq for AlphaColor<T, C>

impl<T, C> StructuralPartialEq for AlphaColor<T, C>