Trait palette::Blend

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


Show 20 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 { ... }

}
Expand description

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

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

Required Methods

Convert the color to premultiplied alpha.

Convert the color from premultiplied alpha.

Provided Methods

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);

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

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

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

Place self over only the visible parts of other.

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

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

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

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

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

Return the darkest parts of self and other.

Return the lightest parts of self and other.

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

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

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.

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.

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

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

Implementors