[][src]Struct amethyst_rendy::palette::rgb::Rgb

#[repr(C)]
pub struct Rgb<S = Srgb, T = f32> where
    S: RgbStandard,
    T: Component
{ pub red: T, pub green: T, pub blue: T, pub standard: PhantomData<S>, }

Generic RGB.

RGB is probably the most common color space, when it comes to computer graphics, and it's defined as an additive mixture of red, green and blue light, where gray scale colors are created when these three channels are equal in strength.

Many conversions and operations on this color space requires that it's linear, meaning that gamma correction is required when converting to and from a displayable RGB, such as sRGB. See the pixel module for encoding formats.

Fields

red: T

The amount of red light, where 0.0 is no red light and 1.0f (or 255u8) is the highest displayable amount.

green: T

The amount of green light, where 0.0 is no green light and 1.0f (or 255u8) is the highest displayable amount.

blue: T

The amount of blue light, where 0.0 is no blue light and 1.0f (or 255u8) is the highest displayable amount.

standard: PhantomData<S>

The kind of RGB standard. sRGB is the default.

Methods

impl<S, T> Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

pub fn new(red: T, green: T, blue: T) -> Rgb<S, T>[src]

Create an RGB color.

pub fn into_format<U>(self) -> Rgb<S, U> where
    U: Component
[src]

Convert into another component type.

pub fn from_format<U>(color: Rgb<S, U>) -> Rgb<S, T> where
    U: Component
[src]

Convert from another component type.

pub fn into_components(self) -> (T, T, T)[src]

Convert to a (red, green, blue) tuple.

pub fn from_components((T, T, T)) -> Rgb<S, T>[src]

Convert from a (red, green, blue) tuple.

impl<S, T> Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

pub fn into_linear(self) -> Rgb<Linear<<S as RgbStandard>::Space>, T>[src]

Convert the color to linear RGB.

pub fn from_linear(
    color: Rgb<Linear<<S as RgbStandard>::Space>, T>
) -> Rgb<S, T>
[src]

Convert linear RGB to nonlinear RGB.

pub fn into_encoding<St>(self) -> Rgb<St, T> where
    St: RgbStandard<Space = <S as RgbStandard>::Space>, 
[src]

Convert the color to a different encoding.

pub fn from_encoding<St>(color: Rgb<St, T>) -> Rgb<S, T> where
    St: RgbStandard<Space = <S as RgbStandard>::Space>, 
[src]

Convert RGB from a different encoding.

Trait Implementations

impl<S, T> Default for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

impl<S, T> Copy for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

impl<S, T> Pixel<T> for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

fn as_raw<P>(&self) -> &P where
    P: RawPixel<T> + ?Sized
[src]

Cast as a reference to raw color components.

fn as_raw_mut<P>(&mut self) -> &mut P where
    P: RawPixel<T> + ?Sized
[src]

Cast as a mutable reference to raw color components.

fn into_raw<P>(self) -> P where
    P: RawPixelSized<T>, 
[src]

Convert from raw color components.

fn from_raw<P>(pixel: &P) -> &Self where
    P: RawPixel<T> + ?Sized
[src]

Cast from a reference to raw color components.

fn from_raw_mut<P>(pixel: &mut P) -> &mut Self where
    P: RawPixel<T> + ?Sized
[src]

Cast from a mutable reference to raw color components.

Important traits for &'_ [u8]
fn from_raw_slice(slice: &[T]) -> &[Self][src]

Cast a slice of raw color components to a slice of colors. Read more

Important traits for &'_ [u8]
fn from_raw_slice_mut(slice: &mut [T]) -> &mut [Self][src]

Cast a mutable slice of raw color components to a mutable slice of colors. Read more

Important traits for &'_ [u8]
fn into_raw_slice(slice: &[Self]) -> &[T][src]

Cast a slice of colors to a slice of raw color components. Read more

Important traits for &'_ [u8]
fn into_raw_slice_mut(slice: &mut [Self]) -> &mut [T][src]

Cast a mutable slice of colors to a mutable slice of raw color components. Read more

