From 6ff7ccf69a8c376fd42c25fedd532d9371b23f3a Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Thu, 2 Oct 2025 18:15:39 +0200 Subject: [PATCH] migrat a OpenGL 3.3 Core Profile --- CMakeLists.txt | 11 +- config/assets.txt | 3 +- data/shaders/crtpi.glsl | 259 ++++++------ data/shaders/crtpi_fragment.glsl | 157 ++++++++ data/shaders/crtpi_vertex.glsl | 48 +++ source/external/jail_shader.cpp | 468 ---------------------- source/external/jail_shader.h | 10 - source/rendering/opengl/opengl_shader.cpp | 455 +++++++++++++++++++++ source/rendering/opengl/opengl_shader.h | 98 +++++ source/rendering/shader_backend.h | 55 +++ source/screen.cpp | 39 +- source/screen.h | 21 +- 12 files changed, 981 insertions(+), 643 deletions(-) create mode 100644 data/shaders/crtpi_fragment.glsl create mode 100644 data/shaders/crtpi_vertex.glsl delete mode 100644 source/external/jail_shader.cpp delete mode 100644 source/external/jail_shader.h create mode 100644 source/rendering/opengl/opengl_shader.cpp create mode 100644 source/rendering/opengl/opengl_shader.h create mode 100644 source/rendering/shader_backend.h diff --git a/CMakeLists.txt b/CMakeLists.txt index f067580..8a17012 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -111,9 +111,13 @@ set(APP_SOURCES # Fuentes de librerías de terceros set(EXTERNAL_SOURCES source/external/jail_audio.cpp - source/external/jail_shader.cpp source/external/json.hpp - source/external/gif.cpp + source/external/gif.cpp +) + +# Fuentes del sistema de renderizado +set(RENDERING_SOURCES + source/rendering/opengl/opengl_shader.cpp ) # Configuración de SDL3 @@ -121,12 +125,13 @@ find_package(SDL3 REQUIRED CONFIG REQUIRED COMPONENTS SDL3) message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}") # --- 2. AÑADIR EJECUTABLE --- -add_executable(${PROJECT_NAME} ${APP_SOURCES} ${EXTERNAL_SOURCES}) +add_executable(${PROJECT_NAME} ${APP_SOURCES} ${EXTERNAL_SOURCES} ${RENDERING_SOURCES}) # --- 3. DIRECTORIOS DE INCLUSIÓN --- target_include_directories(${PROJECT_NAME} PUBLIC "${CMAKE_SOURCE_DIR}/source" "${CMAKE_SOURCE_DIR}/source/external" + "${CMAKE_SOURCE_DIR}/source/rendering" "${CMAKE_BINARY_DIR}" ) diff --git a/config/assets.txt b/config/assets.txt index 643d8bc..59bd652 100644 --- a/config/assets.txt +++ b/config/assets.txt @@ -75,7 +75,8 @@ SOUND|${PREFIX}/data/sound/voice_thankyou.wav SOUND|${PREFIX}/data/sound/walk.wav # Shaders -DATA|${PREFIX}/data/shaders/crtpi.glsl +DATA|${PREFIX}/data/shaders/crtpi_vertex.glsl +DATA|${PREFIX}/data/shaders/crtpi_fragment.glsl # Texturas - Balloons ANIMATION|${PREFIX}/data/gfx/balloon/balloon0.ani diff --git a/data/shaders/crtpi.glsl b/data/shaders/crtpi.glsl index 8b32202..28d2ced 100644 --- a/data/shaders/crtpi.glsl +++ b/data/shaders/crtpi.glsl @@ -1,5 +1,6 @@ /* crt-pi - A Raspberry Pi friendly CRT shader. + Modernized to OpenGL 3.3 Core Profile Copyright (C) 2015-2016 davej @@ -7,35 +8,8 @@ under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - - -Notes: - -This shader is designed to work well on Raspberry Pi GPUs (i.e. 1080P @ 60Hz on a game with a 4:3 aspect ratio). It pushes the Pi's GPU hard and enabling some features will slow it down so that it is no longer able to match 1080P @ 60Hz. You will need to overclock your Pi to the fastest setting in raspi-config to get the best results from this shader: 'Pi2' for Pi2 and 'Turbo' for original Pi and Pi Zero. Note: Pi2s are slower at running the shader than other Pis, this seems to be down to Pi2s lower maximum memory speed. Pi2s don't quite manage 1080P @ 60Hz - they drop about 1 in 1000 frames. You probably won't notice this, but if you do, try enabling FAKE_GAMMA. - -SCANLINES enables scanlines. You'll almost certainly want to use it with MULTISAMPLE to reduce moire effects. SCANLINE_WEIGHT defines how wide scanlines are (it is an inverse value so a higher number = thinner lines). SCANLINE_GAP_BRIGHTNESS defines how dark the gaps between the scan lines are. Darker gaps between scan lines make moire effects more likely. - -GAMMA enables gamma correction using the values in INPUT_GAMMA and OUTPUT_GAMMA. FAKE_GAMMA causes it to ignore the values in INPUT_GAMMA and OUTPUT_GAMMA and approximate gamma correction in a way which is faster than true gamma whilst still looking better than having none. You must have GAMMA defined to enable FAKE_GAMMA. - -CURVATURE distorts the screen by CURVATURE_X and CURVATURE_Y. Curvature slows things down a lot. - -By default the shader uses linear blending horizontally. If you find this too blury, enable SHARPER. - -BLOOM_FACTOR controls the increase in width for bright scanlines. - -MASK_TYPE defines what, if any, shadow mask to use. MASK_BRIGHTNESS defines how much the mask type darkens the screen. - */ -#pragma parameter CURVATURE_X "Screen curvature - horizontal" 0.10 0.0 1.0 0.01 -#pragma parameter CURVATURE_Y "Screen curvature - vertical" 0.15 0.0 1.0 0.01 -#pragma parameter MASK_BRIGHTNESS "Mask brightness" 0.70 0.0 1.0 0.01 -#pragma parameter SCANLINE_WEIGHT "Scanline weight" 6.0 0.0 15.0 0.1 -#pragma parameter SCANLINE_GAP_BRIGHTNESS "Scanline gap brightness" 0.12 0.0 1.0 0.01 -#pragma parameter BLOOM_FACTOR "Bloom factor" 1.5 0.0 5.0 0.01 -#pragma parameter INPUT_GAMMA "Input gamma" 2.4 0.0 5.0 0.01 -#pragma parameter OUTPUT_GAMMA "Output gamma" 2.2 0.0 5.0 0.01 - // Haven't put these as parameters as it would slow the code down. #define SCANLINES #define MULTISAMPLE @@ -46,24 +20,6 @@ MASK_TYPE defines what, if any, shadow mask to use. MASK_BRIGHTNESS defines how // MASK_TYPE: 0 = none, 1 = green/magenta, 2 = trinitron(ish) #define MASK_TYPE 2 - -#ifdef GL_ES -#define COMPAT_PRECISION mediump -precision mediump float; -#else -#define COMPAT_PRECISION -#endif - -#ifdef PARAMETER_UNIFORM -uniform COMPAT_PRECISION float CURVATURE_X; -uniform COMPAT_PRECISION float CURVATURE_Y; -uniform COMPAT_PRECISION float MASK_BRIGHTNESS; -uniform COMPAT_PRECISION float SCANLINE_WEIGHT; -uniform COMPAT_PRECISION float SCANLINE_GAP_BRIGHTNESS; -uniform COMPAT_PRECISION float BLOOM_FACTOR; -uniform COMPAT_PRECISION float INPUT_GAMMA; -uniform COMPAT_PRECISION float OUTPUT_GAMMA; -#else #define CURVATURE_X 0.05 #define CURVATURE_Y 0.1 #define MASK_BRIGHTNESS 0.80 @@ -72,76 +28,94 @@ uniform COMPAT_PRECISION float OUTPUT_GAMMA; #define BLOOM_FACTOR 3.5 #define INPUT_GAMMA 2.4 #define OUTPUT_GAMMA 2.2 -#endif - -/* COMPATIBILITY - - GLSL compilers -*/ - -// Uniform para el tamaño de textura (pasado desde C++) -uniform vec2 TextureSize; - -#if defined(CURVATURE) -varying vec2 screenScale; -#endif -varying vec2 TEX0; -varying float filterWidth; #if defined(VERTEX) -//uniform mat4 MVPMatrix; -//attribute vec4 VertexCoord; -//attribute vec2 TexCoord; -//uniform vec2 InputSize; -//uniform vec2 OutputSize; +// ============================================================================ +// VERTEX SHADER +// ============================================================================ +#version 330 core + +// Inputs (desde VAO) +layout(location = 0) in vec2 aPosition; +layout(location = 1) in vec2 aTexCoord; + +// Outputs al fragment shader +out vec2 vTexCoord; +out float vFilterWidth; +#if defined(CURVATURE) +out vec2 vScreenScale; +#endif + +// Uniforms +uniform vec2 TextureSize; void main() { #if defined(CURVATURE) - screenScale = vec2(1.0, 1.0); //TextureSize / InputSize; + vScreenScale = vec2(1.0, 1.0); #endif // Calcula filterWidth dinámicamente basándose en la altura de la textura - filterWidth = (768.0 / TextureSize.y) / 3.0; - TEX0 = vec2(gl_MultiTexCoord0.x, 1.0-gl_MultiTexCoord0.y)*1.0001; - gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; -} -#elif defined(FRAGMENT) + vFilterWidth = (768.0 / TextureSize.y) / 3.0; + // Pasar coordenadas de textura (invertir Y para SDL) + vTexCoord = vec2(aTexCoord.x, 1.0 - aTexCoord.y) * 1.0001; + + // Posición del vértice (ya en espacio de clip [-1, 1]) + gl_Position = vec4(aPosition, 0.0, 1.0); +} + +#elif defined(FRAGMENT) +// ============================================================================ +// FRAGMENT SHADER +// ============================================================================ +#version 330 core + +// Inputs desde vertex shader +in vec2 vTexCoord; +in float vFilterWidth; +#if defined(CURVATURE) +in vec2 vScreenScale; +#endif + +// Output +out vec4 FragColor; + +// Uniforms uniform sampler2D Texture; +uniform vec2 TextureSize; #if defined(CURVATURE) vec2 Distort(vec2 coord) { vec2 CURVATURE_DISTORTION = vec2(CURVATURE_X, CURVATURE_Y); - // Barrel distortion shrinks the display area a bit, this will allow us to counteract that. vec2 barrelScale = 1.0 - (0.23 * CURVATURE_DISTORTION); - coord *= screenScale; + coord *= vScreenScale; coord -= vec2(0.5); float rsq = coord.x * coord.x + coord.y * coord.y; coord += coord * (CURVATURE_DISTORTION * rsq); coord *= barrelScale; if (abs(coord.x) >= 0.5 || abs(coord.y) >= 0.5) - coord = vec2(-1.0); // If out of bounds, return an invalid value. + coord = vec2(-1.0); else { coord += vec2(0.5); - coord /= screenScale; + coord /= vScreenScale; } - return coord; } #endif float CalcScanLineWeight(float dist) { - return max(1.0-dist*dist*SCANLINE_WEIGHT, SCANLINE_GAP_BRIGHTNESS); + return max(1.0 - dist * dist * SCANLINE_WEIGHT, SCANLINE_GAP_BRIGHTNESS); } float CalcScanLine(float dy) { float scanLineWeight = CalcScanLineWeight(dy); #if defined(MULTISAMPLE) - scanLineWeight += CalcScanLineWeight(dy-filterWidth); - scanLineWeight += CalcScanLineWeight(dy+filterWidth); + scanLineWeight += CalcScanLineWeight(dy - vFilterWidth); + scanLineWeight += CalcScanLineWeight(dy + vFilterWidth); scanLineWeight *= 0.3333333; #endif return scanLineWeight; @@ -149,89 +123,90 @@ float CalcScanLine(float dy) void main() { - // TextureSize ahora viene como uniform, no está hardcodeado #if defined(CURVATURE) - vec2 texcoord = Distort(TEX0); - if (texcoord.x < 0.0) - gl_FragColor = vec4(0.0); - else + vec2 texcoord = Distort(vTexCoord); + if (texcoord.x < 0.0) { + FragColor = vec4(0.0); + return; + } #else - vec2 texcoord = TEX0; -#endif - { - vec2 texcoordInPixels = texcoord * TextureSize; -#if defined(SHARPER) - vec2 tempCoord = floor(texcoordInPixels) + 0.5; - vec2 coord = tempCoord / TextureSize; - vec2 deltas = texcoordInPixels - tempCoord; - float scanLineWeight = CalcScanLine(deltas.y); - vec2 signs = sign(deltas); - deltas.x *= 2.0; - deltas = deltas * deltas; - deltas.y = deltas.y * deltas.y; - deltas.x *= 0.5; - deltas.y *= 8.0; - deltas /= TextureSize; - deltas *= signs; - vec2 tc = coord + deltas; -#else - float tempY = floor(texcoordInPixels.y) + 0.5; - float yCoord = tempY / TextureSize.y; - float dy = texcoordInPixels.y - tempY; - float scanLineWeight = CalcScanLine(dy); - float signY = sign(dy); - dy = dy * dy; - dy = dy * dy; - dy *= 8.0; - dy /= TextureSize.y; - dy *= signY; - vec2 tc = vec2(texcoord.x, yCoord + dy); + vec2 texcoord = vTexCoord; #endif - vec3 colour = texture2D(Texture, tc).rgb; + vec2 texcoordInPixels = texcoord * TextureSize; + +#if defined(SHARPER) + vec2 tempCoord = floor(texcoordInPixels) + 0.5; + vec2 coord = tempCoord / TextureSize; + vec2 deltas = texcoordInPixels - tempCoord; + float scanLineWeight = CalcScanLine(deltas.y); + vec2 signs = sign(deltas); + deltas.x *= 2.0; + deltas = deltas * deltas; + deltas.y = deltas.y * deltas.y; + deltas.x *= 0.5; + deltas.y *= 8.0; + deltas /= TextureSize; + deltas *= signs; + vec2 tc = coord + deltas; +#else + float tempY = floor(texcoordInPixels.y) + 0.5; + float yCoord = tempY / TextureSize.y; + float dy = texcoordInPixels.y - tempY; + float scanLineWeight = CalcScanLine(dy); + float signY = sign(dy); + dy = dy * dy; + dy = dy * dy; + dy *= 8.0; + dy /= TextureSize.y; + dy *= signY; + vec2 tc = vec2(texcoord.x, yCoord + dy); +#endif + + // texture() en vez de texture2D() (OpenGL 3.3+) + vec3 colour = texture(Texture, tc).rgb; #if defined(SCANLINES) #if defined(GAMMA) #if defined(FAKE_GAMMA) - colour = colour * colour; + colour = colour * colour; #else - colour = pow(colour, vec3(INPUT_GAMMA)); + colour = pow(colour, vec3(INPUT_GAMMA)); #endif #endif - scanLineWeight *= BLOOM_FACTOR; - colour *= scanLineWeight; + scanLineWeight *= BLOOM_FACTOR; + colour *= scanLineWeight; #if defined(GAMMA) #if defined(FAKE_GAMMA) - colour = sqrt(colour); + colour = sqrt(colour); #else - colour = pow(colour, vec3(1.0/OUTPUT_GAMMA)); + colour = pow(colour, vec3(1.0 / OUTPUT_GAMMA)); #endif #endif -#endif -#if MASK_TYPE == 0 - gl_FragColor = vec4(colour, 1.0); -#else -#if MASK_TYPE == 1 - float whichMask = fract((gl_FragCoord.x*1.0001) * 0.5); - vec3 mask; - if (whichMask < 0.5) - mask = vec3(MASK_BRIGHTNESS, 1.0, MASK_BRIGHTNESS); - else - mask = vec3(1.0, MASK_BRIGHTNESS, 1.0); -#elif MASK_TYPE == 2 - float whichMask = fract((gl_FragCoord.x*1.0001) * 0.3333333); - vec3 mask = vec3(MASK_BRIGHTNESS, MASK_BRIGHTNESS, MASK_BRIGHTNESS); - if (whichMask < 0.3333333) - mask.x = 1.0; - else if (whichMask < 0.6666666) - mask.y = 1.0; - else - mask.z = 1.0; #endif - gl_FragColor = vec4(colour * mask, 1.0); +#if MASK_TYPE == 0 + FragColor = vec4(colour, 1.0); +#elif MASK_TYPE == 1 + float whichMask = fract(gl_FragCoord.x * 0.5); + vec3 mask; + if (whichMask < 0.5) + mask = vec3(MASK_BRIGHTNESS, 1.0, MASK_BRIGHTNESS); + else + mask = vec3(1.0, MASK_BRIGHTNESS, 1.0); + FragColor = vec4(colour * mask, 1.0); +#elif MASK_TYPE == 2 + float whichMask = fract(gl_FragCoord.x * 0.3333333); + vec3 mask = vec3(MASK_BRIGHTNESS, MASK_BRIGHTNESS, MASK_BRIGHTNESS); + if (whichMask < 0.3333333) + mask.x = 1.0; + else if (whichMask < 0.6666666) + mask.y = 1.0; + else + mask.z = 1.0; + FragColor = vec4(colour * mask, 1.0); #endif - } } + #endif diff --git a/data/shaders/crtpi_fragment.glsl b/data/shaders/crtpi_fragment.glsl new file mode 100644 index 0000000..cd63e80 --- /dev/null +++ b/data/shaders/crtpi_fragment.glsl @@ -0,0 +1,157 @@ +#version 330 core + +// Configuración +#define SCANLINES +#define MULTISAMPLE +#define GAMMA +//#define FAKE_GAMMA +//#define CURVATURE +//#define SHARPER +#define MASK_TYPE 2 + +#define CURVATURE_X 0.05 +#define CURVATURE_Y 0.1 +#define MASK_BRIGHTNESS 0.80 +#define SCANLINE_WEIGHT 6.0 +#define SCANLINE_GAP_BRIGHTNESS 0.12 +#define BLOOM_FACTOR 3.5 +#define INPUT_GAMMA 2.4 +#define OUTPUT_GAMMA 2.2 + +// Inputs desde vertex shader +in vec2 vTexCoord; +in float vFilterWidth; +#if defined(CURVATURE) +in vec2 vScreenScale; +#endif + +// Output +out vec4 FragColor; + +// Uniforms +uniform sampler2D Texture; +uniform vec2 TextureSize; + +#if defined(CURVATURE) +vec2 Distort(vec2 coord) +{ + vec2 CURVATURE_DISTORTION = vec2(CURVATURE_X, CURVATURE_Y); + vec2 barrelScale = 1.0 - (0.23 * CURVATURE_DISTORTION); + coord *= vScreenScale; + coord -= vec2(0.5); + float rsq = coord.x * coord.x + coord.y * coord.y; + coord += coord * (CURVATURE_DISTORTION * rsq); + coord *= barrelScale; + if (abs(coord.x) >= 0.5 || abs(coord.y) >= 0.5) + coord = vec2(-1.0); + else + { + coord += vec2(0.5); + coord /= vScreenScale; + } + return coord; +} +#endif + +float CalcScanLineWeight(float dist) +{ + return max(1.0 - dist * dist * SCANLINE_WEIGHT, SCANLINE_GAP_BRIGHTNESS); +} + +float CalcScanLine(float dy) +{ + float scanLineWeight = CalcScanLineWeight(dy); +#if defined(MULTISAMPLE) + scanLineWeight += CalcScanLineWeight(dy - vFilterWidth); + scanLineWeight += CalcScanLineWeight(dy + vFilterWidth); + scanLineWeight *= 0.3333333; +#endif + return scanLineWeight; +} + +void main() +{ +#if defined(CURVATURE) + vec2 texcoord = Distort(vTexCoord); + if (texcoord.x < 0.0) { + FragColor = vec4(0.0); + return; + } +#else + vec2 texcoord = vTexCoord; +#endif + + vec2 texcoordInPixels = texcoord * TextureSize; + +#if defined(SHARPER) + vec2 tempCoord = floor(texcoordInPixels) + 0.5; + vec2 coord = tempCoord / TextureSize; + vec2 deltas = texcoordInPixels - tempCoord; + float scanLineWeight = CalcScanLine(deltas.y); + vec2 signs = sign(deltas); + deltas.x *= 2.0; + deltas = deltas * deltas; + deltas.y = deltas.y * deltas.y; + deltas.x *= 0.5; + deltas.y *= 8.0; + deltas /= TextureSize; + deltas *= signs; + vec2 tc = coord + deltas; +#else + float tempY = floor(texcoordInPixels.y) + 0.5; + float yCoord = tempY / TextureSize.y; + float dy = texcoordInPixels.y - tempY; + float scanLineWeight = CalcScanLine(dy); + float signY = sign(dy); + dy = dy * dy; + dy = dy * dy; + dy *= 8.0; + dy /= TextureSize.y; + dy *= signY; + vec2 tc = vec2(texcoord.x, yCoord + dy); +#endif + + vec3 colour = texture(Texture, tc).rgb; + +#if defined(SCANLINES) +#if defined(GAMMA) +#if defined(FAKE_GAMMA) + colour = colour * colour; +#else + colour = pow(colour, vec3(INPUT_GAMMA)); +#endif +#endif + scanLineWeight *= BLOOM_FACTOR; + colour *= scanLineWeight; + +#if defined(GAMMA) +#if defined(FAKE_GAMMA) + colour = sqrt(colour); +#else + colour = pow(colour, vec3(1.0 / OUTPUT_GAMMA)); +#endif +#endif +#endif + +#if MASK_TYPE == 0 + FragColor = vec4(colour, 1.0); +#elif MASK_TYPE == 1 + float whichMask = fract(gl_FragCoord.x * 0.5); + vec3 mask; + if (whichMask < 0.5) + mask = vec3(MASK_BRIGHTNESS, 1.0, MASK_BRIGHTNESS); + else + mask = vec3(1.0, MASK_BRIGHTNESS, 1.0); + FragColor = vec4(colour * mask, 1.0); +#elif MASK_TYPE == 2 + float whichMask = fract(gl_FragCoord.x * 0.3333333); + vec3 mask = vec3(MASK_BRIGHTNESS, MASK_BRIGHTNESS, MASK_BRIGHTNESS); + if (whichMask < 0.3333333) + mask.x = 1.0; + else if (whichMask < 0.6666666) + mask.y = 1.0; + else + mask.z = 1.0; + FragColor = vec4(colour * mask, 1.0); +#endif +} diff --git a/data/shaders/crtpi_vertex.glsl b/data/shaders/crtpi_vertex.glsl new file mode 100644 index 0000000..66102c6 --- /dev/null +++ b/data/shaders/crtpi_vertex.glsl @@ -0,0 +1,48 @@ +#version 330 core + +// Configuración +#define SCANLINES +#define MULTISAMPLE +#define GAMMA +//#define FAKE_GAMMA +//#define CURVATURE +//#define SHARPER +#define MASK_TYPE 2 + +#define CURVATURE_X 0.05 +#define CURVATURE_Y 0.1 +#define MASK_BRIGHTNESS 0.80 +#define SCANLINE_WEIGHT 6.0 +#define SCANLINE_GAP_BRIGHTNESS 0.12 +#define BLOOM_FACTOR 3.5 +#define INPUT_GAMMA 2.4 +#define OUTPUT_GAMMA 2.2 + +// Inputs (desde VAO) +layout(location = 0) in vec2 aPosition; +layout(location = 1) in vec2 aTexCoord; + +// Outputs al fragment shader +out vec2 vTexCoord; +out float vFilterWidth; +#if defined(CURVATURE) +out vec2 vScreenScale; +#endif + +// Uniforms +uniform vec2 TextureSize; + +void main() +{ +#if defined(CURVATURE) + vScreenScale = vec2(1.0, 1.0); +#endif + // Calcula filterWidth dinámicamente basándose en la altura de la textura + vFilterWidth = (768.0 / TextureSize.y) / 3.0; + + // Pasar coordenadas de textura (invertir Y para SDL) + vTexCoord = vec2(aTexCoord.x, 1.0 - aTexCoord.y) * 1.0001; + + // Posición del vértice (ya en espacio de clip [-1, 1]) + gl_Position = vec4(aPosition, 0.0, 1.0); +} diff --git a/source/external/jail_shader.cpp b/source/external/jail_shader.cpp deleted file mode 100644 index 33fbee4..0000000 --- a/source/external/jail_shader.cpp +++ /dev/null @@ -1,468 +0,0 @@ -#include "jail_shader.h" - -#include // Para SDL_GL_GetProcAddress, SDL_LogError -#include // Para uintptr_t -#include // Para strncmp -#include // Para runtime_error -#include // Para vector - -#ifdef __APPLE__ -#include // Para OpenGL en macOS - -#include "CoreFoundation/CoreFoundation.h" // Para Core Foundation en macOS -#if ESSENTIAL_GL_PRACTICES_SUPPORT_GL3 -#include // Para OpenGL 3 en macOS -#else // NO ESSENTIAL_GL_PRACTICES_SUPPORT_GL3 -#include // Para OpenGL (compatibilidad) en macOS -#endif // ESSENTIAL_GL_PRACTICES_SUPPORT_GL3 -#else // SI NO ES __APPLE__ -#include // Para GLuint, GLint, glTexCoord2f, glVertex2f -#endif // __APPLE__ - -namespace shader { -// Constantes -const GLuint INVALID_SHADER_ID = 0; -const GLuint INVALID_PROGRAM_ID = 0; -const GLuint DEFAULT_TEXTURE_ID = 1; - -// Variables globales -SDL_Window *win = nullptr; -SDL_Renderer *renderer = nullptr; -GLuint programId = 0; -SDL_Texture *backBuffer = nullptr; -SDL_Point win_size = {320 * 4, 256 * 4}; -SDL_FPoint tex_size = {320, 256}; -bool usingOpenGL = false; - -#ifndef __APPLE__ -// Declaración de funciones de extensión de OpenGL (evitando GLEW) -PFNGLCREATESHADERPROC glCreateShader; -PFNGLSHADERSOURCEPROC glShaderSource; -PFNGLCOMPILESHADERPROC glCompileShader; -PFNGLGETSHADERIVPROC glGetShaderiv; -PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; -PFNGLDELETESHADERPROC glDeleteShader; -PFNGLATTACHSHADERPROC glAttachShader; -PFNGLCREATEPROGRAMPROC glCreateProgram; -PFNGLLINKPROGRAMPROC glLinkProgram; -PFNGLVALIDATEPROGRAMPROC glValidateProgram; -PFNGLGETPROGRAMIVPROC glGetProgramiv; -PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; -PFNGLUSEPROGRAMPROC glUseProgram; -PFNGLDELETEPROGRAMPROC glDeleteProgram; -PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; -PFNGLUNIFORM2FPROC glUniform2f; - -bool initGLExtensions() { - glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader"); - glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource"); - glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader"); - glGetShaderiv = (PFNGLGETSHADERIVPROC)SDL_GL_GetProcAddress("glGetShaderiv"); - glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)SDL_GL_GetProcAddress("glGetShaderInfoLog"); - glDeleteShader = (PFNGLDELETESHADERPROC)SDL_GL_GetProcAddress("glDeleteShader"); - glAttachShader = (PFNGLATTACHSHADERPROC)SDL_GL_GetProcAddress("glAttachShader"); - glCreateProgram = (PFNGLCREATEPROGRAMPROC)SDL_GL_GetProcAddress("glCreateProgram"); - glLinkProgram = (PFNGLLINKPROGRAMPROC)SDL_GL_GetProcAddress("glLinkProgram"); - glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)SDL_GL_GetProcAddress("glValidateProgram"); - glGetProgramiv = (PFNGLGETPROGRAMIVPROC)SDL_GL_GetProcAddress("glGetProgramiv"); - glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog"); - glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram"); - glDeleteProgram = (PFNGLDELETEPROGRAMPROC)SDL_GL_GetProcAddress("glDeleteProgram"); - glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)SDL_GL_GetProcAddress("glGetUniformLocation"); - glUniform2f = (PFNGLUNIFORM2FPROC)SDL_GL_GetProcAddress("glUniform2f"); - - return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && - glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram && - glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog && - glUseProgram && glDeleteProgram && glGetUniformLocation && glUniform2f; -} -#endif - -// Función para verificar errores de OpenGL -void checkGLError(const char *operation) { - GLenum error = glGetError(); - if (error != GL_NO_ERROR) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, - "Error OpenGL en %s: 0x%x", - operation, - error); - } -} - -// Función para compilar un shader a partir de un std::string -GLuint compileShader(const std::string &source, GLuint shader_type) { - if (source.empty()) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "ERROR FATAL: El código fuente del shader está vacío."); - throw std::runtime_error("ERROR FATAL: El código fuente del shader está vacío."); - } - - // Crear identificador del shader - GLuint shader_id = glCreateShader(shader_type); - if (shader_id == INVALID_SHADER_ID) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al crear el shader."); - checkGLError("glCreateShader"); - return INVALID_SHADER_ID; - } - - // Agregar una directiva según el tipo de shader - std::string directive = (shader_type == GL_VERTEX_SHADER) - ? "#define VERTEX\n" - : "#define FRAGMENT\n"; - - const char *sources[2] = {directive.c_str(), source.c_str()}; - - // Especificar el código fuente del shader - glShaderSource(shader_id, 2, sources, nullptr); - checkGLError("glShaderSource"); - - // Compilar el shader - glCompileShader(shader_id); - checkGLError("glCompileShader"); - - // Verificar si la compilación fue exitosa - GLint compiled_ok = GL_FALSE; - glGetShaderiv(shader_id, GL_COMPILE_STATUS, &compiled_ok); - if (compiled_ok != GL_TRUE) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error en la compilación del shader (%d)!", shader_id); - GLint log_length; - glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &log_length); - if (log_length > 0) { - std::vector log(log_length); - glGetShaderInfoLog(shader_id, log_length, &log_length, log.data()); - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Registro de compilación del shader: %s", log.data()); - } - glDeleteShader(shader_id); - return INVALID_SHADER_ID; - } - return shader_id; -} - -// Función para compilar un programa de shaders (vertex y fragment) a partir de std::string -GLuint compileProgram(const std::string &vertex_shader_source, const std::string &fragment_shader_source) { - GLuint program_id = glCreateProgram(); - if (program_id == INVALID_PROGRAM_ID) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al crear el programa de shaders."); - checkGLError("glCreateProgram"); - return INVALID_PROGRAM_ID; - } - - // Si el fragment shader está vacío, reutilizamos el código del vertex shader - GLuint vertex_shader_id = compileShader(vertex_shader_source, GL_VERTEX_SHADER); - GLuint fragment_shader_id = compileShader(fragment_shader_source.empty() ? vertex_shader_source : fragment_shader_source, GL_FRAGMENT_SHADER); - - if (vertex_shader_id != INVALID_SHADER_ID && fragment_shader_id != INVALID_SHADER_ID) { - // Asociar los shaders al programa - glAttachShader(program_id, vertex_shader_id); - checkGLError("glAttachShader vertex"); - glAttachShader(program_id, fragment_shader_id); - checkGLError("glAttachShader fragment"); - - glLinkProgram(program_id); - checkGLError("glLinkProgram"); - - // Verificar el estado del enlace - GLint isLinked = GL_FALSE; - glGetProgramiv(program_id, GL_LINK_STATUS, &isLinked); - if (isLinked == GL_FALSE) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al enlazar el programa de shaders."); - GLint log_length; - glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &log_length); - if (log_length > 0) { - std::vector log(log_length); - glGetProgramInfoLog(program_id, log_length, &log_length, log.data()); - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Registro de enlace del programa: %s", log.data()); - } - glDeleteProgram(program_id); - program_id = INVALID_PROGRAM_ID; - } else { - glValidateProgram(program_id); - checkGLError("glValidateProgram"); - - // Log de información del programa (solo si hay información) - GLint log_length; - glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &log_length); - if (log_length > 1) // > 1 porque algunos drivers devuelven 1 para cadena vacía - { - std::vector log(log_length); - glGetProgramInfoLog(program_id, log_length, &log_length, log.data()); - SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Registro de información del programa:\n%s", log.data()); - } - } - } else { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: No se pudieron compilar los shaders."); - glDeleteProgram(program_id); - program_id = INVALID_PROGRAM_ID; - } - - // Limpiar los shaders (ya no son necesarios después del enlace) - if (vertex_shader_id != INVALID_SHADER_ID) { - glDeleteShader(vertex_shader_id); - } - if (fragment_shader_id != INVALID_SHADER_ID) { - glDeleteShader(fragment_shader_id); - } - - return program_id; -} - -// Función para obtener el ID de textura OpenGL desde SDL3 -GLuint getTextureID(SDL_Texture *texture) { - if (!texture) - return DEFAULT_TEXTURE_ID; - - // Intentar obtener el ID de textura OpenGL desde las propiedades de SDL3 - SDL_PropertiesID props = SDL_GetTextureProperties(texture); - GLuint textureId = 0; - - // Intentar diferentes nombres de propiedades según la versión de SDL3 - textureId = (GLuint)(uintptr_t)SDL_GetPointerProperty(props, "SDL.texture.opengl.texture", nullptr); - - // Si la primera no funciona, intentar con el nombre alternativo - if (textureId == 0) { - textureId = (GLuint)(uintptr_t)SDL_GetPointerProperty(props, "texture.opengl.texture", nullptr); - } - - // Si aún no funciona, intentar obtener como número - if (textureId == 0) { - textureId = (GLuint)SDL_GetNumberProperty(props, "SDL.texture.opengl.texture", DEFAULT_TEXTURE_ID); - } - - // Si ninguna funciona, usar el método manual de bindeo de textura - if (textureId == 0) { - SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, - "No se pudo obtener el ID de textura OpenGL, usando ID por defecto (%d)", - DEFAULT_TEXTURE_ID); - textureId = DEFAULT_TEXTURE_ID; - } - - return textureId; -} - -bool init(SDL_Window *window, SDL_Texture *back_buffer_texture, const std::string &vertex_shader, const std::string &fragment_shader) { - shader::win = window; - shader::renderer = SDL_GetRenderer(window); - shader::backBuffer = back_buffer_texture; - - if (!shader::renderer) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: No se pudo obtener el renderer de la ventana."); - return false; - } - - SDL_GetWindowSize(window, &win_size.x, &win_size.y); - SDL_GetTextureSize(back_buffer_texture, &tex_size.x, &tex_size.y); - - const auto render_name = SDL_GetRendererName(renderer); - if (!render_name) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: No se pudo obtener el nombre del renderer."); - return false; - } - - // Limpiar shader anterior si existe - if (programId != INVALID_PROGRAM_ID) { - glDeleteProgram(programId); - programId = INVALID_PROGRAM_ID; - } - - // Verificar que el renderer sea OpenGL - if (!strncmp(render_name, "opengl", 6)) { -#ifndef __APPLE__ - if (!initGLExtensions()) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "ERROR: No se han podido inicializar las extensiones de OpenGL."); - usingOpenGL = false; - return false; - } -#endif - // Compilar el programa de shaders utilizando std::string - programId = compileProgram(vertex_shader, fragment_shader); - if (programId == INVALID_PROGRAM_ID) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "ERROR: No se pudo compilar el programa de shaders."); - usingOpenGL = false; - return false; - } - - // Establecer el uniform TextureSize inmediatamente después de compilar - // Los uniforms persisten en el programa una vez establecidos - glUseProgram(programId); - GLint textureSizeLocation = glGetUniformLocation(programId, "TextureSize"); - if (textureSizeLocation != -1) { - glUniform2f(textureSizeLocation, tex_size.x, tex_size.y); - checkGLError("glUniform2f(TextureSize) - init"); - } else { - SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, - "Warning: No se pudo encontrar el uniform 'TextureSize' en el shader"); - } - glUseProgram(0); // Deseleccionar el programa - } else { - SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "ADVERTENCIA: El driver del renderer no es OpenGL (%s).", render_name); - usingOpenGL = false; - return false; - } - - usingOpenGL = true; - SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "** Shader system initialized successfully"); - return true; -} - -void render() { - // Establece el color de fondo - SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); - SDL_SetRenderTarget(renderer, nullptr); - SDL_RenderClear(renderer); - - if (usingOpenGL && programId != INVALID_PROGRAM_ID) { - // Obtener el tamaño actual de la ventana (puede haber cambiado desde init) - int current_win_width, current_win_height; - SDL_GetWindowSize(win, ¤t_win_width, ¤t_win_height); - - // Guardar estados de OpenGL - GLint oldProgramId; - glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId); - - GLint oldViewport[4]; - glGetIntegerv(GL_VIEWPORT, oldViewport); - - GLboolean wasTextureEnabled = glIsEnabled(GL_TEXTURE_2D); - GLint oldTextureId; - glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTextureId); - - // Obtener y bindear la textura - GLuint textureId = getTextureID(backBuffer); - glEnable(GL_TEXTURE_2D); - glBindTexture(GL_TEXTURE_2D, textureId); - checkGLError("glBindTexture"); - - // Usar nuestro programa de shaders - glUseProgram(programId); - checkGLError("glUseProgram"); - - // Recupera el tamaño lógico configurado con SDL_RenderSetLogicalSize - int logicalW, logicalH; - SDL_RendererLogicalPresentation mode; - SDL_GetRenderLogicalPresentation(renderer, &logicalW, &logicalH, &mode); - if (logicalW == 0 || logicalH == 0) { - logicalW = current_win_width; - logicalH = current_win_height; - } - - // Cálculo del viewport - int viewportX = 0, viewportY = 0, viewportW = current_win_width, viewportH = current_win_height; - const bool USE_INTEGER_SCALE = mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE; - if (USE_INTEGER_SCALE) { - // Calcula el factor de escalado entero máximo que se puede aplicar - int scaleX = current_win_width / logicalW; - int scaleY = current_win_height / logicalH; - int scale = (scaleX < scaleY ? scaleX : scaleY); - if (scale < 1) { - scale = 1; - } - viewportW = logicalW * scale; - viewportH = logicalH * scale; - viewportX = (current_win_width - viewportW) / 2; - viewportY = (current_win_height - viewportH) / 2; - } else { - // Letterboxing: preserva la relación de aspecto usando una escala flotante - float windowAspect = static_cast(current_win_width) / current_win_height; - float logicalAspect = static_cast(logicalW) / logicalH; - if (windowAspect > logicalAspect) { - viewportW = static_cast(logicalAspect * current_win_height); - viewportX = (current_win_width - viewportW) / 2; - } else { - viewportH = static_cast(current_win_width / logicalAspect); - viewportY = (current_win_height - viewportH) / 2; - } - } - glViewport(viewportX, viewportY, viewportW, viewportH); - checkGLError("glViewport"); - - // Configurar la proyección ortográfica usando el espacio lógico - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - // Queremos que el origen esté en la esquina superior izquierda del espacio lógico. - glOrtho(0, static_cast(logicalW), static_cast(logicalH), 0, -1, 1); - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - // Dibuja el quad con las coordenadas ajustadas. - // Se asignan las coordenadas de textura "normales" para que no quede espejado horizontalmente, - // y se mantiene el flip vertical para que la imagen no aparezca volteada. - glBegin(GL_TRIANGLE_STRIP); - // Vértice superior izquierdo - glTexCoord2f(0.0f, 1.0f); - glVertex2f(0.0f, 0.0f); - // Vértice superior derecho - glTexCoord2f(1.0f, 1.0f); - glVertex2f(static_cast(logicalW), 0.0f); - // Vértice inferior izquierdo - glTexCoord2f(0.0f, 0.0f); - glVertex2f(0.0f, static_cast(logicalH)); - // Vértice inferior derecho - glTexCoord2f(1.0f, 0.0f); - glVertex2f(static_cast(logicalW), static_cast(logicalH)); - glEnd(); - checkGLError("render quad"); - - SDL_GL_SwapWindow(win); - - // Restaurar estados de OpenGL - glUseProgram(oldProgramId); - glBindTexture(GL_TEXTURE_2D, oldTextureId); - if (!wasTextureEnabled) { - glDisable(GL_TEXTURE_2D); - } - glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]); - } else { - // Fallback a renderizado normal de SDL - SDL_RenderTexture(renderer, backBuffer, nullptr, nullptr); - SDL_RenderPresent(renderer); - } -} - -void setTextureSize(float width, float height) { - if (!usingOpenGL || programId == INVALID_PROGRAM_ID) { - return; - } - - // Guardar el programa actual - GLint oldProgramId; - glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId); - - // Usar nuestro programa - glUseProgram(programId); - - // Obtener la ubicación del uniform TextureSize - GLint textureSizeLocation = glGetUniformLocation(programId, "TextureSize"); - if (textureSizeLocation != -1) { - glUniform2f(textureSizeLocation, width, height); - checkGLError("glUniform2f(TextureSize)"); - } else { - SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, - "Warning: No se pudo encontrar el uniform 'TextureSize' en el shader"); - } - - // Restaurar el programa anterior - glUseProgram(oldProgramId); -} - -void cleanup() { - if (programId != INVALID_PROGRAM_ID) { - glDeleteProgram(programId); - programId = INVALID_PROGRAM_ID; - SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Programa de shaders liberado."); - } - - // Reinicializar variables - win = nullptr; - renderer = nullptr; - backBuffer = nullptr; - usingOpenGL = false; -} - -bool isUsingOpenGL() { - return usingOpenGL; -} - -GLuint getProgramId() { - return programId; -} -} // namespace shader \ No newline at end of file diff --git a/source/external/jail_shader.h b/source/external/jail_shader.h deleted file mode 100644 index 29171e7..0000000 --- a/source/external/jail_shader.h +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include // Para SDL_Texture, SDL_Window -#include // Para basic_string, string - -namespace shader { -bool init(SDL_Window *ventana, SDL_Texture *texturaBackBuffer, const std::string &vertexShader, const std::string &fragmentShader = ""); -void render(); -void setTextureSize(float width, float height); // Establece el tamaño de textura como uniform -} // namespace shader \ No newline at end of file diff --git a/source/rendering/opengl/opengl_shader.cpp b/source/rendering/opengl/opengl_shader.cpp new file mode 100644 index 0000000..184e64e --- /dev/null +++ b/source/rendering/opengl/opengl_shader.cpp @@ -0,0 +1,455 @@ +#include "opengl_shader.h" + +#include +#include +#include +#include + +namespace Rendering { + +OpenGLShader::~OpenGLShader() { + cleanup(); +} + +#ifndef __APPLE__ +bool OpenGLShader::initGLExtensions() { + glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader"); + glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource"); + glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader"); + glGetShaderiv = (PFNGLGETSHADERIVPROC)SDL_GL_GetProcAddress("glGetShaderiv"); + glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)SDL_GL_GetProcAddress("glGetShaderInfoLog"); + glDeleteShader = (PFNGLDELETESHADERPROC)SDL_GL_GetProcAddress("glDeleteShader"); + glAttachShader = (PFNGLATTACHSHADERPROC)SDL_GL_GetProcAddress("glAttachShader"); + glCreateProgram = (PFNGLCREATEPROGRAMPROC)SDL_GL_GetProcAddress("glCreateProgram"); + glLinkProgram = (PFNGLLINKPROGRAMPROC)SDL_GL_GetProcAddress("glLinkProgram"); + glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)SDL_GL_GetProcAddress("glValidateProgram"); + glGetProgramiv = (PFNGLGETPROGRAMIVPROC)SDL_GL_GetProcAddress("glGetProgramiv"); + glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog"); + glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram"); + glDeleteProgram = (PFNGLDELETEPROGRAMPROC)SDL_GL_GetProcAddress("glDeleteProgram"); + glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)SDL_GL_GetProcAddress("glGetUniformLocation"); + glUniform2f = (PFNGLUNIFORM2FPROC)SDL_GL_GetProcAddress("glUniform2f"); + glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)SDL_GL_GetProcAddress("glGenVertexArrays"); + glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)SDL_GL_GetProcAddress("glBindVertexArray"); + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)SDL_GL_GetProcAddress("glDeleteVertexArrays"); + glGenBuffers = (PFNGLGENBUFFERSPROC)SDL_GL_GetProcAddress("glGenBuffers"); + glBindBuffer = (PFNGLBINDBUFFERPROC)SDL_GL_GetProcAddress("glBindBuffer"); + glBufferData = (PFNGLBUFFERDATAPROC)SDL_GL_GetProcAddress("glBufferData"); + glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)SDL_GL_GetProcAddress("glDeleteBuffers"); + glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)SDL_GL_GetProcAddress("glVertexAttribPointer"); + glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)SDL_GL_GetProcAddress("glEnableVertexAttribArray"); + + return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && + glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram && + glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog && + glUseProgram && glDeleteProgram && glGetUniformLocation && glUniform2f && + glGenVertexArrays && glBindVertexArray && glDeleteVertexArrays && + glGenBuffers && glBindBuffer && glBufferData && glDeleteBuffers && + glVertexAttribPointer && glEnableVertexAttribArray; +} +#endif + +void OpenGLShader::checkGLError(const char* operation) { + GLenum error = glGetError(); + if (error != GL_NO_ERROR) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error OpenGL en %s: 0x%x", operation, error); + } +} + +GLuint OpenGLShader::compileShader(const std::string& source, GLenum shader_type) { + if (source.empty()) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "ERROR: El código fuente del shader está vacío"); + return 0; + } + + GLuint shader_id = glCreateShader(shader_type); + if (shader_id == 0) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al crear shader"); + checkGLError("glCreateShader"); + return 0; + } + + const char* sources[1] = {source.c_str()}; + glShaderSource(shader_id, 1, sources, nullptr); + checkGLError("glShaderSource"); + + glCompileShader(shader_id); + checkGLError("glCompileShader"); + + // Verificar compilación + GLint compiled = GL_FALSE; + glGetShaderiv(shader_id, GL_COMPILE_STATUS, &compiled); + if (compiled != GL_TRUE) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error en compilación del shader"); + GLint log_length; + glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &log_length); + if (log_length > 0) { + std::vector log(log_length); + glGetShaderInfoLog(shader_id, log_length, &log_length, log.data()); + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Log de compilación: %s", log.data()); + } + glDeleteShader(shader_id); + return 0; + } + + return shader_id; +} + +GLuint OpenGLShader::linkProgram(GLuint vertex_shader, GLuint fragment_shader) { + GLuint program = glCreateProgram(); + if (program == 0) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error al crear programa de shaders"); + return 0; + } + + glAttachShader(program, vertex_shader); + checkGLError("glAttachShader(vertex)"); + glAttachShader(program, fragment_shader); + checkGLError("glAttachShader(fragment)"); + + glLinkProgram(program); + checkGLError("glLinkProgram"); + + // Verificar enlace + GLint linked = GL_FALSE; + glGetProgramiv(program, GL_LINK_STATUS, &linked); + if (linked != GL_TRUE) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error al enlazar programa"); + GLint log_length; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length); + if (log_length > 0) { + std::vector log(log_length); + glGetProgramInfoLog(program, log_length, &log_length, log.data()); + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Log de enlace: %s", log.data()); + } + glDeleteProgram(program); + return 0; + } + + glValidateProgram(program); + checkGLError("glValidateProgram"); + + return program; +} + +void OpenGLShader::createQuadGeometry() { + // Datos del quad: posición (x, y) + coordenadas de textura (u, v) + // Formato: x, y, u, v + float vertices[] = { + // Posición // TexCoords + -1.0f, -1.0f, 0.0f, 0.0f, // Inferior izquierda + 1.0f, -1.0f, 1.0f, 0.0f, // Inferior derecha + 1.0f, 1.0f, 1.0f, 1.0f, // Superior derecha + -1.0f, 1.0f, 0.0f, 1.0f // Superior izquierda + }; + + // Índices para dibujar el quad con dos triángulos + unsigned int indices[] = { + 0, 1, 2, // Primer triángulo + 2, 3, 0 // Segundo triángulo + }; + + // Generar y configurar VAO + glGenVertexArrays(1, &vao_); + glBindVertexArray(vao_); + checkGLError("glBindVertexArray"); + + // Generar y configurar VBO + glGenBuffers(1, &vbo_); + glBindBuffer(GL_ARRAY_BUFFER, vbo_); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + checkGLError("glBufferData(VBO)"); + + // Generar y configurar EBO + glGenBuffers(1, &ebo_); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); + checkGLError("glBufferData(EBO)"); + + // Atributo 0: Posición (2 floats) + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + checkGLError("glVertexAttribPointer(position)"); + + // Atributo 1: Coordenadas de textura (2 floats) + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float))); + glEnableVertexAttribArray(1); + checkGLError("glVertexAttribPointer(texcoord)"); + + // Desvincular + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); +} + +GLuint OpenGLShader::getTextureID(SDL_Texture* texture) { + if (!texture) return 1; + + SDL_PropertiesID props = SDL_GetTextureProperties(texture); + GLuint texture_id = 0; + + // Intentar obtener ID de textura OpenGL + texture_id = (GLuint)(uintptr_t)SDL_GetPointerProperty(props, "SDL.texture.opengl.texture", nullptr); + + if (texture_id == 0) { + texture_id = (GLuint)(uintptr_t)SDL_GetPointerProperty(props, "texture.opengl.texture", nullptr); + } + + if (texture_id == 0) { + texture_id = (GLuint)SDL_GetNumberProperty(props, "SDL.texture.opengl.texture", 1); + } + + if (texture_id == 0) { + SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, + "No se pudo obtener ID de textura OpenGL, usando 1 por defecto"); + texture_id = 1; + } + + return texture_id; +} + +bool OpenGLShader::init(SDL_Window* window, + SDL_Texture* texture, + const std::string& vertex_source, + const std::string& fragment_source) { + window_ = window; + back_buffer_ = texture; + renderer_ = SDL_GetRenderer(window); + + if (!renderer_) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error: No se pudo obtener el renderer"); + return false; + } + + // Obtener tamaños + SDL_GetWindowSize(window_, &window_width_, &window_height_); + SDL_GetTextureSize(back_buffer_, &texture_width_, &texture_height_); + + // Verificar que es OpenGL + const char* renderer_name = SDL_GetRendererName(renderer_); + if (!renderer_name || strncmp(renderer_name, "opengl", 6) != 0) { + SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, + "Renderer no es OpenGL: %s", renderer_name ? renderer_name : "unknown"); + return false; + } + +#ifndef __APPLE__ + // Inicializar extensiones OpenGL en Windows/Linux + if (!initGLExtensions()) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error al inicializar extensiones OpenGL"); + return false; + } +#endif + + // Limpiar shader anterior si existe + if (program_id_ != 0) { + glDeleteProgram(program_id_); + program_id_ = 0; + } + + // Compilar shaders + GLuint vertex_shader = compileShader(vertex_source, GL_VERTEX_SHADER); + GLuint fragment_shader = compileShader(fragment_source, GL_FRAGMENT_SHADER); + + if (vertex_shader == 0 || fragment_shader == 0) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error al compilar shaders"); + if (vertex_shader != 0) glDeleteShader(vertex_shader); + if (fragment_shader != 0) glDeleteShader(fragment_shader); + return false; + } + + // Enlazar programa + program_id_ = linkProgram(vertex_shader, fragment_shader); + + // Limpiar shaders (ya no necesarios tras el enlace) + glDeleteShader(vertex_shader); + glDeleteShader(fragment_shader); + + if (program_id_ == 0) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, + "Error al crear programa de shaders"); + return false; + } + + // Crear geometría del quad + createQuadGeometry(); + + // Obtener ubicación del uniform TextureSize + glUseProgram(program_id_); + texture_size_location_ = glGetUniformLocation(program_id_, "TextureSize"); + if (texture_size_location_ != -1) { + glUniform2f(texture_size_location_, texture_width_, texture_height_); + checkGLError("glUniform2f(TextureSize)"); + } else { + SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, + "Uniform 'TextureSize' no encontrado en shader"); + } + glUseProgram(0); + + is_initialized_ = true; + SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, + "** OpenGL 3.3 Shader Backend inicializado correctamente"); + + return true; +} + +void OpenGLShader::render() { + if (!is_initialized_ || program_id_ == 0) { + // Fallback: renderizado SDL normal + SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255); + SDL_SetRenderTarget(renderer_, nullptr); + SDL_RenderClear(renderer_); + SDL_RenderTexture(renderer_, back_buffer_, nullptr, nullptr); + SDL_RenderPresent(renderer_); + return; + } + + // Obtener tamaño actual de ventana (puede haber cambiado) + int current_width, current_height; + SDL_GetWindowSize(window_, ¤t_width, ¤t_height); + + // Guardar estados OpenGL + GLint old_program; + glGetIntegerv(GL_CURRENT_PROGRAM, &old_program); + + GLint old_viewport[4]; + glGetIntegerv(GL_VIEWPORT, old_viewport); + + GLboolean was_texture_enabled = glIsEnabled(GL_TEXTURE_2D); + GLint old_texture; + glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_texture); + + GLint old_vao; + glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &old_vao); + + // Preparar renderizado + SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255); + SDL_SetRenderTarget(renderer_, nullptr); + SDL_RenderClear(renderer_); + + // Obtener y bindear textura + GLuint texture_id = getTextureID(back_buffer_); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, texture_id); + checkGLError("glBindTexture"); + + // Usar nuestro programa + glUseProgram(program_id_); + checkGLError("glUseProgram"); + + // Configurar viewport (obtener tamaño lógico de SDL) + int logical_w, logical_h; + SDL_RendererLogicalPresentation mode; + SDL_GetRenderLogicalPresentation(renderer_, &logical_w, &logical_h, &mode); + + if (logical_w == 0 || logical_h == 0) { + logical_w = current_width; + logical_h = current_height; + } + + // Calcular viewport considerando aspect ratio + int viewport_x = 0, viewport_y = 0; + int viewport_w = current_width, viewport_h = current_height; + + if (mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) { + int scale_x = current_width / logical_w; + int scale_y = current_height / logical_h; + int scale = (scale_x < scale_y) ? scale_x : scale_y; + if (scale < 1) scale = 1; + + viewport_w = logical_w * scale; + viewport_h = logical_h * scale; + viewport_x = (current_width - viewport_w) / 2; + viewport_y = (current_height - viewport_h) / 2; + } else { + float window_aspect = static_cast(current_width) / current_height; + float logical_aspect = static_cast(logical_w) / logical_h; + + if (window_aspect > logical_aspect) { + viewport_w = static_cast(logical_aspect * current_height); + viewport_x = (current_width - viewport_w) / 2; + } else { + viewport_h = static_cast(current_width / logical_aspect); + viewport_y = (current_height - viewport_h) / 2; + } + } + + glViewport(viewport_x, viewport_y, viewport_w, viewport_h); + checkGLError("glViewport"); + + // Dibujar quad usando VAO + glBindVertexArray(vao_); + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); + checkGLError("glDrawElements"); + + // Presentar + SDL_GL_SwapWindow(window_); + + // Restaurar estados OpenGL + glUseProgram(old_program); + glBindTexture(GL_TEXTURE_2D, old_texture); + if (!was_texture_enabled) { + glDisable(GL_TEXTURE_2D); + } + glBindVertexArray(old_vao); + glViewport(old_viewport[0], old_viewport[1], old_viewport[2], old_viewport[3]); +} + +void OpenGLShader::setTextureSize(float width, float height) { + if (!is_initialized_ || program_id_ == 0) { + return; + } + + texture_width_ = width; + texture_height_ = height; + + GLint old_program; + glGetIntegerv(GL_CURRENT_PROGRAM, &old_program); + + glUseProgram(program_id_); + + if (texture_size_location_ != -1) { + glUniform2f(texture_size_location_, width, height); + checkGLError("glUniform2f(TextureSize)"); + } + + glUseProgram(old_program); +} + +void OpenGLShader::cleanup() { + if (vao_ != 0) { + glDeleteVertexArrays(1, &vao_); + vao_ = 0; + } + + if (vbo_ != 0) { + glDeleteBuffers(1, &vbo_); + vbo_ = 0; + } + + if (ebo_ != 0) { + glDeleteBuffers(1, &ebo_); + ebo_ = 0; + } + + if (program_id_ != 0) { + glDeleteProgram(program_id_); + program_id_ = 0; + } + + is_initialized_ = false; + window_ = nullptr; + renderer_ = nullptr; + back_buffer_ = nullptr; +} + +} // namespace Rendering diff --git a/source/rendering/opengl/opengl_shader.h b/source/rendering/opengl/opengl_shader.h new file mode 100644 index 0000000..957d211 --- /dev/null +++ b/source/rendering/opengl/opengl_shader.h @@ -0,0 +1,98 @@ +#pragma once + +#include "../shader_backend.h" + +#ifdef __APPLE__ +#include +#else +#include +#endif + +namespace Rendering { + +/** + * @brief Backend de shaders usando OpenGL 3.3 Core Profile + * + * Implementa el renderizado de shaders usando APIs modernas de OpenGL: + * - VAO (Vertex Array Objects) + * - VBO (Vertex Buffer Objects) + * - Shaders GLSL #version 330 core + */ +class OpenGLShader : public ShaderBackend { +public: + OpenGLShader() = default; + ~OpenGLShader() override; + + bool init(SDL_Window* window, + SDL_Texture* texture, + const std::string& vertex_source, + const std::string& fragment_source) override; + + void render() override; + void setTextureSize(float width, float height) override; + void cleanup() override; + bool isHardwareAccelerated() const override { return is_initialized_; } + +private: + // Funciones auxiliares + bool initGLExtensions(); + GLuint compileShader(const std::string& source, GLenum shader_type); + GLuint linkProgram(GLuint vertex_shader, GLuint fragment_shader); + void createQuadGeometry(); + GLuint getTextureID(SDL_Texture* texture); + void checkGLError(const char* operation); + + // Estado SDL + SDL_Window* window_ = nullptr; + SDL_Renderer* renderer_ = nullptr; + SDL_Texture* back_buffer_ = nullptr; + + // Estado OpenGL + GLuint program_id_ = 0; + GLuint vao_ = 0; // Vertex Array Object + GLuint vbo_ = 0; // Vertex Buffer Object + GLuint ebo_ = 0; // Element Buffer Object + + // Ubicaciones de uniforms + GLint texture_size_location_ = -1; + + // Tamaños + int window_width_ = 0; + int window_height_ = 0; + float texture_width_ = 0.0f; + float texture_height_ = 0.0f; + + // Estado + bool is_initialized_ = false; + +#ifndef __APPLE__ + // Punteros a funciones OpenGL en Windows/Linux + PFNGLCREATESHADERPROC glCreateShader = nullptr; + PFNGLSHADERSOURCEPROC glShaderSource = nullptr; + PFNGLCOMPILESHADERPROC glCompileShader = nullptr; + PFNGLGETSHADERIVPROC glGetShaderiv = nullptr; + PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = nullptr; + PFNGLDELETESHADERPROC glDeleteShader = nullptr; + PFNGLATTACHSHADERPROC glAttachShader = nullptr; + PFNGLCREATEPROGRAMPROC glCreateProgram = nullptr; + PFNGLLINKPROGRAMPROC glLinkProgram = nullptr; + PFNGLVALIDATEPROGRAMPROC glValidateProgram = nullptr; + PFNGLGETPROGRAMIVPROC glGetProgramiv = nullptr; + PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = nullptr; + PFNGLUSEPROGRAMPROC glUseProgram = nullptr; + PFNGLDELETEPROGRAMPROC glDeleteProgram = nullptr; + PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation = nullptr; + PFNGLUNIFORM2FPROC glUniform2f = nullptr; + PFNGLGENVERTEXARRAYSPROC glGenVertexArrays = nullptr; + PFNGLBINDVERTEXARRAYPROC glBindVertexArray = nullptr; + PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays = nullptr; + PFNGLGENBUFFERSPROC glGenBuffers = nullptr; + PFNGLBINDBUFFERPROC glBindBuffer = nullptr; + PFNGLBUFFERDATAPROC glBufferData = nullptr; + PFNGLDELETEBUFFERSPROC glDeleteBuffers = nullptr; + PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = nullptr; + PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = nullptr; +#endif +}; + +} // namespace Rendering diff --git a/source/rendering/shader_backend.h b/source/rendering/shader_backend.h new file mode 100644 index 0000000..b9fd170 --- /dev/null +++ b/source/rendering/shader_backend.h @@ -0,0 +1,55 @@ +#pragma once + +#include +#include + +namespace Rendering { + +/** + * @brief Interfaz abstracta para backends de renderizado con shaders + * + * Esta interfaz define el contrato que todos los backends de shaders + * deben cumplir (OpenGL, Metal, Vulkan, etc.) + */ +class ShaderBackend { +public: + virtual ~ShaderBackend() = default; + + /** + * @brief Inicializa el backend de shaders + * @param window Ventana SDL + * @param texture Textura de backbuffer a la que aplicar shaders + * @param vertex_source Código fuente del vertex shader + * @param fragment_source Código fuente del fragment shader + * @return true si la inicialización fue exitosa + */ + virtual bool init(SDL_Window* window, + SDL_Texture* texture, + const std::string& vertex_source, + const std::string& fragment_source) = 0; + + /** + * @brief Renderiza la textura con los shaders aplicados + */ + virtual void render() = 0; + + /** + * @brief Establece el tamaño de la textura como parámetro del shader + * @param width Ancho de la textura + * @param height Alto de la textura + */ + virtual void setTextureSize(float width, float height) = 0; + + /** + * @brief Limpia y libera recursos del backend + */ + virtual void cleanup() = 0; + + /** + * @brief Verifica si el backend está usando aceleración por hardware + * @return true si usa aceleración (OpenGL/Metal/Vulkan) + */ + virtual bool isHardwareAccelerated() const = 0; +}; + +} // namespace Rendering diff --git a/source/screen.cpp b/source/screen.cpp index b68eb3f..92d9b4a 100644 --- a/source/screen.cpp +++ b/source/screen.cpp @@ -8,9 +8,9 @@ #include // Para allocator, shared_ptr, make_shared, __shared_ptr_access #include // Para operator+, char_traits, to_string, string -#include "asset.h" // Para Asset -#include "external/jail_shader.h" // Para init, render -#include "mouse.h" // Para updateCursorVisibility +#include "asset.h" // Para Asset +#include "mouse.h" // Para updateCursorVisibility +#include "rendering/opengl/opengl_shader.h" // Para OpenGLShader #include "options.h" // Para VideoOptions, video, WindowOptions, window #include "param.h" // Para Param, param, ParamGame, ParamDebug #include "text.h" // Para Text, Text::COLOR, Text::STROKE @@ -57,7 +57,8 @@ Screen::Screen() // Inicializa los shaders loadShaders(); - shader::init(window_, game_canvas_, shader_source_); + shader_backend_ = std::make_unique(); + shader_backend_->init(window_, game_canvas_, vertex_shader_source_, fragment_shader_source_); } // Destructor @@ -97,8 +98,8 @@ void Screen::renderPresent() { SDL_SetRenderTarget(renderer_, nullptr); clean(); - if (Options::video.shaders) { - shader::render(); + if (Options::video.shaders && shader_backend_) { + shader_backend_->render(); } else { SDL_RenderTexture(renderer_, game_canvas_, nullptr, nullptr); SDL_RenderPresent(renderer_); @@ -223,13 +224,20 @@ void Screen::renderInfo() { } } #endif -// Carga el contenido del archivo GLSL +// Carga el contenido de los archivos GLSL void Screen::loadShaders() { - if (shader_source_.empty()) { - const std::string GLSL_FILE = "crtpi.glsl"; - auto data = Asset::get()->loadData(GLSL_FILE); + if (vertex_shader_source_.empty()) { + const std::string VERTEX_FILE = "crtpi_vertex.glsl"; + auto data = Asset::get()->loadData(VERTEX_FILE); if (!data.empty()) { - shader_source_ = std::string(data.begin(), data.end()); + vertex_shader_source_ = std::string(data.begin(), data.end()); + } + } + if (fragment_shader_source_.empty()) { + const std::string FRAGMENT_FILE = "crtpi_fragment.glsl"; + auto data = Asset::get()->loadData(FRAGMENT_FILE); + if (!data.empty()) { + fragment_shader_source_ = std::string(data.begin(), data.end()); } } } @@ -238,7 +246,10 @@ void Screen::loadShaders() { void Screen::initShaders() { if (Options::video.shaders) { loadShaders(); - shader::init(window_, game_canvas_, shader_source_); + if (!shader_backend_) { + shader_backend_ = std::make_unique(); + } + shader_backend_->init(window_, game_canvas_, vertex_shader_source_, fragment_shader_source_); } } @@ -310,6 +321,10 @@ auto Screen::initSDLVideo() -> bool { SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Warning: Failed to set OpenGL hint!"); } + // Configurar contexto OpenGL 3.3 Core Profile + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); #endif // Crear ventana diff --git a/source/screen.h b/source/screen.h index 0a1a360..e31503e 100644 --- a/source/screen.h +++ b/source/screen.h @@ -8,10 +8,15 @@ #include "color.h" // Para Color #include "options.h" // Para VideoOptions, video +// Forward declarations class Notifier; class ServiceMenu; class Text; +namespace Rendering { + class ShaderBackend; +} + // --- Clase Screen: gestiona la ventana, el renderizador y los efectos visuales globales (singleton) --- class Screen { public: @@ -203,17 +208,19 @@ class Screen { #endif // --- Objetos y punteros --- - SDL_Window *window_; // Ventana de la aplicación - SDL_Renderer *renderer_; // El renderizador de la ventana - SDL_Texture *game_canvas_; // Textura donde se dibuja todo antes de volcarse al renderizador - ServiceMenu *service_menu_; // Objeto para mostrar el menú de servicio - Notifier *notifier_; // Objeto para mostrar las notificaciones por pantalla - std::shared_ptr text_; // Objeto para escribir texto en pantalla + SDL_Window *window_; // Ventana de la aplicación + SDL_Renderer *renderer_; // El renderizador de la ventana + SDL_Texture *game_canvas_; // Textura donde se dibuja todo antes de volcarse al renderizador + ServiceMenu *service_menu_; // Objeto para mostrar el menú de servicio + Notifier *notifier_; // Objeto para mostrar las notificaciones por pantalla + std::shared_ptr text_; // Objeto para escribir texto en pantalla + std::unique_ptr shader_backend_; // Backend de shaders (OpenGL/Metal/Vulkan) // --- Variables de estado --- SDL_FRect src_rect_; // Coordenadas de origen para dibujar la textura del juego SDL_FRect dst_rect_; // Coordenadas destino para dibujar la textura del juego - std::string shader_source_; // Almacena el contenido del archivo GLSL + std::string vertex_shader_source_; // Almacena el vertex shader + std::string fragment_shader_source_; // Almacena el fragment shader FPS fps_; // Gestión de frames por segundo FlashEffect flash_effect_; // Efecto de flash en pantalla ShakeEffect shake_effect_; // Efecto de agitar la pantalla