Enum CompositeOperator 

pub enum CompositeOperator {
    Over,
    In,
    Out,
    Atop,
    Xor,
    Arithmetic {
        k1: f32,
        k2: f32,
        k3: f32,
        k4: f32,
    },
}

Composite operators for combining filter inputs.

These are the Porter-Duff compositing operators used to combine two images. Each operator defines how the source (input 1) and destination (input 2) are combined based on their color and alpha values.

Variants

Over

Source over destination (standard alpha blending).

The source is composited over the destination. This is the most common blending mode where source alpha determines visibility.

In

Source in destination (intersection).

The source is only visible where the destination is opaque. Result alpha = source_alpha × dest_alpha.

Out

Source out destination (subtract).

The source is only visible where the destination is transparent. Useful for masking/cutting out regions.

Atop

Source atop destination.

Source is composited over destination, but only where destination is opaque.

Xor

Source XOR destination (exclusive or).

Shows source where destination is transparent and vice versa, but not where both are opaque.

Arithmetic

Arithmetic combination with custom coefficients.

Custom linear combination: result = k1srcdst + k2src + k3dst + k4. Allows creating custom compositing operations beyond the standard Porter-Duff set.

Fields

k1: f32

Coefficient k1 for the (source * destination) term.

k2: f32

Coefficient k2 for the source term.

k3: f32

Coefficient k3 for the destination term.

k4: f32

Constant offset k4 added to the result.

Trait Implementations

impl Clone for CompositeOperator

fn clone(&self) -> CompositeOperator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompositeOperator

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

Formats the value using the given formatter.

impl PartialEq for CompositeOperator

fn eq(&self, other: &CompositeOperator) -> 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 Copy for CompositeOperator

impl StructuralPartialEq for CompositeOperator