bevy_animation_graph_editor 0.9.0

Animation graph editor for the Bevy game engine
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use bevy::{
    asset::{AssetId, Assets, Handle},
    ecs::{
        resource::Resource,
        system::{In, ResMut},
        world::World,
    },
    platform::collections::HashMap,
};
use bevy_animation_graph::{
    builtin_nodes::clip_node::ClipNode,
    core::{
        animated_scene::AnimatedScene,
        animation_clip::GraphClip,
        animation_graph::{AnimationGraph, NodeId, PinId, SourcePin, TargetPin},
        animation_node::AnimationNode,
        edge_data::DataSpec,
    },
};

use super::{DynamicAction, run_handler};
use crate::ui::actions::ActionContext;

#[derive(Resource, Default)]
pub struct ClipPreviewScenes {
    pub previews: HashMap<AssetId<GraphClip>, Handle<AnimatedScene>>,
}

#[derive(Resource, Default)]
pub struct NodePreviewScenes {
    pub previews: HashMap<NodePreviewKey, Handle<AnimatedScene>>,
}

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct NodePreviewKey {
    pub graph: AssetId<AnimationGraph>,
    pub node_id: NodeId,
    pub pose_pin: PinId,
}

#[derive(Clone)]
pub struct CreateClipPreview {
    /// Clip to preview
    pub clip: Handle<GraphClip>,
    /// On what scene do you want to preview the clip? This will create a new scene that overrides
    /// its animation graph
    pub scene: Handle<AnimatedScene>,
}

impl DynamicAction for CreateClipPreview {
    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
        run_handler(world, "Could not create clip preview")(Self::system, *self)
    }
}

impl CreateClipPreview {
    pub fn system(
        In(action): In<Self>,
        mut previews: ResMut<ClipPreviewScenes>,
        mut graph_assets: ResMut<Assets<AnimationGraph>>,
        mut scene_assets: ResMut<Assets<AnimatedScene>>,
    ) {
        if previews.previews.contains_key(&action.clip.id()) {
            return;
        }

        let mut new_graph = AnimationGraph::new();
        let clip_node = AnimationNode::new("clip", ClipNode::new(action.clip.clone(), None, None));
        let clip_node_id = clip_node.id;
        new_graph.add_node(clip_node);

        new_graph.add_output_data("pose".into(), DataSpec::Pose);
        new_graph.add_output_time();

        new_graph.add_edge(
            SourcePin::NodeData(clip_node_id, ClipNode::OUT_POSE.into()),
            TargetPin::OutputData("pose".into()),
        );
        new_graph.add_edge(SourcePin::NodeTime(clip_node_id), TargetPin::OutputTime);

        let graph_handle = graph_assets.add(new_graph);

        let Some(mut scene) = scene_assets.get(&action.scene).cloned() else {
            return;
        };

        scene.processed_scene = None;
        scene.animation_graph = graph_handle;

        let scene_handle = scene_assets.add(scene);

        previews.previews.insert(action.clip.id(), scene_handle);
    }
}

#[derive(Clone)]
pub struct CreateTrackNodePreview {
    pub preview_key: NodePreviewKey,
    /// On what scene do you want to preview the clip? This will create a new scene that overrides
    /// its animation graph
    pub scene: Handle<AnimatedScene>,
}

impl DynamicAction for CreateTrackNodePreview {
    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
        run_handler(world, "Could not create clip preview")(Self::system, *self)
    }
}

impl CreateTrackNodePreview {
    pub fn system(
        In(action): In<Self>,
        mut previews: ResMut<NodePreviewScenes>,
        mut graph_assets: ResMut<Assets<AnimationGraph>>,
        mut scene_assets: ResMut<Assets<AnimatedScene>>,
    ) {
        if previews.previews.contains_key(&action.preview_key) {
            return;
        }

        let Some(existing_graph) = graph_assets.get(action.preview_key.graph) else {
            return;
        };

        let mut new_graph = existing_graph.clone();

        new_graph.add_output_data("pose".into(), DataSpec::Pose);
        new_graph.add_output_time();

        new_graph.add_edge(
            SourcePin::NodeData(
                action.preview_key.node_id,
                action.preview_key.pose_pin.clone(),
            ),
            TargetPin::OutputData("pose".into()),
        );
        new_graph.add_edge(
            SourcePin::NodeTime(action.preview_key.node_id),
            TargetPin::OutputTime,
        );

        let graph_handle = graph_assets.add(new_graph);

        let Some(mut scene) = scene_assets.get(&action.scene).cloned() else {
            return;
        };

        scene.processed_scene = None;
        scene.animation_graph = graph_handle;

        let scene_handle = scene_assets.add(scene);

        previews.previews.insert(action.preview_key, scene_handle);
    }
}