motion-core 0.2.0

Backend-independent motion engine primitives
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Blending, fill and mask interpretation.

/// Linear-light layer blending, with explicit compositing space.
///
/// Separable modes evaluate straight linear channels with source-over alpha.
/// Extended RGB is not gamut-clipped. Plus instead adds premultiplied RGB and
/// clamps the summed alpha to one. Dodge/Burn retain their formula's intrinsic
/// endpoints and saturation; other modes extend their piecewise formulas without
/// input clipping. Nonseparable modes use hue/saturation/luminosity replacement.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Serialize, serde::Deserialize),
    serde(rename_all = "snake_case")
)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
pub enum BlendMode {
    /// Premultiplied source-over; the default.
    #[default]
    SourceOver,
    /// Unclipped additive RGB with saturated additive alpha.
    Plus,
    /// Product of straight source and backdrop channels.
    Multiply,
    /// Source plus backdrop minus their product.
    Screen,
    /// Minimum of straight source and backdrop channels.
    Darken,
    /// Maximum of straight source and backdrop channels.
    Lighten,
    /// Absolute difference of straight channels.
    Difference,
    /// Source plus backdrop minus twice their product.
    Exclusion,
    /// Multiply or screen, selected by the backdrop channel at one half.
    Overlay,
    /// Multiply or screen, selected by the source channel at one half.
    HardLight,
    /// Piecewise soft lighting, with the low-backdrop cubic and upper square root.
    SoftLight,
    /// Backdrop divided by one minus source, saturated above at one.
    ///
    /// Nonpositive backdrop returns zero before source at or above one returns one.
    ColorDodge,
    /// One minus the saturated ratio of one minus backdrop to source.
    ///
    /// Backdrop at or above one returns one before nonpositive source returns zero.
    ColorBurn,
    /// Source hue with backdrop saturation and luminosity.
    Hue,
    /// Source saturation with backdrop hue and luminosity.
    Saturation,
    /// Source hue/saturation with backdrop luminosity.
    Color,
    /// Source luminosity with backdrop hue/saturation.
    Luminosity,
    /// Internal linear-only additive capture used by sample accumulation.
    #[doc(hidden)]
    LinearPlus,
}

/// Color space used for compositing, independent of stored linear pixels.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum BlendSpace {
    /// Composite straight linear RGB, retaining the default.
    #[default]
    LinearRgb,
    /// Composite encoded sRGB, then return to linear-premultiplied storage.
    Srgb,
}

/// How closed contours determine the filled interior.
///
/// Recording retains both rules without silently substituting one for
/// the default NonZero rule.
///
/// ```
/// use motion_core::prelude::*;
/// use motion_core::{
///     DisplayList, RasterLimits, ResourceStore, ValidatedDisplayList, MAX_PATH_VERBS,
///     MAX_STROKE_VERBS, MAX_SVG_PATH_BYTES, sample_offsets,
/// };
/// let path = Path2D::from_rect(Rect::new(0.0, 0.0, 10.0, 20.0))?;
/// let fill = path.fill(Color::WHITE);
/// let native = DrawContext::default().record(&fill, ValidationLimits::default())?;
/// assert!(matches!(
///     native[0],
///     DrawCommand::Fill {
///         rule: FillRule::NonZero,
///         ..
///     }
/// ));
/// let even = DrawContext::default().record(
///     &fill.fill_rule(FillRule::EvenOdd),
///     ValidationLimits::default(),
/// )?;
/// assert!(matches!(
///     even[0],
///     DrawCommand::Fill {
///         rule: FillRule::EvenOdd,
///         ..
///     }
/// ));
/// # Ok::<(), motion_core::ValidationError>(())
/// ```
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Serialize, serde::Deserialize),
    serde(rename_all = "snake_case")
)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
pub enum FillRule {
    /// Nonzero signed winding count; the default.
    #[default]
    NonZero,
    /// Odd crossing count.
    EvenOdd,
}

/// How linear-premultiplied content becomes a layer's mask coverage.
///
/// Coverage is computed in the compositing color space and clamped
/// to 0..=1 before optional inversion, without altering working colors.
/// Alpha-zero pixels have zero ordinary coverage, even with hidden extended
/// RGB; inverted modes therefore retain source content at those pixels.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Serialize, serde::Deserialize),
    serde(rename_all = "snake_case")
)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
pub enum MaskMode {
    /// Use only the completed mask's alpha.
    #[default]
    Alpha,
    /// One minus the completed mask's alpha, including transparent artwork.
    InvertedAlpha,
    /// Use Rec.709 luminance of linear premultiplied RGB, already alpha-weighted.
    Luminance,
    /// One minus clamped linear-premultiplied luminance; alpha is not inverted first.
    InvertedLuminance,
}