Trait Compose

pub trait Compose {
    // Required methods
    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;
}

The Porter Duff composition operators, as described by W3C.

This set of operators exclude the variants where source and destination are swapped, as well as the “clear”, “copy” and “destination” operators. Those can easily be achieved using other means.

Required Methods

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<C> Compose for Alpha<C, <C as Premultiply>::Scalar>

where C: Premultiply, PreAlpha<C>: Compose,

impl<C> Compose for C

where C: Premultiply, <C as Premultiply>::Scalar: Stimulus, PreAlpha<C>: Compose,

impl<C, T, const N: usize> Compose for PreAlpha<C>

where C: ArrayCast<Array = [T; N]> + Premultiply<Scalar = T>, T: Real + Zero + One + Arithmetics + Clamp + Clone,