Struct ReflectEvent 

pub struct ReflectEvent(/* private fields */);

A struct used to operate on reflected Event trait of a type.

A ReflectEvent for type T can be obtained via [bevy_reflect::TypeRegistration::data].

Implementations

impl ReflectEvent

pub fn trigger( &self, world: &mut World, event: &(dyn PartialReflect + 'static), registry: &TypeRegistry, )

Triggers a reflected Event like trigger().

pub fn create_observer( &self, callback: Box<dyn Fn(&(dyn Reflect + 'static), DeferredWorld<'_>) + Send + Sync>, ) -> Observer

Creates an Observer for this Event that calls the given callback.

pub fn register_event_key(&self, world: &mut World) -> EventKey

Generates the EventKey for this Event.

This is used by various dynamically typed observer APIs, such as Observer::with_event_key.

pub fn new(fns: ReflectEventFns) -> ReflectEvent

Create a custom implementation of ReflectEvent.

This is an advanced feature, useful for scripting implementations, that should not be used by most users unless you know what you are doing.

Usually you should derive [Reflect] and add the #[reflect(Event)] attribute to generate a ReflectEvent implementation automatically.

See ReflectEventFns for more information.

pub fn fn_pointers(&self) -> &ReflectEventFns

The underlying function pointers implementing methods on ReflectEvent.

This is useful when you want to keep track locally of an individual function pointer.

Calling TypeRegistry::get followed by TypeRegistration::data::<ReflectEvent> can be costly if done several times per frame. Consider cloning ReflectEvent and keeping it between frames, cloning a ReflectEvent is very cheap.

If you only need a subset of the methods on ReflectEvent, use fn_pointers to get the underlying ReflectEventFns and copy the subset of function pointers you care about.

Trait Implementations

impl Clone for ReflectEvent

fn clone(&self) -> ReflectEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, E> FromType<E> for ReflectEvent

where E: Event + Reflect + TypePath, <E as Event>::Trigger<'a>: Default,

fn from_type() -> ReflectEvent

Creates an instance of Self for type T.

fn insert_dependencies(_type_registration: &mut TypeRegistration)

Inserts [TypeData] dependencies of this [TypeData]. This is especially useful for trait [TypeData] that has a supertrait (ex: A: B). When the [TypeData] for A is inserted, the B [TypeData] will also be inserted.