redistribuida la carpeta source

source/core/rendering/screen.hpp

@@ -0,0 +1,215 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+#include <stddef.h>  // Para size_t
+
+#include <memory>  // Para shared_ptr, __shared_ptr_access
+#include <string>  // Para string
+#include <vector>  // Para vector
+
+#include "utils/utils.hpp"  // Para Color
+struct Surface;
+namespace Rendering {
+class ShaderBackend;
+}
+
+// Tipos de filtro
+enum class ScreenFilter : Uint32 {
+    NEAREST = 0,
+    LINEAR = 1,
+};
+
+class Screen {
+    private:
+        // Constantes
+        static constexpr int WINDOWS_DECORATIONS = 35;  // Decoraciones de la ventana
+
+        struct DisplayMonitor {
+                std::string name;
+                int width;
+                int height;
+                int refresh_rate;
+        };
+
+        struct FPS {
+                Uint32 ticks;    // Tiempo en milisegundos desde que se comenzó a contar.
+                int frameCount;  // Número acumulado de frames en el intervalo.
+                int lastValue;   // Número de frames calculado en el último segundo.
+
+                // Constructor para inicializar la estructura.
+                FPS()
+                    : ticks(0),
+                      frameCount(0),
+                      lastValue(0) {}
+
+                // Incrementador que se llama en cada frame.
+                void increment() {
+                    frameCount++;
+                }
+
+                // Método para calcular y devolver el valor de FPS.
+                int calculate(Uint32 currentTicks) {
+                    if (currentTicks - ticks >= 1000)  // Si ha pasado un segundo o más.
+                    {
+                        lastValue = frameCount;  // Actualizamos el valor del último FPS.
+                        frameCount = 0;          // Reiniciamos el contador de frames.
+                        ticks = currentTicks;    // Actualizamos el tiempo base.
+                    }
+                    return lastValue;
+                }
+        };
+
+        // [SINGLETON] Objeto privado
+        static Screen* screen_;
+
+        // Objetos y punteros
+        SDL_Window* window_;                                          // Ventana de la aplicación
+        SDL_Renderer* renderer_;                                      // El renderizador de la ventana
+        SDL_Texture* game_texture_;                                   // Textura donde se dibuja el juego
+        SDL_Texture* border_texture_;                                 // Textura donde se dibuja el borde del juego
+        std::shared_ptr<Surface> game_surface_;                       // Surface principal para manejar game_surface_data_
+        std::shared_ptr<Surface> border_surface_;                     // Surface para pintar el el borde de la pantalla
+        std::shared_ptr<std::shared_ptr<Surface>> renderer_surface_;  // Puntero a la Surface que actua
+        std::unique_ptr<Rendering::ShaderBackend> shader_backend_;    // Backend de shaders (OpenGL/Metal/Vulkan)
+
+        // Variables
+        int window_width_;                    // Ancho de la pantalla o ventana
+        int window_height_;                   // Alto de la pantalla o ventana
+        SDL_FRect game_surface_dstrect_;      // Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
+        Uint8 border_color_;                  // Color del borde añadido a la textura de juego para rellenar la pantalla
+        std::vector<std::string> palettes_;   // Listado de los ficheros de paletta disponibles
+        Uint8 current_palette_ = 0;           // Indice para el vector de paletas
+        bool notifications_enabled_ = false;  // indica si se muestran las notificaciones
+        FPS fps_;                             // Variable para gestionar los frames por segundo
+        std::string info_resolution_;         // Texto con la informacion de la pantalla
+        std::string vertex_shader_source_;    // Almacena el vertex shader
+        std::string fragment_shader_source_;  // Almacena el fragment shader
+        DisplayMonitor display_monitor_;      // Informacion de la pantalla
+
+#ifdef DEBUG
+        bool show_debug_info_ = false;  // Indica si ha de mostrar/ocultar la información de la pantalla
+#else
+        bool show_debug_info_ = false;  // Indica si ha de mostrar/ocultar la información de la pantalla
+#endif
+
+        // Dibuja las notificaciones
+        void renderNotifications();
+
+        // Calcula el tamaño de la ventana
+        void adjustWindowSize();
+
+        // Ajusta el tamaño lógico del renderizador
+        void adjustRenderLogicalSize();
+
+        // Extrae los nombres de las paletas
+        void processPaletteList();
+
+        // Copia la surface a la textura
+        void surfaceToTexture();
+
+        // Copia la textura al renderizador
+        void textureToRenderer();
+
+        // Renderiza todos los overlays
+        void renderOverlays();
+
+        // Localiza la paleta dentro del vector de paletas
+        size_t findPalette(const std::string& name);
+
+        void initShaders();           // Inicializa los shaders
+        void loadShaders();           // Carga el contenido del archivo GLSL
+        void renderInfo();            // Muestra información por pantalla
+        void getDisplayInfo();        // Obtiene información sobre la pantalla
+        auto initSDLVideo() -> bool;  // Arranca SDL VIDEO y crea la ventana
+
+        // Constructor
+        Screen();
+
+        // Destructor
+        ~Screen();
+
+    public:
+        // [SINGLETON] Crearemos el objeto con esta función estática
+        static void init();
+
+        // [SINGLETON] Destruiremos el objeto con esta función estática
+        static void destroy();
+
+        // [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
+        static Screen* get();
+
+        // Limpia el renderer
+        void clearRenderer(Color color = {0x00, 0x00, 0x00});
+
+        // Limpia la game_surface_
+        void clearSurface(Uint8 index);
+
+        // Prepara para empezar a dibujar en la textura de juego
+        void start();
+
+        // Vuelca el contenido del renderizador en pantalla
+        void render();
+
+        // Actualiza la lógica de la clase
+        void update();
+
+        // Establece el modo de video
+        void setVideoMode(bool mode);
+
+        // Camibia entre pantalla completa y ventana
+        void toggleVideoMode();
+
+        // Alterna entre activar y desactivar el escalado entero
+        void toggleIntegerScale();
+
+        // Reduce el tamaño de la ventana
+        bool decWindowZoom();
+
+        // Aumenta el tamaño de la ventana
+        bool incWindowZoom();
+
+        // Cambia el color del borde
+        void setBorderColor(Uint8 color);
+
+        // Establece el tamaño del borde
+        void setBorderWidth(int width);
+
+        // Establece el tamaño del borde
+        void setBorderHeight(int height);
+
+        // Establece si se ha de ver el borde en el modo ventana
+        void setBorderEnabled(bool value);
+
+        // Cambia entre borde visible y no visible
+        void toggleBorder();
+
+        // Cambia el estado de los shaders
+        void toggleShaders();
+
+        // Muestra la ventana
+        void show();
+
+        // Oculta la ventana
+        void hide();
+
+        // Establece el renderizador para las surfaces
+        void setRendererSurface(std::shared_ptr<Surface> surface = nullptr);
+
+        // Cambia la paleta
+        void nextPalette();
+        void previousPalette();
+
+        // Establece la paleta
+        void setPalete();
+
+        // Establece la visibilidad de las notificaciones
+        void setNotificationsEnabled(bool value);
+
+        // Activa o desactiva la información de debug
+        void toggleDebugInfo();
+
+        // Getters
+        SDL_Renderer* getRenderer();
+        std::shared_ptr<Surface> getRendererSurface();
+        std::shared_ptr<Surface> getBorderSurface();
+};