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

// Demo de texturas e materiais 3D
use sevenx_engine::*;
use sevenx_engine::world::World;
use sevenx_engine::input::InputHandler;

struct Texture3DDemo {
    renderer3d: Renderer3D,
    meshes: Vec<Mesh3D>,
    camera_angle: f32,
    camera_distance: f32,
}

impl Texture3DDemo {
    fn new() -> Self {
        let renderer3d = Renderer3D::new(1280, 720);
        let mut meshes = Vec::new();

        // Cubo com textura checkerboard
        let mut cube1 = Mesh3D::cube(2.0);
        cube1.position = Vec3::new(-6.0, 0.0, 0.0);
        let texture1 = Texture3D::checkerboard(64, [255, 0, 0, 255], [255, 255, 255, 255]);
        cube1.set_material(Material3D::new([255, 255, 255, 255]).with_texture(texture1));
        meshes.push(cube1);

        // Esfera com material metálico
        let mut sphere = Mesh3D::sphere(1.0, 16);
        sphere.position = Vec3::new(-3.0, 0.0, 0.0);
        sphere.set_material(Material3D::metal());
        meshes.push(sphere);

        // Cilindro com material plástico
        let mut cylinder = Mesh3D::cylinder(0.8, 2.0, 16);
        cylinder.position = Vec3::new(0.0, 0.0, 0.0);
        cylinder.set_material(Material3D::plastic().with_roughness(0.3));
        meshes.push(cylinder);

        // Torus com gradiente
        let mut torus = Mesh3D::torus(1.0, 0.3, 16, 12);
        torus.position = Vec3::new(3.0, 0.0, 0.0);
        let gradient = Texture3D::gradient_horizontal(64, 64, [255, 0, 0, 255], [0, 0, 255, 255]);
        torus.set_material(Material3D::new([255, 255, 255, 255]).with_texture(gradient));
        meshes.push(torus);

        // Cone emissivo
        let mut cone = Mesh3D::cone(1.0, 2.0, 16);
        cone.position = Vec3::new(6.0, 0.0, 0.0);
        cone.set_material(Material3D::emissive([255, 255, 0, 255], 2.0));
        meshes.push(cone);

        // Chão com textura
        let mut ground = Mesh3D::plane(20.0, 20.0);
        ground.position = Vec3::new(0.0, -2.0, 0.0);
        let ground_tex = Texture3D::checkerboard(128, [100, 100, 100, 255], [150, 150, 150, 255]);
        ground.set_material(Material3D::new([255, 255, 255, 255]).with_texture(ground_tex));
        meshes.push(ground);

        Self {
            renderer3d,
            meshes,
            camera_angle: 0.0,
            camera_distance: 15.0,
        }
    }
}

impl GameState for Texture3DDemo {
    fn new() -> Self {
        Self::new()
    }

    fn update(&mut self, dt: f32, input: &InputHandler, _world: &mut World) {
        // Rotação automática da câmera
        self.camera_angle += 20.0 * dt;

        // Controles da câmera
        if input.is_key_pressed(KeyCode::ArrowLeft) {
            self.camera_angle -= 60.0 * dt;
        }
        if input.is_key_pressed(KeyCode::ArrowRight) {
            self.camera_angle += 60.0 * dt;
        }
        if input.is_key_pressed(KeyCode::ArrowUp) {
            self.camera_distance -= 5.0 * dt;
        }
        if input.is_key_pressed(KeyCode::ArrowDown) {
            self.camera_distance += 5.0 * dt;
        }

        // Rotação dos objetos
        for i in 0..self.meshes.len() - 1 {
            self.meshes[i].rotation.y += 30.0 * dt;
            self.meshes[i].rotation.x += 15.0 * dt;
        }

        // Posição da câmera
        let cam_x = self.camera_angle.to_radians().cos() * self.camera_distance;
        let cam_z = self.camera_angle.to_radians().sin() * self.camera_distance;
        
        self.renderer3d.camera.set_position(Vec3::new(cam_x, 5.0, cam_z));
        self.renderer3d.camera.look_at(Vec3::new(0.0, 0.0, 0.0));
    }

    fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
        // Limpa o buffer
        for pixel in pixels.chunks_exact_mut(4) {
            pixel.copy_from_slice(&[20, 25, 35, 255]);
        }

        self.renderer3d.clear_zbuffer();

        // Renderiza meshes
        for mesh in &self.meshes {
            self.renderer3d.render_mesh(mesh, pixels, 1280, 720);
        }

        // UI
        let mut prims = Primitives2D::new(pixels, 1280, 720);
        prims.draw_rect_filled(10, 10, 400, 120, [0, 0, 0, 180]);
        
        // Texto seria renderizado aqui com informações
    }
}

fn main() {
    println!("🎨 SevenX Engine v0.2.7 - Demo de Texturas 3D");
    println!("Controles:");
    println!("  Setas - Controlar câmera");
    println!();

    let config = EngineConfig::new()
        .with_title("SevenX - Texturas 3D")
        .with_size(1280, 720)
        .with_gravity(0.0);

    Engine::with_config(config).run::<Texture3DDemo>();
}