SeanOMik
/
lyra-engine
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

Switch ecs to edict

This commit is contained in:
SeanOMik 2023-08-31 21:34:58 -04:00
parent 805fde2d4e
commit 73b44857eb
Signed by: SeanOMik
GPG Key ID: 568F326C7EB33ACB
18 changed files with 232 additions and 375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
Cargo.lock generated
View File

@ -264,6 +264,12 @@ version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1181e1e0d1fce796a03db1ae795d67167da795f9cf4a39c37589e85ef57f26d3"
[[package]]
name = "atomicell"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "157342dd84c64f16899b4b16c1fb2cce54b887990362aac3c590b3d13810890f"
[[package]]
name = "autocfg"
version = "1.1.0"
@ -534,6 +540,42 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
[[package]]
name = "edict"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d85bf7cde5687ce04b093bfe183453fa12996b6bdfd2567a0262ebd621761d77"
dependencies = [
"atomicell",
"edict-proc",
"hashbrown 0.13.2",
"parking_lot",
"smallvec",
"tiny-fn",
]
[[package]]
name = "edict-proc"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c94d80dc0f05250a9082bb9455bbf3d6c6c51db388b060df914aebcfb4a9b9f1"
dependencies = [
"edict-proc-lib",
"syn 2.0.26",
]
[[package]]
name = "edict-proc-lib"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52d98f9931a4f71c7eb7d85cf4ef1271b27014625c85a65376a52c10ac4ffaea"
dependencies = [
"proc-easy",
"proc-macro2",
"quote",
"syn 2.0.26",
]
[[package]]
name = "equivalent"
version = "1.0.1"
@ -1036,8 +1078,10 @@ dependencies = [
"anyhow",
"async-std",
"async-trait",
"atomicell",
"bytemuck",
"cfg-if",
"edict",
"gilrs-core",
"glam",
"hecs",
@ -1492,6 +1536,17 @@ dependencies = [
"windows-sys 0.48.0",
]
[[package]]
name = "proc-easy"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ea59c637cd0e6b71ae18e589854e9de9b7cb17fefdbf2047e42bd38e24285b19"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.26",
]
[[package]]
name = "proc-macro-crate"
version = "1.3.1"
@ -1780,6 +1835,12 @@ dependencies = [
"once_cell",
]
[[package]]
name = "tiny-fn"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af7b2c33e09916c65a15c92c1e583946052527e06102689ed11c6125f64fa8ba"
[[package]]
name = "tiny-skia"
version = "0.8.4"

2
Cargo.toml
View File

@ -27,3 +27,5 @@ petgraph = "0.6.3"
gilrs-core = "0.5.6"
syn = "2.0.26"
quote = "1.0.29"
edict = "0.5.0"
atomicell = "0.1.9"

2
src/ecs/components/camera.rs
View File

