Struct ColorRGBAOf

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

Fields

r: T

Red

g: T

Green

b: T

Blue

a: T

Alpha

Implementations

impl<T> ColorRGBAOf<T>

pub const R_INDEX: usize = 0usize

Red

pub const G_INDEX: usize = 1usize

Green

pub const B_INDEX: usize = 2usize

Blue

pub const A_INDEX: usize = 3usize

Alpha

pub const fn new(red: T, green: T, blue: T, alpha: T) -> Self

pub const fn rgba(red: T, green: T, blue: T, alpha: T) -> Self

pub const fn rgb(red: T, green: T, blue: T) -> Self

where T: DefaultRange,

pub const fn gray(rgb: T) -> Self

where T: DefaultRange + Copy,

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

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

pub fn rgb_ref(&self) -> &[T; 3]

pub fn rgb_mut(&mut self) -> &mut [T; 3]

pub fn splat_rgba(rgba: T) -> Self

where T: Clone,

pub fn splat_rgb(rgb: T) -> Self

where T: Clone + DefaultRange,

Alpha is at max

pub fn splat_rgb_with_a(rgb: T, a: T) -> Self

where T: Clone,

pub fn r(&self) -> T

where T: Copy,

Red

pub fn with_r(self, r: T) -> Self

where T: Copy,

Red

pub fn set_r(&mut self, r: T) -> &mut Self

Red

pub fn replace_r(self, r: T) -> T

Red

pub fn g(&self) -> T

where T: Copy,

Green

pub fn with_g(self, g: T) -> Self

where T: Copy,

Green

pub fn set_g(&mut self, g: T) -> &mut Self

Green

pub fn replace_g(self, g: T) -> T

Green

pub fn b(&self) -> T

where T: Copy,

Blue

pub fn with_b(self, b: T) -> Self

where T: Copy,

Blue

pub fn set_b(&mut self, b: T) -> &mut Self

Blue

pub fn replace_b(self, b: T) -> T

Blue

pub fn a(&self) -> T

where T: Copy,

Alpha

pub fn with_a(self, a: T) -> Self

where T: Copy,

Alpha

pub fn set_a(&mut self, a: T) -> &mut Self

Alpha

pub fn replace_a(self, a: T) -> T

Alpha

pub fn unpack_rgb(self) -> (T, T, T)

pub fn unpack_rgba(self) -> (T, T, T, T)

Trait Implementations

impl<T> Absolute for ColorRGBAOf<T>

where T: Absolute,

fn abs(self) -> Self

impl<T> Add<T> for ColorRGBAOf<T>

where T: Add<T> + Copy,

type Output = ColorRGBAOf<<T as Add>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add for ColorRGBAOf<T>

where T: Add<T>,

type Output = ColorRGBAOf<<T as Add>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T> AddAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: AddAssign + Copy,

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<T> AddAssign for ColorRGBAOf<T>

where T: AddAssign,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T> ArrayLike<T, 4> for ColorRGBAOf<T>

type WithType<T2> = ColorRGBAOf<T2>

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

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

const DIMENSION: usize = N

fn splat(value: T) -> Self

where T: Clone,

fn map<U, F>(self, f: F) -> Self::WithType<U>

where F: FnMut(T) -> U,

fn map_with<U, T2, F>( self, other: Self::WithType<T2>, f: F, ) -> Self::WithType<U>

where F: FnMut(T, T2) -> U,

fn any<P>(&self, p: P) -> bool

where P: FnMut(&T) -> bool,

True if the predicate is true for at least one component

fn any_with<T2, P>(&self, other: Self::WithType<T2>, p: P) -> bool

where P: FnMut(&T, &T2) -> bool,

True if the predicate is true for at least one component

fn all<P>(&self, p: P) -> bool

where P: FnMut(&T) -> bool,

True if the predicate is true for all component

fn all_with<T2, P>(&self, other: &Self::WithType<T2>, p: P) -> bool

where P: FnMut(&T, &T2) -> bool,

True if the predicate is true for all component

fn for_each<F>(&self, f: F)

where F: FnMut(&T),

