Implementar arquitectura multi-backend para vibe4_shaders

- Actualizar proyecto de vibe3_physics a vibe4_shaders - Crear sistema modular de renderizado con RendererInterface - Añadir WindowManager para gestión de ventana y backends - Implementar backends: SDL (fallback), Vulkan, Metal - Añadir soporte para efectos CRT en software - Migrar sistema de renderizado a batch processing - Actualizar README con nueva arquitectura NOTA: Funcionalidad básica necesita restauración (texto y texturas) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-09-27 23:07:48 +02:00
parent 74cad13867
commit 6a84234265
13 changed files with 1914 additions and 169 deletions
--- a/source/engine.cpp
+++ b/source/engine.cpp
@@ -2,11 +2,9 @@

 #include <SDL3/SDL_error.h>    // for SDL_GetError
 #include <SDL3/SDL_events.h>   // for SDL_Event, SDL_PollEvent
-#include <SDL3/SDL_init.h>     // for SDL_Init, SDL_Quit, SDL_INIT_VIDEO
 #include <SDL3/SDL_keycode.h>  // for SDL_Keycode
-#include <SDL3/SDL_render.h>   // for SDL_SetRenderDrawColor, SDL_RenderPresent
 #include <SDL3/SDL_timer.h>    // for SDL_GetTicks
-#include <SDL3/SDL_video.h>    // for SDL_CreateWindow, SDL_DestroyWindow, SDL_GetDisplayBounds
+#include <SDL3/SDL_render.h>   // for SDL_Renderer, SDL_Texture

 #include <algorithm>  // for std::min, std::max
 #include <cstdlib>   // for rand, srand
@@ -38,49 +36,44 @@ std::string getExecutableDirectory() {

 // Implementación de métodos públicos
 bool Engine::initialize() {
-    bool success = true;
+    // Crear y configurar el window manager
+    window_manager_ = std::make_unique<vibe4::WindowManager>();

-    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_ZOOM, SCREEN_HEIGHT * WINDOW_ZOOM, 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);
-            }
-        }
+    if (!window_manager_->initialize(WINDOW_CAPTION, SCREEN_WIDTH, SCREEN_HEIGHT, WINDOW_ZOOM)) {
+        std::cout << "¡No se pudo inicializar el WindowManager!" << std::endl;
+        return false;
    }

-    // Inicializar otros componentes si SDL se inicializó correctamente
-    if (success) {
-        // Construir ruta absoluta a la imagen
-        std::string exe_dir = getExecutableDirectory();
-        std::string texture_path = exe_dir + "/data/ball.png";
-        texture_ = std::make_shared<Texture>(renderer_, texture_path);
-        srand(static_cast<unsigned>(time(nullptr)));
-        dbg_init(renderer_);
-        initializeThemes();
-        initBalls(scenario_);
+    // Configurar efectos CRT iniciales
+    crt_params_.scanline_intensity = 0.5f;
+    crt_params_.curvature_x = 0.1f;
+    crt_params_.curvature_y = 0.1f;
+    crt_params_.bloom_factor = 1.2f;
+    crt_params_.mask_brightness = 0.8f;
+    crt_params_.enable_scanlines = true;
+    crt_params_.enable_curvature = true;
+    crt_params_.enable_bloom = true;
+
+    // Aplicar parámetros CRT al renderer
+    auto* renderer = window_manager_->getRenderer();
+    if (renderer) {
+        renderer->setCRTParams(crt_params_);
+        renderer->enableCRT(crt_effects_enabled_);
+        renderer->setVSync(vsync_enabled_);
    }

-    return success;
+    // Inicializar otros componentes
+    srand(static_cast<unsigned>(time(nullptr)));
+
+    // TODO: Cargar datos de textura para sprites
+    // En una implementación completa, cargaríamos la textura aquí
+    texture_data_ = nullptr;
+
+    initializeThemes();
+    initBalls(scenario_);
+
+    std::cout << "Engine inicializado con backend: " << getBackendInfo() << std::endl;
+    return true;
 }

 void Engine::run() {
@@ -93,16 +86,14 @@ void Engine::run() {
 }

 void Engine::shutdown() {
-    // Limpiar recursos SDL
-    if (renderer_) {
-        SDL_DestroyRenderer(renderer_);
-        renderer_ = nullptr;
+    // El WindowManager se encarga de toda la limpieza
+    if (window_manager_) {
+        window_manager_->shutdown();
+        window_manager_.reset();
    }
-    if (window_) {
-        SDL_DestroyWindow(window_);
-        window_ = nullptr;
-    }
-    SDL_Quit();
+
+    // Limpiar datos de textura si los hay
+    texture_data_ = nullptr;
 }

 // Métodos privados - esqueleto básico por ahora
@@ -304,22 +295,28 @@ void Engine::render() {
    // Renderizar fondo degradado en lugar de color sólido
    renderGradientBackground();

-    // Limpiar batches del frame anterior
-    batch_vertices_.clear();
-    batch_indices_.clear();
+    // Usar el nuevo sistema de renderizado
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (!renderer) return;
+
+    // Comenzar frame de renderizado
+    renderer->beginFrame();
+
+    // Limpiar batch del frame anterior
+    clearSpriteBatch();

    // 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()));
-    }
+    // Renderizar batch completo
+    renderSpriteBatch();
+
+    // Finalizar frame
+    renderer->endFrame();

    if (show_text_) {
        // Colores acordes a cada tema (para texto del número de pelotas y nombre del tema)
@@ -387,7 +384,10 @@ void Engine::render() {
        dbg_print(8, 64, theme_text.c_str(), 255, 255, 128);  // Amarillo claro para tema
    }

-    SDL_RenderPresent(renderer_);
+    // Presentar frame final
+    if (renderer) {
+        renderer->present();
+    }
 }

 void Engine::initBalls(int value) {
@@ -412,7 +412,7 @@ void Engine::initBalls(int value) {
        const Color COLOR = theme.ball_colors[color_index];
        // Generar factor de masa aleatorio (0.7 = ligera, 1.3 = pesada)
        float mass_factor = GRAVITY_MASS_MIN + (rand() % 1000) / 1000.0f * (GRAVITY_MASS_MAX - GRAVITY_MASS_MIN);
-        balls_.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, texture_, current_screen_width_, current_screen_height_, current_gravity_, mass_factor));
+        balls_.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, nullptr, current_screen_width_, current_screen_height_, current_gravity_, mass_factor));
    }
    setText();  // Actualiza el texto
 }