impl<S, T> Clone for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<'de, S, T> Deserialize<'de> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Deserialize<'de>, 
[src]

impl<S, T> Blend for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Float
[src]

type Color = Rgb<S, T>

The core color type. Typically Self for color types without alpha.

fn blend<F>(self, destination: Self, blend_function: F) -> Self where
    F: BlendFunction<Self::Color>, 
[src]

Blend self, as the source color, with destination, using blend_function. Anything that implements BlendFunction is acceptable, including functions and closures. Read more

fn over(self, other: Self) -> Self[src]

Place self over other. This is the good old common alpha composition equation. Read more

fn inside(self, other: Self) -> Self[src]

Results in the parts of self that overlaps the visible parts of other. Read more

fn outside(self, other: Self) -> Self[src]

Results in the parts of self that lies outside the visible parts of other. Read more

fn atop(self, other: Self) -> Self[src]

Place self over only the visible parts of other.

fn xor(self, other: Self) -> Self[src]

Results in either self or other, where they do not overlap.

fn plus(self, other: Self) -> Self[src]

Add self and other. This uses the alpha component to regulate the effect, so it's not just plain component wise addition. Read more

fn multiply(self, other: Self) -> Self[src]

Multiply self with other. This uses the alpha component to regulate the effect, so it's not just plain component wise multiplication. Read more

fn screen(self, other: Self) -> Self[src]

Make a color which is at least as light as self or other.

fn overlay(self, other: Self) -> Self[src]

Multiply self or other if other is dark, or screen them if other is light. This results in an S curve. Read more

fn darken(self, other: Self) -> Self[src]

Return the darkest parts of self and other.

fn lighten(self, other: Self) -> Self[src]

Return the lightest parts of self and other.

fn dodge(self, other: Self) -> Self[src]

Lighten other to reflect self. Results in other if self is black. Read more

fn burn(self, other: Self) -> Self[src]

Darken other to reflect self. Results in other if self is white. Read more

fn hard_light(self, other: Self) -> Self[src]

Multiply 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. Read more

fn soft_light(self, other: Self) -> Self[src]

Lighten 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. Read more

fn difference(self, other: Self) -> Self[src]

Return the absolute difference between self and other. It's basically abs(self - other), but regulated by the alpha component. Read more

fn exclusion(self, other: Self) -> Self[src]

Similar to difference, but appears to result in a lower contrast. other is inverted if self is white, and preserved if self is black. Read more

impl<S, T> PartialEq<Rgb<S, T>> for Rgb<S, T> where
    S: RgbStandard + PartialEq<S>,
    T: Component + PartialEq<T>, 
[src]

impl<S, T> Add<T> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Add<T>,
    <T as Add<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Add<T>>::Output>

The resulting type after applying the + operator.

impl<S, T> Add<Rgb<S, T>> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Add<T>,
    <T as Add<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Add<T>>::Output>

The resulting type after applying the + operator.

impl<S, T> Limited for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

impl<S, T, P> AsMut<P> for Rgb<S, T> where
    P: RawPixel<T> + ?Sized,
    S: RgbStandard,
    T: Component
[src]

fn as_mut(&mut self) -> &mut P[src]

Convert to a raw pixel format.

use palette::Srgb;

let mut rgb = Srgb::new(38, 42, 19);
{
    let raw: &mut [u8] = rgb.as_mut();
    raw[1] = 5;
}

assert_eq!(rgb.green, 5);

impl<S, T> FromColor<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

fn from_yxy(inp: Yxy<Wp, T>) -> Self[src]

Convert from Yxy color space

fn from_lab(inp: Lab<Wp, T>) -> Self[src]

Convert from Lab* color space

fn from_lch(inp: Lch<Wp, T>) -> Self[src]

Convert from LCh° color space

fn from_hwb<S>(inp: Hwb<S, T>) -> Self where
    S: RgbSpace<WhitePoint = Wp>, 
[src]

Convert from HWB color space

impl<S, T> UpperHex for Rgb<S, T> where
    S: RgbStandard,
    T: Component + UpperHex
[src]

