Struct ReflectComponentFns 

pub struct ReflectComponentFns {
    pub insert: fn(&mut EntityWorldMut<'_>, &(dyn PartialReflect + 'static), &TypeRegistry),
    pub apply: fn(EntityMut<'_>, &(dyn PartialReflect + 'static)),
    pub apply_or_insert_mapped: fn(&mut EntityWorldMut<'_>, &(dyn PartialReflect + 'static), &TypeRegistry, &mut dyn EntityMapper, RelationshipHookMode),
    pub remove: fn(&mut EntityWorldMut<'_>),
    pub contains: fn(FilteredEntityRef<'_, '_>) -> bool,
    pub reflect: for<'w> fn(FilteredEntityRef<'w, '_>) -> Option<&'w (dyn Reflect + 'static)>,
    pub reflect_mut: for<'w> fn(FilteredEntityMut<'w, '_>) -> Option<Mut<'w, dyn Reflect>>,
    pub map_entities: fn(&mut (dyn Reflect + 'static), &mut dyn EntityMapper),
    pub reflect_unchecked_mut: unsafe fn(UnsafeEntityCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
    pub copy: fn(&World, &mut World, Entity, Entity, &TypeRegistry),
    pub register_component: fn(&mut World) -> ComponentId,
}

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

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

Function pointer implementing ReflectComponent::insert().

apply: fn(EntityMut<'_>, &(dyn PartialReflect + 'static))

Function pointer implementing ReflectComponent::apply().

apply_or_insert_mapped: fn(&mut EntityWorldMut<'_>, &(dyn PartialReflect + 'static), &TypeRegistry, &mut dyn EntityMapper, RelationshipHookMode)

Function pointer implementing ReflectComponent::apply_or_insert_mapped().

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

Function pointer implementing ReflectComponent::remove().

contains: fn(FilteredEntityRef<'_, '_>) -> bool

Function pointer implementing ReflectComponent::contains().

reflect: for<'w> fn(FilteredEntityRef<'w, '_>) -> Option<&'w (dyn Reflect + 'static)>

Function pointer implementing ReflectComponent::reflect().

reflect_mut: for<'w> fn(FilteredEntityMut<'w, '_>) -> Option<Mut<'w, dyn Reflect>>

Function pointer implementing ReflectComponent::reflect_mut().

map_entities: fn(&mut (dyn Reflect + 'static), &mut dyn EntityMapper)

Function pointer implementing ReflectComponent::map_entities().

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, &TypeRegistry)

Function pointer implementing ReflectComponent::copy().

register_component: fn(&mut World) -> ComponentId

Function pointer implementing ReflectComponent::register_component().

Implementations

impl ReflectComponentFns

pub fn new<T>() -> ReflectComponentFns

where T: Component + FromReflect + TypePath,

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 duplicate of the value.

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

Performs copy-assignment from source.