Experimento parcial de migración a C++20 modules

- Creados módulos core, themes, physics, rendering, input
- Integrados core y themes exitosamente en main.cpp
- Physics, rendering, input comentados por conflictos SDL
- Aplicación funcional con módulos parciales
- Experimento archivado para futuras referencias

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

source/main.cpp

@@ -1,11 +1,5 @@
-#include <SDL3/SDL_error.h>    // for SDL_GetError
+// Includes de SDL3 directos para compatibilidad con archivos externos
-#include <SDL3/SDL_events.h>   // for SDL_EventType, SDL_PollEvent, SDL_Event
+#include <SDL3/SDL.h>
-#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
@@ -17,10 +11,15 @@
 
 #include "ball.h"              // for Ball
 import vibe2.core;              // Módulo con constantes y tipos básicos
+import vibe2.themes;            // Sistema de temas modular
+// import vibe2.physics;           // Sistema de física modular (temporal)
+// import vibe2.rendering;         // Sistema de renderizado modular (temporal - conflicto SDL)
+// import vibe2.input;             // Sistema de entrada modular (temporal)
+
 #include "external/dbgtxt.h"   // for dbg_init, dbg_print
 #include "external/texture.h"  // for Texture
 
-// Variables globales
+// Variables globales usando tipos SDL directos para compatibilidad
 SDL_Window *window = nullptr;
 SDL_Renderer *renderer = nullptr;
 std::shared_ptr<Texture> texture = nullptr;
@@ -55,139 +54,27 @@ float delta_time = 0.0f;     // Tiempo transcurrido desde el último frame en se
 // Variables para Debug Display
 bool show_debug = false;  // Debug display desactivado por defecto
 
-// El sistema de temas ahora está en el módulo core
+// Sistemas modulares
-ColorTheme current_theme = ColorTheme::SUNSET;
+themes::ThemeManager theme_manager;
-std::string theme_names[] = {"SUNSET", "OCEAN", "NEON", "FOREST"};
+// std::unique_ptr<rendering::GradientRenderer> gradient_renderer;  // Temporal
+// std::unique_ptr<rendering::BatchRenderer> batch_renderer;        // Temporal
 
