Struct bottomless_pit::camera::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(engine: &Engine) -> 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},
}

Examples found in repository

examples/camera.rs (line 21)

fn main() {
    let mut engine = EngineBuilder::new().build().unwrap();

    let texture = Texture::new(&mut engine, "examples/bplogo.png");

    let material = MaterialBuilder::new()
        .add_texture(texture)
        .build(&mut engine);
    
    let camera = Camera::new(&engine);

    let text = TextMaterial::new("Mouse pos: 0,0 \n Mouse pos: 0, 0", Colour::WHITE, 15.0, 20.0, &mut engine);

    let game = CameraExample {
        material,
        text,
        camera,
    };

    engine.run(game);
}

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 Engine::get_window_size

Examples found in repository

examples/camera.rs (line 100)

    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, 'pass>( &'others self, renderer: &mut RenderInformation<'pass, 'others> )

where 'others: 'pass,

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

Examples found in repository

examples/camera.rs (line 49)

    fn render<'pass, 'others>(
        &'others mut self,
        mut render_handle: RenderInformation<'pass, 'others>,
    ) where
        'others: 'pass,
    {
        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);
    }