bevy_animation_graph_editor 0.10.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

use std::{
    any::{Any, TypeId},
    marker::PhantomData,
};

use bevy::asset::{Asset, AssetServer, Assets, Handle};
use bevy_inspector_egui::reflect_inspector::InspectorUi;
use egui_dock::egui;

use super::{EguiInspectorExtension, MakeBuffer};
use crate::ui::utils::asset_sort_key;

pub struct AssetPickerInspector<T> {
    _marker: PhantomData<T>,
}

impl<T> Default for AssetPickerInspector<T> {
    fn default() -> Self {
        Self {
            _marker: PhantomData,
        }
    }
}

impl<T: Asset> EguiInspectorExtension for AssetPickerInspector<T> {
    type Base = Handle<T>;
    type Buffer = ();

    fn mutable(
        value: &mut Self::Base,
        _: &mut Self::Buffer,
        ui: &mut egui::Ui,
        _options: &dyn Any,
        id: egui::Id,
        env: InspectorUi<'_, '_>,
    ) -> bool {
        let value_id = value.id();

        let Some(world) = env.context.world.as_mut() else {
            return false;
        };
        let (mut world_t_assets, world) = world.split_off_resource(TypeId::of::<Assets<T>>());
        let Ok(t_assets) = world_t_assets.get_resource_mut::<Assets<T>>() else {
            return false;
        };
        let Some((asset_server, _)) = world.split_off_resource_typed::<AssetServer>() else {
            return false;
        };

        let mut selected = value_id;

        egui::ComboBox::from_id_salt(id)
            .selected_text(if t_assets.contains(selected) {
                asset_server
                    .get_path(selected)
                    .map(|p| p.path().to_string_lossy().into())
                    .unwrap_or("Unsaved Asset".to_string())
            } else {
                "None".to_string()
            })
            .show_ui(ui, |ui| {
                let mut assets_ids: Vec<_> = t_assets.ids().collect();
                assets_ids.sort_by_key(|id| asset_sort_key(*id, &asset_server));
                for asset_id in assets_ids {
                    ui.selectable_value(
                        &mut selected,
                        asset_id,
                        asset_server
                            .get_path(asset_id)
                            .unwrap_or_default()
                            .path()
                            .to_str()
                            .unwrap_or_default(),
                    );
                }
            });
        if selected != value_id {
            *value = asset_server.get_id_handle(selected).unwrap();
            true
        } else {
            false
        }
    }

    fn readonly(
        _value: &Self::Base,
        buffer: &Self::Buffer,
        ui: &mut egui::Ui,
        _options: &dyn Any,
        id: egui::Id,
        mut env: InspectorUi<'_, '_>,
    ) {
        env.ui_for_reflect_readonly_with_options(buffer, ui, id, &());
    }
}

impl<T: Asset> AssetPickerInspector<T> {}

impl<T: Asset> MakeBuffer<()> for Handle<T> {
    fn make_buffer(&self) {}
}