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

linter

Browse Source
This commit is contained in:
Sergio
2025-10-24 18:11:51 +02:00
parent 145d1e3fc0
commit 5d1c6c6d99
3 changed files with 36 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
source/rendering/opengl/opengl_shader.cpp
View File

@@ -76,8 +76,8 @@ auto OpenGLShader::compileShader(const std::string& source, GLenum shader_type)
return 0; return 0;
} }
const char* sources[1] = {source.c_str()}; std::array<const char*, 1> sources = {source.c_str()};
glShaderSource(shader_id, 1, sources, nullptr); glShaderSource(shader_id, 1, sources.data(), nullptr);
checkGLError("glShaderSource"); checkGLError("glShaderSource");
glCompileShader(shader_id); glCompileShader(shader_id);
@@ -149,7 +149,7 @@ auto OpenGLShader::linkProgram(GLuint vertex_shader, GLuint fragment_shader) ->
void OpenGLShader::createQuadGeometry() { void OpenGLShader::createQuadGeometry() {
// Datos del quad: posición (x, y) + coordenadas de textura (u, v) // Datos del quad: posición (x, y) + coordenadas de textura (u, v)
// Formato: x, y, u, v // Formato: x, y, u, v
float vertices[] = { std::array<float, 16> vertices = {
// Posición // TexCoords // Posición // TexCoords
-1.0F, -1.0F,
-1.0F, -1.0F,
@@ -170,7 +170,7 @@ void OpenGLShader::createQuadGeometry() {
}; };
// Índices para dibujar el quad con dos triángulos // Índices para dibujar el quad con dos triángulos
unsigned int indices[] = { std::array<unsigned int, 6> indices = {
0, 0,
1, 1,
2, // Primer triángulo 2, // Primer triángulo
@@ -187,22 +187,22 @@ void OpenGLShader::createQuadGeometry() {
// Generar y configurar VBO // Generar y configurar VBO
glGenBuffers(1, &vbo_); glGenBuffers(1, &vbo_);
glBindBuffer(GL_ARRAY_BUFFER, vbo_); glBindBuffer(GL_ARRAY_BUFFER, vbo_);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_STATIC_DRAW);
checkGLError("glBufferData(VBO)"); checkGLError("glBufferData(VBO)");
// Generar y configurar EBO // Generar y configurar EBO
glGenBuffers(1, &ebo_); glGenBuffers(1, &ebo_);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices.data(), GL_STATIC_DRAW);
checkGLError("glBufferData(EBO)"); checkGLError("glBufferData(EBO)");
// Atributo 0: Posición (2 floats) // Atributo 0: Posición (2 floats)
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), nullptr);
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
checkGLError("glVertexAttribPointer(position)"); checkGLError("glVertexAttribPointer(position)");
// Atributo 1: Coordenadas de textura (2 floats) // Atributo 1: Coordenadas de textura (2 floats)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float))); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), reinterpret_cast<void*>(2 * sizeof(float)));
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
checkGLError("glVertexAttribPointer(texcoord)"); checkGLError("glVertexAttribPointer(texcoord)");
@@ -212,7 +212,9 @@ void OpenGLShader::createQuadGeometry() {
} }
auto OpenGLShader::getTextureID(SDL_Texture* texture) -> GLuint { auto OpenGLShader::getTextureID(SDL_Texture* texture) -> GLuint {
if (!texture) return 1; if (texture == nullptr) {
return 1;
}
SDL_PropertiesID props = SDL_GetTextureProperties(texture); SDL_PropertiesID props = SDL_GetTextureProperties(texture);
GLuint texture_id = 0; GLuint texture_id = 0;
@@ -245,7 +247,7 @@ auto OpenGLShader::init(SDL_Window* window,
back_buffer_ = texture; back_buffer_ = texture;
renderer_ = SDL_GetRenderer(window); renderer_ = SDL_GetRenderer(window);
if (!renderer_) { if (renderer_ == nullptr) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"Error: No se pudo obtener el renderer"); "Error: No se pudo obtener el renderer");
return false; return false;
@@ -276,10 +278,10 @@ auto OpenGLShader::init(SDL_Window* window,
// Verificar que es OpenGL // Verificar que es OpenGL
const char* renderer_name = SDL_GetRendererName(renderer_); const char* renderer_name = SDL_GetRendererName(renderer_);
if (!renderer_name || strncmp(renderer_name, "opengl", 6) != 0) { if ((renderer_name == nullptr) || strncmp(renderer_name, "opengl", 6) != 0) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
"Renderer no es OpenGL: %s", "Renderer no es OpenGL: %s",
renderer_name ? renderer_name : "unknown"); (renderer_name != nullptr) ? renderer_name : "unknown");
return false; return false;
} }
@@ -305,8 +307,12 @@ auto OpenGLShader::init(SDL_Window* window,
if (vertex_shader == 0 || fragment_shader == 0) { if (vertex_shader == 0 || fragment_shader == 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"Error al compilar shaders"); "Error al compilar shaders");
if (vertex_shader != 0) glDeleteShader(vertex_shader); if (vertex_shader != 0) {
if (fragment_shader != 0) glDeleteShader(fragment_shader); glDeleteShader(vertex_shader);
}
if (fragment_shader != 0) {
glDeleteShader(fragment_shader);
}
return false; return false;
} }
@@ -370,15 +376,16 @@ void OpenGLShader::render() {
} }
// Obtener tamaño actual de ventana (puede haber cambiado) // Obtener tamaño actual de ventana (puede haber cambiado)
int current_width, current_height; int current_width;
int current_height;
SDL_GetWindowSize(window_, &current_width, &current_height); SDL_GetWindowSize(window_, &current_width, &current_height);
// Guardar estados OpenGL // Guardar estados OpenGL
GLint old_program; GLint old_program;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_program); glGetIntegerv(GL_CURRENT_PROGRAM, &old_program);
GLint old_viewport[4]; std::array<GLint, 4> old_viewport{};
glGetIntegerv(GL_VIEWPORT, old_viewport); glGetIntegerv(GL_VIEWPORT, old_viewport.data());
GLboolean was_texture_enabled = glIsEnabled(GL_TEXTURE_2D); GLboolean was_texture_enabled = glIsEnabled(GL_TEXTURE_2D);
GLint old_texture; GLint old_texture;
@@ -403,7 +410,8 @@ void OpenGLShader::render() {
checkGLError("glUseProgram"); checkGLError("glUseProgram");
// Configurar viewport (obtener tamaño lógico de SDL) // Configurar viewport (obtener tamaño lógico de SDL)
int logical_w, logical_h; int logical_w;
int logical_h;
SDL_RendererLogicalPresentation mode; SDL_RendererLogicalPresentation mode;
SDL_GetRenderLogicalPresentation(renderer_, &logical_w, &logical_h, &mode); SDL_GetRenderLogicalPresentation(renderer_, &logical_w, &logical_h, &mode);
@@ -413,14 +421,16 @@ void OpenGLShader::render() {
} }
// Calcular viewport considerando aspect ratio // Calcular viewport considerando aspect ratio
int viewport_x = 0, viewport_y = 0; int viewport_x = 0;
int viewport_w = current_width, viewport_h = current_height; int viewport_y = 0;
int viewport_w = current_width;
int viewport_h = current_height;
if (mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) { if (mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) {
int scale_x = current_width / logical_w; int scale_x = current_width / logical_w;
int scale_y = current_height / logical_h; int scale_y = current_height / logical_h;
int scale = (scale_x < scale_y) ? scale_x : scale_y; int scale = (scale_x < scale_y) ? scale_x : scale_y;
if (scale < 1) scale = 1; scale = std::max(scale, 1);
viewport_w = logical_w * scale; viewport_w = logical_w * scale;
viewport_h = logical_h * scale; viewport_h = logical_h * scale;
@@ -444,7 +454,7 @@ void OpenGLShader::render() {
// Dibujar quad usando VAO // Dibujar quad usando VAO
glBindVertexArray(vao_); glBindVertexArray(vao_);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
checkGLError("glDrawElements"); checkGLError("glDrawElements");
// Presentar // Presentar
@@ -453,7 +463,7 @@ void OpenGLShader::render() {
// Restaurar estados OpenGL // Restaurar estados OpenGL
glUseProgram(old_program); glUseProgram(old_program);
glBindTexture(GL_TEXTURE_2D, old_texture); glBindTexture(GL_TEXTURE_2D, old_texture);
if (!was_texture_enabled) { if (was_texture_enabled == 0u) {
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
} }
glBindVertexArray(old_vao); glBindVertexArray(old_vao);

4
source/rendering/opengl/opengl_shader.hpp
View File

@@ -39,8 +39,8 @@ class OpenGLShader : public ShaderBackend {
auto compileShader(const std::string& source, GLenum shader_type) -> GLuint; auto compileShader(const std::string& source, GLenum shader_type) -> GLuint;
auto linkProgram(GLuint vertex_shader, GLuint fragment_shader) -> GLuint; auto linkProgram(GLuint vertex_shader, GLuint fragment_shader) -> GLuint;
void createQuadGeometry(); void createQuadGeometry();
auto getTextureID(SDL_Texture* texture) -> GLuint; static auto getTextureID(SDL_Texture* texture) -> GLuint;
void checkGLError(const char* operation); static void checkGLError(const char* operation);
// Estado SDL // Estado SDL
SDL_Window* window_ = nullptr; SDL_Window* window_ = nullptr;

2
source/sections/game.hpp
View File

@@ -337,7 +337,7 @@ class Game {
// --- Gestion y dibujado de jugadores en z-order --- // --- Gestion y dibujado de jugadores en z-order ---
static void buildPlayerDrawList(const Players& elements, Players& draw_list); // Construye el draw_list a partir del vector principal static void buildPlayerDrawList(const Players& elements, Players& draw_list); // Construye el draw_list a partir del vector principal
void updatePlayerDrawList(const Players& elements, Players& draw_list); // Actualiza draw_list tras cambios en los z_order static void updatePlayerDrawList(const Players& elements, Players& draw_list); // Actualiza draw_list tras cambios en los z_order
static void renderPlayerDrawList(const Players& draw_list); // Dibuja en el orden definido static void renderPlayerDrawList(const Players& draw_list); // Dibuja en el orden definido
static auto findPlayerIndex(const Players& elems, const std::shared_ptr<Player>& who) -> size_t; static auto findPlayerIndex(const Players& elems, const std::shared_ptr<Player>& who) -> size_t;
void sendPlayerToBack(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list); // Envia al jugador al fondo de la pantalla void sendPlayerToBack(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list); // Envia al jugador al fondo de la pantalla