From d2e70481ce8ff25604923b5c1a6627c69c503164 Mon Sep 17 00:00:00 2001 From: hodasemi Date: Fri, 11 Apr 2025 09:59:51 +0200 Subject: [PATCH] Fix examples --- engine/src/engine/engine.rs | 9 +- engine/src/engine/engine_event_handling.rs | 709 +++++++++++---------- engine/src/prelude.rs | 2 +- examples/free_space/src/game.rs | 224 ++++--- examples/free_space/src/game_state.rs | 22 +- examples/free_space/src/main.rs | 17 +- examples/simple_window/src/main.rs | 82 +-- 7 files changed, 550 insertions(+), 515 deletions(-) diff --git a/engine/src/engine/engine.rs b/engine/src/engine/engine.rs index 0d4414b..ca77841 100644 --- a/engine/src/engine/engine.rs +++ b/engine/src/engine/engine.rs @@ -6,7 +6,7 @@ use super::engine_settings::EngineSettings; use anyhow::Result; use assetpath::AssetPath; use context::prelude::cgmath::vec3; -use ecs::{Resource, resources::Resource as ResourceTrait}; +use ecs::Resource; use crate::assets::asset_manager::AssetManager; use crate::prelude::*; @@ -20,7 +20,7 @@ pub struct Engine { } impl Engine { - pub fn new( + pub fn new( #[allow(unused)] mut create_info: EngineCreateInfo<'_>, world: &mut WorldBuilder, ) -> Result<()> { @@ -171,10 +171,9 @@ impl Engine { world.resources.insert(engine_settings); world.add_system(1, Self::start_frame); - world.add_system(u32::MAX, Self::end_frame); - - world.add_system(100, Self::render_scene); + world.add_system(10_000, Self::render_scene); world.add_system(10_000_000, Self::render_gui); + world.add_system(u32::MAX, Self::end_frame); Ok(()) } diff --git a/engine/src/engine/engine_event_handling.rs b/engine/src/engine/engine_event_handling.rs index 44e1c1f..a074505 100644 --- a/engine/src/engine/engine_event_handling.rs +++ b/engine/src/engine/engine_event_handling.rs @@ -37,347 +37,376 @@ pub trait EventSystem { fn event_system(world_builder: &mut WorldBuilder, func: Func); } -impl EventSystem for Engine -where - Func: Fn(&mut T, &mut Commands, EngineEvent<'_>) -> Result<()> + Send + Sync + 'static, - T: ResourceTrait, -{ - fn event_system(world_builder: &mut WorldBuilder, func: Func) { - world_builder.add_system( - 0, - |world: &World, - commands: &mut Commands, - consumer: &mut T, - gui_handler: &mut GuiHandler, - input_map: &mut InputMap, - context: &mut Context| - -> Result { - let res = context.events(world, |event| { - Self::event(commands, gui_handler, input_map, consumer, event, func) - })?; +macro_rules! impl_event_system { + ( $( $t:ident, )* ) => { + paste::paste! { + impl EventSystem for Engine + where + Func: Fn(&mut T, &mut Commands, EngineEvent<'_>, $( &mut $t, )* ) -> Result<()> + Send + Sync + 'static, + T: ResourceTrait, + $( + $t: ResourceTrait, + )* + { + fn event_system(world_builder: &mut WorldBuilder, func: Func) { + world_builder.add_system( + 0, + move |world: &World, + commands: &mut Commands, + consumer: &mut T, + gui_handler: &mut GuiHandler, + input_map: &mut InputMap, + context: &mut Context, + $( + [< $t:lower >]: &mut $t, + )* + | + -> Result { + let res = context.events(world, |event| { + match event { + Event::MouseMotion(x, y) => { + gui_handler.set_mouse_pos(x, y)?; + func( + consumer, + commands, + EngineEvent::MouseMotion(x, y), + $( + [< $t:lower >], + )* + )?; + } + Event::MouseButtonDown(mouse_button) => { + if !gui_handler.mouse_down(mouse_button)? { + func( + consumer, + commands, + EngineEvent::MouseButtonDown(mouse_button), + $( + [< $t:lower >], + )* + )?; + } + } + Event::MouseButtonUp(mouse_button) => { + if !gui_handler.mouse_up(mouse_button)? { + func( + consumer, + commands, + EngineEvent::MouseButtonUp(mouse_button), + $( + [< $t:lower >], + )* + )?; + } + } + Event::MouseWheel(x, y, direction) => { + func( + consumer, + commands, + EngineEvent::MouseWheel(x, y, direction), + $( + [< $t:lower >], + )* + )?; + } + Event::KeyDown(keycode) => { + if let Some(direction) = + input_map.direction_mapping.get(&keycode) + { + if gui_handler.update_selection(*direction)? { + return Ok(()); + } + } - gui_handler.process_callbacks(commands)?; + match keycode { + Keycode::Backspace => { + if gui_handler.remove_char()? { + return Ok(()); + } + } + Keycode::Return => { + if gui_handler.accept_selection()? { + return Ok(()); + } + } + Keycode::Escape => { + if gui_handler.decline_topgui(commands)? { + return Ok(()); + } + } - Ok(res) - }, - ) - } + _ => (), + } + + func( + consumer, + commands, + EngineEvent::KeyDown(keycode), + $( + [< $t:lower >], + )* + )?; + } + Event::KeyUp(keycode) => { + if input_map.direction_mapping.get(&keycode).is_some() + && gui_handler.update_selection(GuiDirection::None)? + { + return Ok(()); + } + + func( + consumer, + commands, + EngineEvent::KeyUp(keycode), + $( + [< $t:lower >], + )* + )?; + } + Event::TextInput(text) => { + if let Some(writeable) = gui_handler.writeable() { + for c in text.chars() { + writeable.add_letter(gui_handler, c)?; + } + } + } + Event::ControllerButtonDown(controller, button) => { + if gui_handler.check_navigatable() { + match button { + ControllerButton::A => { + if gui_handler.accept_selection()? { + return Ok(()); + } + } + + ControllerButton::B => { + if gui_handler.decline_topgui(commands)? { + return Ok(()); + } + } + + ControllerButton::RightButton => { + if gui_handler.next_tab_topgui(commands, false)? { + return Ok(()); + } + } + + ControllerButton::LeftButton => { + if gui_handler + .previous_tab_topgui(commands, false)? + { + return Ok(()); + } + } + + ControllerButton::RightTrigger => { + if gui_handler.next_tab_topgui(commands, true)? { + return Ok(()); + } + } + + ControllerButton::LeftTrigger => { + if gui_handler + .previous_tab_topgui(commands, true)? + { + return Ok(()); + } + } + + ControllerButton::DPadDown => { + let selection_res = gui_handler + .update_selection(GuiDirection::Down)?; + gui_handler.update_selection(GuiDirection::None)?; + + if selection_res { + return Ok(()); + } + } + + ControllerButton::DPadUp => { + let selection_res = gui_handler + .update_selection(GuiDirection::Up)?; + gui_handler.update_selection(GuiDirection::None)?; + + if selection_res { + return Ok(()); + } + } + + ControllerButton::DPadRight => { + let selection_res = gui_handler + .update_selection(GuiDirection::Right)?; + gui_handler.update_selection(GuiDirection::None)?; + + if selection_res { + return Ok(()); + } + } + + ControllerButton::DPadLeft => { + let selection_res = gui_handler + .update_selection(GuiDirection::Left)?; + gui_handler.update_selection(GuiDirection::None)?; + + if selection_res { + return Ok(()); + } + } + + _ => (), + } + + if !gui_handler.accept_custom_selection(commands, button)? { + func( + consumer, + commands, + EngineEvent::ControllerButtonDown( + controller, button, + ), + $( + [< $t:lower >], + )* + )?; + } + } else { + func( + consumer, + commands, + EngineEvent::ControllerButtonDown(controller, button), + $( + [< $t:lower >], + )* + )?; + } + } + Event::ControllerButtonUp(controller, button) => { + func( + consumer, + commands, + EngineEvent::ControllerButtonUp(controller, button), + $( + [< $t:lower >], + )* + )?; + } + Event::ControllerAxis(controller) => { + if !gui_handler.check_navigatable() { + func( + consumer, + commands, + EngineEvent::ControllerAxis( + controller, + controller.controller_axis(), + ), + $( + [< $t:lower >], + )* + )?; + } else { + gui_handler.update_selection(controller.direction())?; + } + } + Event::ControllerAdded(controller) => { + func( + consumer, + commands, + EngineEvent::ControllerAdded(controller), + $( + [< $t:lower >], + )* + )?; + } + Event::ControllerRemoved(controller) => { + func( + consumer, + commands, + EngineEvent::ControllerRemoved(controller), + $( + [< $t:lower >], + )* + )?; + } + + Event::JoystickAxis(joystick, axis_index, value) => { + func( + consumer, + commands, + EngineEvent::JoystickAxis(joystick, axis_index, value), + $( + [< $t:lower >], + )* + )?; + } + Event::JoystickButtonDown(joystick) => { + func( + consumer, + commands, + EngineEvent::JoystickButtonDown(joystick), + $( + [< $t:lower >], + )* + )?; + } + Event::JoystickButtonUp(joystick) => { + func( + consumer, + commands, + EngineEvent::JoystickButtonUp(joystick), + $( + [< $t:lower >], + )* + )?; + } + Event::JoystickAdded(joystick) => { + func( + consumer, + commands, + EngineEvent::JoystickAdded(joystick), + $( + [< $t:lower >], + )* + )?; + } + Event::JoystickRemoved(joystick) => { + func( + consumer, + commands, + EngineEvent::JoystickRemoved(joystick), + $( + [< $t:lower >], + )* + )?; + } + + Event::FileDrop(filename) => { + func( + consumer, + commands, + EngineEvent::FileDrop(filename), + $( + [< $t:lower >], + )* + )?; + } + } + + Ok(()) + })?; + + gui_handler.process_callbacks(commands)?; + + Ok(res) + }, + ) + } + } + } + }; } -impl Engine { - pub(crate) fn event( - commands: &mut Commands, - gui_handler: &mut GuiHandler, - input: &InputMap, - consumer: &mut T, - event: Event<'_>, - func: Func, - ) -> anyhow::Result<()> { - match event { - Event::MouseMotion(x, y) => { - gui_handler.set_mouse_pos(x, y)?; - consumer.event(commands, EngineEvent::MouseMotion(x, y))?; - } - Event::MouseButtonDown(mouse_button) => { - if !gui_handler.mouse_down(mouse_button)? { - consumer.event(commands, EngineEvent::MouseButtonDown(mouse_button))?; - } - } - Event::MouseButtonUp(mouse_button) => { - if !gui_handler.mouse_up(mouse_button)? { - consumer.event(commands, EngineEvent::MouseButtonUp(mouse_button))?; - } - } - Event::MouseWheel(x, y, direction) => { - consumer.event(commands, EngineEvent::MouseWheel(x, y, direction))? - } - Event::KeyDown(keycode) => { - Self::key_down_event(commands, gui_handler, input, consumer, keycode)?; - } - Event::KeyUp(keycode) => { - Self::key_up_event(commands, gui_handler, input, consumer, keycode)?; - } - Event::TextInput(text) => { - Self::text_input(gui_handler, text)?; - } - Event::ControllerButtonDown(controller, button) => { - Self::button_down_event(commands, gui_handler, consumer, controller, button)?; - } - Event::ControllerButtonUp(controller, button) => { - Self::button_up_event(commands, consumer, controller, button)?; - } - Event::ControllerAxis(controller) => { - if !gui_handler.check_navigatable() { - Self::axis_event(commands, consumer, &controller)? - } else { - gui_handler.update_selection(controller.direction())?; - } - } - Event::ControllerAdded(controller) => { - Self::controller_added(commands, consumer, controller)? - } - Event::ControllerRemoved(controller) => { - Self::controller_removed(commands, consumer, controller)? - } - - Event::JoystickAxis(joystick, axis_index, value) => consumer.event( - commands, - EngineEvent::JoystickAxis(joystick, axis_index, value), - )?, - Event::JoystickButtonDown(joystick) => { - consumer.event(commands, EngineEvent::JoystickButtonDown(joystick))? - } - Event::JoystickButtonUp(joystick) => { - consumer.event(commands, EngineEvent::JoystickButtonUp(joystick))? - } - Event::JoystickAdded(joystick) => { - consumer.event(commands, EngineEvent::JoystickAdded(joystick))? - } - Event::JoystickRemoved(joystick) => { - consumer.event(commands, EngineEvent::JoystickRemoved(joystick))? - } - - Event::FileDrop(filename) => { - consumer.event(commands, EngineEvent::FileDrop(filename))? - } - } - - Ok(()) - } -} - -impl Engine { - #[inline] - fn controller_added( - commands: &mut Commands, - consumer: &mut T, - controller: &Controller, - ) -> Result<()> { - consumer.event(commands, EngineEvent::ControllerAdded(controller))?; - - Ok(()) - } - - #[inline] - fn controller_removed( - commands: &mut Commands, - consumer: &mut T, - controller: &Controller, - ) -> Result<()> { - consumer.event(commands, EngineEvent::ControllerRemoved(controller))?; - - Ok(()) - } - - #[inline] - fn key_up_event( - commands: &mut Commands, - gui_handler: &mut GuiHandler, - input: &InputMap, - consumer: &mut T, - keycode: Keycode, - ) -> Result<()> { - if input.direction_mapping.get(&keycode).is_some() - && gui_handler.update_selection(GuiDirection::None)? - { - return Ok(()); - } - - consumer.event(commands, EngineEvent::KeyUp(keycode))?; - - Ok(()) - } - - #[inline] - fn key_down_event( - commands: &mut Commands, - gui_handler: &mut GuiHandler, - input: &InputMap, - consumer: &mut T, - keycode: Keycode, - ) -> Result<()> { - if let Some(direction) = input.direction_mapping.get(&keycode) { - if gui_handler.update_selection(*direction)? { - return Ok(()); - } - } - - match keycode { - Keycode::Backspace => { - if gui_handler.remove_char()? { - return Ok(()); - } - } - Keycode::Return => { - if gui_handler.accept_selection()? { - return Ok(()); - } - } - Keycode::Escape => { - if gui_handler.decline_topgui(commands)? { - return Ok(()); - } - } - - _ => (), - } - - consumer.event(commands, EngineEvent::KeyDown(keycode))?; - - Ok(()) - } - - #[inline] - fn button_up_event( - commands: &mut Commands, - consumer: &mut T, - controller: &Controller, - button: ControllerButton, - ) -> Result<()> { - consumer.event( - commands, - EngineEvent::ControllerButtonUp(controller, button), - )?; - - Ok(()) - } - - #[inline] - fn button_down_event( - commands: &mut Commands, - gui_handler: &mut GuiHandler, - consumer: &mut T, - controller: &Controller, - button: ControllerButton, - ) -> Result<()> { - if gui_handler.check_navigatable() { - Self::check_button_down(commands, gui_handler, consumer, controller, button)?; - } else { - consumer.event( - commands, - EngineEvent::ControllerButtonDown(controller, button), - )?; - } - - Ok(()) - } - - #[inline] - fn axis_event( - commands: &mut Commands, - consumer: &mut T, - controller: &Controller, - ) -> Result<()> { - consumer.event( - commands, - EngineEvent::ControllerAxis(controller, controller.controller_axis()), - )?; - - Ok(()) - } - - #[inline] - fn check_button_down( - commands: &mut Commands, - gui_handler: &mut GuiHandler, - consumer: &mut T, - controller: &Controller, - button: ControllerButton, - ) -> Result<()> { - match button { - ControllerButton::A => { - if gui_handler.accept_selection()? { - return Ok(()); - } - } - - ControllerButton::B => { - if gui_handler.decline_topgui(commands)? { - return Ok(()); - } - } - - ControllerButton::RightButton => { - if gui_handler.next_tab_topgui(commands, false)? { - return Ok(()); - } - } - - ControllerButton::LeftButton => { - if gui_handler.previous_tab_topgui(commands, false)? { - return Ok(()); - } - } - - ControllerButton::RightTrigger => { - if gui_handler.next_tab_topgui(commands, true)? { - return Ok(()); - } - } - - ControllerButton::LeftTrigger => { - if gui_handler.previous_tab_topgui(commands, true)? { - return Ok(()); - } - } - - ControllerButton::DPadDown => { - let selection_res = gui_handler.update_selection(GuiDirection::Down)?; - gui_handler.update_selection(GuiDirection::None)?; - - if selection_res { - return Ok(()); - } - } - - ControllerButton::DPadUp => { - let selection_res = gui_handler.update_selection(GuiDirection::Up)?; - gui_handler.update_selection(GuiDirection::None)?; - - if selection_res { - return Ok(()); - } - } - - ControllerButton::DPadRight => { - let selection_res = gui_handler.update_selection(GuiDirection::Right)?; - gui_handler.update_selection(GuiDirection::None)?; - - if selection_res { - return Ok(()); - } - } - - ControllerButton::DPadLeft => { - let selection_res = gui_handler.update_selection(GuiDirection::Left)?; - gui_handler.update_selection(GuiDirection::None)?; - - if selection_res { - return Ok(()); - } - } - - _ => (), - } - - if !gui_handler.accept_custom_selection(commands, button)? { - consumer.event( - commands, - EngineEvent::ControllerButtonDown(controller, button), - )?; - } - - Ok(()) - } - - #[inline] - fn text_input(gui_handler: &mut GuiHandler, text: String) -> Result<()> { - if let Some(writeable) = gui_handler.writeable() { - for c in text.chars() { - writeable.add_letter(gui_handler, c)?; - } - } - - Ok(()) - } -} +impl_event_system!(); +impl_event_system!(A, B,); +impl_event_system!(A, B, C,); +impl_event_system!(A, B, C, D,); +impl_event_system!(A, B, C, D, E,); +impl_event_system!(A, B, C, D, E, F,); diff --git a/engine/src/prelude.rs b/engine/src/prelude.rs index 857c7ab..bbb8a09 100644 --- a/engine/src/prelude.rs +++ b/engine/src/prelude.rs @@ -10,7 +10,7 @@ pub use crate::engine::{ asset_handler::{AssetHandler, AssetLoader}, engine::*, engine_create_info::EngineCreateInfo, - engine_event_handling::{EngineEvent, EventConsumer, EventSystem}, + engine_event_handling::{EngineEvent, EventSystem}, engine_settings::*, }; diff --git a/examples/free_space/src/game.rs b/examples/free_space/src/game.rs index c2c74eb..1956618 100644 --- a/examples/free_space/src/game.rs +++ b/examples/free_space/src/game.rs @@ -8,10 +8,22 @@ use engine::prelude::{ *, }; -use crate::{FREE_CAMERA_CONTROL, celestial_object::*}; +use crate::celestial_object::*; -#[derive(Clone, Copy, Debug, Resource)] -struct PlayerEntity(Entity); +#[derive(Debug)] +struct Player; + +impl EntityComponent for Player { + fn name(&self) -> &str { + Self::debug_name() + } +} + +impl ComponentDebug for Player { + fn debug_name() -> &'static str { + "Player" + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] enum Input { @@ -38,7 +50,7 @@ enum Control { } #[derive(Clone, Debug, Resource)] -struct InputSettings { +pub struct InputSettings { mappings: HashMap<(String, u32, Input), (Control, bool)>, } @@ -109,23 +121,23 @@ impl InputSettings { pub struct Game; impl Game { - pub fn update( - &mut self, - commands: &mut Commands, - scene: &mut Scene, - camera_control: &mut FreeCameraControl, - ) -> Result<()> { - if FREE_CAMERA_CONTROL { - let now = commands.now(); + pub fn update(&mut self, commands: &mut Commands) -> Result<()> { + // if FREE_CAMERA_CONTROL { + // let now = commands.now(); - camera_control.update(now, scene.view_mut())?; - } + // camera_control.update(now, scene.view_mut())?; + // } Ok(()) } - pub fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { - if let Some(event) = Self::motion_concepts(world, event)? { + pub fn event( + &mut self, + commands: &mut Commands, + event: EngineEvent<'_>, + input_settings: &mut InputSettings, + ) -> Result<()> { + if let Some(event) = Self::joystick_movement(commands, event, input_settings)? { match event { EngineEvent::JoystickAdded(joystick) => { println!("joystick {} added", joystick.name()); @@ -142,85 +154,78 @@ impl Game { Ok(()) } - fn motion_concepts<'a>( - world: &mut World, - event: EngineEvent<'a>, - ) -> Result>> { - if FREE_CAMERA_CONTROL { - Self::free_camera(world, event) - } else { - Self::joystick_movement(world, event) - } - } + // fn motion_concepts<'a>( + // world: &mut World, + // event: EngineEvent<'a>, + // ) -> Result>> { + // if FREE_CAMERA_CONTROL { + // Self::free_camera(world, event) + // } else { + // Self::joystick_movement(world, event) + // } + // } - fn free_camera<'a>( - world: &mut World, - event: EngineEvent<'a>, - ) -> Result>> { - match event { - EngineEvent::MouseButtonDown(MouseButton::Middle) => { - let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; - camera_control.mouse_down(); - } - EngineEvent::MouseButtonUp(MouseButton::Middle) => { - let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; - camera_control.mouse_release(); - } - EngineEvent::MouseMotion(x, y) => { - let (scene, camera_control): (&mut Scene, &mut FreeCameraControl) = - world.resources.get_mut()?; + // (fn free_camera<'a>(event: EngineEvent<'a>) -> Result>> { + // match event { + // EngineEvent::MouseButtonDown(MouseButton::Middle) => { + // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; + // camera_control.mouse_down(); + // } + // EngineEvent::MouseButtonUp(MouseButton::Middle) => { + // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; + // camera_control.mouse_release(); + // } + // EngineEvent::MouseMotion(x, y) => { + // let (scene, camera_control): (&mut Scene, &mut FreeCameraControl) = + // world.resources.get_mut()?; - camera_control.mouse_move(x, y, scene.view_mut())?; + // camera_control.mouse_move(x, y, scene.view_mut())?; - return Ok(Some(event)); - } - EngineEvent::KeyDown(key) => { - let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; + // return Ok(Some(event)); + // } + // EngineEvent::KeyDown(key) => { + // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; - match key { - Keycode::W => camera_control.forward_back(1.0), - Keycode::A => camera_control.left_right(-1.0), - Keycode::S => camera_control.forward_back(-1.0), - Keycode::D => camera_control.left_right(1.0), - Keycode::Space => camera_control.up_down(1.0), - Keycode::LCtrl => camera_control.up_down(-1.0), + // match key { + // Keycode::W => camera_control.forward_back(1.0), + // Keycode::A => camera_control.left_right(-1.0), + // Keycode::S => camera_control.forward_back(-1.0), + // Keycode::D => camera_control.left_right(1.0), + // Keycode::Space => camera_control.up_down(1.0), + // Keycode::LCtrl => camera_control.up_down(-1.0), - _ => return Ok(Some(event)), - } - } - EngineEvent::KeyUp(key) => { - let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; + // _ => return Ok(Some(event)), + // } + // } + // EngineEvent::KeyUp(key) => { + // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; - match key { - Keycode::W => camera_control.forward_back(-1.0), - Keycode::A => camera_control.left_right(1.0), - Keycode::S => camera_control.forward_back(1.0), - Keycode::D => camera_control.left_right(-1.0), - Keycode::Space => camera_control.up_down(-1.0), - Keycode::LCtrl => camera_control.up_down(1.0), + // match key { + // Keycode::W => camera_control.forward_back(-1.0), + // Keycode::A => camera_control.left_right(1.0), + // Keycode::S => camera_control.forward_back(1.0), + // Keycode::D => camera_control.left_right(-1.0), + // Keycode::Space => camera_control.up_down(-1.0), + // Keycode::LCtrl => camera_control.up_down(1.0), - _ => return Ok(Some(event)), - } - } + // _ => return Ok(Some(event)), + // } + // } - _ => return Ok(Some(event)), - } + // _ => return Ok(Some(event)), + // } - Ok(None) - } + // Ok(None) + // }) fn joystick_movement<'a>( - world: &mut World, + commands: &mut Commands, event: EngineEvent<'a>, + input_settings: &mut InputSettings, ) -> Result>> { - let player = world.resources.get::(); - let (fighter_object, resources) = world.entity_resources(player.0)?; - match event { EngineEvent::JoystickAxis(joystick, axis_index, value) => { let mut normalized = value as f32 * (i16::MAX as f32).recip(); - let input_settings = resources.get::(); - let player_control = fighter_object.get_component_mut::()?; if let Some((control, inverted)) = input_settings.map_axis(joystick.name(), joystick.id(), axis_index) @@ -230,14 +235,18 @@ impl Game { }; match control { - Control::Throttle => player_control.set_throttle(normalized), - Control::StrafeHorizontal => { - player_control.set_left_right_strafe(normalized) + Control::Throttle => { + commands.write_event(PlayerInputEvent::Throttle(normalized)) } - Control::StrafeVertical => player_control.set_up_down_strafe(normalized), - Control::Yaw => player_control.set_yaw(normalized), - Control::Pitch => player_control.set_pitch(normalized), - Control::Roll => player_control.set_roll(normalized), + Control::StrafeHorizontal => { + commands.write_event(PlayerInputEvent::StrafeHorizontal(normalized)) + } + Control::StrafeVertical => { + commands.write_event(PlayerInputEvent::StrafeVertical(normalized)) + } + Control::Yaw => commands.write_event(PlayerInputEvent::Yaw(normalized)), + Control::Pitch => commands.write_event(PlayerInputEvent::Pitch(normalized)), + Control::Roll => commands.write_event(PlayerInputEvent::Roll(normalized)), Control::PrimaryWeapon => (), Control::SecondaryWeapon => (), @@ -254,14 +263,17 @@ impl Game { impl Game { pub fn setup_updates(world_builder: &mut WorldBuilder) -> Result<()> { - if !FREE_CAMERA_CONTROL { - world_builder.add_update(1_000, Self::camera_update)?; - } + // if !FREE_CAMERA_CONTROL { + world_builder.add_update(1_000, Self::camera_update)?; + // } world_builder.add_update(100, Self::celestial_velocity_update)?; world_builder.add_update(200, Self::player_orientation)?; world_builder.add_update(110, Self::celestial_buffer_update)?; + world_builder.events.register_event::(); + world_builder.events.add_reader(PlayerInputEvent::event); + Ok(()) } @@ -274,9 +286,9 @@ impl Game { 0.02, FreeSpaceControlSettings::default(), )); + fighter.insert_component(Player); - let player = PlayerEntity(world.add_entity(fighter)?); - world.resources.insert(player); + world.add_entity(fighter)?; world.resources.insert(InputSettings::default()); let mut example_sun = CelestialObject::new(world, CelestialClass::Sun, 5, None)?; @@ -365,3 +377,33 @@ impl Game { Ok(()) } } + +enum PlayerInputEvent { + Throttle(f32), + StrafeHorizontal(f32), + StrafeVertical(f32), + Yaw(f32), + Pitch(f32), + Roll(f32), +} + +impl PlayerInputEvent { + fn event( + &self, + _commands: &mut Commands, + mut query: Query<(&mut FreeSpaceControl, &mut Player)>, + ) -> Result<()> { + let (player_control, _) = &mut *query; + + match *self { + PlayerInputEvent::Throttle(v) => player_control.set_throttle(v), + PlayerInputEvent::StrafeHorizontal(v) => player_control.set_left_right_strafe(v), + PlayerInputEvent::StrafeVertical(v) => player_control.set_up_down_strafe(v), + PlayerInputEvent::Yaw(v) => player_control.set_yaw(v), + PlayerInputEvent::Pitch(v) => player_control.set_pitch(v), + PlayerInputEvent::Roll(v) => player_control.set_roll(v), + } + + Ok(()) + } +} diff --git a/examples/free_space/src/game_state.rs b/examples/free_space/src/game_state.rs index 1f0964d..66c5807 100644 --- a/examples/free_space/src/game_state.rs +++ b/examples/free_space/src/game_state.rs @@ -3,7 +3,7 @@ use anyhow::Result; use ecs::*; use engine::prelude::*; -use crate::game::Game; +use crate::game::{Game, InputSettings}; #[derive(Default, Resource)] pub enum GameState { @@ -14,26 +14,24 @@ pub enum GameState { } impl GameState { - pub fn update( - commands: &mut Commands, - game_state: &mut GameState, - scene: &mut Scene, - camera_control: &mut FreeCameraControl, - ) -> Result { + pub fn update(commands: &mut Commands, game_state: &mut GameState) -> Result { match game_state { GameState::Startup => *game_state = GameState::Game(Game), - GameState::Game(game) => game.update(commands, scene, camera_control)?, + GameState::Game(game) => game.update(commands)?, } Ok(true) } -} -impl EventConsumer for GameState { - fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { + pub fn event( + &mut self, + commands: &mut Commands, + event: EngineEvent<'_>, + input_settings: &mut InputSettings, + ) -> Result<()> { match self { GameState::Startup => (), - GameState::Game(game) => game.event(commands, event)?, + GameState::Game(game) => game.event(commands, event, input_settings)?, } Ok(()) diff --git a/examples/free_space/src/main.rs b/examples/free_space/src/main.rs index a6e1afd..40672e6 100644 --- a/examples/free_space/src/main.rs +++ b/examples/free_space/src/main.rs @@ -12,7 +12,7 @@ use game::Game; use game_state::GameState; use skybox::SkyBox; -const FREE_CAMERA_CONTROL: bool = false; +// const FREE_CAMERA_CONTROL: bool = false; fn main() -> Result<()> { let mut world_builder = World::builder(); @@ -21,7 +21,8 @@ fn main() -> Result<()> { engine_ci.resource_base_path = "/home/michaelh/Sync/space_game/".to_string(); engine_ci.asset_directories.gltf_file_directory = "objects".into(); - Engine::new::(engine_ci, &mut world_builder)?; + Engine::new(engine_ci, &mut world_builder)?; + Engine::event_system(&mut world_builder, GameState::event); world_builder.add_system(10, GameState::update); world_builder.resources.insert(GameState::default()); @@ -40,12 +41,12 @@ fn main() -> Result<()> { .into_iter(), )?; - if FREE_CAMERA_CONTROL { - let scene: &mut Scene = world_builder.resources.get_mut()?; - let view = scene.view_mut(); - let camera_control = FreeCameraControl::new(view)?; - world_builder.resources.insert(camera_control); - } + // if FREE_CAMERA_CONTROL { + // let scene: &mut Scene = world_builder.resources.get_mut()?; + // let view = scene.view_mut(); + // let camera_control = FreeCameraControl::new(view)?; + // world_builder.resources.insert(camera_control); + // } Game::setup_updates(&mut world_builder)?; let mut world = world_builder.build(); diff --git a/examples/simple_window/src/main.rs b/examples/simple_window/src/main.rs index b65a59f..3757691 100644 --- a/examples/simple_window/src/main.rs +++ b/examples/simple_window/src/main.rs @@ -3,32 +3,15 @@ use anyhow::Result; use ecs::*; use engine::prelude::*; -struct CameraControlStart; -struct CameraControlEnd; -struct CameraControlMove { - x: u32, - y: u32, -} - fn main() -> Result<()> { let mut world_builder = World::builder(); - Engine::new::(EngineCreateInfo::default(), &mut world_builder)?; - Engine::event_system(&mut world_builder); + Engine::new(EngineCreateInfo::default(), &mut world_builder)?; + Engine::event_system(&mut world_builder, GameState::event); world_builder.add_system(10, GameState::update); world_builder.resources.insert(GameState::default()); - world_builder.events.register_event::(); - world_builder.events.register_event::(); - world_builder.events.register_event::(); - - world_builder.events.add_reader(Game::enable_camera_control); - world_builder - .events - .add_reader(Game::disable_camera_control); - world_builder.events.add_reader(Game::update_mouse); - let scene: &mut Scene = world_builder.resources.get_mut()?; let view = scene.view_mut(); let camera_control = FreeCameraControl::new(view)?; @@ -54,13 +37,17 @@ impl GameState { Ok(true) } -} -impl EventConsumer for GameState { - fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { + fn event( + &mut self, + commands: &mut Commands, + event: EngineEvent<'_>, + camera_control: &mut FreeCameraControl, + scene: &mut Scene, + ) -> Result<()> { match self { GameState::Startup => (), - GameState::Game(game) => game.event(commands, event)?, + GameState::Game(game) => game.event(commands, event, camera_control, scene)?, } Ok(()) @@ -70,48 +57,27 @@ impl EventConsumer for GameState { struct Game; impl Game { - fn enable_camera_control( - _: &CameraControlStart, - _commands: &mut Commands, - camera_control: &mut FreeCameraControl, - ) -> Result<()> { - camera_control.mouse_down(); - - Ok(()) - } - - fn disable_camera_control( - _: &CameraControlEnd, - _commands: &mut Commands, - camera_control: &mut FreeCameraControl, - ) -> Result<()> { - camera_control.mouse_release(); - - Ok(()) - } - - fn update_mouse( - camera_move: &CameraControlMove, - _commands: &mut Commands, - camera_control: &mut FreeCameraControl, - scene: &mut Scene, - ) -> Result<()> { - camera_control.mouse_move(camera_move.x, camera_move.y, scene.view_mut())?; - - Ok(()) - } - fn update(&mut self, _commands: &mut Commands) -> Result<()> { Ok(()) } - fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { + fn event( + &mut self, + _commands: &mut Commands, + event: EngineEvent<'_>, + camera_control: &mut FreeCameraControl, + scene: &mut Scene, + ) -> Result<()> { match event { EngineEvent::MouseButtonDown(MouseButton::Left) => { - commands.write_event(CameraControlStart) + camera_control.mouse_down(); + } + EngineEvent::MouseButtonUp(MouseButton::Left) => { + camera_control.mouse_release(); + } + EngineEvent::MouseMotion(x, y) => { + camera_control.mouse_move(x, y, scene.view_mut())?; } - EngineEvent::MouseButtonUp(MouseButton::Left) => commands.write_event(CameraControlEnd), - EngineEvent::MouseMotion(x, y) => commands.write_event(CameraControlMove { x, y }), _ => (), }