Struct LayoutContainer 

pub struct LayoutContainer {
    pub x: f32,
    pub y: f32,
    pub col_gap: f32,
    pub row_gap: f32,
    pub rows: Vec<LayoutRow>,
    pub visible: bool,
}

Positions a set of TextLabels as a stack of rows, so a HUD does not have to hand-place every chip. Each row lays its labels out left to right; rows stack top to bottom. The container owns the labels’ on-screen position: the labels keep their own styling (font, colour, background, padding) but their x/y are overwritten each frame.

Sizing is content-driven: a label is measured at its current text, so the layout reflows as live HUD values change width. A row with a single label sits on its own line beneath the previous row, which is how a wide chip (e.g. a multi-pass timing line) ends up spanning the width of the row above.

Labels referenced by cols are matched by name; a label whose font is not loaded, or which is hidden, is skipped and reserves no space.

LayoutContainer {
    x: 10.0,
    y: 10.0,
    col_gap: 6.0,
    row_gap: 6.0,
    ..Default::default()
};

Fields

x: f32

Left edge of the container in window pixels.

y: f32

Top edge of the container in window pixels.

col_gap: f32

Pixels between adjacent labels in a row, measured between their background boxes.

row_gap: f32

Pixels between adjacent rows, measured between their background boxes.

rows: Vec<LayoutRow>

Rows of labels, top to bottom.

visible: bool

When false, the container leaves its labels where they are instead of repositioning them.

Implementations

impl LayoutContainer

pub fn layout( &self, size_of: impl Fn(AssetId) -> Option<LabelBox>, ) -> Vec<LabelPlacement>

Resolve the text origin for every label in the container.

size_of returns a label’s measured box, or None to drop it from the layout (unknown label, unloaded font, hidden). The result is pure geometry: callers measure with their font metrics, this places the boxes. Boxes within a row are laid edge-to-edge with col_gap between them; rows are stacked with row_gap between them.

pub fn layout_into( &self, size_of: impl Fn(AssetId) -> Option<LabelBox>, out: &mut Vec<LabelPlacement>, )

LayoutContainer::layout writing into a caller-owned buffer, so a per-frame caller reuses its capacity. Clears out first.

Trait Implementations

impl Clone for LayoutContainer

fn clone(&self) -> LayoutContainer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for LayoutContainer

const NAME: &'static str = "LayoutContainer"

The registry name a world authors this component under.

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).

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 LayoutContainer

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 LayoutContainer

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

Formats the value using the given formatter.

impl Default for LayoutContainer

fn default() -> LayoutContainer

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LayoutContainer

where LayoutContainer: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LayoutContainer> for ComponentAsset

fn from(c: LayoutContainer) -> Self

Converts to this type from the input type.

impl RuntimeComponent for LayoutContainer

impl Serialize for LayoutContainer

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.