.envrc

@@ -0,0 +1 @@
+use_nix

Cargo.lock

@@ -330,6 +330,12 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
+[[package]]
+name = "atomic_refcell"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41e67cd8309bbd06cd603a9e693a784ac2e5d1e955f11286e355089fcab3047c"
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -708,12 +714,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.18"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3a430a770ebd84726f584a90ee7f020d28db52c6d02138900f22341f866d39c"
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
-dependencies = [
- "cfg-if",
-]
 
 [[package]]
 name = "crunchy"
@@ -984,12 +987,6 @@ dependencies = [
  "percent-encoding",
 ]
 
-[[package]]
-name = "fps_counter"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3aaba7ff514ee9d802b562927f80b1e94e93d8e74c31b134c9c3762dabf1a36b"
-
 [[package]]
 name = "fsevent-sys"
 version = "4.1.0"
@@ -1755,6 +1752,7 @@ name = "lyra-ecs"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "atomic_refcell",
  "lyra-ecs-derive",
  "lyra-math",
  "paste",
@@ -1797,6 +1795,7 @@ dependencies = [
  "lyra-math",
  "lyra-reflect",
  "lyra-resource",
+ "lyra-scene",
  "quote",
  "syn 2.0.51",
  "thiserror",
@@ -1850,6 +1849,7 @@ dependencies = [
  "lyra-ecs",
  "lyra-math",
  "lyra-reflect",
+ "lyra-scene",
  "mime",
  "notify",
  "notify-debouncer-full",
@@ -3104,7 +3104,6 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "async-std",
- "fps_counter",
  "lyra-engine",
  "tracing",
 ]

examples/testbed/src/main.rs

@@ -1,6 +1,6 @@
-use std::ptr::NonNull;
+use std::{ptr::NonNull, thread, time::Duration};
 
-use lyra_engine::{assets::gltf::Gltf, change_tracker::Ct, ecs::{query::{QueryBorrow, Res, View, ViewState}, system::{BatchedSystem, Criteria, CriteriaSchedule, IntoSystem}, Component, World}, game::Game, input::{Action, ActionHandler, ActionKind, ActionMapping, ActionMappingId, ActionSource, InputActionPlugin, KeyCode, LayoutId, MouseAxis, MouseInput}, math::{self, Quat, Transform, Vec3}, render::{light::{directional::DirectionalLight, PointLight, SpotLight}, window::{CursorGrabMode, WindowOptions}}, scene::{CameraComponent, FreeFlyCamera, FreeFlyCameraPlugin, ACTLBL_LOOK_LEFT_RIGHT, ACTLBL_LOOK_ROLL, ACTLBL_LOOK_UP_DOWN, ACTLBL_MOVE_FORWARD_BACKWARD, ACTLBL_MOVE_LEFT_RIGHT, ACTLBL_MOVE_UP_DOWN}, DeltaTime};
+use lyra_engine::{assets::gltf::Gltf, change_tracker::Ct, ecs::{query::{Res, View}, system::{Criteria, CriteriaSchedule, IntoSystem}, Component, World}, game::Game, input::{Action, ActionHandler, ActionKind, ActionMapping, ActionMappingId, ActionSource, InputActionPlugin, KeyCode, LayoutId, MouseAxis, MouseInput}, math::{self, Quat, Transform, Vec3}, render::{light::{directional::DirectionalLight, PointLight, SpotLight}, window::{CursorGrabMode, WindowOptions}}, scene::{CameraComponent, FreeFlyCamera, FreeFlyCameraPlugin, ACTLBL_LOOK_LEFT_RIGHT, ACTLBL_LOOK_ROLL, ACTLBL_LOOK_UP_DOWN, ACTLBL_MOVE_FORWARD_BACKWARD, ACTLBL_MOVE_LEFT_RIGHT, ACTLBL_MOVE_UP_DOWN}, DeltaTime};
 use lyra_engine::assets::ResourceManager;
 
 struct FixedTimestep {
@@ -73,7 +73,7 @@ async fn main() {
         //let diffuse_texture = resman.request::<Texture>("assets/happy-tree.png").unwrap();
         //let antique_camera_model = resman.request::<Model>("assets/AntiqueCamera.glb").unwrap();
         //let cube_model = resman.request::<Model>("assets/cube-texture-bin.glb").unwrap();
-        let cube_gltf = resman.request::<Gltf>("assets/texture-sep/texture-sep.gltf").unwrap();
+        let cube_gltf = resman.request::<Gltf>("../assets/texture-sep/texture-sep.gltf").unwrap();
         /*let crate_gltf = resman.request::<Gltf>("assets/crate/crate.gltf").unwrap();
 
         let separate_gltf = resman.request::<Gltf>("assets/pos-testing/child-node-cubes.glb").unwrap(); */
@@ -88,7 +88,7 @@ async fn main() {
         let separate_scene = &separate_gltf.data_ref()
             .unwrap().scenes[0]; */
 
-        let sponza_model = resman.request::<Gltf>("assets/sponza/Sponza.gltf").unwrap();
+        let sponza_model = resman.request::<Gltf>("../assets/sponza/Sponza.gltf").unwrap();
         drop(resman);
 
         sponza_model.wait_recurse_dependencies_load();

lyra-ecs/Cargo.toml

@@ -14,6 +14,7 @@ lyra-math = { path = "../lyra-math", optional = true }
 anyhow = "1.0.75"
 thiserror = "1.0.50"
 paste = "1.0.14"
+atomic_refcell = "0.1.13"
 
 [dev-dependencies]
 rand = "0.8.5" # used for tests

lyra-ecs/src/archetype.rs

@@ -19,7 +19,9 @@ impl Drop for ComponentColumn {
 
         unsafe {
             // TODO: trigger drop on the components
-            let layout = self.info.layout();
+            // SAFETY: The size of the data buffer is the capcity times the size of a component
+            let size = self.info.layout().size() * self.capacity;
+            let layout = Layout::from_size_align_unchecked(size, self.info.layout().align());
             dealloc(data, layout);
         }
     }

lyra-ecs/src/bundle.rs

@@ -17,6 +17,24 @@ pub trait Bundle {
     fn is_dynamic(&self) -> bool;
 }
 
+impl Bundle for () {
+    fn type_ids(&self) -> Vec<DynTypeId> {
+        vec![DynTypeId::of::<()>()]
+    }
+
+    fn info(&self) -> Vec<ComponentInfo> {
+        vec![ComponentInfo::new::<()>()]
+    }
+
+    fn take(self, mut f: impl FnMut(NonNull<u8>, DynTypeId, usize)) {
+        f(NonNull::from(&self).cast(), DynTypeId::of::<()>(), size_of::<()>());
+    }
+
+    fn is_dynamic(&self) -> bool {
+        false
+    }
+}
+
 impl<C: Component> Bundle for C {
     fn type_ids(&self) -> Vec<DynTypeId> {
         vec![DynTypeId::of::<C>()]

lyra-ecs/src/command.rs

@@ -1,4 +1,4 @@
-use std::{any::Any, cell::RefMut, collections::VecDeque, ptr::{self, NonNull}};
+use std::{any::Any, cell::RefMut, mem::{self, MaybeUninit}, ptr::{self, NonNull}};
 
 use crate::{system::FnArgFetcher, Access, Bundle, Entities, Entity, World};
 
@@ -23,24 +23,73 @@ where
     }
 }
 
-type RunCommand = unsafe fn(cmd: Box<dyn Command>, world: &mut World);
+type RunCommand = unsafe fn(cmd: *mut (), world: Option<&mut World>) -> usize;
+
+#[repr(C, packed)]
+struct PackedCommand<T: Command> {
+    run: RunCommand,
+    cmd: T,
+}
 
 /// Stores a queue of commands that will get executed after the system is ran.
 /// 
 /// This struct can be inserted as a resource into the world, and the commands will be
 /// executed by the [`GraphExecutor`](crate::system::GraphExecutor) after the system is executed.
 #[derive(Default)]
-pub struct CommandQueue(VecDeque<(RunCommand, Box<dyn Command>)>);
+pub struct CommandQueue {
+    data: Vec<MaybeUninit<u8>>,
+}
+
+impl CommandQueue {
+    /// Execute the commands in the queue.
+    /// 
+    /// If `world` is `None`, the commands will just be dropped and the memory freed.
+    fn execute(&mut self, mut world: Option<&mut World>) {
+        let range = self.data.as_mut_ptr_range();
+        let mut current = range.start;
+        let end = range.end;
+
+        while current < end {
+            // Retrieve the runner for the command.
+            // Safety: current pointer will either be the start of the buffer, or at the start of a new PackedCommand
+            let run_fn = unsafe { current.cast::<RunCommand>().read_unaligned() };
+            
+            // Retrieves the pointer to the command which is just after RunCommand due to PackedCommand.
+            // Safety: PackedCommand is repr C and packed, so it will be right after the RunCommand.
+            current = unsafe { current.add(mem::size_of::<RunCommand>()) };
+
+            // Now run the command, providing the type erased pointer to the command.
+            let read_size = unsafe { run_fn(current.cast(), world.as_deref_mut()) };
+
+            // The pointer is added to so that it is just after the command that was ran.
+            // Safety: the RunCommand returns the size of the command
+            current = unsafe { current.add(read_size) };
+        }
+
+        // Safety: all of the commands were just read from the pointers.
+        unsafe { self.data.set_len(0) };
+    }
+}
+
+impl Drop for CommandQueue {
+    fn drop(&mut self) {
+        if !self.data.is_empty() {
+            println!("CommandQueue has commands but is being dropped");
+        }
+
+        self.execute(None);
+    }
+}
 
 /// Used in a system to queue up commands that will run right after this system.
 /// 
 /// This can be used to delay the mutation of the world until after the system is ran. These
-/// must be used if you're mutating the world inside a [`ViewState`](crate::query::ViewState).
+/// must be used if you're mutating the world inside a [`View`](crate::query::View).
 /// 
 /// ```nobuild
 /// fn particle_spawner_system(
 ///     commands: Commands,
-///     view: ViewState<(&Campfire, &Transform)>
+///     view: View<(&Campfire, &Transform)>
 /// ) -> anyhow::Result<()> {
 ///     for (campfire, pos) in view.iter() {
 ///         // If you do not use commands to spawn this, the next iteration
@@ -66,17 +115,44 @@ impl<'a, 'b> Commands<'a, 'b> {
 
     /// Add a command to the end of the command queue
     pub fn add<C: Command>(&mut self, cmd: C) {
-        let cmd = Box::new(cmd);
+        let run_fn = |cmd_ptr: *mut (), world: Option<&mut World>| {
+            // Safety: the pointer is a type-erased pointer to the command. The pointer is read
+            // then dropped out of scope, this closure will not be ran again so no use-after-free
+            // will occur.
+            let cmd: C = unsafe { ptr::read_unaligned(cmd_ptr.cast::<C>()) };
+            match world {
+                Some(world) => cmd.run(world),
+                None => {} // cmd just gets dropped
+            }
 
-        let run_fn = |cmd: Box<dyn Command>, world: &mut World| {
+            // the size of the command must be returned to increment the pointer when applying
-            let cmd = cmd.as_any_boxed()
+            // the command queue.
-                .downcast::<C>()
+            mem::size_of::<C>()
-                .unwrap();
-            
-            cmd.run(world);
         };
 
-        self.queue.0.push_back((run_fn, cmd));
+        let data = &mut self.queue.data;
+        
+        // Reserve enough bytes from the vec to store the packed command and its run fn.
+        let old_len = data.len();
+        data.reserve(mem::size_of::<PackedCommand<C>>());
+        
+        // Get a pointer to the end of the packed data. Safe since we just reserved enough memory
+        // to store this command.
+        let end_ptr = unsafe { data.as_mut_ptr().add(old_len) };
+
+        unsafe {
+            // write the command and its runner into the buffer
+            end_ptr.cast::<PackedCommand<C>>()
+                // written unaligned to keep everything packed
+                .write_unaligned(PackedCommand {
+                    run: run_fn,
+                    cmd,
+                });
+
+            // we wrote to the vec's buffer without using its api, so we need manually
+            // set the length of the vec.
+            data.set_len(old_len + mem::size_of::<PackedCommand<C>>());
+        }
     }
 
     /// Spawn an entity into the World. See [`World::spawn`]
@@ -91,14 +167,8 @@ impl<'a, 'b> Commands<'a, 'b> {
     }
 
     /// Execute all commands in the queue, in order of insertion
-    pub fn execute(&mut self, world: &mut World) -> anyhow::Result<()> {
+    pub fn execute(&mut self, world: &mut World) {
-        while let Some((cmd_fn, cmd_ptr)) = self.queue.0.pop_front() {
+        self.queue.execute(Some(world));
-            unsafe {
-                cmd_fn(cmd_ptr, world);
-            }
-        }
-
-        Ok(())
     }
 }
 
@@ -125,21 +195,26 @@ impl FnArgFetcher for Commands<'_, '_> {
         let mut cmds = Commands::new(&mut state, world);
         // safety: Commands has a mut borrow only to entities in the world
         let world = unsafe { world_ptr.as_mut() };
-        cmds.execute(world).unwrap()
+        cmds.execute(world);
     }
 }
 
+/// A system for executing deferred commands that are stored in a [`World`] as a Resource.
+/// 
+/// Commands are usually added inside a system from a [`Commands`] object created just for it
+/// as an fn argument. However, there may be cases that commands cannot be added that way, so 
+/// they can also be added as a resource and executed later in this system.
 pub fn execute_deferred_commands(world: &mut World, mut commands: RefMut<Commands>) -> anyhow::Result<()> {
-    commands.execute(world)?;
+    commands.execute(world);
 
     Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-    use std::{cell::Ref, ptr::NonNull};
+    use std::{cell::Ref, ptr::NonNull, sync::{atomic::{AtomicU32, Ordering}, Arc}};
 
-    use crate::{system::{GraphExecutor, IntoSystem}, tests::Vec2, Commands, DynTypeId, World};
+    use crate::{system::{GraphExecutor, IntoSystem}, tests::Vec2, CommandQueue, Commands, DynTypeId, World};
 
     #[test]
     fn deferred_commands() {
@@ -170,4 +245,28 @@ mod tests {
         let vec2: Ref<Vec2> = unsafe { col.get(3) };
         assert_eq!(vec2.clone(), spawned_vec);
     }
+
+    /// A test that ensures a command in a command queue will only ever run once.
+    #[test]
+    fn commands_only_one_exec() {
+        let mut world = World::new();
+
+        let counter = Arc::new(AtomicU32::new(0));
+        
+        let mut queue = CommandQueue::default();
+        let mut commands = Commands::new(&mut queue, &mut world);
+
+        let counter_cl = counter.clone();
+        commands.add(move |_world: &mut World| {
+            counter_cl.fetch_add(1, Ordering::AcqRel);
+        });
+
+        queue.execute(Some(&mut world));
+        assert_eq!(1, counter.load(Ordering::Acquire));
+
+        queue.execute(Some(&mut world));
+        // If its not one, the command somehow was executed.
+        // I would be surprised it wouldn't cause some segfault but still increment the counter
+        assert_eq!(1, counter.load(Ordering::Acquire));
+    }
 }

lyra-ecs/src/lib.rs

@@ -51,6 +51,9 @@ pub mod math;
 
 pub use lyra_ecs_derive::*;
 
+pub use atomic_refcell::AtomicRef;
+pub use atomic_refcell::AtomicRefMut;
+
 #[cfg(test)]
 mod tests;
 

lyra-ecs/src/query/resource.rs

@@ -1,4 +1,6 @@
-use std::{marker::PhantomData, cell::{Ref, RefMut}};
+use std::marker::PhantomData;
+
+use atomic_refcell::{AtomicRef, AtomicRefMut};
 
 use crate::{World, resource::ResourceObject};
 
@@ -9,7 +11,7 @@ pub struct FetchResource<'a, T> {
     _phantom: PhantomData<T>,
 }
 
-impl<'a, T: 'a + 'static> Fetch<'a> for FetchResource<'a, T> {
+impl<'a, T: ResourceObject + 'a> Fetch<'a> for FetchResource<'a, T> {
     type Item = Res<'a, T>;
 
     fn dangling() -> Self {
@@ -79,7 +81,7 @@ impl<R: ResourceObject> AsQuery for QueryResource<R> {
 }
 
 /// A struct used for querying resources from the World.
-pub struct Res<'a, T>(pub(crate) Ref<'a, T>);
+pub struct Res<'a, T>(pub(crate) AtomicRef<'a, T>);
 
 impl<'a, T: ResourceObject> std::ops::Deref for Res<'a, T> {
     type Target = T;
@@ -98,7 +100,7 @@ pub struct FetchResourceMut<'a, T> {
     _phantom: PhantomData<T>,
 }
 
-impl<'a, T: 'a + 'static> Fetch<'a> for FetchResourceMut<'a, T> {
+impl<'a, T: ResourceObject + 'a> Fetch<'a> for FetchResourceMut<'a, T> {
     type Item = ResMut<'a, T>;
 
     fn dangling() -> Self {
@@ -167,7 +169,7 @@ impl<R: ResourceObject> AsQuery for QueryResourceMut<R> {
 }
 
 /// A struct used for querying resources from the World.
-pub struct ResMut<'a, T>(pub(crate) RefMut<'a, T>);
+pub struct ResMut<'a, T>(pub(crate) AtomicRefMut<'a, T>);
 
 impl<'a, T: ResourceObject> std::ops::Deref for ResMut<'a, T> {
     type Target = T;

lyra-ecs/src/relation/relate_pair.rs

@@ -83,8 +83,10 @@ where
 /// A query that fetches the origin, and target of a relation of type `R`.
 /// 
 /// It provides it as a tuple in the following format: `(origin, relation, target)`.
-/// Similar to [`RelatesTo`](super::RelatesTo), you can use [`ViewState::relate_pair`] to get a view that fetches the
+/// Similar to [`RelatesTo`](super::RelatesTo), you can use
-/// pair, or unlike [`RelatesTo`](super::RelatesTo), you can do the common procedure of using [`World::view`].
+/// [`ViewState::relate_pair`](crate::relation::ViewState::relate_pair) to get a view that
+/// fetches the pair, or unlike [`RelatesTo`](super::RelatesTo), you can do the common
+/// procedure of using [`World::view`].
 pub struct RelatePair<R: Relation> {
     _marker: PhantomData<R>,
 }

lyra-ecs/src/resource.rs

@@ -1,26 +1,40 @@
-use std::{any::{TypeId, Any}, cell::{RefCell, Ref, RefMut}};
+use std::any::{TypeId, Any};
+
+use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
 
 /// Shorthand for `Send + Sync + 'static`, so it never needs to be implemented manually.
-pub trait ResourceObject: 'static {}
+pub trait ResourceObject: Send + Sync + Any {
-impl<T: 'static> ResourceObject for T {}
+    fn as_any(&self) -> &dyn Any;
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+}
+
+impl<T: Send + Sync + Any> ResourceObject for T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
 
 /// A type erased storage for a Resource.
 pub struct ResourceData {
-    pub(crate) data: Box<RefCell<dyn Any>>,
+    pub(crate) data: Box<AtomicRefCell<dyn ResourceObject>>,
     type_id: TypeId,
 }
 
 impl ResourceData {
-    pub fn new<T: Any>(data: T) -> Self {
+    pub fn new<T: ResourceObject>(data: T) -> Self {
 
         Self {
-            data: Box::new(RefCell::new(data)),
+            data: Box::new(AtomicRefCell::new(data)),
             type_id: TypeId::of::<T>(),
         }
     }
 
     /// Returns a boolean indicating whether or not `T`` is of the same type of the Resource
-    pub fn is<T: 'static>(&self) -> bool {
+    pub fn is<T: ResourceObject>(&self) -> bool {
         self.type_id == TypeId::of::<T>()
     }
 
@@ -30,8 +44,8 @@ impl ResourceData {
     /// 
     /// * If the data is already borrowed mutably, this will panic.
     /// * If the type of `T` is not the same as the resource type.
-    pub fn get<T: 'static>(&self) -> Ref<T> {
+    pub fn get<T: ResourceObject>(&self) -> AtomicRef<T> {
-        Ref::map(self.data.borrow(), |a| a.downcast_ref().unwrap())
+        AtomicRef::map(self.data.borrow(), |a| a.as_any().downcast_ref().unwrap())
     }
 
     /// Mutably borrow the data inside of the resource.
@@ -40,8 +54,8 @@ impl ResourceData {
     /// 
     /// * If the data is already borrowed mutably, this will panic.
     /// * If the type of `T` is not the same as the resource type.
-    pub fn get_mut<T: 'static>(&self) -> RefMut<T> {
+    pub fn get_mut<T: ResourceObject>(&self) -> AtomicRefMut<T> {
-        RefMut::map(self.data.borrow_mut(), |a| a.downcast_mut().unwrap())
+        AtomicRefMut::map(self.data.borrow_mut(), |a| a.as_any_mut().downcast_mut().unwrap())
     }
 
     /// Borrow the data inside of the resource.
@@ -49,10 +63,9 @@ impl ResourceData {
     /// # Panics
     /// 
     /// * If the type of `T` is not the same as the resource type.
-    pub fn try_get<T: 'static>(&self) -> Option<Ref<T>> {
+    pub fn try_get<T: ResourceObject>(&self) -> Option<AtomicRef<T>> {
-        
         self.data.try_borrow()
-            .map(|r| Ref::map(r, |a| a.downcast_ref().unwrap()))
+            .map(|r| AtomicRef::map(r, |a| a.as_any().downcast_ref().unwrap()))
             .ok()
     }
 
@@ -61,9 +74,9 @@ impl ResourceData {
     /// # Panics
     /// 
     /// * If the type of `T` is not the same as the resource type.
-    pub fn try_get_mut<T: 'static>(&self) -> Option<RefMut<T>> {
+    pub fn try_get_mut<T: ResourceObject>(&self) -> Option<AtomicRefMut<T>> {
         self.data.try_borrow_mut()
-            .map(|r| RefMut::map(r, |a| a.downcast_mut().unwrap()))
+            .map(|r| AtomicRefMut::map(r, |a| a.as_any_mut().downcast_mut().unwrap()))
             .ok()
     }
 }

lyra-ecs/src/system/graph.rs

@@ -58,7 +58,8 @@ impl GraphExecutor {
     }
 
     /// Executes the systems in the graph
-    pub fn execute(&mut self, mut world_ptr: NonNull<World>, stop_on_error: bool) -> Result<Vec<GraphExecutorError>, GraphExecutorError> {
+    pub fn execute(&mut self, mut world_ptr: NonNull<World>, stop_on_error: bool)
+            -> Result<Vec<GraphExecutorError>, GraphExecutorError> {
         let mut stack = VecDeque::new();
         let mut visited = HashSet::new();
 
@@ -99,23 +100,15 @@ impl GraphExecutor {
                 let mut commands = Commands::new(&mut queue, world);
 
                 let world = unsafe { world_ptr.as_mut() };
-                if let Err(e) = commands.execute(world)
+                commands.execute(world);
-                        .map_err(|e| GraphExecutorError::Command(e)) {
-
-                    if stop_on_error {
-                        return Err(e);
-                    }
-    
-                    possible_errors.push(e);
-                    unimplemented!("Cannot resume topological execution from error"); // TODO: resume topological execution from error
-                }
             }
         }
 
         Ok(possible_errors)
     }
 
-    fn topological_sort<'a>(&'a self, stack: &mut VecDeque<String>, visited: &mut HashSet<&'a str>, node: &'a GraphSystem) -> Result<(), GraphExecutorError> {
+    fn topological_sort<'a>(&'a self, stack: &mut VecDeque<String>,
+            visited: &mut HashSet<&'a str>, node: &'a GraphSystem) -> Result<(), GraphExecutorError> {
         
         if !visited.contains(node.name.as_str()) {
             visited.insert(&node.name);

lyra-ecs/src/world.rs

@@ -1,4 +1,6 @@
-use std::{any::TypeId, cell::{Ref, RefMut}, collections::HashMap, ptr::NonNull};
+use std::{any::TypeId, collections::HashMap, ptr::NonNull};
+
+use atomic_refcell::{AtomicRef, AtomicRefMut};
 
 use crate::{archetype::{Archetype, ArchetypeId}, bundle::Bundle, query::{dynamic::DynamicView, AsQuery, Query, ViewState, ViewIter, ViewOne}, resource::ResourceData, ComponentInfo, DynTypeId, Entities, Entity, ResourceObject, Tick, TickTracker};
 
@@ -271,17 +273,17 @@ impl World {
 
     //pub fn view_one(&self, entity: EntityId) -> 
 
-    pub fn add_resource<T: 'static>(&mut self, data: T) {
+    pub fn add_resource<T: ResourceObject>(&mut self, data: T) {
         self.resources.insert(TypeId::of::<T>(), ResourceData::new(data));
     }
 
-    pub fn add_resource_default<T: Default + 'static>(&mut self) {
+    pub fn add_resource_default<T: ResourceObject + Default>(&mut self) {
         self.resources.insert(TypeId::of::<T>(), ResourceData::new(T::default()));
     }
 
     /// Get a resource from the world, or insert it into the world with the provided
     /// `fn` and return it.
-    pub fn get_resource_or_else<T: 'static, F>(&mut self, f: F) -> RefMut<T>
+    pub fn get_resource_or_else<T: ResourceObject, F>(&mut self, f: F) -> AtomicRefMut<T>
     where
         F: Fn() -> T + 'static
     {
@@ -291,7 +293,7 @@ impl World {
     }
 
     /// Get a resource from the world, or insert it into the world as its default.
-    pub fn get_resource_or_default<T: Default + 'static>(&mut self) -> RefMut<T>
+    pub fn get_resource_or_default<T: ResourceObject + Default>(&mut self) -> AtomicRefMut<T>
     {
         self.resources.entry(TypeId::of::<T>())
             .or_insert_with(|| ResourceData::new(T::default()))
@@ -302,21 +304,21 @@ impl World {
     /// 
     /// Will panic if the resource is not in the world. See [`World::try_get_resource`] for
     /// a function that returns an option.
-    pub fn get_resource<T: 'static>(&self) -> Ref<T> {
+    pub fn get_resource<T: ResourceObject>(&self) -> AtomicRef<T> {
         self.resources.get(&TypeId::of::<T>())
             .expect(&format!("World is missing resource of type '{}'", std::any::type_name::<T>()))
             .get()
     }
 
     /// Returns boolean indicating if the World contains a resource of type `T`.
-    pub fn has_resource<T: 'static>(&self) -> bool {
+    pub fn has_resource<T: ResourceObject>(&self) -> bool {
         self.resources.contains_key(&TypeId::of::<T>())
     }
 
     /// Attempts to get a resource from the World.
     /// 
     /// Returns `None` if the resource was not found.
-    pub fn try_get_resource<T: 'static>(&self) -> Option<Ref<T>> {
+    pub fn try_get_resource<T: ResourceObject>(&self) -> Option<AtomicRef<T>> {
         self.resources.get(&TypeId::of::<T>())
             .and_then(|r| r.try_get())
     }
@@ -325,7 +327,7 @@ impl World {
     /// 
     /// Will panic if the resource is not in the world. See [`World::try_get_resource_mut`] for
     /// a function that returns an option.
-    pub fn get_resource_mut<T: 'static>(&self) -> RefMut<T> {
+    pub fn get_resource_mut<T: ResourceObject>(&self) -> AtomicRefMut<T> {
         self.resources.get(&TypeId::of::<T>())
             .expect(&format!("World is missing resource of type '{}'", std::any::type_name::<T>()))
             .get_mut()
@@ -334,7 +336,7 @@ impl World {
     /// Attempts to get a mutable borrow of a resource from the World.
     /// 
     /// Returns `None` if the resource was not found.
-    pub fn try_get_resource_mut<T: 'static>(&self) -> Option<RefMut<T>> {
+    pub fn try_get_resource_mut<T: ResourceObject>(&self) -> Option<AtomicRefMut<T>> {
         self.resources.get(&TypeId::of::<T>())
             .and_then(|r| r.try_get_mut())
     }
@@ -364,6 +366,10 @@ impl World {
     }
 }
 
+// TODO: Ensure that all non-send resources are only accessible on the main thread.
+unsafe impl Send for World {}
+unsafe impl Sync for World {}
+
 #[cfg(test)]
 mod tests {
     use crate::{query::TickOf, tests::{Vec2, Vec3}, Entity};
@@ -440,16 +446,14 @@ mod tests {
     #[test]
     fn resource_multi_borrow() {
         let mut world = World::new();
-        {
         let counter = SimpleCounter(4582);
         world.add_resource(counter);
-        }
 
         // test multiple borrows at the same time
         let counter = world.get_resource::<SimpleCounter>();
         assert_eq!(counter.0, 4582);
         let counter2 = world.get_resource::<SimpleCounter>();
-        assert_eq!(counter2.0, 4582);
+        assert_eq!(counter.0, 4582);
         assert_eq!(counter2.0, 4582);
     }
 
@@ -461,7 +465,7 @@ mod tests {
             world.add_resource(counter);
         }
 
-        // test multiple borrows at the same time
+        // test that its only possible to get a single mutable borrow
         let counter = world.get_resource_mut::<SimpleCounter>();
         assert_eq!(counter.0, 4582);
         assert!(world.try_get_resource_mut::<SimpleCounter>().is_none());

lyra-game/Cargo.toml

@@ -8,6 +8,7 @@ lyra-resource = { path = "../lyra-resource" }
 lyra-ecs = { path = "../lyra-ecs", features = [ "math" ] }
 lyra-reflect = { path = "../lyra-reflect", features = [ "math" ] }
 lyra-math = { path = "../lyra-math" }
+lyra-scene = { path = "../lyra-scene" }
 
 winit = "0.28.1"
 tracing = "0.1.37"

lyra-game/src/as_any.rs

@@ -1,12 +1,13 @@
 use std::any::Any;
 
-pub trait CastableAny: Send + Sync + 'static {
+/// A trait that is implemented for types that are `Send + Sync + 'static`.
+pub trait AsSyncAny: Send + Sync + 'static {
     fn as_any(&self) -> &dyn Any;
     fn as_any_mut(&mut self) -> &mut dyn Any;
 }
 
 /// Implements this trait for anything that fits the type bounds
-impl<T: Send + Sync + 'static> CastableAny for T {
+impl<T: Send + Sync + 'static> AsSyncAny for T {
     fn as_any(&self) -> &dyn Any {
         self
     }

lyra-game/src/events.rs

@@ -1,15 +1,82 @@
-use std::{collections::{HashMap, VecDeque}, any::{TypeId, Any}, cell::RefCell};
+use std::{any::{Any, TypeId}, collections::{HashMap, VecDeque}, marker::PhantomData, mem::{self, MaybeUninit}, ops::Range};
 
-use crate::{castable_any::CastableAny, plugin::Plugin};
+use crate::plugin::Plugin;
 
 pub trait Event: Clone + Send + Sync + 'static {}
 impl<T: Clone + Send + Sync + 'static> Event for T {}
 
 pub type Events<T> = VecDeque<T>;
 
+#[derive(Clone)]
+struct TypeErasedBuffer {
+    type_id: TypeId,
+    item_size: usize,
+    data: Vec<MaybeUninit<u8>>,
+    fn_drop_item: fn(item: *mut ()),
+}
+
+impl Drop for TypeErasedBuffer {
+    fn drop(&mut self) {
+        let range = self.data.as_mut_ptr_range();
+        let mut current = range.start;
+        let end = range.end;
+
+        while current < end {
+            // SAFETY: current pointer will either be the start of the buffer, or at the start of
+            // the next item
+            (self.fn_drop_item)(current.cast());
+
+            // SAFETY: the items are placed right after eachother
+            current = unsafe { current.add(self.item_size) };
+        }
+
+        // Safety: all of the events were just dropped
+        unsafe { self.data.set_len(0) };
+    }
+}
+
+impl TypeErasedBuffer {
+    pub fn new<T: 'static>() -> Self {
+        Self {
+            type_id: TypeId::of::<T>(),
+            item_size: mem::size_of::<T>(),
+            data: Default::default(),
+            // dropped immediately after the read
+            fn_drop_item: |item| unsafe { item.cast::<T>().drop_in_place() },
+        }
+    }
+
+    pub fn push<T: 'static>(&mut self, value: T) {
+        debug_assert!(TypeId::of::<T>() == self.type_id, "The type of the buffer does not match the type that was added to it");
+
+        // reserve enough bytes to store T
+        let old_len = self.data.len();
+        self.data.reserve(mem::size_of::<T>());
+
+        // Get a pointer to the end of the data.
+        // SAFETY: we just reserved enough memory to store the data.
+        let end_ptr = unsafe { self.data.as_mut_ptr().add(old_len) };
+
+        unsafe {
+            // write the command and its runner into the buffer
+            end_ptr.cast::<T>()
+                // written unaligned to keep everything packed
+                .write_unaligned(value);
+
+            // we wrote to the vec's buffer without using its api, so we need manually
+            // set the length of the vec.
+            self.data.set_len(old_len + mem::size_of::<T>());
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len() / self.item_size
+    }
+}
+
 pub struct EventQueue {
-    events: HashMap<TypeId, RefCell<Box<dyn CastableAny>>>,
+    events: HashMap<TypeId, TypeErasedBuffer>,
-    event_write_queue: HashMap<TypeId, RefCell<Box<dyn CastableAny>>>
+    event_write_queue: HashMap<TypeId, TypeErasedBuffer>,
 }
 
 impl Default for EventQueue {
@@ -32,7 +99,7 @@ impl EventQueue {
         E: Event
     {
         // the compiler wants me to explicit right here for some reason
-        let default = || RefCell::new(Box::<Events::<E>>::default() as Box<dyn CastableAny>);
+        /* let default = || RefCell::new(Box::<Events::<E>>::default() as Box<dyn AsSyncAny>);
 
         // Get, or create, a list of events of this type
         let type_id = event.type_id();
@@ -42,7 +109,13 @@ impl EventQueue {
 
         // downcast resource as an events storage
         let e: &mut Events<E> = events.as_mut().as_any_mut().downcast_mut().unwrap();
-        e.push_back(event);
+        e.push_back(event); */
+
+        let type_id = event.type_id();
+        let events = self.event_write_queue.entry(type_id)
+            .or_insert_with(|| TypeErasedBuffer::new::<E>());
+
+        events.push(event);
     }
 
     // Clear events, this should happen at the start of every tick since events are cloned
@@ -60,13 +133,55 @@ impl EventQueue {
         }
     }
 
-    pub fn read_events<E>(&self) -> Option<Events<E>>
+    pub fn read_events<E>(&self) -> Option<EventReader<E>>
     where
         E: Event
     {
-        if let Some(event ) = self.events.get(&TypeId::of::<E>()) {
+        self.events.get(&TypeId::of::<E>())
-            let eref = event.borrow();
+            .map(|event| EventReader::new(event.clone()))
-            Some(eref.as_ref().as_any().downcast_ref::<Events<E>>().unwrap().clone())
+    }
+}
+
+pub struct EventReader<E: Event> {
+    buf: TypeErasedBuffer,
+    range: Option<Range<*mut MaybeUninit<u8>>>,
+    _marker: PhantomData<E>,
+}
+
+impl<E: Event> EventReader<E> {
+    fn new(buffer: TypeErasedBuffer) -> Self {
+        Self {
+            buf: buffer,
+            range: None,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.buf.len()
+    }
+}
+
+impl<E: Event> Iterator for EventReader<E> {
+    type Item = E;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.range.is_none() {
+            self.range = Some(self.buf.data.as_mut_ptr_range());
+        }
+
+        let range = self.range.as_mut().unwrap();
+
+        if range.start < range.end {
+            // Retrieve the event in the buffer.
+            // SAFETY: current pointer will either be the start of the buffer, or at the start
+            // of the next event.
+            let event = unsafe { range.start.cast::<E>().read_unaligned() };
+
+            // Advance the pointer to be after this event.
+            range.start = unsafe { range.start.add(mem::size_of::<E>()) };
+
+            Some(event)
         } else {
             None
         }

lyra-game/src/input/action.rs

@@ -521,10 +521,10 @@ fn actions_system(world: &mut World) -> anyhow::Result<()> {
         }
     }
     
-    let motion_avg = if let Some(mut mouse_events) = mouse_events {
+    let motion_avg = if let Some(mouse_events) = mouse_events {
         let count = mouse_events.len();
         let mut sum = Vec2::ZERO;
-        while let Some(mm) = mouse_events.pop_front() {
+        for mm in mouse_events {
             sum += mm.delta;
         }
         Some(sum / count as f32)

lyra-game/src/input/system.rs

@@ -110,8 +110,8 @@ impl crate::ecs::system::System for InputSystem {
             return Ok(());
         }
 
-        let mut events = queue.unwrap();
+        let events = queue.unwrap();
-        while let Some(event) = events.pop_front() {
+        for event in events {
             self.process_event(world, &event);
         }
 

lyra-game/src/lib.rs

@@ -8,7 +8,7 @@ pub mod game;
 pub mod render;
 pub mod resources;
 pub mod input;
-pub mod castable_any;
+pub mod as_any;
 pub mod plugin;
 pub mod change_tracker;
 

lyra-game/src/render/render_job.rs

@@ -1,17 +1,21 @@
 use lyra_ecs::Entity;
 
+use super::transform_buffer_storage::TransformIndex;
+
 pub struct RenderJob {
     pub entity: Entity,
     pub shader_id: u64,
     pub mesh_uuid: uuid::Uuid,
+    pub transform_id: TransformIndex,
 }
 
 impl RenderJob {
-    pub fn new(entity: Entity, shader_id: u64, mesh_buffer_id: uuid::Uuid) -> Self {
+    pub fn new(entity: Entity, shader_id: u64, mesh_buffer_id: uuid::Uuid, transform_id: TransformIndex) -> Self {
         Self {
             entity,
             shader_id,
             mesh_uuid: mesh_buffer_id,
+            transform_id
         }
     }
 }

lyra-game/src/render/renderer.rs

@@ -10,7 +10,7 @@ use lyra_ecs::query::filter::{Has, Or};
 use lyra_ecs::{Entity, Tick};
 use lyra_ecs::query::{Entities, TickOf};
 use lyra_ecs::World;
-use lyra_resource::gltf::GltfScene;
+use lyra_scene::SceneGraph;
 use tracing::{debug, warn};
 use uuid::Uuid;
 use wgpu::{BindGroupLayout, Limits};
@@ -29,14 +29,14 @@ use super::light_cull_compute::LightCullCompute;
 use super::material::Material;
 use super::render_buffer::BufferWrapper;
 use super::texture::RenderTexture;
-use super::transform_buffer_storage::TransformBuffers;
+use super::transform_buffer_storage::{TransformBuffers, TransformGroup};
 use super::vertex::Vertex;
 use super::{render_pipeline::FullRenderPipeline, render_buffer::BufferStorage, render_job::RenderJob};
 
 use lyra_resource::{gltf::Mesh, ResHandle};
 
 type MeshHandle = ResHandle<Mesh>;
-type SceneHandle = ResHandle<GltfScene>;
+type SceneHandle = ResHandle<SceneGraph>;
 
 pub trait Renderer {
     fn prepare(&mut self, main_world: &mut World);
@@ -374,12 +374,13 @@ impl BasicRenderer {
 
     /// Processes the mesh for the renderer, storing and creating buffers as needed. Returns true if a new mesh was processed.
     fn process_mesh(&mut self, entity: Entity, transform: Transform, mesh: &Mesh, mesh_uuid: Uuid) -> bool {
-        if self.transform_buffers.should_expand() {
+        let _ = transform;
+        /* if self.transform_buffers.should_expand() {
             self.transform_buffers.expand_buffers(&self.device);
         }
 
         self.transform_buffers.update_or_insert(&self.queue, &self.render_limits,
-            mesh_uuid, || ( transform.calculate_mat4(), glam::Mat3::from_quat(transform.rotation) ));
+            entity, || ( transform.calculate_mat4(), glam::Mat3::from_quat(transform.rotation) )); */
 
         #[allow(clippy::map_entry)]
         if !self.mesh_buffers.contains_key(&mesh_uuid) {
@@ -451,10 +452,14 @@ impl Renderer for BasicRenderer {
                         self.check_mesh_buffers(entity, &mesh_han);
                     }
                     
+                    let group = TransformGroup::EntityRes(entity, mesh_han.uuid());
+                    let transform_id = self.transform_buffers.update_or_push(&self.queue, &self.render_limits,
+                        group, || ( interop_pos.calculate_mat4(), glam::Mat3::from_quat(interop_pos.rotation) ));
+
                     let material = mesh.material.as_ref().unwrap()
                         .data_ref().unwrap();
                     let shader = material.shader_uuid.unwrap_or(0);
-                    let job = RenderJob::new(entity, shader, mesh_han.uuid());
+                    let job = RenderJob::new(entity, shader, mesh_han.uuid(), transform_id);
                     self.render_jobs.push_back(job);
                 }
             }
@@ -465,11 +470,11 @@ impl Renderer for BasicRenderer {
 
                 if let Some(scene) = scene_han.data_ref() {
                     let interpo_pos = self.interpolate_transforms(now_inst, last_epoch, entity, &transform, transform_epoch);
-                    let meshes = scene.collect_world_meshes();
 
-                    for (mesh_han, mesh_pos) in meshes.into_iter() {
+                    scene.traverse_down(|sw: &World, mesh_han, pos| {
+                        if let Some(mesh_han) = sw.view_one::<&MeshHandle>(mesh_han.entity()).get() {
                             if let Some(mesh) = mesh_han.data_ref() {
-                            let mesh_interpo = interpo_pos + mesh_pos;
+                                let mesh_interpo = interpo_pos + pos;
     
                                 // if process mesh did not just create a new mesh, and the epoch
                                 // shows that the scene has changed, verify that the mesh buffers
@@ -479,13 +484,19 @@ impl Renderer for BasicRenderer {
                                     self.check_mesh_buffers(entity, &mesh_han);
                                 }
 
+                                let scene_mesh_group = TransformGroup::Res(scene_han.uuid(), mesh_han.uuid());
+                                let group = TransformGroup::OwnedGroup(entity, scene_mesh_group.into());
+                                let transform_id = self.transform_buffers.update_or_push(&self.queue, &self.render_limits,
+                                    group, || ( mesh_interpo.calculate_mat4(), glam::Mat3::from_quat(mesh_interpo.rotation) ));
+                                
                                 let material = mesh.material.as_ref().unwrap()
                                     .data_ref().unwrap();
                                 let shader = material.shader_uuid.unwrap_or(0);
-                            let job = RenderJob::new(entity, shader, mesh_han.uuid());
+                                let job = RenderJob::new(entity, shader, mesh_han.uuid(), transform_id);
                                 self.render_jobs.push_back(job);
                             }
                         }
+                    });
                 }
             }
         }
@@ -575,9 +586,8 @@ impl Renderer for BasicRenderer {
                     }
 
                     // Get the bindgroup for job's transform and bind to it using an offset.
-                    let transform_indices = *self.transform_buffers.transform_indices(job.mesh_uuid).unwrap();
+                    let bindgroup = self.transform_buffers.bind_group(job.transform_id);
-                    let bindgroup = self.transform_buffers.bind_group(transform_indices).unwrap();
+                    let offset = self.transform_buffers.buffer_offset(job.transform_id);
-                    let offset = TransformBuffers::index_offset(&self.render_limits, transform_indices) as u32;
                     render_pass.set_bind_group(1, bindgroup, &[ offset, offset, ]);
 
                     render_pass.set_bind_group(2, &self.camera_buffer.bindgroup(), &[]);

lyra-game/src/render/transform_buffer_storage.rs

@@ -1,44 +1,167 @@
-use std::{collections::{VecDeque, HashMap}, num::NonZeroU64};
+use std::{collections::{HashMap, VecDeque}, hash::{BuildHasher, DefaultHasher, Hash, Hasher, RandomState}, num::NonZeroU64};
 
+use lyra_ecs::Entity;
 use uuid::Uuid;
 use wgpu::Limits;
 
 use std::mem;
 
+/// A group id created from a [`TransformGroup`].
+/// 
+/// This is mainly created so that [`TransformGroup::OwnedGroup`] can use another group inside of it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct TransformGroupId(u64);
+
+impl From<TransformGroup> for TransformGroupId {
+    fn from(value: TransformGroup) -> Self {
+        let mut hasher = DefaultHasher::new();
+        value.hash(&mut hasher);
+        let hash = hasher.finish();
+        
+        TransformGroupId(hash)
+    }
+}
+
+/// Used as a key into the [`TransformBuffers`].
+/// 
+/// This enum is used as a key to identify a transform for a RenderJob. The renderer uses this
+/// to differentiate a transform between two entities that share a resource handle to the same
+/// scene:
+/// ```nobuild
+/// // The group of the mesh in the scene.
+/// let scene_mesh_group = TransformGroup::Res(scene_handle.uuid(), mesh_handle.uuid());
+/// // The group of the owned entity that has mesh in a scene.
+/// let finished_group = TransformGroup::OwnedGroup(entity, scene_mesh_group.into());
+/// ```
+/// 
+/// A simpler example of the use of a transform group is when processing lone mesh handles
+/// owned by entities:
+/// ```nobuild
+/// let group = TransformGroup::EntityRes(entity, mesh_handle.uuid());
+/// ```
+/// 
+/// These were made to fix [#6](https://git.seanomik.net/SeanOMik/lyra-engine/issues/6).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum TransformGroup {
+    /// Just an entity.
+    Entity(Entity),
+    /// An entity that owns another group.
+    OwnedGroup(Entity, TransformGroupId),
+    /// A resource uuid grouped with an owning Entity.
+    EntityRes(Entity, Uuid),
+    /// A resource uuid grouped with another resource uuid.
+    Res(Uuid, Uuid),
+}
+
+/// The index of a specific Transform inside of the buffers.
 #[derive(Default, Copy, Clone, PartialEq, Eq, Debug)]
-pub(crate) struct TransformBufferIndices {
+pub struct TransformIndex {
-    pub buffer_index: usize,
+    /// The index of the entry in the buffer chain.
-    pub transform_index: usize,
+    entry_index: usize,
+    /// The index of the transform in the entry.
+    transform_index: usize,
 }
 
 /// A struct representing a single transform buffer. There can be multiple of these
-pub(crate) struct TransformBufferEntry {
+struct BufferEntry {
     pub len: usize,
-    pub transform_buf: wgpu::Buffer,
-    pub normal_mat_buf: wgpu::Buffer,
     pub bindgroup: wgpu::BindGroup,
+    pub transform_buffer: wgpu::Buffer,
+    pub normal_buffer: wgpu::Buffer,
+}
+
+/// A HashMap that caches values for reuse.
+/// 
+/// The map detects dead values by tracking which entries were not updated since the last time
+/// [`CachedValMap::update`] was ran. When dead values are collected, they can be reused on an
+/// [`insert`](CachedValMap::insert) into the map.
+struct CachedValMap<K, V, S = RandomState> {
+    latest: HashMap<K, V, S>,
+    old: HashMap<K, V, S>,
+    dead: VecDeque<V>,
+}
+
+impl<K, V, S: Default> Default for CachedValMap<K, V, S> {
+    fn default() -> Self {
+        Self {
+            latest: Default::default(),
+            old: Default::default(),
+            dead: Default::default()
+        }
+    }
+}
+
+#[allow(dead_code)]
+impl<K: Hash + Eq + PartialEq + Clone, V: Clone, S: BuildHasher> CachedValMap<K, V, S> {
+    /// Insert a key, possibly reusing a value in the map.
+    /// 
+    /// Returns the reused value, if one was reused. If its `None`, then the value was retrieved
+    /// from running `val_fn`.
+    pub fn insert<F>(&mut self, key: K, mut val_fn: F) -> Option<V>
+    where
+        F: FnMut() -> V
+    {
+        if self.latest.contains_key(&key) {
+            self.latest.insert(key, val_fn());
+            None
+        } else {
+            let val = self.dead.pop_front()
+                .unwrap_or_else(val_fn);
+            self.latest.insert(key, val.clone());
+            Some(val)
+        }
+    }
+
+    /// Returns a reference to the value corresponding to the key.
+    pub fn get(&mut self, key: K) -> Option<&V> {
+        if let Some(v) = self.old.remove(&key) {
+            self.latest.insert(key.clone(), v);
+        }
+
+        self.latest.get(&key)
+    }
+
+    /// Keep a key alive without updating its value.
+    pub fn keep_alive(&mut self, key: K) {
+        if let Some(v) = self.old.remove(&key) {
+            self.latest.insert(key, v);
+        }
+    }
+
+    /// Returns `true` if the map contains a value for the specified key.
+    pub fn contains(&self, key: K) -> bool {
+        self.old.contains_key(&key) || self.latest.contains_key(&key)
+    }
+
+    /// Collects the now dead values for reuse.
+    /// 
+    /// This detects dead values by tracking which entries were not updated since the last time
+    /// update was ran.
+    pub fn update(&mut self) {
+        // drain the dead values into the dead queue
+        self.dead.extend(self.old.drain().map(|(_, v)| v));
+
+        // now drain the latest entries into the old entries
+        self.old.extend(self.latest.drain());
+    }
 }
 
 /// A helper struct for managing the Transform buffers for meshes.
 /// 
-/// This struct manages a "chain" of uniform buffers that store Transform for meshes. When
+/// This struct manages a "chain" of uniform buffers that store Transform for [`TransformGroup`]s.
-/// first created it only has a single "chain-link" with a buffer that is the maximum length
+/// When first created it only has a single "chain-link" with a buffer that is the maximum length
 /// the GPU supports. When the first buffer fills up, a new one should be created which will also
 /// be the maximum length the GPU supports. When the new buffer fills up, a new one will be
 /// created once again, and so on.
 /// 
-/// `Uuid`'s are used to represent entries (usually Meshes) in the buffer. The Uuid's can be used
+/// [`TransformGroup`]s are used to represent entries in the buffer. They are used to insert,
-/// to insert, update, and retrieve the transforms.
+/// update, and retrieve the transforms.
-pub(crate) struct TransformBuffers {
+pub struct TransformBuffers {
     pub bindgroup_layout: wgpu::BindGroupLayout,
-    pub just_updated: HashMap<Uuid, TransformBufferIndices>,
+    groups: CachedValMap<TransformGroupId, TransformIndex>,
-    pub not_updated: HashMap<Uuid, TransformBufferIndices>,
+    entries: Vec<BufferEntry>,
-    pub dead_indices: VecDeque<TransformBufferIndices>,
+    limits: wgpu::Limits,
-    pub next_indices: TransformBufferIndices,
+    max_transform_count: usize,
-    /// (transform count, buffer, bindgroup)
-    pub buffer_bindgroups: Vec<TransformBufferEntry>,
-    /// The max amount of transforms in a buffer
-    pub max_transform_count: usize,
 }
 
 impl TransformBuffers {
@@ -72,13 +195,11 @@ impl TransformBuffers {
         });
 
         let mut s = Self {
-            max_transform_count: limits.max_uniform_buffer_binding_size as usize / (mem::size_of::<glam::Mat4>() * 2),
-            buffer_bindgroups: Vec::new(),
             bindgroup_layout,
-            just_updated: HashMap::new(),
+            groups: Default::default(),
-            not_updated: HashMap::new(),
+            entries: Default::default(),
-            dead_indices: VecDeque::new(),
+            max_transform_count: (limits.max_uniform_buffer_binding_size / 2) as usize / (mem::size_of::<glam::Mat4>()),
-            next_indices: TransformBufferIndices::default(),
+            limits,
         };
 
         // create the first uniform buffer
@@ -87,106 +208,84 @@ impl TransformBuffers {
         s
     }
 
-    /// Update an transform in the buffer.
+    /// Update an existing transform in the buffers.
     /// 
     /// # Panics
-    /// Panics if the entity isn't stored, you can check if it is before with [`TransformBuffers:contains`].
+    /// Panics if the `entity_group` is not already inside of the buffers.
-    pub fn update_transform(&mut self, queue: &wgpu::Queue, limits: &Limits, uuid: Uuid, transform: glam::Mat4, normal_matrix: glam::Mat3) -> TransformBufferIndices {
+    pub fn update_transform(&mut self, queue: &wgpu::Queue, limits: &Limits, entity_group: TransformGroup, transform: glam::Mat4, normal_matrix: glam::Mat3) -> TransformIndex {
-        let indices = self.not_updated.remove(&uuid)
+        let index = *self.groups.get(entity_group.into())
-            .or_else(|| self.just_updated.remove(&uuid))
+            .expect("Use 'push_transform' for new entities");
-            .expect("Use 'insert_entity' for new entities");
+        let entry = self.entries.get_mut(index.entry_index).unwrap();
-        self.just_updated.insert(uuid, indices);
 
         let normal_matrix = glam::Mat4::from_mat3(normal_matrix);
 
-        let buffer = self.buffer_bindgroups.get(indices.buffer_index).unwrap();
+        // write the transform and normal to the end of the transform
-        let offset = Self::index_offset(limits, indices);
+        let offset = Self::get_buffer_offset(limits, index) as _;
-        queue.write_buffer(&buffer.transform_buf, offset, bytemuck::bytes_of(&transform));
+        queue.write_buffer(&entry.transform_buffer, offset, bytemuck::bytes_of(&transform));
-        queue.write_buffer(&buffer.normal_mat_buf, offset, bytemuck::bytes_of(&normal_matrix));
+        queue.write_buffer(&entry.normal_buffer, offset, bytemuck::bytes_of(&normal_matrix));
-        indices
+
+        index
     }
 
-    /// Insert a new transform into the buffer, returns where in the buffer it was stored.
+    /// Push a new transform into the buffers.
-    pub fn insert_transform(&mut self, queue: &wgpu::Queue, limits: &Limits, uuid: Uuid, transform: glam::Mat4, normal_matrix: glam::Mat3) -> TransformBufferIndices {
+    pub fn push_transform(&mut self, queue: &wgpu::Queue, limits: &Limits, entity_group: TransformGroup, transform: glam::Mat4, normal_matrix: glam::Mat3) -> TransformIndex {
-        let indices = match self.dead_indices.pop_front() {
+        self.groups.insert(entity_group.into(), || {
-            Some(indices) => indices,
+            // this closure is only called when there are no values that can be reused,
-            None => {
+            // so we get a brand new index at the end of the last entry in the chain.
-                let indices = &mut self.next_indices;
+            let last = self.entries.last_mut().unwrap();
-                let this_idx = *indices;
-                let entry = self.buffer_bindgroups.get_mut(indices.buffer_index).unwrap();
             
-                if entry.len >= self.max_transform_count {
+            // ensure the gpu buffer is not overflown
-                    panic!("Transform buffer is filled and 'next_indices' was not incremented! Was a new buffer created?");
+            debug_assert!(last.len < self.max_transform_count,
-                }
+                "Transform buffer is filled and 'next_indices' was not incremented! \
+                    Was a new buffer created?");
             
-                entry.len += 1;
+            let tidx = last.len;
-                indices.transform_index += 1;
+            last.len += 1;
-                this_idx
-            }
-        };
 
-        self.just_updated.insert(uuid, indices);
+            TransformIndex {
-        self.update_transform(queue, limits, uuid, transform, normal_matrix)
+                entry_index: self.entries.len() - 1,
+                transform_index: tidx
             }
+        });
 
-    /// Update or insert a transform
+        self.update_transform(queue, limits, entity_group, transform, normal_matrix)
-    pub fn update_or_insert<TFn>(&mut self, queue: &wgpu::Queue, limits: &Limits, uuid: Uuid, transform_fn: TFn) -> TransformBufferIndices
-        where TFn: Fn() -> (glam::Mat4, glam::Mat3)
-    {   
-        let (tran, norm) = transform_fn();
-        if self.contains(uuid) {
-            self.update_transform(queue, limits, uuid, tran, norm)
-        } else {
-            self.insert_transform(queue, limits, uuid, tran, norm)
-        }
-    }
-
-    /// Returns true if the transform related to the `uuid` is stored (does not mean its up-to-date).
-    pub fn contains(&self, uuid: Uuid) -> bool {
-        self.not_updated.contains_key(&uuid) || self.just_updated.contains_key(&uuid)
     }
 
     /// Collect the dead transforms and prepare self to check next time.
     pub fn tick(&mut self) {
-        // take the dead entities, these were ones that were not updated this tick
+        self.groups.update();
-        let dead: VecDeque<TransformBufferIndices> = self.not_updated.values().copied().collect();
-        self.dead_indices = dead;
-
-        self.not_updated = self.just_updated.clone();
-        self.just_updated.clear();
     }
 
-    /// Returns the offset for the transform index in the buffer
+    /// Returns a boolean indicating if the buffer contains this group.
-    pub fn index_offset(limits: &Limits, indices: TransformBufferIndices) -> u64 {
+    pub fn contains(&self, group: TransformGroup) -> bool {
-        indices.transform_index as u64 * limits.min_uniform_buffer_offset_alignment as u64
+        self.groups.contains(group.into())
     }
 
-    /// Returns whether or not the transform buffers should be expanded
+    /// Update an existing transform group or if its not existing yet, pushes it to the buffer.
-    pub fn should_expand(&self) -> bool {
+    /// 
-        if let Some(entry) = self.buffer_bindgroups.last() {
+    /// Returns: the index that the transform is at in the buffers.
-            entry.len >= self.max_transform_count
+    pub fn update_or_push<F>(&mut self, queue: &wgpu::Queue, limits: &Limits, group: TransformGroup, transform_fn: F) -> TransformIndex
+        where F: Fn() -> (glam::Mat4, glam::Mat3)
+    {   
+        let (transform, normal_matrix) = transform_fn();
+        if self.contains(group) {
+            self.update_transform(queue, limits, group, transform, normal_matrix)
         } else {
-            true
+            self.push_transform(queue, limits, group, transform, normal_matrix)
         }
     }
 
-    /// Returns the bind group for the index
-    pub fn bind_group(&self, index: TransformBufferIndices) -> Option<&wgpu::BindGroup> {
-        self.buffer_bindgroups.get(index.buffer_index)
-            .map(|entry| &entry.bindgroup)
-    }
-
     /// Expand the Transform buffers by adding another uniform buffer binding.
     /// 
     /// This object has a chain of uniform buffers, when the buffers are expanded, a new
     /// "chain-link" is created.
     pub fn expand_buffers(&mut self, device: &wgpu::Device) {
         let limits = device.limits();
-        let max_buffer_sizes = (limits.max_uniform_buffer_binding_size as u64) / 2;
+        let max_buffer_sizes = self.max_transform_count as u64 * limits.min_uniform_buffer_offset_alignment as u64;
 
         let transform_buffer = device.create_buffer(
             &wgpu::BufferDescriptor {
-                label: Some(&format!("B_Transform_{}", self.buffer_bindgroups.len())),
+                label: Some(&format!("B_Transform_{}", self.entries.len())),
                 usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
                 size: max_buffer_sizes,
                 mapped_at_creation: false,
@@ -195,7 +294,7 @@ impl TransformBuffers {
 
         let normal_mat_buffer = device.create_buffer(
             &wgpu::BufferDescriptor {
-                label: Some(&format!("B_NormalMatrix_{}", self.buffer_bindgroups.len())),
+                label: Some(&format!("B_NormalMatrix_{}", self.entries.len())),
                 usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
                 size: max_buffer_sizes,
                 mapped_at_creation: false,
@@ -234,17 +333,43 @@ impl TransformBuffers {
             label: Some("BG_Transforms"),
         });
 
-        let entry = TransformBufferEntry {
+        let entry = BufferEntry {
             bindgroup: transform_bind_group,
-            transform_buf: transform_buffer,
+            transform_buffer,
-            normal_mat_buf: normal_mat_buffer,
+            normal_buffer: normal_mat_buffer,
             len: 0,
         };
-        self.buffer_bindgroups.push(entry);
+        self.entries.push(entry);
     }
 
-    /// Returns the indices of the Transform 
+    /// Returns the bind group for the transform index.
-    pub fn transform_indices(&self, uuid: Uuid) -> Option<&TransformBufferIndices> {
+    pub fn bind_group(&self, transform_id: TransformIndex) -> &wgpu::BindGroup {
-        self.just_updated.get(&uuid).or_else(|| self.not_updated.get(&uuid))
+        let entry = self.entries.get(transform_id.entry_index).unwrap();
+        &entry.bindgroup
+    }
+
+    /// Get the buffer offset for a transform using wgpu limits.
+    /// 
+    /// If its possible to borrow immutably, use [`TransformBuffers::buffer_offset`].
+    fn get_buffer_offset(limits: &wgpu::Limits, transform_index: TransformIndex) -> u32 {
+        transform_index.transform_index as u32 * limits.min_uniform_buffer_offset_alignment as u32
+    }
+
+    /// Returns the offset of the transform inside the bind group buffer.
+    /// 
+    /// ```nobuild
+    /// let bindgroup = transform_buffers.bind_group(job.transform_id);
+    /// let offset = transform_buffers.buffer_offset(job.transform_id);
+    /// render_pass.set_bind_group(1, bindgroup, &[ offset, offset, ]);
+    /// ```
+    pub fn buffer_offset(&self, transform_index: TransformIndex) -> u32 {
+        Self::get_buffer_offset(&self.limits, transform_index)
     }
 }
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct TransformNormalMatPair {
+    transform: glam::Mat4,
+    normal_mat: glam::Mat4,
+}

lyra-game/src/render/window.rs

@@ -341,8 +341,8 @@ fn window_updater_system(world: &mut World) -> anyhow::Result<()> {
             let mut opts = world.get_resource_mut::<Ct<WindowOptions>>();
 
             if let Some(event_queue) = world.try_get_resource_mut::<EventQueue>() {
-                if let Some(mut events) = event_queue.read_events::<InputEvent>() {
+                if let Some(events) = event_queue.read_events::<InputEvent>() {
-                    while let Some(ev) = events.pop_front() {
+                    for ev in events {
                         match ev {
                             InputEvent::CursorEntered { .. } => {
                                 opts.cursor_inside_window = true;

lyra-reflect/lyra-reflect-derive/src/enum_derive.rs

@@ -32,7 +32,7 @@ impl From<&Variant> for VariantType {
 
 /// Generates the following different outputs:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// // for struct variants
 /// TestEnum::Error { msg, code }
 /// 
@@ -98,7 +98,7 @@ fn gen_variant_if(enum_id: &proc_macro2::Ident, variant: &Variant, if_body: proc
 
 /// Generates the following:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// /// generated one field here
 /// if name ==  "msg" {
 ///     return Some(msg);
@@ -129,7 +129,7 @@ fn gen_if_field_names(variant: &Variant) -> proc_macro2::TokenStream {
 
 /// Generates the following rust code:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// match name {
 ///     "msg" | "code" => true,
 ///     _ => false,
@@ -153,7 +153,7 @@ fn gen_match_names(variant: &Variant) -> proc_macro2::TokenStream {
 
 /// Generates the following:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// /// generated one field here
 /// if idx == 0 {
 ///     return Some(a);
@@ -190,7 +190,7 @@ fn gen_if_field_indices(variant: &Variant) -> proc_macro2::TokenStream {
 
 /// Generates the following:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// /// generated one field here
 /// if idx == 0 {
 ///     return Some("a");
@@ -226,7 +226,7 @@ fn gen_if_field_indices_names(variant: &Variant) -> proc_macro2::TokenStream {
 }
 
 /// Generates the following:
-/// ```compile_fail
+/// ```nobuild
 /// /// when `by_index` is false:
 /// 
 /// if let TestEnum::Error{ msg, code} = self {
@@ -300,7 +300,7 @@ fn gen_enum_if_stmts(enum_id: &proc_macro2::Ident, data: &DataEnum, by_index: bo
 
 /// Generates the following rust code:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// if let TestEnum::Error { msg, code } = self {
 ///     return match name {
 ///       // expands for continuing struct fields
@@ -331,7 +331,7 @@ fn gen_enum_has_field(enum_id: &proc_macro2::Ident, data: &DataEnum) -> proc_mac
 
 /// Generates the following code:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// match self {
 ///     TestEnum::Start => 0,
 ///     TestEnum::Middle(a, b) => 2,
@@ -358,7 +358,7 @@ fn gen_enum_fields_len(enum_id: &proc_macro2::Ident, data: &DataEnum) -> proc_ma
 
 /// Generates the following code:
 /// 
-/// ```compile_fail
+/// ```nobuild
 /// if let TestEnum::Error { msg, code } = self {
 ///     if idx == 0 {
 ///         return Some("msg");
@@ -389,7 +389,7 @@ fn gen_enum_field_name_at(enum_id: &proc_macro2::Ident, data: &DataEnum) -> proc
 }
 
 /// Generates the following code:
-/// ```compile_fail
+/// ```nobuild
 /// match self {
 ///     TestEnum::Start => 0,
 ///     TestEnum::Middle(a, b) => 1,
@@ -427,7 +427,7 @@ fn gen_enum_variant_name(enum_id: &proc_macro2::Ident, data: &DataEnum, gen_inde
 /// Generates a match statement that returns the types of the variants of the enum.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// match self {
 ///     TestEnum::Start => EnumType::Unit,
 ///     TestEnum::Middle(a, b) => EnumType::Tuple,

lyra-reflect/lyra-reflect-derive/src/struct_derive.rs

@@ -28,7 +28,7 @@ impl StructType {
 /// contains a borrow (mutable borrow if `is_mut` is true) to the matching struct field.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// // when `is_mut` = false
 /// match name {
 ///     "x" => Some(&self.x),
@@ -85,7 +85,7 @@ fn gen_struct_field_match(data: &DataStruct, is_mut: bool) -> proc_macro2::Token
 /// with the provided `val`.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// match name {
 ///     "x" => self.x = any_val.downcast_ref::<f32>()
 ///                .expect(&format!("Cannot set struct's field of {} type to the provided type of {}", "f32", val.name()))
@@ -140,7 +140,7 @@ fn gen_struct_set_field_match(data: &DataStruct) -> proc_macro2::TokenStream {
 /// the type of the field.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// match name {
 ///     "x" => Some("f32"),
 ///     "y" => Some("f32"),
@@ -177,7 +177,7 @@ fn gen_struct_field_name_match(data: &DataStruct) -> proc_macro2::TokenStream {
 /// with the provided `val`.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// match name {
 ///     0 => self.x = any_val.downcast_ref::<f32>()
 ///                .expect(&format!("Cannot set struct's field of {} type to the provided type of {}", "f32", val.name()))
@@ -243,7 +243,7 @@ fn gen_struct_set_field_match_idx(data: &DataStruct) -> proc_macro2::TokenStream
 /// type of the field.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// match name {
 ///     0 => Some("f32"),
 ///     1 => Some("f32"),
@@ -274,7 +274,7 @@ fn gen_struct_field_name_match_idx(data: &DataStruct) -> proc_macro2::TokenStrea
 /// to the matching struct field.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// // when `is_mut` = false
 /// match idx {
 ///     0 => Some(&self.x),
@@ -335,7 +335,7 @@ fn gen_struct_field_match_idx(data: &DataStruct, is_mut: bool) -> proc_macro2::T
 /// and returns an Option that contains the name of the field.
 /// 
 /// Example:
-/// ```compile_fail
+/// ```nobuild
 /// match idx {
 ///     0 => Some("x"),
 ///     1 => Some("y"),

lyra-reflect/src/lib.rs

@@ -2,7 +2,7 @@
 
 use std::{any::TypeId, any::Any, cell::{Ref, RefMut}};
 
-use lyra_ecs::World;
+use lyra_ecs::{AtomicRef, AtomicRefMut, World};
 
 extern crate self as lyra_reflect;
 
@@ -250,46 +250,46 @@ pub trait FromType<T> {
 
 pub trait ReflectWorldExt {
     /// Retrieves the type registry from the world.
-    fn get_type_registry(&self) -> Ref<TypeRegistry>;
+    fn get_type_registry(&self) -> AtomicRef<TypeRegistry>;
     /// Retrieves the type registry mutably from the world.
-    fn get_type_registry_mut(&self) -> RefMut<TypeRegistry>;
+    fn get_type_registry_mut(&self) -> AtomicRefMut<TypeRegistry>;
     /// Get a registered type from the type registry. Returns `None` if the type is not registered
-    fn get_type<T>(&self, type_id: TypeId) -> Option<Ref<RegisteredType>>;
+    fn get_type<T>(&self, type_id: TypeId) -> Option<AtomicRef<RegisteredType>>;
     /// Get a mutable registered type from the type registry in the world. returns `None` if the type is not registered.
-    fn get_type_mut<T>(&self, type_id: TypeId) -> Option<RefMut<RegisteredType>>;
+    fn get_type_mut<T>(&self, type_id: TypeId) -> Option<AtomicRefMut<RegisteredType>>;
     /// Get a registered type, or register a new type and return it.
-    fn get_type_or_default<T>(&self, type_id: TypeId) -> RefMut<RegisteredType>;
+    fn get_type_or_default<T>(&self, type_id: TypeId) -> AtomicRefMut<RegisteredType>;
 }
 
 impl ReflectWorldExt for World {
-    fn get_type_registry(&self) -> Ref<TypeRegistry> {
+    fn get_type_registry(&self) -> AtomicRef<TypeRegistry> {
         self.get_resource::<TypeRegistry>()
     }
     
-    fn get_type_registry_mut(&self) -> RefMut<TypeRegistry> {
+    fn get_type_registry_mut(&self) -> AtomicRefMut<TypeRegistry> {
         self.get_resource_mut::<TypeRegistry>()
     }
     
-    fn get_type<T>(&self, type_id: TypeId) -> Option<Ref<RegisteredType>> {
+    fn get_type<T>(&self, type_id: TypeId) -> Option<AtomicRef<RegisteredType>> {
         let r = self.get_resource::<TypeRegistry>();
         if r.has_type(type_id) {
-            Some(Ref::map(r, |tr| tr.get_type(type_id).unwrap()))
+            Some(AtomicRef::map(r, |tr| tr.get_type(type_id).unwrap()))
         } else {
             None
         }
     }
 
-    fn get_type_mut<T>(&self, type_id: TypeId) -> Option<RefMut<RegisteredType>> {
+    fn get_type_mut<T>(&self, type_id: TypeId) -> Option<AtomicRefMut<RegisteredType>> {
         let r = self.get_resource_mut::<TypeRegistry>();
         if r.has_type(type_id) {
-            Some(RefMut::map(r, |tr| tr.get_type_mut(type_id).unwrap()))
+            Some(AtomicRefMut::map(r, |tr| tr.get_type_mut(type_id).unwrap()))
         } else {
             None
         }
     }
 
-    fn get_type_or_default<T>(&self, type_id: TypeId) -> RefMut<RegisteredType> {
+    fn get_type_or_default<T>(&self, type_id: TypeId) -> AtomicRefMut<RegisteredType> {
         let r = self.get_resource_mut::<TypeRegistry>();
-        RefMut::map(r, |tr| tr.get_type_or_default(type_id))
+        AtomicRefMut::map(r, |tr| tr.get_type_or_default(type_id))
     }
 }

lyra-reflect/src/registry.rs

@@ -1,4 +1,4 @@
-use std::{any::{TypeId, type_name}, collections::HashMap, ops::Deref};
+use std::{any::{type_name, Any, TypeId}, collections::HashMap, ops::Deref};
 
 /// Storage for 
 #[derive(Default, Clone)]
@@ -44,19 +44,19 @@ impl TypeRegistry {
     }
 }
 
-pub trait TypeData: std::any::Any {
+pub trait TypeData: Send + Sync + Any {
-    fn as_any(&self) -> &dyn std::any::Any;
+    fn as_any(&self) -> &dyn Any;
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
+    fn as_any_mut(&mut self) -> &mut dyn Any;
 
     fn boxed_clone(&self) -> Box<dyn TypeData>;
 }
 
-impl<T: Clone + 'static> TypeData for T {
+impl<T: Clone + Send + Sync + Any> TypeData for T {
-    fn as_any(&self) -> &dyn std::any::Any {
+    fn as_any(&self) -> &dyn Any {
         self
     }
 
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+    fn as_any_mut(&mut self) -> &mut dyn Any {
         self
     }
 

lyra-reflect/src/resource.rs

@@ -1,6 +1,6 @@
-use std::{any::{Any, TypeId}, cell::{Ref, RefMut}, ptr::NonNull};
+use std::{any::{Any, TypeId}, mem, ptr::NonNull};
 
-use lyra_ecs::{World, ResourceObject};
+use lyra_ecs::{AtomicRef, AtomicRefMut, ResourceObject, World};
 
 use crate::{Reflect, FromType};
 
@@ -8,20 +8,20 @@ use crate::{Reflect, FromType};
 pub struct ReflectedResource {
     pub type_id: TypeId,
 
-    fn_reflect: for<'a> fn (world: &'a World) -> Option<Ref<'a, dyn Reflect>>,
+    fn_reflect: for<'a> fn (world: &'a World) -> Option<AtomicRef<'a, dyn Reflect>>,
-    fn_reflect_mut: for<'a> fn (world: &'a mut World) -> Option<RefMut<'a, dyn Reflect>>,
+    fn_reflect_mut: for<'a> fn (world: &'a mut World) -> Option<AtomicRefMut<'a, dyn Reflect>>,
     fn_reflect_ptr: fn (world: &mut World) -> Option<NonNull<u8>>,
     fn_refl_insert: fn (world: &mut World, this: Box<dyn Reflect>),
 }
 
 impl ReflectedResource {
     /// Retrieves the reflected resource from the world.
-    pub fn reflect<'a>(&self, world: &'a World) -> Option<Ref<'a, dyn Reflect>> {
+    pub fn reflect<'a>(&self, world: &'a World) -> Option<AtomicRef<'a, dyn Reflect>> {
         (self.fn_reflect)(world)
     }
 
     /// Retrieves a mutable reflected resource from the world.
-    pub fn reflect_mut<'a>(&self, world: &'a mut World) -> Option<RefMut<'a, dyn Reflect>> {
+    pub fn reflect_mut<'a>(&self, world: &'a mut World) -> Option<AtomicRefMut<'a, dyn Reflect>> {
         (self.fn_reflect_mut)(world)
     }
 
@@ -41,11 +41,15 @@ impl<T: ResourceObject + Reflect> FromType<T> for ReflectedResource {
             type_id: TypeId::of::<T>(),
             fn_reflect: |world: &World| {
                 world.try_get_resource::<T>()
-                    .map(|r| r as Ref<dyn Reflect>)
+                    .map(|r| {
+                        AtomicRef::map(r, |r| r as &dyn Reflect)
+                    })
             },
             fn_reflect_mut: |world: &mut World| {
                 world.try_get_resource_mut::<T>()
-                    .map(|r| r as RefMut<dyn Reflect>)
+                    .map(|r| {
+                        AtomicRefMut::map(r, |r| r as &mut dyn Reflect)
+                    })
             },
             fn_reflect_ptr: |world: &mut World| unsafe {
                 world.try_get_resource_ptr::<T>()

lyra-resource/Cargo.toml

@@ -9,6 +9,7 @@ edition = "2021"
 lyra-ecs = { path = "../lyra-ecs", features = [ "math" ] }
 lyra-reflect = { path = "../lyra-reflect" }
 lyra-math = { path = "../lyra-math" }
+lyra-scene = { path = "../lyra-scene" }
 anyhow = "1.0.75"
 base64 = "0.21.4"
 crossbeam = { version = "0.8.4", features = [ "crossbeam-channel" ] }

lyra-resource/src/gltf/loader.rs

@@ -3,9 +3,10 @@ use std::{ffi::OsStr, path::{Path, PathBuf}, sync::Arc};
 use glam::{Quat, Vec3};
 use instant::Instant;
 use lyra_math::Transform;
+use lyra_scene::{SceneGraph, SceneNode};
 use thiserror::Error;
 
-use crate::{gltf::GltfScene, loader::{LoaderError, PinedBoxLoaderFuture, ResourceLoader}, util, ResHandle, ResourceData, ResourceManager, ResourceStorage};
+use crate::{loader::{LoaderError, PinedBoxLoaderFuture, ResourceLoader}, util, ResHandle, ResourceData, ResourceManager, ResourceStorage};
 use super::{Gltf, GltfNode, Material, Mesh, MeshIndices, MeshVertexAttribute, VertexAttributeData};
 
 use tracing::debug;
@@ -64,7 +65,7 @@ impl ModelLoader {
         }
     } */
 
-    fn process_node(ctx: &mut GltfLoadContext, materials: &Vec<ResHandle<Material>>, gnode: gltf::Node<'_>) -> GltfNode {
+    fn process_node(ctx: &mut GltfLoadContext, materials: &Vec<ResHandle<Material>>, scene: &mut SceneGraph, scene_parent: &SceneNode, gnode: gltf::Node<'_>) -> GltfNode {
         let mut node = GltfNode::default();
 
         node.transform = {
@@ -75,6 +76,8 @@ impl ModelLoader {
         };
         node.name = gnode.name().map(str::to_string);
 
+        let scene_node = scene.add_node_under(scene_parent, node.transform, ());
+
         if let Some(mesh) = gnode.mesh() {
             let mut new_mesh = Mesh::default();
 
@@ -127,11 +130,12 @@ impl ModelLoader {
 
             let handle = ResHandle::new_ready(None, new_mesh);
             ctx.resource_manager.store_uuid(handle.clone());
-            node.mesh = Some(handle);
+            node.mesh = Some(handle.clone());
+            scene.insert(&scene_node, (handle.clone(), handle.untyped_clone()));
         }
 
         for child in gnode.children() {
-            let cmesh = ModelLoader::process_node(ctx, materials, child);
+            let cmesh = ModelLoader::process_node(ctx, materials, scene, &scene_node, child);
             node.children.push(cmesh);
         }
         
@@ -210,7 +214,21 @@ impl ResourceLoader for ModelLoader {
             debug!("Loaded {} materials in {}s", materials.len(), mat_time.as_secs_f32());
 
             for (_idx, scene) in gltf.scenes().enumerate() {
-                let start_inst = Instant::now();
+                let mut graph = SceneGraph::new();
+                let root_node = graph.root_node();
+
+                for node in scene.nodes() {
+                    let n = ModelLoader::process_node(&mut context, &materials, &mut graph, &root_node, node);
+
+                    if let Some(mesh) = n.mesh {
+                        gltf_out.meshes.push(mesh.clone());
+                    }
+                }
+
+                let graph = ResHandle::new_ready(Some(path.as_str()), graph);
+                gltf_out.scenes.push(graph);
+
+                /* let start_inst = Instant::now();
                 let nodes: Vec<GltfNode> = scene.nodes()
                     .map(|node| ModelLoader::process_node(&mut context, &materials, node))
                     .collect();
@@ -228,7 +246,7 @@ impl ResourceLoader for ModelLoader {
                     nodes,
                 };
                 let scene = ResHandle::new_ready(Some(path.as_str()), scene);
-                gltf_out.scenes.push(scene);
+                gltf_out.scenes.push(scene); */
             }
 
             gltf_out.materials = materials;
@@ -249,6 +267,8 @@ impl ResourceLoader for ModelLoader {
 
 #[cfg(test)]
 mod tests {
+    use lyra_ecs::{query::Entities, relation::ChildOf};
+
     use crate::tests::busy_wait_resource;
 
     use super::*;
@@ -272,14 +292,30 @@ mod tests {
         let scene = &gltf.scenes[0]
             .data_ref().unwrap();
 
-        assert_eq!(scene.nodes.len(), 1);
+        let mut node = None;
-        let mnode = &scene.nodes[0];
+        scene.traverse_down(|_, no, _tran| {
+            node = Some(no.clone());
+        });
 
-        assert!(mnode.mesh.is_some());
+        let world = scene.world();
-        assert_eq!(mnode.transform, Transform::from_xyz(0.0, 0.0, 0.0));
+        let node = node.unwrap();
-        assert_eq!(mnode.children.len(), 0);
         
-        let mesh = mnode.mesh.as_ref().unwrap();
+        let data = world.view_one::<(&ResHandle<Mesh>, &Transform)>(node.entity()).get();
+        debug_assert!(data.is_some(), "The mesh was not loaded"); // transform will always be there
+        let data = data.unwrap();
+
+        // ensure there are no children of the node
+        assert_eq!(
+            world.view::<Entities>()
+                .relates_to::<ChildOf>(node.entity())
+                .into_iter()
+                .count(),
+            0
+        );
+        
+        assert_eq!(*data.1, Transform::from_xyz(0.0, 0.0, 0.0));
+        
+        let mesh = data.0;
         let mesh = mesh.data_ref().unwrap();
         assert!(mesh.position().unwrap().len() > 0);
         assert!(mesh.normals().unwrap().len() > 0);

lyra-resource/src/gltf/mod.rs

@@ -2,7 +2,7 @@ pub mod loader;
 pub use loader::*;
 
 pub mod material;
-use lyra_math::Transform;
+use lyra_scene::SceneGraph;
 use crate::ResourceData;
 pub use material::*;
 
@@ -17,7 +17,7 @@ use crate::ResHandle;
 /// A loaded Gltf file
 #[derive(Clone, Default)]
 pub struct Gltf {
-    pub scenes: Vec<ResHandle<GltfScene>>,
+    pub scenes: Vec<ResHandle<SceneGraph>>,
     pub materials: Vec<ResHandle<Material>>,
     pub meshes: Vec<ResHandle<Mesh>>,
 }
@@ -51,18 +51,3 @@ impl ResourceData for Gltf {
 
     
 }
-
-impl Gltf {
-    /// Collects all Gltf meshes and gets their world Transform.
-    pub fn collect_world_meshes(&self) -> Vec<(ResHandle<Mesh>, Transform)> {
-        let mut v = vec![];
-
-        for scene in self.scenes.iter() {
-            let mut tmp = scene.data_ref()
-                .unwrap().collect_world_meshes();
-            v.append(&mut tmp);
-        }
-        
-        v
-    }
-}

lyra-resource/src/gltf/scene.rs

@@ -1,4 +1,5 @@
 use lyra_math::Transform;
+use lyra_scene::SceneGraph;
 use crate::{optionally_add_to_dep, ResourceData, UntypedResHandle};
 
 use super::Mesh;
@@ -33,8 +34,8 @@ impl ResourceData for GltfNode {
     }
 }
 
-/// A Scene in a Gltf file
+// A Scene in a Gltf file
-#[derive(Clone)]
+/* #[derive(Clone)]
 pub struct GltfScene {
     pub nodes: Vec<GltfNode>,
 }
@@ -92,4 +93,21 @@ impl GltfScene {
         
         v
     }
+} */
+
+impl ResourceData for SceneGraph {
+    fn dependencies(&self) -> Vec<crate::UntypedResHandle> {
+        self.world().view::<&crate::UntypedResHandle>()
+            .iter()
+            .map(|han| han.clone())
+            .collect()
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
 }

lyra-resource/src/resource.rs

@@ -96,7 +96,7 @@ pub struct UntypedResource {
     pub(crate) condvar: Arc<(Mutex<bool>, Condvar)>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Component)]
 pub struct UntypedResHandle{
     pub(crate) res: Arc<RwLock<UntypedResource>>,
     #[allow(dead_code)]
@@ -214,12 +214,12 @@ impl UntypedResHandle {
 /// However, the only times it will be blocking is if another thread is reloading the resource
 /// and has a write lock on the data. This means that most of the time, it is not blocking.
 #[derive(Component)]
-pub struct ResHandle<T: 'static> {
+pub struct ResHandle<T: ResourceData> {
     pub(crate) handle: UntypedResHandle,
     _marker: PhantomData<T>,
 }
 
-impl<T> Clone for ResHandle<T> {
+impl<T: ResourceData> Clone for ResHandle<T> {
     fn clone(&self) -> Self {
         Self {
             handle: self.handle.clone(),
@@ -228,7 +228,7 @@ impl<T> Clone for ResHandle<T> {
     }
 }
 
-impl<T> Deref for ResHandle<T> {
+impl<T: ResourceData> Deref for ResHandle<T> {
     type Target = UntypedResHandle;
 
     fn deref(&self) -> &Self::Target {
@@ -236,7 +236,7 @@ impl<T> Deref for ResHandle<T> {
     }
 }
 
-impl<T> DerefMut for ResHandle<T> {
+impl<T: ResourceData> DerefMut for ResHandle<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.handle
     }
@@ -285,7 +285,7 @@ impl<T: ResourceData> ResHandle<T> {
     }
 }
 
-impl<T: Send + Sync + 'static> ResourceStorage for ResHandle<T> {
+impl<T: ResourceData> ResourceStorage for ResHandle<T> {
     fn as_any(&self) -> &dyn Any {
         self
     }

lyra-resource/src/resource_manager.rs

@@ -173,7 +173,7 @@ impl ResourceManager {
 
     /// Request a resource without downcasting to a `ResHandle<T>`.
     /// Whenever you're ready to downcast, you can do so like this:
-    /// ```compile_fail
+    /// ```nobuild
     /// let arc_any = res_arc.as_arc_any();
     /// let res: Arc<ResHandle<T>> = res.downcast::<ResHandle<T>>().expect("Failure to downcast resource");
     /// ```
@@ -221,7 +221,7 @@ impl ResourceManager {
     /// 
     /// The resource cannot be requested with [`ResourceManager::request`], it can only be 
     /// retrieved with [`ResourceManager::request_uuid`].
-    pub fn store_uuid<T: Send + Sync + 'static>(&self, res: ResHandle<T>) {
+    pub fn store_uuid<T: ResourceData>(&self, res: ResHandle<T>) {
         let mut state = self.state_mut();
         state.resources.insert(res.uuid().to_string(), Arc::new(res));
     }
@@ -230,7 +230,7 @@ impl ResourceManager {
     /// 
     /// Returns `None` if the resource was not found. The resource must of had been
     /// stored with [`ResourceManager::request`] to return `Some`.
-    pub fn request_uuid<T: Send + Sync + 'static>(&self, uuid: &Uuid) -> Option<ResHandle<T>> {
+    pub fn request_uuid<T: ResourceData>(&self, uuid: &Uuid) -> Option<ResHandle<T>> {
         let state = self.state();
         match state.resources.get(&uuid.to_string())
             .or_else(|| state.uuid_resources.get(&uuid))
@@ -291,7 +291,7 @@ impl ResourceManager {
     /// Requests bytes from the manager.
     pub fn request_loaded_bytes<T>(&self, ident: &str) -> Result<Arc<ResHandle<T>>, RequestError>
     where
-        T: Send + Sync + Any + 'static
+        T: ResourceData
     {
         let state = self.state();
         match state.resources.get(&ident.to_string()) {
@@ -366,7 +366,7 @@ impl ResourceManager {
     /// the handle.
     pub fn reload<T>(&self, resource: ResHandle<T>) -> Result<(), RequestError>
     where
-        T: Send + Sync + Any + 'static
+        T: ResourceData
     {
         let state = self.state();
 

lyra-resource/src/world_ext.rs

@@ -1,5 +1,3 @@
-use std::any::Any;
-
 use crossbeam::channel::Receiver;
 use lyra_ecs::World;
 use notify_debouncer_full::DebouncedEvent;
@@ -30,7 +28,7 @@ pub trait WorldAssetExt {
     /// automatically triggered if the resource is being watched.
     fn reload_res<T>(&mut self, resource: ResHandle<T>) -> Result<(), RequestError>
     where
-        T: Send + Sync + Any + 'static;
+        T: ResourceData;
 }
 
 impl WorldAssetExt for World {
@@ -67,7 +65,7 @@ impl WorldAssetExt for World {
 
     fn reload_res<T>(&mut self, resource: ResHandle<T>) -> Result<(), RequestError>
     where
-        T: Send + Sync + Any + 'static
+        T: ResourceData
     {
         let man = self.get_resource_or_default::<ResourceManager>();
         man.reload(resource)

lyra-scene/src/lib.rs

@@ -1,4 +1,4 @@
-use std::{collections::VecDeque, ops::{Deref, DerefMut}};
+use std::collections::VecDeque;
 
 use lyra_ecs::{query::Entities, relation::ChildOf, Bundle, Component, Entity, World};
 
@@ -21,77 +21,31 @@ pub struct SceneNodeFlag;
 #[derive(Component)]
 pub struct SceneNodeRoot;
 
-enum MutCow<'a, T> {
-    Mut(&'a mut T),
-    Owned(T),
-}
-
-impl<'a, T> Deref for MutCow<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            MutCow::Mut(t) => t,
-            MutCow::Owned(t) => t,
-        }
-    }
-}
-
-impl<'a, T> DerefMut for MutCow<'a, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        match self {
-            MutCow::Mut(t) => t,
-            MutCow::Owned(t) => t,
-        }
-    }
-}
-
 /// A SceneGraph is a Graph of nodes that represents the hierarchy of a scene.
 /// 
 /// This SceneGraph is special in the sense that it is literally just an ECS world with methods
 /// implemented for it that make it easier to use for a SceneGraph.
 //#[derive(Default)]
-pub struct SceneGraph<'a>  {
+pub struct SceneGraph  {
-    pub(crate) world: MutCow<'a, World>,
+    pub(crate) world: World,
     root_node: SceneNode,
 }
 
-impl<'a> SceneGraph<'a> {
+impl SceneGraph {
     /// Create a new SceneGraph with its own ECS World.
     pub fn new() -> Self {
-        let mut world = World::new();
+        let world = World::new();
         
-        let e = world.spawn((Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)), SceneNodeRoot));
+        Self::from_world(world)
-        let root = SceneNode::new(None, e);
-
-        Self {
-            world: MutCow::Owned(world),
-            root_node: root
-        }
-    }
-
-    /// Retrieve a SceneGraph from an ECS World.
-    /// 
-    /// Returns `None` if the `root_entity` was not created from a `SceneGraph` that was later
-    /// inserted into another world with [`SceneGraph::into_world`].
-    pub fn from_world(world: &'a mut World, root_entity: Entity) -> Option<Self> {
-        if world.view_one::<(&SceneNodeRoot, &Transform)>(root_entity).get().is_none() {
-            None
-        } else {
-            Some(Self {
-                world: MutCow::Mut(world),
-                root_node: SceneNode::new(None, root_entity),
-            })
-        }
     }
 
     /// Create a new SceneGraph inside an existing ECS World.
-    pub fn new_from_world(world: &'a mut World) -> Self {
+    pub fn from_world(mut world: World) -> Self {
         let root_en = world.spawn((Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)), SceneNodeRoot));
         let root = SceneNode::new(None, root_en);
 
         Self {
-            world: MutCow::Mut(world),
+            world,
             root_node: root,
         }
     }
@@ -162,6 +116,13 @@ impl<'a> SceneGraph<'a> {
         world_add_child_node(&mut self.world, parent, local_transform, bundle)
     }
 
+    /// Insert a component bundle to a SceneNode.
+    /// 
+    /// See [`lyra_ecs::World::insert`].
+    pub fn insert<B: Bundle>(&mut self, node: &SceneNode, bundle: B) {
+        self.world.insert(node.entity(), bundle);
+    }
+
     pub fn add_empty_node_under(&mut self, parent: &SceneNode, local_transform: Transform) -> SceneNode {
         let e = self.world.spawn((SceneNodeFlag, local_transform));
         self.world.add_relation(e, ChildOf, parent.entity());
@@ -174,7 +135,7 @@ impl<'a> SceneGraph<'a> {
     /// The traversal does not include the root scene node.
     pub fn traverse_down<F>(&self, mut callback: F)
     where
-        F: FnMut(&SceneNode, Transform),
+        F: FnMut(&World, &SceneNode, Transform),
     {
         self.traverse_down_from(self.root_node.clone(), &mut callback);
     }
@@ -183,15 +144,16 @@ impl<'a> SceneGraph<'a> {
     /// SceneNode and its world transform.
     fn traverse_down_from<F>(&self, start: SceneNode, callback: &mut F)
     where
-        F: FnMut(&SceneNode, Transform),
+        F: FnMut(&World, &SceneNode, Transform),
     {
-        let v = self.world.view::<(Entities, &Transform)>()
+        let v = self.world
+            .view::<(Entities, &Transform)>()
             .relates_to::<ChildOf>(start.entity());
 
         for ((e, _), _rel) in v.iter() {
             let node = SceneNode::new(Some(start.entity()), e);
             let world_pos = node.world_transform(self);
-            callback(&node, world_pos);
+            callback(&self.world, &node, world_pos);
 
             self.traverse_down_from(node, callback);
         }
@@ -200,6 +162,11 @@ impl<'a> SceneGraph<'a> {
     pub fn root_node(&self) -> SceneNode {
         self.root_node.clone()
     }
+
+    /// Retrieve a borrow of the world that backs the Scene
+    pub fn world(&self) -> &World {
+        &self.world
+    }
 }
 
 /// Add a node under a parent node.
@@ -255,7 +222,7 @@ pub mod tests {
         assert!(b.parent(&scene).unwrap() == a);
 
         let mut idx = 0;
-        scene.traverse_down(|_e, pos| {
+        scene.traverse_down(|_, _, pos| {
             if idx == 0 {
                 assert_eq!(pos, Transform::from_translation(v2s[idx]));
             } else if idx == 1 {

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly"
+channel = "nightly-2023-11-21"
-date = "2023-11-21"
+#date = "2023-11-21"
 targets = [ "x86_64-unknown-linux-gnu" ]

shell.nix

@@ -1,6 +1,10 @@
 let
-  moz_overlay = import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz);
+  rust_overlay = import (builtins.fetchTarball https://github.com/oxalica/rust-overlay/archive/master.tar.gz);
-  nixpkgs = import <nixpkgs> { overlays = [ moz_overlay ]; };
+  nixpkgs = import <nixpkgs> { overlays = [ rust_overlay ]; };
+
+  rust = (nixpkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml).override {
+    extensions = [ "rust-analysis" "rust-src" "miri-preview" ];
+  };
 in
   with nixpkgs;
   stdenv.mkDerivation rec {
@@ -15,12 +19,7 @@ in
       mold
       udev
       lua5_4_compat
-      ((nixpkgs.rustChannelOf { rustToolchain = ./rust-toolchain.toml; }).rust.override {
+      rust
-        extensions = [
-          "rust-src"
-          "rust-analysis"
-        ];
-      })
     ];
     buildInputs = [
       udev alsa-lib libGL gcc