Enum SpriteAlign 

#[non_exhaustive]
pub enum SpriteAlign {
    TopLeft,
    Top,
    TopRight,
    Left,
    Center,
    Right,
    BottomLeft,
    Bottom,
    BottomRight,
}

Where a sprite sits inside the multi-cell box a span reserves for it.

Geometry only: alignment moves a sprite’s pixels, it never changes their color. See TilesetOptions for how a sprite’s color relates to the cell’s style.

Only observable when the reserved box is larger than the sprite’s own pixels, i.e. when Surface::put_span declares more cells than the artwork fills. A sprite drawn into a box its art exactly fills (the common case) renders identically under every variant. Mirrors BearLibTerminal’s tileset align= option.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

TopLeft

Flush with the box’s top-left corner.

Top

Centred horizontally, flush with the top edge.

TopRight

Flush with the top-right corner.

Left

Flush with the left edge, centred vertically.

Center

Centred on both axes.

Right

Flush with the right edge, centred vertically.

BottomLeft

Flush with the bottom-left corner.

Bottom

Centred horizontally, flush with the bottom edge.

BottomRight

Flush with the bottom-right corner.

Implementations

impl SpriteAlign

pub const fn offset( self, sprite_w: u32, sprite_h: u32, box_w: u32, box_h: u32, ) -> (i16, i16)

Returns the offset of a sprite_w x sprite_h sprite placed inside a box_w x box_h box, in unscaled pixels to match Tile::dx.

Centring uses integer division, so an odd leftover pixel lands on the right/bottom side. Saturates at 0 on either axis where the sprite is at least as large as the box, so an oversized sprite is never pulled off its own anchor cell.

Examples

use retroglyph_window::tileset::SpriteAlign;

// 16x16 art in a 32x32 box leaves 16 pixels of slack on each axis.
assert_eq!(SpriteAlign::Center.offset(16, 16, 32, 32), (8, 8));
assert_eq!(SpriteAlign::BottomRight.offset(16, 16, 32, 32), (16, 16));
// Art that fills its box renders identically under every variant.
assert_eq!(SpriteAlign::Center.offset(16, 16, 16, 16), (0, 0));

pub const fn offset_in_span( self, sprite_w: u32, sprite_h: u32, span_w: u16, span_h: u16, glyph_w: u8, glyph_h: u8, ) -> (i16, i16)

Returns the offset of a sprite_w x sprite_h sprite inside the box a span_w x span_h span of glyph_w x glyph_h cells reserves for it, in unscaled pixels.

span_w/span_h come from Tile::span and glyph_w/ glyph_h are the unscaled cell size, so the box is span_w * glyph_w x span_h * glyph_h pixels. A zero cell size is treated as one pixel, leaving the sprite on its anchor rather than offsetting it by a meaningless amount.

Trait Implementations

impl Clone for SpriteAlign

fn clone(&self) -> SpriteAlign

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpriteAlign

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

Formats the value using the given formatter.

impl Default for SpriteAlign

fn default() -> SpriteAlign

Returns the “default value” for a type.

impl PartialEq for SpriteAlign

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SpriteAlign

impl Eq for SpriteAlign

impl StructuralPartialEq for SpriteAlign