sevenx_engine 0.2.11

Engine de jogos 2D/3D completa com suporte Android, física, áudio, partículas, tilemap, UI, eventos e sistema 3D avançado com PBR.
Documentation

🎮 SevenX Engine v0.2.9

Crates.io License Rust Android

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

🎯 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

🎉 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