jaildoctors_dilemma/source/screen.h

#pragma once

#include <SDL2/SDL_blendmode.h> // Para SDL_BlendMode
#include <SDL2/SDL_rect.h>		// Para SDL_Rect
#include <SDL2/SDL_render.h>	// Para SDL_Renderer, SDL_Texture
#include <SDL2/SDL_stdinc.h>	// Para Uint8, Uint32
#include <SDL2/SDL_video.h>		// Para SDL_Window
#include <stddef.h>				// Para size_t
#include <memory>				// Para shared_ptr, __shared_ptr_access
#include <string>				// Para string
#include <vector>				// Para vector
#include "utils.h"				// Para Color
struct Surface;

// Tipos de filtro
enum class ScreenFilter : Uint32
{
	NEAREST = 0,
	LINEAR = 1,
};

class Screen
{
private:
	// Estructuras
	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;
		}
	};

	// Constantes
	static constexpr int WINDOWS_DECORATIONS_ = 35;

	// [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
	SDL_Texture *shaders_texture_;								 // Textura para aplicar los shaders
	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

	// Variables
	int window_width_;					 // Ancho de la pantalla o ventana
	int window_height_;					 // Alto de la pantalla o ventana
	SDL_Rect game_rect_;				 // 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

#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 game_canvas_rect_
	void adjustGameCanvasRect();

	// Ajusta el tamaño lógico del renderizador
	void adjustRenderLogicalSize();

	// Reinicia los shaders
	void resetShaders();

	// 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);

	// Recrea la textura para los shaders
	void createShadersTexture();

	// Muestra información por pantalla
	void renderInfo();

	// Constructor
	Screen(SDL_Window *window, SDL_Renderer *renderer);

	// Destructor
	~Screen();

public:
	// [SINGLETON] Crearemos el objeto con esta función estática
	static void init(SDL_Window *window, SDL_Renderer *renderer);

	// [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(int mode);

	// Camibia entre pantalla completa y ventana
	void toggleVideoMode();

	// 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();

	// Obtiene el tamaño máximo de zoom posible para la ventana
	int getMaxZoom();

	// 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();
};