vibe1_delta/source/main.cpp

#include <SDL3/SDL_error.h>    // for SDL_GetError
#include <SDL3/SDL_events.h>   // for SDL_EventType, SDL_PollEvent, SDL_Event
#include <SDL3/SDL_init.h>     // for SDL_Init, SDL_Quit, SDL_INIT_VIDEO
#include <SDL3/SDL_keycode.h>  // for SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5
#include <SDL3/SDL_render.h>   // for SDL_SetRenderDrawColor, SDL_CreateRend...
#include <SDL3/SDL_stdinc.h>   // for Uint64
#include <SDL3/SDL_timer.h>    // for SDL_GetTicks
#include <SDL3/SDL_video.h>    // for SDL_CreateWindow, SDL_DestroyWindow
#include <array>               // for array
#include <cstdlib>             // for rand, srand
#include <ctime>               // for time
#include <iostream>            // for basic_ostream, char_traits, operator<<
#include <memory>              // for unique_ptr, shared_ptr, make_shared
#include <string>              // for operator+, string, to_string
#include <vector>              // for vector
#include "ball.h"              // for Ball
#include "external/dbgtxt.h"            // for dbg_init, dbg_print
#include "defines.h"           // for SCREEN_WIDTH, SCREEN_HEIGHT, WINDOW_SIZE
#include "external/texture.h"           // for Texture

// Variables globales
SDL_Window *window = nullptr;
SDL_Renderer *renderer = nullptr;
std::shared_ptr<Texture> texture = nullptr;
std::vector<std::unique_ptr<Ball>> balls;
std::array<int, 8> test = {1, 10, 100, 500, 1000, 10000, 50000, 100000};

bool should_exit = false;  // Controla si la aplicación debe cerrarse
// ticks eliminado - reemplazado por delta time system
int scenario = 0;		   // Escenario actual basado en el número de bolas
std::string text;		   // Texto a mostrar en pantalla
int text_pos = 0;		   // Posición del texto en la pantalla
bool show_text = true;	   // Determina si el texto se debe mostrar
Uint64 text_init_time = 0; // Temporizador para mostrar el texto

// Variables para contador de FPS
Uint64 fps_last_time = 0;  // Último tiempo para cálculo de FPS
int fps_frame_count = 0;   // Contador de frames
int fps_current = 0;       // FPS actuales calculados
std::string fps_text = "FPS: 0"; // Texto del contador de FPS

// Variables para V-Sync
bool vsync_enabled = true; // Estado inicial del V-Sync (activado por defecto)
std::string vsync_text = "VSYNC: ON"; // Texto del estado V-Sync

// Variables para Delta Time
Uint64 last_frame_time = 0; // Tiempo del último frame en milisegundos
float delta_time = 0.0f;    // Tiempo transcurrido desde el último frame en segundos

// Variables para Debug Display
bool show_debug = false; // Debug display desactivado por defecto

// Variables para Batch Rendering
std::vector<SDL_Vertex> batch_vertices;
std::vector<int> batch_indices;

// Función para añadir un sprite al batch
void addSpriteToBatch(float x, float y, float w, float h, Uint8 r, Uint8 g, Uint8 b)
{
    int vertex_index = static_cast<int>(batch_vertices.size());

    // Crear 4 vértices para el quad (2 triángulos)
    SDL_Vertex vertices[4];

    // Convertir colores de Uint8 (0-255) a float (0.0-1.0)
    float rf = r / 255.0f;
    float gf = g / 255.0f;
    float bf = b / 255.0f;

    // Vértice superior izquierdo
    vertices[0].position = {x, y};
    vertices[0].tex_coord = {0.0f, 0.0f};
    vertices[0].color = {rf, gf, bf, 1.0f};

    // Vértice superior derecho
    vertices[1].position = {x + w, y};
    vertices[1].tex_coord = {1.0f, 0.0f};
    vertices[1].color = {rf, gf, bf, 1.0f};

    // Vértice inferior derecho
    vertices[2].position = {x + w, y + h};
    vertices[2].tex_coord = {1.0f, 1.0f};
    vertices[2].color = {rf, gf, bf, 1.0f};

    // Vértice inferior izquierdo
    vertices[3].position = {x, y + h};
    vertices[3].tex_coord = {0.0f, 1.0f};
    vertices[3].color = {rf, gf, bf, 1.0f};

    // Añadir vértices al batch
    for (int i = 0; i < 4; i++) {
        batch_vertices.push_back(vertices[i]);
    }

    // Añadir índices para 2 triángulos (6 índices por sprite)
    // Triángulo 1: 0,1,2
    batch_indices.push_back(vertex_index + 0);
    batch_indices.push_back(vertex_index + 1);
    batch_indices.push_back(vertex_index + 2);

    // Triángulo 2: 2,3,0
    batch_indices.push_back(vertex_index + 2);
    batch_indices.push_back(vertex_index + 3);
    batch_indices.push_back(vertex_index + 0);
}

