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

ecs: some code cleanup

This commit is contained in:
SeanOMik 2024-03-02 21:34:20 -05:00
parent 7d90b1d38f
commit 6210778e9d
Signed by: SeanOMik
GPG Key ID: FEC9E2FC15235964
19 changed files with 78 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
lyra-ecs/src/archetype.rs
View File

@ -18,9 +18,8 @@ impl Drop for ComponentColumn {
let data = data.as_ptr(); let data = data.as_ptr();
unsafe { unsafe {
// layout of current alloc // TODO: trigger drop on the components
let layout = Layout::from_size_align_unchecked(self.info.layout.size() * self.capacity, let layout = self.info.layout();
self.info.layout.align());
dealloc(data, layout); dealloc(data, layout);
} }
} }
@ -42,7 +41,7 @@ impl ComponentColumn {
} }
pub unsafe fn new(info: ComponentInfo, capacity: usize) -> Self { pub unsafe fn new(info: ComponentInfo, capacity: usize) -> Self {
let data = ComponentColumn::alloc(info.layout, capacity); let data = ComponentColumn::alloc(info.layout(), capacity);
Self { Self {
data: RefCell::new(data), data: RefCell::new(data),
@ -64,7 +63,7 @@ impl ComponentColumn {
let mut data = self.data.borrow_mut(); let mut data = self.data.borrow_mut();
let data = data.deref_mut(); let data = data.deref_mut();
let size = self.info.layout.size(); let size = self.info.layout().size();
let dest = NonNull::new_unchecked(data.as_ptr().add(entity_index * size)); let dest = NonNull::new_unchecked(data.as_ptr().add(entity_index * size));
ptr::copy_nonoverlapping(comp_src.as_ptr(), dest.as_ptr(), size); ptr::copy_nonoverlapping(comp_src.as_ptr(), dest.as_ptr(), size);
@ -87,27 +86,28 @@ impl ComponentColumn {
Ref::map(data, |data| { Ref::map(data, |data| {
let ptr = NonNull::new_unchecked(data.as_ptr() let ptr = NonNull::new_unchecked(data.as_ptr()
.add(entity_index * self.info.layout.size())) .add(entity_index * self.info.layout().size()))
.cast(); .cast();
&*ptr.as_ptr() &*ptr.as_ptr()
}) })
} }
/// Get a component at an entities index. /// Get a mutable borrow to the component at an entities index, ticking the entity.
/// ///
/// # Safety /// # Safety
/// ///
/// This column must have the entity. /// This column must have the entity.
pub unsafe fn get_mut<T>(&mut self, entity_index: usize, tick: &Tick) -> &mut T { pub unsafe fn get_mut<T>(&mut self, entity_index: usize, tick: &Tick) -> RefMut<T> {
self.entity_ticks[entity_index].tick_to(tick); self.entity_ticks[entity_index].tick_to(tick);
let mut data = self.data.borrow_mut(); let data = self.data.borrow_mut();
let data = data.deref_mut();
let p = data.as_ptr() RefMut::map(data, |data| {
.cast::<T>() let ptr = NonNull::new_unchecked(data.as_ptr()
.add(entity_index * self.info.layout.size()); .add(entity_index * self.info.layout().size()))
&mut *p .cast();
&mut *ptr.as_ptr()
})
} }
/// Grow the column to fit `new_capacity` amount of components. /// Grow the column to fit `new_capacity` amount of components.
@ -125,17 +125,19 @@ impl ComponentColumn {
let mut data = self.data.borrow_mut(); let mut data = self.data.borrow_mut();
let mut new_ptr = Self::alloc(self.info.layout, new_capacity); let layout = self.info.layout();
let mut new_ptr = Self::alloc(layout, new_capacity);
if self.len > 0 { if self.len > 0 {
ptr::copy_nonoverlapping(data.as_ptr(), new_ptr.as_ptr(), self.len * self.info.layout.size()); ptr::copy_nonoverlapping(data.as_ptr(), new_ptr.as_ptr(), self.len * layout.size());
} }
// dont attempt to free if we weren't able to store anything anyway // dont attempt to free if we weren't able to store anything anyway
if self.capacity != 0 { if self.capacity != 0 {
// create a layout with the same alignment, but expand the size of the buffer.
let old_layout = Layout::from_size_align_unchecked( let old_layout = Layout::from_size_align_unchecked(
self.info.layout.size().checked_mul(self.capacity).unwrap(), layout.size().checked_mul(self.capacity).unwrap(),
self.info.layout.align() layout.align()
); );
mem::swap(data.deref_mut(), &mut new_ptr); mem::swap(data.deref_mut(), &mut new_ptr);
@ -154,7 +156,7 @@ impl ComponentColumn {
let mut data = self.data.borrow_mut(); let mut data = self.data.borrow_mut();
let data = data.deref_mut(); let data = data.deref_mut();
let size = self.info.layout.size(); let size = self.info.layout().size();
let mut old_comp_ptr = NonNull::new_unchecked(data.as_ptr() let mut old_comp_ptr = NonNull::new_unchecked(data.as_ptr()
.add(entity_index * size)); .add(entity_index * size));
@ -328,13 +330,14 @@ impl Archetype {
/// Returns a boolean indicating whether this archetype can store the TypeIds given /// Returns a boolean indicating whether this archetype can store the TypeIds given
pub fn is_archetype_for(&self, types: &Vec<DynTypeId>) -> bool { pub fn is_archetype_for(&self, types: &Vec<DynTypeId>) -> bool {
if types.len() == self.columns.len() { if types.len() == self.columns.len() {
self.columns.iter().all(|c| types.contains(&c.info.type_id)) self.columns.iter().all(|c| types.contains(&c.info.type_id()))
} else { false } } else { false }
} }
/// Returns a boolean indicating whether this archetype has a column for `comp_type` /// Returns a boolean indicating whether this archetype has a column for `comp_type`
pub fn has_column(&self, comp_type: DynTypeId) -> bool { pub fn has_column<I: Into<DynTypeId>>(&self, comp_type: I) -> bool {
self.columns.iter().any(|c| comp_type == c.info.type_id) let comp_type = comp_type.into();
self.columns.iter().any(|c| comp_type == c.info.type_id())
} }
/// Returns a boolean indicating whether this archetype is empty or not. /// Returns a boolean indicating whether this archetype is empty or not.
@ -368,7 +371,7 @@ impl Archetype {
/// Attempts to find the column storing components of `type_id` /// Attempts to find the column storing components of `type_id`
pub fn get_column<I: Into<DynTypeId>>(&self, type_id: I) -> Option<&ComponentColumn> { pub fn get_column<I: Into<DynTypeId>>(&self, type_id: I) -> Option<&ComponentColumn> {
let type_id = type_id.into(); let type_id = type_id.into();
self.columns.iter().find(|c| c.info.type_id == type_id) self.columns.iter().find(|c| c.info.type_id() == type_id)
} }
/// Returns a mutable borrow to a component column for `type_id`. /// Returns a mutable borrow to a component column for `type_id`.
@ -376,7 +379,7 @@ impl Archetype {
/// Note: This does not modify the tick for the column! /// Note: This does not modify the tick for the column!
pub fn get_column_mut<I: Into<DynTypeId>>(&mut self, type_id: I) -> Option<&mut ComponentColumn> { pub fn get_column_mut<I: Into<DynTypeId>>(&mut self, type_id: I) -> Option<&mut ComponentColumn> {
let type_id = type_id.into(); let type_id = type_id.into();
self.columns.iter_mut().find(|c| c.info.type_id == type_id) self.columns.iter_mut().find(|c| c.info.type_id() == type_id)
} }
/// Reserves a slot in the columns for an entity and returns the index of that reserved spot /// Reserves a slot in the columns for an entity and returns the index of that reserved spot

4
lyra-ecs/src/bundle.rs
View File

@ -143,7 +143,7 @@ impl DynamicBundle {
impl Bundle for DynamicBundle { impl Bundle for DynamicBundle {
fn type_ids(&self) -> Vec<DynTypeId> { fn type_ids(&self) -> Vec<DynTypeId> {
self.bundle.iter().map(|b| b.1.type_id).collect() self.bundle.iter().map(|b| b.1.type_id()).collect()
} }
fn info(&self) -> Vec<ComponentInfo> { fn info(&self) -> Vec<ComponentInfo> {
@ -152,7 +152,7 @@ impl Bundle for DynamicBundle {
fn take(self, mut f: impl FnMut(NonNull<u8>, DynTypeId, usize)) { fn take(self, mut f: impl FnMut(NonNull<u8>, DynTypeId, usize)) {
for (data, info) in self.bundle.iter() { for (data, info) in self.bundle.iter() {
f(*data, info.type_id, info.layout.size()); f(*data, info.type_id(), info.layout().size());
} }
} }

12
lyra-ecs/src/component_info.rs
View File

@ -54,8 +54,8 @@ impl DynTypeId {
/// Some information about a component. /// Some information about a component.
#[derive(Clone, Copy, Debug, PartialEq, Eq)] #[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ComponentInfo { pub struct ComponentInfo {
pub type_id: DynTypeId, type_id: DynTypeId,
pub(crate) layout: Layout, layout: Layout,
} }
impl ComponentInfo { impl ComponentInfo {
@ -77,4 +77,12 @@ impl ComponentInfo {
layout, layout,
} }
} }
pub fn type_id(&self) -> DynTypeId {
self.type_id
}
pub fn layout(&self) -> Layout {
self.layout
}
} }

40
lyra-ecs/src/query/borrow.rs
View File

@ -1,13 +1,12 @@
use std::{marker::PhantomData, ptr::NonNull, cell::{Ref, RefMut}}; use std::{marker::PhantomData, ptr::NonNull, cell::{Ref, RefMut}};
use crate::{world::World, ComponentColumn, DynTypeId, Tick, Component}; use crate::{World, ComponentColumn, DynTypeId, Tick, Component};
use super::{Fetch, Query, AsQuery}; use super::{Fetch, Query, AsQuery};
/// Fetcher for borrowing components from archetypes. /// Fetcher for borrowing components from archetypes.
pub struct FetchBorrow<'a, T> { pub struct FetchBorrow<'a, T> {
col: &'a ComponentColumn, col: &'a ComponentColumn,
size: usize,
_phantom: PhantomData<&'a T> _phantom: PhantomData<&'a T>
} }
@ -22,13 +21,7 @@ where
} }
unsafe fn get_item(&mut self, entity: crate::world::ArchetypeEntityId) -> Self::Item { unsafe fn get_item(&mut self, entity: crate::world::ArchetypeEntityId) -> Self::Item {
let ptr = self.col.borrow_ptr(); self.col.get(entity.0 as _)
Ref::map(ptr, |ptr| {
let ptr = NonNull::new_unchecked(ptr.as_ptr()
.add(entity.0 as usize * self.size))
.cast();
&*ptr.as_ptr()
})
} }
} }
@ -81,17 +74,16 @@ where
} }
fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool { fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool {
archetype.columns.iter().any(|c| c.info.type_id == self.type_id) archetype.has_column(self.type_id)
} }
unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> { unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> {
let _ = tick; let _ = tick;
let col = archetype.columns.iter().find(|c| c.info.type_id == self.type_id) let col = archetype.get_column(self.type_id)
.expect("You ignored 'can_visit_archetype'!"); .expect("You ignored 'can_visit_archetype'!");
FetchBorrow { FetchBorrow {
col, col,
size: col.info.layout.size(),
_phantom: PhantomData, _phantom: PhantomData,
} }
} }
@ -108,7 +100,6 @@ impl<T: Component> AsQuery for &T {
/// A fetcher for mutably borrowing components from archetypes. /// A fetcher for mutably borrowing components from archetypes.
pub struct FetchBorrowMut<'a, T> { pub struct FetchBorrowMut<'a, T> {
col: NonNull<ComponentColumn>, col: NonNull<ComponentColumn>,
size: usize,
tick: Tick, tick: Tick,
_phantom: PhantomData<&'a T> _phantom: PhantomData<&'a T>
} }
@ -125,15 +116,7 @@ where
unsafe fn get_item(&mut self, entity: crate::world::ArchetypeEntityId) -> Self::Item { unsafe fn get_item(&mut self, entity: crate::world::ArchetypeEntityId) -> Self::Item {
let col = unsafe { self.col.as_mut() }; let col = unsafe { self.col.as_mut() };
col.entity_ticks[entity.0 as usize] = self.tick; col.get_mut(entity.0 as _, &self.tick)
let ptr = col.borrow_mut_ptr();
RefMut::map(ptr, |ptr| {
let ptr = NonNull::new_unchecked(ptr.as_ptr()
.add(entity.0 as usize * self.size))
.cast();
&mut *ptr.as_ptr()
})
} }
} }
@ -188,13 +171,12 @@ where
} }
fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool { fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool {
archetype.columns.iter().any(|c| c.info.type_id == self.type_id) archetype.has_column(self.type_id)
} }
unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> { unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> {
let col = archetype.columns.iter().find(|c| c.info.type_id == self.type_id) let col = archetype.get_column(self.type_id)
.expect("You ignored 'can_visit_archetype'!"); .expect("You ignored 'can_visit_archetype'!");
let layout_size = col.info.layout.size();
let col = NonNull::from(col); let col = NonNull::from(col);
// TODO: find a way to get the component column mutable with a borrowed archetype so its tick can be updated. // TODO: find a way to get the component column mutable with a borrowed archetype so its tick can be updated.
@ -202,7 +184,6 @@ where
FetchBorrowMut { FetchBorrowMut {
col, col,
size: layout_size,
tick, tick,
_phantom: PhantomData, _phantom: PhantomData,
} }
@ -219,9 +200,9 @@ impl<T: Component> AsQuery for &mut T {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::{mem::size_of, marker::PhantomData, ptr::NonNull}; use std::{marker::PhantomData, ptr::NonNull};
use crate::{archetype::{Archetype, ArchetypeId}, bundle::Bundle, query::{Fetch, ViewState}, tests::Vec2, world::World, DynTypeId, Entity, EntityId, Tick}; use crate::{archetype::{Archetype, ArchetypeId}, bundle::Bundle, query::{Fetch, ViewState}, tests::Vec2, World, DynTypeId, Entity, EntityId, Tick};
use super::{QueryBorrow, QueryBorrowMut, FetchBorrowMut}; use super::{QueryBorrow, QueryBorrowMut, FetchBorrowMut};
@ -298,12 +279,11 @@ mod tests {
}, (Vec2::rand(),), &Tick::default()); }, (Vec2::rand(),), &Tick::default());
} }
let col = a.columns.iter().find(|c| c.info.type_id == DynTypeId::of::<Vec2>()).unwrap(); let col = a.get_column(DynTypeId::of::<Vec2>()).unwrap();
let mut bmut = FetchBorrowMut::<Vec2> { let mut bmut = FetchBorrowMut::<Vec2> {
col: NonNull::from(col), col: NonNull::from(col),
tick: Tick::default(), tick: Tick::default(),
size: size_of::<Vec2>(),
_phantom: PhantomData, _phantom: PhantomData,
}; };
let item = unsafe { bmut.get_item(crate::ArchetypeEntityId(0)) }; let item = unsafe { bmut.get_item(crate::ArchetypeEntityId(0)) };

