cranpose-liquid 0.9.39

Glass controls, themes and motion for Cranpose apps
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

use std::{cell::RefCell, rc::Rc};

use cranpose_animation::{Animatable, spring};
use cranpose_core::{RuntimeHandle, State, with_current_composer};
use cranpose_macros::composable;

#[derive(Clone, Copy, PartialEq)]
pub(super) enum ControlContactKind {
    Thumb,
    Segment,
}

pub(super) struct ControlContactMotion {
    channels: RefCell<[Animatable<f32>; 2]>,
    runtime: RuntimeHandle,
    kind: ControlContactKind,
}

impl ControlContactMotion {
    fn new(runtime: RuntimeHandle, kind: ControlContactKind) -> Self {
        Self {
            channels: RefCell::new([
                Animatable::new(0.0, runtime.clone()),
                Animatable::new(0.0, runtime.clone()),
            ]),
            runtime,
            kind,
        }
    }

    pub(super) fn states(&self) -> (State<f32>, State<f32>) {
        let channels = self.channels.borrow();
        (channels[0].state(), channels[1].state())
    }

    pub(super) fn pressed(&self, down: bool, event_time: Option<u64>) {
        let geometry = match (self.kind, down) {
            (ControlContactKind::Thumb, true) => spring(0.55, 600.0),
            (ControlContactKind::Thumb, false) => spring(0.7, 170.0),
            (ControlContactKind::Segment, true) => spring(1.0, 600.0),
            (ControlContactKind::Segment, false) => spring(1.0, 650.0),
        };
        let material = if down { geometry } else { spring(1.0, 250.0) };
        let time = event_time.or_else(|| self.runtime.last_frame_time_nanos());
        for (channel, animation) in self
            .channels
            .borrow_mut()
            .iter_mut()
            .zip([geometry, material])
        {
            let target = f32::from(down);
            if channel.target() != target {
                if let Some(time) = time {
                    channel.animate_to_at(target, animation, time);
                } else {
                    channel.animateTo(target, animation);
                }
            }
        }
    }
}

#[composable]
pub(super) fn remember_control_contact(kind: ControlContactKind) -> Rc<ControlContactMotion> {
    with_current_composer(|composer| {
        let runtime = composer.runtime_handle();
        composer
            .remember(move || Rc::new(ControlContactMotion::new(runtime, kind)))
            .with(Rc::clone)
    })
}

#[cfg(test)]
#[path = "tests/control_motion_tests.rs"]
mod tests;