// Establece el texto en pantalla mostrando el número de bolas actuales
void setText()
{
	const std::string TEXT_NUMBER = test[scenario] == 1 ? " PELOTA" : " PELOTAS";
	text = std::to_string(test[scenario]) + TEXT_NUMBER;
	const int TEXT_SIZE = static_cast<int>(text.size() * 8);
	text_pos = SCREEN_WIDTH / 2 - TEXT_SIZE / 2;
	text_init_time = SDL_GetTicks();
	show_text = true;
}

// Inicializa las bolas según el escenario seleccionado
void initBalls(int value)
{
	balls.clear();
	for (int i = 0; i < test.at(value); ++i)
	{
		const int SIGN = ((rand() % 2) * 2) - 1;											 // Genera un signo aleatorio (+ o -)
		const float X = (rand() % (SCREEN_WIDTH / 2)) + (SCREEN_WIDTH / 4);					 // Posición inicial en X
		const float VX = (((rand() % 20) + 10) * 0.1f) * SIGN;								 // Velocidad en X
		const float VY = ((rand() % 60) - 30) * 0.1f;										 // Velocidad en Y
		const Color COLOR = {(rand() % 192) + 32, (rand() % 192) + 32, (rand() % 192) + 32}; // Color aleatorio
		balls.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, texture));
	}
	setText(); // Actualiza el texto
}

// Aumenta la velocidad vertical de las bolas "hacia arriba"
void pushUpBalls()
{
	for (auto &ball : balls)
	{
		const int SIGNO = ((rand() % 2) * 2) - 1;
		const float VX = (((rand() % 20) + 10) * 0.1f) * SIGNO;
		const float VY = ((rand() % 40) * 0.1f) + 5;
		ball->modVel(VX, -VY); // Modifica la velocidad de la bola
	}
}

// Cambia la gravedad de todas las bolas
void switchBallsGravity()
{
	for (auto &ball : balls)
	{
		ball->switchGravity();
	}
}

// Alterna el estado del V-Sync
void toggleVSync()
{
	vsync_enabled = !vsync_enabled;
	vsync_text = vsync_enabled ? "VSYNC: ON" : "VSYNC: OFF";

	// Aplicar el cambio de V-Sync al renderizador
	SDL_SetRenderVSync(renderer, vsync_enabled ? 1 : 0);
}

// Calcula el delta time entre frames
void calculateDeltaTime()
{
	Uint64 current_time = SDL_GetTicks();

	// En el primer frame, inicializar el tiempo anterior
	if (last_frame_time == 0)
	{
		last_frame_time = current_time;
		delta_time = 1.0f / 60.0f; // Asumir 60 FPS para el primer frame
		return;
	}

	// Calcular delta time en segundos
	delta_time = (current_time - last_frame_time) / 1000.0f;
	last_frame_time = current_time;

	// Limitar delta time para evitar saltos grandes (pausa larga, depuración, etc.)
	if (delta_time > 0.05f) // Máximo 50ms (20 FPS mínimo)
	{
		delta_time = 1.0f / 60.0f; // Usar 60 FPS como fallback
	}
}

// Inicializa SDL y configura los componentes principales
bool init()
{
	bool success = true;

	// Inicializa SDL
	if (!SDL_Init(SDL_INIT_VIDEO))
	{
		std::cout << "¡SDL no se pudo inicializar! Error de SDL: " << SDL_GetError() << std::endl;
		success = false;
	}
	else
	{
		// Crear ventana principal
		window = SDL_CreateWindow(WINDOW_CAPTION, SCREEN_WIDTH * WINDOW_SIZE, SCREEN_HEIGHT * WINDOW_SIZE, SDL_WINDOW_OPENGL);
		if (window == nullptr)
		{
			std::cout << "¡No se pudo crear la ventana! Error de SDL: " << SDL_GetError() << std::endl;
			success = false;
		}
		else
		{
			// Crear renderizador
			renderer = SDL_CreateRenderer(window, nullptr);
			if (renderer == nullptr)
			{
				std::cout << "¡No se pudo crear el renderizador! Error de SDL: " << SDL_GetError() << std::endl;
				success = false;
			}
			else
			{
				// Establecer color inicial del renderizador
				SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);

				// Establecer tamaño lógico para el renderizado
				SDL_SetRenderLogicalPresentation(renderer, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);

				// Configurar V-Sync inicial
				SDL_SetRenderVSync(renderer, vsync_enabled ? 1 : 0);
			}
		}
	}

	// Inicializar otros componentes
	texture = std::make_shared<Texture>(renderer, "resources/ball.png");
	// ticks eliminado - delta time system se inicializa automáticamente
	srand(static_cast<unsigned>(time(nullptr)));
	dbg_init(renderer);
	initBalls(scenario);

	return success;
}

