Struct Camera2d 

pub struct Camera2d {
    pub center: Vec2,
    pub offset: Vec2,
    pub units_per_pixel: f32,
    pub zoom: f32,
    pub roll: f32,
}

2D orthographic camera. Owned by the UI (signals), copied into the snapshot per frame.

The camera’s look point is effective_center (center + offset); zoom and units_per_pixel scale the view uniformly. All three viewport consumers (canvas drawing, the GPU batch matrix, and pointer picks) derive from these fields through one shared transform, so they can never disagree.

Fields

center: Vec2

World-space point the camera follows (the follow target, room center, or player position). Defaults to (0, 0).

Scroll limits (see apply_limits) clamp this field; put momentary displacement such as trauma shake in offset instead so it can push past the limits.

offset: Vec2

Momentary displacement added to center. Defaults to (0, 0).

Useful for looking around or camera shake animations: applied after limits, so a shake impulse still moves the view even when the follow target is pinned at a scroll edge. Decays back to zero under game-side trauma handling.

units_per_pixel: f32

World units per screen pixel at zoom 1. Defaults to 1.0.

Combined with the viewport size to build the orthographic projection: a smaller value shows less of the world (larger sprites). Together with zoom, the visible world width is viewport_dp * units_per_pixel / zoom. Non-positive values fall back to 1.0 so a bad snapshot can never divide by zero.

zoom: f32

Magnification. Defaults to 1.0.

Higher values zoom in: 2.0 shows half the world width on each axis (a quarter of the area); 0.5 shows twice as much. Applied on canvas and GPU alike. Non-positive values fall back to 1.0.

roll: f32

Roll in radians around the look point (trauma shake). Defaults to 0.0.

Applied after look/zoom on canvas, GPU, picks, and actor surfaces, so all consumers stay glued. Positive is clockwise in y-down space.

Implementations

impl Camera2d

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

Effective look point: center + offset.

All framing (canvas drawing, the GPU batch matrix, pointer picks, actor surfaces) uses this value, so shake and look-around applied through offset move every consumer together.

pub fn fit_matrix(&self, canvas_dp: [f32; 2], world_size: [f32; 2]) -> Mat4

Framing matrix used by GPU + picks. Prefer this over raw ortho. Includes roll around the look point.

pub fn dp_to_world_pt( &self, canvas_dp: [f32; 2], world_size: [f32; 2], dp: [f32; 2], ) -> Vec2

World under a dp-space cursor (canvas coords, density already divided out). Includes roll.

pub fn view_proj_screen(&self, viewport_px: [f32; 2]) -> Mat4

Raw ortho ignoring contain-fit letterbox. Kept for HUD overlays in screen space; viewport code must use fit_matrix.

pub fn view_proj(&self, viewport_px: [f32; 2]) -> Mat4

👎Deprecated since 0.1.8:

ignores world_size; use fit_view_proj for the shared canvas/GPU/pick framing contract

Legacy y-down view-projection: world +y points screen-down.

Diverges from the shared framing contract: this frames from viewport * units_per_pixel / zoom and ignores FrameInput::world_size, so it disagrees with canvas, GPU, and picks whenever a contain-fit letterboxes. Kept for guards/tests; viewport code must use fit_view_proj instead.

pub fn screen_to_world(&self, viewport_px: [f32; 2], px: [f32; 2]) -> Vec2

👎Deprecated since 0.1.8:

ignores world_size; use pick_world over the painted FrameGeom instead

Legacy world-space position under a viewport-pixel cursor.

Inverts view_proj, so it shares that function’s divergence from the contain-fit contract. Pointer picks must go through pick_world over the painted FrameGeom.

Trait Implementations

impl Clone for Camera2d

fn clone(&self) -> Camera2d

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Camera2d

impl Debug for Camera2d

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

Formats the value using the given formatter.

impl Default for Camera2d

fn default() -> Camera2d

Returns the “default value” for a type.