sevenx_engine 0.2.11

# Guia de Renderização 3D Experimental


## 🎲 Visão Geral


A versão 0.2.6 da SevenX Engine introduz suporte **experimental** para renderização 3D usando um software rasterizer. Isso permite criar protótipos 3D simples sem precisar de GPU ou bibliotecas complexas.

⚠️ **Nota**: Este é um sistema 3D básico para prototipagem. Para jogos 3D complexos, considere usar engines especializadas como Bevy ou wgpu.

## 📦 Componentes Principais


### Vec3 - Vetores 3D


```rust
use sevenx_engine::Vec3;

let position = Vec3::new(0.0, 1.0, 2.0);
let direction = Vec3::new(1.0, 0.0, 0.0);

// Operações
let length = position.length();
let normalized = direction.normalize();
let dot_product = position.dot(&direction);
let cross_product = position.cross(&direction);
```

### Mesh3D - Geometria 3D


```rust
use sevenx_engine::{Mesh3D, Vec3};

// Criar primitivas
let cube = Mesh3D::cube(2.0);
let sphere = Mesh3D::sphere(1.5, 16);

// Transformar mesh
let mut mesh = Mesh3D::cube(1.0);
mesh.position = Vec3::new(0.0, 0.0, -5.0);
mesh.rotation = Vec3::new(0.0, 45.0_f32.to_radians(), 0.0);
mesh.scale = Vec3::new(1.0, 2.0, 1.0);
```

### Camera3D - Câmera 3D


```rust
use sevenx_engine::{Camera3D, Vec3};

let mut camera = Camera3D::new(800, 600);

// Posicionar câmera
camera.position = Vec3::new(0.0, 2.0, 10.0);
camera.look_at(Vec3::zero());

// Mover câmera
camera.move_forward(5.0); // Move para frente

// Rotacionar ao redor do alvo
camera.rotate_around_target(0.1, 0.2);

// Configurar projeção
camera.fov = 60.0;
camera.near = 0.1;
camera.far = 100.0;
```

### Renderer3D - Renderizador


```rust
use sevenx_engine::{Renderer3D, Mesh3D};

let mut renderer = Renderer3D::new(800, 600);

// Configurações
renderer.wireframe = false; // Sólido ou wireframe
renderer.backface_culling = true; // Otimização

// Renderizar mesh
renderer.render_mesh(&cube, frame, 800, 600);
```

## 🎮 Exemplo Completo


```rust
use sevenx_engine::*;

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

impl GameState for Game3D {
    fn new() -> Self {
        let mut renderer3d = Renderer3D::new(800, 600);
        renderer3d.camera.position = Vec3::new(0.0, 3.0, 10.0);
        renderer3d.camera.look_at(Vec3::zero());

        let mut cube = Mesh3D::cube(2.0);
        cube.position = Vec3::new(-3.0, 0.0, 0.0);

        let mut sphere = Mesh3D::sphere(1.5, 20);
        sphere.position = Vec3::new(3.0, 0.0, 0.0);

        Self {
            renderer3d,
            cube,
            sphere,
            rotation: 0.0,
        }
    }

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

        // Controles de câmera
        if input.is_key_pressed(KeyCode::KeyW) {
            self.renderer3d.camera.move_forward(5.0 * dt);
        }
        if input.is_key_pressed(KeyCode::KeyS) {
            self.renderer3d.camera.move_forward(-5.0 * dt);
        }
        if input.is_key_pressed(KeyCode::KeyA) {
            self.renderer3d.camera.rotate_around_target(0.0, 2.0 * dt);
        }
        if input.is_key_pressed(KeyCode::KeyD) {
            self.renderer3d.camera.rotate_around_target(0.0, -2.0 * dt);
        }

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

    fn draw(&mut self, _world: &World, frame: &mut [u8]) {
        // Limpa tela
        for pixel in frame.chunks_exact_mut(4) {
            pixel.copy_from_slice(&[20, 20, 40, 255]);
        }

        // Renderiza objetos 3D
        self.renderer3d.render_mesh(&self.cube, frame, 800, 600);
        self.renderer3d.render_mesh(&self.sphere, frame, 800, 600);
    }
}

fn main() {
    let config = EngineConfig::default()
        .with_title("Meu Jogo 3D")
        .with_size(800, 600);

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

## 🎨 Cores de Vértices


Você pode customizar cores por vértice:

```rust
let mut mesh = Mesh3D::cube(2.0);

// Modifica cor de um vértice
mesh.vertices[0].color = [255, 0, 0, 255]; // Vermelho
mesh.vertices[1].color = [0, 255, 0, 255]; // Verde
mesh.vertices[2].color = [0, 0, 255, 255]; // Azul
```

## ⚡ Performance


O software rasterizer tem limitações:
- **Bom para**: Protótipos, visualizações simples, efeitos especiais
- **Não recomendado para**: Jogos 3D complexos, muitos polígonos

Dicas de otimização:
- Use `backface_culling = true`
- Mantenha meshes com poucos polígonos (< 1000 triângulos)
- Use wireframe para debug
- Considere LOD (Level of Detail) manual

## 🔄 Misturando 2D e 3D


Você pode combinar renderização 2D e 3D:

```rust
fn draw(&mut self, world: &World, frame: &mut [u8]) {
    // 1. Renderiza 3D primeiro
    self.renderer3d.render_mesh(&self.cube, frame, 800, 600);
    
    // 2. Renderiza 2D por cima (UI, sprites)
    // Desenhe sprites normalmente aqui
}
```

## 📚 Próximos Passos


- Experimente com diferentes primitivas
- Crie suas próprias meshes customizadas
- Combine com iluminação 2D para efeitos interessantes
- Use post-processing para melhorar a aparência

Execute o exemplo:
```bash
cargo run --example 3d_demo
```