10
lyra-ecs/src/query/dynamic/mod.rs
View File

@ -1,6 +1,6 @@
use std::ptr::NonNull; use std::ptr::NonNull;
use crate::{world::World, ComponentColumn, ComponentInfo}; use crate::{World, ComponentColumn, ComponentInfo};
mod view; mod view;
pub use view::*; pub use view::*;
@ -15,7 +15,7 @@ pub struct DynamicType {
impl DynamicType { impl DynamicType {
pub fn is<T: 'static>(&self) -> bool { pub fn is<T: 'static>(&self) -> bool {
self.info.type_id.is::<T>() self.info.type_id().is::<T>()
} }
} }
@ -38,7 +38,7 @@ impl<'a> Fetch<'a> for FetchDynamicType<'a> {
unsafe fn get_item(&mut self, entity: crate::ArchetypeEntityId) -> Self::Item { unsafe fn get_item(&mut self, entity: crate::ArchetypeEntityId) -> Self::Item {
let ptr = self.col.borrow_ptr(); let ptr = self.col.borrow_ptr();
let ptr = NonNull::new_unchecked(ptr.as_ptr() let ptr = NonNull::new_unchecked(ptr.as_ptr()
.add(entity.0 as usize * self.info.layout.size())); .add(entity.0 as usize * self.info.layout().size()));
DynamicType { DynamicType {
info: self.info, info: self.info,
@ -63,11 +63,11 @@ impl QueryDynamicType {
} }
pub fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool { pub fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool {
archetype.has_column(self.info.type_id) archetype.has_column(self.info.type_id())
} }
pub unsafe fn fetch<'a>(&self, _world: &'a World, _arch_id: crate::archetype::ArchetypeId, archetype: &'a crate::archetype::Archetype) -> FetchDynamicType<'a> { pub unsafe fn fetch<'a>(&self, _world: &'a World, _arch_id: crate::archetype::ArchetypeId, archetype: &'a crate::archetype::Archetype) -> FetchDynamicType<'a> {
let col = archetype.columns.iter().find(|c| c.info.type_id == self.info.type_id) let col = archetype.get_column(self.info.type_id())
.expect("You ignored 'can_visit_archetype'!"); .expect("You ignored 'can_visit_archetype'!");
FetchDynamicType { FetchDynamicType {

4
lyra-ecs/src/query/dynamic/view.rs
View File

@ -1,6 +1,6 @@
use std::ops::Range; use std::ops::Range;
use crate::{world::World, Archetype, ArchetypeEntityId, ArchetypeId, query::Fetch}; use crate::{World, Archetype, ArchetypeEntityId, ArchetypeId, query::Fetch};
use super::{QueryDynamicType, FetchDynamicType, DynamicType}; use super::{QueryDynamicType, FetchDynamicType, DynamicType};
@ -104,7 +104,7 @@ impl<'a> Iterator for DynamicViewIter<'a> {
mod tests { mod tests {
use std::{alloc::Layout, ptr::NonNull}; use std::{alloc::Layout, ptr::NonNull};
use crate::{world::World, ComponentInfo, DynTypeId, DynamicBundle, query::dynamic::QueryDynamicType}; use crate::{World, ComponentInfo, DynTypeId, DynamicBundle, query::dynamic::QueryDynamicType};
use super::DynamicView; use super::DynamicView;

2
lyra-ecs/src/query/entities.rs
View File

@ -1,4 +1,4 @@
use crate::{archetype::Archetype, world::World, Entity}; use crate::{archetype::Archetype, World, Entity};
use super::{Fetch, Query, AsQuery}; use super::{Fetch, Query, AsQuery};

2
lyra-ecs/src/query/mod.rs
View File

@ -125,7 +125,7 @@ impl AsQuery for () {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::{world::World, archetype::Archetype, tests::Vec2}; use crate::{World, archetype::Archetype, tests::Vec2};
use super::{ViewState, Entities}; use super::{ViewState, Entities};

4
lyra-ecs/src/query/resource.rs
View File

@ -1,6 +1,6 @@
use std::{marker::PhantomData, cell::{Ref, RefMut}}; use std::{marker::PhantomData, cell::{Ref, RefMut}};
use crate::{world::World, resource::ResourceObject}; use crate::{World, resource::ResourceObject};
use super::{Query, Fetch, AsQuery}; use super::{Query, Fetch, AsQuery};
@ -192,7 +192,7 @@ impl<'a, T: ResourceObject> AsQuery for ResMut<'a, T> {
mod tests { mod tests {
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use crate::{query::{Res, ResMut}, tests::{Vec2, Vec3}, world::World}; use crate::{query::{Res, ResMut}, tests::{Vec2, Vec3}, World};
struct SomeCounter(u32); struct SomeCounter(u32);

6
lyra-ecs/src/query/tick.rs
View File

@ -1,6 +1,6 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use crate::{ComponentColumn, Tick, DynTypeId, world::World}; use crate::{ComponentColumn, Tick, DynTypeId, World};
use super::{Query, Fetch, AsQuery}; use super::{Query, Fetch, AsQuery};
@ -90,11 +90,11 @@ where
} }
fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool { fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool {
archetype.columns.iter().any(|c| c.info.type_id == self.type_id) archetype.has_column(self.type_id)
} }
unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, _tick: crate::Tick) -> Self::Fetch<'a> { unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, _tick: crate::Tick) -> Self::Fetch<'a> {
let col = archetype.columns.iter().find(|c| c.info.type_id == self.type_id) let col = archetype.get_column(self.type_id)
.expect("You ignored 'can_visit_archetype'!"); .expect("You ignored 'can_visit_archetype'!");
FetchTickOf { FetchTickOf {

4
lyra-ecs/src/query/tuple.rs
View File

@ -1,4 +1,4 @@
use crate::world::World; use crate::World;
use super::{Query, Fetch, AsQuery}; use super::{Query, Fetch, AsQuery};
@ -175,7 +175,7 @@ impl_bundle_tuple! { Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10, Q11, Q12, Q13, Q14
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::{world::World, tests::{Vec2, Vec3}}; use crate::{World, tests::{Vec2, Vec3}};
#[test] #[test]
fn tuple_queries() { fn tuple_queries() {

5
lyra-ecs/src/relation/relate_pair.rs
View File

@ -1,4 +1,4 @@
use std::{any::TypeId, cell::Ref, marker::PhantomData}; use std::{any::{Any, TypeId}, cell::Ref, marker::PhantomData};
use crate::{query::{AsQuery, Fetch, Query}, Archetype, ComponentColumn, Entity, World}; use crate::{query::{AsQuery, Fetch, Query}, Archetype, ComponentColumn, Entity, World};
@ -69,8 +69,7 @@ where
unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> { unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> {
let _ = tick; let _ = tick;
let tyid = crate::DynTypeId::Rust(TypeId::of::<RelationOriginComponent<R>>()); let col = archetype.get_column(self.type_id())
let col = archetype.columns.iter().find(|c| c.info.type_id == tyid)
.expect("You ignored 'can_visit_archetype'!"); .expect("You ignored 'can_visit_archetype'!");
FetchRelatePair { FetchRelatePair {

6
lyra-ecs/src/relation/relates_to.rs
View File

@ -70,14 +70,12 @@ where
} }
fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool { fn can_visit_archetype(&self, archetype: &crate::archetype::Archetype) -> bool {
let tyid = crate::DynTypeId::Rust(TypeId::of::<RelationOriginComponent<R>>()); archetype.has_column(TypeId::of::<RelationOriginComponent<R>>())
archetype.has_column(tyid)
} }
unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> { unsafe fn fetch<'a>(&self, _world: &'a World, archetype: &'a crate::archetype::Archetype, tick: crate::Tick) -> Self::Fetch<'a> {
let _ = tick; let _ = tick;
let tyid = crate::DynTypeId::Rust(TypeId::of::<RelationOriginComponent<R>>()); let col = archetype.get_column(TypeId::of::<RelationOriginComponent<R>>())
let col = archetype.columns.iter().find(|c| c.info.type_id == tyid)
.expect("You ignored 'can_visit_archetype'!"); .expect("You ignored 'can_visit_archetype'!");
FetchRelatesTo { FetchRelatesTo {

2
lyra-ecs/src/system/batched.rs
View File

@ -1,4 +1,4 @@
use lyra_ecs::world::World; use lyra_ecs::World;
use crate::Access; use crate::Access;

2
lyra-ecs/src/system/criteria.rs
View File

@ -1,6 +1,6 @@
use std::ptr::NonNull; use std::ptr::NonNull;
use lyra_ecs::world::World; use lyra_ecs::World;
/// An enum that is used to control if the Criteria was met or not. /// An enum that is used to control if the Criteria was met or not.
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]

4
lyra-ecs/src/system/fn_sys.rs
View File

@ -1,7 +1,7 @@
use std::{any::Any, marker::PhantomData, ptr::NonNull}; use std::{any::Any, marker::PhantomData, ptr::NonNull};
use paste::paste; use paste::paste;
use crate::{world::World, Access, ResourceObject, query::{Query, ViewState, ResMut, Res}}; use crate::{World, Access, ResourceObject, query::{Query, ViewState, ResMut, Res}};
use super::{System, IntoSystem}; use super::{System, IntoSystem};
@ -239,7 +239,7 @@ impl<R: ResourceObject> FnArgFetcher for ResMut<'_, R> {
mod tests { mod tests {
use std::ptr::NonNull; use std::ptr::NonNull;
use crate::{tests::{Vec2, Vec3}, world::World, query::{QueryBorrow, ViewState, ResMut}}; use crate::{tests::{Vec2, Vec3}, World, query::{QueryBorrow, ViewState, ResMut}};
use super::{System, IntoSystem}; use super::{System, IntoSystem};
struct SomeCounter(u32); struct SomeCounter(u32);

4
lyra-ecs/src/system/graph.rs
View File

@ -2,7 +2,7 @@ use std::{collections::{HashMap, VecDeque, HashSet}, ptr::NonNull};
use super::System; use super::System;
use crate::{world::World, CommandQueue, Commands}; use crate::{World, CommandQueue, Commands};
#[derive(thiserror::Error, Debug)] #[derive(thiserror::Error, Debug)]
pub enum GraphExecutorError { pub enum GraphExecutorError {
@ -140,7 +140,7 @@ impl GraphExecutor {
mod tests { mod tests {
use std::ptr::NonNull; use std::ptr::NonNull;
use crate::{query::{ResMut, View}, system::IntoSystem, world::World}; use crate::{query::{ResMut, View}, system::IntoSystem, World};
use super::GraphExecutor; use super::GraphExecutor;

2
lyra-ecs/src/system/mod.rs
View File

@ -1,6 +1,6 @@
use std::ptr::NonNull; use std::ptr::NonNull;
use crate::{world::World, Access}; use crate::{World, Access};
mod graph; mod graph;
pub use graph::*; pub use graph::*;

4
lyra-ecs/src/world.rs
View File

@ -143,7 +143,7 @@ impl World {
let record = self.entities.entity_record(entity).unwrap(); let record = self.entities.entity_record(entity).unwrap();
let current_arch = self.archetypes.get(&record.id).unwrap(); let current_arch = self.archetypes.get(&record.id).unwrap();
let mut col_types: Vec<DynTypeId> = current_arch.columns.iter().map(|c| c.info.type_id).collect(); let mut col_types: Vec<DynTypeId> = current_arch.columns.iter().map(|c| c.info.type_id()).collect();
let orig_col = col_types.clone(); let orig_col = col_types.clone();
col_types.extend(bundle.type_ids()); col_types.extend(bundle.type_ids());
@ -158,7 +158,7 @@ impl World {
for (col_type, (col_ptr, col_info)) in orig_col.into_iter().zip(col_ptrs.into_iter()) { for (col_type, (col_ptr, col_info)) in orig_col.into_iter().zip(col_ptrs.into_iter()) {
unsafe { unsafe {
let ptr = NonNull::new_unchecked(col_ptr.as_ptr() let ptr = NonNull::new_unchecked(col_ptr.as_ptr()
.add(res_index.0 as usize * col_info.layout.size())); .add(res_index.0 as usize * col_info.layout().size()));
let col = arch.get_column_mut(col_type).unwrap(); let col = arch.get_column_mut(col_type).unwrap();
col.set_at(res_index.0 as _, ptr, tick); col.set_at(res_index.0 as _, ptr, tick);
} }