🎮 SevenX Engine v0.2.9

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

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

# 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

[dependencies]
sevenx_engine = "0.2.8"

Com áudio:

[dependencies]
sevenx_engine = { version = "0.2.8", features = ["audio"] }

Com multiplayer (networking real):

[dependencies]
sevenx_engine = { version = "0.2.8", features = ["multiplayer"] }

Tudo junto:

[dependencies]
sevenx_engine = { version = "0.2.8", features = ["audio", "multiplayer"] }

🌍 Multiplataforma

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

# 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 para detalhes completos.

---

🚀 Início Rápido

Jogo 2D Básico

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

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

# 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 - Guia completo da engine
• 🎮 GAME_TUTORIAL_V2.md - Tutorial de criação de jogos
• 🎲 3D_API_GUIDE.md - Guia da API 3D
• 🎨 PRIMITIVES_GUIDE.md - Guia de primitivas 2D/3D
• 🎨 CUSTOM_SHADERS_GUIDE.md - Guia de shaders customizáveis
• 💡 LIGHTING_GUIDE.md - Sistema de iluminação
• 🗺️ PATHFINDING_GUIDE.md - Pathfinding
• 🌐 MULTIPLAYER_GUIDE.md - Sistema de multiplayer
• 📚 API_REFERENCE.md - Referência completa da API
• ❓ 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 para detalhes.

---

📝 Licença

Dual-licensed sob MIT ou Apache-2.0.

---

🔗 Links

• 📦 Crates.io
• 📚 Documentação
• 🐙 GitHub
• 💬 Discord

---

🎉 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