Struct DesignMapping 

pub struct DesignMapping {
    pub design: [f32; 2],
    pub canvas_dp: [f32; 2],
    pub policy: DesignFit,
}

A design box mapped onto a dp canvas under one DesignFit policy: the scale, the offsets it implies, the inverse, and the snapping rule. Build it per frame, or on resize, from the measured canvas and the game’s design size.

Degenerate sides (<= 0.0: the state before the first measure) fall back exactly like contain_fit / cover_fit: scale 1.0, offsets 0.0, so the mapping is the identity on design units and visible reports that canvas over 1.0. Sides so far apart that the ratio underflows past the shared 1e-6 guard read the same way. A non-finite side is not repaired: it surfaces in the offsets rather than being replaced by an invented number.

Fields

design: [f32; 2]

Design box in design units.

canvas_dp: [f32; 2]

Measured canvas in dp.

policy: DesignFit

Which ratio wins.

Implementations

impl DesignMapping

pub fn contain(canvas_dp: [f32; 2], design: [f32; 2]) -> Self

Contain, the design box fully visible. Canvas first, matching contain_fit.

pub fn cover(canvas_dp: [f32; 2], design: [f32; 2]) -> Self

Cover, the canvas fully filled and the overflow cropped. Canvas first, matching cover_fit.

pub fn scale(&self) -> f32

dp per design unit for this policy: the games’ grid_scale / ui_scale under DesignFit::Contain, world_scale under DesignFit::Cover.

pub fn fit(&self) -> (f32, f32, f32)

The (scale, offset_x, offset_y) tuple the framing functions take. With the default centered camera the design origin lands at the offsets, so this tuple feeds fit_view_proj_with_roll, world_to_dp and picks alike; under DesignFit::Cover the offsets are negative on the cropped axis.

pub fn box_dp(&self) -> [f32; 2]

The design box scaled to dp at scale: the games’ cover_box under DesignFit::Cover, whose top-left sits at the offsets fit reports.

pub fn visible(&self) -> [f32; 2]

Design units the canvas shows, the games’ field_size. For a measured canvas under DesignFit::Contain this is the design box or more (the roomier axis reveals past it); under DesignFit::Cover it is the design sub-rect that survives cropping, so content that must stay visible belongs inside it.

pub fn design_to_dp(&self, design: [f32; 2]) -> [f32; 2]

Design units to dp through the fit: offset + design * scale, no rounding.

pub fn dp_to_design(&self, dp: [f32; 2]) -> [f32; 2]

Inverse of design_to_dp. Exact up to float error for any scale the fits can report (they never report zero).

pub fn snap_box(&self, at: [f32; 2], size: [f32; 2]) -> ([f32; 2], [f32; 2])

Snap a design box onto whole dp: round the converted top-left and bottom-right corners, then derive the dp extent from the two snapped corners. Two boxes that share a design-space edge therefore share the snapped edge exactly, and the extent can never disagree with its own corners (round(x) + round(w) can, by up to a dp per seam). Opt in: this is for art that must land on whole dp, not for moving content.

Trait Implementations

impl Clone for DesignMapping

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DesignMapping

impl Debug for DesignMapping

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

Formats the value using the given formatter.

impl PartialEq for DesignMapping

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DesignMapping