sevenx_engine 0.2.11

Engine de jogos 2D/3D completa com suporte Android, física, áudio, partículas, tilemap, UI, eventos e sistema 3D avançado com PBR.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

/// Sistema de câmera para controlar a visualização do mundo.
#[derive(Debug, Clone, Copy)]
pub struct Camera {
    pub x: f32,
    pub y: f32,
    pub zoom: f32,
    pub viewport_width: u32,
    pub viewport_height: u32,
}

impl Camera {
    pub fn new(viewport_width: u32, viewport_height: u32) -> Self {
        Self {
            x: 0.0,
            y: 0.0,
            zoom: 1.0,
            viewport_width,
            viewport_height,
        }
    }

    /// Converte coordenadas do mundo para coordenadas da tela.
    pub fn world_to_screen(&self, world_x: f32, world_y: f32) -> (i32, i32) {
        let screen_x = ((world_x - self.x) * self.zoom) as i32;
        let screen_y = ((world_y - self.y) * self.zoom) as i32;
        (screen_x, screen_y)
    }

    /// Converte coordenadas da tela para coordenadas do mundo.
    pub fn screen_to_world(&self, screen_x: i32, screen_y: i32) -> (f32, f32) {
        let world_x = (screen_x as f32 / self.zoom) + self.x;
        let world_y = (screen_y as f32 / self.zoom) + self.y;
        (world_x, world_y)
    }

    /// Move a câmera para seguir um alvo suavemente.
    pub fn follow(&mut self, target_x: f32, target_y: f32, smoothness: f32, dt: f32) {
        let center_x = target_x - (self.viewport_width as f32 / (2.0 * self.zoom));
        let center_y = target_y - (self.viewport_height as f32 / (2.0 * self.zoom));
        
        let lerp_factor = (smoothness * dt).min(1.0);
        self.x += (center_x - self.x) * lerp_factor;
        self.y += (center_y - self.y) * lerp_factor;
    }

    /// Move a câmera instantaneamente para centralizar em um ponto.
    pub fn center_on(&mut self, x: f32, y: f32) {
        self.x = x - (self.viewport_width as f32 / (2.0 * self.zoom));
        self.y = y - (self.viewport_height as f32 / (2.0 * self.zoom));
    }

    pub fn set_zoom(&mut self, zoom: f32) {
        self.zoom = zoom.max(0.1);
    }

    pub fn resize_viewport(&mut self, width: u32, height: u32) {
        self.viewport_width = width;
        self.viewport_height = height;
    }
}