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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

// Sistema de Skybox para ambientes 3D
use crate::mesh3d::{Mesh3D, Vec3};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Skybox {
    pub mesh: Mesh3D,
    pub textures: SkyboxTextures,
    pub brightness: f32,
    pub rotation_speed: f32,
    pub current_rotation: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SkyboxTextures {
    CubeMap {
        front: String,
        back: String,
        left: String,
        right: String,
        top: String,
        bottom: String,
    },
    Procedural(ProceduralSky),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProceduralSky {
    pub horizon_color: [u8; 4],
    pub zenith_color: [u8; 4],
    pub ground_color: [u8; 4],
    pub sun_color: [u8; 4],
    pub sun_position: Vec3,
    pub sun_size: f32,
    pub stars: bool,
    pub star_count: u32,
}

impl Skybox {
    pub fn new_cubemap(
        front: String,
        back: String,
        left: String,
        right: String,
        top: String,
        bottom: String,
    ) -> Self {
        let mesh = Self::create_skybox_mesh();
        Self {
            mesh,
            textures: SkyboxTextures::CubeMap {
                front,
                back,
                left,
                right,
                top,
                bottom,
            },
            brightness: 1.0,
            rotation_speed: 0.0,
            current_rotation: 0.0,
        }
    }

    pub fn new_procedural(config: ProceduralSky) -> Self {
        let mesh = Self::create_skybox_mesh();
        Self {
            mesh,
            textures: SkyboxTextures::Procedural(config),
            brightness: 1.0,
            rotation_speed: 0.0,
            current_rotation: 0.0,
        }
    }

    pub fn simple_gradient(top_color: [u8; 4], bottom_color: [u8; 4]) -> Self {
        Self::new_procedural(ProceduralSky {
            horizon_color: bottom_color,
            zenith_color: top_color,
            ground_color: [50, 50, 50, 255],
            sun_color: [255, 255, 200, 255],
            sun_position: Vec3::new(0.0, 1.0, 0.5).normalize(),
            sun_size: 0.05,
            stars: false,
            star_count: 0,
        })
    }

    pub fn day_sky() -> Self {
        Self::new_procedural(ProceduralSky {
            horizon_color: [135, 206, 235, 255], // Azul claro
            zenith_color: [25, 25, 112, 255],     // Azul escuro
            ground_color: [34, 139, 34, 255],     // Verde
            sun_color: [255, 255, 200, 255],
            sun_position: Vec3::new(0.3, 0.8, 0.5).normalize(),
            sun_size: 0.05,
            stars: false,
            star_count: 0,
        })
    }

    pub fn night_sky() -> Self {
        Self::new_procedural(ProceduralSky {
            horizon_color: [25, 25, 112, 255],  // Azul escuro
            zenith_color: [0, 0, 20, 255],      // Quase preto
            ground_color: [20, 20, 30, 255],
            sun_color: [200, 200, 255, 255],    // Lua
            sun_position: Vec3::new(-0.3, 0.6, 0.5).normalize(),
            sun_size: 0.04,
            stars: true,
            star_count: 200,
        })
    }

    pub fn sunset_sky() -> Self {
        Self::new_procedural(ProceduralSky {
            horizon_color: [255, 140, 0, 255],   // Laranja
            zenith_color: [255, 69, 0, 255],     // Vermelho
            ground_color: [139, 69, 19, 255],
            sun_color: [255, 100, 0, 255],
            sun_position: Vec3::new(0.8, 0.2, 0.5).normalize(),
            sun_size: 0.08,
            stars: false,
            star_count: 0,
        })
    }

    fn create_skybox_mesh() -> Mesh3D {
        let size = 500.0;
        let mut mesh = Mesh3D::cube(size);
        mesh.flip_normals(); // Normais para dentro
        mesh
    }

    pub fn update(&mut self, dt: f32) {
        if self.rotation_speed != 0.0 {
            self.current_rotation += self.rotation_speed * dt;
            self.mesh.rotation.y = self.current_rotation;
        }
    }

    pub fn set_rotation_speed(&mut self, speed: f32) {
        self.rotation_speed = speed;
    }

    pub fn set_brightness(&mut self, brightness: f32) {
        self.brightness = brightness.max(0.0).min(2.0);
    }
}

impl Default for ProceduralSky {
    fn default() -> Self {
        Self {
            horizon_color: [135, 206, 235, 255],
            zenith_color: [25, 25, 112, 255],
            ground_color: [34, 139, 34, 255],
            sun_color: [255, 255, 200, 255],
            sun_position: Vec3::new(0.0, 1.0, 0.0),
            sun_size: 0.05,
            stars: false,
            star_count: 0,
        }
    }
}