Struct prisma::Alpha

#[repr(C)]pub struct Alpha<T, InnerColor> { /* fields omitted */ }

A wrapper around a color with an alpha channel

Alpha<T> makes it easy to add an alpha channel to any other color and share code between all color types. Alpha<T> implements Deref and DerefMut, making it able to act like the underlying color in many situations.

Implementations

impl<T, InnerColor> Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color, 

pub fn new(color: InnerColor, alpha: T) -> Self

Construct an Alpha object from a color and an alpha value

pub fn decompose(self) -> (InnerColor, T)

Break apart an Alpha into the inner color and alpha channel value

pub fn color(&self) -> &InnerColor

Returns a reference to the inner color

pub fn alpha(&self) -> T

Returns the alpha scalar

pub fn color_mut(&mut self) -> &mut InnerColor

Returns a mutable reference to the inner color

pub fn alpha_mut(&mut self) -> &mut T

Returns a mutable reference to the alpha scalar

pub fn set_color(&mut self, color: InnerColor)

Set the inner color

pub fn set_alpha(&mut self, alpha: T)

Set the alpha channel value

Trait Implementations

impl<T, InnerColor> AbsDiffEq<Alpha<T, InnerColor>> for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + AbsDiffEq<Epsilon = InnerColor::Epsilon>,
    InnerColor: Color + AbsDiffEq,
    InnerColor::Epsilon: Clone + Float, 

type Epsilon = T::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<T, InnerColor> Bounded for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + Bounded, 

fn normalize(self) -> Self

Return a value clipped inside the normalized range

fn is_normalized(&self) -> bool

Return true if the value is normalized

impl<T, InnerColor> Broadcast for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + HomogeneousColor<ChannelFormat = T> + Broadcast, 

fn broadcast(value: T) -> Self

Construct Self with each channel set to value

impl<T: Clone, InnerColor: Clone> Clone for Alpha<T, InnerColor>

fn clone(&self) -> Alpha<T, InnerColor>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, InnerColor> Color for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color, 

type Tag = AlphaTag<InnerColor::Tag>

The unique tag unit struct identifying the color type

type ChannelsTuple = (InnerColor::ChannelsTuple, T)

A tuple of types for each channel in the color

fn num_channels() -> u32

Return how many channels the color has

fn to_tuple(self) -> Self::ChannelsTuple

Convert a color into a tuple of channels

impl<T, InnerColor> Color4 for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color3, 

impl<T> ConvertFromXyz<T, Alpha<T, Xyz<T>>> for SRgb<T> where
    T: Float + FreeChannelScalar + PosNormalChannelScalar + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>, 

type OutputColor = Rgba<T>

The color type converted to.

fn convert_from_xyz_raw(&self, color: &Xyza<T>) -> Rgba<T>

Convert color out of the XYZ space, returning a bare color without any wrappers

fn convert_from_xyz(
    &self,
    color: &In
) -> SpacedColor<T, Self::OutputColor, Self::Encoding, Self>

Convert color out of the XYZ space, using the color space's preferred encoding

fn convert_from_xyz_linear(
    &self,
    color: &In
) -> SpacedColor<T, Self::OutputColor, LinearEncoding, Self>

Convert color out of the XYZ space, using a linear encoding

impl<T, E> ConvertToXyz<T, Alpha<T, Rgb<T>>, E> for SRgb<T> where
    T: Float + FreeChannelScalar + PosNormalChannelScalar + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding, 

type OutputColor = Xyza<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(&self, color: &EncodedColor<Rgba<T>, E>) -> Self::OutputColor

Convert color into the XYZ space

impl<T, E, EIn> ConvertToXyz<T, Alpha<T, Rgb<T>>, EIn> for EncodedColorSpace<T, E> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyza<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(
    &self,
    color: &EncodedColor<Rgba<T>, EIn>
) -> Self::OutputColor

Convert color into the XYZ space

impl<'a, T, E, EIn> ConvertToXyz<T, Alpha<T, Rgb<T>>, EIn> for &'a EncodedColorSpace<T, E> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyza<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(
    &self,
    color: &EncodedColor<Rgba<T>, EIn>
) -> Self::OutputColor

Convert color into the XYZ space

impl<T, E, EIn> ConvertToXyz<T, Alpha<T, Rgb<T>>, EIn> for Rc<EncodedColorSpace<T, E>> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyza<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(
    &self,
    color: &EncodedColor<Rgba<T>, EIn>
) -> Self::OutputColor

Convert color into the XYZ space

impl<T, E, EIn> ConvertToXyz<T, Alpha<T, Rgb<T>>, EIn> for Arc<EncodedColorSpace<T, E>> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyza<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(
    &self,
    color: &EncodedColor<Rgba<T>, EIn>
) -> Self::OutputColor

Convert color into the XYZ space

impl<T: Copy, InnerColor: Copy> Copy for Alpha<T, InnerColor>

impl<T: Debug, InnerColor: Debug> Debug for Alpha<T, InnerColor>

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

Formats the value using the given formatter.

impl<T, InnerColor> Default for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + Default + Zero,
    InnerColor: Color + Default + Zero, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, InnerColor> Deref for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color, 

type Target = InnerColor

The resulting type after dereferencing.

