Struct AsyncComponent

pub struct AsyncComponent {
    task: Task<()>,
    receiver: Receiver<CommandQueue>,
}

Represents an ongoing asynchronous operation that will be polled for progress and/or completion.

To create instances, see AsyncComponent::new_async, AsyncComponent::new_compute and AsyncComponent::new_io.

Fields

task: Task<()>

The task tracking if the asynchronous operation is completed.

receiver: Receiver<CommandQueue>

The channel through which updates are emitted.

Updates are modelled through Bevy’s CommandQueue, which allows async tasks to send commands back to the main World.

Implementations

impl AsyncComponent

pub fn new_async<F, Fut, EF>(task: F, handler: EF) -> Self

where F: FnOnce(Sender<CommandQueue>) -> Fut + Send + 'static, Fut: Future<Output = Result<(), BevyError>> + Send + 'static, EF: FnOnce(BevyError, Sender<CommandQueue>) + Send + 'static,

Generates a new AsyncComponent for the task, scheduled on the [AsyncComputeTaskPool]. Like the [AsyncComputeTaskPool], this is intended for CPU-intensive work that may span across multiple frames.

The handler passed in will be called if task returns an error. This allows handling errors within the context of the task.

pub fn new_compute<F, Fut, EF>(task: F, handler: EF) -> Self

where F: FnOnce(Sender<CommandQueue>) -> Fut + Send + 'static, Fut: Future<Output = Result<(), BevyError>> + Send + 'static, EF: FnOnce(BevyError, Sender<CommandQueue>) + Send + 'static,

Generates a new AsyncComponent for the task, scheduled on the [ComputeTaskPool]. Like the [ComputeTaskPool], this is intended for CPU-intensive work that must be completed to deliver the next frame.

The handler passed in will be called if task returns an error. This allows handling errors within the context of the task.

pub fn new_io<F, Fut, EF>(task: F, handler: EF) -> Self

where F: FnOnce(Sender<CommandQueue>) -> Fut + Send + 'static, Fut: Future<Output = Result<(), BevyError>> + Send + 'static, EF: FnOnce(BevyError, Sender<CommandQueue>) + Send + 'static,

Generates a new AsyncComponent for the task, scheduled on the [IoTaskPool]. Like the [IoTaskPool], this is intended for IO-intensive work.

The handler passed in will be called if task returns an error. This allows handling errors within the context of the task.

Trait Implementations

impl Component for AsyncComponent

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its [ComponentHooks].

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add [ComponentHook] for this [Component] if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert [ComponentHook] for this [Component] if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace [ComponentHook] for this [Component] if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove [ComponentHook] for this [Component] if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn [ComponentHook] for this [Component] if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given [EntityMapper]. This is used to remap entities in contexts like scenes and entity cloning. When deriving [Component], this is populated by annotating fields containing entities with #[entities]