Struct DebugHud 

pub struct DebugHud {
    pub passes_label: Option<AssetId>,
    pub mouse_label: Option<AssetId>,
    pub camera_label: Option<AssetId>,
    pub sys_label: Option<AssetId>,
}

Requests the developer debug HUD: a set of TextLabel chips with diagnostic readouts, anchored to the top-right of the window and toggled with F1 (hidden by default).

Each label field, when set, receives one chip: passes_label a multi-line list of the heaviest rendering steps of the last frame, mouse_label the cursor position in window pixels, camera_label the live camera pose (position, yaw, pitch) in the exact form a fixed viewpoint is reproduced with, and sys_label the worker-thread and host-memory budgets (the job pool’s thread count, and the process resident set against the memory budget). Chips whose stat is unavailable stay blank. The chips stack vertically from the top-right corner in the order cursor, then camera, then system, then passes (passes is last because its height varies with the frame’s step count), so their on-screen position is fixed by the engine rather than the authored coordinates.

The always-on frame-rate and GPU-memory readouts live on the separate StatHud.

Every rendering world receives a DebugHud and its chip labels at build time when it declares none, so the example below is only needed to restyle the chips. The HUD only activates in developer contexts: a debug build of the host binary, or a world launched through cn debug; release builds leave it inert even when declared. Declare an EngineDefaults with "debug_hud": false to remove it from the build entirely.

Fields

passes_label: Option<AssetId>

TextLabel that receives the per-step GPU-timing chip text.

mouse_label: Option<AssetId>

TextLabel that receives the cursor-position chip text.

camera_label: Option<AssetId>

TextLabel that receives the live camera-pose chip text.

sys_label: Option<AssetId>

TextLabel that receives the thread / memory budget chip text.

Trait Implementations

impl Clone for DebugHud

fn clone(&self) -> DebugHud

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for DebugHud

const NAME: &'static str = "DebugHud"

The registry name a world authors this component under.

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

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for DebugHud

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

Formats the value using the given formatter.

impl Default for DebugHud

fn default() -> DebugHud

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DebugHud

where DebugHud: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DebugHud> for ComponentAsset

fn from(c: DebugHud) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for DebugHud

impl Serialize for DebugHud

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.