Implementar sistema delta time independiente del framerate
- Migrar de fisica frame-based (60 FPS fijo) a time-based - Convertir velocidades: x60 multiplicador (pixeles/frame → pixeles/segundo) - Convertir gravedad: x3600 multiplicador (pixeles/frame² → pixeles/segundo²) - Añadir calculateDeltaTime() con limitador de saltos grandes - Actualizar Ball::update() para recibir deltaTime como parametro - Implementar debug display con valores de fisica en tiempo real - Documentar proceso completo de migracion en README.md - Conseguir velocidad consistente entre diferentes refresh rates - V-Sync independiente: misma velocidad con V-Sync ON/OFF 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
146
README.md
146
README.md
@@ -103,50 +103,154 @@ make
|
||||
|
||||
### Configuracion Actual
|
||||
- **Resolucion**: 320x240 pixeles (escalado x3 = 960x720)
|
||||
- **FPS objetivo**: 60 FPS (16.67ms por frame)
|
||||
- **Sistema de timing**: Delta time independiente del framerate
|
||||
- **Fisica**: Gravedad constante (0.2f), rebotes con perdida de energia
|
||||
- **Tamaño de pelota**: 10x10 pixeles
|
||||
- **V-Sync**: Activado por defecto, controlable dinamicamente
|
||||
|
||||
### Arquitectura del Codigo
|
||||
|
||||
1. **main.cpp**: Contiene el bucle principal con tres fases:
|
||||
- `update()`: Actualiza la logica del juego + calculo FPS
|
||||
1. **main.cpp**: Contiene el bucle principal con cuatro fases:
|
||||
- `calculateDeltaTime()`: Calcula tiempo transcurrido entre frames
|
||||
- `update()`: Actualiza la logica del juego usando delta time + calculo FPS
|
||||
- `checkEvents()`: Procesa eventos de entrada
|
||||
- `render()`: Renderiza la escena + overlays informativos
|
||||
|
||||
2. **Ball**: Maneja la fisica de cada pelota individual
|
||||
2. **Ball**: Maneja la fisica de cada pelota individual con timing basado en delta time
|
||||
3. **Sprite**: Sistema de renderizado de texturas con filtro nearest neighbor
|
||||
4. **Texture**: Gestion de carga y renderizado de imagenes con filtro pixel-perfect
|
||||
|
||||
### Problema Actual: FPS Dependiente
|
||||
## ✅ Migracion a Delta Time (COMPLETADO)
|
||||
|
||||
El sistema actual usa un **bucle acoplado** donde la logica y renderizado estan sincronizados a 60 FPS fijos:
|
||||
### Sistema Anterior (Frame-Based)
|
||||
|
||||
El sistema original estaba **acoplado a 60 FPS** con logica dependiente del framerate:
|
||||
|
||||
```cpp
|
||||
// En update() - linea 236
|
||||
if (SDL_GetTicks() - ticks > DEMO_SPEED) { // DEMO_SPEED = 1000/60
|
||||
// Solo aqui se actualiza la fisica
|
||||
// Sistema ANTIGUO en update()
|
||||
if (SDL_GetTicks() - ticks > DEMO_SPEED) { // DEMO_SPEED = 1000/60 = 16.67ms
|
||||
// Solo aqui se actualizaba la fisica cada 16.67ms
|
||||
for (auto &ball : balls) {
|
||||
ball->update(); // Sin parametros de tiempo
|
||||
}
|
||||
ticks = SDL_GetTicks();
|
||||
}
|
||||
```
|
||||
|
||||
## 🚧 Mejoras Planificadas
|
||||
**Problemas del sistema anterior:**
|
||||
- Velocidad inconsistente entre diferentes refresh rates (60Hz vs 75Hz vs 144Hz)
|
||||
- Logica de fisica acoplada a framerate fijo
|
||||
- V-Sync ON/OFF cambiaba la velocidad del juego
|
||||
- Rendimiento inconsistente en diferentes hardware
|
||||
|
||||
### Implementacion de Delta Time
|
||||
### Sistema Actual (Delta Time)
|
||||
|
||||
**Objetivo**: Separar el bucle de proceso del de renderizado usando delta time para conseguir:
|
||||
**Implementacion delta time** para simulacion independiente del framerate:
|
||||
|
||||
- **Simulacion independiente del framerate**
|
||||
- **Mejor rendimiento** en escenarios de alta carga
|
||||
- **Consistencia** en diferentes dispositivos
|
||||
- **Preparacion para optimizaciones futuras**
|
||||
```cpp
|
||||
// Sistema NUEVO - Variables globales
|
||||
Uint64 last_frame_time = 0;
|
||||
float delta_time = 0.0f;
|
||||
|
||||
### Cambios Previstos
|
||||
// Calculo de delta time
|
||||
void calculateDeltaTime() {
|
||||
Uint64 current_time = SDL_GetTicks();
|
||||
if (last_frame_time == 0) {
|
||||
last_frame_time = current_time;
|
||||
delta_time = 1.0f / 60.0f; // Primer frame a 60 FPS
|
||||
return;
|
||||
}
|
||||
|
||||
1. **Sistema de timing basado en delta time**
|
||||
2. **Bucle de juego desacoplado** (logica vs renderizado)
|
||||
3. **Interpolacion** para renderizado suave
|
||||
4. **Optimizaciones de rendimiento**
|
||||
delta_time = (current_time - last_frame_time) / 1000.0f; // Convertir a segundos
|
||||
last_frame_time = current_time;
|
||||
|
||||
// Limitar delta time para evitar saltos grandes
|
||||
if (delta_time > 0.05f) {
|
||||
delta_time = 1.0f / 60.0f; // Fallback a 60 FPS
|
||||
}
|
||||
}
|
||||
|
||||
// Bucle principal actualizado
|
||||
while (!should_exit) {
|
||||
calculateDeltaTime(); // 1. Calcular tiempo transcurrido
|
||||
update(); // 2. Actualizar logica (usa delta_time)
|
||||
checkEvents(); // 3. Procesar entrada
|
||||
render(); // 4. Renderizar escena
|
||||
}
|
||||
```
|
||||
|
||||
### Conversion de Fisica: Frame-Based → Time-Based
|
||||
|
||||
#### 1. Conversion de Velocidades
|
||||
|
||||
```cpp
|
||||
// En Ball::Ball() constructor
|
||||
// ANTES: velocidades en pixeles/frame
|
||||
vx_ = vx;
|
||||
vy_ = vy;
|
||||
|
||||
// AHORA: convertir a pixeles/segundo (x60)
|
||||
vx_ = vx * 60.0f;
|
||||
vy_ = vy * 60.0f;
|
||||
```
|
||||
|
||||
#### 2. Conversion de Gravedad (Aceleracion)
|
||||
|
||||
```cpp
|
||||
// En Ball::Ball() constructor
|
||||
// ANTES: gravedad en pixeles/frame²
|
||||
gravity_force_ = GRAVITY_FORCE;
|
||||
|
||||
// AHORA: convertir a pixeles/segundo² (x60²)
|
||||
gravity_force_ = GRAVITY_FORCE * 60.0f * 60.0f; // 3600x multiplicador
|
||||
```
|
||||
|
||||
**¿Por que 60² para gravedad?**
|
||||
- Velocidad: `pixeles/frame * frame/segundo = pixeles/segundo` → **x60**
|
||||
- Aceleracion: `pixeles/frame² * frame²/segundo² = pixeles/segundo²` → **x60²**
|
||||
|
||||
#### 3. Aplicacion de Delta Time en Fisica
|
||||
|
||||
```cpp
|
||||
// En Ball::update(float deltaTime)
|
||||
// ANTES: incrementos fijos por frame
|
||||
vy_ += gravity_force_;
|
||||
pos_.x += vx_;
|
||||
pos_.y += vy_;
|
||||
|
||||
// AHORA: incrementos proporcionales al tiempo transcurrido
|
||||
vy_ += gravity_force_ * deltaTime; // Aceleracion * tiempo
|
||||
pos_.x += vx_ * deltaTime; // Velocidad * tiempo
|
||||
pos_.y += vy_ * deltaTime;
|
||||
```
|
||||
|
||||
### Valores de Debug: Antes vs Ahora
|
||||
|
||||
| Parametro | Sistema Anterior | Sistema Delta Time | Razon |
|
||||
|-----------|------------------|-------------------|-------|
|
||||
| **Velocidad X/Y** | 1.0 - 3.0 pixeles/frame | 60.0 - 180.0 pixeles/segundo | x60 conversion |
|
||||
| **Gravedad** | 0.2 pixeles/frame² | 720.0 pixeles/segundo² | x3600 conversion |
|
||||
| **Debug Display** | No disponible | GRAV: 720.000000 VY: -140.5 FLOOR: NO | Valores en tiempo real |
|
||||
|
||||
### Beneficios Conseguidos
|
||||
|
||||
- ✅ **Velocidad consistente** entre 60Hz, 75Hz, 144Hz y otros refresh rates
|
||||
- ✅ **V-Sync independiente**: misma velocidad con V-Sync ON/OFF
|
||||
- ✅ **Fisica precisa**: gravedad y movimiento calculados correctamente
|
||||
- ✅ **Escalabilidad**: preparado para futuras optimizaciones
|
||||
- ✅ **Debug en tiempo real**: monitoreo de valores de fisica
|
||||
|
||||
### Sistema de Debug Implementado
|
||||
|
||||
```cpp
|
||||
// Debug display para primera pelota
|
||||
if (!balls.empty()) {
|
||||
std::string debug_text = "GRAV: " + std::to_string(balls[0]->getGravityForce()) +
|
||||
" VY: " + std::to_string(balls[0]->getVelocityY()) +
|
||||
" FLOOR: " + (balls[0]->isOnFloor() ? "YES" : "NO");
|
||||
dbg_print(8, 24, debug_text.c_str(), 255, 0, 255); // Magenta
|
||||
}
|
||||
```
|
||||
|
||||
## 🛠️ Desarrollo
|
||||
|
||||
|
||||
Reference in New Issue
Block a user