-struct ThemeColors {
+// Función para renderizar fondo degradado usando el módulo
-        // Colores de fondo (superior -> inferior)
-        float bg_top_r, bg_top_g, bg_top_b;
-        float bg_bottom_r, bg_bottom_g, bg_bottom_b;
-
-        // Paletas de colores para bolas (RGB 0-255)
-        int ball_colors[8][3];  // 8 colores por tema
-};
-
-ThemeColors themes[4] = {
-    // SUNSET: Naranjas, rojos, amarillos, rosas
-    {180.0f / 255.0f, 140.0f / 255.0f, 100.0f / 255.0f,  // Fondo superior (naranja suave)
-        40.0f / 255.0f,
-        20.0f / 255.0f,
-        60.0f / 255.0f,  // Fondo inferior (púrpura oscuro)
-        {{255, 140, 0}, {255, 69, 0}, {255, 215, 0}, {255, 20, 147}, {255, 99, 71}, {255, 165, 0}, {255, 192, 203}, {220, 20, 60}}},
-    // OCEAN: Azules, cianes, verdes agua, blancos
-    {100.0f / 255.0f, 150.0f / 255.0f, 200.0f / 255.0f,  // Fondo superior (azul cielo)
-        20.0f / 255.0f,
-        40.0f / 255.0f,
-        80.0f / 255.0f,  // Fondo inferior (azul marino)
-        {{0, 191, 255}, {0, 255, 255}, {32, 178, 170}, {176, 224, 230}, {70, 130, 180}, {0, 206, 209}, {240, 248, 255}, {64, 224, 208}}},
-    // NEON: Cian, magenta, verde lima, amarillo vibrante
-    {20.0f / 255.0f, 20.0f / 255.0f, 40.0f / 255.0f,  // Fondo superior (negro azulado)
-        0.0f / 255.0f,
-        0.0f / 255.0f,
-        0.0f / 255.0f,  // Fondo inferior (negro)
-        {{0, 255, 255}, {255, 0, 255}, {50, 205, 50}, {255, 255, 0}, {255, 20, 147}, {0, 255, 127}, {138, 43, 226}, {255, 69, 0}}},
-    // FOREST: Verdes, marrones, amarillos otoño
-    {144.0f / 255.0f, 238.0f / 255.0f, 144.0f / 255.0f,  // Fondo superior (verde claro)
-        101.0f / 255.0f,
-        67.0f / 255.0f,
-        33.0f / 255.0f,  // Fondo inferior (marrón tierra)
-        {{34, 139, 34}, {107, 142, 35}, {154, 205, 50}, {255, 215, 0}, {210, 180, 140}, {160, 82, 45}, {218, 165, 32}, {50, 205, 50}}}};
-
-// Variables para Batch Rendering
-std::vector<SDL_Vertex> batch_vertices;
-std::vector<int> batch_indices;
-
-// Función para renderizar fondo degradado
 void renderGradientBackground() {
-    // Crear quad de pantalla completa con degradado
+    // TODO: Implementar con rendering module cuando se resuelvan conflictos SDL
-    SDL_Vertex bg_vertices[4];
+    // const auto& theme_data = theme_manager.getCurrentThemeData();
+    // gradient_renderer->renderBackground(theme_data);
 
-    // Obtener colores del tema actual
+    // Fondo temporal básico
-    ThemeColors &theme = themes[static_cast<int>(current_theme)];
+    SDL_SetRenderDrawColor(renderer, 32, 64, 128, 255);  // Azul oscuro
-
+    SDL_RenderClear(renderer);
-    float top_r = theme.bg_top_r;
-    float top_g = theme.bg_top_g;
-    float top_b = theme.bg_top_b;
-
-    float bottom_r = theme.bg_bottom_r;
-    float bottom_g = theme.bg_bottom_g;
-    float bottom_b = theme.bg_bottom_b;
-
-    // Vértice superior izquierdo
-    bg_vertices[0].position = {0, 0};
-    bg_vertices[0].tex_coord = {0.0f, 0.0f};
-    bg_vertices[0].color = {top_r, top_g, top_b, 1.0f};
-
-    // Vértice superior derecho
-    bg_vertices[1].position = {SCREEN_WIDTH, 0};
-    bg_vertices[1].tex_coord = {1.0f, 0.0f};
-    bg_vertices[1].color = {top_r, top_g, top_b, 1.0f};
-
-    // Vértice inferior derecho
-    bg_vertices[2].position = {SCREEN_WIDTH, SCREEN_HEIGHT};
-    bg_vertices[2].tex_coord = {1.0f, 1.0f};
-    bg_vertices[2].color = {bottom_r, bottom_g, bottom_b, 1.0f};
-
-    // Vértice inferior izquierdo
-    bg_vertices[3].position = {0, SCREEN_HEIGHT};
-    bg_vertices[3].tex_coord = {0.0f, 1.0f};
-    bg_vertices[3].color = {bottom_r, bottom_g, bottom_b, 1.0f};
-
-    // Índices para 2 triángulos
-    int bg_indices[6] = {0, 1, 2, 2, 3, 0};
-
-    // Renderizar sin textura (nullptr)
-    SDL_RenderGeometry(renderer, nullptr, bg_vertices, 4, bg_indices, 6);
 }
 
-// Función para añadir un sprite al batch
+// Función para añadir un sprite al batch usando el módulo
 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());
+    // TODO: Implementar con rendering module cuando se resuelvan conflictos SDL
-
+    // Color color(r, g, b);
-    // Crear 4 vértices para el quad (2 triángulos)
+    // batch_renderer->addSprite(x, y, w, h, color);
-    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
@@ -208,12 +95,8 @@ void initBalls(int value) {
         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
-        // Seleccionar color de la paleta del tema actual
+        // Usar el theme manager para obtener un color aleatorio
-        ThemeColors &theme = themes[static_cast<int>(current_theme)];
+        const Color COLOR = theme_manager.getRandomColor();
-        int color_index = rand() % 8;  // 8 colores por tema
-        const Color COLOR = {theme.ball_colors[color_index][0],
-            theme.ball_colors[color_index][1],
-            theme.ball_colors[color_index][2]};
         balls.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, texture));
     }
     setText();  // Actualiza el texto
