Struct bevy::ecs::reflect::ReflectComponentFns

pub struct ReflectComponentFns {
    pub from_world: fn(_: &mut World) -> Box<dyn Reflect, Global>,
    pub insert: fn(_: &mut EntityWorldMut<'_>, _: &(dyn Reflect + 'static)),
    pub apply: fn(_: &mut EntityWorldMut<'_>, _: &(dyn Reflect + 'static)),
    pub apply_or_insert: fn(_: &mut EntityWorldMut<'_>, _: &(dyn Reflect + 'static)),
    pub remove: fn(_: &mut EntityWorldMut<'_>),
    pub contains: fn(_: EntityRef<'_>) -> bool,
    pub reflect: fn(_: EntityRef<'_>) -> Option<&(dyn Reflect + 'static)>,
    pub reflect_mut: fn(_: &'a mut EntityWorldMut<'_>) -> Option<Mut<'a, dyn Reflect>>,
    pub reflect_unchecked_mut: unsafe fn(_: UnsafeEntityCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
    pub copy: fn(_: &World, _: &mut World, _: Entity, _: Entity),
}

The raw function pointers needed to make up a ReflectComponent.

This is used when creating custom implementations of ReflectComponent with ReflectComponent::new().

Note: Creating custom implementations of ReflectComponent is an advanced feature that most users will not need. Usually a ReflectComponent is created for a type by deriving Reflect and adding the #[reflect(Component)] attribute. After adding the component to the TypeRegistry, its ReflectComponent can then be retrieved when needed.

Creating a custom ReflectComponent may be useful if you need to create new component types at runtime, for example, for scripting implementations.

By creating a custom ReflectComponent and inserting it into a type’s TypeRegistration, you can modify the way that reflected components of that type will be inserted into the Bevy world.

Fields

from_world: fn(_: &mut World) -> Box<dyn Reflect, Global>

Function pointer implementing ReflectComponent::from_world().

insert: fn(_: &mut EntityWorldMut<'_>, _: &(dyn Reflect + 'static))

Function pointer implementing ReflectComponent::insert().

apply: fn(_: &mut EntityWorldMut<'_>, _: &(dyn Reflect + 'static))

Function pointer implementing ReflectComponent::apply().

apply_or_insert: fn(_: &mut EntityWorldMut<'_>, _: &(dyn Reflect + 'static))

Function pointer implementing ReflectComponent::apply_or_insert().

remove: fn(_: &mut EntityWorldMut<'_>)

Function pointer implementing ReflectComponent::remove().

contains: fn(_: EntityRef<'_>) -> bool

Function pointer implementing ReflectComponent::contains().

reflect: fn(_: EntityRef<'_>) -> Option<&(dyn Reflect + 'static)>

Function pointer implementing ReflectComponent::reflect().

reflect_mut: fn(_: &'a mut EntityWorldMut<'_>) -> Option<Mut<'a, dyn Reflect>>

Function pointer implementing ReflectComponent::reflect_mut().

reflect_unchecked_mut: unsafe fn(_: UnsafeEntityCell<'_>) -> Option<Mut<'_, dyn Reflect>>

Function pointer implementing ReflectComponent::reflect_unchecked_mut().

Safety

The function may only be called with an UnsafeEntityCell that can be used to mutably access the relevant component on the given entity.

copy: fn(_: &World, _: &mut World, _: Entity, _: Entity)

Function pointer implementing ReflectComponent::copy().

Implementations

impl ReflectComponentFns

pub fn new<T>() -> ReflectComponentFnswhere T: Component + Reflect + FromWorld,

Get the default set of ReflectComponentFns for a specific component type using its FromType implementation.

This is useful if you want to start with the default implementation before overriding some of the functions to create a custom implementation.

Trait Implementations

impl Clone for ReflectComponentFns

fn clone(&self) -> ReflectComponentFns

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.