Struct View2 

pub struct View2 { /* private fields */ }

Object providing a world-to-model transform in 2D

Rendering and meshing happen in the ±1 square or cube; these are referred to as world coordinates. A View generates a homogeneous transform matrix that maps from positions in world coordinates to model coordinates, which can be whatever you want.

For example, the world-to-model transform could map the ±1 region onto the ±0.5 region, which would be a zoom transform.

Here’s an example of using a View2 to focus on the region [4, 6]:

let view = View2::from_center_and_scale(Vector2::new(5.0, 5.0), 1.0);

//   -------d-------
//   |             |
//   |             |
//   c      a      b
//   |             |
//   |             |
//   -------e-------
let a = view.transform_point(&Point2::new(0.0, 0.0));
assert_eq!(a, Point2::new(5.0, 5.0));

let b = view.transform_point(&Point2::new(1.0, 0.0));
assert_eq!(b, Point2::new(6.0, 5.0));

let c = view.transform_point(&Point2::new(-1.0, 0.0));
assert_eq!(c, Point2::new(4.0, 5.0));

let d = view.transform_point(&Point2::new(0.0, 1.0));
assert_eq!(d, Point2::new(5.0, 6.0));

let e = view.transform_point(&Point2::new(0.0, -1.0));
assert_eq!(e, Point2::new(5.0, 4.0));

See also RegionSize::screen_to_world, which converts from screen to world coordinates.

Implementations

impl View2

pub fn from_center_and_scale(center: Vector2<f32>, scale: f32) -> Self

Builds a camera from a center (in world coordinates) and a scale

The resulting camera will point at the center, and the viewport will be ± scale in size.

pub fn components(&self) -> (Vector2<f32>, f32)

Returns a (center, scale) tuple

pub fn from_components(center: Vector2<f32>, scale: f32) -> Self

Builds a view from its components

This function is identical to from_center_and_scale

pub fn world_to_model(&self) -> Matrix3<f32>

Returns the world-to-model transform matrix

pub fn transform_point(&self, p: &Point2<f32>) -> Point2<f32>

Transform a point from world to model space

pub fn begin_translate(&self, start: Point2<f32>) -> TranslateHandle<2>

Begins a translation operation, given a point in world space

pub fn translate(&mut self, h: &TranslateHandle<2>, pos: Point2<f32>) -> bool

Applies a translation (in world units) to the current camera position

pub fn zoom(&mut self, amount: f32, pos: Option<Point2<f32>>) -> bool

Zooms the camera about a particular position (in world space)

Returns true if the view has changed, false otherwise

Trait Implementations

impl Clone for View2

fn clone(&self) -> View2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for View2

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

Formats the value using the given formatter.

impl Default for View2

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for View2

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for View2

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for View2

impl StructuralPartialEq for View2