Trait palette::Shade

pub trait Shade: Sized {
    type Scalar: Float;
    fn lighten(&self, amount: Self::Scalar) -> Self;

    fn darken(&self, amount: Self::Scalar) -> Self { ... }
}

The Shade trait allows a color to be lightened or darkened.

use palette::{LinSrgb, Shade};

let a = LinSrgb::new(0.4, 0.4, 0.4);
let b = LinSrgb::new(0.6, 0.6, 0.6);

assert_eq!(a.lighten(0.1), b.darken(0.1));

Associated Types

type Scalar: Float

The type of the lighten/darken amount.

Loading content...

Required methods

fn lighten(&self, amount: Self::Scalar) -> Self

Lighten the color by amount.

Loading content...

Provided methods

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

Darken the color by amount.

Loading content...

Implementors

impl<C: Shade> Shade for Alpha<C, C::Scalar>

type Scalar = C::Scalar

fn lighten(&self, amount: C::Scalar) -> Alpha<C, C::Scalar>

impl<S, T> Shade for Luma<S, T> where
    T: Component + Float,
    S: LumaStandard<TransferFn = LinearFn>, 

type Scalar = T

fn lighten(&self, amount: T) -> Luma<S, T>

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

type Scalar = T

fn lighten(&self, amount: T) -> Rgb<S, T>

impl<S, T> Shade for Hsl<S, T> where
    T: Component + Float,
    S: RgbSpace, 

type Scalar = T

fn lighten(&self, amount: T) -> Hsl<S, T>

impl<S, T> Shade for Hsv<S, T> where
    T: Component + Float,
    S: RgbSpace, 

type Scalar = T

fn lighten(&self, amount: T) -> Hsv<S, T>

impl<S, T> Shade for Hwb<S, T> where
    T: Component + Float,
    S: RgbSpace, 

type Scalar = T

fn lighten(&self, amount: T) -> Hwb<S, T>

impl<Wp, T> Shade for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn lighten(&self, amount: T) -> Lab<Wp, T>

impl<Wp, T> Shade for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn lighten(&self, amount: T) -> Lch<Wp, T>

impl<Wp, T> Shade for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn lighten(&self, amount: T) -> Xyz<Wp, T>

impl<Wp, T> Shade for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn lighten(&self, amount: T) -> Yxy<Wp, T>

Loading content...