refactor(renderer): improve error handling and memory management in shader and vertex buffer creation

- Enhanced error handling in GL_CreateShaderProgram and GL_CreateVertexBuffer functions to ensure proper resource cleanup on allocation failures.
- Replaced nullptr with 0 for shader program and shader pointers to maintain consistency in memory management practices.
- Introduced error logging for failed memory allocations to aid in debugging and improve overall robustness of the rendering system.

Author: timfox

src/common/crash_verbose.cpp

@@ -11,8 +11,11 @@
 // Crash logs directory
 #define CRASH_LOG_DIR "logs"
 
+// Maximum backtrace depth - can be increased if needed for very deep call stacks
+#define MAX_BACKTRACE_DEPTH 256
+
 void append_verbose_crash_context(void) {
-    void* buffer[256];
+    void* buffer[MAX_BACKTRACE_DEPTH];
     int nptrs = backtrace(buffer, sizeof(buffer) / sizeof(void*));
     if (nptrs <= 0) return;
 

src/renderers/opengl/gl_shader.c

@@ -105,17 +105,17 @@ GL_ShaderShutdown
 void GL_ShaderShutdown(void) {
     if (shaderManager.defaultProgram.program) {
         qglDeleteProgram(shaderManager.defaultProgram.program);
-        shaderManager.defaultProgram.program = nullptr;
+        shaderManager.defaultProgram.program = 0;
     }
 
     if (shaderManager.defaultProgram.vertexShader) {
         qglDeleteShader(shaderManager.defaultProgram.vertexShader);
-        shaderManager.defaultProgram.vertexShader = nullptr;
+        shaderManager.defaultProgram.vertexShader = 0;
     }
 
     if (shaderManager.defaultProgram.fragmentShader) {
         qglDeleteShader(shaderManager.defaultProgram.fragmentShader);
-        shaderManager.defaultProgram.fragmentShader = nullptr;
+        shaderManager.defaultProgram.fragmentShader = 0;
     }
 
     Com_Memset(&shaderManager, 0, sizeof(shaderManager));
@@ -128,6 +128,10 @@ GL_CreateShaderProgram
 */
 shaderProgram_t *GL_CreateShaderProgram(const char *vertexSource, const char *fragmentSource) {
     shaderProgram_t *program = ri.Malloc(sizeof(shaderProgram_t));
+    if (!program) {
+        ri.Printf(PRINT_ERROR, "GL_CreateShaderProgram: Failed to allocate shader program structure\n");
+        return nullptr;
+    }
     Com_Memset(program, 0, sizeof(shaderProgram_t));
 
     program->vertexShader = qglCreateShader(GL_VERTEX_SHADER);
@@ -140,6 +144,19 @@ shaderProgram_t *GL_CreateShaderProgram(const char *vertexSource, const char *fr
 
         program->compiled = qtrue;
         program->linked = qtrue;
+    } else {
+        // Compilation/linking failed - clean up OpenGL objects
+        if (program->program) {
+            qglDeleteProgram(program->program);
+        }
+        if (program->vertexShader) {
+            qglDeleteShader(program->vertexShader);
+        }
+        if (program->fragmentShader) {
+            qglDeleteShader(program->fragmentShader);
+        }
+        ri.Free(program);
+        return nullptr;
     }
 
     return program;

src/renderers/opengl/gl_vertex.c

@@ -97,6 +97,10 @@ GL_CreateVertexBuffer
 */
 vertexBuffer_t *GL_CreateVertexBuffer(int maxVertices, int maxIndices, qboolean dynamic) {
     vertexBuffer_t *buffer = ri.Malloc(sizeof(vertexBuffer_t));
+    if (!buffer) {
+        ri.Printf(PRINT_ERROR, "GL_CreateVertexBuffer: Failed to allocate vertex buffer structure\n");
+        return nullptr;
+    }
     Com_Memset(buffer, 0, sizeof(vertexBuffer_t));
 
     buffer->maxVertices = maxVertices;
@@ -113,8 +117,30 @@ vertexBuffer_t *GL_CreateVertexBuffer(int maxVertices, int maxIndices, qboolean
 
     // Allocate memory
     buffer->vertices = ri.Malloc(sizeof(vertex_t) * maxVertices);
+    if (!buffer->vertices) {
+        ri.Printf(PRINT_ERROR, "GL_CreateVertexBuffer: Failed to allocate vertex data (%d vertices)\n", maxVertices);
+        // Clean up OpenGL objects
+        qglDeleteVertexArrays(1, &buffer->vao);
+        qglDeleteBuffers(1, &buffer->vbo);
+        if (maxIndices > 0) {
+            qglDeleteBuffers(1, &buffer->ibo);
+        }
+        ri.Free(buffer);
+        return nullptr;
+    }
+
     if (maxIndices > 0) {
         buffer->indices = ri.Malloc(sizeof(GLuint) * maxIndices);
+        if (!buffer->indices) {
+            ri.Printf(PRINT_ERROR, "GL_CreateVertexBuffer: Failed to allocate index data (%d indices)\n", maxIndices);
+            // Clean up everything
+            ri.Free(buffer->vertices);
+            qglDeleteVertexArrays(1, &buffer->vao);
+            qglDeleteBuffers(1, &buffer->vbo);
+            qglDeleteBuffers(1, &buffer->ibo);
+            ri.Free(buffer);
+            return nullptr;
+        }
     }
 
     return buffer;