Enum CompositeOperation 

pub enum CompositeOperation {
    SourceOver,
    SourceIn,
    SourceOut,
    SourceAtop,
    DestinationOver,
    DestinationIn,
    DestinationOut,
    DestinationAtop,
    Lighter,
    Copy,
    Xor,
    Multiply,
    Screen,
    Overlay,
    Darken,
    Lighten,
    ColorDodge,
    ColorBurn,
    HardLight,
    SoftLight,
    Difference,
    Exclusion,
    Hue,
    Saturation,
    Color,
    Luminosity,
}

The type of compositing operation to apply when drawing new shapes

(JavaScript docs)

Variants

SourceOver

Draws new shapes over existing canvas content

SourceIn

Draws new shapes over existing canvas content, but only where existing canvas content overlaps. Anything not in that area becomes transparent.

SourceOut

New shapes are drawn where there is no existing canvas content. Everything else (including old canvas content) is made transparent.

SourceAtop

Draws new shapes only where there is existing canvas content, over existing canvas content

DestinationOver

Draws new shapes behind existing canvas content

DestinationIn

Keeps existing canvas content where it overlaps with the new shape. Everything outside the overlap is made transparent.

DestinationOut

The existing content is kept where it doesn’t overlap with the new shape. Everything else, including the new shape area, is made transparent.

DestinationAtop

Existing content is kept only where it overlaps with the new shape. The new shape is drawn behind the existing content.

Lighter

Where both shapes overlap, the new color is determined by adding color values

Copy

Only the new shape is shown

Xor

Where both shapes overlap, make it transparent

Multiply

The pixels of the new and old layer are multiplied. (Pixel values are in the range of [0,1], so this makes a darker picture)

Screen

Pixels from both new and old are inverted, multiplied together, then inverted again. (Pixel values are in the range of [0,1], so this makes a lighter picture)

Overlay

Applies Multiply to dark colors in the existing content, and Screen to bright colors in the existing content

Darken

Retains the darkest pixels

Lighten

Retains the lighest pixels

ColorDodge

Divides the bottom layer by the inverted top layer.

ColorBurn

Divides the inverted bottom layer by the top layer, and then inverts the result.

HardLight

A combination of multiply and screen like overlay, but with top and bottom layer swapped.

SoftLight

A softer version of hard-light. Pure black or white does not result in pure black or white.

Difference

Subtracts the bottom layer from the top layer or the other way round to always get a positive value.

Exclusion

Like difference, but with lower contrast.

Hue

Preserves the luma and chroma of the bottom layer, while adopting the hue of the top layer.

Saturation

Preserves the luma and hue of the bottom layer, while adopting the chroma of the top layer.

Color

Preserves the luma of the bottom layer, while adopting the hue and chroma of the top layer.

Luminosity

Preserves the hue and chroma of the bottom layer, while adopting the luma of the top layer.

Trait Implementations

impl Clone for CompositeOperation

fn clone(&self) -> CompositeOperation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CompositeOperation

impl Debug for CompositeOperation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for CompositeOperation

impl PartialEq for CompositeOperation

fn eq(&self, other: &CompositeOperation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CompositeOperation