games
/
acts-of-gods
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Loading Entities: Making progress, but still not fully implemented

Browse Source
attempt/001
Elijah C. Voigt 1 year ago
parent 21e67e04ca
commit 8f3472c4cd
7 changed files with 136 additions and 208 deletions
Show Stats Download Patch File Download Diff File

6
assets/editor/entities/camera.entity
Unescape Escape View File

@ -0,0 +1,6 @@
uuid 739619d7-b8a1-42b4-8803-2b8cfedeebf1
name "Editor Camera"
editor_tag
camera render_target window b90f31a2-34d9-42c2-9e53-646d9c9c6c70
fly_camera
transform transform 10.0 10.0 10.0

4
assets/editor/entities/ui_container.entity
Unescape Escape View File

@ -0,0 +1,4 @@
uuid 08e1a4d9-6c76-471d-af02-1aa7db1b435a
editor_tag
ui_node
target_camera 739619d7-b8a1-42b4-8803-2b8cfedeebf1

4
assets/editor/entities/ui_title.entity
Unescape Escape View File

@ -0,0 +1,4 @@
uuid 0088bc7d-851e-402b-9d20-fadfe5cab106
editor_tag
ui_text text "Welcome to the editor" color 1.0 1.0 1.0 1.0
parent 08e1a4d9-6c76-471d-af02-1aa7db1b435a

4
assets/editor/entities/window.entity
Unescape Escape View File

@ -0,0 +1,4 @@
uuid b90f31a2-34d9-42c2-9e53-646d9c9c6c70
editor_tag
name "Editor Window"
window title "Editor" visible false

123
src/editor.rs
Unescape Escape View File

