JailDoctor/jdd_opendingux
1
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Issues Pull Requests Projects Releases Wiki Activity

Implementats els shaders

Browse Source
This commit is contained in:
Sergio
2025-02-20 08:48:55 +01:00
parent cc0f050c50
commit 9cb57e2ff2
20 changed files with 957 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
source/jail_engine/input.h
View File

@@ -22,12 +22,13 @@ enum inputs_e
// Inputs personalizados
input_jump,
input_window_fullscreen,
input_window_inc_size,
input_window_dec_size,
input_toggle_videomode,
input_toggle_border,
input_switch_music,
input_swap_palette,
input_toggle_music,
input_toggle_palette,
input_toggle_shaders,
// Input obligatorio
input_number_of_inputs

251
source/jail_engine/jail_shader.cpp Normal file
View File

@@ -0,0 +1,251 @@
#ifndef NO_SHADERS
#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<<
#ifdef __APPLE__
#include "CoreFoundation/CoreFoundation.h"
#include <OpenGL/OpenGL.h>
#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
namespace shader
{
SDL_Window *win = nullptr;
SDL_Renderer *renderer = nullptr;
GLuint programId = 0;
SDL_Texture *backBuffer = nullptr;
SDL_Point win_size = {320 * 4, 256 * 4};
SDL_Point tex_size = {320, 256};
bool usingOpenGL;
#ifndef __APPLE__
// I'm avoiding the use of GLEW or some extensions handler, but that
// doesn't mean you should...
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;
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");
return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv &&
glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
glUseProgram;
}
#endif
GLuint compileShader(const char *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)
{
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;
}
return result;
}
GLuint compileProgram(const char *vertexShaderSource, const char *fragmentShaderSource)
{
GLuint programId = 0;
GLuint vtxShaderId, fragShaderId;
programId = glCreateProgram();
vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
fragShaderId = compileShader(fragmentShaderSource ? fragmentShaderSource : vertexShaderSource, GL_FRAGMENT_SHADER);
if (vtxShaderId && fragShaderId)
{
// Associate shader with program
glAttachShader(programId, vtxShaderId);
glAttachShader(programId, fragShaderId);
glLinkProgram(programId);
glValidateProgram(programId);
// Check the status of the compile/link
GLint logLen;
glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
if (logLen > 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);
}
}
if (vtxShaderId)
{
glDeleteShader(vtxShaderId);
}
if (fragShaderId)
{
glDeleteShader(fragShaderId);
}
return programId;
}
const bool init(SDL_Window *win, SDL_Texture *backBuffer, const char *vertexShader, const char *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)
{
std::cout << "ERROR FATAL: La textura per al render ha de tindre SDL_TEXTUREACCESS_TARGET definit." << std::endl;
exit(1);
}
SDL_RendererInfo rendererInfo;
SDL_GetRendererInfo(renderer, &rendererInfo);
if (!strncmp(rendererInfo.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;
usingOpenGL = false;
return false;
}
#endif
// Compilar el shader y dejarlo listo para usar.
programId = compileProgram(vertexShader, fragmentShader);
// std::cout << "programId = " << programId << std::endl;
}
else
{
std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
usingOpenGL = false;
return false;
}
usingOpenGL = true;
return true;
}
void render()
{
GLint oldProgramId;
// Guarrada para obtener el textureid (en driverdata->texture)
// Detach the texture
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_SetRenderTarget(renderer, NULL);
SDL_RenderClear(renderer);
if (usingOpenGL)
{
SDL_GL_BindTexture(backBuffer, NULL, NULL);
if (programId != 0)
{
glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
glUseProgram(programId);
}
GLfloat minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
// Coordenadas de la ventana donde pintar.
minx = 0.0f;
miny = 0.0f;
maxx = tex_size.x;
maxy = tex_size.y;
minu = 0.0f;
maxu = 1.0f;
minv = 0.0f;
maxv = 1.0f;
glViewport(0, 0, win_size.x, win_size.y);
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);
glEnd();
SDL_GL_SwapWindow(win);
if (programId != 0)
{
glUseProgram(oldProgramId);
}
}
else
{
SDL_RenderCopy(renderer, backBuffer, NULL, NULL);
SDL_RenderPresent(renderer);
}
}
}
#endif

