Trait nannou::color::blend::Blend

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

    // Required 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;

    // Provided methods
    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.

Required Associated Types

type Color: Blend<Color = Self::Color> + ComponentWise

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

Required Methods

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

Convert the color to premultiplied alpha.

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

Convert the color from premultiplied alpha.

Provided Methods

fn blend<F>(self, destination: Self, blend_function: F) -> Self

where F: BlendFunction<Self::Color>,

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

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

fn inside(self, other: Self) -> Self

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

fn outside(self, other: Self) -> Self

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

fn atop(self, other: Self) -> Self

Place self over only the visible parts of other.

fn xor(self, other: Self) -> Self

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

fn plus(self, other: Self) -> Self

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

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

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

fn overlay(self, other: Self) -> Self

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

Return the darkest parts of self and other.

fn lighten(self, other: Self) -> Self

Return the lightest parts of self and other.

fn dodge(self, other: Self) -> Self

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

fn burn(self, other: Self) -> Self

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

fn hard_light(self, other: Self) -> Self

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

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

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

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

Object Safety

This trait is not object safe.

Implementors

impl<C, T> Blend for Alpha<C, T>

where C: Blend, T: Float, <C as Blend>::Color: ComponentWise<Scalar = T>, Alpha<C, T>: Into<Alpha<<C as Blend>::Color, T>> + From<Alpha<<C as Blend>::Color, T>>,

type Color = <C as Blend>::Color

impl<C, T> Blend for PreAlpha<C, T>

where C: Blend<Color = C> + ComponentWise<Scalar = T>, T: Float,

type Color = C

impl<S, T> Blend for Luma<S, T>

where T: Component + Float, S: LumaStandard<TransferFn = LinearFn>,

type Color = Luma<S, T>

impl<S, T> Blend for Rgb<S, T>

where S: RgbStandard<TransferFn = LinearFn>, T: Component + Float,

type Color = Rgb<S, T>