bevy_animation_graph_editor 0.8.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
156
157
158
159
160
161
162

use std::fmt::Display;

use bevy::{
    asset::Assets,
    ecs::{
        system::{In, ResMut},
        world::World,
    },
    log::error,
    platform::collections::HashMap,
};
use bevy_animation_graph::{
    core::event_track::{EventTrack, TrackItem, TrackItemValue},
    nodes::EventMarkupNode,
    prelude::{AnimationGraph, GraphClip},
};
use uuid::Uuid;

use crate::ui::native_windows::event_track_editor::TargetTracks;

use super::saving::DirtyAssets;

pub enum EventTrackAction {
    NewEvent(NewEventAction),
    NewTrack(NewTrackAction),
    EditEvent(EditEventAction),
}

pub struct NewEventAction {
    pub target_tracks: TargetTracks,
    pub track_id: String,
    pub item: TrackItem,
}

pub struct NewTrackAction {
    pub target_tracks: TargetTracks,
    pub track_id: String,
}

pub struct EditEventAction {
    pub target_tracks: TargetTracks,
    pub track_id: String,
    pub event_id: Uuid,
    pub item: TrackItemValue,
}

pub fn handle_event_track_action(world: &mut World, action: EventTrackAction) {
    match action {
        EventTrackAction::NewEvent(action) => {
            let _ = world
                .run_system_cached_with(handle_new_event_system, action)
                .inspect_err(|err| handle_system_error(err));
        }
        EventTrackAction::NewTrack(action) => {
            let _ = world
                .run_system_cached_with(handle_new_track_system, action)
                .inspect_err(|err| handle_system_error(err));
        }
        EventTrackAction::EditEvent(action) => {
            let _ = world
                .run_system_cached_with(handle_edit_event_system, action)
                .inspect_err(|err| handle_system_error(err));
        }
    }
}

pub fn handle_new_event_system(
    In(action): In<NewEventAction>,
    mut graph_clip_assets: ResMut<Assets<GraphClip>>,
    mut animation_graph_assets: ResMut<Assets<AnimationGraph>>,
    mut dirty_assets: ResMut<DirtyAssets>,
) {
    edit_tracks(
        &action.target_tracks,
        &mut graph_clip_assets,
        &mut animation_graph_assets,
        &mut dirty_assets,
        |t| {
            if let Some(t) = t.get_mut(&action.track_id) {
                t.add_item_preassigned_id(action.item)
            }
        },
    );
}

pub fn handle_new_track_system(
    In(action): In<NewTrackAction>,
    mut graph_clip_assets: ResMut<Assets<GraphClip>>,
    mut animation_graph_assets: ResMut<Assets<AnimationGraph>>,
    mut dirty_assets: ResMut<DirtyAssets>,
) {
    edit_tracks(
        &action.target_tracks,
        &mut graph_clip_assets,
        &mut animation_graph_assets,
        &mut dirty_assets,
        |t| {
            if !t.contains_key(&action.track_id) {
                t.insert(
                    action.track_id.clone(),
                    EventTrack {
                        name: action.track_id,
                        events: Vec::new(),
                    },
                );
            }
        },
    );
}

pub fn handle_edit_event_system(
    In(action): In<EditEventAction>,
    mut graph_clip_assets: ResMut<Assets<GraphClip>>,
    mut animation_graph_assets: ResMut<Assets<AnimationGraph>>,
    mut dirty_assets: ResMut<DirtyAssets>,
) {
    edit_tracks(
        &action.target_tracks,
        &mut graph_clip_assets,
        &mut animation_graph_assets,
        &mut dirty_assets,
        |tracks| {
            if let Some(t) = tracks.get_mut(&action.track_id) {
                t.edit_item(action.event_id, |_| action.item)
            }
        },
    );
}

fn edit_tracks<F, T>(
    target: &TargetTracks,
    graph_clip_assets: &mut Assets<GraphClip>,
    animation_graph_assets: &mut Assets<AnimationGraph>,
    dirty_assets: &mut DirtyAssets,
    f: F,
) -> Option<T>
where
    F: FnOnce(&mut HashMap<String, EventTrack>) -> T,
{
    match target {
        TargetTracks::Clip(handle) => {
            dirty_assets.add(handle.clone());
            graph_clip_assets
                .get_mut(handle.id())
                .map(|c| c.event_tracks_mut())
                .map(f)
        }
        TargetTracks::GraphNode { graph, node } => {
            dirty_assets.add(graph.clone());
            animation_graph_assets
                .get_mut(graph.id())
                .and_then(|g| g.nodes.get_mut(node))
                .and_then(|n| n.inner.as_any_mut().downcast_mut::<EventMarkupNode>())
                .map(|n| &mut n.event_tracks)
                .map(f)
        }
    }
}

fn handle_system_error<Err: Display>(err: Err) {
    error!("Failed to apply event track action: {}", err);
}