motion-canvas-rs 0.2.3

A high-performance vector animation engine inspired by Motion Canvas, built on Vello and Typst.
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

use crate::core::animation::{Node, Signal};
use crate::elements::physics::traits::PhysicsBody;
use crate::elements::physics::{PhysicsMode, RigidBodyNode, StaticBodyNode};
use glam::Vec2;
use kurbo::Affine;
use rapier2d::prelude::{ColliderSet, RigidBody};
use std::time::Duration;

#[cfg(feature = "runtime")]
use vello::Scene;

/// Internal composite enum representing physical wrapper nodes registered in the engine.
#[derive(Clone)]
pub enum BodyWrapper {
    /// A dynamic/kinematic rigid body wrapper.
    Dynamic(RigidBodyNode),
    /// A static fixed body wrapper.
    Static(StaticBodyNode),
}

impl Node for BodyWrapper {
    #[cfg(feature = "runtime")]
    fn render(&self, scene: &mut Scene, parent_transform: Affine, parent_opacity: f32) {
        match self {
            BodyWrapper::Dynamic(n) => n.render(scene, parent_transform, parent_opacity),
            BodyWrapper::Static(n) => n.render(scene, parent_transform, parent_opacity),
        }
    }

    fn update(&mut self, dt: Duration) {
        match self {
            BodyWrapper::Dynamic(n) => n.update(dt),
            BodyWrapper::Static(n) => n.update(dt),
        }
    }

    fn state_hash(&self) -> u64 {
        match self {
            BodyWrapper::Dynamic(n) => n.state_hash(),
            BodyWrapper::Static(n) => n.state_hash(),
        }
    }

    fn clone_node(&self) -> Box<dyn Node> {
        match self {
            BodyWrapper::Dynamic(n) => Box::new(n.clone()),
            BodyWrapper::Static(n) => Box::new(n.clone()),
        }
    }

    fn reset(&mut self) {
        match self {
            BodyWrapper::Dynamic(n) => n.reset(),
            BodyWrapper::Static(n) => n.reset(),
        }
    }
}

impl PhysicsBody for BodyWrapper {
    fn mode(&self) -> PhysicsMode {
        match self {
            BodyWrapper::Dynamic(n) => n.mode(),
            BodyWrapper::Static(n) => n.mode(),
        }
    }

    fn position_signal(&self) -> &Signal<Vec2> {
        match self {
            BodyWrapper::Dynamic(n) => n.position_signal(),
            BodyWrapper::Static(n) => n.position_signal(),
        }
    }

    fn rotation_signal(&self) -> &Signal<f32> {
        match self {
            BodyWrapper::Dynamic(n) => n.rotation_signal(),
            BodyWrapper::Static(n) => n.rotation_signal(),
        }
    }

    fn sync_to_rapier(&mut self, rb: &mut RigidBody, collider_set: &mut ColliderSet) {
        match self {
            BodyWrapper::Dynamic(n) => n.sync_to_rapier(rb, collider_set),
            BodyWrapper::Static(n) => n.sync_to_rapier(rb, collider_set),
        }
    }
}