48
source/jail_engine/jail_shader.h Normal file
View File

@@ -0,0 +1,48 @@
#ifndef NO_SHADERS
#pragma once
#include <SDL2/SDL_render.h> // para SDL_Texture
#include <SDL2/SDL_video.h> // para SDL_Window
// TIPS:
// =======================================================================
// Abans de crear el renderer, cridar a la següent funció:
//
// SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
//
// Aixó li diu que volem un renderer que use especificament opengl. A més,
// al crear el renderer li tenim que dir que el volem que use acceeració
// per hardware, i que soporte render a textura. Per exemple:
//
// SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED |
// SDL_RENDERER_TARGETTEXTURE);
//
// Per altra part, al crear la textura tenim que definir que puga ser target
// de renderitzat (SDL_TEXTUREACCESS_TARGET), per exemple:
//
// SDL_Texture *tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
// SDL_TEXTUREACCESS_TARGET, 320, 240);
//
// Els shaders li'ls passem com una cadena, som nosaltres els que s'encarreguem
// de carregarlos de disc, amb fopen, ifstream, jfile o el que vullgues.
// Si els tens en un std::string, passa-li-la com "cadena.c_str()".
//
// Poden ser els dos el mateix arxiu, com fa libRetro, jo desde dins ja fique
// els defines necessaris. Si es el mateix arxiu, pots no ficar el quart paràmetre.
//
// Els shaders de libRetro no funcionen directament, hi ha que fer algunes modificacions.
//
// El pintat final de la teua escena l'has de fer com si "backBuffer" fora la pantalla.
//
// Ah! una cosa mes: al compilar, en Linux afegir "-lGL", en Windows afegir "-lopengl32".
// En Mac ni idea
namespace shader
{
const bool init(SDL_Window *win, SDL_Texture *backBuffer,
const char *vertexShader, const char *fragmentShader = nullptr);
void render();
}
#endif

118
source/jail_engine/screen.cpp
View File

