sevenx_engine 0.2.11

# 🎮 **SevenX Engine v0.2.9**


[![Crates.io](https://img.shields.io/crates/v/sevenx_engine.svg)](https://crates.io/crates/sevenx_engine)
[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](LICENSE)
[![Rust](https://img.shields.io/badge/rust-2024-orange.svg)](https://www.rust-lang.org)
[![Android](https://img.shields.io/badge/android-7.0%2B-green.svg)](https://developer.android.com)

Uma engine de jogos **2D/3D** completa, moderna e otimizada, feita em Rust. Agora com **suporte completo para Android**! Ideal para aprendizado, prototipagem rápida e desenvolvimento de jogos indie e mobile.

## ✨ **Novidades v0.2.9 - ANDROID SUPPORT! 🤖📱**


### 📱 **Suporte Android Completo**

- **Multi-Touch**: Touch input ilimitado com detecção de pressão
- **Joystick Virtual**: Controle analógico suave e responsivo
- **Sensores**: Acelerômetro e giroscópio 3 eixos
- **Vibração**: 3 intensidades + padrões customizados
- **Bateria**: Gerenciamento inteligente de bateria e temperatura
- **Performance**: FPS adaptativo e thermal throttling automático

### 🎮 **Controles Mobile**

```rust
use sevenx_engine::android::*;

let mut android = AndroidManager::new();

// Joystick virtual
android.input.create_virtual_joystick(100.0, 500.0, 50.0);
let (axis_x, axis_y) = android.input.get_virtual_joystick_axis();

// Touch input
if android.input.is_touch_in_area(x, y, width, height) {
    android.vibration.vibrate(50); // Feedback tátil
}

// Controle por inclinação
let accel = android.input.get_accelerometer();
player_x += accel.x * 2.0;
```

### 📦 **Compilação Android**

```bash
# Instalar ferramentas

rustup target add aarch64-linux-android
cargo install cargo-apk

# Compilar e instalar

cargo apk build --release --target aarch64-linux-android
cargo apk run --release
```

### 📚 **Documentação Android**

- `ANDROID_FEATURES_0.2.9.md` - Guia completo
- `examples/android_demo.rs` - Demo interativa
- `PLATFORM_SUPPORT.md` - Plataformas suportadas

---

## ✨ **Novidades v0.2.8**


### 🌍 **Suporte Multiplataforma**

- **Windows, Linux, macOS**: Suporte completo e testado
- **Android**: Suporte experimental (ARM64, ARMv7)
- **Detecção Automática**: A engine detecta a plataforma e ajusta configurações
- **Scripts de Build**: Compile para todas as plataformas com um comando
- **Otimizações**: Configurações automáticas por plataforma

### 🚀 **Otimizações 3D Avançadas**

- **Frustum Culling**: Não renderiza objetos fora da câmera (até 90% de economia)
- **LOD System**: 5 níveis de detalhe automáticos baseados em distância
- **Bounding Volumes**: BoundingBox e BoundingSphere para colisões rápidas
- **Culling Stats**: Estatísticas em tempo real de otimização

### 🌅 **Sistema de Skybox**

- **Cubemap**: Suporte a 6 texturas (front, back, left, right, top, bottom)
- **Procedural**: Céu gerado por código com gradientes
- **Presets**: day_sky(), night_sky(), sunset_sky()
- **Dinâmico**: Rotação e brilho ajustáveis
- **Estrelas**: Sistema de estrelas para céu noturno

### 🔧 **Mesh 3D Avançado**

- **subdivide()**: Aumenta detalhes da mesh
- **smooth()**: Suaviza normais (smooth shading)
- **mirror()**: Espelha mesh em X, Y ou Z
- **extrude()**: Extrude faces ao longo das normais
- **apply_noise()**: Adiciona ruído para terrenos procedurais
- **optimize()**: Remove vértices duplicados
- **surface_area()**: Calcula área de superfície
- **volume()**: Calcula volume de meshes fechadas

### 🎯 **Battle Royale Multiplayer**

- 20 jogadores simultâneos (1 humano + 19 bots)
- Zona que diminui ao longo do tempo
- Sistema de loot (munição, vida, armas)
- Eliminações e ranking em tempo real
- Minimapa tático
- Sincronização multiplayer completa

---

## ✨ **Novidades v0.2.7**


### 🎨 **Sistema de Shaders Customizáveis**

- Crie seus próprios shaders via código ou arquivo
- 7 shaders built-in (invert, grayscale, sepia, vignette, brightness, contrast, tint)
- ShaderBuilder para combinar efeitos facilmente
- Sistema de uniforms para parâmetros dinâmicos

### 📦 **Carregamento de Modelos 3D**

- Suporte a arquivos OBJ
- Exportação para OBJ
- Cache automático de modelos
- ModelBuilder para configuração fácil

### 🎨 **UI Avançada**

- 6 widgets (Button, Slider, Checkbox, Panel, ProgressBar, Label)
- 3 temas prontos (Dark, Light, Neon)
- Painéis arrastáveis
- Sistema de eventos UI

### 🖱️ **Input Avançado**

- 35+ métodos de input
- Mouse completo (botões, scroll, posição, delta)
- Just pressed/released para teclado e mouse
- Atalhos (Ctrl, Shift, Alt)
- Eixos de movimento (WASD/Setas)

---

## 🚀 **Funcionalidades Completas**


### **🎲 Sistema 3D v0.1.1** (Release Oficial)

- ✅ **12 Primitivas 3D**: Cube, Sphere, Cylinder, Cone, Pyramid, Capsule, Torus, Icosphere, Prism, Plane, Quad, Grid, Ring, Star
- ✅ **7 Shaders 3D**: Phong, Toon, Fresnel, Normal Map, Reflection, Fog, Wireframe
- ✅ **Texturas e Materiais**: Sistema PBR-like com metallic, roughness, emission
- ✅ **Partículas 3D**: 6 efeitos pré-configurados (explosion, fire, magic, smoke, sparkles, trail)
- ✅ **Otimizações Avançadas**: LOD (5 níveis), Frustum Culling (até 90% economia), Backface Culling, Batch Rendering
- ✅ **Skybox**: Cubemap e procedural com presets (dia, noite, pôr do sol)
- ✅ **Manipulação de Mesh**: Subdivide, smooth, mirror, extrude, noise, optimize
- ✅ **Carregamento de Modelos**: Suporte a OBJ

### **🖌️ Sistema 2D Completo**

- ✅ **20+ Primitivas 2D**: Pixel, Linha, Retângulo, Círculo, Elipse, Triângulo, Polígono, Arco, Grade, Flood Fill
- ✅ **Gradientes**: Horizontal, Vertical, Radial
- ✅ **Sprites Avançados**: Rotação, escala, pivot, flip, blend modes
- ✅ **Animações**: Sistema de animação de sprites
- ✅ **Efeitos Visuais**: Shake, Flash, Fade, Pulse, Wave

### **⚙️ Sistema de Configurações Gráficas**

- ✅ **5 Níveis de Qualidade**: Muito Baixo (padrão), Baixo, Médio, Alto, Ultra
- ✅ **Ajuste Dinâmico**: Baseado no FPS atual
- ✅ **Monitor de Performance**: Tracking de FPS e estabilidade
- ✅ **Otimizado para PCs Fracos**: Padrão em "Muito Baixo" (30 FPS, 50% resolução)

### **🎮 Core**

- 🎯 **Sistema de Componentes**: Transform, Physics, Collider
- 🎨 **Renderização**: Controle de baixo nível do buffer de pixels
- 📷 **Câmera 2D/3D**: Viewport, zoom, seguimento suave
- 🎯 **Layers**: Z-index para profundidade

### **⚡ Física e Colisão**

- 💥 **Física 2D**: Velocidade, aceleração, gravidade, arrasto
- 🔲 **Colisão AABB**: Com suporte a triggers
- 🌍 **Gravidade Global**: Configurável

### **🎬 Sprites e Animação**

- 🖼️ **Sprite Sheets**: Carregamento e gerenciamento
- 🎬 **Animações**: Baseadas em frames com múltiplas ações
- 💾 **Resource Manager**: Cache de texturas

### **🔊 Áudio**

- 🎵 **Música e SFX**: Reprodução de áudio
- 🔉 **Controle de Volume**: Independente para música e efeitos
- 💿 **Cache**: Gerenciamento eficiente

### **🌐 Multiplayer** (Novo!)

- 🎮 **Sincronização de Estado**: Interpolação automática de posições
- 🔄 **Predição do Cliente**: Movimento suave com compensação de lag
- 🏠 **Sistema de Lobby**: Gerenciamento de salas, times e ready
- 💬 **Chat**: Global, time e whisper
- 📊 **Estatísticas**: Ping, packet loss, bandwidth
- 🚀 **Networking Real**: QUIC/UDP com feature "multiplayer"
- 🎯 **Suporte 2D e 3D**: Sincronização de posição e rotação

### **🗺️ Tilemap e Níveis**

- 🧱 **Tilemap**: Renderização baseada em grid
- 🚧 **Colisão**: Tiles sólidos para plataformas
- 💾 **Serialização**: JSON/TOML
- 🎨 **Editor**: Ferramentas para criar níveis

### **✨ Partículas**

- 💥 **2D e 3D**: Sistemas completos de partículas
- 🎆 **Emissores**: Burst e stream
- 🌈 **Efeitos**: Alpha blending, turbulência, color shifting
- ⚙️ **Presets**: Prontos para usar

### **📡 Eventos**

- 🎯 **Sistema de Eventos**: Customizáveis com callbacks
- 📬 **Fila**: Processamento assíncrono
- 🎮 **Pré-definidos**: PlayerDied, CoinCollected, etc.

### **🎮 Input**

- ⌨️ **Teclado**: Completo com just pressed/released
- 🖱️ **Mouse**: Botões, posição, delta, scroll
- 🎮 **Gamepad**: Suporte completo
- 🔧 **Atalhos**: Ctrl, Shift, Alt

### **💾 Persistência**

- 💾 **Save System**: Salvar/carregar progresso
- 🏆 **Achievements**: Sistema de conquistas
- ⚙️ **Configurações**: Persistência de settings

---

## 📦 **Instalação**


```toml
[dependencies]
sevenx_engine = "0.2.8"
```

Com áudio:
```toml
[dependencies]
sevenx_engine = { version = "0.2.8", features = ["audio"] }
```

Com multiplayer (networking real):
```toml
[dependencies]
sevenx_engine = { version = "0.2.8", features = ["multiplayer"] }
```

Tudo junto:
```toml
[dependencies]
sevenx_engine = { version = "0.2.8", features = ["audio", "multiplayer"] }
```

## 🌍 **Multiplataforma**


A SevenX Engine funciona em **Windows, Linux, macOS e Android**!

```bash
# Compile para sua plataforma

cargo build --release

# Compile para Android

./build_scripts/build_android.sh

# Compile para todas as plataformas

./build_scripts/build_all_platforms.sh
```

Veja [PLATFORM_SUPPORT.md](PLATFORM_SUPPORT.md) para detalhes completos.

---

## 🚀 **Início Rápido**


### Jogo 2D Básico


```rust
use sevenx_engine::*;

struct MyGame {
    player_x: f32,
    player_y: f32,
    particles: ParticleSystem,
}

impl GameState for MyGame {
    fn new() -> Self {
        let mut particles = ParticleSystem::new();
        particles.config.lifetime = 1.0;
        particles.config.color_start = [100, 200, 255, 255];
        particles.config.color_end = [50, 100, 200, 0];
        
        Self { 
            player_x: 400.0, 
            player_y: 300.0,
            particles,
        }
    }

    fn update(&mut self, dt: f32, input: &InputHandler, _world: &mut World) {
        // Movimento com WASD ou setas
        let (axis_x, axis_y) = input.get_movement_vector();
        let speed = if input.is_shift_pressed() { 400.0 } else { 200.0 };
        
        self.player_x += axis_x * speed * dt;
        self.player_y += axis_y * speed * dt;
        
        // Emite partículas ao se mover
        if axis_x != 0.0 || axis_y != 0.0 {
            self.particles.emit(self.player_x, self.player_y, 5);
        }
        
        self.particles.update(dt);
    }

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

        // Desenha partículas
        self.particles.draw(pixels, 800, 600);

        // Desenha player
        let mut prims = Primitives2D::new(pixels, 800, 600);
        prims.draw_circle_filled(
            self.player_x as i32,
            self.player_y as i32,
            20,
            [100, 200, 255, 255]
        );
        
        // Desenha borda do player
        prims.draw_circle(
            self.player_x as i32,
            self.player_y as i32,
            20,
            [150, 220, 255, 255]
        );
    }
}

fn main() {
    let config = EngineConfig {
        window_title: "Meu Jogo 2D".to_string(),
        window_width: 800,
        window_height: 600,
        clear_color: [20, 25, 35, 255],
        ..Default::default()
    };
    
    Engine::with_config(config).run::<MyGame>();
}
```

### Jogo 3D com Skybox e LOD


```rust
use sevenx_engine::*;

struct My3DGame {
    renderer3d: Renderer3D,
    skybox: Skybox,
    meshes: Vec<LODMesh>,
    frustum: Frustum,
    time: f32,
}

impl GameState for My3DGame {
    fn new() -> Self {
        let mut renderer3d = Renderer3D::new(800, 600);
        renderer3d.camera.position = Vec3::new(0.0, 5.0, 15.0);
        renderer3d.camera.look_at(Vec3::zero());
        
        // Skybox com céu do dia
        let skybox = Skybox::day_sky();
        
        // Cria meshes com LOD
        let mut meshes = Vec::new();
        for i in 0..5 {
            let mut sphere = Mesh3D::sphere(1.5, 32);
            sphere.position = Vec3::new(i as f32 * 4.0 - 8.0, 0.0, 0.0);
            sphere.set_material(Material3D::metal());
            meshes.push(LODMesh::new(sphere));
        }
        
        let frustum = Frustum::from_camera(&renderer3d.camera, 800.0 / 600.0);
        
        Self { renderer3d, skybox, meshes, frustum, time: 0.0 }
    }

    fn update(&mut self, dt: f32, input: &InputHandler, _world: &mut World) {
        self.time += dt;
        
        // Controles da câmera
        let speed = 5.0;
        if input.is_key_down(KeyCode::KeyW) {
            self.renderer3d.camera.position = 
                self.renderer3d.camera.position + self.renderer3d.camera.get_forward() * speed * dt;
        }
        if input.is_key_down(KeyCode::KeyS) {
            self.renderer3d.camera.position = 
                self.renderer3d.camera.position - self.renderer3d.camera.get_forward() * speed * dt;
        }
        
        // Atualiza skybox
        self.skybox.update(dt);
        
        // Atualiza frustum culling
        self.frustum = Frustum::from_camera(&self.renderer3d.camera, 800.0 / 600.0);
        
        // Atualiza LOD das meshes
        for lod_mesh in &mut self.meshes {
            let mesh = lod_mesh.get_current_mesh();
            lod_mesh.update(self.renderer3d.camera.position, mesh.position);
            
            // Anima rotação
            let mut mesh_mut = lod_mesh.levels[lod_mesh.current_level].mesh.clone();
            mesh_mut.rotation.y = self.time;
        }
    }

    fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
        // Limpa com cor do skybox
        for pixel in pixels.chunks_exact_mut(4) {
            pixel.copy_from_slice(&[135, 206, 235, 255]);
        }
        
        self.renderer3d.clear_zbuffer();
        
        // Renderiza skybox (sempre primeiro)
        self.renderer3d.render_mesh(&self.skybox.mesh, pixels, 800, 600);
        
        // Renderiza meshes com frustum culling
        for lod_mesh in &self.meshes {
            let mesh = lod_mesh.get_current_mesh();
            let sphere = BoundingSphere::new(mesh.position, 2.0);
            
            // Só renderiza se estiver visível
            if self.frustum.contains_sphere(&sphere) {
                self.renderer3d.render_mesh(mesh, pixels, 800, 600);
            }
        }
    }
}

fn main() {
    let config = EngineConfig {
        window_title: "Meu Jogo 3D - v0.2.8".to_string(),
        window_width: 800,
        window_height: 600,
        clear_color: [135, 206, 235, 255],
        ..Default::default()
    };
    
    Engine::with_config(config).run::<My3DGame>();
}
```

---

## 📚 **Exemplos**


```bash
# Jogo teste básico

cargo run --example jogo_teste

# Showcase de input avançado

cargo run --example input_showcase

# Demo de shaders customizáveis

cargo run --example custom_shaders_demo

# Demo de UI avançada

cargo run --example ui_advanced_demo

# Demo de configurações gráficas

cargo run --example graphics_settings_demo

# Demo 3D avançado (LOD, Frustum Culling, Skybox)

cargo run --example advanced_3d_demo

# FPS 3D completo

cargo run --example fps_3d_game

# Plataforma 3D

cargo run --example platformer_3d

# Multiplayer 2D

cargo run --example multiplayer_demo

# Multiplayer com networking real (QUIC)

cargo run --example multiplayer_demo --features multiplayer

# Servidor dedicado

cargo run --example dedicated_server --features multiplayer

# Battle Royale (20 jogadores)

cargo run --example battle_royale --release
```

---

## 📖 **Documentação**


- 📘 [GUIDE.md](GUIDE.md) - Guia completo da engine
- 🎮 [GAME_TUTORIAL_V2.md](GAME_TUTORIAL_V2.md) - Tutorial de criação de jogos
- 🎲 [3D_API_GUIDE.md](3D_API_GUIDE.md) - Guia da API 3D
- 🎨 [PRIMITIVES_GUIDE.md](PRIMITIVES_GUIDE.md) - Guia de primitivas 2D/3D
- 🎨 [CUSTOM_SHADERS_GUIDE.md](CUSTOM_SHADERS_GUIDE.md) - Guia de shaders customizáveis
- 💡 [LIGHTING_GUIDE.md](LIGHTING_GUIDE.md) - Sistema de iluminação
- 🗺️ [PATHFINDING_GUIDE.md](PATHFINDING_GUIDE.md) - Pathfinding
- 🌐 [MULTIPLAYER_GUIDE.md](MULTIPLAYER_GUIDE.md) - Sistema de multiplayer
- 📚 [API_REFERENCE.md](API_REFERENCE.md) - Referência completa da API
- ❓ [FAQ.md](FAQ.md) - Perguntas frequentes

---

## 🎯 **Casos de Uso**


### Jogos 2D

- ✅ Platformers
- ✅ Top-down shooters
- ✅ Puzzle games
- ✅ RPGs
- ✅ Visual novels

### Jogos 3D

- ✅ FPS
- ✅ Plataformas 3D
- ✅ Puzzle 3D
- ✅ Aventura
- ✅ Corrida

### Ferramentas

- ✅ Editores de níveis
- ✅ Visualizadores
- ✅ Protótipos
- ✅ Demos técnicas

---

## 🏆 **Destaques**


- 🚀 **Performance**: Otimizado para PCs fracos (30 FPS garantido)
- 🎨 **Flexível**: Sistema de shaders customizáveis
- 📦 **Completo**: 2D + 3D em uma engine
- 🔧 **Fácil**: API simples e intuitiva
- 📚 **Documentado**: Guias completos e exemplos
- 🎮 **Pronto**: Exemplos de jogos completos incluídos

---

## 📊 **Estatísticas v0.2.8**


- **Plataformas**: 4 (Windows, Linux, macOS, Android)
- **Arquiteturas**: 4 (x86_64, ARM64, ARMv7, x86)
- **Primitivas 3D**: 14 (Ring, Star adicionados)
- **Shaders 3D**: 7
- **Primitivas 2D**: 20+
- **Widgets UI**: 6
- **Shaders Customizáveis**: 7 built-in + infinitos customizados
- **Níveis de Qualidade**: 5
- **Níveis de LOD**: 5 (Ultra, High, Medium, Low, VeryLow)
- **Métodos de Input**: 35+
- **Métodos de Mesh**: 28+ (8 novos avançados)
- **Sistemas 3D**: 8 (Frustum, LOD, Skybox, Physics, Octree, Terrain, Billboard, Mesh)
- **Exemplos**: 17+
- **Linhas de Código**: ~18,000+

---

## 🤝 **Contribuindo**


Contribuições são bem-vindas! Veja [CONTRIBUTING.md](CONTRIBUTING.md) para detalhes.

---

## 📝 **Licença**


Dual-licensed sob MIT ou Apache-2.0.

---

## 🔗 **Links**


- 📦 [Crates.io](https://crates.io/crates/sevenx_engine)
- 📚 [Documentação](https://docs.rs/sevenx_engine)
- 🐙 [GitHub](https://github.com/sevenx777-dev/SevenX-Engine)
- 💬 [Discord](https://discord.gg/sevenx-engine)

---

## 🎉 **Changelog v0.2.8**


### Adicionado

- 🚀 **Frustum Culling**: Sistema completo de culling com estatísticas
- 🌅 **Skybox**: Cubemap e procedural com 3 presets prontos
- 📊 **LOD System**: 5 níveis de detalhe automáticos
- 🔧 **8 Métodos Avançados de Mesh**: subdivide, smooth, mirror, extrude, noise, optimize, surface_area, volume
- 🎲 **2 Novas Primitivas 3D**: Ring e Star
- 📦 **Bounding Volumes**: BoundingBox e BoundingSphere
- 📈 **CullingStats**: Estatísticas em tempo real

### Melhorado

- ⚡ Performance 3D: Até 90% de economia com frustum culling
- 🎨 Qualidade visual: LOD automático baseado em distância
- 🔧 Manipulação de mesh: 8 novos métodos poderosos
- 📚 Documentação: Exemplos atualizados

### Corrigido

- 🐛 Bugs de renderização 3D
- 📝 Exemplos do README atualizados

---

**SevenX Engine v0.2.8** - Crie jogos incríveis em Rust! 🎮✨🚀

*Feito com ❤️ por Rian7x*