Struct Shadow 

pub struct Shadow {
    pub offset: (f32, f32),
    pub blur: f32,
    pub spread: f32,
    pub color: Color,
}

Shadow configuration for shapes

Fields

offset: (f32, f32)

Shadow offset in logical pixels (x, y)

blur: f32

Blur radius in logical pixels

spread: f32

Spread amount in logical pixels (expands shadow)

color: Color

Shadow color

Implementations

impl Shadow

pub const fn new( offset: (f32, f32), blur: f32, spread: f32, color: Color, ) -> Self

Create a shadow with the given parameters.

const, along with simple and none, so an application can write its own ladder of shadows down as constants — which is where a design system’s elevation scale lives now that the library ships no table of its own.

pub fn extent(&self) -> f32

How far this shadow reaches past the box that casts it.

The amount the damage rect has to grow by, so repainting the box also re-composites the shadow instead of leaving the old one behind: signed_extent floored at zero, since a shadow pulled inside its box reaches nothing past it.

pub fn scaled(self, k: f32) -> Self

The same shadow, every length multiplied by k.

The colour does not scale — a shadow made smaller should be smaller, not fainter — and neither does the alpha extent gates on, so scaled(k).extent() == extent() * k for any k >= 0. That identity is what shrunk_to rests on, and it is why the two live beside extent rather than beside either caller: add a constant term to extent and both stop holding, here, where it is tested.

Two callers, one rule: the HiDPI pass multiplies a shadow by the surface scale before it reaches the instance buffer, and a container shrinks one to fit the damage rect its layout reserved.

pub fn shrunk_to(self, reach: f32) -> Self

This shadow, shrunk until it reaches no further than reach past its box.

Uniform, so the shape survives rather than the shadow collapsing along one axis. A shadow already inside the rect is returned untouched, and so is one whose extent is not a positive number — which is what answers a NaN field, since every comparison against it is false. A reach below zero counts as zero, so the factor is never above one or below zero.

pub const fn simple(offset: (f32, f32), blur: f32, color: Color) -> Self

Create a shadow with no spread

pub const fn none() -> Self

Create a default shadow (no shadow)

Trait Implementations

impl Animatable for Shadow

fn is_reverse(from: &Self, to: &Self) -> bool

Shrinking, and then fading at a constant size.

Shadow::signed_extent is the same reduction the damage rect is sized by, so “reverse” here means the same thing it means to everything downstream: the shadow is giving ground back. Alpha breaks the tie because the extent reports the full reach at any alpha above zero, so a shadow fading out at a constant geometry would otherwise read as forward in both directions.

The ties this keeps are the ones that trade one dimension for another — a blur of 4 becoming a spread of 8, an offset moving from down to sideways. Both reduce to the same extent, and neither is larger.

Showing comes before size: a transparent shadow measures zero, which is above every shadow pulled inside its box, so by extent alone fading one of those out would read as growing.

fn lerp(from: &Self, to: &Self, t: f32) -> Self

Linear interpolation between two values t = 0.0 returns from, t = 1.0 returns to t can exceed [0, 1] range for overshoot effects

fn channels(&self) -> Channels

The value as the vector of numbers the animation interpolates.

impl Clone for Shadow

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Shadow

impl Debug for Shadow

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

Formats the value using the given formatter.

impl PartialEq for Shadow

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Shadow