jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

style: renombrades algunes variables en jail_shader.cpp

Browse Source
This commit is contained in:
Sergio
2025-06-10 13:36:00 +02:00
parent 32d3f96a3d
commit 5d573d51a6
1 changed files with 46 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
source/jail_shader.cpp
View File

@@ -67,7 +67,7 @@ namespace shader
#endif #endif
// Función para compilar un shader a partir de un std::string // Función para compilar un shader a partir de un std::string
GLuint compileShader(const std::string &source, GLuint shaderType) GLuint compileShader(const std::string &source, GLuint shader_type)
{ {
if (source.empty()) if (source.empty())
{ {
@@ -76,92 +76,92 @@ namespace shader
} }
// Crear identificador del shader // Crear identificador del shader
GLuint resultado = glCreateShader(shaderType); GLuint shader_id = glCreateShader(shader_type);
// Agregar una directiva según el tipo de shader // Agregar una directiva según el tipo de shader
std::string directiva = (shaderType == GL_VERTEX_SHADER) std::string directive = (shader_type == GL_VERTEX_SHADER)
? "#define VERTEX\n" ? "#define VERTEX\n"
: "#define FRAGMENT\n"; : "#define FRAGMENT\n";
const char *sources[2] = {directiva.c_str(), source.c_str()}; const char *sources[2] = {directive.c_str(), source.c_str()};
// Especificar el código fuente del shader // Especificar el código fuente del shader
glShaderSource(resultado, 2, sources, nullptr); glShaderSource(shader_id, 2, sources, nullptr);
// Compilar el shader // Compilar el shader
glCompileShader(resultado); glCompileShader(shader_id);
// Verificar si la compilación fue exitosa // Verificar si la compilación fue exitosa
GLint compiladoCorrectamente = GL_FALSE; GLint compiled_ok = GL_FALSE;
glGetShaderiv(resultado, GL_COMPILE_STATUS, &compiladoCorrectamente); glGetShaderiv(shader_id, GL_COMPILE_STATUS, &compiled_ok);
if (compiladoCorrectamente != GL_TRUE) if (compiled_ok != GL_TRUE)
{ {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error en la compilación del shader (%d)!", resultado); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error en la compilación del shader (%d)!", shader_id);
GLint longitudLog; GLint log_length;
glGetShaderiv(resultado, GL_INFO_LOG_LENGTH, &longitudLog); glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &log_length);
if (longitudLog > 0) if (log_length > 0)
{ {
std::vector<GLchar> log(longitudLog); std::vector<GLchar> log(log_length);
glGetShaderInfoLog(resultado, longitudLog, &longitudLog, log.data()); glGetShaderInfoLog(shader_id, log_length, &log_length, log.data());
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Registro de compilación del shader: %s", log.data()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Registro de compilación del shader: %s", log.data());
} }
glDeleteShader(resultado); glDeleteShader(shader_id);
resultado = 0; shader_id = 0;
} }
return resultado; return shader_id;
} }
// Función para compilar un programa de shaders (vertex y fragment) a partir de std::string // 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 compileProgram(const std::string &vertex_shader_source, const std::string &fragment_shader_source)
{ {
GLuint idPrograma = glCreateProgram(); GLuint program_id = glCreateProgram();
// Si el fragment shader está vacío, reutilizamos el código del vertex shader // Si el fragment shader está vacío, reutilizamos el código del vertex shader
GLuint idShaderVertice = compileShader(vertexShaderSource, GL_VERTEX_SHADER); GLuint vertex_shader_id = compileShader(vertex_shader_source, GL_VERTEX_SHADER);
GLuint idShaderFragmento = compileShader(fragmentShaderSource.empty() ? vertexShaderSource : fragmentShaderSource, GL_FRAGMENT_SHADER); GLuint fragment_shader_id = compileShader(fragment_shader_source.empty() ? vertex_shader_source : fragment_shader_source, GL_FRAGMENT_SHADER);
if (idShaderVertice && idShaderFragmento) if (vertex_shader_id && fragment_shader_id)
{ {
// Asociar los shaders al programa // Asociar los shaders al programa
glAttachShader(idPrograma, idShaderVertice); glAttachShader(program_id, vertex_shader_id);
glAttachShader(idPrograma, idShaderFragmento); glAttachShader(program_id, fragment_shader_id);
glLinkProgram(idPrograma); glLinkProgram(program_id);
glValidateProgram(idPrograma); glValidateProgram(program_id);
// Verificar el estado del enlace // Verificar el estado del enlace
GLint longitudLog; GLint log_length;
glGetProgramiv(idPrograma, GL_INFO_LOG_LENGTH, &longitudLog); glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &log_length);
if (longitudLog > 0) if (log_length > 0)
{ {
std::vector<char> log(longitudLog); std::vector<char> log(log_length);
glGetProgramInfoLog(idPrograma, longitudLog, &longitudLog, log.data()); 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()); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Registro de información del programa:\n%s", log.data());
} }
} }
if (idShaderVertice) if (vertex_shader_id)
{ {
glDeleteShader(idShaderVertice); glDeleteShader(vertex_shader_id);
} }
if (idShaderFragmento) if (fragment_shader_id)
{ {
glDeleteShader(idShaderFragmento); glDeleteShader(fragment_shader_id);
} }
return idPrograma; return program_id;
} }
bool init(SDL_Window *ventana, SDL_Texture *texturaBackBuffer, const std::string &vertexShader, const std::string &fragmentShader) bool init(SDL_Window *window, SDL_Texture *back_buffer_texture, const std::string &vertex_shader, const std::string &fragment_shader)
{ {
shader::win = ventana; shader::win = window;
shader::renderer = SDL_GetRenderer(ventana); shader::renderer = SDL_GetRenderer(window);
shader::backBuffer = texturaBackBuffer; shader::backBuffer = back_buffer_texture;
SDL_GetWindowSize(ventana, &win_size.x, &win_size.y); SDL_GetWindowSize(window, &win_size.x, &win_size.y);
SDL_GetTextureSize(texturaBackBuffer, &tex_size.x, &tex_size.y); SDL_GetTextureSize(back_buffer_texture, &tex_size.x, &tex_size.y);
const auto RENDER_NAME = SDL_GetRendererName(renderer); const auto render_name = SDL_GetRendererName(renderer);
// Verificar que el renderer sea OpenGL // Verificar que el renderer sea OpenGL
if (!strncmp(RENDER_NAME, "opengl", 6)) if (!strncmp(render_name, "opengl", 6))
{ {
#ifndef __APPLE__ #ifndef __APPLE__
if (!initGLExtensions()) if (!initGLExtensions())
@@ -172,7 +172,7 @@ namespace shader
} }
#endif #endif
// Compilar el programa de shaders utilizando std::string // Compilar el programa de shaders utilizando std::string
programId = compileProgram(vertexShader, fragmentShader); programId = compileProgram(vertex_shader, fragment_shader);
} }
else else
{ {