impl<S, T> Sub<Rgb<S, T>> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Sub<T>,
    <T as Sub<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Sub<T>>::Output>

The resulting type after applying the - operator.

impl<S, T> Sub<T> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Sub<T>,
    <T as Sub<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Sub<T>>::Output>

The resulting type after applying the - operator.

impl<S, T> Mul<Rgb<S, T>> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Mul<T>,
    <T as Mul<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Mul<T>>::Output>

The resulting type after applying the * operator.

impl<S, T> Mul<T> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Mul<T>,
    <T as Mul<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Mul<T>>::Output>

The resulting type after applying the * operator.

impl<S, T, Wp> IntoColor<Wp, T> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float,
    Wp: WhitePoint,
    <S as RgbStandard>::Space: RgbSpace,
    <<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T> Mix for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Float
[src]

type Scalar = T

The type of the mixing factor.

impl<S, T> Into<(T, T, T)> for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

impl<S, T> Div<T> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Div<T>,
    <T as Div<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Div<T>>::Output>

The resulting type after applying the / operator.

impl<S, T> Div<Rgb<S, T>> for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Div<T>,
    <T as Div<T>>::Output: Component
[src]

type Output = Rgb<S, <T as Div<T>>::Output>

The resulting type after applying the / operator.

impl<S, T> ApproxEq for Rgb<S, T> where
    S: RgbStandard,
    T: Component + ApproxEq,
    <T as ApproxEq>::Epsilon: Copy
[src]

type Epsilon = <T as ApproxEq>::Epsilon

Used for specifying relative comparisons.

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

The inverse of ApproxEq::relative_eq.

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

The inverse of ApproxEq::ulps_eq.

impl<S, T, P> AsRef<P> for Rgb<S, T> where
    P: RawPixel<T> + ?Sized,
    S: RgbStandard,
    T: Component
[src]

fn as_ref(&self) -> &P[src]

Convert to a raw pixel format.

use palette::Srgb;

let mut rgb = Srgb::new(38, 42, 19);
let raw: &[u8] = rgb.as_ref();

assert_eq!(raw[1], 42);

impl<S, T> Debug for Rgb<S, T> where
    S: RgbStandard + Debug,
    T: Component + Debug
[src]

impl<S, T> LowerHex for Rgb<S, T> where
    S: RgbStandard,
    T: Component + LowerHex
[src]

impl<S, T> From<Hwb<<S as RgbStandard>::Space, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T, Sp, Wp> From<Hsl<Sp, T>> for Rgb<S, T> where
    S: RgbStandard,
    Sp: RgbSpace<WhitePoint = Wp>,
    T: Component + Float,
    Wp: WhitePoint,
    <S as RgbStandard>::Space: RgbSpace,
    <<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T> From<Alpha<Hwb<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T> From<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<Wp, T, S> From<Rgb<S, T>> for Xyz<Wp, T> where
    S: RgbStandard,
    T: Component + Float,
    Wp: WhitePoint,
    <S as RgbStandard>::Space: RgbSpace,
    <<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, Wp, T> From<Xyz<Wp, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float,
    Wp: WhitePoint,
    <S as RgbStandard>::Space: RgbSpace,
    <<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, Sp, Wp> From<Hsv<Sp, T>> for Rgb<S, T> where
    S: RgbStandard,
    Sp: RgbSpace<WhitePoint = Wp>,
    T: Component + Float,
    Wp: WhitePoint,
    <S as RgbStandard>::Space: RgbSpace,
    <<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T> From<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<(T, T, T)> for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

impl<S, T> From<Color<<S as RgbStandard>::Space, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == <S as LumaStandard>::WhitePoint
[src]

impl<S, T> From<Alpha<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T> From<Alpha<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, St, Wp> From<Luma<St, T>> for Rgb<S, T> where
    S: RgbStandard,
    St: LumaStandard<WhitePoint = Wp>,
    T: Component + Float,
    Wp: WhitePoint,
    <S as RgbStandard>::Space: RgbSpace,
    <<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T> From<Alpha<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float,
    _S: RgbStandard<Space = <S as RgbStandard>::Space>, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == <S as LumaStandard>::WhitePoint
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <<S as RgbStandard>::Space as RgbSpace>::WhitePoint>, 
[src]

