bevy_motiongfx 0.2.0

An implementation of the MotionGfx framework for Bevy.
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

use bevy_ecs::component::Mutable;
use bevy_ecs::prelude::*;
use motiongfx::prelude::*;

pub type WorldPipelineRegistry = PipelineRegistry<World>;
pub type WorldPipeline = Pipeline<World>;

pub fn bake_component_actions<S, T>(world: &World, ctx: BakeCtx)
where
    S: Component,
    T: Clone + ThreadSafe,
{
    ctx.bake::<Entity, S, T>(|entity| world.get::<S>(entity));
}

pub fn sample_component_actions<S, T>(
    world: &mut World,
    ctx: SampleCtx,
) where
    S: Component<Mutability = Mutable>,
    T: Clone + ThreadSafe,
{
    ctx.sample::<Entity, S, T>(|entity, target, accessor| {
        if let Some(mut source) = world.get_mut::<S>(entity) {
            *accessor.get_mut(&mut source) = target;
        }
    });
}

#[cfg(feature = "asset")]
pub fn bake_asset_actions<S, T>(world: &World, ctx: BakeCtx)
where
    S: bevy_asset::Asset,
    T: Clone + ThreadSafe,
{
    use bevy_asset::Assets;
    use bevy_asset::UntypedAssetId;

    let Some(assets) = world.get_resource::<Assets<S>>() else {
        return;
    };

    ctx.bake::<UntypedAssetId, S, T>(|asset_id| {
        assets.get(asset_id.typed::<S>())
    });
}

#[cfg(feature = "asset")]
pub fn sample_asset_actions<S, T>(world: &mut World, ctx: SampleCtx)
where
    S: bevy_asset::Asset,
    T: Clone + ThreadSafe,
{
    use bevy_asset::Assets;
    use bevy_asset::UntypedAssetId;

    let Some(mut assets) = world.get_resource_mut::<Assets<S>>()
    else {
        return;
    };

    ctx.sample::<UntypedAssetId, S, T>(
        |asset_id, target, accessor| {
            if let Some(source) =
                assets.get_mut(asset_id.typed::<S>())
            {
                *accessor.get_mut(source) = target;
            }
        },
    );
}

pub trait PipelineRegistryExt {
    fn register_component<S, T>(&mut self) -> PipelineKey
    where
        S: Component<Mutability = Mutable>,
        T: Clone + ThreadSafe;

    #[cfg(feature = "asset")]
    fn register_asset<S, T>(&mut self) -> PipelineKey
    where
        S: bevy_asset::Asset,
        T: Clone + ThreadSafe;
}

impl PipelineRegistryExt for WorldPipelineRegistry {
    fn register_component<S, T>(&mut self) -> PipelineKey
    where
        S: Component<Mutability = Mutable>,
        T: Clone + ThreadSafe,
    {
        let key = PipelineKey::new::<Entity, S, T>();

        self.register_unchecked(
            key,
            WorldPipeline::new(
                bake_component_actions::<S, T>,
                sample_component_actions::<S, T>,
            ),
        );

        key
    }

    #[cfg(feature = "asset")]
    fn register_asset<S, T>(&mut self) -> PipelineKey
    where
        S: bevy_asset::Asset,
        T: Clone + ThreadSafe,
    {
        use bevy_asset::UntypedAssetId;

        let key = PipelineKey::new::<UntypedAssetId, S, T>();

        self.register_unchecked(
            key,
            WorldPipeline::new(
                bake_asset_actions::<S, T>,
                sample_asset_actions::<S, T>,
            ),
        );

        key
    }
}