mirror of
https://github.com/bevyengine/bevy
synced 2024-12-23 03:23:20 +00:00
1108 lines
32 KiB
Rust
1108 lines
32 KiB
Rust
use crate::{
|
|
archetype::{Archetype, Archetypes},
|
|
bundle::Bundles,
|
|
component::{Component, ComponentId, ComponentTicks, Components},
|
|
entity::{Entities, Entity},
|
|
query::{FilterFetch, FilteredAccess, FilteredAccessSet, QueryState, WorldQuery},
|
|
system::{CommandQueue, Commands, Query, SystemState},
|
|
world::{FromWorld, World},
|
|
};
|
|
pub use bevy_ecs_macros::SystemParam;
|
|
use bevy_ecs_macros::{all_tuples, impl_query_set};
|
|
use std::{
|
|
marker::PhantomData,
|
|
ops::{Deref, DerefMut},
|
|
};
|
|
|
|
/// A parameter that can be used in a [`System`](super::System).
|
|
///
|
|
/// # Derive
|
|
///
|
|
/// This trait can be derived with the [`derive@super::SystemParam`] macro.
|
|
///
|
|
/// ```
|
|
/// # use bevy_ecs::prelude::*;
|
|
/// use bevy_ecs::system::SystemParam;
|
|
///
|
|
/// #[derive(SystemParam)]
|
|
/// struct MyParam<'a> {
|
|
/// foo: Res<'a, usize>,
|
|
/// }
|
|
///
|
|
/// fn my_system(param: MyParam) {
|
|
/// // Access the resource through `param.foo`
|
|
/// }
|
|
///
|
|
/// # my_system.system();
|
|
/// ```
|
|
pub trait SystemParam: Sized {
|
|
type Fetch: for<'a> SystemParamFetch<'a>;
|
|
}
|
|
|
|
/// The state of a [`SystemParam`].
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// It is the implementor's responsibility to ensure `system_state` is populated with the _exact_
|
|
/// [`World`] access used by the `SystemParamState` (and associated [`SystemParamFetch`]).
|
|
/// Additionally, it is the implementor's responsibility to ensure there is no
|
|
/// conflicting access across all SystemParams.
|
|
pub unsafe trait SystemParamState: Send + Sync + 'static {
|
|
type Config: Send + Sync;
|
|
fn init(world: &mut World, system_state: &mut SystemState, config: Self::Config) -> Self;
|
|
#[inline]
|
|
fn new_archetype(&mut self, _archetype: &Archetype, _system_state: &mut SystemState) {}
|
|
#[inline]
|
|
fn apply(&mut self, _world: &mut World) {}
|
|
fn default_config() -> Self::Config;
|
|
}
|
|
|
|
pub trait SystemParamFetch<'a>: SystemParamState {
|
|
type Item;
|
|
/// # Safety
|
|
///
|
|
/// This call might access any of the input parameters in an unsafe way. Make sure the data
|
|
/// access is safe in the context of the system scheduler.
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item;
|
|
}
|
|
|
|
pub struct QueryFetch<Q, F>(PhantomData<(Q, F)>);
|
|
|
|
impl<'a, Q: WorldQuery + 'static, F: WorldQuery + 'static> SystemParam for Query<'a, Q, F>
|
|
where
|
|
F::Fetch: FilterFetch,
|
|
{
|
|
type Fetch = QueryState<Q, F>;
|
|
}
|
|
|
|
// SAFE: Relevant query ComponentId and ArchetypeComponentId access is applied to SystemState. If
|
|
// this QueryState conflicts with any prior access, a panic will occur.
|
|
unsafe impl<Q: WorldQuery + 'static, F: WorldQuery + 'static> SystemParamState for QueryState<Q, F>
|
|
where
|
|
F::Fetch: FilterFetch,
|
|
{
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
let state = QueryState::new(world);
|
|
assert_component_access_compatibility(
|
|
&system_state.name,
|
|
std::any::type_name::<Q>(),
|
|
std::any::type_name::<F>(),
|
|
&system_state.component_access_set,
|
|
&state.component_access,
|
|
world,
|
|
);
|
|
system_state
|
|
.component_access_set
|
|
.add(state.component_access.clone());
|
|
system_state
|
|
.archetype_component_access
|
|
.extend(&state.archetype_component_access);
|
|
state
|
|
}
|
|
|
|
fn new_archetype(&mut self, archetype: &Archetype, system_state: &mut SystemState) {
|
|
self.new_archetype(archetype);
|
|
system_state
|
|
.archetype_component_access
|
|
.extend(&self.archetype_component_access);
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, Q: WorldQuery + 'static, F: WorldQuery + 'static> SystemParamFetch<'a> for QueryState<Q, F>
|
|
where
|
|
F::Fetch: FilterFetch,
|
|
{
|
|
type Item = Query<'a, Q, F>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
Query::new(world, state, system_state.last_change_tick, change_tick)
|
|
}
|
|
}
|
|
|
|
fn assert_component_access_compatibility(
|
|
system_name: &str,
|
|
query_type: &'static str,
|
|
filter_type: &'static str,
|
|
system_access: &FilteredAccessSet<ComponentId>,
|
|
current: &FilteredAccess<ComponentId>,
|
|
world: &World,
|
|
) {
|
|
let mut conflicts = system_access.get_conflicts(current);
|
|
if conflicts.is_empty() {
|
|
return;
|
|
}
|
|
let conflicting_components = conflicts
|
|
.drain(..)
|
|
.map(|component_id| world.components.get_info(component_id).unwrap().name())
|
|
.collect::<Vec<&str>>();
|
|
let accesses = conflicting_components.join(", ");
|
|
panic!("Query<{}, {}> in system {} accesses component(s) {} in a way that conflicts with a previous system parameter. Allowing this would break Rust's mutability rules. Consider merging conflicting Queries into a QuerySet.",
|
|
query_type, filter_type, system_name, accesses);
|
|
}
|
|
|
|
pub struct QuerySet<T>(T);
|
|
pub struct QuerySetState<T>(T);
|
|
|
|
impl_query_set!();
|
|
|
|
/// Shared borrow of a resource.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// Panics when used as a [`SystemParameter`](SystemParam) if the resource does not exist.
|
|
///
|
|
/// Use `Option<Res<T>>` instead if the resource might not always exist.
|
|
pub struct Res<'w, T: Component> {
|
|
value: &'w T,
|
|
ticks: &'w ComponentTicks,
|
|
last_change_tick: u32,
|
|
change_tick: u32,
|
|
}
|
|
|
|
impl<'w, T: Component> Res<'w, T> {
|
|
/// Returns true if (and only if) this resource been added since the last execution of this
|
|
/// system.
|
|
pub fn is_added(&self) -> bool {
|
|
self.ticks.is_added(self.last_change_tick, self.change_tick)
|
|
}
|
|
|
|
/// Returns true if (and only if) this resource been changed since the last execution of this
|
|
/// system.
|
|
pub fn is_changed(&self) -> bool {
|
|
self.ticks
|
|
.is_changed(self.last_change_tick, self.change_tick)
|
|
}
|
|
}
|
|
|
|
impl<'w, T: Component> Deref for Res<'w, T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
self.value
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`Res`].
|
|
pub struct ResState<T> {
|
|
component_id: ComponentId,
|
|
marker: PhantomData<T>,
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParam for Res<'a, T> {
|
|
type Fetch = ResState<T>;
|
|
}
|
|
|
|
// SAFE: Res ComponentId and ArchetypeComponentId access is applied to SystemState. If this Res
|
|
// conflicts with any prior access, a panic will occur.
|
|
unsafe impl<T: Component> SystemParamState for ResState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
let component_id = world.initialize_resource::<T>();
|
|
let combined_access = system_state.component_access_set.combined_access_mut();
|
|
if combined_access.has_write(component_id) {
|
|
panic!(
|
|
"Res<{}> in system {} conflicts with a previous ResMut<{0}> access. Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
|
|
std::any::type_name::<T>(), system_state.name);
|
|
}
|
|
combined_access.add_read(component_id);
|
|
|
|
let resource_archetype = world.archetypes.resource();
|
|
let archetype_component_id = resource_archetype
|
|
.get_archetype_component_id(component_id)
|
|
.unwrap();
|
|
system_state
|
|
.archetype_component_access
|
|
.add_read(archetype_component_id);
|
|
Self {
|
|
component_id,
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParamFetch<'a> for ResState<T> {
|
|
type Item = Res<'a, T>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
let column = world
|
|
.get_populated_resource_column(state.component_id)
|
|
.unwrap_or_else(|| {
|
|
panic!(
|
|
"Resource requested by {} does not exist: {}",
|
|
system_state.name,
|
|
std::any::type_name::<T>()
|
|
)
|
|
});
|
|
Res {
|
|
value: &*column.get_ptr().as_ptr().cast::<T>(),
|
|
ticks: &*column.get_ticks_mut_ptr(),
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of `Option<Res<T>>`.
|
|
pub struct OptionResState<T>(ResState<T>);
|
|
|
|
impl<'a, T: Component> SystemParam for Option<Res<'a, T>> {
|
|
type Fetch = OptionResState<T>;
|
|
}
|
|
|
|
unsafe impl<T: Component> SystemParamState for OptionResState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self(ResState::init(world, system_state, ()))
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParamFetch<'a> for OptionResState<T> {
|
|
type Item = Option<Res<'a, T>>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
world
|
|
.get_populated_resource_column(state.0.component_id)
|
|
.map(|column| Res {
|
|
value: &*column.get_ptr().as_ptr().cast::<T>(),
|
|
ticks: &*column.get_ticks_mut_ptr(),
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Unique borrow of a resource.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// Panics when used as a [`SystemParameter`](SystemParam) if the resource does not exist.
|
|
///
|
|
/// Use `Option<ResMut<T>>` instead if the resource might not always exist.
|
|
pub struct ResMut<'w, T: Component> {
|
|
value: &'w mut T,
|
|
ticks: &'w mut ComponentTicks,
|
|
last_change_tick: u32,
|
|
change_tick: u32,
|
|
}
|
|
|
|
impl<'w, T: Component> ResMut<'w, T> {
|
|
/// Returns true if (and only if) this resource been added since the last execution of this
|
|
/// system.
|
|
pub fn is_added(&self) -> bool {
|
|
self.ticks.is_added(self.last_change_tick, self.change_tick)
|
|
}
|
|
|
|
/// Returns true if (and only if) this resource been changed since the last execution of this
|
|
/// system.
|
|
pub fn is_changed(&self) -> bool {
|
|
self.ticks
|
|
.is_changed(self.last_change_tick, self.change_tick)
|
|
}
|
|
}
|
|
|
|
impl<'w, T: Component> Deref for ResMut<'w, T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
self.value
|
|
}
|
|
}
|
|
|
|
impl<'w, T: Component> DerefMut for ResMut<'w, T> {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
self.ticks.set_changed(self.change_tick);
|
|
self.value
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`ResMut`].
|
|
pub struct ResMutState<T> {
|
|
component_id: ComponentId,
|
|
marker: PhantomData<T>,
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParam for ResMut<'a, T> {
|
|
type Fetch = ResMutState<T>;
|
|
}
|
|
|
|
// SAFE: Res ComponentId and ArchetypeComponentId access is applied to SystemState. If this Res
|
|
// conflicts with any prior access, a panic will occur.
|
|
unsafe impl<T: Component> SystemParamState for ResMutState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
let component_id = world.initialize_resource::<T>();
|
|
let combined_access = system_state.component_access_set.combined_access_mut();
|
|
if combined_access.has_write(component_id) {
|
|
panic!(
|
|
"ResMut<{}> in system {} conflicts with a previous ResMut<{0}> access. Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
|
|
std::any::type_name::<T>(), system_state.name);
|
|
} else if combined_access.has_read(component_id) {
|
|
panic!(
|
|
"ResMut<{}> in system {} conflicts with a previous Res<{0}> access. Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
|
|
std::any::type_name::<T>(), system_state.name);
|
|
}
|
|
combined_access.add_write(component_id);
|
|
|
|
let resource_archetype = world.archetypes.resource();
|
|
let archetype_component_id = resource_archetype
|
|
.get_archetype_component_id(component_id)
|
|
.unwrap();
|
|
system_state
|
|
.archetype_component_access
|
|
.add_write(archetype_component_id);
|
|
Self {
|
|
component_id,
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParamFetch<'a> for ResMutState<T> {
|
|
type Item = ResMut<'a, T>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
let value = world
|
|
.get_resource_unchecked_mut_with_id(state.component_id)
|
|
.unwrap_or_else(|| {
|
|
panic!(
|
|
"Requested resource does not exist: {}",
|
|
std::any::type_name::<T>()
|
|
)
|
|
});
|
|
ResMut {
|
|
value: value.value,
|
|
ticks: value.component_ticks,
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of `Option<ResMut<T>>`.
|
|
pub struct OptionResMutState<T>(ResMutState<T>);
|
|
|
|
impl<'a, T: Component> SystemParam for Option<ResMut<'a, T>> {
|
|
type Fetch = OptionResMutState<T>;
|
|
}
|
|
|
|
unsafe impl<T: Component> SystemParamState for OptionResMutState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self(ResMutState::init(world, system_state, ()))
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParamFetch<'a> for OptionResMutState<T> {
|
|
type Item = Option<ResMut<'a, T>>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
world
|
|
.get_resource_unchecked_mut_with_id(state.0.component_id)
|
|
.map(|value| ResMut {
|
|
value: value.value,
|
|
ticks: value.component_ticks,
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> SystemParam for Commands<'a> {
|
|
type Fetch = CommandQueue;
|
|
}
|
|
|
|
// SAFE: only local state is accessed
|
|
unsafe impl SystemParamState for CommandQueue {
|
|
type Config = ();
|
|
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Default::default()
|
|
}
|
|
|
|
fn apply(&mut self, world: &mut World) {
|
|
self.apply(world);
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a> SystemParamFetch<'a> for CommandQueue {
|
|
type Item = Commands<'a>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
Commands::new(state, world)
|
|
}
|
|
}
|
|
|
|
/// A system local [`SystemParam`].
|
|
///
|
|
/// A local may only be accessed by the system itself and is therefore not visible to other systems.
|
|
/// If two or more systems specify the same local type each will have their own unique local.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # use bevy_ecs::prelude::*;
|
|
/// # let world = &mut World::default();
|
|
/// fn write_to_local(mut local: Local<usize>) {
|
|
/// *local = 42;
|
|
/// }
|
|
/// fn read_from_local(local: Local<usize>) -> usize {
|
|
/// *local
|
|
/// }
|
|
/// let mut write_system = write_to_local.system();
|
|
/// let mut read_system = read_from_local.system();
|
|
/// write_system.initialize(world);
|
|
/// read_system.initialize(world);
|
|
///
|
|
/// assert_eq!(read_system.run((), world), 0);
|
|
/// write_system.run((), world);
|
|
/// // Note how the read local is still 0 due to the locals not being shared.
|
|
/// assert_eq!(read_system.run((), world), 0);
|
|
/// ```
|
|
pub struct Local<'a, T: Component>(&'a mut T);
|
|
|
|
impl<'a, T: Component> Deref for Local<'a, T> {
|
|
type Target = T;
|
|
|
|
#[inline]
|
|
fn deref(&self) -> &Self::Target {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
impl<'a, T: Component> DerefMut for Local<'a, T> {
|
|
#[inline]
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`Local`].
|
|
pub struct LocalState<T: Component>(T);
|
|
|
|
impl<'a, T: Component + FromWorld> SystemParam for Local<'a, T> {
|
|
type Fetch = LocalState<T>;
|
|
}
|
|
|
|
// SAFE: only local state is accessed
|
|
unsafe impl<T: Component + FromWorld> SystemParamState for LocalState<T> {
|
|
type Config = Option<T>;
|
|
|
|
fn init(world: &mut World, _system_state: &mut SystemState, config: Self::Config) -> Self {
|
|
Self(config.unwrap_or_else(|| T::from_world(world)))
|
|
}
|
|
|
|
fn default_config() -> Option<T> {
|
|
None
|
|
}
|
|
}
|
|
|
|
impl<'a, T: Component + FromWorld> SystemParamFetch<'a> for LocalState<T> {
|
|
type Item = Local<'a, T>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
_world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
Local(&mut state.0)
|
|
}
|
|
}
|
|
|
|
/// A [`SystemParam`] that grants access to the entities that had their `T` [`Component`] removed.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// Basic usage:
|
|
///
|
|
/// ```
|
|
/// # use bevy_ecs::system::IntoSystem;
|
|
/// # use bevy_ecs::system::RemovedComponents;
|
|
/// #
|
|
/// # struct MyComponent;
|
|
///
|
|
/// fn react_on_removal(removed: RemovedComponents<MyComponent>) {
|
|
/// removed.iter().for_each(|removed_entity| println!("{:?}", removed_entity));
|
|
/// }
|
|
///
|
|
/// # react_on_removal.system();
|
|
/// ```
|
|
pub struct RemovedComponents<'a, T> {
|
|
world: &'a World,
|
|
component_id: ComponentId,
|
|
marker: PhantomData<T>,
|
|
}
|
|
|
|
impl<'a, T> RemovedComponents<'a, T> {
|
|
/// Returns an iterator over the entities that had their `T` [`Component`] removed.
|
|
pub fn iter(&self) -> std::iter::Cloned<std::slice::Iter<'_, Entity>> {
|
|
self.world.removed_with_id(self.component_id)
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`RemovedComponents`].
|
|
pub struct RemovedComponentsState<T> {
|
|
component_id: ComponentId,
|
|
marker: PhantomData<T>,
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParam for RemovedComponents<'a, T> {
|
|
type Fetch = RemovedComponentsState<T>;
|
|
}
|
|
|
|
// SAFE: no component access. removed component entity collections can be read in parallel and are
|
|
// never mutably borrowed during system execution
|
|
unsafe impl<T: Component> SystemParamState for RemovedComponentsState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self {
|
|
component_id: world.components.get_or_insert_id::<T>(),
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: Component> SystemParamFetch<'a> for RemovedComponentsState<T> {
|
|
type Item = RemovedComponents<'a, T>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
RemovedComponents {
|
|
world,
|
|
component_id: state.component_id,
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Shared borrow of a non-[`Send`] resource.
|
|
///
|
|
/// Only `Send` resources may be accessed with the [`Res`] [`SystemParam`]. In case that the
|
|
/// resource does not implement `Send`, this `SystemParam` wrapper can be used. This will instruct
|
|
/// the scheduler to instead run the system on the main thread so that it doesn't send the resource
|
|
/// over to another thread.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// Panics when used as a `SystemParameter` if the resource does not exist.
|
|
pub struct NonSend<'w, T> {
|
|
pub(crate) value: &'w T,
|
|
ticks: ComponentTicks,
|
|
last_change_tick: u32,
|
|
change_tick: u32,
|
|
}
|
|
|
|
impl<'w, T: Component> NonSend<'w, T> {
|
|
/// Returns true if (and only if) this resource been added since the last execution of this
|
|
/// system.
|
|
pub fn is_added(&self) -> bool {
|
|
self.ticks.is_added(self.last_change_tick, self.change_tick)
|
|
}
|
|
|
|
/// Returns true if (and only if) this resource been changed since the last execution of this
|
|
/// system.
|
|
pub fn is_changed(&self) -> bool {
|
|
self.ticks
|
|
.is_changed(self.last_change_tick, self.change_tick)
|
|
}
|
|
}
|
|
|
|
impl<'w, T: 'static> Deref for NonSend<'w, T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
self.value
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`NonSend`].
|
|
pub struct NonSendState<T> {
|
|
component_id: ComponentId,
|
|
marker: PhantomData<fn() -> T>,
|
|
}
|
|
|
|
impl<'a, T: 'static> SystemParam for NonSend<'a, T> {
|
|
type Fetch = NonSendState<T>;
|
|
}
|
|
|
|
// SAFE: NonSendComponentId and ArchetypeComponentId access is applied to SystemState. If this
|
|
// NonSend conflicts with any prior access, a panic will occur.
|
|
unsafe impl<T: 'static> SystemParamState for NonSendState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
system_state.set_non_send();
|
|
|
|
let component_id = world.initialize_non_send_resource::<T>();
|
|
let combined_access = system_state.component_access_set.combined_access_mut();
|
|
if combined_access.has_write(component_id) {
|
|
panic!(
|
|
"NonSend<{}> in system {} conflicts with a previous mutable resource access ({0}). Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
|
|
std::any::type_name::<T>(), system_state.name);
|
|
}
|
|
combined_access.add_read(component_id);
|
|
|
|
let resource_archetype = world.archetypes.resource();
|
|
let archetype_component_id = resource_archetype
|
|
.get_archetype_component_id(component_id)
|
|
.unwrap();
|
|
system_state
|
|
.archetype_component_access
|
|
.add_read(archetype_component_id);
|
|
Self {
|
|
component_id,
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: 'static> SystemParamFetch<'a> for NonSendState<T> {
|
|
type Item = NonSend<'a, T>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
world.validate_non_send_access::<T>();
|
|
let column = world
|
|
.get_populated_resource_column(state.component_id)
|
|
.unwrap_or_else(|| {
|
|
panic!(
|
|
"Requested non-send resource does not exist: {}",
|
|
std::any::type_name::<T>()
|
|
)
|
|
});
|
|
NonSend {
|
|
value: &*column.get_ptr().as_ptr().cast::<T>(),
|
|
ticks: *column.get_ticks_mut_ptr(),
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Unique borrow of a non-[`Send`] resource.
|
|
///
|
|
/// Only `Send` resources may be accessed with the [`ResMut`] [`SystemParam`]. In case that the
|
|
/// resource does not implement `Send`, this `SystemParam` wrapper can be used. This will instruct
|
|
/// the scheduler to instead run the system on the main thread so that it doesn't send the resource
|
|
/// over to another thread.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// Panics when used as a `SystemParameter` if the resource does not exist.
|
|
pub struct NonSendMut<'a, T: 'static> {
|
|
pub(crate) value: &'a mut T,
|
|
ticks: &'a mut ComponentTicks,
|
|
last_change_tick: u32,
|
|
change_tick: u32,
|
|
}
|
|
|
|
impl<'w, T: Component> NonSendMut<'w, T> {
|
|
/// Returns true if (and only if) this resource been added since the last execution of this
|
|
/// system.
|
|
pub fn is_added(&self) -> bool {
|
|
self.ticks.is_added(self.last_change_tick, self.change_tick)
|
|
}
|
|
|
|
/// Returns true if (and only if) this resource been changed since the last execution of this
|
|
/// system.
|
|
pub fn is_changed(&self) -> bool {
|
|
self.ticks
|
|
.is_changed(self.last_change_tick, self.change_tick)
|
|
}
|
|
}
|
|
|
|
impl<'a, T: 'static> Deref for NonSendMut<'a, T> {
|
|
type Target = T;
|
|
|
|
#[inline]
|
|
fn deref(&self) -> &T {
|
|
self.value
|
|
}
|
|
}
|
|
|
|
impl<'a, T: 'static> DerefMut for NonSendMut<'a, T> {
|
|
#[inline]
|
|
fn deref_mut(&mut self) -> &mut T {
|
|
self.ticks.set_changed(self.change_tick);
|
|
self.value
|
|
}
|
|
}
|
|
|
|
impl<'a, T: 'static + core::fmt::Debug> core::fmt::Debug for NonSendMut<'a, T> {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
self.value.fmt(f)
|
|
}
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`NonSendMut`].
|
|
pub struct NonSendMutState<T> {
|
|
component_id: ComponentId,
|
|
marker: PhantomData<fn() -> T>,
|
|
}
|
|
|
|
impl<'a, T: 'static> SystemParam for NonSendMut<'a, T> {
|
|
type Fetch = NonSendMutState<T>;
|
|
}
|
|
|
|
// SAFE: NonSendMut ComponentId and ArchetypeComponentId access is applied to SystemState. If this
|
|
// NonSendMut conflicts with any prior access, a panic will occur.
|
|
unsafe impl<T: 'static> SystemParamState for NonSendMutState<T> {
|
|
type Config = ();
|
|
|
|
fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
system_state.set_non_send();
|
|
|
|
let component_id = world.components.get_or_insert_non_send_resource_id::<T>();
|
|
let combined_access = system_state.component_access_set.combined_access_mut();
|
|
if combined_access.has_write(component_id) {
|
|
panic!(
|
|
"NonSendMut<{}> in system {} conflicts with a previous mutable resource access ({0}). Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
|
|
std::any::type_name::<T>(), system_state.name);
|
|
} else if combined_access.has_read(component_id) {
|
|
panic!(
|
|
"NonSendMut<{}> in system {} conflicts with a previous immutable resource access ({0}). Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
|
|
std::any::type_name::<T>(), system_state.name);
|
|
}
|
|
combined_access.add_write(component_id);
|
|
|
|
let resource_archetype = world.archetypes.resource();
|
|
let archetype_component_id = resource_archetype
|
|
.get_archetype_component_id(component_id)
|
|
.unwrap();
|
|
system_state
|
|
.archetype_component_access
|
|
.add_write(archetype_component_id);
|
|
Self {
|
|
component_id,
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a, T: 'static> SystemParamFetch<'a> for NonSendMutState<T> {
|
|
type Item = NonSendMut<'a, T>;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
world.validate_non_send_access::<T>();
|
|
let column = world
|
|
.get_populated_resource_column(state.component_id)
|
|
.unwrap_or_else(|| {
|
|
panic!(
|
|
"Requested non-send resource does not exist: {}",
|
|
std::any::type_name::<T>()
|
|
)
|
|
});
|
|
NonSendMut {
|
|
value: &mut *column.get_ptr().as_ptr().cast::<T>(),
|
|
ticks: &mut *column.get_ticks_mut_ptr(),
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct OrState<T>(T);
|
|
|
|
impl<'a> SystemParam for &'a Archetypes {
|
|
type Fetch = ArchetypesState;
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`Archetypes`].
|
|
pub struct ArchetypesState;
|
|
|
|
// SAFE: no component value access
|
|
unsafe impl SystemParamState for ArchetypesState {
|
|
type Config = ();
|
|
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a> SystemParamFetch<'a> for ArchetypesState {
|
|
type Item = &'a Archetypes;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
_state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
world.archetypes()
|
|
}
|
|
}
|
|
|
|
impl<'a> SystemParam for &'a Components {
|
|
type Fetch = ComponentsState;
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`Components`].
|
|
pub struct ComponentsState;
|
|
|
|
// SAFE: no component value access
|
|
unsafe impl SystemParamState for ComponentsState {
|
|
type Config = ();
|
|
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a> SystemParamFetch<'a> for ComponentsState {
|
|
type Item = &'a Components;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
_state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
world.components()
|
|
}
|
|
}
|
|
|
|
impl<'a> SystemParam for &'a Entities {
|
|
type Fetch = EntitiesState;
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`Entities`].
|
|
pub struct EntitiesState;
|
|
|
|
// SAFE: no component value access
|
|
unsafe impl SystemParamState for EntitiesState {
|
|
type Config = ();
|
|
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a> SystemParamFetch<'a> for EntitiesState {
|
|
type Item = &'a Entities;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
_state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
world.entities()
|
|
}
|
|
}
|
|
|
|
impl<'a> SystemParam for &'a Bundles {
|
|
type Fetch = BundlesState;
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`Bundles`].
|
|
pub struct BundlesState;
|
|
|
|
// SAFE: no component value access
|
|
unsafe impl SystemParamState for BundlesState {
|
|
type Config = ();
|
|
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a> SystemParamFetch<'a> for BundlesState {
|
|
type Item = &'a Bundles;
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
_state: &'a mut Self,
|
|
_system_state: &'a SystemState,
|
|
world: &'a World,
|
|
_change_tick: u32,
|
|
) -> Self::Item {
|
|
world.bundles()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct SystemChangeTick {
|
|
pub last_change_tick: u32,
|
|
pub change_tick: u32,
|
|
}
|
|
|
|
impl SystemParam for SystemChangeTick {
|
|
type Fetch = SystemChangeTickState;
|
|
}
|
|
|
|
/// The [`SystemParamState`] of [`SystemChangeTickState`].
|
|
pub struct SystemChangeTickState {}
|
|
|
|
unsafe impl SystemParamState for SystemChangeTickState {
|
|
type Config = ();
|
|
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
|
|
Self {}
|
|
}
|
|
|
|
fn default_config() {}
|
|
}
|
|
|
|
impl<'a> SystemParamFetch<'a> for SystemChangeTickState {
|
|
type Item = SystemChangeTick;
|
|
|
|
unsafe fn get_param(
|
|
_state: &mut Self,
|
|
system_state: &SystemState,
|
|
_world: &World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
SystemChangeTick {
|
|
last_change_tick: system_state.last_change_tick,
|
|
change_tick,
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! impl_system_param_tuple {
|
|
($($param: ident),*) => {
|
|
impl<$($param: SystemParam),*> SystemParam for ($($param,)*) {
|
|
type Fetch = ($($param::Fetch,)*);
|
|
}
|
|
#[allow(unused_variables)]
|
|
#[allow(non_snake_case)]
|
|
impl<'a, $($param: SystemParamFetch<'a>),*> SystemParamFetch<'a> for ($($param,)*) {
|
|
type Item = ($($param::Item,)*);
|
|
|
|
#[inline]
|
|
unsafe fn get_param(
|
|
state: &'a mut Self,
|
|
system_state: &'a SystemState,
|
|
world: &'a World,
|
|
change_tick: u32,
|
|
) -> Self::Item {
|
|
|
|
let ($($param,)*) = state;
|
|
($($param::get_param($param, system_state, world, change_tick),)*)
|
|
}
|
|
}
|
|
|
|
/// SAFE: implementors of each SystemParamState in the tuple have validated their impls
|
|
#[allow(non_snake_case)]
|
|
unsafe impl<$($param: SystemParamState),*> SystemParamState for ($($param,)*) {
|
|
type Config = ($(<$param as SystemParamState>::Config,)*);
|
|
#[inline]
|
|
fn init(_world: &mut World, _system_state: &mut SystemState, config: Self::Config) -> Self {
|
|
let ($($param,)*) = config;
|
|
(($($param::init(_world, _system_state, $param),)*))
|
|
}
|
|
|
|
#[inline]
|
|
fn new_archetype(&mut self, _archetype: &Archetype, _system_state: &mut SystemState) {
|
|
let ($($param,)*) = self;
|
|
$($param.new_archetype(_archetype, _system_state);)*
|
|
}
|
|
|
|
#[inline]
|
|
fn apply(&mut self, _world: &mut World) {
|
|
let ($($param,)*) = self;
|
|
$($param.apply(_world);)*
|
|
}
|
|
|
|
fn default_config() -> ($(<$param as SystemParamState>::Config,)*) {
|
|
($(<$param as SystemParamState>::default_config(),)*)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
all_tuples!(impl_system_param_tuple, 0, 16, P);
|