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

pub trait Blend where
    <Self::Color as ComponentWise>::Scalar: Float,
    <Self::Color as Blend>::Color == Self::Color, {
    type Color: Blend + ComponentWise;
    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 + ComponentWise

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>

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.

Loading content...

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.

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, T> Blend for Alpha<C, T> where
    C: Blend,
    T: Float,
    <C as Blend>::Color: ComponentWise,
    Alpha<C, T>: Into<Alpha<<C as Blend>::Color, T>>,
    Alpha<C, T>: From<Alpha<<C as Blend>::Color, T>>,
    <<C as Blend>::Color as ComponentWise>::Scalar == T, [src]

type Color = <C as Blend>::Color

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

type Color = Rgb<Linear<S>, T>

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

type Color = Luma<S, T>

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

type Color = Rgb<S, T>

Loading content...