Struct Sprite 

pub struct Sprite {

    pub asset_id: AssetId,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub texture: Option<TextureHandle>,
    pub tint: [f32; 4],
    pub follow_cursor: bool,
    pub visible: bool,
    pub screen: Option<AssetId>,
    pub fit: SpriteFit,
    pub corner_radius: f32,
    pub border_width: f32,
    pub border_color: [f32; 4],
}

Screen-space 2D rectangle drawn as a UI overlay each frame.

Sprites are pixel-anchored quads with an RGBA tint. They draw alongside TextLabels, ordered behind labels so text sits on top.

A sprite with a texture draws that image, multiplied by the tint (use a white tint to show the image unchanged; the tint’s alpha fades it). Without one, the tint is drawn as a solid-coloured rectangle.

Sprite {
    x: 0.0,
    y: 0.0,
    width: 1280.0,
    height: 720.0,
    tint: [0.04, 0.06, 0.1, 1.0],
    ..Default::default()
};

Fields

asset_id: AssetId

Assigned by the loader; not authored.

x: f32

Left edge in screen pixels from the window’s top-left.

y: f32

Top edge in screen pixels from the window’s top-left.

width: f32

Width in screen pixels.

height: f32

Height in screen pixels.

texture: Option<TextureHandle>

Texture to draw, sampled over the sprite’s rect and multiplied by tint. Omitted, the sprite is a solid tint fill.

tint: [f32; 4]

RGBA colour the rectangle is filled with, each channel in [0, 1].

follow_cursor: bool

When true, the sprite acts as an in-engine cursor: it is drawn on top of the other overlays as an arrow pointer tracking the mouse, with the pointer at the arrow’s tip. tint is the arrow fill (a contrasting outline is added automatically) and height its size; width is ignored so the arrow keeps its shape. The system cursor is hidden while a visible follow_cursor sprite exists.

visible: bool

When false the sprite is skipped each frame.

screen: Option<AssetId>

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

fit: SpriteFit

How a screen-owned sprite maps from the reference canvas to the window when their aspect ratios differ.

corner_radius: f32

Corner rounding radius in the sprite’s own pixel space. 0 keeps sharp corners; larger values round each corner with a quarter-circle arc (clamped to half the sprite’s shorter side). The rounded edge is softly anti-aliased.

border_width: f32

Border stroke width in the sprite’s own pixel space, drawn just inside the sprite’s outline and following its rounded corners. 0 draws no border; larger values paint a ring of that width in border_color (clamped to half the sprite’s shorter side). An opaque fill is inset under the ring; a translucent fill keeps the whole rect, so the ring sits over its edge and whatever is behind still shows through.

border_color: [f32; 4]

RGBA colour of the border stroke, each channel in [0, 1]. Ignored when border_width is 0.

Trait Implementations

impl Clone for Sprite

fn clone(&self) -> Sprite

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Sprite

const NAME: &'static str = "Sprite"

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 Sprite

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 Sprite

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

Formats the value using the given formatter.

impl Default for Sprite

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Sprite

where Sprite: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Sprite> for ComponentAsset

fn from(c: Sprite) -> Self

Converts to this type from the input type.

impl RuntimeComponent for Sprite

impl Serialize for Sprite

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.