Struct Camera 

pub struct Camera {
    pub center: Vec2<f32>,
    pub rotation: f32,
    pub scale: Vec2<f32>,
    /* private fields */
}

A simple 2D camera that can translate, rotate, and scale everything on the screen.

Fields

center: Vec2<f32>

The center of the camera becomes the center of the screen

rotation: f32

needs to be in degrees

scale: Vec2<f32>

This controls the size of every object in view

Implementations

impl Camera

pub fn new(center: Vec2<f32>, rotation: f32, scale: Vec2<f32>) -> Self

creates a new camera with center point, rotation and scale.

pub fn transform_point( &self, point: Vec2<f32>, screen_size: Vec2<u32>, ) -> Vec2<f32>

This will transform a point in screen space to camera space. You can get the screen size from crate::Engine::get_window_size

Examples found in repository

examples/camera.rs (line 109)

    fn update(&mut self, engine_handle: &mut Engine) {
        let dt = engine_handle.get_frame_delta_time();
        let mouse_pos = engine_handle.get_mouse_position();
        let size = engine_handle.get_window_size();

        let move_factor = 15.0;

        if engine_handle.is_key_down(Key::A) {
            self.camera.center.x -= move_factor * dt;
        }

        if engine_handle.is_key_down(Key::D) {
            self.camera.center.x += move_factor * dt;
        }

        if engine_handle.is_key_down(Key::W) {
            self.camera.center.y += move_factor * dt;
        }

        if engine_handle.is_key_down(Key::S) {
            self.camera.center.y -= move_factor * dt;
        }

        if engine_handle.is_key_down(Key::Left) {
            self.camera.rotation += move_factor * dt;
        }

        if engine_handle.is_key_down(Key::Right) {
            self.camera.rotation -= move_factor * dt;
        }

        if engine_handle.is_key_down(Key::L) {
            self.camera.scale += vec2!(2.0 * dt, 2.0 * dt);
        }

        if engine_handle.is_key_down(Key::K) {
            self.camera.scale -= vec2!(2.0 * dt, 2.0 * dt);
        }

        if engine_handle.is_key_pressed(Key::Enter) {
            self.camera.rotation += 45.0;
        }

        let trans_mouse = self.camera.transform_point(mouse_pos, size);

        self.text.set_text(
            &format!(
                "Screen mouse pos: {:.3}, {:.3}\nWorld mouse pos: {:.3}, {:.3}",
                mouse_pos.x, mouse_pos.y, trans_mouse.x, trans_mouse.y
            ),
            Colour::WHITE,
            engine_handle,
        );

        self.text.prepare(engine_handle);
    }

pub fn set_active<'others>( &'others mut self, renderer: &mut Renderer<'_, 'others>, )

Sets this camera to the active camera transforming all objects with this camera.

Examples found in repository

examples/camera.rs (line 57)

    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
        let mut render_handle = render.begin_pass(Colour::BLACK);

        self.material.add_rectangle(
            Vec2 { x: 0.0, y: 0.0 },
            Vec2 { x: 300.0, y: 300.0 },
            Colour::WHITE,
            &render_handle,
        );

        self.camera.set_active(&mut render_handle);
        self.material.draw(&mut render_handle);

        render_handle.reset_camera();
        self.text
            .add_instance(vec2!(0.0), Colour::WHITE, &render_handle);
        self.text.draw(&mut render_handle);
    }

Trait Implementations

impl Default for Camera

fn default() -> Self

creates a new camera with these values:

Camera {
    center: Vec2{x : 0.0, y: 0.0},
    rotation: 0.0,
    scale: Vec2{x: 1.0, y: 1.0},
}