summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Cargo.lock66
-rw-r--r--ecs-macros/src/lib.rs44
-rw-r--r--ecs/Cargo.toml4
-rw-r--r--ecs/src/component.rs194
-rw-r--r--ecs/src/component/local.rs6
-rw-r--r--ecs/src/component/storage.rs224
-rw-r--r--ecs/src/component/storage/archetype.rs94
-rw-r--r--ecs/src/component/storage/graph.rs12
-rw-r--r--ecs/src/entity.rs38
-rw-r--r--ecs/src/lib.rs95
-rw-r--r--ecs/src/lock.rs13
-rw-r--r--ecs/src/query.rs29
-rw-r--r--ecs/src/query/flexible.rs34
-rw-r--r--ecs/src/relationship.rs158
-rw-r--r--ecs/src/system.rs228
-rw-r--r--ecs/src/system/stateful.rs7
16 files changed, 727 insertions, 519 deletions
diff --git a/Cargo.lock b/Cargo.lock
index b7df585..625d625 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -42,6 +42,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
name = "bindgen"
version = "0.68.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -56,7 +62,27 @@ dependencies = [
"proc-macro2",
"quote",
"regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags 2.9.0",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash 2.1.1",
"shlex",
"syn",
]
@@ -238,6 +264,7 @@ dependencies = [
"thiserror",
"tracing",
"util-macros",
+ "vizoxide",
]
[[package]]
@@ -336,7 +363,7 @@ dependencies = [
name = "glfw"
version = "0.1.0"
dependencies = [
- "bindgen",
+ "bindgen 0.68.1",
"bitflags 2.9.0",
"libc",
"thiserror",
@@ -350,6 +377,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
[[package]]
+name = "graphviz-sys"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97dbac5b269c7160b78812a9873f548668aa34b62f28f7a64328a6cd94feb47d"
+dependencies = [
+ "bindgen 0.71.1",
+]
+
+[[package]]
name = "half"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -635,6 +671,16 @@ dependencies = [
]
[[package]]
+name = "prettyplease"
+version = "0.2.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5316f57387668042f561aae71480de936257848f9c43ce528e311d89a07cadeb"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
name = "proc-macro2"
version = "1.0.94"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -712,6 +758,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
name = "ryu"
version = "1.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -955,6 +1007,16 @@ dependencies = [
]
[[package]]
+name = "vizoxide"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec190047a5e02a6423f147cf40890be1d37bbc68b9eba441689acbcd255f942"
+dependencies = [
+ "base64",
+ "graphviz-sys",
+]
+
+[[package]]
name = "walkdir"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/ecs-macros/src/lib.rs b/ecs-macros/src/lib.rs
index b58671d..5af10b9 100644
--- a/ecs-macros/src/lib.rs
+++ b/ecs-macros/src/lib.rs
@@ -47,7 +47,7 @@ pub fn component_derive(input: TokenStream) -> TokenStream
{
let item: TypeItem = parse::<Item>(input).unwrap().try_into().unwrap();
- let ComponentAttribute { ref_type, ref_mut_type } = item
+ let ComponentAttribute { handle_type, handle_mut_type } = item
.attribute::<ComponentAttribute>("component")
.unwrap_or_default();
@@ -114,8 +114,10 @@ pub fn component_derive(input: TokenStream) -> TokenStream
Removed as ComponentRemovedEvent,
Kind as ComponentEventKind,
};
- use #ecs_path::system::ComponentRefMut;
- use #ecs_path::system::ComponentRef;
+ use #ecs_path::component::{
+ Handle as ComponentHandle,
+ HandleMut as ComponentHandleMut
+ };
use #ecs_path::uid::{Uid, Kind as UidKind};
use #ecs_path::system::Input as SystemInput;
use #ecs_path::type_name::TypeName;
@@ -129,8 +131,8 @@ pub fn component_derive(input: TokenStream) -> TokenStream
{
type Component = Self;
- type RefMut<'component> = #ref_mut_type;
- type Ref<'component> = #ref_type;
+ type HandleMut<'component> = #handle_mut_type;
+ type Handle<'component> = #handle_type;
fn id() -> Uid
{
@@ -389,32 +391,32 @@ fn find_engine_ecs_crate_path() -> Option<Path>
#[derive(Debug)]
struct ComponentAttribute
{
- ref_type: proc_macro2::TokenStream,
- ref_mut_type: proc_macro2::TokenStream,
+ handle_type: proc_macro2::TokenStream,
+ handle_mut_type: proc_macro2::TokenStream,
}
impl FromAttribute for ComponentAttribute
{
fn from_attribute(attribute: &Attribute) -> Result<Self, syn::Error>
{
- let mut ref_type: Option<Type> = None;
- let mut ref_mut_type: Option<Type> = None;
+ let mut handle_type: Option<Type> = None;
+ let mut handle_mut_type: Option<Type> = None;
attribute.parse_nested_meta(|meta| {
let Some(flag) = meta.path.get_ident() else {
return Err(meta.error("Not a single identifier"));
};
- if flag == "ref_type" {
+ if flag == "handle_type" {
let value = meta.value()?;
- ref_type = Some(value.parse::<Type>()?);
+ handle_type = Some(value.parse::<Type>()?);
return Ok(());
- } else if flag == "ref_mut_type" {
+ } else if flag == "handle_mut_type" {
let value = meta.value()?;
- ref_mut_type = Some(value.parse::<Type>()?);
+ handle_mut_type = Some(value.parse::<Type>()?);
return Ok(());
}
@@ -423,12 +425,12 @@ impl FromAttribute for ComponentAttribute
})?;
Ok(Self {
- ref_type: ref_type
- .map(|ref_type| ref_type.into_token_stream())
- .unwrap_or_else(|| Self::default().ref_type),
- ref_mut_type: ref_mut_type
- .map(|ref_mut_type| ref_mut_type.into_token_stream())
- .unwrap_or_else(|| Self::default().ref_mut_type),
+ handle_type: handle_type
+ .map(|handle_type| handle_type.into_token_stream())
+ .unwrap_or_else(|| Self::default().handle_type),
+ handle_mut_type: handle_mut_type
+ .map(|handle_mut_type| handle_mut_type.into_token_stream())
+ .unwrap_or_else(|| Self::default().handle_mut_type),
})
}
}
@@ -438,8 +440,8 @@ impl Default for ComponentAttribute
fn default() -> Self
{
Self {
- ref_type: quote! { ComponentRef<'component, Self> },
- ref_mut_type: quote! { ComponentRefMut<'component, Self> },
+ handle_type: quote! { ComponentHandle<'component, Self> },
+ handle_mut_type: quote! { ComponentHandleMut<'component, Self> },
}
}
}
diff --git a/ecs/Cargo.toml b/ecs/Cargo.toml
index 4945171..cf35a74 100644
--- a/ecs/Cargo.toml
+++ b/ecs/Cargo.toml
@@ -3,6 +3,9 @@ name = "ecs"
version = "0.1.0"
edition = "2021"
+[features]
+vizoxide = ["dep:vizoxide"]
+
[dependencies]
seq-macro = "0.3.5"
paste = "1.0.14"
@@ -13,6 +16,7 @@ hashbrown = "0.15.2"
parking_lot = "0.12.3"
ecs-macros = { path = "../ecs-macros" }
util-macros = { path = "../util-macros" }
+vizoxide = { version = "1.0.5", optional = true }
[dev-dependencies.criterion]
version = "0.5.1"
diff --git a/ecs/src/component.rs b/ecs/src/component.rs
index 265eb9e..46fbf8a 100644
--- a/ecs/src/component.rs
+++ b/ecs/src/component.rs
@@ -1,5 +1,6 @@
use std::any::{type_name, Any};
use std::fmt::Debug;
+use std::ops::{Deref, DerefMut};
use seq_macro::seq;
@@ -8,7 +9,14 @@ use crate::event::component::{
Kind as ComponentEventKind,
Removed as ComponentRemovedEvent,
};
-use crate::lock::{Error as LockError, Lock, ReadGuard, WriteGuard};
+use crate::lock::{
+ Error as LockError,
+ Lock,
+ MappedReadGuard,
+ MappedWriteGuard,
+ ReadGuard,
+ WriteGuard,
+};
use crate::system::Input as SystemInput;
use crate::type_name::TypeName;
use crate::uid::Uid;
@@ -26,11 +34,11 @@ pub trait Component: SystemInput + Any + TypeName
where
Self: Sized;
- type RefMut<'component>: FromOptionalMut<'component> + FromLockedOptional<'component>
+ type HandleMut<'component>: FromLockedOptional<'component>
where
Self: Sized;
- type Ref<'component>: FromOptional<'component> + FromLockedOptional<'component>
+ type Handle<'component>: FromLockedOptional<'component>
where
Self: Sized;
@@ -101,12 +109,12 @@ impl TypeName for Box<dyn Component>
impl<ComponentT> Component for Option<ComponentT>
where
ComponentT: Component,
- for<'a> Option<ComponentT::Ref<'a>>: FromOptional<'a> + FromLockedOptional<'a>,
- for<'a> Option<ComponentT::RefMut<'a>>: FromOptionalMut<'a> + FromLockedOptional<'a>,
+ for<'a> Option<ComponentT::Handle<'a>>: FromLockedOptional<'a>,
+ for<'a> Option<ComponentT::HandleMut<'a>>: FromLockedOptional<'a>,
{
type Component = ComponentT;
- type Ref<'component> = Option<ComponentT::Ref<'component>>;
- type RefMut<'component> = Option<ComponentT::RefMut<'component>>;
+ type Handle<'component> = Option<ComponentT::Handle<'component>>;
+ type HandleMut<'component> = Option<ComponentT::HandleMut<'component>>;
fn id() -> Uid
{
@@ -182,7 +190,7 @@ where
ComponentT: Component,
{
type Component = ComponentT;
- type Handle<'component> = ComponentT::Ref<'component>;
+ type Handle<'component> = ComponentT::Handle<'component>;
}
impl<ComponentT> Ref for &mut ComponentT
@@ -190,7 +198,7 @@ where
ComponentT: Component,
{
type Component = ComponentT;
- type Handle<'component> = ComponentT::RefMut<'component>;
+ type Handle<'component> = ComponentT::HandleMut<'component>;
}
/// [`Component`] metadata.
@@ -220,22 +228,6 @@ impl Metadata
}
}
-pub trait FromOptionalMut<'comp>
-{
- fn from_optional_mut_component(
- optional_component: Option<WriteGuard<'comp, Box<dyn Component>>>,
- world: &'comp World,
- ) -> Self;
-}
-
-pub trait FromOptional<'comp>
-{
- fn from_optional_component(
- optional_component: Option<ReadGuard<'comp, Box<dyn Component>>>,
- world: &'comp World,
- ) -> Self;
-}
-
pub trait FromLockedOptional<'comp>: Sized
{
/// Converts a reference to a optional locked boxed component to a instance of `Self`.
@@ -248,18 +240,158 @@ pub trait FromLockedOptional<'comp>: Sized
) -> Result<Self, LockError>;
}
+#[derive(Debug)]
+pub struct Handle<'a, ComponentT: Component>
+{
+ inner: MappedReadGuard<'a, ComponentT>,
+}
+
+impl<'a, ComponentT: Component> Handle<'a, ComponentT>
+{
+ pub(crate) fn new(inner: ReadGuard<'a, Box<dyn Component>>) -> Self
+ {
+ Self {
+ inner: inner.map(|component| {
+ component.downcast_ref::<ComponentT>().unwrap_or_else(|| {
+ panic!(
+ "Cannot downcast component {} to type {}",
+ component.type_name(),
+ type_name::<ComponentT>()
+ );
+ })
+ }),
+ }
+ }
+}
+
+impl<'component, ComponentT: Component> FromLockedOptional<'component>
+ for Handle<'component, ComponentT>
+{
+ fn from_locked_optional_component(
+ optional_component: Option<&'component crate::lock::Lock<Box<dyn Component>>>,
+ _world: &'component World,
+ ) -> Result<Self, LockError>
+ {
+ let component = optional_component.unwrap_or_else(|| {
+ panic!(
+ "Component {} was not found in entity",
+ type_name::<ComponentT>()
+ );
+ });
+
+ Ok(Self::new(component.read_nonblock()?))
+ }
+}
+
+impl<'comp, ComponentT> FromLockedOptional<'comp> for Option<Handle<'comp, ComponentT>>
+where
+ ComponentT: Component,
+{
+ fn from_locked_optional_component(
+ optional_component: Option<&'comp Lock<Box<dyn Component>>>,
+ _world: &'comp World,
+ ) -> Result<Self, LockError>
+ {
+ optional_component
+ .map(|lock| Ok(Handle::new(lock.read_nonblock()?)))
+ .transpose()
+ }
+}
+
+impl<ComponentT: Component> Deref for Handle<'_, ComponentT>
+{
+ type Target = ComponentT;
+
+ fn deref(&self) -> &Self::Target
+ {
+ &self.inner
+ }
+}
+
+#[derive(Debug)]
+pub struct HandleMut<'a, ComponentT: Component>
+{
+ inner: MappedWriteGuard<'a, ComponentT>,
+}
+
+impl<'a, ComponentT: Component> HandleMut<'a, ComponentT>
+{
+ pub(crate) fn new(inner: WriteGuard<'a, Box<dyn Component>>) -> Self
+ {
+ Self {
+ inner: inner.map(|component| {
+ let component_type_name = component.type_name();
+
+ component.downcast_mut::<ComponentT>().unwrap_or_else(|| {
+ panic!(
+ "Cannot downcast component {component_type_name} to type {}",
+ type_name::<ComponentT>()
+ );
+ })
+ }),
+ }
+ }
+}
+
+impl<'component, ComponentT: Component> FromLockedOptional<'component>
+ for HandleMut<'component, ComponentT>
+{
+ fn from_locked_optional_component(
+ optional_component: Option<&'component Lock<Box<dyn Component>>>,
+ _world: &'component World,
+ ) -> Result<Self, LockError>
+ {
+ let component = optional_component.unwrap_or_else(|| {
+ panic!(
+ "Component {} was not found in entity",
+ type_name::<ComponentT>()
+ );
+ });
+
+ Ok(Self::new(component.write_nonblock()?))
+ }
+}
+
+impl<'comp, ComponentT> FromLockedOptional<'comp> for Option<HandleMut<'comp, ComponentT>>
+where
+ ComponentT: Component,
+{
+ fn from_locked_optional_component(
+ optional_component: Option<&'comp Lock<Box<dyn Component>>>,
+ _world: &'comp World,
+ ) -> Result<Self, LockError>
+ {
+ optional_component
+ .map(|lock| Ok(HandleMut::new(lock.write_nonblock()?)))
+ .transpose()
+ }
+}
+
+impl<ComponentT: Component> Deref for HandleMut<'_, ComponentT>
+{
+ type Target = ComponentT;
+
+ fn deref(&self) -> &Self::Target
+ {
+ &self.inner
+ }
+}
+
+impl<ComponentT: Component> DerefMut for HandleMut<'_, ComponentT>
+{
+ fn deref_mut(&mut self) -> &mut Self::Target
+ {
+ &mut self.inner
+ }
+}
+
macro_rules! inner {
($c: tt) => {
seq!(I in 0..=$c {
impl<#(IntoComp~I,)*> Sequence for (#(IntoComp~I,)*)
where
#(
- for<'comp> IntoComp~I: Into<
- Component: Component<
- RefMut<'comp>: FromOptionalMut<'comp>,
- Ref<'comp>: FromOptional<'comp>
- >
- >,
+ for<'comp> IntoComp~I: Into<Component: Component>,
)*
{
const COUNT: usize = $c + 1;
diff --git a/ecs/src/component/local.rs b/ecs/src/component/local.rs
index d4e414e..0f6f641 100644
--- a/ecs/src/component/local.rs
+++ b/ecs/src/component/local.rs
@@ -1,14 +1,14 @@
use std::ops::{Deref, DerefMut};
-use crate::component::Component;
-use crate::system::{ComponentRefMut, Param as SystemParam, System};
+use crate::component::{Component, HandleMut as ComponentHandleMut};
+use crate::system::{Param as SystemParam, System};
use crate::World;
/// Holds a component which is local to a single system.
#[derive(Debug)]
pub struct Local<'world, LocalComponent: Component>
{
- local_component: ComponentRefMut<'world, LocalComponent>,
+ local_component: ComponentHandleMut<'world, LocalComponent>,
}
impl<'world, LocalComponent> SystemParam<'world> for Local<'world, LocalComponent>
diff --git a/ecs/src/component/storage.rs b/ecs/src/component/storage.rs
index 4b2b6d8..40909fb 100644
--- a/ecs/src/component/storage.rs
+++ b/ecs/src/component/storage.rs
@@ -7,7 +7,8 @@ use hashbrown::HashMap;
use crate::component::storage::archetype::{
Archetype,
- ArchetypeEntity,
+ Entity as ArchetypeEntity,
+ EntityComponent as ArchetypeEntityComponent,
Id as ArchetypeId,
};
use crate::component::storage::graph::{
@@ -20,7 +21,6 @@ use crate::component::Component;
use crate::type_name::TypeName;
use crate::uid::{Kind as UidKind, Uid};
use crate::util::{BorrowedOrOwned, Either, StreamingIterator, VecExt};
-use crate::EntityComponent;
pub mod archetype;
@@ -123,17 +123,14 @@ impl Storage
archetype_node
.archetype_mut()
- .push_entity(ArchetypeEntity { uid, components: vec![] });
+ .push_entity(ArchetypeEntity::new(uid, []));
self.entity_archetype_lookup.insert(uid, empty_archetype_id);
Ok(())
}
- pub fn remove_entity(
- &mut self,
- entity_uid: Uid,
- ) -> Result<Vec<EntityComponent>, Error>
+ pub fn remove_entity(&mut self, entity_uid: Uid) -> Result<ArchetypeEntity, Error>
{
let Some(archetype_id) = self.entity_archetype_lookup.get(&entity_uid) else {
return Err(Error::EntityDoesNotExist(entity_uid));
@@ -151,7 +148,7 @@ impl Storage
self.entity_archetype_lookup.remove(&entity_uid);
- Ok(entity.components)
+ Ok(entity)
}
pub fn get_entity_archetype(&self, entity_uid: Uid) -> Option<&Archetype>
@@ -195,10 +192,24 @@ impl Storage
});
}
- let add_edge_archetype_id = archetype_node
+ let add_edge_archetype_id = match archetype_node
.get_or_insert_edges(component_id, ArchetypeEdges::default)
.add
- .unwrap_or_else(|| {
+ {
+ Some(add_edge_id) => {
+ if !self.graph.contains_archetype(add_edge_id) {
+ let (_, add_edge_comp_ids) = self
+ .graph
+ .get_node_by_id(archetype_id)
+ .expect("Archetype should exist")
+ .make_add_edge(component_id);
+
+ self.graph.create_node(add_edge_id, &add_edge_comp_ids);
+ }
+
+ add_edge_id
+ }
+ None => {
let archetype_node = self
.graph
.get_node_by_id_mut(archetype_id)
@@ -217,7 +228,8 @@ impl Storage
}
add_edge_id
- });
+ }
+ };
{
let add_edge_archetype_node = self
@@ -247,13 +259,10 @@ impl Storage
.expect("Add edge archetype should exist")
.archetype_mut();
- let component_index = add_edge_archetype
- .get_index_for_component(component_id)
- .expect("Archetype should have index for component");
-
- entity.components.insert(
- component_index,
- EntityComponent::new(component_id, component),
+ entity.insert_component(
+ component_id,
+ ArchetypeEntityComponent::new(component),
+ add_edge_archetype,
);
add_edge_archetype.push_entity(entity);
@@ -326,14 +335,7 @@ impl Storage
.remove_entity(entity_uid)
.expect("Entity should exist in archetype");
- let (comp_to_remove_index, _) = entity
- .components
- .iter()
- .enumerate()
- .find(|(_, comp)| comp.id == component_id)
- .expect("Entity should contain component");
-
- entity.components.remove(comp_to_remove_index);
+ entity.remove_component(component_id, archetype_node.archetype());
self.graph
.get_node_by_id_mut(remove_edge_id)
@@ -421,6 +423,176 @@ impl TypeName for Storage
}
}
+#[cfg(feature = "vizoxide")]
+impl Storage
+{
+ pub fn create_vizoxide_archetype_graph(
+ &self,
+ graph_name: impl AsRef<str>,
+ params: VizoxideArchetypeGraphParams,
+ ) -> Result<vizoxide::Graph, vizoxide::GraphvizError>
+ {
+ let viz_graph = vizoxide::Graph::builder(graph_name.as_ref())
+ .strict(true)
+ .directed(true)
+ .build()?;
+
+ let mut viz_node_lookup = HashMap::new();
+
+ for node in self.graph.iter_nodes() {
+ let id = node.archetype().id();
+
+ if !viz_node_lookup.contains_key(&id) {
+ let node = self.graph.get_node_by_id(id).unwrap();
+
+ let viz_node = (params.create_node_cb)(
+ node.archetype(),
+ ArchetypeMetadata { is_imaginary: false },
+ viz_graph.create_node(&(params.create_node_name)(
+ node.archetype(),
+ ArchetypeMetadata { is_imaginary: false },
+ )),
+ )
+ .build()?;
+
+ viz_node_lookup.insert(id, viz_node);
+ }
+
+ for (edge_comp_id, edges) in node.iter_edges() {
+ if let Some(add_edge) = edges.add {
+ if !viz_node_lookup.contains_key(&add_edge) {
+ let viz_node = self.create_vizoxide_archetype_graph_edge_node(
+ &viz_graph,
+ node,
+ add_edge,
+ *edge_comp_id,
+ &params,
+ )?;
+
+ viz_node_lookup.insert(add_edge, viz_node);
+ }
+
+ (params.create_edge_cb)(
+ node.archetype(),
+ *edge_comp_id,
+ VizoxideArchetypeGraphEdgeKind::Add,
+ viz_graph.create_edge(
+ viz_node_lookup.get(&id).unwrap(),
+ viz_node_lookup.get(&add_edge).unwrap(),
+ Some(&format!("Add {}", edge_comp_id.id())),
+ ),
+ )
+ .build()?;
+ }
+
+ if let Some(remove_edge) = edges.remove {
+ if !viz_node_lookup.contains_key(&remove_edge) {
+ let viz_node = self.create_vizoxide_archetype_graph_edge_node(
+ &viz_graph,
+ node,
+ remove_edge,
+ *edge_comp_id,
+ &params,
+ )?;
+
+ viz_node_lookup.insert(remove_edge, viz_node);
+ }
+
+ (params.create_edge_cb)(
+ node.archetype(),
+ *edge_comp_id,
+ VizoxideArchetypeGraphEdgeKind::Remove,
+ viz_graph.create_edge(
+ viz_node_lookup.get(&id).unwrap(),
+ viz_node_lookup.get(&remove_edge).unwrap(),
+ Some(&format!("Remove {}", edge_comp_id.id())),
+ ),
+ )
+ .build()?;
+ }
+ }
+ }
+
+ drop(viz_node_lookup);
+
+ Ok(viz_graph)
+ }
+
+ fn create_vizoxide_archetype_graph_edge_node<'vizoxide_graph>(
+ &self,
+ viz_graph: &'vizoxide_graph vizoxide::Graph,
+ node: &graph::ArchetypeNode,
+ edge_id: ArchetypeId,
+ edge_comp_id: Uid,
+ params: &VizoxideArchetypeGraphParams,
+ ) -> Result<vizoxide::Node<'vizoxide_graph>, vizoxide::GraphvizError>
+ {
+ match self.graph.get_node_by_id(edge_id) {
+ Some(edge_node) => (params.create_node_cb)(
+ edge_node.archetype(),
+ ArchetypeMetadata { is_imaginary: false },
+ viz_graph.create_node(&(params.create_node_name)(
+ edge_node.archetype(),
+ ArchetypeMetadata { is_imaginary: false },
+ )),
+ )
+ .build(),
+ None => {
+ let mut comp_ids =
+ node.archetype().component_ids_sorted().collect::<Vec<_>>();
+
+ let insert_index = comp_ids.partition_point(|cid| *cid <= edge_comp_id);
+
+ comp_ids.insert(insert_index, edge_comp_id);
+
+ let imaginary_edge_archetype = Archetype::new(edge_id, comp_ids);
+
+ (params.create_node_cb)(
+ &imaginary_edge_archetype,
+ ArchetypeMetadata { is_imaginary: true },
+ viz_graph.create_node(&(params.create_node_name)(
+ &imaginary_edge_archetype,
+ ArchetypeMetadata { is_imaginary: true },
+ )),
+ )
+ .build()
+ }
+ }
+ }
+}
+
+#[cfg(feature = "vizoxide")]
+pub struct VizoxideArchetypeGraphParams
+{
+ pub create_node_name: fn(&Archetype, ArchetypeMetadata) -> std::borrow::Cow<'_, str>,
+ pub create_node_cb: for<'storage, 'graph> fn(
+ &'storage Archetype,
+ ArchetypeMetadata,
+ vizoxide::NodeBuilder<'graph>,
+ ) -> vizoxide::NodeBuilder<'graph>,
+ pub create_edge_cb: for<'storage, 'graph> fn(
+ &'storage Archetype,
+ Uid,
+ VizoxideArchetypeGraphEdgeKind,
+ vizoxide::EdgeBuilder<'graph>,
+ ) -> vizoxide::EdgeBuilder<'graph>,
+}
+
+#[cfg(feature = "vizoxide")]
+#[derive(Debug, Clone)]
+pub struct ArchetypeMetadata
+{
+ pub is_imaginary: bool,
+}
+
+#[cfg(feature = "vizoxide")]
+#[derive(Debug, Clone, Copy)]
+pub enum VizoxideArchetypeGraphEdgeKind
+{
+ Add,
+ Remove,
+}
+
#[derive(Debug)]
pub struct ArchetypeRefIter<'storage, 'search_terms>
{
diff --git a/ecs/src/component/storage/archetype.rs b/ecs/src/component/storage/archetype.rs
index f6f8132..5306cf9 100644
--- a/ecs/src/component/storage/archetype.rs
+++ b/ecs/src/component/storage/archetype.rs
@@ -3,16 +3,16 @@ use std::slice::Iter as SliceIter;
use hashbrown::HashMap;
-use crate::component::Metadata as ComponentMetadata;
+use crate::component::{Component, Metadata as ComponentMetadata};
+use crate::lock::Lock;
use crate::uid::{Kind as UidKind, Uid};
use crate::util::HashMapExt;
-use crate::EntityComponent;
#[derive(Debug)]
pub struct Archetype
{
id: Id,
- entities: Vec<ArchetypeEntity>,
+ entities: Vec<Entity>,
entity_index_lookup: HashMap<Uid, usize>,
component_index_lookup: HashMap<Uid, usize>,
component_ids: Vec<Uid>,
@@ -53,7 +53,7 @@ impl Archetype
.keys_is_subset(&other.component_index_lookup)
}
- pub fn get_entity_by_id(&self, entity_uid: Uid) -> Option<&ArchetypeEntity>
+ pub fn get_entity_by_id(&self, entity_uid: Uid) -> Option<&Entity>
{
let index = *self.entity_index_lookup.get(&entity_uid)?;
@@ -64,7 +64,7 @@ impl Archetype
}))
}
- pub fn push_entity(&mut self, entity: ArchetypeEntity)
+ pub fn push_entity(&mut self, entity: Entity)
{
self.entity_index_lookup
.insert(entity.uid, self.entities.len());
@@ -72,7 +72,7 @@ impl Archetype
self.entities.push(entity);
}
- pub fn remove_entity(&mut self, entity_uid: Uid) -> Option<ArchetypeEntity>
+ pub fn remove_entity(&mut self, entity_uid: Uid) -> Option<Entity>
{
//debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
@@ -142,12 +142,12 @@ impl Archetype
#[derive(Debug)]
pub struct EntityIter<'archetype>
{
- iter: SliceIter<'archetype, ArchetypeEntity>,
+ iter: SliceIter<'archetype, Entity>,
}
impl<'archetype> Iterator for EntityIter<'archetype>
{
- type Item = &'archetype ArchetypeEntity;
+ type Item = &'archetype Entity;
fn next(&mut self) -> Option<Self::Item>
{
@@ -156,10 +156,82 @@ impl<'archetype> Iterator for EntityIter<'archetype>
}
#[derive(Debug)]
-pub struct ArchetypeEntity
+pub struct Entity
{
- pub uid: Uid,
- pub components: Vec<EntityComponent>,
+ uid: Uid,
+ components: Vec<EntityComponent>,
+}
+
+impl Entity
+{
+ pub fn new(uid: Uid, components: impl IntoIterator<Item = EntityComponent>) -> Self
+ {
+ Self {
+ uid,
+ components: components.into_iter().collect(),
+ }
+ }
+
+ pub fn uid(&self) -> Uid
+ {
+ self.uid
+ }
+
+ pub fn components(&self) -> &[EntityComponent]
+ {
+ &self.components
+ }
+
+ pub fn remove_component(&mut self, component_id: Uid, archetype: &Archetype)
+ {
+ let index = archetype
+ .get_index_for_component(component_id)
+ .expect("Archetype should contain component");
+
+ self.components.remove(index);
+ }
+
+ pub fn insert_component(
+ &mut self,
+ component_id: Uid,
+ component: EntityComponent,
+ archetype: &Archetype,
+ )
+ {
+ let index = archetype
+ .get_index_for_component(component_id)
+ .expect("Archetype should contain component");
+
+ self.components.insert(index, component);
+ }
+}
+
+#[derive(Debug)]
+pub struct EntityComponent
+{
+ name: &'static str,
+ component: Lock<Box<dyn Component>>,
+}
+
+impl EntityComponent
+{
+ pub fn new(component: Box<dyn Component>) -> Self
+ {
+ Self {
+ name: component.type_name(),
+ component: Lock::new(component),
+ }
+ }
+
+ pub fn name(&self) -> &str
+ {
+ self.name
+ }
+
+ pub fn component(&self) -> &Lock<Box<dyn Component>>
+ {
+ &self.component
+ }
}
/// Archetype ID.
diff --git a/ecs/src/component/storage/graph.rs b/ecs/src/component/storage/graph.rs
index a221877..11160e7 100644
--- a/ecs/src/component/storage/graph.rs
+++ b/ecs/src/component/storage/graph.rs
@@ -71,6 +71,12 @@ impl Graph
}))
}
+ #[cfg(feature = "vizoxide")]
+ pub fn iter_nodes(&self) -> impl Iterator<Item = &ArchetypeNode>
+ {
+ self.nodes.iter()
+ }
+
pub fn dfs_archetype_add_edges(
&self,
archetype_id: ArchetypeId,
@@ -233,6 +239,12 @@ impl ArchetypeNode
self.edges.entry(component_id).or_insert_with(insert_fn)
}
+ #[cfg(feature = "vizoxide")]
+ pub fn iter_edges(&self) -> impl Iterator<Item = (&Uid, &ArchetypeEdges)>
+ {
+ self.edges.iter()
+ }
+
pub fn get_edges_mut(&mut self, component_id: Uid) -> Option<&mut ArchetypeEdges>
{
debug_assert_eq!(component_id.kind(), UidKind::Component);
diff --git a/ecs/src/entity.rs b/ecs/src/entity.rs
index 3de9cd5..a43f9ce 100644
--- a/ecs/src/entity.rs
+++ b/ecs/src/entity.rs
@@ -1,6 +1,42 @@
use linkme::distributed_slice;
-use crate::World;
+use crate::component::storage::archetype::{Archetype, Entity as ArchetypeEntity};
+use crate::uid::Uid;
+use crate::{EntityComponentRef, World};
+
+/// A handle to a entity.
+pub struct Handle<'a>
+{
+ archetype: &'a Archetype,
+ entity: &'a ArchetypeEntity,
+}
+
+impl<'a> Handle<'a>
+{
+ /// Returns the [`Uid`] of this entity.
+ #[inline]
+ #[must_use]
+ pub fn uid(&self) -> Uid
+ {
+ self.entity.uid()
+ }
+
+ #[inline]
+ #[must_use]
+ pub fn get_component(&self, component_uid: Uid) -> Option<EntityComponentRef<'a>>
+ {
+ let index = self.archetype.get_index_for_component(component_uid)?;
+
+ Some(EntityComponentRef::new(
+ self.entity.components().get(index).unwrap(),
+ ))
+ }
+
+ pub(crate) fn new(archetype: &'a Archetype, entity: &'a ArchetypeEntity) -> Self
+ {
+ Self { archetype, entity }
+ }
+}
#[allow(clippy::module_name_repetitions)]
#[macro_export]
diff --git a/ecs/src/lib.rs b/ecs/src/lib.rs
index 9b787a2..3caaa6b 100644
--- a/ecs/src/lib.rs
+++ b/ecs/src/lib.rs
@@ -10,6 +10,7 @@ use std::sync::Arc;
use hashbrown::HashMap;
use crate::actions::Action;
+use crate::component::storage::archetype::EntityComponent as ArchetypeEntityComponent;
use crate::component::storage::Storage as ComponentStorage;
use crate::component::{Component, Sequence as ComponentSequence};
use crate::entity::CREATE_STATIC_ENTITIES;
@@ -20,7 +21,7 @@ use crate::phase::{Phase, START as START_PHASE};
use crate::query::flexible::Query as FlexibleQuery;
use crate::query::term::Without;
use crate::query::{
- ComponentIter,
+ Iter as QueryIter,
TermWithFieldTuple as QueryTermWithFieldTuple,
TermWithoutFieldTuple as QueryTermWithoutFieldTuple,
Terms as QueryTerms,
@@ -246,6 +247,59 @@ impl World
while let StepResult::Continue = self.step() {}
}
+ #[cfg(feature = "vizoxide")]
+ pub fn create_vizoxide_archetype_graph(
+ &self,
+ name: impl AsRef<str>,
+ ) -> Result<vizoxide::Graph, vizoxide::GraphvizError>
+ {
+ use std::borrow::Cow;
+
+ use crate::component::storage::{
+ VizoxideArchetypeGraphEdgeKind,
+ VizoxideArchetypeGraphParams,
+ };
+
+ let component_storage_lock = self
+ .data
+ .component_storage
+ .read_nonblock()
+ .expect("Failed to acquire read-only component storage lock");
+
+ component_storage_lock.create_vizoxide_archetype_graph(
+ name,
+ VizoxideArchetypeGraphParams {
+ create_node_name: |archetype, _| {
+ Cow::Owned(format!(
+ "[{}]",
+ archetype
+ .component_ids_sorted()
+ .into_iter()
+ .map(|comp_id| comp_id.id().to_string())
+ .collect::<Vec<_>>()
+ .join(", ")
+ ))
+ },
+ create_node_cb: |_archetype, archetype_metadata, node_builder| {
+ if archetype_metadata.is_imaginary {
+ return node_builder.attribute("shape", "ellipse");
+ }
+
+ node_builder.attribute("shape", "box")
+ },
+ create_edge_cb: |_, _, edge_kind, edge_builder| {
+ edge_builder.attribute(
+ "color",
+ match edge_kind {
+ VizoxideArchetypeGraphEdgeKind::Add => "green",
+ VizoxideArchetypeGraphEdgeKind::Remove => "red",
+ },
+ )
+ },
+ },
+ )
+ }
+
fn query_and_run_systems(&self, phase_euid: Uid)
{
let system_comps_query =
@@ -414,7 +468,7 @@ impl World
{
let mut component_storage_lock = self.lock_component_storage_rw();
- let components = match component_storage_lock.remove_entity(entity_uid) {
+ let removed_entity = match component_storage_lock.remove_entity(entity_uid) {
Ok(components) => components,
Err(err) => {
tracing::error!("Failed to despawn entity: {err}");
@@ -422,16 +476,17 @@ impl World
}
};
- let component_removed_event_uids = components
+ let component_removed_event_uids = removed_entity
+ .components()
.iter()
.map(|component| {
component
- .component
+ .component()
.read_nonblock()
.unwrap_or_else(|_| {
panic!(
"Failed to acquire read-only {} component lock",
- component.name
+ component.name()
)
})
.get_event_uid(ComponentEventKind::Removed)
@@ -481,11 +536,6 @@ impl World
fn emit_event_by_id(&self, event_id: Uid)
{
- //let query = self.flexible_query([
- // ComponentMetadata::of::<SystemComponent>(),
- // ComponentMetadata { id: event_id, is_optional: false },
- //]);
-
let mut query_required_ids = [SystemComponent::id(), event_id];
let query = self.flexible_query(
@@ -494,8 +544,7 @@ impl World
.build(),
);
- for (system,) in ComponentIter::<(&SystemComponent,), _>::new(self, query.iter())
- {
+ for (system,) in QueryIter::<(&SystemComponent,), _>::new(self, query.iter()) {
unsafe {
system.system.run(self);
}
@@ -550,23 +599,21 @@ pub struct WorldData
}
#[derive(Debug)]
-#[non_exhaustive]
-pub struct EntityComponent
+pub struct EntityComponentRef<'a>
{
- pub id: Uid,
- pub name: &'static str,
- pub component: Lock<Box<dyn Component>>,
+ comp: &'a ArchetypeEntityComponent,
}
-impl EntityComponent
+impl<'a> EntityComponentRef<'a>
{
- pub fn new(id: Uid, component: Box<dyn Component>) -> Self
+ pub fn component(&self) -> &'a Lock<Box<dyn Component>>
{
- Self {
- id,
- name: component.type_name(),
- component: Lock::new(component),
- }
+ self.comp.component()
+ }
+
+ fn new(comp: &'a ArchetypeEntityComponent) -> Self
+ {
+ Self { comp }
}
}
diff --git a/ecs/src/lock.rs b/ecs/src/lock.rs
index 1ce13fc..d6ed40e 100644
--- a/ecs/src/lock.rs
+++ b/ecs/src/lock.rs
@@ -1,4 +1,4 @@
-use std::mem::{forget, transmute};
+use std::mem::forget;
use std::ops::{Deref, DerefMut};
use parking_lot::{
@@ -101,17 +101,6 @@ where
inner: RwLockReadGuard::map(inner, func),
}
}
-
- /// Converts the `ReadGuard` to a `ReadGuard` with a possibly longer lifetime.
- ///
- /// # Safety
- /// The returned `ReadGuard` must **NOT** be used for longer than the original
- /// lifetime.
- #[must_use]
- pub unsafe fn upgrade_lifetime<'new>(self) -> ReadGuard<'new, Value>
- {
- unsafe { transmute(self) }
- }
}
impl<Value> Deref for ReadGuard<'_, Value>
diff --git a/ecs/src/query.rs b/ecs/src/query.rs
index 1889e00..d7d2d1c 100644
--- a/ecs/src/query.rs
+++ b/ecs/src/query.rs
@@ -5,11 +5,8 @@ use std::marker::PhantomData;
use seq_macro::seq;
use crate::component::{Component, FromLockedOptional, Ref as ComponentRef};
-use crate::query::flexible::{
- EntityHandle,
- Iter as FlexibleQueryIter,
- Query as FlexibleQuery,
-};
+use crate::entity::Handle as EntityHandle;
+use crate::query::flexible::{Iter as FlexibleQueryIter, Query as FlexibleQuery};
use crate::system::{Param as SystemParam, System};
use crate::uid::Uid;
use crate::util::VecExt;
@@ -39,11 +36,11 @@ where
#[must_use]
pub fn iter<'query>(
&'query self,
- ) -> ComponentIter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>
+ ) -> Iter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>
{
tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
- ComponentIter {
+ Iter {
world: self.world,
iter: self.inner.iter(),
comps_pd: PhantomData,
@@ -51,7 +48,7 @@ where
}
/// Iterates over the entities matching this query, the iterator item being the entity
- /// [`Uid`] and the entity components.
+ /// [`Uid`] and the matching entity components.
#[must_use]
pub fn iter_with_euids<'query>(
&'query self,
@@ -70,18 +67,18 @@ where
/// `func`.
///
/// This function exists so that a custom [`EntityHandle`] iterator can be given to
- /// [`ComponentIter`] without giving the user access to a reference to the [`World`].
+ /// [`Iter`] without giving the user access to a reference to the [`World`].
#[must_use]
pub fn iter_with<'query, OutIter>(
&'query self,
func: impl FnOnce(FlexibleQueryIter<'query>) -> OutIter,
- ) -> ComponentIter<'query, 'world, FieldTerms, OutIter>
+ ) -> Iter<'query, 'world, FieldTerms, OutIter>
where
OutIter: Iterator<Item = EntityHandle<'query>>,
{
tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
- ComponentIter {
+ Iter {
world: self.world,
iter: func(self.inner.iter()),
comps_pd: PhantomData,
@@ -116,7 +113,7 @@ where
FieldTerms: TermWithFieldTuple + 'world,
FieldlessTerms: TermWithoutFieldTuple,
{
- type IntoIter = ComponentIter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>;
+ type IntoIter = Iter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>;
type Item = FieldTerms::Fields<'query>;
fn into_iter(self) -> Self::IntoIter
@@ -304,7 +301,7 @@ impl<ComponentRefT: ComponentRef> TermWithField for ComponentRefT
Self::Field::from_locked_optional_component(
entity_handle
.get_component(ComponentRefT::Component::id())
- .map(|component| &component.component),
+ .map(|component| component.component()),
world,
)
.unwrap_or_else(|err| {
@@ -333,7 +330,7 @@ pub trait TermWithFieldTuple
) -> Self::Fields<'component>;
}
-pub struct ComponentIter<'query, 'world, FieldTerms, EntityHandleIter>
+pub struct Iter<'query, 'world, FieldTerms, EntityHandleIter>
where
FieldTerms: TermWithFieldTuple + 'world,
EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
@@ -344,7 +341,7 @@ where
}
impl<'query, 'world, FieldTerms, EntityHandleIter>
- ComponentIter<'query, 'world, FieldTerms, EntityHandleIter>
+ Iter<'query, 'world, FieldTerms, EntityHandleIter>
where
FieldTerms: TermWithFieldTuple + 'world,
EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
@@ -363,7 +360,7 @@ where
}
impl<'query, 'world, FieldTerms, EntityHandleIter> Iterator
- for ComponentIter<'query, 'world, FieldTerms, EntityHandleIter>
+ for Iter<'query, 'world, FieldTerms, EntityHandleIter>
where
FieldTerms: TermWithFieldTuple + 'world,
EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
diff --git a/ecs/src/query/flexible.rs b/ecs/src/query/flexible.rs
index 7d24dc9..652b96f 100644
--- a/ecs/src/query/flexible.rs
+++ b/ecs/src/query/flexible.rs
@@ -1,16 +1,16 @@
//! Low-level querying.
use std::iter::{repeat_n, FlatMap, RepeatN, Zip};
-use crate::component::storage::archetype::{Archetype, ArchetypeEntity, EntityIter};
+use crate::component::storage::archetype::{Archetype, EntityIter};
use crate::component::storage::{
ArchetypeRefIter,
ArchetypeSearchTerms,
Storage as ComponentStorage,
};
+use crate::entity::Handle as EntityHandle;
use crate::lock::ReadGuard;
use crate::query::Terms;
-use crate::uid::Uid;
-use crate::{EntityComponent, World};
+use crate::World;
/// Low-level entity query structure.
#[derive(Debug)]
@@ -68,33 +68,7 @@ impl<'query> Iterator for Iter<'query>
{
let (archetype, entity) = self.iter.next()?;
- Some(EntityHandle { archetype, entity })
- }
-}
-
-pub struct EntityHandle<'query>
-{
- archetype: &'query Archetype,
- entity: &'query ArchetypeEntity,
-}
-
-impl<'query> EntityHandle<'query>
-{
- /// Returns the [`Uid`] of this entity.
- #[inline]
- #[must_use]
- pub fn uid(&self) -> Uid
- {
- self.entity.uid
- }
-
- #[inline]
- #[must_use]
- pub fn get_component(&self, component_uid: Uid) -> Option<&'query EntityComponent>
- {
- let index = self.archetype.get_index_for_component(component_uid)?;
-
- Some(self.entity.components.get(index).unwrap())
+ Some(EntityHandle::new(archetype, entity))
}
}
diff --git a/ecs/src/relationship.rs b/ecs/src/relationship.rs
index a0ccf4d..45fa265 100644
--- a/ecs/src/relationship.rs
+++ b/ecs/src/relationship.rs
@@ -7,19 +7,18 @@ use crate::component::storage::Storage as ComponentStorage;
use crate::component::{
Component,
FromLockedOptional as FromLockedOptionalComponent,
- FromOptional as FromOptionalComponent,
- FromOptionalMut as FromOptionalMutComponent,
+ Handle as ComponentHandle,
+ HandleMut as ComponentHandleMut,
};
-use crate::lock::{Error as LockError, Lock, ReadGuard, WriteGuard};
-use crate::system::{ComponentRef, ComponentRefMut};
+use crate::lock::{Error as LockError, Lock, ReadGuard};
use crate::uid::{Kind as UidKind, Uid};
use crate::World;
/// A relationship to one or more targets.
#[derive(Debug, Component)]
#[component(
- ref_type = Relation<'component, Kind, ComponentT>,
- ref_mut_type = RelationMut<'component, Kind, ComponentT>,
+ handle_type = Relation<'component, Kind, ComponentT>,
+ handle_mut_type = RelationMut<'component, Kind, ComponentT>,
)]
pub struct Relationship<Kind, ComponentT: Component>
where
@@ -67,27 +66,26 @@ where
Kind: 'static,
ComponentT: Component,
{
- component_storage_lock: ReadGuard<'static, ComponentStorage>,
- relationship_comp: ComponentRefMut<'rel_comp, Relationship<Kind, ComponentT>>,
+ component_storage_lock: ReadGuard<'rel_comp, ComponentStorage>,
+ relationship_comp: ComponentHandleMut<'rel_comp, Relationship<Kind, ComponentT>>,
}
-impl<'rel_comp, Kind, ComponentT> FromOptionalMutComponent<'rel_comp>
+impl<'rel_comp, Kind, ComponentT> FromLockedOptionalComponent<'rel_comp>
for RelationMut<'rel_comp, Kind, ComponentT>
where
ComponentT: Component,
{
- fn from_optional_mut_component(
- optional_component: Option<
- crate::lock::WriteGuard<'rel_comp, Box<dyn Component>>,
- >,
+ fn from_locked_optional_component(
+ optional_component: Option<&'rel_comp crate::lock::Lock<Box<dyn Component>>>,
world: &'rel_comp World,
- ) -> Self
+ ) -> Result<Self, LockError>
{
+ let relationship_comp_handle_from_locked_opt_comp = ComponentHandleMut::<
+ Relationship<Kind, ComponentT>,
+ >::from_locked_optional_component;
+
let relationship_comp =
- ComponentRefMut::<Relationship<Kind, ComponentT>>::from_optional_mut_component(
- optional_component,
- world,
- );
+ relationship_comp_handle_from_locked_opt_comp(optional_component, world)?;
let component_storage_lock = world
.data
@@ -95,49 +93,14 @@ where
.read_nonblock()
.expect("Failed to aquire read-only component storage lock");
- Self {
+ Ok(Self {
relationship_comp,
- // SAFETY: The component lock is not used for longer than the original
- // lifetime
- component_storage_lock: unsafe { component_storage_lock.upgrade_lifetime() },
- }
- }
-}
-
-impl<'rel_comp, Kind, ComponentT> FromOptionalMutComponent<'rel_comp>
- for Option<RelationMut<'rel_comp, Kind, ComponentT>>
-where
- ComponentT: Component,
-{
- fn from_optional_mut_component(
- optional_component: Option<WriteGuard<'rel_comp, Box<dyn Component>>>,
- world: &'rel_comp World,
- ) -> Self
- {
- optional_component.map(|component| {
- RelationMut::from_optional_mut_component(Some(component), world)
+ component_storage_lock,
})
}
}
impl<'rel_comp, Kind, ComponentT> FromLockedOptionalComponent<'rel_comp>
- for RelationMut<'rel_comp, Kind, ComponentT>
-where
- ComponentT: Component,
-{
- fn from_locked_optional_component(
- optional_component: Option<&'rel_comp crate::lock::Lock<Box<dyn Component>>>,
- world: &'rel_comp World,
- ) -> Result<Self, LockError>
- {
- Ok(Self::from_optional_mut_component(
- optional_component.map(Lock::write_nonblock).transpose()?,
- world,
- ))
- }
-}
-
-impl<'rel_comp, Kind, ComponentT> FromLockedOptionalComponent<'rel_comp>
for Option<RelationMut<'rel_comp, Kind, ComponentT>>
where
ComponentT: Component,
@@ -165,7 +128,7 @@ where
/// Will panic if the entity does not exist in the archetype it belongs to. This
/// should hopefully never happend.
#[must_use]
- pub fn get(&self, index: usize) -> Option<ComponentRefMut<'_, ComponentT>>
+ pub fn get(&self, index: usize) -> Option<ComponentHandleMut<'_, ComponentT>>
{
let target = self.get_target(index)?;
@@ -177,11 +140,11 @@ where
let component_index = archetype.get_index_for_component(ComponentT::id())?;
- let component = ComponentRefMut::new(
+ let component = ComponentHandleMut::new(
entity
- .components
+ .components()
.get(component_index)?
- .component
+ .component()
.write_nonblock()
.unwrap_or_else(|_| {
panic!(
@@ -276,7 +239,7 @@ where
ComponentT: Component,
{
type IntoIter = TargetComponentIterMut<'relationship, 'rel_comp, Kind, ComponentT>;
- type Item = ComponentRefMut<'rel_comp, ComponentT>;
+ type Item = ComponentHandleMut<'rel_comp, ComponentT>;
fn into_iter(self) -> Self::IntoIter
{
@@ -301,7 +264,7 @@ where
Kind: 'static,
ComponentT: Component,
{
- type Item = ComponentRefMut<'rel_comp, ComponentT>;
+ type Item = ComponentHandleMut<'rel_comp, ComponentT>;
fn next(&mut self) -> Option<Self::Item>
{
@@ -325,25 +288,26 @@ where
Kind: 'static,
ComponentT: Component,
{
- component_storage_lock: ReadGuard<'static, ComponentStorage>,
- relationship_comp: ComponentRef<'rel_comp, Relationship<Kind, ComponentT>>,
+ component_storage_lock: ReadGuard<'rel_comp, ComponentStorage>,
+ relationship_comp: ComponentHandle<'rel_comp, Relationship<Kind, ComponentT>>,
}
-impl<'rel_comp, Kind, ComponentT> FromOptionalComponent<'rel_comp>
+impl<'rel_comp, Kind, ComponentT> FromLockedOptionalComponent<'rel_comp>
for Relation<'rel_comp, Kind, ComponentT>
where
ComponentT: Component,
{
- fn from_optional_component(
- optional_component: Option<ReadGuard<'rel_comp, Box<dyn Component>>>,
+ fn from_locked_optional_component(
+ optional_component: Option<&'rel_comp Lock<Box<dyn Component>>>,
world: &'rel_comp World,
- ) -> Self
+ ) -> Result<Self, LockError>
{
+ let relationship_comp_handle_from_locked_opt_comp = ComponentHandle::<
+ Relationship<Kind, ComponentT>,
+ >::from_locked_optional_component;
+
let relationship_comp =
- ComponentRef::<Relationship<Kind, ComponentT>>::from_optional_component(
- optional_component,
- world,
- );
+ relationship_comp_handle_from_locked_opt_comp(optional_component, world)?;
let component_storage_lock = world
.data
@@ -351,44 +315,10 @@ where
.read_nonblock()
.expect("Failed to aquire read-only component storage lock");
- Self {
+ Ok(Self {
relationship_comp,
- // SAFETY: The component lock is not used for longer than the original
- // lifetime
- component_storage_lock: unsafe { component_storage_lock.upgrade_lifetime() },
- }
- }
-}
-
-impl<'rel_comp, Kind, ComponentT> FromOptionalComponent<'rel_comp>
- for Option<Relation<'rel_comp, Kind, ComponentT>>
-where
- ComponentT: Component,
-{
- fn from_optional_component(
- optional_component: Option<ReadGuard<'rel_comp, Box<dyn Component>>>,
- world: &'rel_comp World,
- ) -> Self
- {
- optional_component
- .map(|component| Relation::from_optional_component(Some(component), world))
- }
-}
-
-impl<'rel_comp, Kind, ComponentT> FromLockedOptionalComponent<'rel_comp>
- for Relation<'rel_comp, Kind, ComponentT>
-where
- ComponentT: Component,
-{
- fn from_locked_optional_component(
- optional_component: Option<&'rel_comp Lock<Box<dyn Component>>>,
- world: &'rel_comp World,
- ) -> Result<Self, LockError>
- {
- Ok(Self::from_optional_component(
- optional_component.map(Lock::read_nonblock).transpose()?,
- world,
- ))
+ component_storage_lock,
+ })
}
}
@@ -420,7 +350,7 @@ where
/// Will panic if the entity does not exist in the archetype it belongs to. This
/// should hopefully never happend.
#[must_use]
- pub fn get(&self, index: usize) -> Option<ComponentRef<'_, ComponentT>>
+ pub fn get(&self, index: usize) -> Option<ComponentHandle<'_, ComponentT>>
{
let target = self.get_target(index)?;
@@ -432,11 +362,11 @@ where
let component_index = archetype.get_index_for_component(ComponentT::id())?;
- let component = ComponentRef::new(
+ let component = ComponentHandle::new(
entity
- .components
+ .components()
.get(component_index)?
- .component
+ .component()
.read_nonblock()
.unwrap_or_else(|_| {
panic!(
@@ -490,7 +420,7 @@ where
ComponentT: Component,
{
type IntoIter = TargetComponentIter<'relationship, 'rel_comp, Kind, ComponentT>;
- type Item = ComponentRef<'rel_comp, ComponentT>;
+ type Item = ComponentHandle<'rel_comp, ComponentT>;
fn into_iter(self) -> Self::IntoIter
{
@@ -515,7 +445,7 @@ where
Kind: 'static,
ComponentT: Component,
{
- type Item = ComponentRef<'rel_comp, ComponentT>;
+ type Item = ComponentHandle<'rel_comp, ComponentT>;
fn next(&mut self) -> Option<Self::Item>
{
diff --git a/ecs/src/system.rs b/ecs/src/system.rs
index 40eba8d..603c015 100644
--- a/ecs/src/system.rs
+++ b/ecs/src/system.rs
@@ -1,26 +1,11 @@
-use std::any::{type_name, Any};
+use std::any::Any;
use std::convert::Infallible;
use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::ops::{Deref, DerefMut};
use ecs_macros::Component;
use seq_macro::seq;
-use crate::component::{
- Component,
- FromLockedOptional as FromLockedOptionalComponent,
- FromOptional as FromOptionalComponent,
- FromOptionalMut as FromOptionalMutComponent,
-};
-use crate::lock::{
- Error as LockError,
- Lock,
- MappedReadGuard,
- MappedWriteGuard,
- ReadGuard,
- WriteGuard,
-};
+use crate::component::{Component, HandleMut as ComponentHandleMut};
use crate::tuple::{ReduceElement as TupleReduceElement, Tuple};
use crate::World;
@@ -41,7 +26,7 @@ pub trait System<'world, Impl>: 'static
fn get_local_component_mut<LocalComponent: Component>(
&self,
- ) -> Option<ComponentRefMut<LocalComponent>>;
+ ) -> Option<ComponentHandleMut<LocalComponent>>;
fn set_local_component<LocalComponent: Component>(
&mut self,
@@ -100,7 +85,7 @@ macro_rules! impl_system {
fn get_local_component_mut<LocalComponent: Component>(
&self,
- ) -> Option<ComponentRefMut<LocalComponent>>
+ ) -> Option<ComponentHandleMut<LocalComponent>>
{
panic!("System does not have any local components");
}
@@ -194,211 +179,6 @@ impl<Accumulator> TupleReduceElement<Accumulator, ParamWithInputFilter> for ()
type Return = Accumulator;
}
-#[derive(Debug)]
-pub struct ComponentRefMut<'a, ComponentT: Component>
-{
- inner: MappedWriteGuard<'a, ComponentT>,
- _ph: PhantomData<ComponentT>,
-}
-
-impl<'a, ComponentT: Component> ComponentRefMut<'a, ComponentT>
-{
- pub(crate) fn new(inner: WriteGuard<'a, Box<dyn Component>>) -> Self
- {
- Self {
- inner: inner.map(|component| {
- let component_type_name = component.type_name();
-
- component.downcast_mut::<ComponentT>().unwrap_or_else(|| {
- panic!(
- "Cannot downcast component {component_type_name} to type {}",
- type_name::<ComponentT>()
- );
- })
- }),
- _ph: PhantomData,
- }
- }
-}
-
-impl<'component, ComponentT: Component> FromOptionalMutComponent<'component>
- for ComponentRefMut<'component, ComponentT>
-{
- fn from_optional_mut_component(
- inner: Option<WriteGuard<'component, Box<dyn Component>>>,
- _world: &'component World,
- ) -> Self
- {
- Self::new(inner.unwrap_or_else(|| {
- panic!(
- "Component {} was not found in entity",
- type_name::<ComponentT>()
- );
- }))
- }
-}
-
-impl<'component, ComponentT: Component> FromLockedOptionalComponent<'component>
- for ComponentRefMut<'component, ComponentT>
-{
- fn from_locked_optional_component(
- optional_component: Option<&'component crate::lock::Lock<Box<dyn Component>>>,
- world: &'component World,
- ) -> Result<Self, LockError>
- {
- Ok(Self::from_optional_mut_component(
- optional_component.map(Lock::write_nonblock).transpose()?,
- world,
- ))
- }
-}
-
-impl<'comp, ComponentT> FromOptionalMutComponent<'comp>
- for Option<ComponentRefMut<'comp, ComponentT>>
-where
- ComponentT: Component,
-{
- fn from_optional_mut_component(
- optional_component: Option<WriteGuard<'comp, Box<dyn Component>>>,
- _world: &'comp World,
- ) -> Self
- {
- optional_component.map(|component| ComponentRefMut::new(component))
- }
-}
-
-impl<'comp, ComponentT> FromLockedOptionalComponent<'comp>
- for Option<ComponentRefMut<'comp, ComponentT>>
-where
- ComponentT: Component,
-{
- fn from_locked_optional_component(
- optional_component: Option<&'comp Lock<Box<dyn Component>>>,
- _world: &'comp World,
- ) -> Result<Self, LockError>
- {
- optional_component
- .map(|lock| Ok(ComponentRefMut::new(lock.write_nonblock()?)))
- .transpose()
- }
-}
-
-impl<ComponentT: Component> Deref for ComponentRefMut<'_, ComponentT>
-{
- type Target = ComponentT;
-
- fn deref(&self) -> &Self::Target
- {
- &self.inner
- }
-}
-
-impl<ComponentT: Component> DerefMut for ComponentRefMut<'_, ComponentT>
-{
- fn deref_mut(&mut self) -> &mut Self::Target
- {
- &mut self.inner
- }
-}
-
-#[derive(Debug)]
-pub struct ComponentRef<'a, ComponentT: Component>
-{
- inner: MappedReadGuard<'a, ComponentT>,
- _ph: PhantomData<ComponentT>,
-}
-
-impl<'a, ComponentT: Component> ComponentRef<'a, ComponentT>
-{
- pub(crate) fn new(inner: ReadGuard<'a, Box<dyn Component>>) -> Self
- {
- Self {
- inner: inner.map(|component| {
- component.downcast_ref::<ComponentT>().unwrap_or_else(|| {
- panic!(
- "Cannot downcast component {} to type {}",
- component.type_name(),
- type_name::<ComponentT>()
- );
- })
- }),
- _ph: PhantomData,
- }
- }
-}
-
-impl<'component, ComponentT: Component> FromOptionalComponent<'component>
- for ComponentRef<'component, ComponentT>
-{
- fn from_optional_component(
- inner: Option<ReadGuard<'component, Box<dyn Component>>>,
- _world: &'component World,
- ) -> Self
- {
- Self::new(inner.unwrap_or_else(|| {
- panic!(
- "Component {} was not found in entity",
- type_name::<ComponentT>()
- );
- }))
- }
-}
-
-impl<'component, ComponentT: Component> FromLockedOptionalComponent<'component>
- for ComponentRef<'component, ComponentT>
-{
- fn from_locked_optional_component(
- optional_component: Option<&'component crate::lock::Lock<Box<dyn Component>>>,
- world: &'component World,
- ) -> Result<Self, LockError>
- {
- Ok(Self::from_optional_component(
- optional_component.map(Lock::read_nonblock).transpose()?,
- world,
- ))
- }
-}
-
-impl<'comp, ComponentT> FromOptionalComponent<'comp>
- for Option<ComponentRef<'comp, ComponentT>>
-where
- ComponentT: Component,
-{
- fn from_optional_component(
- optional_component: Option<ReadGuard<'comp, Box<dyn Component>>>,
- _world: &'comp World,
- ) -> Self
- {
- optional_component.map(|component| ComponentRef::new(component))
- }
-}
-
-impl<'comp, ComponentT> FromLockedOptionalComponent<'comp>
- for Option<ComponentRef<'comp, ComponentT>>
-where
- ComponentT: Component,
-{
- fn from_locked_optional_component(
- optional_component: Option<&'comp Lock<Box<dyn Component>>>,
- _world: &'comp World,
- ) -> Result<Self, LockError>
- {
- optional_component
- .map(|lock| Ok(ComponentRef::new(lock.read_nonblock()?)))
- .transpose()
- }
-}
-
-impl<ComponentT: Component> Deref for ComponentRef<'_, ComponentT>
-{
- type Target = ComponentT;
-
- fn deref(&self) -> &Self::Target
- {
- &self.inner
- }
-}
-
#[derive(Debug, Component)]
pub(crate) struct SystemComponent
{
diff --git a/ecs/src/system/stateful.rs b/ecs/src/system/stateful.rs
index 80ac346..9d911ee 100644
--- a/ecs/src/system/stateful.rs
+++ b/ecs/src/system/stateful.rs
@@ -4,10 +4,9 @@ use std::panic::{RefUnwindSafe, UnwindSafe};
use hashbrown::HashMap;
use seq_macro::seq;
-use crate::component::Component;
+use crate::component::{Component, HandleMut as ComponentHandleMut};
use crate::lock::Lock;
use crate::system::{
- ComponentRefMut,
Into as IntoSystem,
Param,
ParamWithInputFilter,
@@ -110,14 +109,14 @@ macro_rules! impl_system {
fn get_local_component_mut<LocalComponent: Component>(
&self,
- ) -> Option<ComponentRefMut<LocalComponent>>
+ ) -> Option<ComponentHandleMut<LocalComponent>>
{
let local_component = self.local_components
.get(&LocalComponent::id())?
.write_nonblock()
.expect("Failed to aquire read-write local component lock");
- Some(ComponentRefMut::new(local_component))
+ Some(ComponentHandleMut::new(local_component))
}
fn set_local_component<LocalComponent: Component>(
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-04-03 03:39:50 +0000