Enum ClipPath 

pub enum ClipPath {
    None,
    Inset {
        top: LengthPercentage,
        right: LengthPercentage,
        bottom: LengthPercentage,
        left: LengthPercentage,
        radius: Option<BorderRadius>,
    },
    Circle {
        radius: LengthPercentage,
        origin: Option<TransformOrigin>,
    },
    Ellipse {
        rx: LengthPercentage,
        ry: LengthPercentage,
        origin: Option<TransformOrigin>,
    },
    Polygon {
        points: Vec<(LengthPercentage, LengthPercentage)>,
    },
    Path {
        d: String,
    },
    Blob {
        radius: LengthPercentage,
        origin: Option<TransformOrigin>,
        lobes: u32,
        wobble: f32,
        seed: u32,
    },
    NodePath {
        id: String,
    },
    Morph {
        from: Box<ClipPath>,
        to: Box<ClipPath>,
        via: Vec<ClipPath>,
        progress: f32,
    },
}

Variants

None

Inset

Fields

top: LengthPercentage

right: LengthPercentage

bottom: LengthPercentage

left: LengthPercentage

radius: Option<BorderRadius>

Circle

Fields

radius: LengthPercentage

origin: Option<TransformOrigin>

Ellipse

Fields

rx: LengthPercentage

ry: LengthPercentage

origin: Option<TransformOrigin>

Polygon

Fields

points: Vec<(LengthPercentage, LengthPercentage)>

Path

Fields

d: String

Blob

A procedurally generated organic silhouette — the same wobbling-lobe shape a blob scene transition grows across a whole cut, scoped here to one element’s own clip instead. lobes control points sit around a circle of radius, each nudged radially by a deterministic noise scaled by wobble and picked by seed; the same three values reproduce the same silhouette, byte for byte. wobble: 0 degenerates to a plain circle, the same way radius alone does for circle.

Fields

radius: LengthPercentage

origin: Option<TransformOrigin>

lobes: u32

How many lobes the silhouette grows. Same field as transition.lobes.

wobble: f32

How far each lobe’s radius wanders from a perfect circle, as a fraction of it. Same field as transition.wobble.

seed: u32

Stable selector for the lobe noise, same selector as pixel_dissolve.seed and transition.seed.

NodePath

Clip to another node’s own path geometry, by id, instead of a literal d frozen at author time. The motivating shape: two copies of the same gem, each clipped by the same animated “crack” node, so the two halves separate along a coherent, shared edge — a literal ClipPath::Path on each copy could not track the crack’s own animation without duplicating it (and letting the two drift out of sync the moment one copy’s d is edited and the other isn’t).

This mirrors node("id", "prop") in crate::expr’s grammar, which reads another node’s already-resolved scalar through Scope::node_prop; this variant instead names a node whose geometry (its own resolved path — a shape with ShapeType::Path, most naturally) should be read, so the (id, prop) pair that call uses does not apply — id alone is enough to say which node.

Resolving id into an actual clip (finding the node, reading its current-frame path, intersecting the canvas clip with it) is the paint pipeline’s job, not this enum’s — same division as every other ClipPath variant, none of which carry their own clipping logic either.

Fields

id: String

Morph

A shape that sweeps continuously from from to to as progress goes 0.0 → 1.0 (#384) — the chamfered-wall-style beat where the clip itself is the animation, not a transform riding on top of a frozen shape.

progress is meant to be driven by an ordinary keyframes animation on the clip_path_progress property (see KNOWN_MOTION_PROPERTIES); the literal value here is only the resting position when nothing animates it.

from and to must be the same variant — and, for polygon, the same vertex count — for the paint pass to have a correspondence to interpolate along. A mismatch is reported on stderr and the node is left unclipped for that frame; see engine::paint_pass::morph_clip_path_to_skia.

Fields

from: Box<ClipPath>

to: Box<ClipPath>

via: Vec<ClipPath>

Shapes the morph passes through on its way from from to to, in order. Empty means a direct two-shape sweep, which is what a morph without this field has always been.

progress spans the whole chain, not each leg: with one via shape, 0.5 is exactly that shape.

progress: f32

Trait Implementations

impl Clone for ClipPath

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClipPath

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClipPath

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ClipPath

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for ClipPath

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ClipPath

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ClipPath