@ -1,7 +1,9 @@
use edict::Component;
use winit::dpi::PhysicalSize;
use crate::{math::{Angle, OPENGL_TO_WGPU_MATRIX, Transform}, render::camera::CameraProjectionMode};
#[derive(Clone, Component)]
pub struct CameraComponent {
pub transform: Transform,
pub fov: Angle,

4
src/ecs/components/mesh.rs
View File

@ -1,6 +1,8 @@
use edict::Component;
use crate::render::{vertex::Vertex, mesh::Mesh, material::Material};
#[derive(Clone)]
#[derive(Clone, Component)]
pub struct MeshComponent {
pub mesh: Mesh,
pub material: Material,

4
src/ecs/components/transform.rs
View File

@ -1,6 +1,8 @@
use edict::Component;
use crate::math::Transform;
#[derive(Clone)]
#[derive(Clone, Component)]
pub struct TransformComponent {
pub transform: Transform,
}

5
src/ecs/mod.rs
View File

@ -6,11 +6,8 @@ use tracing::warn;
use crate::game::Controls;
pub mod components;
pub mod world;
pub mod resources;
use world::World;
/// A trait that represents a simple system
pub trait SimpleSystem {
fn setup(&mut self, controls: &mut Controls) -> anyhow::Result<()> {
@ -22,7 +19,7 @@ pub trait SimpleSystem {
}
impl<S> SimpleSystem for S
where S: FnMut(&mut World) -> anyhow::Result<()>
where S: FnMut(&mut edict::World) -> anyhow::Result<()>
{
fn execute_mut(&mut self, controls: &mut Controls) -> anyhow::Result<()> {
self(controls.world)

63
src/ecs/resources/event_queue.rs Normal file
View File

@ -0,0 +1,63 @@
use std::{collections::{HashMap, VecDeque}, any::{TypeId, Any}, cell::{RefCell, Ref, RefMut}};
use super::{CastableAny, Events, Event};
pub struct EventQueue {
events: HashMap<TypeId, RefCell<Box<dyn CastableAny>>>,
event_write_queue: HashMap<TypeId, RefCell<Box<dyn CastableAny>>>
}
impl EventQueue {
pub fn new() -> Self {
Self {
event_write_queue: HashMap::new(),
events: HashMap::new(),
}
}
/// Trigger an event
pub fn trigger_event<E>(&mut self, event: E)
where
E: Event
{
// the compiler wants me to explicit right here for some reason
let default = || RefCell::new(Box::new(Events::<E>::new()) as Box<dyn CastableAny>);
// Get, or create, a list of events of this type
let type_id = event.type_id();
let mut events = self.event_write_queue.entry(type_id)
.or_insert_with(default)
.borrow_mut();
// downcast resource as an events storage
let e: &mut Events<E> = events.as_mut().as_any_mut().downcast_mut().unwrap();
e.push_back(event);
}
// Clear events, this should happen at the start of every tick since events are cloned
// before being given to the reader.
pub fn update_events(&mut self) {
self.events.clear();
// get all keys of events
let keys: Vec<TypeId> = self.event_write_queue.keys().map(|k| k.clone()).collect();
// remove all elements from self.event_write_queue and insert them to events
for k in keys.into_iter() {
let v = self.event_write_queue.remove(&k).unwrap();
self.events.insert(k, v);
}
}
pub fn read_events<E>(&self) -> Option<Events<E>>
where
E: Event
{
if let Some(event ) = self.events.get(&TypeId::of::<E>()) {
let eref = event.borrow();
Some(eref.as_ref().as_any().downcast_ref::<Events<E>>().unwrap().clone())
} else {
None
}
}
}

51
src/ecs/resources/events.rs
View File

@ -1,53 +1,6 @@
use std::{collections::VecDeque, ops::{Deref, DerefMut}};
use super::Resource;
use std::collections::VecDeque;
pub trait Event: Clone + Send + Sync + 'static {}
impl<T: Clone + Send + Sync + 'static> Event for T {}
#[derive(Clone)]
pub struct Events<T: Event> {
inner: VecDeque<T>
}
impl<T: Event> Events<T> {
pub fn new() -> Self {
Self {
inner: VecDeque::new()
}
}
}
impl<T: Event> Deref for Events<T> {
type Target = VecDeque<T>;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<T: Event> DerefMut for Events<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<T: Event> Resource for Events<T> {
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
self
}
}
pub trait EventHolder {
fn get_data<T>() -> T;
}
pub struct EventStorage<T> {
data: T,
is_future: bool,
}
pub type Events<T> = VecDeque<T>;

18
src/ecs/resources/mod.rs
View File

@ -8,22 +8,16 @@ pub use window_state::*;
pub mod events;
pub use events::*;
pub trait Resource: Send + Sync + 'static {
pub mod event_queue;
pub use event_queue::*;
pub trait CastableAny: Send + Sync + 'static {
fn as_any(&self) -> &dyn Any;
fn as_any_mut(&mut self) -> &mut dyn Any;
}
impl Resource for WindowEvent<'static> {
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
impl<T: Sync + Send + 'static> Resource for VecDeque<T> {
/// Implements this trait for anything that fits the type bounds
impl<T: Send + Sync + 'static> CastableAny for T {
fn as_any(&self) -> &dyn Any {
self
}

12
src/ecs/resources/window_state.rs
View File

@ -1,6 +1,6 @@
use std::any::Any;
use super::Resource;
use super::CastableAny;
#[derive(Clone, Default)]
pub struct WindowState {
@ -12,14 +12,4 @@ impl WindowState {
pub fn new() -> Self {
Self::default()
}
}
impl Resource for WindowState {
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}

185
src/ecs/world.rs
View File

@ -1,185 +0,0 @@
use std::{any::{TypeId, Any}, collections::{HashMap, HashSet, VecDeque}, ops::{Deref, DerefMut}, cell::{RefCell, Ref, RefMut}};
use tracing::debug;
use super::resources::{Resource, Events};
pub struct World {
inner: hecs::World,
resources: HashMap<TypeId, Box<RefCell<dyn Resource>>>,
updated_resources: HashSet<TypeId>,
// a boolean that flip flops to clear events every other frame
events_flipflop: bool,
events: HashMap<TypeId, Box<RefCell<dyn Resource>>>,
event_write_queue: HashMap<TypeId, Box<RefCell<dyn Resource>>>,//VecDeque<(TypeId, Box<dyn Resource>)>,
}
impl Deref for World {
type Target = hecs::World;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl DerefMut for World {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
#[allow(dead_code)]
impl World {
pub fn new() -> Self {
Self::from_hecs(hecs::World::new())
}
pub fn from_hecs(hecs_world: hecs::World) -> Self {
Self {
inner: hecs_world,
resources: HashMap::new(),
updated_resources: HashSet::new(),
events_flipflop: false,
events: HashMap::new(),
event_write_queue: HashMap::new(),
}
}
/// Attempts to query a resource, or will create it when its not found.
///
/// The resource will be created by a function passed in `default`.
pub fn query_or_insert_res<R>(&mut self, default: impl Fn() -> Box<RefCell<dyn Resource + 'static>>) -> RefMut<R>
where
R: Resource,
{
let type_id = TypeId::of::<R>();
let r = self.resources.entry(type_id)
.or_insert_with(default)
.borrow_mut();
RefMut::map(r, |r| r.as_any_mut().downcast_mut::<R>().unwrap())
}
/// Insert a resource into the World. You can only have one resource of the same type.
/// If you attempt to add another resource of the same type, it will be replaced.
///
/// This will also mark the resource as updated in this frame.
pub fn insert_resource<R>(&mut self, res: R)
where
R: Resource
{
let type_id = res.type_id();
self.resources.insert(type_id, Box::new(RefCell::new(res)));
self.updated_resources.insert(type_id);
}
/// Checks if a resource was updated this frame.
pub fn was_res_updated<R>(&self) -> bool
where
R: Resource
{
self.updated_resources.contains(&TypeId::of::<R>())
}
pub(crate) fn clear_updated_resources(&mut self) {
self.updated_resources.clear();
}
/// Trigger an event
pub fn trigger_event<E>(&mut self, event: E)
where
E: Clone + Send + Sync + 'static
{
// the compiler wants me to explicit right here for some reason
let default = || Box::new(RefCell::new(Events::<E>::new())) as Box<RefCell<(dyn Resource + 'static)>>;
// Get, or create, a list of events of this type
let type_id = event.type_id();
let events = self.event_write_queue.entry(type_id)
.or_insert_with(default)
.borrow_mut();
// downcast resource as an events storage
let mut events: RefMut<Events<E>> = RefMut::map(events, |e| e.as_any_mut().downcast_mut().unwrap());
events.push_back(event);
}
/// Clear events, this should happen at the start of every tick since events are cloned
/// before being given to the reader.
pub fn update_events(&mut self) {
self.events.clear();
// get all keys of events
let keys: Vec<TypeId> = self.event_write_queue.keys().map(|k| k.clone()).collect();
// remove all elements from self.event_write_queue and insert them to events
for k in keys.into_iter() {
let v = self.event_write_queue.remove(&k).unwrap();
self.events.insert(k, v);
}
}
pub fn read_events<E>(&self) -> Option<Ref<Events<E>>>
where
E: Clone + Send + Sync + 'static
{
if let Some(event ) = self.events.get(&TypeId::of::<E>()) {
//.or_else(|| self.event_write_queue.get(&TypeId::of::<E>())) {
let eref = event.borrow();
Some(Ref::map(eref, |x| x.as_any().downcast_ref::<Events<E>>().unwrap()))
} else {
None
}
/* if let Some(event) = self.events.get(&TypeId::of::<E>()) {
let eref = event.borrow();
Some(Ref::map(eref, |x| x.as_any().downcast_ref::<Events<E>>().unwrap()))
} else if let Some(event) = self.events.get(&TypeId::of::<E>()) {
None
} */
/* self.events.get(&TypeId::of::<E>())
//.map(|r| r.borrow().as_any().downcast_ref::<Events<E>>())
.map(|r| r.borrow().as_any().do)
.flatten() */
}
/// Query a resource.
///
/// This is O(1), resources are stored in HashMaps.
pub fn query_res<R>(&self) -> Option<Ref<R>>
where
R: Resource
{
self.resources
.get(&TypeId::of::<R>())
.map(|r| {
let r = r.borrow();
Ref::map(r, |r| r.as_any().downcast_ref().unwrap())
})
}
/// Query a resource mutably.
///
/// This will mark the resource as changed, even if it actually wasn't modified when mutably borrowed.
/// This is O(1), resources are stored in HashMaps.
pub fn query_res_mut<R>(&mut self) -> Option<RefMut<R>>
where
R: Resource
{
self.resources
.get_mut(&TypeId::of::<R>())
.map(|r| {
// update resource
self.updated_resources.insert(TypeId::of::<R>());
let r = r.borrow_mut();
RefMut::map(r, |r| r.as_any_mut().downcast_mut::<R>().unwrap())
})
}
}

50
src/game.rs
View File

@ -1,4 +1,4 @@
use std::{sync::Arc, cell::RefCell, borrow::Borrow, collections::VecDeque};
use std::sync::Arc;
use async_std::{task::block_on, sync::Mutex};
@ -13,10 +13,10 @@ use tracing_subscriber::{
use winit::{window::{WindowBuilder, Window}, event::{Event, WindowEvent, KeyboardInput, ElementState, VirtualKeyCode, DeviceEvent}, event_loop::{EventLoop, ControlFlow}};
use crate::{render::{renderer::{Renderer, BasicRenderer}, render_job::RenderJob}, input_event::InputEvent, ecs::{components::{mesh::MeshComponent, transform::TransformComponent}, SimpleSystem, SystemDispatcher, world::World, resources::{WindowState, Events}}, input::InputEventUpdater};
use crate::{render::renderer::{Renderer, BasicRenderer}, input_event::InputEvent, ecs::{SimpleSystem, SystemDispatcher, resources::{WindowState, Events, EventQueue}}};
pub struct Controls<'a> {
pub world: &'a mut World,
pub world: &'a mut edict::World,
}
struct TickCounter {
@ -78,7 +78,7 @@ struct GameLoop {
window: Arc<Window>,
renderer: Box<dyn Renderer>,
world: Arc<Mutex<World>>,
world: Arc<Mutex<edict::World>>,
/// higher priority systems
engine_sys_dispatcher: SystemDispatcher,
user_sys_dispatcher: SystemDispatcher,
@ -86,7 +86,13 @@ struct GameLoop {
}
impl GameLoop {
pub async fn new(window: Arc<Window>, world: Arc<Mutex<World>>, user_systems: SystemDispatcher) -> GameLoop {
pub async fn new(window: Arc<Window>, world: Arc<Mutex<edict::World>>, user_systems: SystemDispatcher) -> GameLoop {
// Create the EventQueue resource in the world
{
let mut world = world.lock().await;
world.insert_resource(EventQueue::new());
}
Self {
window: Arc::clone(&window),
renderer: Box::new(BasicRenderer::create_with_window(window).await),
@ -99,7 +105,7 @@ impl GameLoop {
}
pub async fn on_resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
self.renderer.on_resize(new_size).await;
self.renderer.on_resize(new_size);
}
pub fn run_sync(&mut self, event: Event<()>, control_flow: &mut ControlFlow) {
@ -142,7 +148,7 @@ impl GameLoop {
InputEvent::CursorEntered { .. } => {
let mut world = self.world.lock().await;
let mut state = world.query_or_insert_res::<WindowState>(|| Box::new(RefCell::new(WindowState::new())));
let mut state = world.with_resource(|| WindowState::new());
state.is_cursor_inside_window = true;
None
@ -151,7 +157,7 @@ impl GameLoop {
InputEvent::CursorLeft { .. } => {
let mut world = self.world.lock().await;
let mut state = world.query_or_insert_res::<WindowState>(|| Box::new(RefCell::new(WindowState::new())));
let mut state = world.with_resource(|| WindowState::new());
state.is_cursor_inside_window = false;
None
@ -186,14 +192,13 @@ impl GameLoop {
let mut world = self.world.lock().await;
// make sure that the mouse is inside the window and the mouse has focus before reporting mouse motion
let trigger = match world.query_res::<WindowState>() {
let trigger = match world.get_resource::<WindowState>() {
Some(window_state) if window_state.is_focused && window_state.is_cursor_inside_window => true,
_ => false,
};
if trigger {
let mut event_queue = world.query_or_insert_res::<Events<InputEvent>>
(|| Box::new(RefCell::new(Events::<InputEvent>::new())));
let event_queue = world.with_resource(|| Events::<InputEvent>::new());
let input_event = InputEvent::MouseMotion { device_id, delta, };
event_queue.push_back(input_event);
@ -212,8 +217,10 @@ impl GameLoop {
// Its possible to receive multiple input events before the update event for
// the InputSystem is called, so we must use a queue for the events.
{
let mut world = self.world.lock().await;
world.trigger_event(input_event.clone());
let world = self.world.lock().await;
if let Some(mut event_queue) = world.get_resource_mut::<EventQueue>() {
event_queue.trigger_event(input_event.clone());
};
}
if let Some(new_control) = self.input_update(&input_event).await {
@ -238,7 +245,7 @@ impl GameLoop {
WindowEvent::Focused(is_focused) => {
let mut world = self.world.lock().await;
let mut state = world.query_or_insert_res::<WindowState>(|| Box::new(RefCell::new(WindowState::new())));
let mut state = world.with_resource(|| WindowState::new());
state.is_focused = *is_focused;
},
@ -257,12 +264,13 @@ impl GameLoop {
} */
let mut world = self.world.lock().await;
self.renderer.as_mut().prepare(&mut world).await;
world.clear_updated_resources();
world.update_events();
self.renderer.as_mut().prepare(&mut world);
if let Some(mut event_queue) = world.get_resource_mut::<EventQueue>() {
event_queue.update_events();
}
drop(world);
match self.renderer.as_mut().render().await {
match self.renderer.as_mut().render() {
Ok(_) => {}
// Reconfigure the surface if lost
Err(wgpu::SurfaceError::Lost) => self.on_resize(self.renderer.as_ref().surface_size()).await,
@ -282,7 +290,7 @@ impl GameLoop {
}
pub struct Game {
world: Option<Arc<Mutex<World>>>,
world: Option<Arc<Mutex<edict::World>>>,
system_dispatcher: Option<SystemDispatcher>
}
@ -312,13 +320,13 @@ impl Game {
Self::default()
}
pub fn with_world(&mut self, world: World) -> &mut Self {
pub fn with_world(&mut self, world: edict::World) -> &mut Self {
self.world = Some(Arc::new(Mutex::new(world)));
self
}
pub fn with_world_arc(&mut self, world: Arc<Mutex<World>>) -> &mut Self {
pub fn with_world_arc(&mut self, world: Arc<Mutex<edict::World>>) -> &mut Self {
self.world = Some(world);
self

76
src/input.rs
View File

@ -5,7 +5,7 @@ use glam::Vec2;
use tracing::{warn, debug};
use winit::event::{VirtualKeyCode, ElementState, MouseScrollDelta};
use crate::{ecs::{SimpleSystem, resources::{Resource, Events}, world::World}, input_event::InputEvent};
use crate::{ecs::{SimpleSystem, resources::{CastableAny, Events, EventQueue}}, input_event::InputEvent};
pub type KeyCode = winit::event::VirtualKeyCode;
@ -100,16 +100,6 @@ pub struct Touches {
pub touches: Vec<Touch>,
}
impl Resource for Touches {
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
impl Touches {
pub fn new() -> Self {
Self {
@ -152,16 +142,6 @@ pub struct InputButtons<T: Clone + Hash + Eq + PartialEq + 'static> {
button_events: HashMap<u64, ButtonEvent<T>>,
}
impl<T: Sync + Send + Clone + Hash + Eq + PartialEq + 'static> Resource for InputButtons<T> {
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
impl<T: Clone + Hash + Eq + PartialEq + 'static> InputButtons<T> {
pub fn new() -> Self {
Self {
@ -279,12 +259,19 @@ impl InputEventUpdater {
}
}
pub fn update(&mut self, event: &InputEvent, world: &mut World) -> bool {
pub fn update(&mut self, event: &InputEvent, world: &mut edict::World) -> bool {
let event_queue = world.get_resource_mut::<EventQueue>();
if event_queue.is_none() {
return false;
}
let mut event_queue = event_queue.unwrap();
match event {
InputEvent::KeyboardInput { input, .. } => {
if let Some(code) = input.virtual_keycode {
let mut e = world.query_or_insert_res::<InputButtons<KeyCode>>
(|| Box::new(RefCell::new(InputButtons::<KeyCode>::new())));
drop(event_queue);
let mut e = world.with_resource(|| InputButtons::<KeyCode>::new());
//let mut e = with_resource_mut(world, || InputButtons::<KeyCode>::new());
e.add_input_from_winit(code, input.state);
}
},
@ -293,22 +280,22 @@ impl InputEventUpdater {
delta: Vec2::new(delta.0 as f32, delta.1 as f32)
};
world.trigger_event(delta);
event_queue.trigger_event(delta);
},
InputEvent::CursorMoved { position, .. } => {
let exact = MouseExact {
pos: Vec2::new(position.x as f32, position.y as f32)
};
world.trigger_event(exact);
event_queue.trigger_event(exact);
},
InputEvent::CursorEntered { .. } => {
let event = CursorEnteredWindow {};
world.trigger_event(event);
event_queue.trigger_event(event);
},
InputEvent::CursorLeft { .. } => {
let event = CursorLeftWindow {};
world.trigger_event(event);
event_queue.trigger_event(event);
},
InputEvent::MouseWheel { delta, .. } => {
let event = match delta {
@ -320,7 +307,7 @@ impl InputEventUpdater {
},
};
world.trigger_event(event);
event_queue.trigger_event(event);
}, //MouseButton
InputEvent::MouseInput { button, state, .. } => {
let button_event = match button {
@ -330,13 +317,15 @@ impl InputEventUpdater {
winit::event::MouseButton::Other(v) => MouseButton::Other(*v),
};
world.trigger_event(button_event.clone());
event_queue.trigger_event(button_event.clone());
drop(event_queue);
let mut e = world.query_or_insert_res::<InputButtons<MouseButton>>
(|| Box::new(RefCell::new(InputButtons::<MouseButton>::new())));
let mut e = world.with_resource(|| InputButtons::<MouseButton>::new());
e.add_input_from_winit(button_event, state.clone());
},
InputEvent::Touch(t) => {
drop(event_queue);
let touch = Touch {
phase: TouchPhase::from(t.phase),
location: Vec2::new(t.location.x as f32, t.location.y as f32),
@ -347,9 +336,7 @@ impl InputEventUpdater {
finger_id: t.id,
};
let mut touches = world.query_or_insert_res::<Touches>
(|| Box::new(RefCell::new(Touches::new())));
let mut touches = world.with_resource(|| Touches::new());
touches.touches.push(touch);
},
_ => {},
@ -363,32 +350,19 @@ impl SimpleSystem for InputEventUpdater {
fn execute_mut(&mut self, controls: &mut crate::game::Controls) -> anyhow::Result<()> {
let world = &mut controls.world;
let queue = world.read_events::<InputEvent>();
let queue = world.get_resource_mut::<EventQueue>()
.map(|q| q.read_events::<InputEvent>()).flatten();
if queue.is_none() {
return Ok(());
}
let queue = queue.unwrap();
// borrow checker isn't happy when I query multiple things :(
let mut events = queue.clone();
drop(queue);
let mut events = queue.unwrap();
while let Some(event) = events.pop_front() {
self.update(&event, world);
}
/* if let Some(queue) = world.read_events::<InputEvent>() {
// Clone the queue, then clear it
let mut events = queue.clone();
drop(queue);
while let Some(event) = events.pop_front() {
self.update(&event, world);
}
} */
Ok(())
}
}

12
src/input_event.rs
View File

@ -1,6 +1,6 @@
use winit::{event::{DeviceId, KeyboardInput, ModifiersState, MouseScrollDelta, TouchPhase, MouseButton, AxisId, Touch, WindowEvent, ElementState}, dpi::PhysicalPosition};
use crate::ecs::resources::Resource;
use crate::ecs::resources::CastableAny;
/// Wrapper around events from `winit::WindowEvent` that are specific to input related events.
///
@ -220,14 +220,4 @@ impl<'a> TryFrom<&'a WindowEvent<'a>> for InputEvent {
_ => Err(InputEventConversionError::FromError(value))
}
}
}
impl Resource for InputEvent {
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
self
}
}

26
src/main.rs
View File

@ -6,16 +6,15 @@ mod ecs;
mod math;
mod input;
use std::cell::Ref;
use atomicell::Ref;
use ecs::components::mesh::MeshComponent;
use ecs::components::transform::TransformComponent;
use edict::QueryIter;
use game::Game;
use input_event::InputEvent;
use tracing::debug;
use crate::ecs::world::World;
use crate::input::{InputEventUpdater, KeyCode, MouseMotion, MouseExact, CursorEnteredWindow, MouseScroll, CursorLeftWindow, MouseButton, InputButtons};
use crate::render::material::Material;
use crate::render::texture::Texture;
@ -68,7 +67,7 @@ impl Point3d {
#[async_std::main]
async fn main() {
let mut world = World::new();
let mut world = edict::World::new();
//world.spawn((Point2d::new(10, 10), Point3d::new(50, 50, 50)));
@ -91,10 +90,8 @@ async fn main() {
camera.transform.rotate_z(Angle::Degrees(-90.0));
world.spawn((camera,));
let jiggle_system = |world: &mut World| -> anyhow::Result<()> {
//let input: &InputEventUpdater = world.query_res().unwrap();
let keys = world.query_res();
let jiggle_system = |world: &mut edict::World| -> anyhow::Result<()> {
let keys = world.get_resource();
if keys.is_none() {
return Ok(());
}
@ -124,7 +121,16 @@ async fn main() {
drop(keys);
for (_eid, (transform, )) in world.query_mut::<(&mut TransformComponent,)>() {
for transform in world.query_mut::<(&mut TransformComponent,)>().iter_mut() {
let t = &mut transform.transform;
//debug!("Translation: {}", t.translation);
/* t.translation += glam::Vec3::new(0.0, 0.001, 0.0);
t.translation.x *= -1.0; */
t.translation.x += dir_x;
t.translation.y += dir_y;
}
/* for (transform,) in world.query_mut::<(TransformComponent, )>().iter() {
let t = &mut transform.transform;
/* debug!("Translation: {}", t.translation);
@ -133,7 +139,7 @@ async fn main() {
t.translation.x *= -1.0 */
t.translation.x += dir_x;
t.translation.y += dir_y;
}
} */
Ok(())
};

1
src/math/angle.rs
View File

@ -10,6 +10,7 @@ pub fn radians_to_degrees(radians: f32) -> f32 {
radians * 180.0 / PI
}
#[derive(Clone)]
pub enum Angle {
Degrees(f32),
Radians(f32),

8
src/render/render_job.rs
View File

@ -1,4 +1,4 @@
use hecs::Entity;
use edict::EntityId;
use crate::math::Transform;
@ -7,14 +7,14 @@ use super::{mesh::Mesh, material::Material};
pub struct RenderJob {
mesh: Mesh,
material: Material,
entity: Entity,
entity: EntityId,
transform: Transform,
last_transform: Option<Transform>, // TODO: render interpolation
}
impl RenderJob {
pub fn new(mesh: Mesh, material: Material, entity: Entity, transform: Transform, last_transform: Option<Transform>) -> Self {
pub fn new(mesh: Mesh, material: Material, entity: EntityId, transform: Transform, last_transform: Option<Transform>) -> Self {
Self {
mesh,
material,
@ -32,7 +32,7 @@ impl RenderJob {
&self.material
}
pub fn entity(&self)-> Entity {
pub fn entity(&self)-> EntityId {
self.entity
}

27
src/render/renderer.rs
View File

@ -6,17 +6,16 @@ use std::borrow::Cow;
use async_std::sync::Mutex;
use async_trait::async_trait;
use atomicell::{AtomicCell, RefMut};
use edict::{EntityId, Entities};
use tracing::{debug, warn};
use wgpu::{BindGroup, BindGroupLayout};
use wgpu::util::DeviceExt;
use winit::window::Window;
use hecs::Entity;
use crate::ecs::components::camera::CameraComponent;
use crate::ecs::components::mesh::MeshComponent;
use crate::ecs::components::transform::TransformComponent;
use crate::ecs::world::World;
use crate::math::{Transform, Angle};
use crate::resources;
@ -25,11 +24,10 @@ use super::desc_buf_lay::DescVertexBufferLayout;
use super::texture::RenderTexture;
use super::{render_pipeline::FullRenderPipeline, vertex::{VERTICES}, render_buffer::BufferStorage, render_job::RenderJob, mesh::Mesh};
#[async_trait]
pub trait Renderer {
async fn prepare(&mut self, main_world: &mut World);
async fn render(&mut self) -> Result<(), wgpu::SurfaceError>;
async fn on_resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>);
fn prepare(&mut self, main_world: &mut edict::World);
fn render(&mut self) -> Result<(), wgpu::SurfaceError>;
fn on_resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>);
fn surface_size(&self) -> winit::dpi::PhysicalSize<u32>;
fn add_render_pipeline(&mut self, shader_id: u32, pipeline: Arc<FullRenderPipeline>);
@ -57,7 +55,7 @@ pub struct BasicRenderer {
pub render_pipelines: HashMap<u32, Arc<FullRenderPipeline>>,
pub render_jobs: VecDeque<RenderJob>,
buffer_storage: HashMap<Entity, RenderBufferStorage>, // TODO: clean up left over buffers from deleted entities/components
buffer_storage: HashMap<EntityId, RenderBufferStorage>, // TODO: clean up left over buffers from deleted entities/components
transform_buffer: wgpu::Buffer,
transform_bind_group: wgpu::BindGroup,
@ -346,10 +344,10 @@ impl BasicRenderer {
}
}
#[async_trait]
impl Renderer for BasicRenderer {
async fn prepare(&mut self, main_world: &mut World) {
for (entity, (model, transform)) in main_world.query::<(&MeshComponent, &TransformComponent)>().iter() {
fn prepare(&mut self, main_world: &mut edict::World) {
for (entity, model, transform) in main_world.query::<(Entities, &MeshComponent, &TransformComponent)>().iter() {
// Create the render job and push it to the queue
let job = RenderJob::new(model.mesh.clone(), model.material.clone(), entity, transform.transform, None);
self.render_jobs.push_back(job);
@ -360,8 +358,7 @@ impl Renderer for BasicRenderer {
}
}
// Find the active camera
if let Some((_e, (camera,))) = main_world.query_mut::<(&mut CameraComponent,)>().into_iter().next() {
if let Some(camera) = main_world.query_mut::<(&mut CameraComponent,)>().into_iter().next() {
let view_proj = self.inuse_camera.update_view_projection(camera);
self.queue.write_buffer(&self.camera_buffer, 0, bytemuck::cast_slice(&[view_proj.clone()]));
} else {
@ -369,7 +366,7 @@ impl Renderer for BasicRenderer {
}
}
async fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
let output = self.surface.get_current_texture()?;
let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -434,7 +431,7 @@ impl Renderer for BasicRenderer {
Ok(())
}
async fn on_resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
fn on_resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
if new_size.width > 0 && new_size.height > 0 {
self.size = new_size;
self.config.width = new_size.width;