@@ -476,25 +476,30 @@ void Engine::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);
+    // Aplicar el cambio de V-Sync al backend activo
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer) {
+        renderer->setVSync(vsync_enabled_);
+    }
 }

 void Engine::toggleFullscreen() {
-    // Si está en modo real fullscreen, primero salir de él
-    if (real_fullscreen_enabled_) {
-        toggleRealFullscreen();  // Esto lo desactiva
-    }
+    if (window_manager_) {
+        // Si está en modo real fullscreen, primero salir de él
+        if (real_fullscreen_enabled_) {
+            toggleRealFullscreen();  // Esto lo desactiva
+        }

-    fullscreen_enabled_ = !fullscreen_enabled_;
-    SDL_SetWindowFullscreen(window_, fullscreen_enabled_);
+        fullscreen_enabled_ = !fullscreen_enabled_;
+        window_manager_->setFullscreen(fullscreen_enabled_);
+    }
 }

 void Engine::toggleRealFullscreen() {
    // Si está en modo fullscreen normal, primero desactivarlo
    if (fullscreen_enabled_) {
        fullscreen_enabled_ = false;
-        SDL_SetWindowFullscreen(window_, false);
+        // SDL_SetWindowFullscreen(window_, false); // TODO: Migrar a WindowManager
    }

    real_fullscreen_enabled_ = !real_fullscreen_enabled_;
@@ -511,11 +516,11 @@ void Engine::toggleRealFullscreen() {
                current_screen_height_ = dm->h;

                // Recrear ventana con nueva resolución
-                SDL_SetWindowSize(window_, current_screen_width_, current_screen_height_);
-                SDL_SetWindowFullscreen(window_, true);
+                // SDL_SetWindowSize(window_, current_screen_width_, current_screen_height_); // TODO: Migrar a WindowManager
+                // SDL_SetWindowFullscreen(window_, true); // TODO: Migrar a WindowManager

                // Actualizar presentación lógica del renderizador
-                SDL_SetRenderLogicalPresentation(renderer_, current_screen_width_, current_screen_height_, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
+                // SDL_SetRenderLogicalPresentation(renderer_, current_screen_width_, current_screen_height_, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE); // TODO: Migrar a WindowManager

                // Reinicar la escena con nueva resolución
                initBalls(scenario_);
@@ -528,11 +533,11 @@ void Engine::toggleRealFullscreen() {
        current_screen_height_ = SCREEN_HEIGHT;

        // Restaurar ventana normal
-        SDL_SetWindowFullscreen(window_, false);
-        SDL_SetWindowSize(window_, SCREEN_WIDTH * WINDOW_ZOOM, SCREEN_HEIGHT * WINDOW_ZOOM);
+        // SDL_SetWindowFullscreen(window_, false); // TODO: Migrar a WindowManager
+        // SDL_SetWindowSize(window_, SCREEN_WIDTH * WINDOW_ZOOM, SCREEN_HEIGHT * WINDOW_ZOOM); // TODO: Migrar a WindowManager

        // Restaurar presentación lógica original
-        SDL_SetRenderLogicalPresentation(renderer_, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
+        // SDL_SetRenderLogicalPresentation(renderer_, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE); // TODO: Migrar a WindowManager

        // Reinicar la escena con resolución original
        initBalls(scenario_);
@@ -587,56 +592,22 @@ void Engine::renderGradientBackground() {
    // Í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);
-}
+    // TODO: Migrar renderizado de fondo degradado al nuevo sistema
+    // SDL_RenderGeometry(renderer_, nullptr, bg_vertices, 4, bg_indices, 6);

-void Engine::addSpriteToBatch(float x, float y, float w, float h, int r, int g, int 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 int (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]);
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer) {
+        renderer->renderGradientBackground(
+            theme.bg_top_r, theme.bg_top_g, theme.bg_top_b,
+            theme.bg_bottom_r, theme.bg_bottom_g, theme.bg_bottom_b
+        );
    }
-
-    // Añadir índices para 2 triángulos
-    batch_indices_.push_back(vertex_index + 0);
-    batch_indices_.push_back(vertex_index + 1);
-    batch_indices_.push_back(vertex_index + 2);
-    batch_indices_.push_back(vertex_index + 2);
-    batch_indices_.push_back(vertex_index + 3);
-    batch_indices_.push_back(vertex_index + 0);
 }

-// Sistema de zoom dinámico
+// Método addSpriteToBatch antiguo eliminado - ahora se usa el del nuevo sistema
+
+// Métodos de zoom obsoletos - migrados a WindowManager
+/*
 int Engine::calculateMaxWindowZoom() const {
    // Obtener información del display usando el método de Coffee Crisis
    int num_displays = 0;
@@ -711,6 +682,7 @@ void Engine::zoomIn() {
 void Engine::zoomOut() {
    setWindowZoom(current_window_zoom_ - 1);
 }
+*/

 void Engine::initializeThemes() {
    // SUNSET: Naranjas, rojos, amarillos, rosas (8 colores)
@@ -816,4 +788,99 @@ void Engine::performRandomRestart() {
    // Resetear temporizador
    all_balls_were_stopped_ = false;
    all_balls_stopped_start_time_ = 0;
+}
+
+// Métodos del nuevo sistema de renderizado
+
+void Engine::zoomIn() {
+    if (window_manager_) {
+        window_manager_->zoomIn();
+    }
+}
+
+void Engine::zoomOut() {
+    if (window_manager_) {
+        window_manager_->zoomOut();
+    }
+}
+
+void Engine::toggleCRTEffects() {
+    crt_effects_enabled_ = !crt_effects_enabled_;
+
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer) {
+        renderer->enableCRT(crt_effects_enabled_);
+    }
+
+    std::cout << "Efectos CRT: " << (crt_effects_enabled_ ? "ON" : "OFF") << std::endl;
+}
+
+void Engine::adjustScanlineIntensity(float delta) {
+    crt_params_.scanline_intensity = std::max(0.0f, std::min(1.0f, crt_params_.scanline_intensity + delta));
+
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer) {
+        renderer->setCRTParams(crt_params_);
+    }
+
+    std::cout << "Intensidad scanlines: " << crt_params_.scanline_intensity << std::endl;
+}
+
+void Engine::adjustCurvature(float delta) {
+    crt_params_.curvature_x = std::max(0.0f, std::min(0.5f, crt_params_.curvature_x + delta));
+    crt_params_.curvature_y = crt_params_.curvature_x; // Mantener proporción
+
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer) {
+        renderer->setCRTParams(crt_params_);
+    }
+
+    std::cout << "Curvatura CRT: " << crt_params_.curvature_x << std::endl;
+}
+
+void Engine::adjustBloom(float delta) {
+    crt_params_.bloom_factor = std::max(1.0f, std::min(3.0f, crt_params_.bloom_factor + delta));
+
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer) {
+        renderer->setCRTParams(crt_params_);
+    }
+
+    std::cout << "Factor bloom: " << crt_params_.bloom_factor << std::endl;
+}
+
+void Engine::switchRenderingBackend() {
+    // En una implementación completa, esto cambiaría entre backends disponibles
+    std::cout << "Cambio de backend no implementado aún" << std::endl;
+}
+
+std::string Engine::getBackendInfo() const {
+    if (window_manager_ && window_manager_->getRenderer()) {
+        return std::string(window_manager_->getBackendName());
+    }
+    return "None";
+}
+
+void Engine::clearSpriteBatch() {
+    sprite_batch_.clear();
+}
+
+void Engine::renderSpriteBatch() {
+    auto* renderer = window_manager_ ? window_manager_->getRenderer() : nullptr;
+    if (renderer && !sprite_batch_.empty()) {
+        renderer->renderSpriteBatch(sprite_batch_, texture_data_);
+    }
+}
+
+void Engine::addSpriteToBatch(float x, float y, float w, float h, int r, int g, int b) {
+    vibe4::SpriteData sprite;
+    sprite.x = x;
+    sprite.y = y;
+    sprite.w = w;
+    sprite.h = h;
+    sprite.r = static_cast<float>(r);
+    sprite.g = static_cast<float>(g);
+    sprite.b = static_cast<float>(b);
+
+    sprite_batch_.push_back(sprite);
 }