Struct KeyBinding 

pub struct KeyBinding {
    pub key: String,
    pub action: String,
    pub screen: Option<AssetId>,
}

Maps a keyboard key to an action string.

When the bound key is pressed, the action fires once per press (like a HitRegion click). Bindings only run while the cursor is free: they’re inactive in worlds that capture the cursor for camera control. While a TextInput has keyboard focus, bindings are suspended so typing cannot trigger actions; a Screen’s toggle_key stays live.

The action vocabulary is the same as HitRegion’s:

• "scene:<name>": jump to the named Scene
• "quit": stop the application
• "screen:show:<name>": show the named Screen, replacing the top of the stack
• "screen:push:<name>": open the named Screen on top of what is showing
• "screen:hide": close the top Screen
• "screen:toggle:<name>": toggle the named Screen

InputKey names are case-sensitive canonical names (e.g. "Escape", "Space", "Enter").

KeyBinding {
    key: "Escape".into(),
    action: "screen:toggle:pause_menu".into(),
    ..Default::default()
};

Fields

key: String

The key name to bind (e.g. "Escape").

action: String

The action to fire when the key is pressed.

screen: Option<AssetId>

Screen this binding is scoped to: the binding only fires while that screen is on top of the stack. Unset, the binding is global.

Trait Implementations

impl Authored for KeyBinding

const TYPE: &'static str = "KeyBinding"

The registered asset type, as it appears in a world line’s type.

impl Clone for KeyBinding

fn clone(&self) -> KeyBinding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for KeyBinding

const NAME: &'static str = "KeyBinding"

The registry name a world authors this component under.

fn from_baked(bytes: &[u8]) -> Result<KeyBinding, 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 KeyBinding

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for KeyBinding

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

Formats the value using the given formatter.

impl Default for KeyBinding

fn default() -> KeyBinding

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for KeyBinding

where KeyBinding: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl RuntimeComponent for KeyBinding

impl Serialize for KeyBinding

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.