Struct TextLabel 

pub struct TextLabel {

    pub asset_id: AssetId,
    pub font: Option<FontHandle>,
    pub content: String,
    pub x: f32,
    pub y: f32,
    pub color: [f32; 3],
    pub scale: f32,
    pub centered: bool,
    pub align: TextAlign,
    pub fit: SpriteFit,
    pub background: [f32; 4],
    pub padding: f32,
    pub wrap_width: f32,
    pub max_lines: u32,
    pub visible: bool,
    pub screen: Option<AssetId>,
}

Screen-space text drawn as a UI overlay on top of the 3D scene each frame.

Text is laid out using the referenced Font. A label naming none draws with the engine’s built-in face at 24px, which costs the build nothing (the face ships inside the binary) and renders the same whether the world was compiled or assembled in code. The content field can be updated every frame (e.g. by an FpsCounter).

A \n in content starts a new line. When background has an alpha > 0, a box is filled behind the glyphs, extended outward by padding pixels, useful for HUD chips.

TextLabel {
    content: "FPS: --".into(),
    x: 10.0,
    y: 10.0,
    color: [1.0, 1.0, 1.0],
    scale: 1.0,
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

font: Option<FontHandle>

The Font asset to use for rendering. Unset draws with the engine’s built-in face at its native 24px.

content: String

Text to display. Can be updated each frame.

x: f32

Horizontal position in pixels from the left edge of the window.

y: f32

Vertical position in pixels from the top edge of the window.

color: [f32; 3]

Linear-space RGB text colour.

scale: f32

Uniform scale applied on top of the font’s size_px (24 for the built-in face). 1.0 = native size. Ignored when centered is set, which sizes the text to the viewport instead.

centered: bool

When true, fit the label to the viewport and center it there each frame, so x, y, align and scale are all ignored.

align: TextAlign

Horizontal alignment relative to x (measured with the real font metrics). Ignored when centered is set.

fit: SpriteFit

How a screen-owned label maps from the reference canvas to the window when their aspect ratios differ (matches Sprite’s fit). Bottom keeps a label flush with a bottom-anchored sprite it labels.

background: [f32; 4]

RGBA fill of a box drawn behind the text. An alpha of 0 (the default) draws no box; any alpha > 0 draws the box at that opacity.

padding: f32

Pixels the background box extends past the text on every side. Only meaningful when background is visible.

wrap_width: f32

Width in the label’s own pixels that text wraps within. 0 (the default) never wraps, so the text runs as far as it needs to. Any greater value breaks the content into lines at word boundaries, using the real font metrics, splitting a word only when it cannot fit a line on its own. Authored newlines are kept as breaks either way. Ignored when centered is set, since a centered label is sized to the viewport rather than to a container.

max_lines: u32

Most lines the label draws. 0 (the default) draws every line. When the text needs more than this, the last drawn line ends in an ellipsis, so text bounded by wrap_width is bounded in both directions and can never spill out of the box that holds it.

visible: bool

When false, the label is hidden.

screen: Option<AssetId>

Screen this label belongs to. Resolved automatically from the naming convention (<screen>_*); you don’t set this directly. None means the label is always visible.

Trait Implementations

impl Clone for TextLabel

fn clone(&self) -> TextLabel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for TextLabel

const NAME: &'static str = "TextLabel"

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<TextLabel, 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 TextLabel

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for TextLabel

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

Formats the value using the given formatter.

impl Default for TextLabel

fn default() -> TextLabel

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TextLabel

where TextLabel: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TextLabel> for ComponentAsset

fn from(c: TextLabel) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for TextLabel

impl Serialize for TextLabel

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.