Struct Screen 

pub struct Screen {
    pub asset_id: AssetId,
    pub initial: bool,
    pub fade_in_secs: f32,
    pub toggle_key: String,
    pub input: ScreenInput,
    pub pauses_world: bool,
    pub focus: Option<AssetId>,
    pub layer: i32,
}

A named full-screen layer of UI drawn over the world: a pause menu, a settings page, a console, a score overlay.

UI elements (Sprite, TextLabel, TextInput, HitRegion) belong to a screen by name prefix <screen_name>_*, mirroring the Scene → Prop convention. Active screens form a stack; each is shown / hidden via HitRegion or KeyBinding actions:

• screen:show:<name> replaces the top of the stack (menu navigation)
• screen:push:<name> opens on top of what is already showing
• screen:hide closes the top screen, revealing what was beneath
• screen:toggle:<name> closes the screen if it is on top, opens it otherwise

Screens draw in stack order (later on top); layer orders a screen against the always-on HUD and other screens independent of stack position. While any active screen has pauses_world set, the world freezes exactly as today’s pause menu does. A toggle_key opens and closes the screen from anywhere. focus names a TextInput that receives keyboard focus whenever the screen reaches the top of the stack. Worlds that need no menus simply declare no screens.

Screen {
    toggle_key: "Escape".into(),
    ..Default::default()
};

Fields

asset_id: AssetId

Assigned by the loader; not authored.

initial: bool

When true, this screen is shown as soon as the world loads.

fade_in_secs: f32

Seconds to fade the screen in when it’s shown. 0 shows it instantly.

toggle_key: String

InputKey that toggles this screen open / closed from anywhere, by the same canonical key names a KeyBinding uses (e.g. “Escape”, “Backtick”). Empty leaves the screen action-driven only.

input: ScreenInput

Input policy while the screen is active.

pauses_world: bool

When true (the default), the world pauses beneath this screen while it is active: gameplay input, physics, and animation freeze.

focus: Option<AssetId>

TextInput that receives keyboard focus whenever this screen reaches the top of the stack.

layer: i32

Draw-order bias against the always-on HUD and other screens. Screens default above the HUD in stack order; a negative layer draws beneath the HUD, a higher layer stays above later-pushed screens.

Trait Implementations

impl Clone for Screen

fn clone(&self) -> Screen

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Screen

const NAME: &'static str = "Screen"

The registry name a world authors this component under.

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.

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

impl ComponentSlot for Screen

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for Screen

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

Formats the value using the given formatter.

impl Default for Screen

fn default() -> Screen

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Screen

where Screen: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Screen> for ComponentAsset

fn from(c: Screen) -> Self

Converts to this type from the input type.

impl RuntimeComponent for Screen

impl Serialize for Screen

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.