pub type Hsla<S = Srgb, T = f32> = Alpha<Hsl<S, T>, T>;
Expand description
Linear HSL with an alpha component. See the Hsla
implementation in
Alpha
.
Aliased Type§
struct Hsla<S = Srgb, T = f32> {
pub color: Hsl<S, T>,
pub alpha: T,
}
Fields§
§color: Hsl<S, T>
The color.
alpha: T
The transparency component. 0.0 (or 0u8) is fully transparent and 1.0 (or 255u8) is fully opaque.
Implementations
source§impl<C> Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
impl<C> Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
sourcepub fn premultiply(self) -> PreAlpha<C>
pub fn premultiply(self) -> PreAlpha<C>
Alpha mask the color by its transparency.
source§impl<C, A> Alpha<C, A>
impl<C, A> Alpha<C, A>
sourcepub fn iter<'a>(&'a self) -> <&'a Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a Alpha<C, A>: IntoIterator,
pub fn iter<'a>(&'a self) -> <&'a Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a Alpha<C, A>: IntoIterator,
Return an iterator over the colors in the wrapped collections.
sourcepub fn iter_mut<'a>(
&'a mut self,
) -> <&'a mut Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a mut Alpha<C, A>: IntoIterator,
pub fn iter_mut<'a>(
&'a mut self,
) -> <&'a mut Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a mut Alpha<C, A>: IntoIterator,
Return an iterator that allows modifying the colors in the wrapped collections.
source§impl<S, T, A> Alpha<Hsl<S, &mut T>, &mut A>
impl<S, T, A> Alpha<Hsl<S, &mut T>, &mut A>
source§impl<S, Ct, Ca> Alpha<Hsl<S, Ct>, Ca>
impl<S, Ct, Ca> Alpha<Hsl<S, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Hsl<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsl<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, with references to the components at index
. See slice::get
for details.
sourcepub fn get_mut<'a, I, T, A>(
&'a mut self,
index: I,
) -> Option<Alpha<Hsl<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsl<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<S, T, A> Alpha<Hsl<S, T>, A>
impl<S, T, A> Alpha<Hsl<S, T>, A>
Hsla
implementations.
sourcepub fn new<H>(
hue: H,
saturation: T,
lightness: T,
alpha: A,
) -> Alpha<Hsl<S, T>, A>
pub fn new<H>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<S, T>, A>
Create an HSL color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
saturation: T,
lightness: T,
alpha: A,
) -> Alpha<Hsl<S, T>, A>
pub const fn new_const( hue: RgbHue<T>, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<S, T>, A>
Create an HSL color with transparency. This is the same as Hsla::new
without the generic hue type. It’s temporary until const fn
supports
traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Hsl<S, U>, B>
pub fn into_format<U, B>(self) -> Alpha<Hsl<S, U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Hsl<S, U>, B>) -> Alpha<Hsl<S, T>, A>
pub fn from_format<U, B>(color: Alpha<Hsl<S, U>, B>) -> Alpha<Hsl<S, T>, A>
Convert from another component type.
sourcepub fn into_components(self) -> (RgbHue<T>, T, T, A)
pub fn into_components(self) -> (RgbHue<T>, T, T, A)
Convert to a (hue, saturation, lightness, alpha)
tuple.
sourcepub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsl<S, T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsl<S, T>, A>
Convert from a (hue, saturation, lightness, alpha)
tuple.
source§impl<S, T, A> Alpha<Hsl<S, Vec<T>>, Vec<A>>
impl<S, T, A> Alpha<Hsl<S, Vec<T>>, Vec<A>>
sourcepub fn with_capacity(capacity: usize) -> Alpha<Hsl<S, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Hsl<S, Vec<T>>, Vec<A>>
Create a struct of vectors with a minimum capacity. See Vec::with_capacity
for details.
sourcepub fn push(&mut self, value: Alpha<Hsl<S, T>, A>)
pub fn push(&mut self, value: Alpha<Hsl<S, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Hsl<S, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Hsl<S, T>, A>>
Pop a color’s components from the component vectors. See Vec::pop
for details.
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Clear the component vectors. See Vec::clear
for details.
Trait Implementations
source§impl<C, T> AbsDiffEq for Alpha<C, T>
impl<C, T> AbsDiffEq for Alpha<C, T>
source§fn default_epsilon() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
fn default_epsilon() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
source§fn abs_diff_eq(
&self,
other: &Alpha<C, T>,
epsilon: <T as AbsDiffEq>::Epsilon,
) -> bool
fn abs_diff_eq( &self, other: &Alpha<C, T>, epsilon: <T as AbsDiffEq>::Epsilon, ) -> bool
source§fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
AbsDiffEq::abs_diff_eq
.source§impl<T, C> AddAssign<T> for Alpha<C, T>
impl<T, C> AddAssign<T> for Alpha<C, T>
source§fn add_assign(&mut self, c: T)
fn add_assign(&mut self, c: T)
+=
operation. Read moresource§impl<C, T> AddAssign for Alpha<C, T>
impl<C, T> AddAssign for Alpha<C, T>
source§fn add_assign(&mut self, other: Alpha<C, T>)
fn add_assign(&mut self, other: Alpha<C, T>)
+=
operation. Read moresource§impl<C, T, const N: usize> Blend for Alpha<C, T>where
C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone,
T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone,
<T as HasBoolMask>::Mask: LazySelect<T>,
impl<C, T, const N: usize> Blend for Alpha<C, T>where
C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone,
T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone,
<T as HasBoolMask>::Mask: LazySelect<T>,
source§fn multiply(self, other: Alpha<C, T>) -> Alpha<C, T>
fn multiply(self, other: Alpha<C, T>) -> Alpha<C, T>
self
with other
. This uses the alpha component to regulate
the effect, so it’s not just plain component wise multiplication.source§fn screen(self, other: Alpha<C, T>) -> Alpha<C, T>
fn screen(self, other: Alpha<C, T>) -> Alpha<C, T>
self
or other
.source§fn overlay(self, other: Alpha<C, T>) -> Alpha<C, T>
fn overlay(self, other: Alpha<C, T>) -> Alpha<C, T>
self
or other
if other is dark, or screen them if other
is light. This results in an S curve.source§fn darken(self, other: Alpha<C, T>) -> Alpha<C, T>
fn darken(self, other: Alpha<C, T>) -> Alpha<C, T>
self
and other
.source§fn lighten(self, other: Alpha<C, T>) -> Alpha<C, T>
fn lighten(self, other: Alpha<C, T>) -> Alpha<C, T>
self
and other
.source§fn dodge(self, other: Alpha<C, T>) -> Alpha<C, T>
fn dodge(self, other: Alpha<C, T>) -> Alpha<C, T>
other
to reflect self
. Results in other
if self
is
black.source§fn burn(self, other: Alpha<C, T>) -> Alpha<C, T>
fn burn(self, other: Alpha<C, T>) -> Alpha<C, T>
other
to reflect self
. Results in other
if self
is
white.source§fn hard_light(self, other: Alpha<C, T>) -> Alpha<C, T>
fn hard_light(self, other: Alpha<C, T>) -> Alpha<C, T>
self
or other
if other is dark, or screen them if self
is light. This is similar to overlay
, but depends on self
instead
of other
.source§fn soft_light(self, other: Alpha<C, T>) -> Alpha<C, T>
fn soft_light(self, other: Alpha<C, T>) -> Alpha<C, T>
other
if self
is light, or darken other
as if it’s burned
if self
is dark. The effect is increased if the components of self
is further from 0.5.source§fn difference(self, other: Alpha<C, T>) -> Alpha<C, T>
fn difference(self, other: Alpha<C, T>) -> Alpha<C, T>
self
and other
. It’s
basically abs(self - other)
, but regulated by the alpha component.source§impl<C> BlendWith for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
impl<C> BlendWith for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
source§fn blend_with<F>(
self,
destination: Alpha<C, <C as Premultiply>::Scalar>,
blend_function: F,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn blend_with<F>( self, destination: Alpha<C, <C as Premultiply>::Scalar>, blend_function: F, ) -> Alpha<C, <C as Premultiply>::Scalar>
destination
, using
blend_function
. Anything that implements BlendFunction
is
acceptable, including functions and closures. Read moresource§impl<C, T> ClampAssign for Alpha<C, T>
impl<C, T> ClampAssign for Alpha<C, T>
source§fn clamp_assign(&mut self)
fn clamp_assign(&mut self)
source§impl<C> Compose for Alpha<C, <C as Premultiply>::Scalar>
impl<C> Compose for Alpha<C, <C as Premultiply>::Scalar>
source§fn over(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn over( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
over other
. This is the good old common alpha composition
equation.source§fn inside(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn inside( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
that overlaps the visible parts of
other
.source§fn outside(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn outside( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
that lies outside the visible parts of
other
.source§fn atop(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn atop( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
over only the visible parts of other
.source§fn xor(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn xor( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
or other
, where they do not overlap.source§fn plus(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn plus( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
and other
. This uses the alpha component to regulate the
effect, so it’s not just plain component wise addition.source§impl<'de, C, T> Deserialize<'de> for Alpha<C, T>where
C: Deserialize<'de>,
T: Deserialize<'de>,
impl<'de, C, T> Deserialize<'de> for Alpha<C, T>where
C: Deserialize<'de>,
T: Deserialize<'de>,
source§fn deserialize<D>(
deserializer: D,
) -> Result<Alpha<C, T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Alpha<C, T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<T, C> DivAssign<T> for Alpha<C, T>
impl<T, C> DivAssign<T> for Alpha<C, T>
source§fn div_assign(&mut self, c: T)
fn div_assign(&mut self, c: T)
/=
operation. Read moresource§impl<C, T> DivAssign for Alpha<C, T>
impl<C, T> DivAssign for Alpha<C, T>
source§fn div_assign(&mut self, other: Alpha<C, T>)
fn div_assign(&mut self, other: Alpha<C, T>)
/=
operation. Read moresource§impl<Tc, Ta, C, A> Extend<Alpha<Tc, Ta>> for Alpha<C, A>
impl<Tc, Ta, C, A> Extend<Alpha<Tc, Ta>> for Alpha<C, A>
source§fn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = Alpha<Tc, Ta>>,
fn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = Alpha<Tc, Ta>>,
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<C> From<PreAlpha<C>> for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
impl<C> From<PreAlpha<C>> for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
source§impl<C1, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>
impl<C1, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>
source§fn from_color_unclamped(other: C1) -> Alpha<C2, T>
fn from_color_unclamped(other: C1) -> Alpha<C2, T>
source§impl<Tc, Ta, C, A> FromIterator<Alpha<Tc, Ta>> for Alpha<C, A>
impl<Tc, Ta, C, A> FromIterator<Alpha<Tc, Ta>> for Alpha<C, A>
source§impl<C, T> HasBoolMask for Alpha<C, T>
impl<C, T> HasBoolMask for Alpha<C, T>
source§type Mask = <C as HasBoolMask>::Mask
type Mask = <C as HasBoolMask>::Mask
Self
values.source§impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a [T]>, &'a [T]>
impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a [T]>, &'a [T]>
source§impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a mut [T]>, &'a mut [T]>
impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a mut [T]>, &'a mut [T]>
source§impl<S, T, const N: usize> IntoIterator for Alpha<Hsl<S, [T; N]>, [T; N]>
impl<S, T, const N: usize> IntoIterator for Alpha<Hsl<S, [T; N]>, [T; N]>
source§impl<'a, S, T> IntoIterator for Alpha<Hsl<S, Vec<T>>, Vec<T>>
impl<'a, S, T> IntoIterator for Alpha<Hsl<S, Vec<T>>, Vec<T>>
source§impl<C, T> IsWithinBounds for Alpha<C, T>where
C: IsWithinBounds,
T: Stimulus + PartialCmp<Mask = <C as HasBoolMask>::Mask> + IsWithinBounds,
<C as HasBoolMask>::Mask: BitAnd<Output = <C as HasBoolMask>::Mask>,
impl<C, T> IsWithinBounds for Alpha<C, T>where
C: IsWithinBounds,
T: Stimulus + PartialCmp<Mask = <C as HasBoolMask>::Mask> + IsWithinBounds,
<C as HasBoolMask>::Mask: BitAnd<Output = <C as HasBoolMask>::Mask>,
source§fn is_within_bounds(&self) -> <C as HasBoolMask>::Mask
fn is_within_bounds(&self) -> <C as HasBoolMask>::Mask
source§impl<C> Lighten for Alpha<C, <C as Lighten>::Scalar>where
C: Lighten,
impl<C> Lighten for Alpha<C, <C as Lighten>::Scalar>where
C: Lighten,
source§impl<C> LightenAssign for Alpha<C, <C as LightenAssign>::Scalar>where
C: LightenAssign,
impl<C> LightenAssign for Alpha<C, <C as LightenAssign>::Scalar>where
C: LightenAssign,
source§type Scalar = <C as LightenAssign>::Scalar
type Scalar = <C as LightenAssign>::Scalar
source§fn lighten_assign(&mut self, factor: <C as LightenAssign>::Scalar)
fn lighten_assign(&mut self, factor: <C as LightenAssign>::Scalar)
source§fn lighten_fixed_assign(&mut self, amount: <C as LightenAssign>::Scalar)
fn lighten_fixed_assign(&mut self, amount: <C as LightenAssign>::Scalar)
source§impl<T, C> MulAssign<T> for Alpha<C, T>
impl<T, C> MulAssign<T> for Alpha<C, T>
source§fn mul_assign(&mut self, c: T)
fn mul_assign(&mut self, c: T)
*=
operation. Read moresource§impl<C, T> MulAssign for Alpha<C, T>
impl<C, T> MulAssign for Alpha<C, T>
source§fn mul_assign(&mut self, other: Alpha<C, T>)
fn mul_assign(&mut self, other: Alpha<C, T>)
*=
operation. Read moresource§impl<C, T> RelativeEq for Alpha<C, T>where
C: RelativeEq<Epsilon = <T as AbsDiffEq>::Epsilon>,
T: RelativeEq,
<T as AbsDiffEq>::Epsilon: Clone,
impl<C, T> RelativeEq for Alpha<C, T>where
C: RelativeEq<Epsilon = <T as AbsDiffEq>::Epsilon>,
T: RelativeEq,
<T as AbsDiffEq>::Epsilon: Clone,
source§fn default_max_relative() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
fn default_max_relative() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
source§fn relative_eq(
&self,
other: &Alpha<C, T>,
epsilon: <Alpha<C, T> as AbsDiffEq>::Epsilon,
max_relative: <Alpha<C, T> as AbsDiffEq>::Epsilon,
) -> bool
fn relative_eq( &self, other: &Alpha<C, T>, epsilon: <Alpha<C, T> as AbsDiffEq>::Epsilon, max_relative: <Alpha<C, T> as AbsDiffEq>::Epsilon, ) -> bool
source§fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon,
) -> bool
fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool
RelativeEq::relative_eq
.source§impl<C> Saturate for Alpha<C, <C as Saturate>::Scalar>where
C: Saturate,
impl<C> Saturate for Alpha<C, <C as Saturate>::Scalar>where
C: Saturate,
source§impl<C> SaturateAssign for Alpha<C, <C as SaturateAssign>::Scalar>where
C: SaturateAssign,
impl<C> SaturateAssign for Alpha<C, <C as SaturateAssign>::Scalar>where
C: SaturateAssign,
source§type Scalar = <C as SaturateAssign>::Scalar
type Scalar = <C as SaturateAssign>::Scalar
source§fn saturate_assign(&mut self, factor: <C as SaturateAssign>::Scalar)
fn saturate_assign(&mut self, factor: <C as SaturateAssign>::Scalar)
factor
, a value
ranging from 0.0
to 1.0
. Read moresource§fn saturate_fixed_assign(&mut self, amount: <C as SaturateAssign>::Scalar)
fn saturate_fixed_assign(&mut self, amount: <C as SaturateAssign>::Scalar)
source§impl<T, C> SaturatingAdd<T> for Alpha<C, T>
impl<T, C> SaturatingAdd<T> for Alpha<C, T>
source§type Output = Alpha<<C as SaturatingAdd<T>>::Output, <T as SaturatingAdd>::Output>
type Output = Alpha<<C as SaturatingAdd<T>>::Output, <T as SaturatingAdd>::Output>
source§fn saturating_add(self, c: T) -> <Alpha<C, T> as SaturatingAdd<T>>::Output
fn saturating_add(self, c: T) -> <Alpha<C, T> as SaturatingAdd<T>>::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> SaturatingAdd for Alpha<C, T>where
C: SaturatingAdd,
T: SaturatingAdd,
impl<C, T> SaturatingAdd for Alpha<C, T>where
C: SaturatingAdd,
T: SaturatingAdd,
source§type Output = Alpha<<C as SaturatingAdd>::Output, <T as SaturatingAdd>::Output>
type Output = Alpha<<C as SaturatingAdd>::Output, <T as SaturatingAdd>::Output>
source§fn saturating_add(
self,
other: Alpha<C, T>,
) -> <Alpha<C, T> as SaturatingAdd>::Output
fn saturating_add( self, other: Alpha<C, T>, ) -> <Alpha<C, T> as SaturatingAdd>::Output
self
and other
, but saturates instead of overflowing.source§impl<T, C> SaturatingSub<T> for Alpha<C, T>
impl<T, C> SaturatingSub<T> for Alpha<C, T>
source§type Output = Alpha<<C as SaturatingSub<T>>::Output, <T as SaturatingSub>::Output>
type Output = Alpha<<C as SaturatingSub<T>>::Output, <T as SaturatingSub>::Output>
source§fn saturating_sub(self, c: T) -> <Alpha<C, T> as SaturatingSub<T>>::Output
fn saturating_sub(self, c: T) -> <Alpha<C, T> as SaturatingSub<T>>::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> SaturatingSub for Alpha<C, T>where
C: SaturatingSub,
T: SaturatingSub,
impl<C, T> SaturatingSub for Alpha<C, T>where
C: SaturatingSub,
T: SaturatingSub,
source§type Output = Alpha<<C as SaturatingSub>::Output, <T as SaturatingSub>::Output>
type Output = Alpha<<C as SaturatingSub>::Output, <T as SaturatingSub>::Output>
source§fn saturating_sub(
self,
other: Alpha<C, T>,
) -> <Alpha<C, T> as SaturatingSub>::Output
fn saturating_sub( self, other: Alpha<C, T>, ) -> <Alpha<C, T> as SaturatingSub>::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> Serialize for Alpha<C, T>
impl<C, T> Serialize for Alpha<C, T>
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
source§impl<C, T> ShiftHueAssign for Alpha<C, T>where
C: ShiftHueAssign,
impl<C, T> ShiftHueAssign for Alpha<C, T>where
C: ShiftHueAssign,
source§type Scalar = <C as ShiftHueAssign>::Scalar
type Scalar = <C as ShiftHueAssign>::Scalar
source§fn shift_hue_assign(&mut self, amount: <Alpha<C, T> as ShiftHueAssign>::Scalar)
fn shift_hue_assign(&mut self, amount: <Alpha<C, T> as ShiftHueAssign>::Scalar)
amount
.source§impl<T, C> SubAssign<T> for Alpha<C, T>
impl<T, C> SubAssign<T> for Alpha<C, T>
source§fn sub_assign(&mut self, c: T)
fn sub_assign(&mut self, c: T)
-=
operation. Read moresource§impl<C, T> SubAssign for Alpha<C, T>
impl<C, T> SubAssign for Alpha<C, T>
source§fn sub_assign(&mut self, other: Alpha<C, T>)
fn sub_assign(&mut self, other: Alpha<C, T>)
-=
operation. Read moresource§impl<C, T> UlpsEq for Alpha<C, T>
impl<C, T> UlpsEq for Alpha<C, T>
source§fn default_max_ulps() -> u32
fn default_max_ulps() -> u32
source§impl<C, A> WithAlpha<A> for Alpha<C, A>
impl<C, A> WithAlpha<A> for Alpha<C, A>
source§fn with_alpha(self, alpha: A) -> <Alpha<C, A> as WithAlpha<A>>::WithAlpha
fn with_alpha(self, alpha: A) -> <Alpha<C, A> as WithAlpha<A>>::WithAlpha
Self
already has a transparency, it is
overwritten. Read more