fn for_each_mut<F>(&mut self, f: F)

where F: FnMut(&mut T),

fn slice(&self) -> &[T]

fn slice_mut(&mut self) -> &mut [T]

impl<T> AsMut<[T; 4]> for ColorRGBAOf<T>

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

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

impl<T> AsRef<[T; 4]> for ColorRGBAOf<T>

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

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

impl<T> Binary for ColorRGBAOf<T>

where T: Binary,

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

Formats the value using the given formatter.

impl<T> BitAnd<T> for ColorRGBAOf<T>

where T: BitAnd<T> + Copy,

type Output = ColorRGBAOf<<T as BitAnd>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<T> BitAnd for ColorRGBAOf<T>

where T: BitAnd<T>,

type Output = ColorRGBAOf<<T as BitAnd>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T> BitAndAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: BitAndAssign + Copy,

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<T> BitAndAssign for ColorRGBAOf<T>

where T: BitAndAssign,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T> BitOr<T> for ColorRGBAOf<T>

where T: BitOr<T> + Copy,

type Output = ColorRGBAOf<<T as BitOr>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<T> BitOr for ColorRGBAOf<T>

where T: BitOr<T>,

type Output = ColorRGBAOf<<T as BitOr>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T> BitOrAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: BitOrAssign + Copy,

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<T> BitOrAssign for ColorRGBAOf<T>

where T: BitOrAssign,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T> BitXor<T> for ColorRGBAOf<T>

where T: BitXor<T> + Copy,

type Output = ColorRGBAOf<<T as BitXor>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<T> BitXor for ColorRGBAOf<T>

where T: BitXor<T>,

type Output = ColorRGBAOf<<T as BitXor>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T> BitXorAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: BitXorAssign + Copy,

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<T> BitXorAssign for ColorRGBAOf<T>

where T: BitXorAssign,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T, CastToOut> CastIntoComposite<CastToOut> for ColorRGBAOf<T>

where T: CastIntoComposite<CastToOut>,

type Output = ColorRGBAOf<<T as CastIntoComposite<CastToOut>>::Output>

fn cast_into_composite(self) -> Self::Output

Might lose some precision. Same semantics as the as keyword: 4f32 as u64

impl<T> Clone for ColorRGBAOf<T>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ColorRGBAOf<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for ColorRGBAOf<T>

where T: DefaultRange,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for ColorRGBAOf<T>

where [T; 4]: 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> Display for ColorRGBAOf<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T> Div<T> for ColorRGBAOf<T>

where T: Div<T> + Copy,

type Output = ColorRGBAOf<<T as Div>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Div for ColorRGBAOf<T>

where T: Div<T>,

type Output = ColorRGBAOf<<T as Div>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T> DivAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<T> DivAssign for ColorRGBAOf<T>

where T: DivAssign,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T> From<[T; 3]> for ColorRGBAOf<T>

where T: DefaultRange,

fn from(value: [T; 3]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 4]> for ColorRGBAOf<T>

fn from(value: [T; 4]) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T)> for ColorRGBAOf<T>

where T: DefaultRange,

fn from(value: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T)> for ColorRGBAOf<T>

