Struct FrameInput 

pub struct FrameInput {

    pub forward: bool,
    pub backward: bool,
    pub left: bool,
    pub right: bool,
    pub sprint: bool,
    pub interact: bool,
    pub jump: bool,
    pub ctrl: bool,
    pub shift: bool,
    pub alt: bool,
    pub cmd: bool,
    pub move_axis: [f32; 2],
    pub look_axis: [f32; 2],
    pub captured_button: Option<GamepadButton>,
    pub nav: Option<NavDirection>,
    pub confirm: bool,
    pub back: bool,
    pub mouse_dx: f32,
    pub mouse_dy: f32,
    pub scroll_delta: f32,
    pub mouse_x: f32,
    pub mouse_y: f32,
    pub left_click: bool,
    pub left_button_down: bool,
    pub right_click: bool,
    pub viewport: [f32; 2],
    pub top_inset: f32,
    pub hud_toggle: bool,
    pub escape: bool,
    pub captured_key: Option<InputKey>,
    pub typed_char: Option<char>,
}

Per-frame keyboard and mouse input state.

One FrameInput is updated each frame from the window’s keyboard and mouse state and read by camera and UI behavior. It is maintained automatically and is never saved with the world.

Fields

forward: bool

True while the move-forward key (W) is held.

backward: bool

True while the move-backward key (S) is held.

left: bool

True while the strafe-left key (A) is held.

right: bool

True while the strafe-right key (D) is held.

sprint: bool

True while the sprint key (Shift) is held.

interact: bool

True for exactly one frame when the interact key (E) is pressed.

jump: bool

True for exactly one frame when the jump key (Space) is pressed.

ctrl: bool

True while the Control key is held. A modifier used by UI (e.g. a story fast-forwards its dialogue while it is down). Like escape and captured_key it is not frozen while a menu is open.

shift: bool

True while the Shift key is held. A modifier used by UI (e.g. additive selection in the editor). Unlike sprint it is not frozen while a menu is open, matching ctrl.

alt: bool

True while the Alt (Option) key is held. A modifier used by UI (e.g. the editor’s orbit drag). Not frozen while a menu is open, matching ctrl.

cmd: bool

True while the platform’s command modifier is held: the Command key on macOS, where application shortcuts are built on it. Windows and Linux leave this false and use ctrl instead, since the Super key there belongs to the desktop shell. UI that offers a shortcut on both accepts either modifier. Not frozen while a menu is open, matching ctrl.

move_axis: [f32; 2]

Gamepad left-stick movement vector [x, y]: x is rightward strafe, y is forward. Radial deadzone applied, magnitude at most 1, so partial deflection walks slower. [0.0, 0.0] with no gamepad; frozen (zeroed) while a menu is open, like the movement keys.

look_axis: [f32; 2]

Gamepad right-stick look vector [x, y] in the mouse-delta sign convention (positive x looks right, positive y looks down), with deadzone and response curve applied, magnitude at most 1. Unlike the pixel-based mouse deltas this is a deflection rate: consumers scale it by their look speed and the frame time. Frozen while a menu is open.

captured_button: Option<GamepadButton>

The gamepad button pressed this frame, for one frame, or None. Surfaced regardless of menu state (like captured_key) so the settings menu can capture a button for rebinding.

nav: Option<NavDirection>

The UI-navigation pulse this frame, or None. A one-frame NavDirection produced from a d-pad press (repeating while held) or a deliberate left-stick deflection. Surfaced regardless of menu state (like captured_key); menu focus movement consumes it only while a screen is active, so during play the d-pad and stick keep their movement meaning.

confirm: bool

True for exactly one frame when the confirm button (South) is pressed. Surfaced regardless of menu state; menus fire their focused control from it while a screen is active.

back: bool

True for exactly one frame when the back button (East) is pressed. Surfaced regardless of menu state; menus treat it like Escape while a screen is active.

mouse_dx: f32

Accumulated horizontal mouse movement since the last frame (pixels).

mouse_dy: f32

Accumulated vertical mouse movement since the last frame (pixels).

scroll_delta: f32

Accumulated vertical scroll-wheel movement since the last frame. Positive scrolls the content up (a scrollable UI panel moves its rows up). Cleared each frame like the mouse deltas.

mouse_x: f32

Absolute cursor X position in window pixels (origin top-left). Only meaningful when the cursor is not captured.

mouse_y: f32

Absolute cursor Y position in window pixels (origin top-left). Only meaningful when the cursor is not captured.

left_click: bool

True for exactly one frame when the left mouse button is pressed while the cursor is not captured.

left_button_down: bool

True while the left mouse button is held down (cursor not captured). Unlike left_click this stays true across frames until release, so a UI drag (e.g. a slider) can track the cursor for its whole duration.

right_click: bool

True for exactly one frame when the right mouse button is pressed while the cursor is not captured. Used for contextual UI (e.g. a create-at-cursor menu); it never captures the cursor.

viewport: [f32; 2]

Live logical viewport size in pixels [width, height]. Used to map overlay (Screen-owned) UI between its fixed reference resolution and the window, so menus scale with the window and the cursor still hit-tests against the scaled controls. [0.0, 0.0] before the backend is ready.

top_inset: f32

Height of the window chrome overlapping the top of the render surface, in the same logical units as viewport. Non-zero only where the window’s content runs under a transparent title bar (macOS), leaving the OS window buttons floating over the frame’s top-left corner: UI anchored to the top of the window starts below this so it cannot land under them. 0.0 on a window whose content already begins below its chrome.

hud_toggle: bool

True for exactly one frame when the HUD-toggle key (F1) is pressed.

escape: bool

True for exactly one frame when Escape is pressed while the cursor is not captured (menu / UI worlds). Used to fire KeyBinding actions. In worlds that capture the cursor, Escape instead releases the cursor and this stays false.

captured_key: Option<InputKey>

The canonical key pressed this frame, for one frame, or None. Surfaced regardless of menu state (unlike the gameplay keys, which freeze while a menu is open) so the settings menu can capture a key for rebinding and scrollable menu lists can react to the arrow keys.

typed_char: Option<char>

The printable character typed this frame (Unicode, with shift / layout applied by the OS), for text-input fields, or None. A one-frame pulse surfaced regardless of menu state, like captured_key. Editing keys (Backspace, Delete, arrows) arrive via captured_key, not here.

Trait Implementations

impl Clone for FrameInput

fn clone(&self) -> FrameInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for FrameInput

const NAME: &'static str = "FrameInput"

The registry name a world authors this component under.

fn from_baked(bytes: &[u8]) -> Result<FrameInput, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

fn inject_name(&mut self, _id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

impl ComponentSlot for FrameInput

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<FrameInput>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<FrameInput>

Mutably borrow this type’s column out of the storage.

impl Debug for FrameInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for FrameInput

fn default() -> FrameInput

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FrameInput

fn deserialize<__D>( __deserializer: __D, ) -> Result<FrameInput, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<FrameInput> for ComponentAsset

fn from(c: FrameInput) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for FrameInput

impl Serialize for FrameInput

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.