jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests Activity

afegit gif.cpp i jail_shader.cpp desde coffee_crisis_arcade_edition

Browse Source
This commit is contained in:
Sergio
2025-03-16 15:44:38 +01:00
parent a14f6fcf6f
commit 40dcbabfe8
61 changed files with 1185 additions and 1231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
source/jail_shader.cpp
View File

@@ -1,21 +1,22 @@
#include "jail_shader.h"
#include <SDL2/SDL_rect.h> // para SDL_Point
#include <stdlib.h> // para NULL, free, malloc, exit
#include <string.h> // para strncmp
#include <iostream> // para basic_ostream, char_traits, operator<<
#include <SDL2/SDL_rect.h> // Para SDL_Point
#include <SDL2/SDL_stdinc.h> // Para SDL_bool
#include <cstring> // Para strncmp
#include <iostream> // Para basic_ostream, operator<<, endl, cout
#include <stdexcept> // Para runtime_error
#include <vector> // Para vector
#ifdef __APPLE__
#include "CoreFoundation/CoreFoundation.h"
#include <OpenGL/OpenGL.h>
#include "CoreFoundation/CoreFoundation.h" // Para Core Foundation en macOS
#include <OpenGL/OpenGL.h> // Para OpenGL en macOS
#if ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
#include <OpenGL/gl3.h>
#else
#include <OpenGL/gl.h>
#endif //! ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
#else
#include <SDL2/SDL_opengl.h>
#endif
#include <OpenGL/gl3.h> // Para OpenGL 3 en macOS
#else // NO ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
#include <OpenGL/gl.h> // Para OpenGL (compatibilidad) en macOS
#endif // ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
#else // SI NO ES __APPLE__
#include <SDL2/SDL_opengl.h> // Para GLuint, glTexCoord2f, glVertex2f, GLfloat
#endif // __APPLE__
namespace shader
{
@@ -25,12 +26,10 @@ namespace shader
SDL_Texture *backBuffer = nullptr;
SDL_Point win_size = {320 * 4, 256 * 4};
SDL_Point tex_size = {320, 256};
bool usingOpenGL;
bool usingOpenGL = false;
#ifndef __APPLE__
// I'm avoiding the use of GLEW or some extensions handler, but that
// doesn't mean you should...
// Declaración de funciones de extensión de OpenGL (evitando GLEW)
PFNGLCREATESHADERPROC glCreateShader;
PFNGLSHADERSOURCEPROC glShaderSource;
PFNGLCOMPILESHADERPROC glCompileShader;
@@ -66,120 +65,125 @@ namespace shader
glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
glUseProgram;
}
#endif
GLuint compileShader(const char *source, GLuint shaderType)
// Función para compilar un shader a partir de un std::string
GLuint compileShader(const std::string &source, GLuint shaderType)
{
// Create ID for shader
GLuint result = glCreateShader(shaderType);
// Add define depending on shader type
const char *sources[2] = {shaderType == GL_VERTEX_SHADER ? "#define VERTEX\n" : "#define FRAGMENT\n", source};
// Define shader text
glShaderSource(result, 2, sources, NULL);
// Compile shader
glCompileShader(result);
// Check vertex shader for errors
GLint shaderCompiled = GL_FALSE;
glGetShaderiv(result, GL_COMPILE_STATUS, &shaderCompiled);
if (shaderCompiled != GL_TRUE)
if (source.empty())
{
std::cout << "Error en la compilación: " << result << "!" << std::endl;
GLint logLength;
glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0)
{
GLchar *log = (GLchar *)malloc(logLength);
glGetShaderInfoLog(result, logLength, &logLength, log);
std::cout << "Shader compile log:" << log << std::endl;
free(log);
}
glDeleteShader(result);
result = 0;
// } else {
// std::cout << "Shader compilado correctamente. Id = " << result << std::endl;
throw std::runtime_error("ERROR FATAL: El código fuente del shader está vacío.");
}
return result;
// Crear identificador del shader
GLuint resultado = glCreateShader(shaderType);
// Agregar una directiva según el tipo de shader
std::string directiva = (shaderType == GL_VERTEX_SHADER)
? "#define VERTEX\n"
: "#define FRAGMENT\n";
const char *sources[2] = {directiva.c_str(), source.c_str()};
// Especificar el código fuente del shader
glShaderSource(resultado, 2, sources, nullptr);
// Compilar el shader
glCompileShader(resultado);
// Verificar si la compilación fue exitosa
GLint compiladoCorrectamente = GL_FALSE;
glGetShaderiv(resultado, GL_COMPILE_STATUS, &compiladoCorrectamente);
if (compiladoCorrectamente != GL_TRUE)
{
std::cout << "Error en la compilación del shader (" << resultado << ")!" << std::endl;
GLint longitudLog;
glGetShaderiv(resultado, GL_INFO_LOG_LENGTH, &longitudLog);
if (longitudLog > 0)
{
std::vector<GLchar> log(longitudLog);
glGetShaderInfoLog(resultado, longitudLog, &longitudLog, log.data());
std::cout << "Registro de compilación del shader: " << log.data() << std::endl;
}
glDeleteShader(resultado);
resultado = 0;
}
return resultado;
}
GLuint compileProgram(const char *vertexShaderSource, const char *fragmentShaderSource)
// Función para compilar un programa de shaders (vertex y fragment) a partir de std::string
GLuint compileProgram(const std::string &vertexShaderSource, const std::string &fragmentShaderSource)
{
GLuint programId = 0;
GLuint vtxShaderId, fragShaderId;
GLuint idPrograma = glCreateProgram();
programId = glCreateProgram();
// Si el fragment shader está vacío, reutilizamos el código del vertex shader
GLuint idShaderVertice = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint idShaderFragmento = compileShader(fragmentShaderSource.empty() ? vertexShaderSource : fragmentShaderSource, GL_FRAGMENT_SHADER);
vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
fragShaderId = compileShader(fragmentShaderSource ? fragmentShaderSource : vertexShaderSource, GL_FRAGMENT_SHADER);
if (vtxShaderId && fragShaderId)
if (idShaderVertice && idShaderFragmento)
{
// Associate shader with program
glAttachShader(programId, vtxShaderId);
glAttachShader(programId, fragShaderId);
glLinkProgram(programId);
glValidateProgram(programId);
// Asociar los shaders al programa
glAttachShader(idPrograma, idShaderVertice);
glAttachShader(idPrograma, idShaderFragmento);
glLinkProgram(idPrograma);
glValidateProgram(idPrograma);
// Check the status of the compile/link
GLint logLen;
glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
if (logLen > 0)
// Verificar el estado del enlace
GLint longitudLog;
glGetProgramiv(idPrograma, GL_INFO_LOG_LENGTH, &longitudLog);
if (longitudLog > 0)
{
char *log = (char *)malloc(logLen * sizeof(char));
// Show any errors as appropriate
glGetProgramInfoLog(programId, logLen, &logLen, log);
std::cout << "Prog Info Log: " << std::endl
<< log << std::endl;
free(log);
std::vector<char> log(longitudLog);
glGetProgramInfoLog(idPrograma, longitudLog, &longitudLog, log.data());
std::cout << "Registro de información del programa:" << std::endl
<< log.data() << std::endl;
}
}
if (vtxShaderId)
if (idShaderVertice)
{
glDeleteShader(vtxShaderId);
glDeleteShader(idShaderVertice);
}
if (fragShaderId)
if (idShaderFragmento)
{
glDeleteShader(fragShaderId);
glDeleteShader(idShaderFragmento);
}
return programId;
return idPrograma;
}
const bool init(SDL_Window *win, SDL_Texture *backBuffer, const char *vertexShader, const char *fragmentShader)
bool init(SDL_Window *ventana, SDL_Texture *texturaBackBuffer, const std::string &vertexShader, const std::string &fragmentShader)
{
shader::win = win;
shader::renderer = SDL_GetRenderer(win);
shader::backBuffer = backBuffer;
SDL_GetWindowSize(win, &win_size.x, &win_size.y);
int access;
SDL_QueryTexture(backBuffer, NULL, &access, &tex_size.x, &tex_size.y);
if (access != SDL_TEXTUREACCESS_TARGET)
shader::win = ventana;
shader::renderer = SDL_GetRenderer(ventana);
shader::backBuffer = texturaBackBuffer;
SDL_GetWindowSize(ventana, &win_size.x, &win_size.y);
int acceso;
SDL_QueryTexture(texturaBackBuffer, nullptr, &acceso, &tex_size.x, &tex_size.y);
if (acceso != SDL_TEXTUREACCESS_TARGET)
{
std::cout << "ERROR FATAL: La textura per al render ha de tindre SDL_TEXTUREACCESS_TARGET definit." << std::endl;
exit(1);
throw std::runtime_error("ERROR FATAL: La textura debe tener definido SDL_TEXTUREACCESS_TARGET.");
}
SDL_RendererInfo rendererInfo;
SDL_GetRendererInfo(renderer, &rendererInfo);
SDL_RendererInfo infoRenderer;
SDL_GetRendererInfo(renderer, &infoRenderer);
if (!strncmp(rendererInfo.name, "opengl", 6))
// Verificar que el renderer sea OpenGL
if (!strncmp(infoRenderer.name, "opengl", 6))
{
// std::cout << "Es OpenGL!" << std::endl;
#ifndef __APPLE__
if (!initGLExtensions())
{
std::cout << "WARNING: No s'han pogut inicialitzar les extensions d'OpenGL!" << std::endl;
std::cout << "ADVERTENCIA: No se han podido inicializar las extensiones de OpenGL." << std::endl;
usingOpenGL = false;
return false;
}
#endif
// Compilar el shader y dejarlo listo para usar.
// Compilar el programa de shaders utilizando std::string
programId = compileProgram(vertexShader, fragmentShader);
// std::cout << "programId = " << programId << std::endl;
}
else
{
std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
std::cout << "ADVERTENCIA: El driver del renderer no es OpenGL." << std::endl;
usingOpenGL = false;
return false;
}
@@ -190,48 +194,90 @@ namespace shader
void render()
{
GLint oldProgramId;
// Guarrada para obtener el textureid (en driverdata->texture)
// Detach the texture
// Establece el color de fondo
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_SetRenderTarget(renderer, NULL);
SDL_SetRenderTarget(renderer, nullptr);
SDL_RenderClear(renderer);
if (usingOpenGL)
{
SDL_GL_BindTexture(backBuffer, NULL, NULL);
SDL_GL_BindTexture(backBuffer, nullptr, nullptr);
if (programId != 0)
{
glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
glUseProgram(programId);
}
GLfloat minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
// Recupera el tamaño lógico configurado con SDL_RenderSetLogicalSize
int logicalW, logicalH;
SDL_RenderGetLogicalSize(renderer, &logicalW, &logicalH);
if (logicalW == 0 || logicalH == 0)
{
logicalW = win_size.x;
logicalH = win_size.y;
}
// Coordenadas de la ventana donde pintar.
minx = 0.0f;
miny = 0.0f;
maxx = tex_size.x;
maxy = tex_size.y;
// Cálculo del viewport
int viewportX = 0, viewportY = 0, viewportW = win_size.x, viewportH = win_size.y;
SDL_bool useIntegerScale = SDL_RenderGetIntegerScale(renderer);
if (useIntegerScale)
{
// Calcula el factor de escalado entero máximo que se puede aplicar
int scaleX = win_size.x / logicalW;
int scaleY = win_size.y / logicalH;
int scale = (scaleX < scaleY ? scaleX : scaleY);
if (scale < 1)
scale = 1;
viewportW = logicalW * scale;
viewportH = logicalH * scale;
viewportX = (win_size.x - viewportW) / 2;
viewportY = (win_size.y - viewportH) / 2;
}
else
{
// Letterboxing: preserva la relación de aspecto usando una escala flotante
float windowAspect = static_cast<float>(win_size.x) / win_size.y;
float logicalAspect = static_cast<float>(logicalW) / logicalH;
if (windowAspect > logicalAspect)
{
viewportW = static_cast<int>(logicalAspect * win_size.y);
viewportX = (win_size.x - viewportW) / 2;
}
else
{
viewportH = static_cast<int>(win_size.x / logicalAspect);
viewportY = (win_size.y - viewportH) / 2;
}
}
glViewport(viewportX, viewportY, viewportW, viewportH);
minu = 0.0f;
maxu = 1.0f;
minv = 0.0f;
maxv = 1.0f;
// Configurar la proyección ortográfica usando el espacio lógico
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0, 0, win_size.x, win_size.y);
// Queremos que el origen esté en la esquina superior izquierda del espacio lógico.
glOrtho(0, static_cast<GLdouble>(logicalW), static_cast<GLdouble>(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);
glTexCoord2f(minu, minv);
glVertex2f(minx, miny);
glTexCoord2f(maxu, minv);
glVertex2f(maxx, miny);
glTexCoord2f(minu, maxv);
glVertex2f(minx, maxy);
glTexCoord2f(maxu, maxv);
glVertex2f(maxx, maxy);
// 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<GLfloat>(logicalW), 0.0f);
// Vértice inferior izquierdo
glTexCoord2f(0.0f, 0.0f);
glVertex2f(0.0f, static_cast<GLfloat>(logicalH));
// Vértice inferior derecho
glTexCoord2f(1.0f, 0.0f);
glVertex2f(static_cast<GLfloat>(logicalW), static_cast<GLfloat>(logicalH));
glEnd();
SDL_GL_SwapWindow(win);
if (programId != 0)
@@ -241,7 +287,7 @@ namespace shader
}
else
{
SDL_RenderCopy(renderer, backBuffer, NULL, NULL);
SDL_RenderCopy(renderer, backBuffer, nullptr, nullptr);
SDL_RenderPresent(renderer);
}
}