// Limpia todos los recursos y cierra SDL
void close()
{
	SDL_DestroyRenderer(renderer);
	SDL_DestroyWindow(window);
	SDL_Quit(); 
}

// Verifica los eventos en la cola
void checkEvents()
{
	SDL_Event event;
	while (SDL_PollEvent(&event) != 0)
	{
		// Evento de salida
		if (event.type == SDL_EVENT_QUIT)
		{
			should_exit = true;
			break;
		}

		// Procesar eventos de teclado
		if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0)
		{
			switch (event.key.key)
			{
			case SDLK_ESCAPE:
				should_exit = true;
				break;

			case SDLK_SPACE:
				pushUpBalls();
				break;

			case SDLK_G:
				switchBallsGravity();
				break;

			case SDLK_V:
				toggleVSync();
				break;

			case SDLK_H:
				show_debug = !show_debug;
				break;

			case SDLK_1:
				scenario = 0;
				initBalls(scenario);
				break;

			case SDLK_2:
				scenario = 1;
				initBalls(scenario);
				break;

			case SDLK_3:
				scenario = 2;
				initBalls(scenario);
				break;

			case SDLK_4:
				scenario = 3;
				initBalls(scenario);
				break;

			case SDLK_5:
				scenario = 4;
				initBalls(scenario);
				break;

			case SDLK_6:
				scenario = 5;
				initBalls(scenario);
				break;

			case SDLK_7:
				scenario = 6;
				initBalls(scenario);
				break;

			case SDLK_8:
				scenario = 7;
				initBalls(scenario);
				break;
			}
		}
	}
}

// Actualiza la lógica del juego
void update()
{
	// Calcular FPS
	fps_frame_count++;
	Uint64 current_time = SDL_GetTicks();
	if (current_time - fps_last_time >= 1000) // Actualizar cada segundo
	{
		fps_current = fps_frame_count;
		fps_frame_count = 0;
		fps_last_time = current_time;
		fps_text = "FPS: " + std::to_string(fps_current);
	}

	// ¡DELTA TIME! Actualizar física siempre, usando tiempo transcurrido
	for (auto &ball : balls)
	{
		ball->update(delta_time); // Pasar delta time a cada pelota
	}

	// Actualizar texto (sin cambios en la lógica)
	if (show_text)
	{
		show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
	}
}

// Renderiza el contenido en la pantalla
void render()
{
	SDL_SetRenderDrawColor(renderer, 64, 64, 64, 255);
	SDL_RenderClear(renderer);

	// Limpiar batches del frame anterior
	batch_vertices.clear();
	batch_indices.clear();

	// Recopilar datos de todas las bolas para batch rendering
	for (auto &ball : balls)
	{
		// En lugar de ball->render(), obtener datos para batch
		SDL_FRect pos = ball->getPosition();
		Color color = ball->getColor();
		addSpriteToBatch(pos.x, pos.y, pos.w, pos.h, color.r, color.g, color.b);
	}

	// Renderizar todas las bolas en una sola llamada
	if (!batch_vertices.empty())
	{
		SDL_RenderGeometry(renderer, texture->getSDLTexture(),
		                   batch_vertices.data(), static_cast<int>(batch_vertices.size()),
		                   batch_indices.data(), static_cast<int>(batch_indices.size()));
	}

	if (show_text)
	{
		dbg_print(text_pos, 8, text.c_str(), 255, 255, 255);
	}

	// Debug display (solo si está activado con tecla H)
	if (show_debug)
	{
		// Mostrar contador de FPS en esquina superior derecha
		int fps_text_width = static_cast<int>(fps_text.length() * 8); // 8 píxeles por carácter
		int fps_x = SCREEN_WIDTH - fps_text_width - 8; // 8 píxeles de margen
		dbg_print(fps_x, 8, fps_text.c_str(), 255, 255, 0); // Amarillo para distinguir

		// Mostrar estado V-Sync en esquina superior izquierda
		dbg_print(8, 8, vsync_text.c_str(), 0, 255, 255); // Cian para distinguir

		// Debug: Mostrar valores de la primera pelota (si existe)
		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 para debug
		}
	}

	SDL_RenderPresent(renderer);
}

// Función principal
int main(int argc, char *args[])
{
	if (!init())
	{
		std::cout << "Ocurrió un error durante la inicialización." << std::endl;
		return 1;
	}

	while (!should_exit)
	{
		// 1. Calcular delta time antes de actualizar la lógica
		calculateDeltaTime();

		// 2. Actualizar lógica del juego con delta time
		update();

		// 3. Procesar eventos de entrada
		checkEvents();

		// 4. Renderizar la escena
		render();
	}

	close();

	return 0;
}