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
61
62
63
64
65
66
67
68

/// Componente de física para objetos com movimento.
#[derive(Debug, Clone, Copy)]
pub struct Physics {
    pub velocity: (f32, f32),
    pub acceleration: (f32, f32),
    pub drag: f32,  // Resistência do ar (0.0 = sem resistência, 1.0 = para instantaneamente)
    pub gravity_scale: f32,  // Multiplicador da gravidade (0.0 = sem gravidade)
}

impl Physics {
    pub fn new() -> Self {
        Self {
            velocity: (0.0, 0.0),
            acceleration: (0.0, 0.0),
            drag: 0.0,
            gravity_scale: 0.0,
        }
    }

    pub fn with_velocity(mut self, vx: f32, vy: f32) -> Self {
        self.velocity = (vx, vy);
        self
    }

    pub fn with_gravity(mut self, scale: f32) -> Self {
        self.gravity_scale = scale;
        self
    }

    pub fn with_drag(mut self, drag: f32) -> Self {
        self.drag = drag.clamp(0.0, 1.0);
        self
    }

    pub fn apply_force(&mut self, fx: f32, fy: f32) {
        self.acceleration.0 += fx;
        self.acceleration.1 += fy;
    }

    pub fn update(&mut self, dt: f32, gravity: f32) {
        // Aplica gravidade
        self.acceleration.1 += gravity * self.gravity_scale;

        // Atualiza velocidade
        self.velocity.0 += self.acceleration.0 * dt;
        self.velocity.1 += self.acceleration.1 * dt;

        // Aplica arrasto
        if self.drag > 0.0 {
            let drag_factor = 1.0 - self.drag * dt;
            self.velocity.0 *= drag_factor.max(0.0);
            self.velocity.1 *= drag_factor.max(0.0);
        }

        // Reseta aceleração
        self.acceleration = (0.0, 0.0);
    }

    pub fn get_displacement(&self, dt: f32) -> (f32, f32) {
        (self.velocity.0 * dt, self.velocity.1 * dt)
    }
}

impl Default for Physics {
    fn default() -> Self {
        Self::new()
    }
}