Struct ShatterConfig 

pub struct ShatterConfig {
    pub delay: f64,
    pub duration: f64,
    pub mode: ShatterMode,
    pub pieces: u32,
    pub seed: u32,
    pub origin: ShatterOrigin,
    pub spread: f32,
    pub spin: f32,
    pub depth: f32,
    pub fade: bool,
}

Configuration for the shatter animation effect: the node’s own rendered subtree — background, border, content and children, exactly as it would have painted — is rasterised once, cut into pieces convex cells by a deterministic Voronoi partition seeded by seed, and each cell is flown away from origin, spun and faded independently.

seed and the sampled instant fully determine every shard’s cell, direction, spin and depth — two renders of the same file at the same time are byte-identical.

mode decides which end of the timeline is the intact node and which is the fully dispersed one, and what happens once delay + duration has elapsed:

• "out" (default): assembled at delay, fully dispersed at delay + duration. Outside [delay, delay + duration) the effect contributes nothing at all — the node renders byte-identically to one with no shatter effect in its animation list, the same hard short-circuit chromatic_aberration and zoom_blur use rather than a fade that only gets close to zero.
• "in" is the mirror: dispersed at delay, assembled at delay + duration, and — like "out" — outside its window the node renders as if the effect were absent.
• "hold" plays the same dispersal as "out" but freezes at the fully dispersed state once delay + duration is reached instead of short-circuiting back to the plain node — it legitimately never converges.

Fields

delay: f64

Delay before the shards start moving (seconds).

duration: f64

How long the dispersal (or, in "in" mode, the assembly) takes (seconds).

mode: ShatterMode

Which end of the timeline is intact and what happens after delay + duration. See the type-level doc comment.

pieces: u32

Number of Voronoi shards (default 24, clamped 1..=64).

seed: u32

Seed for the deterministic Voronoi partition and every shard’s direction/spin/depth jitter.

origin: ShatterOrigin

Point shards fly away from (or, in "in" mode, converge toward), as a fraction of the node’s own box ({ "x": 0.5, "y": 0.5 } is the centre, the default).

spread: f32

Radial travel multiplier at full dispersal, relative to the node’s own diagonal (default 1.0). 0 pins shards in place — only spin, depth and fade remain visible.

spin: f32

Maximum rotation in degrees a shard reaches at full dispersal (default 90); each shard’s own sign and magnitude are jittered from seed.

depth: f32

Per-shard scale modulation at full dispersal, the same “0.0 = none” semantics as OrbitConfig::depth (default 0.4): each shard’s own signed depth is jittered from seed, so some shards appear to come toward the camera (scale > 1) while others recede (scale < 1).

fade: bool

Fade each shard’s opacity to zero as it reaches full dispersal (default true). With mode: "in" this is a mirror: shards start transparent and reach full opacity as they assemble.

Trait Implementations

impl Clone for ShatterConfig

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 ShatterConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShatterConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ShatterConfig

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 ShatterConfig

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ShatterConfig

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 ShatterConfig