fn from(value: (T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<ColorRGBAOf<T>> for [T; 3]

fn from(value: ColorRGBAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorRGBAOf<T>> for [T; 4]

fn from(value: ColorRGBAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorRGBAOf<T>> for (T, T, T)

fn from(value: ColorRGBAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorRGBAOf<T>> for (T, T, T, T)

fn from(value: ColorRGBAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorRGBAOf<T>> for Vector3<T>

fn from(value: ColorRGBAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorRGBAOf<T>> for Vector4<T>

fn from(value: ColorRGBAOf<T>) -> Self

Converts to this type from the input type.

impl From<ColorRGBAOf<f32>> for ColorHSLA

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<ColorRGBAOf<f32>> for ColorByte

fn from(value: Color) -> Self

Converts to this type from the input type.

impl From<ColorRGBAOf<u8>> for ColorHSLA

fn from(value: ColorRGBAByte) -> Self

Converts to this type from the input type.

impl From<ColorRGBAOf<u8>> for Color

fn from(value: ColorByte) -> Self

Converts to this type from the input type.

impl<T> From<T> for ColorRGBAOf<T>

where T: Copy,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T> From<Vector<T, 3>> for ColorRGBAOf<T>

where T: DefaultRange,

fn from(value: Vector3<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vector<T, 4>> for ColorRGBAOf<T>

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T, Idx> Get<Idx> for ColorRGBAOf<T>

where [T; 4]: Get<Idx>,

type Output = <[T; 4] as Get<Idx>>::Output

fn try_get(&self, index: Idx) -> Result<&Self::Output, ()>

fn get(&self, index: Idx) -> Option<&Self::Output>

unsafe fn get_unchecked(&self, index: Idx) -> &Self::Output

fn get_or_panic(&self, index: Idx) -> &Self::Output

fn is_index_valid(&self, index: Idx) -> bool

True if get(index) return Some, false otherwise.

fn is_index_invalid(&self, index: Idx) -> bool

True if get(index) return None, false otherwise.

impl<T, Idx> GetManyMut<Idx> for ColorRGBAOf<T>

where [T; 4]: GetManyMut<Idx>,

fn try_get_many_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> Result<[&mut Self::Output; N], ()>

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

unsafe fn get_many_unchecked_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> [&mut Self::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> Option<[&mut Self::Output; N]>

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut_or_panic<const N: usize>( &mut self, indices: [Idx; N], ) -> [&mut Self::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn try_swap(&mut self, a: Idx, b: Idx) -> Result<(), ()>

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

fn swap(&mut self, a: Idx, b: Idx) -> bool

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

fn swap_or_panic(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

unsafe fn swap_unchecked(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

impl<T, Idx> GetMut<Idx> for ColorRGBAOf<T>

where [T; 4]: GetMut<Idx>,

fn try_get_mut(&mut self, index: Idx) -> Result<&mut Self::Output, ()>

fn get_mut(&mut self, index: Idx) -> Option<&mut Self::Output>

unsafe fn get_unchecked_mut(&mut self, index: Idx) -> &mut Self::Output

fn get_mut_or_panic(&mut self, idx: Idx) -> &mut Self::Output

fn try_replace( &mut self, index: Idx, value: Self::Output, ) -> Result<Self::Output, ()>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace(&mut self, index: Idx, value: Self::Output) -> Option<Self::Output>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace_or_panic(&mut self, index: Idx, value: Self::Output) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

unsafe fn replace_unchecked( &mut self, index: Idx, value: Self::Output, ) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

fn try_set(&mut self, index: Idx, value: Self::Output) -> Result<(), ()>

where Self::Output: Sized,

Set the value and drop the previous one.

fn set(&mut self, index: Idx, value: Self::Output) -> bool

where Self::Output: Sized,

Set the value and drop the previous one.

fn set_or_panic(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

Set the value and drop the previous one.

unsafe fn set_unchecked(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

impl<T> Half for ColorRGBAOf<T>

where T: Half,

const HALF: Self

fn is_half(self) -> bool

where Self: PartialEq,

fn is_non_half(self) -> bool

where Self: PartialEq,

impl<T> Hash for ColorRGBAOf<T>

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IColor for ColorRGBAOf<T>

where Self: From<Color> + From<ColorByte> + From<ColorHSLA> + ToFloat<Output = ColorRGBAOf<float>>, T: ToCoef<Output = Coef> + FromCoef + ToFloat<Output = float> + DefaultRange + Copy + PartialEq + Default,

const TRANSPARENT: Self

const BLACK: Self

const GRAY: Self

const WHITE: Self

const RED: Self

const GREEN: Self

const BLUE: Self

const CYAN: Self

const PINK: Self

const YELLOW: Self

fn rgba_from_bytes(r: u8, g: u8, b: u8, a: u8) -> Self

fn rgba_from_bytes_slice(rgba: &[u8]) -> Self

fn from_rgb_hex(hex: u32) -> Self

fn from_rgba_hex(hex: u32) -> Self

fn to_rgba_hex(self) -> u32

Cast to color byte and convert to u32 using : #RRGGBBAA

fn to_rgba_hex_string(self) -> String

Cast to color byte and format the color : #RRGGBBAA

impl<T, Idx> Index<Idx> for ColorRGBAOf<T>

where [T; 4]: Index<Idx>,

type Output = <[T; 4] as Index<Idx>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, Idx> IndexMut<Idx> for ColorRGBAOf<T>

where [T; 4]: IndexMut<Idx>,

fn index_mut(&mut self, index: Idx) -> &mut Self::Output

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

impl<'a, T> IntoIterator for &'a ColorRGBAOf<T>

where &'a [T; 4]: IntoIterator,

type Item = <&'a [T; 4] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a [T; 4] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut ColorRGBAOf<T>

where &'a mut [T; 4]: IntoIterator,

type Item = <&'a mut [T; 4] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a mut [T; 4] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for ColorRGBAOf<T>

where [T; 4]: IntoIterator,

type Item = <[T; 4] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <[T; 4] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> LowerExp for ColorRGBAOf<T>

where T: LowerExp,

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

Formats the value using the given formatter.

impl<T> LowerHex for ColorRGBAOf<T>

where T: LowerHex,

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

Formats the value using the given formatter.

impl<T> MaxValue for ColorRGBAOf<T>

where T: MaxValue,

const MAX: Self

fn is_max_value(&self) -> bool

where Self: PartialEq,

fn is_non_max_value(&self) -> bool

where Self: PartialEq,

impl<T> MinValue for ColorRGBAOf<T>

where T: MinValue,

const MIN: Self

fn is_min_value(&self) -> bool

where Self: PartialEq,

fn is_not_min_value(&self) -> bool

where Self: PartialEq,

impl<T> Mul<T> for ColorRGBAOf<T>

where T: Mul<T> + Copy,

type Output = ColorRGBAOf<<T as Mul>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul for ColorRGBAOf<T>

where T: Mul<T>,

type Output = ColorRGBAOf<<T as Mul>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> MulAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<T> MulAssign for ColorRGBAOf<T>

where T: MulAssign,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T> NaNValue for ColorRGBAOf<T>

where T: NaNValue,

const NAN: Self

fn is_nan(&self) -> bool

where Self: PartialEq,

fn is_not_nan(&self) -> bool

where Self: PartialEq,

impl<T> Neg for ColorRGBAOf<T>

where T: Neg,

type Output = ColorRGBAOf<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Not for ColorRGBAOf<T>

where T: Not,

type Output = ColorRGBAOf<<T as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Octal for ColorRGBAOf<T>

where T: Octal,

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

Formats the value using the given formatter.

impl<T> One for ColorRGBAOf<T>

where T: One,

const ONE: Self

The neutral element of the multiplication such that x * X::ONE = x

fn one() -> Self

where Self: Sized,

fn set_one(&mut self) -> &mut Self

fn is_one(&self) -> bool

where Self: PartialEq,

fn is_non_one(&self) -> bool

where Self: PartialEq,

impl<T> Ord for ColorRGBAOf<T>

where T: Ord,

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for ColorRGBAOf<T>

where T: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

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

impl<T> PartialOrd for ColorRGBAOf<T>

where T: PartialOrd,

fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Pointer for ColorRGBAOf<T>

where T: Pointer,

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

Formats the value using the given formatter.

impl<T> PrefixBillion for ColorRGBAOf<T>

where T: PrefixBillion,

const BILLION: Self

10^9 = 1_000_000_000

fn billion(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^9 = 1_000_000_000

impl<T> PrefixCenti for ColorRGBAOf<T>

where T: PrefixCenti,

const CENTI: Self

10^-2 = 1/100

fn centi(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-2 = 1/100

impl<T> PrefixDeca for ColorRGBAOf<T>

where T: PrefixDeca,

const DECA: Self

10^1 = 10

fn deca(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^1 = 10

impl<T> PrefixDecade for ColorRGBAOf<T>

where T: PrefixDecade,

const DECADE: Self

10^1 = 10

fn decade(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^1 = 10

impl<T> PrefixDeci for ColorRGBAOf<T>

where T: PrefixDeci,

const DECI: Self

10^-1 = 1/10

fn deci(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-1 = 1/10

impl<T> PrefixFemto for ColorRGBAOf<T>

where T: PrefixFemto,

const FEMTO: Self

10^-15 = 1/1_000_000_000_000_000

fn femto(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-15 = 1/1_000_000_000_000_000

impl<T> PrefixGiga for ColorRGBAOf<T>

where T: PrefixGiga,

const GIGA: Self

10^9 = 1_000_000_000

fn giga(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^9 = 1_000_000_000

impl<T> PrefixHecto for ColorRGBAOf<T>

where T: PrefixHecto,

const HECTO: Self

10^2 = 100

fn hecto(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^2 = 100

impl<T> PrefixHundred for ColorRGBAOf<T>

where T: PrefixHundred,

const HUNDRED: Self

10^2 = 100

fn hundred(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^2 = 100

impl<T> PrefixKilo for ColorRGBAOf<T>

where T: PrefixKilo,

const KILO: Self

10^3 = 1_000

fn kilo(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^3 = 1_000

impl<T> PrefixMega for ColorRGBAOf<T>

where T: PrefixMega,

const MEGA: Self

10^6 = 1_000_000

fn mega(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^6 = 1_000_000

impl<T> PrefixMicro for ColorRGBAOf<T>

where T: PrefixMicro,

const MICRO: Self

10^-6 = 1/1_000_000

fn micro(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-6 = 1/1_000_000

impl<T> PrefixMilli for ColorRGBAOf<T>

where T: PrefixMilli,

const MILLI: Self

10^-3 = 1/1_000

fn milli(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-3 = 1/1_000

impl<T> PrefixMillion for ColorRGBAOf<T>

where T: PrefixMillion,

const MILLION: Self

10^6 = 1_000_000

fn million(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^6 = 1_000_000

impl<T> PrefixNano for ColorRGBAOf<T>

where T: PrefixNano,

const NANO: Self

10^-9 = 1/1_000_000_000

fn nano(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-9 = 1/1_000_000_000

impl<T> PrefixPeta for ColorRGBAOf<T>

where T: PrefixPeta,

const PETA: Self

10^15 = 1_000_000_000_000_000

fn peta(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^15 = 1_000_000_000_000_000

impl<T> PrefixPico for ColorRGBAOf<T>

where T: PrefixPico,

const PICO: Self

10^-12 = 1/1_000_000_000_000

fn pico(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^-12 = 1/1_000_000_000_000

impl<T> PrefixQuadrillion for ColorRGBAOf<T>

where T: PrefixQuadrillion,

const QUADRILLION: Self

10^15 = 1_000_000_000_000_000

fn quadrillion(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^15 = 1_000_000_000_000_000

impl<T> PrefixTera for ColorRGBAOf<T>

where T: PrefixTera,

const TERA: Self

10^12 = 1_000_000_000_000

fn tera(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^12 = 1_000_000_000_000

impl<T> PrefixThousand for ColorRGBAOf<T>

where T: PrefixThousand,

const THOUSAND: Self

10^3 = 1_000

fn thousand(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^3 = 1_000

impl<T> PrefixTrillion for ColorRGBAOf<T>

where T: PrefixTrillion,

const TRILLION: Self

10^12 = 1_000_000_000_000

fn trillion(self) -> Self

where Self: Mul<Self, Output = Self>,

multiply by 10^12 = 1_000_000_000_000

impl<T> Product for ColorRGBAOf<T>

where Self: One + Mul<Self, Output = Self>,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T> Rem<T> for ColorRGBAOf<T>

where T: Rem<T> + Copy,

type Output = ColorRGBAOf<<T as Rem>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T> Rem for ColorRGBAOf<T>

where T: Rem<T>,

type Output = ColorRGBAOf<<T as Rem>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T> RemAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: RemAssign + Copy,

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<T> RemAssign for ColorRGBAOf<T>

where T: RemAssign,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T> Serialize for ColorRGBAOf<T>

where [T; 4]: 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> Shl<T> for ColorRGBAOf<T>

where T: Shl<T> + Copy,

type Output = ColorRGBAOf<<T as Shl>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<T> Shl for ColorRGBAOf<T>

where T: Shl<T>,

type Output = ColorRGBAOf<<T as Shl>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<T> ShlAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: ShlAssign + Copy,

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<T> ShlAssign for ColorRGBAOf<T>

where T: ShlAssign,

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<T> Shr<T> for ColorRGBAOf<T>

where T: Shr<T> + Copy,

type Output = ColorRGBAOf<<T as Shr>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<T> Shr for ColorRGBAOf<T>

where T: Shr<T>,

type Output = ColorRGBAOf<<T as Shr>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<T> ShrAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: ShrAssign + Copy,

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<T> ShrAssign for ColorRGBAOf<T>

where T: ShrAssign,

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<T> Sub<T> for ColorRGBAOf<T>

where T: Sub<T> + Copy,

type Output = ColorRGBAOf<<T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub for ColorRGBAOf<T>

where T: Sub<T>,

type Output = ColorRGBAOf<<T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T> SubAssign<&ColorRGBAOf<T>> for ColorRGBAOf<T>

where T: SubAssign + Copy,

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<T> SubAssign for ColorRGBAOf<T>

where T: SubAssign,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T> Sum for ColorRGBAOf<T>

where Self: Zero + Add<Self, Output = Self>,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> ToAngle for ColorRGBAOf<T>

where T: ToAngle,

type Output = ColorRGBAOf<<T as ToAngle>::Output>

fn degree(self) -> Self::Output

fn radian(self) -> Self::Output

fn turn(self) -> Self::Output

impl<T> ToColorRep for ColorRGBAOf<T>

where Self: From<Color> + From<ColorByte> + From<ColorHSLA> + ToFloat<Output = ColorRGBAOf<float>>, T: ToCoef<Output = Coef> + FromCoef + ToFloat<Output = float> + DefaultRange + Copy + PartialEq + Default,

type ColorRGBA = ColorRGBAOf<f32>

type ColorHSLA = ColorHSLAOf<f32>

type ColorRGBAByte = ColorRGBAOf<u8>

fn to_rgba_coef(&self) -> Self::ColorRGBA

fn to_hsla(&self) -> Self::ColorHSLA

fn to_rgba_u8(&self) -> Self::ColorRGBAByte

fn to_color(&self) -> Self::ColorRGBA

impl<T> ToSigned for ColorRGBAOf<T>

where T: ToSigned,

type Output = ColorRGBAOf<<T as ToSigned>::Output>

The signed equivalence

fn to_signed(self) -> Self::Output

impl<T> ToTime for ColorRGBAOf<T>

where T: ToTime,

type Output = ColorRGBAOf<<T as ToTime>::Output>

fn ms(self) -> Self::Output

fn s(self) -> Self::Output

fn mins(self) -> Self::Output

With an s to avoid the confusion with the min function

fn hour(self) -> Self::Output

fn day(self) -> Self::Output

impl<T> ToUnsigned for ColorRGBAOf<T>

where T: ToUnsigned,

type Output = ColorRGBAOf<<T as ToUnsigned>::Output>

The unsigned equivalence

fn to_unsigned(self) -> Self::Output

impl<T> UpperExp for ColorRGBAOf<T>

where T: UpperExp,

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

Formats the value using the given formatter.

impl<T> UpperHex for ColorRGBAOf<T>

where T: UpperHex,

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

Formats the value using the given formatter.

impl<T> Zero for ColorRGBAOf<T>

where T: Zero,

const ZERO: Self

The absorbing element of the multiplication such that x * X::ZERO = X::ZERO

fn zero() -> Self

fn set_zero(&mut self) -> &mut Self

fn is_zero(&self) -> bool

where Self: PartialEq,

fn is_non_zero(&self) -> bool

where Self: PartialEq,

impl<T> Copy for ColorRGBAOf<T>

where T: Copy,

impl<T> Eq for ColorRGBAOf<T>

where T: Eq,