@ -1,5 +1,3 @@
use bevy::render::primitives::Aabb;
use crate::prelude::*;
pub(crate) struct EditorPlugin;
@ -7,18 +5,12 @@ pub(crate) struct EditorPlugin;
impl Plugin for EditorPlugin {
fn build(&self, app: &mut App) {
app.init_state::<EditorState>()
.add_systems(Startup, init_editor)
.add_systems(OnEnter(EditorState::Open), spawn_editor)
.add_systems(OnExit(EditorState::Open), despawn_editor)
.add_systems(
Update,
toggle_editor_state.run_if(input_just_pressed(KeyCode::F3)),
)
.add_systems(
Update,
(
toggle_editor_window,
toggle_entity_aabb,
).run_if(state_changed::<EditorState>),
)
.add_systems(
Update,
(
@ -64,57 +56,6 @@ impl std::convert::From<&EditorState> for bool {
#[derive(Component)]
struct EditorTag;
/// At startup initialize some editor components
fn init_editor(mut commands: Commands) {
// Editor window
let editor_window = commands
.spawn((
EditorTag,
Window {
visible: false,
title: "Editor".into(),
..default()
},
))
.id();
// Editor camera
let editor_camera = commands
.spawn((
EditorTag,
FlyCamera,
Camera3dBundle {
camera: Camera {
target: RenderTarget::Window(WindowRef::Entity(editor_window)),
..default()
},
transform: Transform::from_xyz(10.0, 10.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
},
))
.id();
// Editor UI elements
commands
.spawn((
EditorTag,
TargetCamera(editor_camera),
NodeBundle { ..default() },
))
.with_children(|parent| {
parent.spawn((
EditorTag,
TextBundle::from_section(
"Welcome to the editor",
TextStyle {
color: WHITE.into(),
..default()
},
),
));
});
}
fn toggle_editor_state(
curr_state: Res<State<EditorState>>,
mut next_state: ResMut<NextState<EditorState>>,
@ -132,18 +73,16 @@ fn toggle_editor_state(
}
}
fn toggle_editor_window(
state: Res<State<EditorState>>,
mut windows: Query<&mut Window, With<EditorTag>>,
mut cameras: Query<&mut Camera, With<EditorTag>>,
fn spawn_editor(
mut _commands: Commands,
) {
let curr = state.get().into();
cameras.iter_mut().for_each(|mut camera| {
camera.is_active = curr;
});
windows.iter_mut().for_each(|mut window| {
window.visible = curr;
})
todo!("Spawn editor");
}
fn despawn_editor(
mut _comands: Commands,
) {
todo!("Despawn editor");
}
/// Handles window close requests which are only weird because of the editor
@ -184,44 +123,4 @@ fn plane_gizmos(mut gizmos: Gizmos) {
gizmos.arrow(Vec3::ZERO, Vec3::Y, DARK_GREEN);
gizmos.arrow(Vec3::ZERO, Vec3::Z, BLUE);
}
}
fn toggle_entity_aabb(
state: Res<State<EditorState>>,
query: Query<Entity, With<Handle<SaveEntity>>>,
children: Query<&Children>,
aabbs: Query<(Entity, &Aabb)>,
mut commands: Commands,
) {
let add_component = match state.get() {
EditorState::Open => true,
EditorState::Closed => false,
};
query.iter().for_each(|root| {
if add_component {
commands.entity(root).insert(ShowAabbGizmo { ..default() });
} else {
commands.entity(root).remove::<ShowAabbGizmo>();
}
let mut child_has_bounding_box = false;
for child in children.iter_descendants(root) {
if add_component {
commands.entity(child).insert(ShowAabbGizmo { ..default() });
} else {
commands.entity(child).remove::<ShowAabbGizmo>();
}
if aabbs.contains(child) {
commands.entity(child).insert(Aabb { center: Vec3A::ZERO, half_extents: Vec3A::ONE });
} else {
child_has_bounding_box = true;
}
}
if !aabbs.contains(root) && !child_has_bounding_box {
commands.entity(root).insert(Aabb { center: Vec3A::ZERO, half_extents: Vec3A::ONE });
} else {
commands.entity(root).remove::<Aabb>();
}
})
}

7
src/prelude.rs
Unescape Escape View File

@ -1,14 +1,15 @@
pub(crate) use bevy::{
app::AppExit,
asset::{io::Reader, AssetLoader, LoadContext, AsyncReadExt},
color::palettes::css::{WHITE, GRAY, RED, DARK_GREEN, BLUE},
color::palettes::css::{GRAY, RED, DARK_GREEN, BLUE},
gltf::Gltf,
input::common_conditions::input_just_pressed,
math::Vec3A,
prelude::*,
render::camera::RenderTarget,
window::{WindowRef, WindowCloseRequested, PrimaryWindow},
};
pub(crate) use bevy::ecs::reflect::ReflectCommandExt;
pub(crate) use nom::bytes::complete::take;
pub(crate) use nom::{
IResult,
bytes::complete::{tag, take_until1},
@ -20,7 +21,5 @@ pub(crate) use uuid::Uuid;
pub(crate) use thiserror::Error;
pub(crate) use crate::{
camera::*,
conditions::*,
save::*,
};

196
src/save.rs
Unescape Escape View File

@ -5,7 +5,11 @@ pub(crate) struct SavePlugin;
impl Plugin for SavePlugin {
fn build(&self, app: &mut App) {
app.init_asset::<SaveEntity>()
app
.register_type::<parse::EntityUuid>()
.register_type::<parse::SaveCameraRenderTarget>()
.register_type::<GltfScene>()
.init_asset::<SaveEntity>()
.init_asset_loader::<SaveEntityLoader>()
.add_systems(Startup, test_save_entity)
.add_systems(
@ -15,17 +19,16 @@ impl Plugin for SavePlugin {
}
}
#[derive(Asset, TypePath, Debug, Default)]
#[derive(Asset, TypePath, Default)]
pub(crate) struct SaveEntity {
transform: Option<Transform>,
name: Option<Name>,
uuid: Option<EntityUuid>,
model: Option<(Handle<Gltf>, String)>,
// TODO: Option<bool> feels like an antipattern as this is either Some(true) or None and never Some(false).
// Either encode more Camera data in this or replace it with Option<()> or just bool.
camera: Option<bool>,
components: Vec<Box<dyn Reflect>>,
}
// TODO: SCALABILITY: SaveEntity should maybe be a HashSet or Vec of Box<into Bundle>
// Then we tell the parse "For each line, run through each of these concrete parsers"
// If it matches, add it to the set of Box<Bundle>
// Ironically we basically want DynamicEntity: https://docs.rs/bevy/latest/bevy/scene/struct.DynamicEntity.html
impl SaveEntity {
fn parse(
text: &str,
@ -34,25 +37,32 @@ impl SaveEntity {
let lines = text.split('\n');
let mut entity = SaveEntity { ..default() };
lines.into_iter().for_each(|line| {
if let Ok(name) = parse::parse_save_name(line) {
entity.name = Some(name);
entity.components.push(name.clone_value());
} else if let Ok(transform) = parse::parse_save_transform(line) {
entity.transform = Some(transform);
entity.components.push(transform.clone_value());
} else if let Ok(uuid) = parse::parse_save_uuid(line) {
entity.uuid = Some(EntityUuid(uuid));
} else if let Ok((gltf_path, scene_name)) = parse::parse_save_model(line) {
let handle = load_context.load(gltf_path);
entity.model = Some((handle, scene_name));
} else if let Ok(true) = parse::parse_save_camera(line) {
entity.camera = Some(true);
entity.components.push(uuid.clone_value());
} else if let Ok((gltf_file, scene_name)) = parse::parse_save_model(line) {
let gltf_scene = GltfScene { gltf: load_context.load(gltf_file), name: scene_name };
entity.components.push(gltf_scene.clone_value());
} else if let Ok(target) = parse::parse_save_camera(line) {
entity.components.push(target.clone_value());
} else {
error!("Failed to parse line component `{:?}`", line);
}
});
Ok(entity)
}
}
#[derive(Component, Clone, Debug)]
struct EntityUuid(Uuid);
#[derive(Component, Clone, Debug, Reflect, PartialEq)]
struct GltfScene {
gltf: Handle<Gltf>,
name: String,
}
mod parse {
use super::*;
@ -67,6 +77,8 @@ mod parse {
Transform,
#[error("Failed to parse Entity")]
Nom(nom::Err<nom::error::Error<Box<str>>>),
#[error("Failed to parse camera")]
Camera,
}
// Convert Nom error to parse error
@ -107,12 +119,6 @@ mod parse {
}
///
/// ```
/// let parsed = parse_save_transform("transform translation 1.0 2.0 3.0 rotation 1.0 0.0 0.0 0.0 scale 1.0 1.0 1.0").unwrap();
/// let expected = Transform { translation: Vec3::new(1.0, 1.0, 1.0), rotation: Quat::from_xzyw(1.0, 0.0, 0.0, 0.0), scale: Vec3::ONE };
///
/// assert_eq!(parsed, expected);
/// ```
///
pub(crate) fn parse_save_transform(line: &str) -> Result<Transform, SaveEntityParseError> {
let (rem, _) = tag("transform")(line)?;
@ -121,7 +127,6 @@ mod parse {
let mut curr = rem.trim_start();
for _ in 0..3 {
println!("Curr: {:?}", curr);
if let Ok((rem, (_, _, (x, y, z)))) = tuple((parse_word("translation"), space1, parse_xyz))(curr.trim_start()) {
transform.translation = Vec3::new(x, y, z);
curr = rem.trim_start();
@ -156,12 +161,6 @@ mod parse {
}
///
/// ```
/// let parsed = parse_save_name("name asfd").unwrap();
/// let expected = Name::new("asdf");
///
/// assert_eq!(parsed, expected);
/// ```
///
pub(crate) fn parse_save_name(line: &str) -> Result<Name, SaveEntityParseError> {
let (remainder, _) = tag("name")(line)?;
@ -192,31 +191,31 @@ mod parse {
}
}
#[derive(Component, Clone, Debug, Reflect, PartialEq)]
pub(crate) struct EntityUuid(Uuid);
///
/// ```
/// let parsed = parse_save_uuid("uuid 339dd18f-761a-4997-b515-ef57f4dc2447").unwrap();
/// let expected = Uuid::parse_str("339dd18f-761a-4997-b515-ef57f4dc2447").unwrap();
///
/// assert_eq!(parsed, expected);
/// ```
///
pub(crate) fn parse_save_uuid(line: &str) -> Result<Uuid, SaveEntityParseError> {
pub(crate) fn parse_save_uuid(line: &str) -> Result<EntityUuid, SaveEntityParseError> {
let (remainder, _) = tag("uuid")(line)?;
let uuid = Uuid::try_parse(remainder.trim())?;
Ok(uuid)
Ok(EntityUuid(uuid))
}
#[test]
fn test_parse_uuid() {
let line = "uuid 1c16ab9a-5f79-4340-8469-4086f69c64f2";
let parsed = parse_save_uuid(line).unwrap();
let expected = Uuid::parse_str("1c16ab9a-5f79-4340-8469-4086f69c64f2").unwrap();
let expected = EntityUuid(Uuid::parse_str("1c16ab9a-5f79-4340-8469-4086f69c64f2").unwrap());
assert_eq!(parsed, expected);
}
///
///
pub(crate) fn parse_save_model(line: &str) -> Result<(String, String), SaveEntityParseError> {
let (rem, (_, _, gltf_name, _, scene_name)) = tuple((
let (rem, (_, _, gltf_path, _, scene_name)) = tuple((
tag("model"),
space1,
parse_string,
@ -224,9 +223,9 @@ mod parse {
parse_string,
))(line)?;
debug_assert_eq!(rem, "");
debug_assert!(rem == "");
Ok((String::from(gltf_name), String::from(scene_name)))
Ok((gltf_path.into(), scene_name.into()))
}
#[test]
@ -238,9 +237,45 @@ mod parse {
assert_eq!(parsed, expected);
}
pub(crate) fn parse_save_camera(line: &str) -> Result<bool, SaveEntityParseError> {
let (_rem, cam) = tag("camera")(line)?;
Ok(!cam.is_empty())
#[derive(Debug, Default, PartialEq, Reflect)]
pub(crate) enum SaveCameraRenderTarget {
#[default]
Default,
Window(Uuid),
}
pub(crate) fn parse_save_camera(line: &str) -> Result<SaveCameraRenderTarget, SaveEntityParseError> {
if let Ok((rem, _camera)) = tag::<&str, &str, ()>("camera")(line) {
if let Ok((rem, (_, _target))) = tuple((space1::<&str, ()>, tag("target")))(rem) {
if let Ok((rem, (_, _window))) = tuple((space1::<&str, ()>, tag("window")))(rem) {
// Camera + target + window + UUID
if let Ok((rem, (_, uuid))) = tuple((space1::<&str, ()>, take(36usize)))(rem) {
debug_assert!(rem == "");
let parsed_uuid = Uuid::parse_str(uuid)?;
Ok(SaveCameraRenderTarget::Window(parsed_uuid))
// Camera + target + widow
} else {
debug_assert!(rem == "");
Ok(SaveCameraRenderTarget::Default)
}
// camera + target
} else {
debug_assert!(rem == "");
Err(SaveEntityParseError::Camera)
}
// Just camera
} else {
debug_assert!(rem == "");
Ok(SaveCameraRenderTarget::Default)
}
// Nothing parsed well
} else {
Err(SaveEntityParseError::Camera)
}
}
#[test]
@ -248,7 +283,25 @@ mod parse {
{
let line = "camera";
let parsed = parse_save_camera(line).unwrap();
let expected = true;
let expected = SaveCameraRenderTarget::Default;
assert_eq!(parsed, expected);
}
{
let line = "camera target window";
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Default;
assert_eq!(parsed, expected);
}
{
let line = "camera target";
let parsed = parse_save_camera(line);
assert!(parsed.is_err());
}
{
let line = "camera target window 9a1367e0-71e5-4c79-b4ad-02aa44b68af0";
let target_uuid = Uuid::parse_str("9a1367e0-71e5-4c79-b4ad-02aa44b68af0").unwrap();
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Window(target_uuid);
assert_eq!(parsed, expected);
}
{
@ -307,7 +360,6 @@ fn check_loaded_entity_assets(
mut events: EventReader<AssetEvent<SaveEntity>>,
save_entities: Res<Assets<SaveEntity>>,
mut commands: Commands,
gltfs: Res<Assets<Gltf>>,
) {
events.read().for_each(|event| {
if let AssetEvent::LoadedWithDependencies { id } = event {
@ -316,51 +368,11 @@ fn check_loaded_entity_assets(
.filter(|(_, handle)| handle.id() == *id)
.for_each(|(entity, _handle)| {
let saved = save_entities.get(*id).unwrap();
debug!(
"Updating entity {:?} ({:?}) because asset changed",
saved.name, saved.uuid
);
let mut e = commands.entity(entity);
// Apply camera
// Should be applied early to avoid clobbering transform
if let Some(is_camera) = &saved.camera {
if *is_camera {
e.insert(Camera3dBundle { ..default() });
}
} else {
e.remove::<(Camera, Camera3d)>();
}
// Apply transform
if let Some(transform) = &saved.transform {
// TODO: Only update if different
e.insert(*transform);
} else {
e.remove::<Transform>();
}
// Apply Name
if let Some(name) = &saved.name {
// TODO: Only update if different
e.insert(name.clone());
} else {
e.remove::<Name>();
}
// Apply Uuid
if let Some(uuid) = &saved.uuid {
// TODO: Only update if different
e.insert(uuid.clone());
} else {
e.remove::<EntityUuid>();
}
// Apply Model
if let Some((gltf_handle, scene_name)) = &saved.model {
// Find scene and update
let gltf = gltfs.get(gltf_handle).unwrap();
let scene_handle = gltf.named_scenes.get(scene_name.as_str().into()).unwrap();
e.insert(scene_handle.clone());
} else {
e.remove::<Handle<Scene>>();
}
saved.components.iter().for_each(|dc| {
e.insert_reflect(dc.clone_value());
});
});
}
})

Write Preview
Loading…
Cancel
Save