Merge pull request #36 from inda21plusplus/mathm/ecs-phx-integration

Integrate the ECS and Physics
inda21plusplus · May 19, 2022 · 519dde4 · 519dde4
2 parents 38677ff + f2917ff
commit 519dde4
Show file tree

Hide file tree

Showing 51 changed files with 993 additions and 1,092 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -2,4 +2,12 @@
 
 resolver = "2"
 
-members = ["examples/runtime", "game-engine", "ecs", "rendering", "common"]
+members = [
+    "common",
+    "ecs",
+    "game-engine",
+    "physics",
+    "rendering",
+
+    "examples/runtime",
+]
diff --git a/ecs/src/component/registry.rs b/ecs/src/component/registry.rs
@@ -147,7 +147,8 @@ impl ComponentRegistry {
     ) -> ComponentId {
         let id = ComponentId(self.entries.len().try_into().unwrap());
 
-        debug_assert!(self.rust_types.insert(type_id, id).is_none());
+        let old = self.rust_types.insert(type_id, id);
+        debug_assert!(old.is_none());
         assert!(self.check_exclusive_access());
 
         let info = ComponentInfo {

diff --git a/ecs/src/lib.rs b/ecs/src/lib.rs
@@ -5,13 +5,12 @@ pub mod component;
 mod entity;
 mod error;
 #[macro_use]
-mod query;
+pub mod query;
 mod world;
 
 pub use commands::{CommandBuffer, Commands};
 pub use entity::{Entities, Entity};
 pub use error::BorrowMutError;
-pub use query::{ComponentQuery, Query, _as_mut_lt, _as_ref_lt};
 pub use world::World;
 
 #[cfg(test)]
@@ -26,7 +25,10 @@ mod tests {
         time::{Duration, Instant},
     };
 
-    use crate::component::{ComponentRegistry, Storage, StorageType};
+    use crate::{
+        component::{ComponentRegistry, Storage, StorageType},
+        query::{ComponentQuery, Query},
+    };
 
     use super::*;
 

diff --git a/ecs/src/query/macros.rs b/ecs/src/query/macros.rs
@@ -4,15 +4,15 @@ macro_rules! query_iter {
         let mut command_buffer = $crate::CommandBuffer::new();
         let mut $commands = $crate::Commands::new(&mut command_buffer, $world.entities());
 
-        query_iter!($world, ($($query)*) => $body);
+        $crate::query_iter!($world, ($($query)*) => $body);
 
         command_buffer.apply(&mut $world);
     }};
     ( $world:expr, ($($query:tt)*) => $body:block ) => {{
         #[allow(unused_mut)]
         let mut v = vec![];
-        _query_definition!($world, v, ($($query)*));
-        let q = Query::new(v).expect("Query violates rusts borrow rules");
+        $crate::_query_definition!($world, v, ($($query)*));
+        let q = $crate::query::Query::new(v).expect("Query violates rusts borrow rules");
 
         let mut res = $world.query(&q);
 
@@ -31,19 +31,18 @@ macro_rules! query_iter_combs {
         let mut command_buffer = $crate::CommandBuffer::new();
         let mut $commands = $crate::Commands::new(&mut command_buffer, $world.entities());
 
-        query_iter_combs!($world, ($($query)*) => $body);
+        $crate::query_iter_combs!($world, ($($query)*) => $body);
 
         command_buffer.apply(&mut $world);
     }};
     ( $world:expr, ($($query:tt)*) => $body:block ) => {{
         #[allow(unused_mut)]
         let mut v = vec![];
-        _query_definition!($world, v, ($($query)*));
-        let q = Query::new(v).expect("Query violates rusts borrow rules");
+        $crate::_query_definition!($world, v, ($($query)*));
+        let q = $crate::query::Query::new(v).expect("Query violates rusts borrow rules");
 
         let mut res = $world.query(&q);
 
-        // (e1, e2): Entity, (p1, p2): Pos, (v1, v2): mut Vel
         #[allow(unused_variables)]
         for ((e1, comps1), (e2, comps2)) in unsafe { res.iter_combinations() } {
             let lt = ();
@@ -57,75 +56,99 @@ macro_rules! query_iter_combs {
 macro_rules! _query_definition {
     // entity
     ( $world:expr, $vec:expr, ($name:tt: Entity, $($tail:tt)*) ) => {{
-        _query_definition!($world, $vec, ($($tail)*));
+        $crate::_query_definition!($world, $vec, ($($tail)*));
     }};
     // opt
     ( $world:expr, $vec:expr, ($name:tt: Option<$type:ty>, $($tail:tt)*) ) => {{
         $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: false,
             optional: false,
         });
-        _query_definition!($world, $vec, ($($tail)*));
+        $crate::_query_definition!($world, $vec, ($($tail)*));
     }};
     // opt mut
     ( $world:expr, $vec:expr, ($name:tt: mut Option<$type:ty>, $($tail:tt)*) ) => {{
         $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: true,
             optional: true,
         });
-        _query_definition!($world, $vec, ($($tail)*));
+        $crate::_query_definition!($world, $vec, ($($tail)*));
     }};
     // comp
     ( $world:expr, $vec:expr, ($name:tt: $type:ty, $($tail:tt)*) ) => {{
-        $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+        $vec.push($crate::query::ComponentQuery {
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: false,
             optional: false,
         });
-        _query_definition!($world, $vec, ($($tail)*));
+        $crate::_query_definition!($world, $vec, ($($tail)*));
     }};
     // mut
     ( $world:expr, $vec:expr, ($name:tt: mut $type:ty, $($tail:tt)*) ) => {{
-        $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+        $vec.push($crate::query::ComponentQuery {
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: true,
             optional: false,
         });
-        _query_definition!($world, $vec, ($($tail)*));
+        $crate::_query_definition!($world, $vec, ($($tail)*));
     }};
 
     // Last entry
     ( $world:expr, $vec:expr, ($name:tt: Entity) ) => { };
     // opt
     ( $world:expr, $vec:expr, ($name:tt: Option<$type:ty>) ) => {{
-        $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+        $vec.push($crate::query::ComponentQuery {
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: false,
             optional: true,
         });
     }};
     // mut opt
     ( $world:expr, $vec:expr, ($name:tt: mut Option<$type:ty>) ) => {{
         $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().expect(&format!("{}", std::any::type_name::<$type>())),
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: true,
             optional: true,
         });
     }};
     // comp
     ( $world:expr, $vec:expr, ($name:tt: $type:ty) ) => {{
-        $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+        $vec.push($crate::query::ComponentQuery {
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: false,
             optional: false,
         });
     }};
     // mut
     ( $world:expr, $vec:expr, ($name:tt: mut $type:ty) ) => {{
-        $vec.push(ComponentQuery {
-            id: $world.component_registry().id::<$type>().unwrap(),
+        $vec.push($crate::query::ComponentQuery {
+            id: $world.component_registry().id::<$type>().expect(&format!(
+                    "Tried querying for unregistered type {}",
+                    std::any::type_name::<$type>(),
+            )),
             mutable: true,
             optional: false,
         });
@@ -137,27 +160,27 @@ macro_rules! _query_defvars {
     // Entity
     ( $comps:expr, $lt:expr, $entity:expr, ($name:ident: Entity, $($tail:tt)*) ) => {
         let $name = $entity;
-        _query_defvars!($comps[..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars!($comps[..], $lt, $entity, ($($tail)*));
     };
     // opt
     ( $comps:expr, $lt:expr, $entity:expr, ($name:ident: Option<$type:ty>, $($tail:tt)*) ) => {
         let $name = unsafe { $crate::query::_as_opt_ref_lt($lt, $comps[0].cast::<$type>()) };
-        _query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
     };
     // mut opt
     ( $comps:expr, $lt:expr, $entity:expr, ($name:ident: mut Option<$type:ty>, $($tail:tt)*) ) => {
         let $name = unsafe { $crate::query::_as_opt_mut_lt($lt, $comps[0].cast::<$type>()) };
-        _query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
     };
     // comp
     ( $comps:expr, $lt:expr, $entity:expr, ($name:ident: $type:ty, $($tail:tt)*) ) => {
         let $name = unsafe { $crate::query::_as_ref_lt($lt, $comps[0].cast::<$type>()) };
-        _query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
     };
     // mut
     ( $comps:expr, $lt:expr, $entity:expr, ($name:ident: mut $type:ty, $($tail:tt)*) ) => {
         let $name = unsafe { $crate::query::_as_mut_lt($lt, $comps[0].cast::<$type>()) };
-        _query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars!($comps[1..], $lt, $entity, ($($tail)*));
     };
 
     // Last entry
@@ -187,39 +210,39 @@ macro_rules! _query_defvars_combs {
     // entity
     ( $comps1:expr, $comps2:expr, $lt:expr, $entity:expr, ($name:tt: Entity, $($tail:tt)*) ) => {
         let $name = $entity;
-        _query_defvars_combs!($comps1, $comps2, $lt, $entity, ($($tail)*));
+        $crate::_query_defvars_combs!($comps1, $comps2, $lt, $entity, ($($tail)*));
     };
     // opt
     ( $comps1:expr, $comps2:expr, $lt:expr, $entity:expr, ($name:tt: Option<$type:ty>, $($tail:tt)*) ) => {
         let $name = unsafe { (
             $crate::query::_as_opt_ref_lt($lt, $comps1[0].cast::<$type>()),
             $crate::query::_as_opt_ref_lt($lt, $comps2[0].cast::<$type>()),
         ) };
-        _query_defvars_combs!($comps1[1..], $comps2[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars_combs!($comps1[1..], $comps2[1..], $lt, $entity, ($($tail)*));
     };
     // opt mut
     ( $comps1:expr, $comps2:expr, $lt:expr, $entity:expr, ($name:tt: mut Option<$type:ty>, $($tail:tt)*) ) => {
         let $name = unsafe { (
             $crate::query::_as_opt_mut_lt($lt, $comps1[0].cast::<$type>()),
             $crate::query::_as_opt_mut_lt($lt, $comps2[0].cast::<$type>()),
         ) };
-        _query_defvars_combs!($comps[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars_combs!($comps[1..], $lt, $entity, ($($tail)*));
     };
     // comp
     ( $comps1:expr, $comps2:expr, $lt:expr, $entity:expr, ($name:tt: $type:ty, $($tail:tt)*) ) => {
         let $name = unsafe { (
             $crate::query::_as_ref_lt($lt, $comps1[0].cast::<$type>()),
             $crate::query::_as_ref_lt($lt, $comps2[0].cast::<$type>()),
         ) };
-        _query_defvars_combs!($comps1[1..], $comps2[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars_combs!($comps1[1..], $comps2[1..], $lt, $entity, ($($tail)*));
     };
     // mut
     ( $comps1:expr, $comps2:expr, $lt:expr, $entity:expr, ($name:tt: mut $type:ty, $($tail:tt)*) ) => {
         let $name = unsafe { (
             $crate::query::_as_mut_lt($lt, $comps1[0].cast::<$type>()),
             $crate::query::_as_mut_lt($lt, $comps2[0].cast::<$type>()),
         ) };
-        _query_defvars_combs!($comps[1..], $lt, $entity, ($($tail)*));
+        $crate::_query_defvars_combs!($comps1[1..], $comps2[1..], $lt, $entity, ($($tail)*));
     };
 
     // Last entry

diff --git a/ecs/src/query/mod.rs b/ecs/src/query/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     BorrowMutError, Entity, World,
 };
 
-mod macros;
+pub mod macros;
 
 pub use self::macros::*;
 
@@ -105,10 +105,14 @@ impl<'w, 'q> QueryResponse<'w, 'q> {
         Some(res)
     }
 
+    /// # Safety
+    /// See documentation for `try_get`
     pub unsafe fn iter<'a>(&'a mut self) -> Iter<'a, 'w, 'q> {
         Iter::new(self)
     }
 
+    /// # Safety
+    /// See documentation for `try_get`
     pub unsafe fn iter_combinations<'a>(&'a mut self) -> IterCombinations<'a, 'w, 'q> {
         IterCombinations::new(self)
     }

diff --git a/ecs/src/world.rs b/ecs/src/world.rs
@@ -1,6 +1,6 @@
 use crate::component::{ComponentId, ComponentRegistry};
 use crate::query::QueryResponse;
-use crate::{BorrowMutError, Entities, Entity, Query};
+use crate::{query::Query, BorrowMutError, Entities, Entity};
 
 pub struct ResourceId(ComponentId);
 

diff --git a/examples/runtime/Cargo.toml b/examples/runtime/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "ide"
+name = "runtime"
 version = "0.1.0"
 edition = "2021"
 

diff --git a/examples/runtime/physics_scene.rs b/examples/runtime/physics_scene.rs
diff --git a/examples/runtime/src/camera_controller.rs b/examples/runtime/src/camera_controller.rs
@@ -7,7 +7,7 @@ pub struct CameraController {
     /// Degrees per pixel
     pub mouse_sensitivity: f32,
     pub position: Vec3,
-    /// Pitch, Yaw
+    /// (Pitch, Yaw)
     pub rotation: Vec2,
     pub is_forward_pressed: bool,
     pub is_backward_pressed: bool,
@@ -125,7 +125,5 @@ impl CameraController {
 
         camera.eye = self.position;
         camera.target = self.position + forward;
-
-        //println!("{:?} {:?}", camera.eye, self.rotation);
     }
 }