@@ -302,6 +185,11 @@ bool init() {
 
     // Inicializar otros componentes
     texture = std::make_shared<Texture>(renderer, "data/ball.png");
+
+    // Inicializar sistemas modulares (temporal comentado por conflictos SDL)
+    // gradient_renderer = std::make_unique<rendering::GradientRenderer>(renderer);
+    // batch_renderer = std::make_unique<rendering::BatchRenderer>(renderer);
+
     // ticks eliminado - delta time system se inicializa automáticamente
     srand(static_cast<unsigned>(time(nullptr)));
     dbg_init(renderer);
@@ -320,7 +208,7 @@ void close() {
 // Verifica los eventos en la cola
 void checkEvents() {
     SDL_Event event;
-    while (SDL_PollEvent(&event) != 0) {
+    while (SDL_PollEvent(&event)) {
         // Evento de salida
         if (event.type == SDL_EVENT_QUIT) {
             should_exit = true;
@@ -351,28 +239,28 @@ void checkEvents() {
                     break;
 
                 case SDLK_T:
-                    // Ciclar al siguiente tema
+                    // Ciclar al siguiente tema usando el theme manager
-                    current_theme = static_cast<ColorTheme>((static_cast<int>(current_theme) + 1) % 4);
+                    theme_manager.cycleTheme();
                     initBalls(scenario);  // Regenerar bolas con nueva paleta
                     break;
 
                 case SDLK_F1:
-                    current_theme = ColorTheme::SUNSET;
+                    theme_manager.setTheme(ColorTheme::SUNSET);
                     initBalls(scenario);
                     break;
 
                 case SDLK_F2:
-                    current_theme = ColorTheme::OCEAN;
+                    theme_manager.setTheme(ColorTheme::OCEAN);
                     initBalls(scenario);
                     break;
 
                 case SDLK_F3:
-                    current_theme = ColorTheme::NEON;
+                    theme_manager.setTheme(ColorTheme::NEON);
                     initBalls(scenario);
                     break;
 
                 case SDLK_F4:
-                    current_theme = ColorTheme::FOREST;
+                    theme_manager.setTheme(ColorTheme::FOREST);
                     initBalls(scenario);
                     break;
 
@@ -446,51 +334,34 @@ void update() {
 
 // Renderiza el contenido en la pantalla
 void render() {
-    // Renderizar fondo degradado en lugar de color sólido
+    // Renderizar fondo degradado usando el módulo
     renderGradientBackground();
 
-    // Limpiar batches del frame anterior
+    // TODO: Reimplementar con batch rendering cuando se resuelvan conflictos SDL
-    batch_vertices.clear();
+    // Renderizado temporal directo de bolas
-    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();
+        texture->render(nullptr, &pos);
-        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);
 
-        // Mostrar nombre del tema en castellano debajo del número de pelotas
+        // Mostrar nombre del tema usando el theme manager
-        std::string theme_names_es[] = {"ATARDECER", "OCEANO", "NEON", "BOSQUE"};
+        std::string theme_name = theme_manager.getThemeNameES();
-        std::string theme_name = theme_names_es[static_cast<int>(current_theme)];
+        // TODO: Usar rendering::utils cuando se resuelvan conflictos SDL
-        int theme_text_width = static_cast<int>(theme_name.length() * 8);  // 8 píxeles por carácter
+        int theme_x = (SCREEN_WIDTH - static_cast<int>(theme_name.length() * 8)) / 2;  // Centrado temporal
-        int theme_x = (SCREEN_WIDTH - theme_text_width) / 2;               // Centrar horizontalmente
 
-        // Colores acordes a cada tema
+        // Obtener color de debug del tema actual
-        int theme_colors[][3] = {
+        Color theme_color = theme_manager.getDebugColor();
-            {255, 140, 60},  // ATARDECER: Naranja cálido
+        dbg_print(theme_x, 24, theme_name.c_str(), theme_color.r, theme_color.g, theme_color.b);
-            {80, 200, 255},  // OCEANO: Azul océano
-            {255, 60, 255},  // NEON: Magenta brillante
-            {100, 255, 100}  // BOSQUE: Verde natural
-        };
-        int theme_idx = static_cast<int>(current_theme);
-        dbg_print(theme_x, 24, theme_name.c_str(), theme_colors[theme_idx][0], theme_colors[theme_idx][1], theme_colors[theme_idx][2]);
     }
 
     // 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
+        // TODO: Usar rendering::utils cuando se resuelvan conflictos SDL
-        int fps_x = SCREEN_WIDTH - fps_text_width - 8;                 // 8 píxeles de margen
+        int fps_x = SCREEN_WIDTH - static_cast<int>(fps_text.length() * 8) - 8;  // Alineado derecha temporal
         dbg_print(fps_x, 8, fps_text.c_str(), 255, 255, 0);            // Amarillo para distinguir
 
         // Mostrar estado V-Sync en esquina superior izquierda
@@ -513,9 +384,8 @@ void render() {
             dbg_print(8, 40, floor_text.c_str(), 255, 0, 255);  // Magenta para debug
         }
 
-        // Debug: Mostrar tema actual
+        // Debug: Mostrar tema actual usando el theme manager
-        std::string theme_names[] = {"SUNSET", "OCEAN", "NEON", "FOREST"};
+        std::string theme_text = std::string("THEME ") + theme_manager.getThemeName();
-        std::string theme_text = "THEME " + theme_names[static_cast<int>(current_theme)];
         dbg_print(8, 48, theme_text.c_str(), 255, 255, 128);  // Amarillo claro para tema
     }
 

source/modules/input.cppm

@@ -0,0 +1,124 @@
+export module vibe2.input;
+
+import vibe2.core;
+import vibe2.external.sdl_wrapper;
+
+export namespace vibe2::input {
+
+    // Acciones del juego
+    enum class GameAction {
+        EXIT,
+        PUSH_BALLS,
+        TOGGLE_GRAVITY,
+        TOGGLE_VSYNC,
+        TOGGLE_DEBUG,
+        CYCLE_THEME,
+        SET_THEME_SUNSET,
+        SET_THEME_OCEAN,
+        SET_THEME_NEON,
+        SET_THEME_FOREST,
+        SET_SCENARIO_1,
+        SET_SCENARIO_2,
+        SET_SCENARIO_3,
+        SET_SCENARIO_4,
+        SET_SCENARIO_5,
+        SET_SCENARIO_6,
+        SET_SCENARIO_7,
+        SET_SCENARIO_8,
+        NONE
+    };
+
+    // Mapeador básico de teclas
+    class KeyMapper {
+    public:
+        static GameAction getActionForKey(int key) {
+            switch (key) {
+                case vibe2::sdl::KEY_ESCAPE: return GameAction::EXIT;
+                case vibe2::sdl::KEY_SPACE: return GameAction::PUSH_BALLS;
+                case vibe2::sdl::KEY_G: return GameAction::TOGGLE_GRAVITY;
+                case vibe2::sdl::KEY_V: return GameAction::TOGGLE_VSYNC;
+                case vibe2::sdl::KEY_H: return GameAction::TOGGLE_DEBUG;
+                case vibe2::sdl::KEY_T: return GameAction::CYCLE_THEME;
+                case vibe2::sdl::KEY_F1: return GameAction::SET_THEME_SUNSET;
+                case vibe2::sdl::KEY_F2: return GameAction::SET_THEME_OCEAN;
+                case vibe2::sdl::KEY_F3: return GameAction::SET_THEME_NEON;
+                case vibe2::sdl::KEY_F4: return GameAction::SET_THEME_FOREST;
+                case vibe2::sdl::KEY_1: return GameAction::SET_SCENARIO_1;
+                case vibe2::sdl::KEY_2: return GameAction::SET_SCENARIO_2;
+                case vibe2::sdl::KEY_3: return GameAction::SET_SCENARIO_3;
+                case vibe2::sdl::KEY_4: return GameAction::SET_SCENARIO_4;
+                case vibe2::sdl::KEY_5: return GameAction::SET_SCENARIO_5;
+                case vibe2::sdl::KEY_6: return GameAction::SET_SCENARIO_6;
+                case vibe2::sdl::KEY_7: return GameAction::SET_SCENARIO_7;
+                case vibe2::sdl::KEY_8: return GameAction::SET_SCENARIO_8;
+                default: return GameAction::NONE;
+            }
+        }
+
+        static const char* getActionDescription(GameAction action) {
+            switch (action) {
+                case GameAction::EXIT: return "Salir";
+                case GameAction::PUSH_BALLS: return "Impulsar pelotas";
+                case GameAction::TOGGLE_GRAVITY: return "Alternar gravedad";
+                case GameAction::TOGGLE_VSYNC: return "Alternar V-Sync";
+                case GameAction::TOGGLE_DEBUG: return "Alternar debug";
+                case GameAction::CYCLE_THEME: return "Cambiar tema";
+                case GameAction::SET_THEME_SUNSET: return "Tema Atardecer";
+                case GameAction::SET_THEME_OCEAN: return "Tema Océano";
+                case GameAction::SET_THEME_NEON: return "Tema Neón";
+                case GameAction::SET_THEME_FOREST: return "Tema Bosque";
+                case GameAction::SET_SCENARIO_1: return "1 pelota";
+                case GameAction::SET_SCENARIO_2: return "10 pelotas";
+                case GameAction::SET_SCENARIO_3: return "100 pelotas";
+                case GameAction::SET_SCENARIO_4: return "500 pelotas";
+                case GameAction::SET_SCENARIO_5: return "1K pelotas";
+                case GameAction::SET_SCENARIO_6: return "10K pelotas";
+                case GameAction::SET_SCENARIO_7: return "50K pelotas";
+                case GameAction::SET_SCENARIO_8: return "100K pelotas";
+                default: return "Desconocido";
+            }
+        }
+    };
+
+    // Utilidades para conversión de escenarios
+    namespace utils {
+        constexpr int SCENARIO_COUNTS[8] = {1, 10, 100, 500, 1000, 10000, 50000, 100000};
+
+        inline int getScenarioIndex(GameAction action) {
+            switch (action) {
+                case GameAction::SET_SCENARIO_1: return 0;
+                case GameAction::SET_SCENARIO_2: return 1;
+                case GameAction::SET_SCENARIO_3: return 2;
+                case GameAction::SET_SCENARIO_4: return 3;
+                case GameAction::SET_SCENARIO_5: return 4;
+                case GameAction::SET_SCENARIO_6: return 5;
+                case GameAction::SET_SCENARIO_7: return 6;
+                case GameAction::SET_SCENARIO_8: return 7;
+                default: return -1;
+            }
+        }
+
+        inline int getScenarioCount(GameAction action) {
+            int index = getScenarioIndex(action);
+            return (index >= 0) ? SCENARIO_COUNTS[index] : 0;
+        }
+
+        inline ColorTheme getThemeFromAction(GameAction action) {
+            switch (action) {
+                case GameAction::SET_THEME_SUNSET: return ColorTheme::SUNSET;
+                case GameAction::SET_THEME_OCEAN: return ColorTheme::OCEAN;
+                case GameAction::SET_THEME_NEON: return ColorTheme::NEON;
+                case GameAction::SET_THEME_FOREST: return ColorTheme::FOREST;
+                default: return ColorTheme::SUNSET;
+            }
+        }
+
+        inline bool isScenarioAction(GameAction action) {
+            return action >= GameAction::SET_SCENARIO_1 && action <= GameAction::SET_SCENARIO_8;
+        }
+
+        inline bool isThemeAction(GameAction action) {
+            return action >= GameAction::SET_THEME_SUNSET && action <= GameAction::SET_THEME_FOREST;
+        }
+    }
+}

source/modules/physics.cppm

@@ -0,0 +1,122 @@
+export module vibe2.physics;
+
+import vibe2.core;
+
+// Declaraciones forward en lugar de includes pesados
+struct SDL_FRect;
+
+export namespace vibe2::physics {
+
+    // Entidad física básica
+    class PhysicsEntity {
+    private:
+        float x_, y_, w_, h_;          // Posición y tamaño
+        float vx_, vy_;               // Velocidad
+        float gravity_force_;         // Gravedad
+        bool on_floor_;               // En el suelo
+        bool stopped_;                // Detenido
+        float bounce_loss_;           // Pérdida de rebote
+
+    public:
+        PhysicsEntity(float x, float y, float w, float h, float vx = 0.0f, float vy = 0.0f)
+            : x_(x), y_(y), w_(w), h_(h),
+              vx_(vx * vibe2::physics::CONVERSION_FACTOR),
+              vy_(vy * vibe2::physics::CONVERSION_FACTOR),
+              gravity_force_(vibe2::GRAVITY_FORCE * vibe2::physics::CONVERSION_FACTOR * vibe2::physics::CONVERSION_FACTOR),
+              on_floor_(false), stopped_(false), bounce_loss_(0.7f) {}
+
+        void update(float deltaTime) {
+            if (stopped_) return;
+
+            // Aplicar gravedad
+            if (!on_floor_) {
+                vy_ += gravity_force_ * deltaTime;
+            }
+
+            // Actualizar posición
+            x_ += vx_ * deltaTime;
+            if (!on_floor_) {
+                y_ += vy_ * deltaTime;
+            } else {
+                y_ = vibe2::SCREEN_HEIGHT - h_;
+            }
+
+            handleCollisions();
+        }
+
+        void handleCollisions() {
+            // Colisiones laterales
+            if (x_ < 0) {
+                x_ = 0;
+                vx_ = -vx_;
+            }
+            if (x_ + w_ > vibe2::SCREEN_WIDTH) {
+                x_ = vibe2::SCREEN_WIDTH - w_;
+                vx_ = -vx_;
+            }
+
+            // Colisión superior
+            if (y_ < 0) {
+                y_ = 0;
+                vy_ = -vy_;
+            }
+
+            // Colisión inferior (suelo)
+            if (y_ + h_ > vibe2::SCREEN_HEIGHT) {
+                y_ = vibe2::SCREEN_HEIGHT - h_;
+                vy_ = -vy_ * bounce_loss_;
+
+                if (vy_ > -vibe2::physics::VELOCITY_THRESHOLD && vy_ < vibe2::physics::VELOCITY_THRESHOLD) {
+                    vy_ = 0.0f;
+                    on_floor_ = true;
+                }
+            }
+
+            // Fricción en el suelo
+            if (on_floor_) {
+                float friction = 1.0f - (1.0f - vibe2::physics::FRICTION_FACTOR) * deltaTime * 60.0f;
+                vx_ *= friction;
+
+                if (vx_ > -vibe2::physics::VELOCITY_THRESHOLD && vx_ < vibe2::physics::VELOCITY_THRESHOLD) {
+                    vx_ = 0.0f;
+                    stopped_ = true;
+                }
+            }
+        }
+
+        // Modificar velocidad
+        void addVelocity(float vx, float vy) {
+            if (stopped_) {
+                vx_ += vx * vibe2::physics::CONVERSION_FACTOR;
+            }
+            vy_ += vy * vibe2::physics::CONVERSION_FACTOR;
+            on_floor_ = false;
+            stopped_ = false;
+        }
+
+        // Cambiar gravedad
+        void toggleGravity() {
+            gravity_force_ = (gravity_force_ == 0.0f) ?
+                (vibe2::GRAVITY_FORCE * vibe2::physics::CONVERSION_FACTOR * vibe2::physics::CONVERSION_FACTOR) : 0.0f;
+        }
+
+        // Getters
+        float getX() const { return x_; }
+        float getY() const { return y_; }
+        float getW() const { return w_; }
+        float getH() const { return h_; }
+        float getVX() const { return vx_; }
+        float getVY() const { return vy_; }
+        float getGravityForce() const { return gravity_force_; }
+        bool isOnFloor() const { return on_floor_; }
+        bool isStopped() const { return stopped_; }
+
+        void setPosition(float x, float y) {
+            x_ = x;
+            y_ = y;
+        }
+
+    private:
+        float deltaTime = 0.016f; // Para cálculos internos
+    };
+}

source/modules/rendering.cppm

@@ -0,0 +1,134 @@
+export module vibe2.rendering;
+
+import vibe2.core;
+import vibe2.themes;
+import vibe2.external.sdl_wrapper;
+
+export namespace vibe2::rendering {
+
+    // Utilidades básicas de renderizado
+    namespace utils {
+        // Calcular posición centrada para texto
+        inline int getCenteredTextX(int text_length, int char_width = debug::DEFAULT_TEXT_SIZE) {
+            const int text_pixel_width = text_length * char_width;
+            return (SCREEN_WIDTH - text_pixel_width) / 2;
+        }
+
+        // Calcular posición alineada a la derecha
+        inline int getRightAlignedX(int text_length, int char_width = debug::DEFAULT_TEXT_SIZE, int margin = debug::MARGIN) {
+            const int text_pixel_width = text_length * char_width;
+            return SCREEN_WIDTH - text_pixel_width - margin;
+        }
+
+        // Convertir color RGB a valores normalizados
+        inline void rgbToFloat(int r, int g, int b, float& rf, float& gf, float& bf) {
+            rf = r / 255.0f;
+            gf = g / 255.0f;
+            bf = b / 255.0f;
+        }
+    }
+
+    // Renderizador de fondos degradados
+    class GradientRenderer {
+    private:
+        vibe2::sdl::Renderer* renderer_;
+
+    public:
+        GradientRenderer(vibe2::sdl::Renderer* renderer) : renderer_(renderer) {}
+
+        void renderBackground(const themes::ThemeData& theme_data) {
+            // Crear quad de pantalla completa con degradado
+            vibe2::sdl::Vertex bg_vertices[4];
+
+            // Vértice superior izquierdo
+            bg_vertices[0].position = {0, 0};
+            bg_vertices[0].tex_coord = {0.0f, 0.0f};
+            bg_vertices[0].color = {theme_data.bg_top_r, theme_data.bg_top_g, theme_data.bg_top_b, 1.0f};
+
+            // Vértice superior derecho
+            bg_vertices[1].position = {SCREEN_WIDTH, 0};
+            bg_vertices[1].tex_coord = {1.0f, 0.0f};
+            bg_vertices[1].color = {theme_data.bg_top_r, theme_data.bg_top_g, theme_data.bg_top_b, 1.0f};
+
+            // Vértice inferior derecho
+            bg_vertices[2].position = {SCREEN_WIDTH, SCREEN_HEIGHT};
+            bg_vertices[2].tex_coord = {1.0f, 1.0f};
+            bg_vertices[2].color = {theme_data.bg_bottom_r, theme_data.bg_bottom_g, theme_data.bg_bottom_b, 1.0f};
+
+            // Vértice inferior izquierdo
+            bg_vertices[3].position = {0, SCREEN_HEIGHT};
+            bg_vertices[3].tex_coord = {0.0f, 1.0f};
+            bg_vertices[3].color = {theme_data.bg_bottom_r, theme_data.bg_bottom_g, theme_data.bg_bottom_b, 1.0f};
+
+            // Índices para 2 triángulos
+            int bg_indices[6] = {0, 1, 2, 2, 3, 0};
+
+            // Renderizar sin textura
+            vibe2::sdl::renderGeometry(renderer_, nullptr, bg_vertices, 4, bg_indices, 6);
+        }
+    };
+
+    // Sistema de batch rendering básico
+    class BatchRenderer {
+    private:
+        static constexpr int MAX_SPRITES = 10000;
+        vibe2::sdl::Vertex vertices_[MAX_SPRITES * 4];
+        int indices_[MAX_SPRITES * 6];
+        int sprite_count_;
+        vibe2::sdl::Renderer* renderer_;
+
+    public:
+        BatchRenderer(vibe2::sdl::Renderer* renderer) : sprite_count_(0), renderer_(renderer) {}
+
+        void clear() {
+            sprite_count_ = 0;
+        }
+
+        void addSprite(float x, float y, float w, float h, const Color& color) {
+            if (sprite_count_ >= MAX_SPRITES) return;
+
+            int vertex_index = sprite_count_ * 4;
+            int index_start = sprite_count_ * 6;
+
+            // Convertir colores de Uint8 (0-255) a float (0.0-1.0)
+            float rf = color.r / 255.0f;
+            float gf = color.g / 255.0f;
+            float bf = color.b / 255.0f;
+
+            // Crear 4 vértices para el quad
+            vertices_[vertex_index + 0].position = {x, y};
+            vertices_[vertex_index + 0].tex_coord = {0.0f, 0.0f};
+            vertices_[vertex_index + 0].color = {rf, gf, bf, 1.0f};
+
+            vertices_[vertex_index + 1].position = {x + w, y};
+            vertices_[vertex_index + 1].tex_coord = {1.0f, 0.0f};
+            vertices_[vertex_index + 1].color = {rf, gf, bf, 1.0f};
+
+            vertices_[vertex_index + 2].position = {x + w, y + h};
+            vertices_[vertex_index + 2].tex_coord = {1.0f, 1.0f};
+            vertices_[vertex_index + 2].color = {rf, gf, bf, 1.0f};
+
+            vertices_[vertex_index + 3].position = {x, y + h};
+            vertices_[vertex_index + 3].tex_coord = {0.0f, 1.0f};
+            vertices_[vertex_index + 3].color = {rf, gf, bf, 1.0f};
+
+            // Índices para 2 triángulos
+            indices_[index_start + 0] = vertex_index + 0;
+            indices_[index_start + 1] = vertex_index + 1;
+            indices_[index_start + 2] = vertex_index + 2;
+            indices_[index_start + 3] = vertex_index + 2;
+            indices_[index_start + 4] = vertex_index + 3;
+            indices_[index_start + 5] = vertex_index + 0;
+
+            sprite_count_++;
+        }
+
+        void renderBatch(vibe2::sdl::Texture* texture = nullptr) {
+            if (sprite_count_ > 0) {
+                vibe2::sdl::renderGeometry(renderer_, texture, vertices_, sprite_count_ * 4, indices_, sprite_count_ * 6);
+            }
+        }
+
+        int getSpriteCount() const { return sprite_count_; }
+    };
+}

source/modules/themes.cppm

@@ -0,0 +1,150 @@
+export module vibe2.themes;
+
+import vibe2.core;
+
+export namespace vibe2::themes {
+
+    // Estructura para datos de un tema
+    struct ThemeData {
+        // Colores de fondo (superior -> inferior) en formato float [0-1]
+        float bg_top_r, bg_top_g, bg_top_b;
+        float bg_bottom_r, bg_bottom_g, bg_bottom_b;
+
+        // Paletas de colores para elementos (RGB 0-255)
+        int element_colors[8][3];  // 8 colores por tema
+
+        // Nombres del tema
+        const char* name_en;
+        const char* name_es;
+    };
+
+    // Definición de todos los temas disponibles
+    constexpr ThemeData THEME_DATA[4] = {
+        // SUNSET: Naranjas, rojos, amarillos, rosas
+        {
+            180.0f / 255.0f, 140.0f / 255.0f, 100.0f / 255.0f,  // Fondo superior
+            40.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f,     // Fondo inferior
+            {{255, 140, 0}, {255, 69, 0}, {255, 215, 0}, {255, 20, 147},
+             {255, 99, 71}, {255, 165, 0}, {255, 192, 203}, {220, 20, 60}},
+            "SUNSET", "ATARDECER"
+        },
+        // OCEAN: Azules, cianes, verdes agua, blancos
+        {
+            100.0f / 255.0f, 150.0f / 255.0f, 200.0f / 255.0f,  // Fondo superior
+            20.0f / 255.0f, 40.0f / 255.0f, 80.0f / 255.0f,     // Fondo inferior
+            {{0, 191, 255}, {0, 255, 255}, {32, 178, 170}, {176, 224, 230},
+             {70, 130, 180}, {0, 206, 209}, {240, 248, 255}, {64, 224, 208}},
+            "OCEAN", "OCEANO"
+        },
+        // NEON: Cian, magenta, verde lima, amarillo vibrante
+        {
+            20.0f / 255.0f, 20.0f / 255.0f, 40.0f / 255.0f,     // Fondo superior
+            0.0f / 255.0f, 0.0f / 255.0f, 0.0f / 255.0f,        // Fondo inferior
+            {{0, 255, 255}, {255, 0, 255}, {50, 205, 50}, {255, 255, 0},
+             {255, 20, 147}, {0, 255, 127}, {138, 43, 226}, {255, 69, 0}},
+            "NEON", "NEON"
+        },
+        // FOREST: Verdes, marrones, amarillos otoño
+        {
+            144.0f / 255.0f, 238.0f / 255.0f, 144.0f / 255.0f,  // Fondo superior
+            101.0f / 255.0f, 67.0f / 255.0f, 33.0f / 255.0f,    // Fondo inferior
+            {{34, 139, 34}, {107, 142, 35}, {154, 205, 50}, {255, 215, 0},
+             {210, 180, 140}, {160, 82, 45}, {218, 165, 32}, {50, 205, 50}},
+            "FOREST", "BOSQUE"
+        }
+    };
+
+    // Colores específicos para debug UI por tema
+    constexpr int DEBUG_COLORS[4][3] = {
+        {255, 140, 60},  // ATARDECER: Naranja cálido
+        {80, 200, 255},  // OCEANO: Azul océano
+        {255, 60, 255},  // NEON: Magenta brillante
+        {100, 255, 100}  // BOSQUE: Verde natural
+    };
+
+    // Gestor de temas
+    class ThemeManager {
+    private:
+        ColorTheme current_theme_;
+
+    public:
+        ThemeManager(ColorTheme initial_theme = ColorTheme::SUNSET)
+            : current_theme_(initial_theme) {}
+
+        // Cambiar tema
+        void setTheme(ColorTheme theme) {
+            current_theme_ = theme;
+        }
+
+        // Ciclar al siguiente tema
+        void cycleTheme() {
+            int next = (static_cast<int>(current_theme_) + 1) % 4;
+            current_theme_ = static_cast<ColorTheme>(next);
+        }
+
+        // Obtener tema actual
+        ColorTheme getCurrentTheme() const {
+            return current_theme_;
+        }
+
+        // Obtener datos del tema actual
+        const ThemeData& getCurrentThemeData() const {
+            return THEME_DATA[static_cast<int>(current_theme_)];
+        }
+
+        // Obtener color aleatorio de la paleta actual
+        Color getRandomColor() const {
+            const auto& theme_data = getCurrentThemeData();
+            // Usar random simple para evitar dependencias
+            static int seed = 1;
+            seed = seed * 1103515245 + 12345;
+            int color_index = (seed / 65536) % 8;
+
+            return Color(
+                theme_data.element_colors[color_index][0],
+                theme_data.element_colors[color_index][1],
+                theme_data.element_colors[color_index][2]
+            );
+        }
+
+        // Obtener color específico de la paleta actual
+        Color getColor(int index) const {
+            const auto& theme_data = getCurrentThemeData();
+            index = index % 8; // Asegurar que esté en rango
+            return Color(
+                theme_data.element_colors[index][0],
+                theme_data.element_colors[index][1],
+                theme_data.element_colors[index][2]
+            );
+        }
+
+        // Obtener nombre del tema en inglés
+        const char* getThemeName() const {
+            return getCurrentThemeData().name_en;
+        }
+
+        // Obtener nombre del tema en español
+        const char* getThemeNameES() const {
+            return getCurrentThemeData().name_es;
+        }
+
+        // Obtener color de debug para el tema actual
+        Color getDebugColor() const {
+            int theme_idx = static_cast<int>(current_theme_);
+            return Color(
+                DEBUG_COLORS[theme_idx][0],
+                DEBUG_COLORS[theme_idx][1],
+                DEBUG_COLORS[theme_idx][2]
+            );
+        }
+    };
+
+    // Funciones de utilidad
+    inline const char* getThemeNameEN(ColorTheme theme) {
+        return THEME_DATA[static_cast<int>(theme)].name_en;
+    }
+
+    inline const char* getThemeNameES(ColorTheme theme) {
+        return THEME_DATA[static_cast<int>(theme)].name_es;
+    }
+}