Struct PendingInput 

pub struct PendingInput { /* private fields */ }

Injected input waiting to be applied in PreUpdate.

Why this queue exists

BRP methods registered with with_method_main run in RemoteLast (after Last), and a message written there would be read a whole frame late by everything. More importantly, the deferral rules below — one edge per key per frame, cursor ordering, text behind an opening keystroke — have to live in exactly one place, and this is it.

The bug this shape was built around, which is worth not re-learning

Bevy’s keyboard_input_system runs in PreUpdate and begins by clearing the just-pressed and just-released sets. A press written straight into ButtonInput from a RemoteLast handler therefore had its just_pressed flag wiped by the very next PreUpdate, before any Update system could read it. Every just_pressed-based action was unreachable by injected input while the method answered success: true. Held pressed state survived the clear, which is what made it look intermittent: some actions responded and some silently did not.

That was first fixed by writing ButtonInput after the clear. It is now fixed one level further down: apply_pending_input runs before InputSystems and writes the KeyboardInput / MouseButtonInput messages that the clear-then-fold reads, so the edge is produced by Bevy from the same stream a real key travels on. There is one path for input, and now that is literally true rather than true of one half.

Implementations

impl PendingInput

pub fn queue_key(&mut self, key: KeyCode, action: InputAction)

Queue a keyboard action, applied on the next PreUpdate.

The BRP handler is one caller; a host driving itself (a test, an example, a scripted demo) is another. Both go through this queue rather than writing messages directly, because the ordering and deferral rules are only correct in one place.

The logical half is derived by logical_for, so a host driving KeyCode::Escape reaches a text field exactly as the BRP path does. window is Entity::PLACEHOLDER — see apply_pending_input for why nothing reads it.

pub fn queue_typed(&mut self, message: KeyboardInput)

Queue one already-built typed character — see typed, which is how a caller gets one.

Separate from queue_key because it is a different question, not a different spelling: this says a character arrived, that says a key went down.

pub fn queue_text(&mut self, text: &str, window: Entity) -> Result<(), char>

Queue a whole string, one message per character. Returns the character it could not build a Key from, if any — nothing is queued in that case.

pub fn queue_tap_key(&mut self, key: KeyCode)

Queue a one-frame tap: pressed on the next PreUpdate, released the frame after — the shape a physical key produces, and what just_pressed readers expect.

pub fn queue_mouse(&mut self, button: MouseButton, action: InputAction)

Queue a mouse-button action, applied on the next PreUpdate.

pub fn queue_cursor(&mut self, at: Option<Vec2>)

Queue a cursor move — logical window pixels, or None to hand the pointer back.

Through the queue like everything else, so a cursor move and the click that follows it land in the documented order rather than racing: a click applied a frame before the move would be read at the old position, which is the drag bug this whole module is shaped around avoiding.

Trait Implementations

impl Component for PendingInput

where Self: Send + Sync + 'static,

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

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, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

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 relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

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_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard 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]

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick.

impl Default for PendingInput

fn default() -> Self

Returns the “default value” for a type.

impl Resource for PendingInput

where Self: Send + Sync + 'static,