fn deref(&self) -> &InnerColor

Dereferences the value.

impl<T, InnerColor> DerefMut for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color, 

fn deref_mut(&mut self) -> &mut InnerColor

Mutably dereferences the value.

impl<T, InnerColor> Display for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + Display,
    InnerColor: Color + Display, 

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

Formats the value using the given formatter.

impl<T, InnerColor> EncodableColor for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: EncodableColor, 

fn encoded_as<E>(self, encoding: E) -> EncodedColor<Self, E> where
    E: ColorEncoding, 

Specify what encoding the color has. This does not actually encode anything

fn linear(self) -> EncodedColor<Self, LinearEncoding>

Specify that the color is linear

fn srgb_encoded(self) -> EncodedColor<Self, SrgbEncoding>

Specify that the color is sRGB encoded

fn gamma_encoded<T: Float>(
    self,
    gamma: T
) -> EncodedColor<Self, GammaEncoding<T>>

Specify that the color is gamma encoded with a given gamma

impl<T: Eq, InnerColor: Eq> Eq for Alpha<T, InnerColor>

impl<T, InnerColor> Flatten for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + Flatten + HomogeneousColor<ChannelFormat = T>, 

fn as_slice(&self) -> &[Self::ChannelFormat]

Return a slice representation of Self

fn from_slice(values: &[T]) -> Self

Return Self constructed from values

impl<T, InnerColor, InnerColor2> FromColor<Alpha<T, InnerColor2>> for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + FromColor<InnerColor2>,
    InnerColor2: Color, 

fn from_color(from: &Alpha<T, InnerColor2>) -> Self

Construct Self from from

impl<T, InnerColor, A> FromHsi<Alpha<T, Hsi<T, A>>> for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + FromHsi<Hsi<T, A>>,
    A: AngularChannelScalar + Angle, 

fn from_hsi(
    from: &Alpha<T, Hsi<T, A>>,
    out_of_gamut_mode: HsiOutOfGamutMode
) -> Self

Construct Self from from, describing what to do if the color is out of gamut for Self

impl<T, InnerColor> FromTuple for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + FromTuple, 

fn from_tuple(values: Self::ChannelsTuple) -> Self

Construct Self from a tuple of channel values

impl<T, InnerColor, M> FromYCbCr<Alpha<T, YCbCr<T, M>>> for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + NormalChannelScalar,
    InnerColor: Color + FromYCbCr<YCbCr<T, M>>,
    M: YCbCrModel<T>, 

fn from_ycbcr(
    from: &Alpha<T, YCbCr<T, M>>,
    out_of_gamut_mode: YCbCrOutOfGamutMode
) -> Self

Construct Self from from, describing what to do if the color is out of gamut for Self

impl<T: Hash, InnerColor: Hash> Hash for Alpha<T, InnerColor>

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<T, InnerColor> HomogeneousColor for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + HomogeneousColor<ChannelFormat = T>, 

type ChannelFormat = T

The scalar type of each channel

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

Clamp the value of each channel between min and max

impl<T, InnerColor> Invert for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + Invert, 

fn invert(self) -> Self

Invert Self

impl<T, InnerColor> Lerp for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + Lerp<Position = InnerColor::Position>,
    InnerColor: Color + Lerp, 

type Position = InnerColor::Position

The type of the pos argument

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Interpolate between self and right

impl<T: Ord, InnerColor: Ord> Ord for Alpha<T, InnerColor>

fn cmp(&self, other: &Alpha<T, InnerColor>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: PartialEq, InnerColor: PartialEq> PartialEq<Alpha<T, InnerColor>> for Alpha<T, InnerColor>

fn eq(&self, other: &Alpha<T, InnerColor>) -> bool

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

fn ne(&self, other: &Alpha<T, InnerColor>) -> bool

This method tests for !=.

impl<T: PartialOrd, InnerColor: PartialOrd> PartialOrd<Alpha<T, InnerColor>> for Alpha<T, InnerColor>

fn partial_cmp(&self, other: &Alpha<T, InnerColor>) -> Option<Ordering>

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

fn lt(&self, other: &Alpha<T, InnerColor>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Alpha<T, InnerColor>) -> bool

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

fn gt(&self, other: &Alpha<T, InnerColor>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Alpha<T, InnerColor>) -> bool

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

impl<T, InnerColor> PolarColor for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar,
    InnerColor: Color + PolarColor<Cartesian = T>, 

type Angular = InnerColor::Angular

The angular channel's scalar type

type Cartesian = InnerColor::Cartesian

The remaining channels' scalar types

impl<T, InnerColor> RelativeEq<Alpha<T, InnerColor>> for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + RelativeEq<Epsilon = InnerColor::Epsilon>,
    InnerColor: Color + RelativeEq,
    InnerColor::Epsilon: Clone + Float, 

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<T, InnerColor> StructuralEq for Alpha<T, InnerColor>

impl<T, InnerColor> StructuralPartialEq for Alpha<T, InnerColor>

impl<T, InnerColor> UlpsEq<Alpha<T, InnerColor>> for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + UlpsEq<Epsilon = InnerColor::Epsilon>,
    InnerColor: Color + UlpsEq,
    InnerColor::Epsilon: Clone + Float, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.