pop
/
monologue-trees
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Loading animations w/ button

Browse Source
main
Elijah Voigt 2 years ago
parent 434965cdf3
commit e159346b89
2 changed files with 284 additions and 62 deletions
Show Stats Download Patch File Download Diff File

250
bin/editor.rs
Unescape Escape View File

@ -1,10 +1,26 @@
// Monologue Trees Editor
//
// Editor for creating Monologue Trees levels
//
// TODO:
// * Tree Organization: GLTF contains Animations and Scenes
// * Camera can only select one at a time.
// * (easy) Load audios like current GLTFs
// * (easy) Loop audio enable/disable
// * (easy) Better Colorscheme
// * (easy) Interactive buttons (hover/click)
// * (medium) Visual errors for bad GLTFs
// * (medium) Collapsable containers (Gltfs, Animations, Scenes, Audio Clips, Cameras)
// * (medium) Spawn clicked scene
// * (medium) Play clicked animation
// * (idea) Use enum instead of markers for exclusive UI
use bevy::{
asset::{AssetPath, Assets},
gltf::Gltf,
input::{keyboard::KeyboardInput, ButtonState},
prelude::*,
utils::HashSet,
};
use monologue_trees::{debug::*, ui::*};
@ -22,24 +38,43 @@ fn main() {
DebugInfoPlugin,
GameUiPlugin,
))
.init_resource::<AssetRegistry>()
.add_systems(Startup, (initialize_ui,))
.add_systems(
Update,
(
// GLTF Systems
load_gltf,
unload_gltf,
manage_gltf_ui,
// Scene Systems
manage_scene_ui,
spawn_scene,
// Animation systems
manage_animation_ui,
// Camera systems
manage_camera_ui,
// Audio Systems
load_audio,
unload_audio,
spawn_scene,
play_audio,
// Level Import/Export systems
export_level,
import_level,
// Misc/Debug Systems
load_bogus,
),
)
.run();
}
/// A generic referenece used for UI elements to point to assets or entities
#[derive(Debug, Component)]
enum UiRef<T> {
Handle(T),
Entity(T),
}
/// UI:
/// * GLTFs
/// * Scenes
@ -62,16 +97,36 @@ fn initialize_ui(mut commands: Commands) {
..default()
})
.with_children(|parent| {
parent.spawn((GameUiList("GLTFs"), NodeBundle { ..default() }, GltfsUi));
parent.spawn((GameUiList("Scenes"), NodeBundle { ..default() }, ScenesUi));
parent.spawn((GameUiList("Cameras"), NodeBundle { ..default() }, CamerasUi));
parent.spawn((
GameUiList("Animations"),
NodeBundle { ..default() },
AnimationsUi,
));
parent
.spawn((
GameUiList,
Name::new("GLTFs"),
NodeBundle { ..default() },
GltfsUi,
))
.with_children(|parent| {
parent.spawn((
GameUiList,
Name::new("Scenes"),
NodeBundle { ..default() },
ScenesUi,
));
parent.spawn((
GameUiList,
Name::new("Cameras"),
NodeBundle { ..default() },
CamerasUi,
));
parent.spawn((
GameUiList,
Name::new("Animations"),
NodeBundle { ..default() },
AnimationsUi,
));
});
parent.spawn((
GameUiSet("Audio Clips"),
GameUiSet,
Name::new("Audio Clips"),
NodeBundle { ..default() },
AudioClipsUi,
));
@ -92,32 +147,195 @@ fn load_bogus(
)
.for_each(|_| {
commands
.spawn((GameUiButton("bogus"), NodeBundle { ..default() }))
.spawn((GameUiButton, Name::new("bogus"), NodeBundle { ..default() }))
.set_parent(root.single());
})
}
#[derive(Resource, Default, Debug)]
struct AssetRegistry(HashSet<HandleUntyped>);
/// Component marking UI for loaded Gltf assets
#[derive(Component)]
struct GltfsUi;
/// Drag+Drop import GLTF to editor
fn load_gltf(
mut events: EventReader<FileDragAndDrop>,
server: Res<AssetServer>,
mut assets: ResMut<AssetRegistry>,
) {
events
.iter()
.filter_map(|event| match event {
FileDragAndDrop::DroppedFile { path_buf, .. } => Some(path_buf),
_ => None,
})
.for_each(|path_buf| {
let path = path_buf.as_path();
let handle = server.load_untyped(path);
assets.0.insert(handle);
});
}
/// Helper method to extract the stripped filename given a full asset path
fn get_fname(asset_path: AssetPath, suffixes: &[&str]) -> String {
let path = asset_path.path().file_name().expect("Filename");
let path_str = path.to_str().expect("Asset Path to Str");
let name_str = suffixes
.iter()
.rfold(path_str, |acc, &suffix| acc.trim_end_matches(suffix));
String::from(name_str)
}
/// Sync GLTF assets with UI
///
/// TODO: Handle failed load events
/// Options:
/// * Show Error message, do not add to UI
/// * Add to UI with visual indicator
/// This should be a separate async system
fn manage_gltf_ui(
mut events: EventReader<AssetEvent<Gltf>>,
root: Query<Entity, With<GltfsUi>>,
mut commands: Commands,
server: Res<AssetServer>,
) {
events
.iter()
.filter_map(|event| match event {
AssetEvent::Created { handle } => {
let asset_path = server
.get_handle_path(handle.clone())
.expect("Fetch Asset Path");
let name = get_fname(asset_path, &[".gltf", ".glb"]);
Some((handle.clone(), String::from(name)))
}
_ => None,
})
.for_each(|(handle, name)| {
commands
.spawn((
GameUiButton,
Name::new(name),
NodeBundle { ..default() },
GltfsUi,
UiRef::Handle(handle.clone()),
))
.set_parent(root.single());
});
}
/// Remove gltf from editor
fn unload_gltf() {}
/// Component marking UI for Scene assets
#[derive(Component)]
struct ScenesUi;
/// Sync scene assets with UI
fn manage_scene_ui(
mut events: EventReader<AssetEvent<Scene>>,
root: Query<Entity, With<ScenesUi>>,
mut commands: Commands,
gltfs: Res<Assets<Gltf>>,
registry: Res<AssetRegistry>,
) {
events
.iter()
.filter_map(|event| match event {
AssetEvent::Created { handle } => {
let name = registry
.0
.iter()
.find_map(
|gltf_handle| match gltfs.get(&gltf_handle.clone().typed::<Gltf>()) {
Some(gltf) => {
gltf.named_scenes.iter().find_map(|(name, scene_handle)| {
info!(
"scene_handle({:?}) == handle({:?})",
scene_handle, handle
);
(scene_handle == handle).then_some(name)
})
}
None => None,
},
)
.expect("Find scene name");
Some((handle.clone(), String::from(name)))
}
_ => None,
})
.for_each(|(handle, name)| {
commands
.spawn((
GameUiButton,
Name::new(name),
NodeBundle { ..default() },
ScenesUi,
UiRef::Handle(handle.clone()),
))
.set_parent(root.single());
});
}
/// Component marking UI for Camera assets
#[derive(Component)]
struct CamerasUi;
fn manage_camera_ui() {}
/// Component marking UI for Animation assets
#[derive(Component)]
struct AnimationsUi;
/// Drag+Drop import GLTF to editor
fn load_gltf() {}
/// Remove gltf from editor
fn unload_gltf() {}
fn manage_animation_ui(
mut events: EventReader<AssetEvent<AnimationClip>>,
root: Query<Entity, With<AnimationsUi>>,
mut commands: Commands,
gltfs: Res<Assets<Gltf>>,
registry: Res<AssetRegistry>,
) {
events
.iter()
.filter_map(|event| match event {
AssetEvent::Created { handle } => {
let name =
registry
.0
.iter()
.find_map(|gltf_handle| {
match gltfs.get(&gltf_handle.clone().typed::<Gltf>()) {
Some(gltf) => gltf.named_animations.iter().find_map(
|(name, animation_handle)| {
info!(
"animation_handle({:?}) == handle({:?})",
animation_handle, handle
);
(animation_handle == handle).then_some(name)
},
),
None => None,
}
})
.expect("Find animation name");
Some((handle.clone(), String::from(name)))
}
_ => None,
})
.for_each(|(handle, name)| {
commands
.spawn((
GameUiButton,
Name::new(name),
NodeBundle { ..default() },
AnimationsUi,
UiRef::Handle(handle.clone()),
))
.set_parent(root.single());
});
}
/// Component marking UI for Audio Clip assets
#[derive(Component)]

96
src/ui.rs
Unescape Escape View File

@ -18,69 +18,73 @@ impl Plugin for GameUiPlugin {
/// GameUiList for holding ordered collections of objects
#[derive(Debug, Component)]
pub struct GameUiList(pub &'static str);
pub struct GameUiList;
/// Manage UI Lists: lists of UI entities.
fn manage_ui_list(events: Query<(Entity, &GameUiList), Added<GameUiList>>, mut commands: Commands) {
events.iter().for_each(|(entity, ui_list)| {
info!("Expanding UI List {:?}", ui_list);
commands.entity(entity).insert(NodeBundle {
style: Style {
width: Val::Px(100.0),
margin: UiRect::all(Val::Px(2.0)),
padding: UiRect::all(Val::Px(2.0)),
border: UiRect::all(Val::Px(2.0)),
flex_direction: FlexDirection::Column,
align_items: AlignItems::Stretch,
justify_items: JustifyItems::Center,
align_content: AlignContent::FlexStart,
fn manage_ui_list(events: Query<(Entity, &Name), Added<GameUiList>>, mut commands: Commands) {
events.iter().for_each(|(entity, name)| {
commands
.entity(entity)
.insert(NodeBundle {
style: Style {
// width: Val::Px(100.0),
margin: UiRect::all(Val::Px(2.0)),
padding: UiRect::all(Val::Px(2.0)),
border: UiRect::all(Val::Px(2.0)),
flex_direction: FlexDirection::Column,
align_items: AlignItems::Stretch,
justify_items: JustifyItems::Center,
align_content: AlignContent::FlexStart,
..default()
},
background_color: BackgroundColor(Color::RED),
border_color: BorderColor(Color::BLACK),
..default()
},
background_color: BackgroundColor(Color::RED),
border_color: BorderColor(Color::BLACK),
..default()
});
})
.with_children(|parent| {
parent.spawn(TextBundle::from_section(name, TextStyle { ..default() }));
});
});
}
/// GameUiSet Component for holding collections of objects
#[derive(Debug, Component)]
pub struct GameUiSet(pub &'static str);
pub struct GameUiSet;
/// Manage UI Sets: collections of UI entities.
fn manage_ui_set(events: Query<(Entity, &GameUiSet), Added<GameUiSet>>, mut commands: Commands) {
events.iter().for_each(|(entity, ui_set)| {
info!("Expanding UI Set {:?}", ui_set);
commands.entity(entity).insert(NodeBundle {
style: Style {
width: Val::Px(100.0),
margin: UiRect::all(Val::Px(2.0)),
padding: UiRect::all(Val::Px(2.0)),
border: UiRect::all(Val::Px(2.0)),
align_items: AlignItems::FlexStart,
align_content: AlignContent::FlexStart,
flex_direction: FlexDirection::Row,
flex_wrap: FlexWrap::Wrap,
fn manage_ui_set(events: Query<(Entity, &Name), Added<GameUiSet>>, mut commands: Commands) {
events.iter().for_each(|(entity, name)| {
commands
.entity(entity)
.insert(NodeBundle {
style: Style {
// width: Val::Px(100.0),
margin: UiRect::all(Val::Px(2.0)),
padding: UiRect::all(Val::Px(2.0)),
border: UiRect::all(Val::Px(2.0)),
align_items: AlignItems::FlexStart,
align_content: AlignContent::FlexStart,
flex_direction: FlexDirection::Row,
flex_wrap: FlexWrap::Wrap,
..default()
},
background_color: BackgroundColor(Color::BLUE),
border_color: BorderColor(Color::BLACK),
..default()
},
background_color: BackgroundColor(Color::BLUE),
border_color: BorderColor(Color::BLACK),
..default()
});
})
.with_children(|parent| {
parent.spawn(TextBundle::from_section(name, TextStyle { ..default() }));
});
});
}
/// GameUiButton for interactive elements
#[derive(Debug, Component)]
pub struct GameUiButton(pub &'static str);
pub struct GameUiButton;
/// Manage UI Buttons. interactive buttons.
fn manage_ui_button(
events: Query<(Entity, &GameUiButton), Added<GameUiButton>>,
mut commands: Commands,
) {
events.iter().for_each(|(entity, ui_button)| {
info!("Expanding UI Button {:?}", ui_button);
fn manage_ui_button(events: Query<(Entity, &Name), Added<GameUiButton>>, mut commands: Commands) {
events.iter().for_each(|(entity, name)| {
commands
.entity(entity)
.insert(ButtonBundle {
@ -96,7 +100,7 @@ fn manage_ui_button(
..default()
})
.with_children(|parent| {
parent.spawn(TextBundle::from_section(ui_button.0, TextStyle::default()));
parent.spawn(TextBundle::from_section(name, TextStyle::default()));
});
});
}

Write Preview
Loading…
Cancel
Save