@@ -1,5 +1,8 @@
#include "screen.h"
#include "jail_shader.h"
#include <string>
#include <fstream> // Para basic_ifstream, ifstream
#include <iterator> // Para istreambuf_iterator, operator==
#include <iostream>
// Constructor
@@ -51,6 +54,9 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options
// Inicializa variables
notifyActive = false;
// Muestra la ventana
SDL_ShowWindow(window);
}
// Destructor
@@ -81,29 +87,19 @@ void Screen::startDrawOnBorder()
}
// Vuelca el contenido del renderizador en pantalla
void Screen::blit()
void Screen::render()
{
// Vuelve a dejar el renderizador en modo normal
SDL_SetRenderTarget(renderer, nullptr);
// Borra el contenido previo
// SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
// SDL_RenderClear(renderer);
// Copia la textura del borde en la ventana
if (options->borderEnabled)
{
SDL_RenderCopy(renderer, borderCanvas, nullptr, nullptr);
}
// Copia la textura de juego en la ventana en la posición adecuada
SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
// Dibuja las notificaciones
// Renderiza sobre gameCanvas los overlays
renderNotifications();
// Muestra por pantalla el renderizador
SDL_RenderPresent(renderer);
// Si está el borde activo, vuelca gameCanvas sobre borderCanvas
if (options->borderEnabled)
{
gameCanvasToBorderCanvas();
}
// Muestra el contenido por pantalla
renderPresent();
}
// Establece el modo de video
@@ -118,9 +114,6 @@ void Screen::setVideoMode(int videoMode)
// Muestra el puntero
SDL_ShowCursor(SDL_ENABLE);
// Esconde la ventana
// SDL_HideWindow(window);
// Modifica el tamaño de la ventana en función del borde
if (options->borderEnabled)
{
@@ -139,9 +132,6 @@ void Screen::setVideoMode(int videoMode)
// Modifica el tamaño de la ventana
SDL_SetWindowSize(window, windowWidth * options->windowSize, windowHeight * options->windowSize);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
// Muestra la ventana
// SDL_ShowWindow(window);
}
// Si está activo el modo de pantalla completa añade el borde
@@ -204,10 +194,27 @@ void Screen::setVideoMode(int videoMode)
// Establece el tamaño de las notificaciones
setNotificationSize();
// Reinicia los shaders
if (options->shaders)
{
const std::string glsl_file = options->screen.windowHeight == 192 ? "crtpi_192.glsl" : "crtpi_240.glsl";
std::ifstream f(asset->get(glsl_file).c_str());
std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
if (options->borderEnabled)
{
shader::init(window, borderCanvas, source.c_str());
}
else
{
shader::init(window, gameCanvas, source.c_str());
}
}
}
// Camibia entre pantalla completa y ventana
void Screen::switchVideoMode()
void Screen::toggleVideoMode()
{
options->videoMode = (options->videoMode == 0) ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0;
setVideoMode(options->videoMode);
@@ -240,10 +247,11 @@ void Screen::incWindowSize()
void Screen::setBorderColor(color_t color)
{
borderColor = color;
auto temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, borderCanvas);
SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer, temp);
}
// Cambia el tipo de mezcla
@@ -271,7 +279,7 @@ void Screen::setBorderEnabled(bool value)
}
// Cambia entre borde visible y no visible
void Screen::switchBorder()
void Screen::toggleBorder()
{
options->borderEnabled = !options->borderEnabled;
setVideoMode(0);
@@ -428,14 +436,10 @@ void Screen::showNotification(std::string text1, std::string text2, int icon)
// Dibuja las notificaciones
void Screen::renderNotifications()
{
if (!notifyActive)
if (notifyActive)
{
return;
notify->render();
}
SDL_RenderSetLogicalSize(renderer, notificationLogicalWidth, notificationLogicalHeight);
notify->render();
SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
}
// Establece el tamaño de las notificaciones
@@ -460,4 +464,48 @@ void Screen::setNotificationSize()
notificationLogicalWidth = windowWidth / 3;
notificationLogicalHeight = windowHeight / 3;
}
}
// Copia el gameCanvas en el borderCanvas
void Screen::gameCanvasToBorderCanvas()
{
auto temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, borderCanvas);
SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
SDL_SetRenderTarget(renderer, temp);
}
// Muestra el contenido de Screen por pantalla
void Screen::renderPresent()
{
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
SDL_RenderClear(renderer);
if (options->shaders)
{
// Aplica shaders y renderiza el contenido
shader::render();
}
else
{
if (options->borderEnabled)
{
SDL_RenderCopy(renderer, borderCanvas, nullptr, nullptr);
}
else
{
SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);
}
SDL_RenderPresent(renderer);
}
}
// Cambia el estado de los shaders
void Screen::toggleShaders()
{
options->shaders = !options->shaders;
setVideoMode(options->videoMode);
}

15
source/jail_engine/screen.h
View File

@@ -69,6 +69,12 @@ private:
// Establece el tamaño de las notificaciones
void setNotificationSize();
// Copia el gameCanvas en el borderCanvas
void gameCanvasToBorderCanvas();
// Muestra el contenido de Screen por pantalla
void renderPresent();
public:
// Constructor
Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options_t *options);
@@ -86,13 +92,13 @@ public:
void startDrawOnBorder();
// Vuelca el contenido del renderizador en pantalla
void blit();
void render();
// Establece el modo de video
void setVideoMode(int videoMode);
// Camibia entre pantalla completa y ventana
void switchVideoMode();
void toggleVideoMode();
// Cambia el tamaño de la ventana
void setWindowSize(int size);
@@ -117,7 +123,7 @@ public:
void setBorderEnabled(bool value);
// Cambia entre borde visible y no visible
void switchBorder();
void toggleBorder();
// Activa el fade
void setFade();
@@ -142,6 +148,9 @@ public:
// Muestra una notificación de texto por pantalla;
void showNotification(std::string text1 = "", std::string text2 = "", int icon = -1);
// Cambia el estado de los shaders
void toggleShaders();
};
#endif

1
source/jail_engine/utils.h
View File

@@ -132,6 +132,7 @@ struct options_t
int windowSize; // Contiene el valor por el que se multiplica el tamaño de la ventana
Uint32 filter; // Filtro usado para el escalado de la imagen
bool vSync; // Indica si se quiere usar vsync o no
bool shaders; // Indica si se van a usar shaders o no
int gameWidth; // Ancho de la resolucion nativa del juego
int gameHeight; // Alto de la resolucion nativa del juego
bool integerScale; // Indica si el escalado de la imagen ha de ser entero en el modo a pantalla completa