Struct Camera

Source

pub struct Camera { /* private fields */ }

Expand description

A rectangular viewport onto a larger world, with world/screen conversions.

Implementations§

Source §

impl Camera

Source

pub const fn new(viewport: Rect, world: Size) -> Self

Create a camera drawing into viewport (screen cells) over a world of world cells. The initial origin is (0, 0); call center_on to follow a target.

Source

pub const fn viewport(&self) -> Rect

The screen rectangle the world is drawn into.

Source

pub const fn world(&self) -> Size

The world dimensions.

Source

pub const fn origin(&self) -> Pos

The world cell shown at the viewport’s top-left corner.

Source

pub fn set_viewport(&mut self, viewport: Rect)

Replace the viewport (for example after a terminal resize), keeping the world unchanged and re-clamping the origin so it stays in bounds.

Never panics: a viewport larger than world re-clamps the origin to (0, 0) via saturating_sub rather than underflowing.

Source

pub fn center_on(&mut self, target: Pos)

Center the view on target (world coords), clamped to the world edges so the viewport never scrolls past [0, world).

Never panics, even for a target outside [0, world): the offset and clamp are both computed with saturating arithmetic.

Source

pub fn visible_bounds(&self) -> Rect

The world rectangle currently visible, clamped to world bounds.

Never panics: the clamp against world uses saturating_sub, so it cannot underflow even if origin is somehow past world’s edge.

§Examples

use retroglyph_core::{Camera, Pos, Rect, Size};

// A 10x10 viewport near the bottom-right corner of a 12x12 world: the origin clamps
// to (2, 2), so the visible rect is narrower than the viewport rather than reading
// past the world edge.
let mut cam = Camera::new(Rect::new(0, 0, 10, 10), Size { width: 12, height: 12 });
cam.center_on(Pos::new(11, 11));
assert_eq!(cam.origin(), Pos::new(2, 2));
assert_eq!(cam.visible_bounds(), Rect::new(2, 2, 10, 10));

// A world smaller than the viewport: the visible rect is the whole world, not the
// full viewport size.
let small = Camera::new(Rect::new(0, 0, 20, 20), Size { width: 5, height: 5 });
assert_eq!(small.visible_bounds(), Rect::new(0, 0, 5, 5));

Source

pub const fn world_to_screen(&self, world: Pos) -> Option<Pos>

Map a world position to its screen position, or None if it is outside the visible viewport.

Source

pub fn screen_to_world(&self, screen: Pos) -> Option<Pos>

Map a screen position back to a world position, or None if it is outside the viewport or beyond the world (useful for mouse picking).

§Examples

use retroglyph_core::{Camera, Pos, Rect, Size};

let mut cam = Camera::new(Rect::new(5, 5, 10, 10), Size { width: 100, height: 100 });
cam.center_on(Pos::new(50, 50));

// Inside the viewport: maps back to the world cell under it.
assert_eq!(cam.screen_to_world(Pos::new(5, 5)), Some(Pos::new(45, 45)));

// Off the viewport entirely (the viewport starts at x = 5): `None`, not a clamp.
assert_eq!(cam.screen_to_world(Pos::new(0, 0)), None);

Source

pub fn cells(&self) -> impl Iterator<Item = (Pos, Pos)> + '_

Iterate the visible cells as (world, screen) position pairs, in row-major order. Only cells that exist in the world are yielded, so the caller can fill the rest of the viewport with a background.