sevenx_engine 0.2.11

// SevenX Engine - Simple 3D Demo
// Exemplo 3D básico que funciona sem bugs

use sevenx_engine::*;

struct Simple3DGame {
    renderer: Renderer3D,
    camera: Camera3D,
    cube: Mesh3D,
    sphere: Mesh3D,
    cylinder: Mesh3D,
    time: f32,
}

impl GameState for Simple3DGame {
    fn new() -> Self {
        let renderer = Renderer3D::new(800, 600);
        
        let mut camera = Camera3D::new(800, 600);
        camera.position = Vec3::new(0.0, 3.0, 8.0);
        camera.look_at(Vec3::zero());
        
        // Cubo vermelho
        let mut cube = Mesh3D::cube(1.5);
        cube.position = Vec3::new(-3.0, 0.0, 0.0);
        cube.set_color([255, 100, 100, 255]);
        
        // Esfera azul
        let mut sphere = Mesh3D::sphere(1.0, 16);
        sphere.position = Vec3::new(0.0, 0.0, 0.0);
        sphere.set_color([100, 100, 255, 255]);
        
        // Cilindro verde
        let mut cylinder = Mesh3D::cylinder(0.8, 2.0, 16);
        cylinder.position = Vec3::new(3.0, 0.0, 0.0);
        cylinder.set_color([100, 255, 100, 255]);
        
        Self {
            renderer,
            camera,
            cube,
            sphere,
            cylinder,
            time: 0.0,
        }
    }
    
    fn update(&mut self, dt: f32, input: &InputHandler, _world: &mut World) {
        self.time += dt;
        
        // Rotacionar objetos
        self.cube.rotation.y = self.time;
        self.cube.rotation.x = self.time * 0.5;
        
        self.sphere.rotation.x = self.time * 0.7;
        self.sphere.rotation.z = self.time * 0.3;
        
        self.cylinder.rotation.y = self.time * 0.5;
        
        // Animar posições
        self.cube.position.y = (self.time * 2.0).sin() * 0.5;
        self.sphere.position.y = (self.time * 2.0 + 2.0).sin() * 0.5;
        self.cylinder.position.y = (self.time * 2.0 + 4.0).sin() * 0.5;
        
        // Câmera orbital
        let radius = 8.0;
        self.camera.position.x = (self.time * 0.5).cos() * radius;
        self.camera.position.z = (self.time * 0.5).sin() * radius;
        self.camera.position.y = 3.0 + (self.time * 0.3).sin() * 2.0;
        self.camera.look_at(Vec3::zero());
        
        // Controles
        if input.is_key_pressed(KeyCode::Escape) {
            std::process::exit(0);
        }
        
        // Wireframe toggle
        if input.is_key_just_pressed(KeyCode::KeyW) {
            self.renderer.wireframe = !self.renderer.wireframe;
        }
        
        // Backface culling toggle
        if input.is_key_just_pressed(KeyCode::KeyB) {
            self.renderer.backface_culling = !self.renderer.backface_culling;
        }
    }
    
    fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
        // Limpar tela com gradiente
        for y in 0..600 {
            for x in 0..800 {
                let idx = (y * 800 + x) * 4;
                let sky_factor = y as f32 / 600.0;
                pixels[idx] = (20.0 + sky_factor * 30.0) as u8;     // R
                pixels[idx + 1] = (20.0 + sky_factor * 40.0) as u8; // G
                pixels[idx + 2] = (30.0 + sky_factor * 60.0) as u8; // B
                pixels[idx + 3] = 255;                               // A
            }
        }
        
        // Limpar zbuffer
        for z in &mut self.renderer.zbuffer {
            *z = f32::INFINITY;
        }
        
        // Renderizar objetos
        self.renderer.render_mesh(&self.cube, &self.camera, pixels, 800, 600);
        self.renderer.render_mesh(&self.sphere, &self.camera, pixels, 800, 600);
        self.renderer.render_mesh(&self.cylinder, &self.camera, pixels, 800, 600);
        
        // HUD
        ui::render_text(
            "SevenX Engine - Simple 3D Demo",
            10, 10,
            [255, 255, 255, 255],
            pixels,
            800
        );
        
        ui::render_text(
            &format!("FPS: {:.0}", 1.0 / if dt > 0.0 { dt } else { 0.016 }),
            10, 30,
            [255, 255, 0, 255],
            pixels,
            800
        );
        
        ui::render_text(
            &format!("Wireframe: {} (W)", self.renderer.wireframe),
            10, 50,
            [200, 200, 200, 255],
            pixels,
            800
        );
        
        ui::render_text(
            &format!("Backface Culling: {} (B)", self.renderer.backface_culling),
            10, 70,
            [200, 200, 200, 255],
            pixels,
            800
        );
        
        ui::render_text(
            "ESC: Sair",
            10, 90,
            [200, 200, 200, 255],
            pixels,
            800
        );
    }
}

fn main() {
    let config = EngineConfig::new()
        .with_title("Simple 3D Demo - SevenX Engine")
        .with_size(800, 600);
    
    Engine::with_config(config).run::<Simple3DGame>();
}