Struct Camera2d 

pub struct Camera2d { /* private fields */ }

Represents a camera (“view”) positioned and oriented in a 2D scene with a 2D transformation and a 2D projection

Implementations

impl Camera2d

pub fn new(viewport_width: u16, viewport_height: u16) -> Self

Create a new camera centered at the origin looking down the positive Y axis with ‘up’ vector aligned with the Z axis.

The orthographic projection is defined such that at the initial zoom level of 1.0, one unit in world space is one pixel, so the points in the bounding rectangle defined by minimum point (-half_screen_width+1, -half_screen_height+1) and maximum point (half_screen_width, half_screen_height) are visible.

pub const fn yaw(&self) -> Rad<f32>

pub const fn position(&self) -> Point2<f32>

pub const fn orientation(&self) -> Rotation2<f32>

pub const fn viewport_width(&self) -> u16

pub const fn viewport_height(&self) -> u16

pub const fn transform_mat_world_to_view(&self) -> Matrix4<f32>

pub const fn zoom(&self) -> f32

pub const fn ortho(&self) -> FrustumPlanes<f32>

pub const fn projection_mat_ortho(&self) -> Matrix4<f32>

pub fn screen_to_world(&self, screen_coord: Point2<f32>) -> Point2<f32>

Convert a screen space coordinate to world space based on the current view.

let [width, height] = [320, 240];
let mut camera2d = Camera2d::new (width, height);
let screen_coord = [width as f32 / 2.0, height as f32 / 2.0].into();
assert_eq!(camera2d.screen_to_world (screen_coord).0, [0.0, 0.0].into());

pub fn world_to_screen(&self, world_coord: Point2<f32>) -> Point2<f32>

Convert a world space coordinate to screen space based on the current view.

let [width, height] = [320, 240];
let mut camera2d = Camera2d::new (width, height);
let world_coord  = math::Point::origin();
assert_eq!(camera2d.world_to_screen (world_coord).0,
  [width as f32 / 2.0, height as f32 / 2.0].into());

pub fn set_viewport_dimensions( &mut self, viewport_width: u16, viewport_height: u16, )

Should be called when the screen resolution changes to update the orthographic projection state.

Panics

Panics if the viewport width or height are zero:

let mut camera2d = Camera2d::new (320, 240);
camera2d.set_viewport_dimensions (0, 0); // panics

pub fn set_position(&mut self, position: Point2<f32>)

pub fn set_zoom(&mut self, zoom: f32)

Set the zoom level.

Panics

Panics if scale factor is zero or negative:

let mut camera2d = Camera2d::new (320, 240);
camera2d.set_zoom (-1.0);   // panics

pub fn rotate(&mut self, delta_yaw: Rad<f32>)

pub fn move_local(&mut self, delta_x: f32, delta_y: f32)

Move by delta X and Y values in local coordinates

pub fn move_origin_to_bottom_left(&mut self)

Move camera so that the world-space origin will be centered on the lower left pixel

pub fn scale_zoom(&mut self, scale: f32)

Multiply the current zoom by the given scale factor.

Panics

Panics if scale factor is zero or negative:

let mut camera2d = Camera2d::new (320, 240);
camera2d.scale_zoom (-1.0);   // panics

pub fn view_ortho_mats(&self) -> ([[f32; 4]; 4], [[f32; 4]; 4])

Returns the raw world to view transform and ortho projection matrix data, suitable for use as shader uniforms.

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 Debug for Camera2d

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

Formats the value using the given formatter.

impl PartialEq for Camera2d

fn eq(&self, other: &Camera2d) -> 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 StructuralPartialEq for Camera2d