# ❓ FAQ - Perguntas Frequentes
## 🚀 Começando
### Como instalo a SevenX Engine?
```bash
cargo new meu_jogo
cd meu_jogo
```
Adicione ao `Cargo.toml`:
```toml
[dependencies]
sevenx_engine = "0.2.9"
# Com áudio
sevenx_engine = { version = "0.2.9", features = ["audio"] }
# Com multiplayer
sevenx_engine = { version = "0.2.9", features = ["multiplayer"] }
# Tudo junto
sevenx_engine = { version = "0.2.9", features = ["audio", "multiplayer"] }
```
### Qual é o código mínimo para começar?
```rust
use sevenx_engine::*;
struct MeuJogo;
impl GameState for MeuJogo {
fn new() -> Self { MeuJogo }
fn update(&mut self, dt: f32, input: &InputHandler, world: &mut World) {}
fn draw(&mut self, _world: &World, _pixels: &mut [u8]) {}
}
fn main() {
Engine::new().run::<MeuJogo>();
}
```
**Não esqueça os imports!**
---
## 🐛 Erros Comuns
### ❌ "cannot find type `InputHandler` in this scope"
**Problema**: Faltam imports
**Solução**:
```rust
use sevenx_engine::{
input::InputHandler,
world::World,
Engine, EngineConfig, GameState, KeyCode,
};
```
### ❌ "cannot find type `World` in this scope"
**Problema**: Mesmo que acima
**Solução**: Adicione `world::World` aos imports
### ❌ "method `is_key_pressed` not found"
**Problema**: `input` não é do tipo correto
**Solução**: Verifique a assinatura do método `update`:
```rust
fn update(&mut self, dt: f32, input: &InputHandler, world: &mut World)
```
### ❌ Nada aparece na tela (TELA PRETA)
**Problema mais comum**: O método `draw` não está desenhando nada!
**Solução**: Você PRECISA desenhar no método `draw`:
```rust
fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
// DESENHE ALGO AQUI!
ui::render_rect(100, 100, 50, 50, [255, 0, 0, 255], pixels, 800);
ui::render_text("HELLO", 100, 100, [255, 255, 255, 255], pixels, 800);
}
```
**Outras causas**:
1. **Objetos não adicionados ao mundo**
```rust
let player = GameObject::new(100.0, 100.0, ObjectType::Player);
let player = GameObject::new(100.0, 100.0, ObjectType::Player);
world.add_object(player);
```
2. **Sprite não adicionado**
```rust
player.sheets.insert(PlayerAction::Idle, SpriteSheet::create_placeholder());
```
3. **Objeto inativo**
```rust
player.active = true;
```
4. **Esqueceu de importar ui**
```rust
use sevenx_engine::ui::{self, render_text};
```
### ❌ "failed to load assets/player.png"
**Problema**: Arquivo não existe
**Soluções**:
1. Crie a pasta `assets/` no seu projeto
2. Adicione a imagem
3. Ou use placeholder:
```rust
let sprite = SpriteSheet::create_placeholder();
```
---
## 🎮 Gameplay
### Como faço o jogador se mover?
```rust
fn update(&mut self, dt: f32, input: &InputHandler, world: &mut World) {
let speed = 200.0;
if input.is_key_pressed(KeyCode::ArrowLeft) {
self.player_x -= speed * dt;
}
if input.is_key_pressed(KeyCode::ArrowRight) {
self.player_x += speed * dt;
}
}
```
### Como desenho na tela?
```rust
use sevenx_engine::ui;
fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
// Retângulo
ui::render_rect(100, 100, 50, 50, [255, 0, 0, 255], pixels, 800);
// Texto
ui::render_text("HELLO", 100, 100, [255, 255, 255, 255], pixels, 800);
}
```
### Como detecto colisões?
```rust
use sevenx_engine::collision::Rect;
let rect1 = Rect::new(x1, y1, w1, h1);
let rect2 = Rect::new(x2, y2, w2, h2);
if rect1.intersects(&rect2) {
println!("Colisão!");
}
```
### Como adiciono física?
```rust
use sevenx_engine::Physics;
let player = GameObject::new(100.0, 100.0, ObjectType::Player)
.with_physics(Physics::new()
.with_gravity(1.0)
.with_drag(0.1));
```
### Como faço um pulo?
```rust
if input.is_key_pressed(KeyCode::Space) {
if let Some(physics) = &mut player.physics {
physics.velocity.1 = -400.0; // Força para cima
}
}
```
---
## 🎨 Gráficos
### Como carrego sprites?
```rust
use sevenx_engine::sprite::SpriteSheet;
// De arquivo
let sprite = SpriteSheet::load("assets/player.png", 32, 32)?;
// Placeholder (sem arquivo)
let sprite = SpriteSheet::create_placeholder();
```
### Como roto sprites?
```rust
// Em radianos
obj.transform.rotation = 1.57;
// Em graus
obj.transform.set_rotation_degrees(90.0);
// Rotar gradualmente
obj.transform.rotate(0.1 * dt);
```
### Como espelho sprites?
```rust
// Flip horizontal
obj.transform.flip_h = true;
// Flip vertical
obj.transform.flip_v = true;
```
### Como crio partículas?
```rust
use sevenx_engine::{ParticleSystem, ParticleConfig};
let mut particles = ParticleSystem::new(500);
// Explosão
let config = ParticleConfig::explosion();
particles.emit_burst(x, y, 50, config);
// No update
particles.update(dt, world.gravity);
// No draw
particles.render(pixels, 0.0, 0.0, 800, 600);
```
---
## 💾 Save/Load
### Como salvo o progresso?
```rust
use sevenx_engine::save_system::GameSave;
let mut save = GameSave::new();
save.player_data.level = 5;
save.game_progress.score = 1000;
save.save_json("saves/save1.json")?;
```
### Como carrego o progresso?
```rust
let save = GameSave::load_json("saves/save1.json")?;
println!("Level: {}", save.player_data.level);
```
---
## � Shaderms e Partículas (v0.2.6)
### Como uso os novos shaders?
```rust
use sevenx_engine::{Shader, ShaderManager, ShaderType};
// No new()
let mut shader_manager = ShaderManager::new();
shader_manager.add_shader(
Shader::new(ShaderType::Bloom)
.with_parameter("threshold", 200.0)
.with_parameter("bloom_intensity", 1.5)
);
// No draw()
shader_manager.apply_all(pixels, 800, 600);
```
### Quais são os melhores shaders para cada efeito?
- **Fogo/Magia**: `Bloom` + `HueShift`
- **Velocidade**: `MotionBlur`
- **Retro**: `CRT` ou `Scanlines`
- **Artístico**: `OilPainting` ou `Posterize`
- **Glitch/Cyberpunk**: `Glitch` + `ChromaticAberration`
- **Atmosfera**: `Vignette` + `Saturation`
### Como faço partículas com turbulência?
```rust
use sevenx_engine::Particle;
let particle = Particle::new(x, y, vx, vy, 2.0, color, 5.0)
.with_turbulence(10.0) // Movimento caótico
.with_color_shift([-100.0, 50.0, 100.0, 0.0]) // Muda de cor
.with_acceleration(0.0, 50.0); // Acelera para baixo
particle_system.emit(particle);
```
### Como faço partículas 3D?
```rust
use sevenx_engine::{ParticleSystem3D, Vec3};
let mut particles_3d = ParticleSystem3D::new(500);
// Explosão
particles_3d.explosion(Vec3::new(0.0, 0.0, 0.0));
// Fogo
particles_3d.fire(Vec3::new(0.0, 0.0, 0.0));
// Magia
particles_3d.magic(Vec3::new(0.0, 2.0, 0.0));
// Atualizar
particles_3d.update(dt);
```
### Posso combinar múltiplos shaders?
Sim! Os shaders são aplicados em sequência:
```rust
shader_manager.add_shader(Shader::new(ShaderType::Bloom)...);
shader_manager.add_shader(Shader::new(ShaderType::HueShift)...);
shader_manager.add_shader(Shader::new(ShaderType::Vignette)...);
// Aplica: Bloom → HueShift → Vignette
shader_manager.apply_all(pixels, 800, 600);
```
### Como faço um efeito de rastro de partículas?
```rust
// No update, quando o jogador se move
if player_moved {
use rand::Rng;
let mut rng = rand::thread_rng();
for _ in 0..3 {
let particle = Particle::new(
player_x,
player_y,
rng.gen_range(-20.0..20.0),
rng.gen_range(-20.0..20.0),
0.5,
[100, 200, 255, 200],
4.0,
)
.with_scale(1.0, -0.5); // Encolhe rapidamente
particle_system.emit(particle);
}
}
```
---
## 🎯 Performance
### Meu jogo está lento, o que faço?
1. **Use Z-index** para ordenar renderização
2. **Desative objetos** em vez de remover
```rust
obj.active = false;
world.cleanup_inactive(); ```
3. **Use ResourceManager** para cache
```rust
resources.load_sprite_sheet("player", "assets/player.png", 32, 32)?;
```
4. **Limite partículas**
```rust
let particles = ParticleSystem::new(500); ```
5. **Limite shaders simultâneos**
```rust
```
### Quantas partículas posso ter?
**Recomendações para 60 FPS:**
- **Partículas 2D**: 500-1000
- **Partículas 3D**: 200-500
- **Com Bloom ativo**: Reduza 30%
### Quais shaders são mais pesados?
**Pesados** (use com moderação):
- `Bloom`
- `GaussianBlur`
- `OilPainting`
- `MotionBlur` (com muitos samples)
**Leves** (use à vontade):
- `Grayscale`
- `Sepia`
- `Invert`
- `HueShift`
- `Saturation`
- `Brightness`
- `Contrast`
### Como verifico o FPS?
```rust
fn update(&mut self, dt: f32, input: &InputHandler, world: &mut World) {
let fps = 1.0 / dt;
println!("FPS: {:.0}", fps);
}
```
---
## 🔧 Configuração
### Como mudo o tamanho da janela?
```rust
let config = EngineConfig::new()
.with_size(1024, 768);
Engine::with_config(config).run::<MeuJogo>();
```
### Como mudo o título?
```rust
let config = EngineConfig::new()
.with_title("Meu Jogo Incrível");
```
### Como mudo a cor de fundo?
```rust
let config = EngineConfig::new()
.with_clear_color(20, 20, 40, 255); // RGBA
```
### Como desativo a gravidade?
```rust
let config = EngineConfig::new()
.with_gravity(0.0);
```
---
## 🎮 Input
### Quais teclas posso usar?
```rust
// Setas
KeyCode::ArrowUp, ArrowDown, ArrowLeft, ArrowRight
// Letras
KeyCode::KeyA, KeyB, KeyC... KeyZ
// Números
KeyCode::Digit1, Digit2... Digit9, Digit0
// Especiais
KeyCode::Space
KeyCode::Enter
KeyCode::Escape
KeyCode::Tab
KeyCode::Backspace
```
### Como uso gamepad?
```rust
use sevenx_engine::{GamepadManager, GamepadButton, GamepadAxis};
let gamepad = GamepadManager::new();
// Botões
if gamepad.is_button_pressed(GamepadButton::South) {
println!("A/Cross pressionado!");
}
// Eixos
let axis_x = gamepad.get_axis(GamepadAxis::LeftStickX);
player_x += axis_x * speed * dt;
```
---
## 📚 Recursos
### Onde encontro exemplos?
```bash
# Clone o repositório
git clone https://github.com/sevenx777-dev/SevenX-Engine.git
cd SevenX-Engine
# Execute exemplos
cargo run --example jogo_teste
cargo run --example physics_demo
cargo run --example particles_demo
```
### Onde encontro assets gratuitos?
- **OpenGameArt.org** - https://opengameart.org/
- **Kenney.nl** - https://kenney.nl/assets
- **Itch.io** - https://itch.io/game-assets/free
### Onde peço ajuda?
- **GitHub Issues**: https://github.com/sevenx777-dev/SevenX-Engine/issues
- **Discussions**: https://github.com/sevenx777-dev/SevenX-Engine/discussions
---
## 🎓 Aprendizado
### Sou iniciante, por onde começo?
1. Leia **API_REFERENCE.md** - Referência rápida
2. Siga **GAME_TUTORIAL.md** - Tutoriais passo a passo
3. Execute os exemplos
4. Modifique os exemplos
5. Crie seu próprio jogo!
### Qual a ordem de aprendizado?
1. **Básico**: Movimento e input
2. **Gráficos**: Desenhar na tela
3. **Colisões**: Detectar interações
4. **Física**: Gravidade e movimento
5. **Efeitos**: Partículas e shaders (v0.2.6)
6. **Avançado**: Diálogos, save/load, networking
7. **3D**: Renderização 3D experimental (v0.2.6)
### Onde está a documentação completa?
- **API_REFERENCE.md** - Referência rápida ⭐ COMECE AQUI
- **GUIDE.md** - Guia detalhado
- **GAME_TUTORIAL.md** - Tutoriais de jogos
- **ASSETS_GUIDE.md** - Como usar assets
- **PATTERNS.md** - Padrões de design
- **FAQ.md** - Este arquivo
---
## 💡 Dicas
### Use o template!
Copie o template de **API_REFERENCE.md** e comece a modificar!
### Teste frequentemente
```bash
cargo run
```
### Use println! para debug
```rust
println!("Player X: {}", player_x);
println!("FPS: {:.0}", 1.0 / dt);
```
### Comece simples
Não tente fazer tudo de uma vez. Comece com:
1. Movimento básico
2. Desenhar na tela
3. Adicione features gradualmente
---
## � ARecursos Avançados (v0.2.6)
### Como uso iluminação 3D?
```rust
use sevenx_engine::{PhongShader, Light3D, Material, Vec3};
let mut phong = PhongShader::new();
phong.add_light(Light3D::new(
Vec3::new(5.0, 10.0, 5.0),
[1.0, 1.0, 1.0],
1.5
));
let material = Material::metal();
let color = phong.calculate_lighting(&pos, &normal, &view_dir, &material, base_color);
```
### Como faço efeito de neblina (fog)?
```rust
use sevenx_engine::FogShader;
let mut fog = FogShader::new();
fog.fog_start = 10.0;
fog.fog_end = 50.0;
fog.fog_density = 0.05;
let color = fog.apply(base_color, distance);
```
### Como faço cel shading (toon)?
```rust
use sevenx_engine::ToonShader;
let toon = ToonShader::new(4) // 4 níveis de cor
.with_outline(0.1, [0, 0, 0, 255]);
let color = toon.apply(base_color, light_intensity);
```
### Como faço rim lighting (fresnel)?
```rust
use sevenx_engine::FresnelShader;
let fresnel = FresnelShader::new();
let color = fresnel.calculate(&normal, &view_dir, base_color);
```
### Posso misturar partículas 2D e 3D?
Sim! Use ambos os sistemas:
```rust
// 2D para UI e efeitos de tela
let mut particles_2d = ParticleSystem::new(1000);
// 3D para efeitos no mundo 3D
let mut particles_3d = ParticleSystem3D::new(500);
// No update
particles_2d.update(dt, 200.0);
particles_3d.update(dt);
// No draw
particles_2d.render(pixels, 0.0, 0.0, 800, 600);
// Renderize partículas 3D como parte do mundo 3D
```
### Como otimizo shaders pesados?
1. **Use intensity menor**
```rust
Shader::new(ShaderType::Bloom).with_intensity(0.5)
```
2. **Reduza parâmetros**
```rust
.with_parameter("samples", 3.0) ```
3. **Aplique condicionalmente**
```rust
if show_effects {
shader_manager.apply_all(pixels, 800, 600);
}
```
4. **Use shaders leves primeiro**
```rust
shader_manager.add_shader(Shader::new(ShaderType::HueShift)...);
shader_manager.add_shader(Shader::new(ShaderType::Bloom)...);
```
### Exemplos atualizados com novos recursos?
Sim! Veja:
- `examples/particles_2d_advanced.rs` - Partículas 2D avançadas
- `examples/3d_demo.rs` - 3D com partículas e shaders
- `examples/advanced_features_demo.rs` - Todos os recursos
- `examples/shader_particles_showcase.rs` - Showcase completo
---
---
## 📱 Suporte Android (v0.2.9 - NOVO!)
### Como compilo para Android?
```bash
# Instale cargo-ndk
cargo install cargo-ndk
# Adicione targets Android
rustup target add aarch64-linux-android
rustup target add armv7-linux-androideabi
# Compile
cargo ndk -t arm64-v8a build --release --example android_complete
# Instale no dispositivo
adb install target/aarch64-linux-android/release/examples/android_complete.apk
```
### Como uso Touch Input?
```rust
use sevenx_engine::AndroidManager;
// No new()
let mut android = AndroidManager::new();
android.enable_touch();
// No update
android.update();
// Verificar toques
let touches = android.get_touches();
for touch in touches {
println!("Touch ID: {} at ({}, {})", touch.id, touch.x, touch.y);
println!("Pressure: {}", touch.pressure);
}
// Toque simples
if let Some(touch) = android.get_primary_touch() {
player_x = touch.x;
player_y = touch.y;
}
```
### Como uso Joystick Virtual?
```rust
// Habilitar joystick
android.enable_virtual_joystick(
100.0, // X
500.0, // Y
80.0 // Raio
);
// No update
let (jx, jy) = android.get_joystick_axis();
player_x += jx * speed * dt;
player_y += jy * speed * dt;
// Verificar se está sendo usado
if android.is_joystick_active() {
println!("Joystick ativo!");
}
```
### Como uso Sensores (Acelerômetro/Giroscópio)?
```rust
// Habilitar sensores
android.enable_sensors();
// Acelerômetro (inclinação do dispositivo)
let (ax, ay, az) = android.get_accelerometer();
player_x += ax * sensitivity * dt;
// Giroscópio (rotação)
let (gx, gy, gz) = android.get_gyroscope();
camera_rotation += gy * dt;
```
### Como uso Vibração?
```rust
// Vibração simples
android.vibrate(100); // 100ms
// Intensidades pré-definidas
android.vibrate_light(); // Leve
android.vibrate_medium(); // Média
android.vibrate_strong(); // Forte
// Padrão customizado
use sevenx_engine::VibrationPattern;
let pattern = VibrationPattern::new()
.vibrate(100)
.pause(50)
.vibrate(200)
.repeat(2);
android.vibrate_pattern(pattern);
// Cancelar
android.cancel_vibration();
```
### Como detecto Gestos?
```rust
use sevenx_engine::GestureType;
// No update
if let Some(gesture) = android.get_last_gesture() {
match gesture {
GestureType::Tap(x, y) => {
println!("Tap em ({}, {})", x, y);
}
GestureType::DoubleTap(x, y) => {
println!("Double tap!");
}
GestureType::LongPress(x, y) => {
println!("Long press!");
}
GestureType::Swipe(dir) => {
println!("Swipe: {:?}", dir);
}
GestureType::Pinch(scale) => {
camera_zoom *= scale;
}
GestureType::Rotate(angle) => {
object_rotation += angle;
}
}
}
```
### Como monitoro Bateria?
```rust
// Nível de bateria (0-100)
let level = android.get_battery_level();
println!("Bateria: {}%", level);
// Status de carregamento
if android.is_charging() {
println!("Carregando...");
}
// Temperatura
let temp = android.get_battery_temperature();
if temp > 40.0 {
println!("Dispositivo quente!");
}
```
### Como otimizo Performance no Android?
```rust
// Configurar FPS adaptativo
android.set_target_fps(60);
// Habilitar thermal throttling
android.enable_thermal_management();
// Verificar se está superaquecendo
if android.is_overheating() {
// Reduzir qualidade gráfica
android.set_target_fps(30);
}
// Estatísticas
let stats = android.get_performance_stats();
println!("FPS: {:.1}", stats.current_fps);
println!("Frame time: {:.2}ms", stats.frame_time_ms);
```
### Como uso Notificações?
```rust
// Notificação simples
android.show_notification(
"Título",
"Mensagem",
"icon"
);
// Notificação agendada
android.schedule_notification(
"Lembrete",
"Volte a jogar!",
"icon",
3600 // 1 hora
);
// Cancelar notificação
android.cancel_notification(notification_id);
```
### Como verifico Conectividade?
```rust
use sevenx_engine::ConnectionType;
// Tipo de conexão
match android.get_connection_type() {
ConnectionType::WiFi => println!("WiFi conectado"),
ConnectionType::Mobile => println!("Dados móveis"),
ConnectionType::Ethernet => println!("Ethernet"),
ConnectionType::None => println!("Sem conexão"),
}
// Verificar se está online
if android.is_online() {
// Fazer download, etc
}
```
### Como salvo dados no Android?
```rust
// Salvar
let data = serde_json::to_string(&game_state)?;
android.save_data("save.json", &data)?;
// Carregar
if let Ok(data) = android.load_data("save.json") {
let game_state: GameState = serde_json::from_str(&data)?;
}
// Listar arquivos
let files = android.list_files()?;
for file in files {
println!("Arquivo: {}", file);
}
```
### Exemplo Completo Android
```rust
use sevenx_engine::*;
struct MeuJogoMobile {
android: AndroidManager,
player_x: f32,
player_y: f32,
}
impl GameState for MeuJogoMobile {
fn new() -> Self {
let mut android = AndroidManager::new();
android.enable_touch();
android.enable_virtual_joystick(100.0, 500.0, 80.0);
android.enable_sensors();
Self {
android,
player_x: 400.0,
player_y: 300.0,
}
}
fn update(&mut self, dt: f32, _input: &InputHandler, _world: &mut World) {
self.android.update();
// Joystick virtual
let (jx, jy) = self.android.get_joystick_axis();
self.player_x += jx * 200.0 * dt;
self.player_y += jy * 200.0 * dt;
// Gestos
if let Some(GestureType::Tap(x, y)) = self.android.get_last_gesture() {
println!("Tap em ({}, {})", x, y);
self.android.vibrate_light();
}
// Bateria
if self.android.get_battery_level() < 20 {
println!("Bateria baixa!");
}
}
fn draw(&mut self, _world: &World, pixels: &mut [u8]) {
// Desenhar jogador
ui::render_rect(
self.player_x as i32,
self.player_y as i32,
32, 32,
[0, 255, 0, 255],
pixels,
800
);
// Desenhar joystick
self.android.draw_virtual_joystick(pixels, 800);
}
}
```
---
## 🚀 Recursos 3D Avançados (v0.2.8)
### Como uso Frustum Culling?
```rust
use sevenx_engine::{Frustum, BoundingSphere, Camera3D};
// Cria frustum da câmera
let frustum = Frustum::from_camera(&camera, 800.0 / 600.0);
// Testa se objeto está visível
let sphere = BoundingSphere::new(mesh.position, 2.0);
if frustum.contains_sphere(&sphere) {
// Renderiza apenas se visível
renderer.render_mesh(&mesh, pixels, 800, 600);
}
```
### Como uso LOD (Level of Detail)?
```rust
use sevenx_engine::{LODMesh, Mesh3D};
// Cria mesh com LOD automático
let base_mesh = Mesh3D::sphere(2.0, 32);
let mut lod_mesh = LODMesh::new(base_mesh);
// No update, atualiza LOD baseado na distância
lod_mesh.update(camera.position, object_position);
// Pega mesh otimizada
let mesh = lod_mesh.get_current_mesh();
```
### Como crio um Skybox?
```rust
use sevenx_engine::Skybox;
// Presets prontos
let skybox = Skybox::day_sky(); // Céu de dia
let skybox = Skybox::night_sky(); // Céu de noite
let skybox = Skybox::sunset_sky(); // Pôr do sol
// Com rotação
let mut skybox = Skybox::day_sky();
skybox.set_rotation_speed(0.1);
// No update
skybox.update(dt);
```
### Como uso Física 3D?
```rust
use sevenx_engine::{Physics3D, RigidBody3D, Collider3D, Vec3};
let mut physics = Physics3D::new();
// Adiciona corpo dinâmico (cai com gravidade)
let body = RigidBody3D::dynamic(Vec3::new(0.0, 10.0, 0.0), 1.0);
let collider = Collider3D::sphere(1.0);
let id = physics.add_body(body, collider);
// Adiciona chão estático
let ground = RigidBody3D::static_body(Vec3::new(0.0, -1.0, 0.0));
let ground_collider = Collider3D::box_collider(Vec3::new(50.0, 1.0, 50.0));
physics.add_body(ground, ground_collider);
// No update
physics.update(dt);
// Aplica força
physics.bodies[id].apply_force(Vec3::new(0.0, 100.0, 0.0));
```
### Como faço Raycast 3D?
```rust
// Raycast para detectar objetos
let ray_origin = camera.position;
let ray_direction = camera.get_forward();
if let Some(hit) = physics.raycast(ray_origin, ray_direction, 100.0) {
println!("Hit at: {:?}", hit.point);
println!("Distance: {:.2}", hit.distance);
println!("Normal: {:?}", hit.normal);
}
```
### Como uso Octree para otimização?
```rust
use sevenx_engine::{Octree, BoundingBox, Vec3};
// Cria octree
let bounds = BoundingBox::new(
Vec3::new(-50.0, -50.0, -50.0),
Vec3::new(50.0, 50.0, 50.0)
);
let mut octree = Octree::new(bounds, 4, 8);
// Insere objetos
for i in 0..1000 {
octree.insert(position, object_id);
}
// Busca objetos em área
let query_bounds = BoundingBox::new(min, max);
let nearby = octree.query_range(&query_bounds);
// Busca objetos em esfera
let nearby = octree.query_sphere(center, radius);
```
### Como crio Terreno Procedural?
```rust
use sevenx_engine::{Terrain, TerrainConfig};
// Presets prontos
let terrain = Terrain::flat(50, 50);
let terrain = Terrain::hills(50, 50, 15.0);
let terrain = Terrain::mountains(100, 100, 30.0);
// Customizado
let config = TerrainConfig {
width: 100,
depth: 100,
height_scale: 20.0,
octaves: 6,
persistence: 0.5,
lacunarity: 2.0,
seed: 42,
};
let terrain = Terrain::new(config);
// Pega altura em posição
let height = terrain.get_height_at(x, z);
// Suaviza terreno
terrain.smooth(3);
```
### Como uso Billboards (sprites 3D)?
```rust
use sevenx_engine::{Billboard, BillboardBatch, BillboardType};
let mut billboards = BillboardBatch::new();
// Billboard esférico (sempre olha para câmera)
billboards.add(
Billboard::spherical(Vec3::new(0.0, 5.0, 0.0), 2.0, 4.0)
.with_color([50, 150, 50, 255])
);
// Billboard cilíndrico (só rotaciona em Y - árvores)
billboards.add(
Billboard::cylindrical(Vec3::new(5.0, 0.0, 0.0), 2.0, 4.0)
.with_texture("tree.png".to_string())
);
// Ordena por distância (para alpha blending)
billboards.sort_by_distance(camera.position);
// Converte para meshes
let meshes = billboards.to_meshes(&camera);
```
### Como manipulo meshes avançadamente?
```rust
use sevenx_engine::{Mesh3D, MirrorAxis};
let mut mesh = Mesh3D::sphere(2.0, 16);
// Subdivide para mais detalhes
mesh.subdivide();
// Suaviza normais (smooth shading)
mesh.smooth();
// Espelha mesh
let mirrored = mesh.mirror(MirrorAxis::X);
// Extrude faces
mesh.extrude(0.5);
// Adiciona ruído (terrenos procedurais)
mesh.apply_noise(1.0, 0.5);
// Otimiza removendo vértices duplicados
mesh.optimize();
// Calcula propriedades
let area = mesh.surface_area();
let volume = mesh.volume();
```
### Quantos objetos 3D posso ter?
**Com Frustum Culling e LOD (v0.2.8):**
- **Sem otimização**: 100-200 objetos
- **Com Frustum Culling**: 500-1000 objetos (90% podem ser culled)
- **Com LOD**: 1000-2000 objetos (distantes usam menos polígonos)
- **Com Octree**: 5000+ objetos (busca espacial rápida)
**Dica**: Combine todas as otimizações!
```rust
// Setup
let frustum = Frustum::from_camera(&camera, aspect);
let mut octree = Octree::new(bounds, 4, 8);
let mut lod_meshes = vec![];
// No update
for lod_mesh in &mut lod_meshes {
lod_mesh.update(camera.position, mesh.position);
}
// No draw
let nearby = octree.query_sphere(camera.position, 100.0);
for id in nearby {
let mesh = lod_meshes[*id].get_current_mesh();
let sphere = BoundingSphere::new(mesh.position, 2.0);
if frustum.contains_sphere(&sphere) {
renderer.render_mesh(mesh, pixels, 800, 600);
}
}
```
### Como vejo estatísticas de otimização?
```rust
use sevenx_engine::{CullingStats, LODStats};
// Frustum Culling Stats
let stats = CullingStats::new(total_objects, visible_objects);
println!("Culled: {}%", stats.culling_percentage);
// LOD Stats
let lod_stats = lod_mesh.get_stats();
println!("Level: {}", lod_stats.current_level);
println!("Vertices: {}", lod_stats.vertex_count);
println!("Quality: {:?}", lod_stats.current_quality);
// Octree Stats
let octree_stats = octree.get_stats();
println!("Nodes: {}", octree_stats.total_nodes);
println!("Objects: {}", octree_stats.total_objects);
println!("Avg/Node: {:.2}", octree_stats.average_objects_per_node);
```
---
## 🆘 Ainda com problemas?
1. Verifique os **exemplos** incluídos
2. Leia **API_REFERENCE.md**
3. Consulte **3D_GUIDE.md** para recursos 3D
4. Veja **complete_3d_showcase.rs** para exemplo completo
5. Abra uma **issue** no GitHub
6. Pergunte nas **Discussions**
**Boa sorte criando seus jogos! 🚀🎨✨**