impl<S, T> From<Alpha<Hsl<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T> From<Rgb<Linear<S>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> Shade for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Float
[src]

type Scalar = T

The type of the lighten/darken amount.

fn darken(&self, amount: Self::Scalar) -> Self[src]

Darken the color by amount.

impl<S, T> Serialize for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Serialize
[src]

impl<S, T> GetHue for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Float
[src]

type Hue = RgbHue<T>

The kind of hue unit this color space uses. Read more

impl<S, T> ComponentWise for Rgb<S, T> where
    S: RgbStandard,
    T: Component
[src]

type Scalar = T

The scalar type for color components.

impl<S, T, B> From<Rgb<S, T>> for Pixel<Rgb, B, Srgb> where
    B: ChannelSize,
    S: RgbStandard<Space = Srgb>,
    T: Component,
    Srgb: ChannelRepr<B>,
    <Srgb as ChannelRepr<B>>::Repr: Component
[src]

impl<S, T, B> From<Rgb<S, T>> for Pixel<Rgb, B, Unorm> where
    B: ChannelSize,
    S: RgbStandard<Space = Srgb>,
    T: Component,
    Unorm: ChannelRepr<B>,
    <Unorm as ChannelRepr<B>>::Repr: Component
[src]

impl<S, T, B> From<Rgb<S, T>> for Pixel<Rgb, B, Float> where
    B: ChannelSize,
    S: RgbStandard<Space = Srgb>,
    T: Component,
    Float: ChannelRepr<B>,
    <Float as ChannelRepr<B>>::Repr: Component
[src]

Auto Trait Implementations

impl<S, T> Unpin for Rgb<S, T> where
    S: Unpin,
    T: Unpin

impl<S, T> Sync for Rgb<S, T> where
    S: Sync,
    T: Sync

impl<S, T> Send for Rgb<S, T> where
    S: Send,
    T: Send

impl<S, T> UnwindSafe for Rgb<S, T> where
    S: UnwindSafe,
    T: UnwindSafe

impl<S, T> RefUnwindSafe for Rgb<S, T> where
    S: RefUnwindSafe,
    T: RefUnwindSafe

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<S, D, Swp, Dwp, T> AdaptFrom<S, Swp, Dwp, T> for D where
    D: FromColor<Dwp, T>,
    Dwp: WhitePoint,
    S: IntoColor<Swp, T>,
    Swp: WhitePoint,
    T: Component + Float
[src]

fn adapt_from(color: S) -> Self[src]

Convert the source color to the destination color using the bradford method by default Read more

impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where
    D: AdaptFrom<S, Swp, Dwp, T>,
    Dwp: WhitePoint,
    Swp: WhitePoint,
    T: Component + Float
[src]

fn adapt_into(self) -> D[src]

Convert the source color to the destination color using the bradford method by default Read more

impl<T> DeserializeOwned for T where
    T: Deserialize<'de>, 
[src]

impl<T> SetParameter for T[src]

fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
    T: Parameter<Self>, 
[src]

Sets value as a parameter of self.

impl<T> Supports<T> for T[src]

impl<T> Erased for T[src]

impl<T> Serialize for T where
    T: Serialize + ?Sized
[src]

impl<T> Scalar for T where
    T: Copy + PartialEq<T> + Any + Debug
[src]

fn is<T>() -> bool where
    T: Scalar
[src]

Tests if Self the same as the type T Read more

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 
[src]

impl<T> Resource for T where
    T: Any + Send + Sync
[src]

impl<T> Any for T where
    T: Any
[src]

impl<T> TryDefault for T where
    T: Default
[src]

fn unwrap_default() -> Self[src]

Calls try_default and panics on an error case.

impl<T> Event for T where
    T: Send + Sync + 'static, 
[src]

impl<T> Clone for T where
    T: Clone
[src]

impl<T> Config for T where
    T: Deserialize<'a> + Serialize + Default
[src]