Struct EngineDefaults 

pub struct EngineDefaults {
    pub hud: bool,
    pub debug_hud: bool,
    pub sky: bool,
    pub story_pause_menu: bool,
    pub loading_overlay: bool,
    pub physics_config: bool,
}

Opts a world out of individual engine-injected defaults.

A world is completed at start with the standard components it does not declare itself: the DebugHud with its chip TextLabels and font, the chips and font of a StatHud, the PhysicsConfig a world with physics content simulates on, the LoadingOverlay a streamed world waits behind, and, when an EnvironmentMap is present, the sky mesh that displays it. Declaring a piece yourself keeps the injection from filling that slot; declaring EngineDefaults with a flag set to false removes the whole default.

Two defaults are stated in terms of a MainMenu, which the build expands away, so they are injected by the build instead: the StatHud a menu world drives, and a story world’s pause menu.

EngineDefaults {
    debug_hud: false,
    sky: false,
    ..Default::default()
};

Fields

hud: bool

Inject the StatHud when the world declares a MainMenu but no StatHud, and fill any declared StatHud’s unset chip labels with chips.

debug_hud: bool

Inject the DebugHud with its chip labels when the world declares no DebugHud.

sky: bool

Inject the sky mesh (a skybox mesh, Material, and Prop) when the world has an EnvironmentMap but no skybox mesh. Disable to use an EnvironmentMap for image-based lighting only, with the background left to clear_color or your own geometry.

story_pause_menu: bool

Inject an Escape-toggled pause MainMenu when the world plays a Story but declares no MainMenu: Resume, Save, Load, a trimmed Settings screen, and Quit to the story’s title. Disable to leave a story with no pause menu, or declare your own MainMenu to replace it.

loading_overlay: bool

Inject the LoadingOverlay with its screen, backdrop, progress bar, and label when the world declares Scenes and a StreamingConfig but no LoadingOverlay. Disable to jump between scenes with no loading screen while their content streams in.

physics_config: bool

Inject a PhysicsConfig with the engine’s own values when the world has physics content – a RigidBody, a PropBody, a TriggerVolume, or a SkinnedMesh with a capsule – but declares no PhysicsConfig. Physics runs on those values either way; the injected component is what makes them visible to tooling. Disable to leave them implicit.

Trait Implementations

impl Clone for EngineDefaults

fn clone(&self) -> EngineDefaults

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for EngineDefaults

const NAME: &'static str = "EngineDefaults"

The registry name a world authors this component under.

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

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for EngineDefaults

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

Formats the value using the given formatter.

impl Default for EngineDefaults

fn default() -> EngineDefaults

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EngineDefaults

where EngineDefaults: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EngineDefaults

impl From<EngineDefaults> for ComponentAsset

fn from(c: EngineDefaults) -> ComponentAsset

Converts to this type from the input type.

impl PartialEq for EngineDefaults

fn eq(&self, other: &EngineDefaults) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl RuntimeComponent for EngineDefaults

impl Serialize for EngineDefaults

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.

impl StructuralPartialEq for EngineDefaults