aura-anim-iced 0.2.1

Iced-first animation 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

use crate::{
    TransformValue,
    property::{self, PropertySnapshot, PropertyValue},
    runtime::{AnimationTargetId, AnimationTick},
};

/// View-friendly effects extracted from sampled animation properties.
///
/// # Example
///
/// ```
/// use aura_anim_iced::{
///     EffectSnapshot,
///     property::{self, PropertySnapshot},
/// };
///
/// let properties = PropertySnapshot::from(vec![
///     (property::OPACITY, 0.75),
///     (property::SCALE, 1.02),
/// ]);
/// let effects = EffectSnapshot::from_properties(&properties);
///
/// assert_eq!(effects.opacity, Some(0.75));
/// assert_eq!(effects.scale, Some(1.02));
/// ```
#[derive(Debug, Clone, PartialEq, Default)]
pub struct EffectSnapshot {
    /// Element opacity.
    pub opacity: Option<f32>,
    /// Element width.
    pub width: Option<f32>,
    /// Element height.
    pub height: Option<f32>,
    /// Element padding.
    pub padding: Option<f32>,
    /// Element translation.
    pub translation: Option<iced::Vector>,
    /// Element transform.
    pub transform: Option<TransformValue>,
    /// Element rotation.
    pub rotate: Option<f32>,
    /// Element scale.
    pub scale: Option<f32>,
    /// Element radius.
    pub radius: Option<f32>,
    /// Element background color.
    pub background: Option<iced::Color>,
    /// Element border color.
    pub border_color: Option<iced::Color>,
    /// Element text color.
    pub text_color: Option<iced::Color>,
    /// Element shadow.
    pub shadow: Option<iced::Shadow>,
}

impl EffectSnapshot {
    /// Extracts view-friendly effects from sampled properties.
    #[must_use]
    pub fn from_properties(properties: &PropertySnapshot) -> Self {
        let mut effects = Self::default();

        for entry in properties.entries() {
            match entry.value() {
                PropertyValue::Scalar(value) if *entry.spec() == property::OPACITY.raw() => {
                    effects.opacity = Some(*value);
                }
                PropertyValue::Scalar(value) if *entry.spec() == property::WIDTH.raw() => {
                    effects.width = Some(*value);
                }
                PropertyValue::Scalar(value) if *entry.spec() == property::HEIGHT.raw() => {
                    effects.height = Some(*value);
                }
                PropertyValue::Scalar(value) if *entry.spec() == property::PADDING.raw() => {
                    effects.padding = Some(*value);
                }
                PropertyValue::Scalar(value) if *entry.spec() == property::ROTATE.raw() => {
                    effects.rotate = Some(*value);
                }
                PropertyValue::Transform(value) if *entry.spec() == property::TRANSFORM.raw() => {
                    effects.transform = Some(*value);
                }
                PropertyValue::Vector2(value) if *entry.spec() == property::TRANSLATE.raw() => {
                    effects.translation = Some(*value);
                }
                PropertyValue::Scalar(value) if *entry.spec() == property::SCALE.raw() => {
                    effects.scale = Some(*value);
                }
                PropertyValue::Scalar(value) if *entry.spec() == property::RADIUS.raw() => {
                    effects.radius = Some(*value);
                }
                PropertyValue::Color(value) if *entry.spec() == property::BACKGROUND.raw() => {
                    effects.background = Some(*value);
                }
                PropertyValue::Color(value) if *entry.spec() == property::BORDER_COLOR.raw() => {
                    effects.border_color = Some(*value);
                }
                PropertyValue::Color(value) if *entry.spec() == property::TEXT_COLOR.raw() => {
                    effects.text_color = Some(*value);
                }
                PropertyValue::Shadow(value) if *entry.spec() == property::SHADOW.raw() => {
                    effects.shadow = Some(*value);
                }
                _ => {}
            }
        }

        effects
    }

    /// Extracts view-friendly effects from a runtime tick for one target.
    #[must_use]
    pub fn from_tick_for(tick: &AnimationTick, target: AnimationTargetId) -> Self {
        tick.properties_for(target)
            .map(Self::from_properties)
            .unwrap_or_default()
    }

    /// Returns whether no effect was extracted.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self == &Self::default()
    }
}

/// Extracts view-friendly effects from sampled properties.
#[must_use]
pub fn effect_snapshot(properties: &PropertySnapshot) -> EffectSnapshot {
    EffectSnapshot::from_properties(properties)
}

/// Extracts view-friendly effects from a runtime tick for one target.
#[must_use]
pub fn tick_effect_snapshot_for(tick: &AnimationTick, target: AnimationTargetId) -> EffectSnapshot {
    EffectSnapshot::from_tick_for(tick, target)
}