bevy_manim 0.1.0

bevy plugin for drawing and animation
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

pub mod emergence;
pub mod highlight;
pub mod delete;
pub mod transform;
pub mod funcs;

#[macro_export]
macro_rules! define_animation
{
    ($name:ident, $anim_name:ident $(,)?
    $($field:ident: $ftype:ty = $fdef:expr),* $(,)?) =>
    {
        use $crate::core::
        {
            ProgressFunc,
            Vertex,
            Indices,
            Color,
            AnimationKind,
            PackedAnimation,
            DEFAULT_PROGRESS_FUNC
        };
        use $crate::draw::Tessellation;
        use std::sync::{Arc, Mutex};

        #[derive(Clone, Debug)]
        pub struct $name
        {
            pub progress: f32,
            pub func: ProgressFunc,
            $(
                pub $field: $ftype,
            )*
        }

        impl Default for $name
        {
            fn default() -> Self
            {
                Self
                {
                    progress: 0.0,
                    func: DEFAULT_PROGRESS_FUNC,
                    $(
                        $field: $fdef,
                    )*
                }
            }
        }

        impl AnimationKind for $name
        {
            fn generate
                (
                    self,
                    tessellation: Tessellation
                ) -> PackedAnimation
                {
                    Arc::new(
                    Mutex::new(
                        $anim_name
                        {
                            tessellation, data: self
                        }
                    ))
                }
        }

        #[derive(Debug, Clone, Default)]
        pub(crate) struct $anim_name
        {
            tessellation: Tessellation,
            data: $name,
        }

    };
}

pub mod dummy
{
    use crate::core::Animation;

    define_animation!(Dummy, DummyAnimation);

    impl Animation for DummyAnimation
    {
        #[inline]
        fn set_progress(&mut self, progress: f32) { self.data.progress = progress }

        #[inline]
        fn get_progress(&self) -> f32 { self.data.progress }

        #[inline]
        fn get_vertices(&self) -> Vec<Vertex> { self.tessellation.vertices.clone() }

        #[inline]
        fn get_indices(&self) -> Indices { self.tessellation.indices.clone() }

        #[inline]
        fn get_colors(&self) -> Vec<Color> { self.tessellation.colors.clone() }
    }
}