sevenx_engine 0.2.11

// Demo 3D Simples - Cubo Rotativo FUNCIONANDO
use sevenx_engine::*;
use sevenx_engine::world::World;

struct Game3D {
    cube: Mesh3D,
    renderer3d: Renderer3D,
    rotation: f32,
}

impl GameState for Game3D {
    fn new() -> Self {
        // Cria cubo maior e mais visível
        let mut cube = Mesh3D::cube(3.0);
        cube.position = Vec3::new(0.0, 0.0, 0.0);
        
        // Configura renderer
        let mut renderer3d = Renderer3D::new(800, 600);
        renderer3d.camera.position = Vec3::new(0.0, 3.0, 10.0);
        renderer3d.camera.look_at(Vec3::zero());
        renderer3d.wireframe = true;  // Começa em wireframe para ver melhor
        
        Self {
            cube,
            renderer3d,
            rotation: 0.0,
        }
    }

    fn update(&mut self, dt: f32, input: &sevenx_engine::input::InputHandler, _world: &mut World) {
        // Rotaciona o cubo
        self.rotation += dt;
        self.cube.rotation.y = self.rotation;
        self.cube.rotation.x = self.rotation * 0.5;

        // Controles
        if input.is_key_pressed(KeyCode::Space) {
            self.renderer3d.wireframe = !self.renderer3d.wireframe;
        }

        // Câmera
        if input.is_key_pressed(KeyCode::KeyW) {
            self.renderer3d.camera.position.z -= 5.0 * dt;
        }
        if input.is_key_pressed(KeyCode::KeyS) {
            self.renderer3d.camera.position.z += 5.0 * dt;
        }
        if input.is_key_pressed(KeyCode::KeyA) {
            self.renderer3d.camera.position.x -= 5.0 * dt;
        }
        if input.is_key_pressed(KeyCode::KeyD) {
            self.renderer3d.camera.position.x += 5.0 * dt;
        }
        if input.is_key_pressed(KeyCode::KeyQ) {
            self.renderer3d.camera.position.y += 5.0 * dt;
        }
        if input.is_key_pressed(KeyCode::KeyE) {
            self.renderer3d.camera.position.y -= 5.0 * dt;
        }
    }

    fn draw(&mut self, _world: &World, frame: &mut [u8]) {
        // Limpa a tela - azul escuro
        for pixel in frame.chunks_exact_mut(4) {
            pixel[0] = 20;
            pixel[1] = 30;
            pixel[2] = 50;
            pixel[3] = 255;
        }

        // Renderiza o cubo 3D
        self.renderer3d.render_mesh(&self.cube, frame, 800, 600);

        // Desenha texto de ajuda (simplificado - barra no topo)
        for y in 0..40 {
            for x in 0..800 {
                let idx = ((y * 800 + x) * 4) as usize;
                if idx + 3 < frame.len() {
                    // Fundo semi-transparente
                    frame[idx] = (frame[idx] as f32 * 0.3) as u8;
                    frame[idx + 1] = (frame[idx + 1] as f32 * 0.3) as u8;
                    frame[idx + 2] = (frame[idx + 2] as f32 * 0.3) as u8;
                }
            }
        }

        // Desenha alguns pixels brancos para indicar controles
        self.draw_text_simple(frame, 10, 10, "WASD/QE: Camera | SPACE: Wireframe");
    }
}

impl Game3D {
    fn draw_text_simple(&self, frame: &mut [u8], x: usize, y: usize, text: &str) {
        // Desenha texto muito simples (apenas pixels brancos)
        for (i, _c) in text.chars().enumerate() {
            let px = x + i * 8;
            if px < 800 && y < 600 {
                // Desenha um pequeno retângulo branco para cada caractere
                for dy in 0..8 {
                    for dx in 0..6 {
                        let idx = (((y + dy) * 800 + (px + dx)) * 4) as usize;
                        if idx + 3 < frame.len() {
                            frame[idx] = 255;
                            frame[idx + 1] = 255;
                            frame[idx + 2] = 255;
                        }
                    }
                }
            }
        }
    }
}

fn main() {
    let config = EngineConfig::default()
        .with_title("SevenX Engine - 3D Demo Simples")
        .with_size(800, 600);

    let engine = Engine::with_config(config);
    engine.run::<Game3D>();
}