hodasemi/engine
1
1
Fork 0
Code Issues 3 Pull requests 1 Projects Releases Wiki Activity Actions

Fix examples

Browse source
This commit is contained in:
hodasemi 2025-04-11 09:59:51 +02:00
parent 49da5c947d
commit d2e70481ce
7 changed files with 550 additions and 515 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
engine/src/engine/engine.rs
View file

@ -6,7 +6,7 @@ use super::engine_settings::EngineSettings;
use anyhow::Result; use anyhow::Result;
use assetpath::AssetPath; use assetpath::AssetPath;
use context::prelude::cgmath::vec3; use context::prelude::cgmath::vec3;
use ecs::{Resource, resources::Resource as ResourceTrait}; use ecs::Resource;
use crate::assets::asset_manager::AssetManager; use crate::assets::asset_manager::AssetManager;
use crate::prelude::*; use crate::prelude::*;
@ -20,7 +20,7 @@ pub struct Engine {
} }
impl Engine { impl Engine {
pub fn new<T: ResourceTrait + EventConsumer>( pub fn new(
#[allow(unused)] mut create_info: EngineCreateInfo<'_>, #[allow(unused)] mut create_info: EngineCreateInfo<'_>,
world: &mut WorldBuilder, world: &mut WorldBuilder,
) -> Result<()> { ) -> Result<()> {
@ -171,10 +171,9 @@ impl Engine {
world.resources.insert(engine_settings); world.resources.insert(engine_settings);
world.add_system(1, Self::start_frame); world.add_system(1, Self::start_frame);
world.add_system(u32::MAX, Self::end_frame); world.add_system(10_000, Self::render_scene);
world.add_system(100, Self::render_scene);
world.add_system(10_000_000, Self::render_gui); world.add_system(10_000_000, Self::render_gui);
world.add_system(u32::MAX, Self::end_frame);
Ok(()) Ok(())
} }

709
engine/src/engine/engine_event_handling.rs
View file

@ -37,347 +37,376 @@ pub trait EventSystem<Func, T> {
fn event_system(world_builder: &mut WorldBuilder, func: Func); fn event_system(world_builder: &mut WorldBuilder, func: Func);
} }
impl<Func, T> EventSystem<Func, T> for Engine macro_rules! impl_event_system {
where ( $( $t:ident, )* ) => {
Func: Fn(&mut T, &mut Commands, EngineEvent<'_>) -> Result<()> + Send + Sync + 'static, paste::paste! {
T: ResourceTrait, impl<Func, T, $( $t, )* > EventSystem<Func, (T, $( $t, )*)> for Engine
{ where
fn event_system(world_builder: &mut WorldBuilder, func: Func) { Func: Fn(&mut T, &mut Commands, EngineEvent<'_>, $( &mut $t, )* ) -> Result<()> + Send + Sync + 'static,
world_builder.add_system( T: ResourceTrait,
0, $(
|world: &World, $t: ResourceTrait,
commands: &mut Commands, )*
consumer: &mut T, {
gui_handler: &mut GuiHandler, fn event_system(world_builder: &mut WorldBuilder, func: Func) {
input_map: &mut InputMap, world_builder.add_system(
context: &mut Context| 0,
-> Result<bool> { move |world: &World,
let res = context.events(world, |event| { commands: &mut Commands,
Self::event(commands, gui_handler, input_map, consumer, event, func) consumer: &mut T,
})?; gui_handler: &mut GuiHandler,
input_map: &mut InputMap,
context: &mut Context,
$(
[< $t:lower >]: &mut $t,
)*
|
-> Result<bool> {
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 { impl_event_system!();
pub(crate) fn event<T>( impl_event_system!(A, B,);
commands: &mut Commands, impl_event_system!(A, B, C,);
gui_handler: &mut GuiHandler, impl_event_system!(A, B, C, D,);
input: &InputMap, impl_event_system!(A, B, C, D, E,);
consumer: &mut T, impl_event_system!(A, B, C, D, E, F,);
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<T: EventConsumer>(
commands: &mut Commands,
consumer: &mut T,
controller: &Controller,
) -> Result<()> {
consumer.event(commands, EngineEvent::ControllerAdded(controller))?;
Ok(())
}
#[inline]
fn controller_removed<T: EventConsumer>(
commands: &mut Commands,
consumer: &mut T,
controller: &Controller,
) -> Result<()> {
consumer.event(commands, EngineEvent::ControllerRemoved(controller))?;
Ok(())
}
#[inline]
fn key_up_event<T: EventConsumer>(
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<T: EventConsumer>(
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<T: EventConsumer>(
commands: &mut Commands,
consumer: &mut T,
controller: &Controller,
button: ControllerButton,
) -> Result<()> {
consumer.event(
commands,
EngineEvent::ControllerButtonUp(controller, button),
)?;
Ok(())
}
#[inline]
fn button_down_event<T: EventConsumer>(
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<T: EventConsumer>(
commands: &mut Commands,
consumer: &mut T,
controller: &Controller,
) -> Result<()> {
consumer.event(
commands,
EngineEvent::ControllerAxis(controller, controller.controller_axis()),
)?;
Ok(())
}
#[inline]
fn check_button_down<T: EventConsumer>(
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(())
}
}

2
engine/src/prelude.rs
View file

@ -10,7 +10,7 @@ pub use crate::engine::{
asset_handler::{AssetHandler, AssetLoader}, asset_handler::{AssetHandler, AssetLoader},
engine::*, engine::*,
engine_create_info::EngineCreateInfo, engine_create_info::EngineCreateInfo,
engine_event_handling::{EngineEvent, EventConsumer, EventSystem}, engine_event_handling::{EngineEvent, EventSystem},
engine_settings::*, engine_settings::*,
}; };

224
examples/free_space/src/game.rs
View file

@ -8,10 +8,22 @@ use engine::prelude::{
*, *,
}; };
use crate::{FREE_CAMERA_CONTROL, celestial_object::*}; use crate::celestial_object::*;
#[derive(Clone, Copy, Debug, Resource)] #[derive(Debug)]
struct PlayerEntity(Entity); 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)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Input { enum Input {
@ -38,7 +50,7 @@ enum Control {
} }
#[derive(Clone, Debug, Resource)] #[derive(Clone, Debug, Resource)]
struct InputSettings { pub struct InputSettings {
mappings: HashMap<(String, u32, Input), (Control, bool)>, mappings: HashMap<(String, u32, Input), (Control, bool)>,
} }
@ -109,23 +121,23 @@ impl InputSettings {
pub struct Game; pub struct Game;
impl Game { impl Game {
pub fn update( pub fn update(&mut self, commands: &mut Commands) -> Result<()> {
&mut self, // if FREE_CAMERA_CONTROL {
commands: &mut Commands, // let now = commands.now();
scene: &mut Scene,
camera_control: &mut FreeCameraControl,
) -> Result<()> {
if FREE_CAMERA_CONTROL {
let now = commands.now();
camera_control.update(now, scene.view_mut())?; // camera_control.update(now, scene.view_mut())?;
} // }
Ok(()) Ok(())
} }
pub fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { pub fn event(
if let Some(event) = Self::motion_concepts(world, 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 { match event {
EngineEvent::JoystickAdded(joystick) => { EngineEvent::JoystickAdded(joystick) => {
println!("joystick {} added", joystick.name()); println!("joystick {} added", joystick.name());
@ -142,85 +154,78 @@ impl Game {
Ok(()) Ok(())
} }
fn motion_concepts<'a>( // fn motion_concepts<'a>(
world: &mut World, // world: &mut World,
event: EngineEvent<'a>, // event: EngineEvent<'a>,
) -> Result<Option<EngineEvent<'a>>> { // ) -> Result<Option<EngineEvent<'a>>> {
if FREE_CAMERA_CONTROL { // if FREE_CAMERA_CONTROL {
Self::free_camera(world, event) // Self::free_camera(world, event)
} else { // } else {
Self::joystick_movement(world, event) // Self::joystick_movement(world, event)
} // }
} // }
fn free_camera<'a>( // (fn free_camera<'a>(event: EngineEvent<'a>) -> Result<Option<EngineEvent<'a>>> {
world: &mut World, // match event {
event: EngineEvent<'a>, // EngineEvent::MouseButtonDown(MouseButton::Middle) => {
) -> Result<Option<EngineEvent<'a>>> { // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?;
match event { // camera_control.mouse_down();
EngineEvent::MouseButtonDown(MouseButton::Middle) => { // }
let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; // EngineEvent::MouseButtonUp(MouseButton::Middle) => {
camera_control.mouse_down(); // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?;
} // camera_control.mouse_release();
EngineEvent::MouseButtonUp(MouseButton::Middle) => { // }
let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; // EngineEvent::MouseMotion(x, y) => {
camera_control.mouse_release(); // let (scene, camera_control): (&mut Scene, &mut FreeCameraControl) =
} // world.resources.get_mut()?;
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)); // return Ok(Some(event));
} // }
EngineEvent::KeyDown(key) => { // EngineEvent::KeyDown(key) => {
let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?;
match key { // match key {
Keycode::W => camera_control.forward_back(1.0), // Keycode::W => camera_control.forward_back(1.0),
Keycode::A => camera_control.left_right(-1.0), // Keycode::A => camera_control.left_right(-1.0),
Keycode::S => camera_control.forward_back(-1.0), // Keycode::S => camera_control.forward_back(-1.0),
Keycode::D => camera_control.left_right(1.0), // Keycode::D => camera_control.left_right(1.0),
Keycode::Space => camera_control.up_down(1.0), // Keycode::Space => camera_control.up_down(1.0),
Keycode::LCtrl => camera_control.up_down(-1.0), // Keycode::LCtrl => camera_control.up_down(-1.0),
_ => return Ok(Some(event)), // _ => return Ok(Some(event)),
} // }
} // }
EngineEvent::KeyUp(key) => { // EngineEvent::KeyUp(key) => {
let camera_control: &mut FreeCameraControl = world.resources.get_mut()?; // let camera_control: &mut FreeCameraControl = world.resources.get_mut()?;
match key { // match key {
Keycode::W => camera_control.forward_back(-1.0), // Keycode::W => camera_control.forward_back(-1.0),
Keycode::A => camera_control.left_right(1.0), // Keycode::A => camera_control.left_right(1.0),
Keycode::S => camera_control.forward_back(1.0), // Keycode::S => camera_control.forward_back(1.0),
Keycode::D => camera_control.left_right(-1.0), // Keycode::D => camera_control.left_right(-1.0),
Keycode::Space => camera_control.up_down(-1.0), // Keycode::Space => camera_control.up_down(-1.0),
Keycode::LCtrl => 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>( fn joystick_movement<'a>(
world: &mut World, commands: &mut Commands,
event: EngineEvent<'a>, event: EngineEvent<'a>,
input_settings: &mut InputSettings,
) -> Result<Option<EngineEvent<'a>>> { ) -> Result<Option<EngineEvent<'a>>> {
let player = world.resources.get::<PlayerEntity>();
let (fighter_object, resources) = world.entity_resources(player.0)?;
match event { match event {
EngineEvent::JoystickAxis(joystick, axis_index, value) => { EngineEvent::JoystickAxis(joystick, axis_index, value) => {
let mut normalized = value as f32 * (i16::MAX as f32).recip(); let mut normalized = value as f32 * (i16::MAX as f32).recip();
let input_settings = resources.get::<InputSettings>();
let player_control = fighter_object.get_component_mut::<FreeSpaceControl>()?;
if let Some((control, inverted)) = if let Some((control, inverted)) =
input_settings.map_axis(joystick.name(), joystick.id(), axis_index) input_settings.map_axis(joystick.name(), joystick.id(), axis_index)
@ -230,14 +235,18 @@ impl Game {
}; };
match control { match control {
Control::Throttle => player_control.set_throttle(normalized), Control::Throttle => {
Control::StrafeHorizontal => { commands.write_event(PlayerInputEvent::Throttle(normalized))
player_control.set_left_right_strafe(normalized)
} }
Control::StrafeVertical => player_control.set_up_down_strafe(normalized), Control::StrafeHorizontal => {
Control::Yaw => player_control.set_yaw(normalized), commands.write_event(PlayerInputEvent::StrafeHorizontal(normalized))
Control::Pitch => player_control.set_pitch(normalized), }
Control::Roll => player_control.set_roll(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::PrimaryWeapon => (),
Control::SecondaryWeapon => (), Control::SecondaryWeapon => (),
@ -254,14 +263,17 @@ impl Game {
impl Game { impl Game {
pub fn setup_updates(world_builder: &mut WorldBuilder) -> Result<()> { pub fn setup_updates(world_builder: &mut WorldBuilder) -> Result<()> {
if !FREE_CAMERA_CONTROL { // if !FREE_CAMERA_CONTROL {
world_builder.add_update(1_000, Self::camera_update)?; world_builder.add_update(1_000, Self::camera_update)?;
} // }
world_builder.add_update(100, Self::celestial_velocity_update)?; world_builder.add_update(100, Self::celestial_velocity_update)?;
world_builder.add_update(200, Self::player_orientation)?; world_builder.add_update(200, Self::player_orientation)?;
world_builder.add_update(110, Self::celestial_buffer_update)?; world_builder.add_update(110, Self::celestial_buffer_update)?;
world_builder.events.register_event::<PlayerInputEvent>();
world_builder.events.add_reader(PlayerInputEvent::event);
Ok(()) Ok(())
} }
@ -274,9 +286,9 @@ impl Game {
0.02, 0.02,
FreeSpaceControlSettings::default(), FreeSpaceControlSettings::default(),
)); ));
fighter.insert_component(Player);
let player = PlayerEntity(world.add_entity(fighter)?); world.add_entity(fighter)?;
world.resources.insert(player);
world.resources.insert(InputSettings::default()); world.resources.insert(InputSettings::default());
let mut example_sun = CelestialObject::new(world, CelestialClass::Sun, 5, None)?; let mut example_sun = CelestialObject::new(world, CelestialClass::Sun, 5, None)?;
@ -365,3 +377,33 @@ impl Game {
Ok(()) 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(())
}
}

22
examples/free_space/src/game_state.rs
View file

@ -3,7 +3,7 @@ use anyhow::Result;
use ecs::*; use ecs::*;
use engine::prelude::*; use engine::prelude::*;
use crate::game::Game; use crate::game::{Game, InputSettings};
#[derive(Default, Resource)] #[derive(Default, Resource)]
pub enum GameState { pub enum GameState {
@ -14,26 +14,24 @@ pub enum GameState {
} }
impl GameState { impl GameState {
pub fn update( pub fn update(commands: &mut Commands, game_state: &mut GameState) -> Result<bool> {
commands: &mut Commands,
game_state: &mut GameState,
scene: &mut Scene,
camera_control: &mut FreeCameraControl,
) -> Result<bool> {
match game_state { match game_state {
GameState::Startup => *game_state = GameState::Game(Game), GameState::Startup => *game_state = GameState::Game(Game),
GameState::Game(game) => game.update(commands, scene, camera_control)?, GameState::Game(game) => game.update(commands)?,
} }
Ok(true) Ok(true)
} }
}
impl EventConsumer for GameState { pub fn event(
fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { &mut self,
commands: &mut Commands,
event: EngineEvent<'_>,
input_settings: &mut InputSettings,
) -> Result<()> {
match self { match self {
GameState::Startup => (), GameState::Startup => (),
GameState::Game(game) => game.event(commands, event)?, GameState::Game(game) => game.event(commands, event, input_settings)?,
} }
Ok(()) Ok(())

17
examples/free_space/src/main.rs
View file

@ -12,7 +12,7 @@ use game::Game;
use game_state::GameState; use game_state::GameState;
use skybox::SkyBox; use skybox::SkyBox;
const FREE_CAMERA_CONTROL: bool = false; // const FREE_CAMERA_CONTROL: bool = false;
fn main() -> Result<()> { fn main() -> Result<()> {
let mut world_builder = World::builder(); 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.resource_base_path = "/home/michaelh/Sync/space_game/".to_string();
engine_ci.asset_directories.gltf_file_directory = "objects".into(); engine_ci.asset_directories.gltf_file_directory = "objects".into();
Engine::new::<GameState>(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.add_system(10, GameState::update);
world_builder.resources.insert(GameState::default()); world_builder.resources.insert(GameState::default());
@ -40,12 +41,12 @@ fn main() -> Result<()> {
.into_iter(), .into_iter(),
)?; )?;
if FREE_CAMERA_CONTROL { // if FREE_CAMERA_CONTROL {
let scene: &mut Scene = world_builder.resources.get_mut()?; // let scene: &mut Scene = world_builder.resources.get_mut()?;
let view = scene.view_mut(); // let view = scene.view_mut();
let camera_control = FreeCameraControl::new(view)?; // let camera_control = FreeCameraControl::new(view)?;
world_builder.resources.insert(camera_control); // world_builder.resources.insert(camera_control);
} // }
Game::setup_updates(&mut world_builder)?; Game::setup_updates(&mut world_builder)?;
let mut world = world_builder.build(); let mut world = world_builder.build();

82
examples/simple_window/src/main.rs
View file

@ -3,32 +3,15 @@ use anyhow::Result;
use ecs::*; use ecs::*;
use engine::prelude::*; use engine::prelude::*;
struct CameraControlStart;
struct CameraControlEnd;
struct CameraControlMove {
x: u32,
y: u32,
}
fn main() -> Result<()> { fn main() -> Result<()> {
let mut world_builder = World::builder(); let mut world_builder = World::builder();
Engine::new::<GameState>(EngineCreateInfo::default(), &mut world_builder)?; Engine::new(EngineCreateInfo::default(), &mut world_builder)?;
Engine::event_system(&mut world_builder); Engine::event_system(&mut world_builder, GameState::event);
world_builder.add_system(10, GameState::update); world_builder.add_system(10, GameState::update);
world_builder.resources.insert(GameState::default()); world_builder.resources.insert(GameState::default());
world_builder.events.register_event::<CameraControlStart>();
world_builder.events.register_event::<CameraControlEnd>();
world_builder.events.register_event::<CameraControlMove>();
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 scene: &mut Scene = world_builder.resources.get_mut()?;
let view = scene.view_mut(); let view = scene.view_mut();
let camera_control = FreeCameraControl::new(view)?; let camera_control = FreeCameraControl::new(view)?;
@ -54,13 +37,17 @@ impl GameState {
Ok(true) Ok(true)
} }
}
impl EventConsumer for GameState { fn event(
fn event(&mut self, commands: &mut Commands, event: EngineEvent<'_>) -> Result<()> { &mut self,
commands: &mut Commands,
event: EngineEvent<'_>,
camera_control: &mut FreeCameraControl,
scene: &mut Scene,
) -> Result<()> {
match self { match self {
GameState::Startup => (), GameState::Startup => (),
GameState::Game(game) => game.event(commands, event)?, GameState::Game(game) => game.event(commands, event, camera_control, scene)?,
} }
Ok(()) Ok(())
@ -70,48 +57,27 @@ impl EventConsumer for GameState {
struct Game; struct Game;
impl 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<()> { fn update(&mut self, _commands: &mut Commands) -> Result<()> {
Ok(()) 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 { match event {
EngineEvent::MouseButtonDown(MouseButton::Left) => { 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 }),
_ => (), _ => (),
} }