Trait palette::blend::Blend[−][src]

pub trait Blend: Sized where
    <Self::Color as ComponentWise>::Scalar: Float, {
    type Color: Blend<Color = Self::Color> + ComponentWise;

Show methods    fn into_premultiplied(
        self
    ) -> PreAlpha<Self::Color, <Self::Color as ComponentWise>::Scalar>;

    fn from_premultiplied(
        color: PreAlpha<Self::Color, <Self::Color as ComponentWise>::Scalar>
    ) -> Self;

    fn blend<F>(self, destination: Self, blend_function: F) -> Self
    where
        F: BlendFunction<Self::Color>,
    { ... }

    fn over(self, other: Self) -> Self { ... }

    fn inside(self, other: Self) -> Self { ... }

    fn outside(self, other: Self) -> Self { ... }

    fn atop(self, other: Self) -> Self { ... }

    fn xor(self, other: Self) -> Self { ... }

    fn plus(self, other: Self) -> Self { ... }

    fn multiply(self, other: Self) -> Self { ... }

    fn screen(self, other: Self) -> Self { ... }

    fn overlay(self, other: Self) -> Self { ... }

    fn darken(self, other: Self) -> Self { ... }

    fn lighten(self, other: Self) -> Self { ... }

    fn dodge(self, other: Self) -> Self { ... }

    fn burn(self, other: Self) -> Self { ... }

    fn hard_light(self, other: Self) -> Self { ... }

    fn soft_light(self, other: Self) -> Self { ... }

    fn difference(self, other: Self) -> Self { ... }

    fn exclusion(self, other: Self) -> Self { ... }

}

A trait for colors that can be blended together.

Blending can either be performed through the predefined blend modes, or a custom blend functions.

Note: The default implementations of the blend modes are meant for color components in the range [0.0, 1.0] and may otherwise produce strange results.

Associated Types

type Color: Blend<Color = Self::Color> + ComponentWise[src]

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

Loading content...

Required methods

fn into_premultiplied(
    self
) -> PreAlpha<Self::Color, <Self::Color as ComponentWise>::Scalar>[src]

Convert the color to premultiplied alpha.

fn from_premultiplied(
    color: PreAlpha<Self::Color, <Self::Color as ComponentWise>::Scalar>
) -> Self[src]

Convert the color from premultiplied alpha.

Loading content...

Provided methods

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.

use palette::{LinSrgb, LinSrgba, Blend};
use palette::blend::PreAlpha;

type PreRgba = PreAlpha<LinSrgb<f32>, f32>;

fn blend_mode(a: PreRgba, b: PreRgba) -> PreRgba {
   PreAlpha {
       color: LinSrgb::new(a.red * b.green, a.green * b.blue, a.blue * b.red),
       alpha: a.alpha * b.alpha,
   }
}

let a = LinSrgba::new(0.2, 0.5, 0.1, 0.8);
let b = LinSrgba::new(0.6, 0.3, 0.5, 0.1);
let c = a.blend(b, blend_mode);

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

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

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

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

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

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

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.

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.

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.

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.

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

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

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.

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.

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.

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.

Loading content...

Implementors

impl<C, T> Blend for PreAlpha<C, T> where
    C: Blend<Color = C> + ComponentWise<Scalar = T>,
    T: Float, [src]

type Color = C

impl<C: Blend, T: Float> Blend for Alpha<C, T> where
    C::Color: ComponentWise<Scalar = T>,
    Alpha<C, T>: Into<Alpha<C::Color, T>> + From<Alpha<C::Color, T>>, [src]

type Color = C::Color

impl<S, T> Blend for Luma<S, T> where
    T: FloatComponent,
    S: LumaStandard<TransferFn = LinearFn>, [src]

type Color = Luma<S, T>

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

type Color = Rgb<S, T>

Loading content...