Fix some rendering warnings

4 files changed, 43 insertions, 56 deletions

diff --git a/src/rendering/include/engine/rendering/rendering.h b/src/rendering/include/engine/rendering/rendering.h
index b3e266a..b022117 100644
--- a/src/rendering/include/engine/rendering/rendering.h
+++ b/src/rendering/include/engine/rendering/rendering.h
@@ -120,7 +120,7 @@ typedef struct {
 
   /* MVP (a uniform from the shader).
    * This could also probably be generalized */
-  u32 mvp;
+  i32 mvp;
 
   // The texture ID, glBindTextures(target, &this->texture)
   u32 texture;
@@ -236,7 +236,7 @@ int renderbatch_refresh(RenderBatch* renderbatch);
 
 Shader compile_shader(const char* file_path, const ShaderType shader_type);
 Shader compose_shader(Shader *shaders, usize shaders_len);
-void shaders_delete(Shader* shader, isize shader_len);
+void shaders_delete(Shader* shader, usize shader_len);
 
 u32 ComposeShader(u32 *shaders, usize shaders_len);
 
diff --git a/src/rendering/src/gl.c b/src/rendering/src/gl.c
index 99a0636..eec56e2 100644
--- a/src/rendering/src/gl.c
+++ b/src/rendering/src/gl.c
@@ -24,11 +24,11 @@ const char* ShaderType_str[] = {
 };
 
 Shader compile_shader(const char* file_path, const ShaderType shader_type) {
-  GLuint shaderID = 0;
+  u32 shaderID = 0;
   GLenum shadertype = GL_INVALID_ENUM;
 
-  GLint Result = GL_FALSE;
-  int InfoLogLength;
+  i32 Result = GL_FALSE;
+  i32 infolog_len;
 
   char* source = NULL;
   FILE* file = NULL;
@@ -58,10 +58,10 @@ Shader compile_shader(const char* file_path, const ShaderType shader_type) {
   if(file != NULL) {
     const i64 size = f_get_sz(file);
 
-    source = calloc(size + 1, sizeof(char));
+    source = calloc((usize)size + 1, sizeof(char));
 
     // Assume the whole file is successfully read
-    fread(source, sizeof(char), size, file);
+    fread(source, sizeof(char), (usize)size, file);
 
     fclose(file);
   } else {
@@ -77,10 +77,10 @@ Shader compile_shader(const char* file_path, const ShaderType shader_type) {
 
   // Check shader
   gl->GetShaderiv(shaderID, GL_COMPILE_STATUS, &Result);
-  gl->GetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
-  if ( InfoLogLength > 0 ) {
-    char* msg = calloc(InfoLogLength + 1, sizeof(char));
-    gl->GetShaderInfoLog(shaderID, InfoLogLength, NULL, msg);
+  gl->GetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &infolog_len);
+  if ( infolog_len > 0 ) {
+    char* msg = calloc((usize)infolog_len + 1, sizeof(char));
+    gl->GetShaderInfoLog(shaderID, infolog_len, NULL, msg);
     ERROR("Failed to compile shader: " TERM_COLOR_YELLOW "%s" TERM_COLOR_RESET, msg);
     free(msg);
   }
@@ -91,13 +91,13 @@ Shader compile_shader(const char* file_path, const ShaderType shader_type) {
 
 
 // http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/
-GLuint load_shaders(
+u32 load_shaders(
     const GladGLContext* gl,
     const char* vertex_file_path,
     const char* fragment_file_path) {
 
-  GLint Result = GL_FALSE;
-  int InfoLogLength;
+  i32 Result = GL_FALSE;
+  i32 infolog_len;
 
   // Create the shaders
   const Shader vertexShader = compile_shader(vertex_file_path, Shader_Vertex);
@@ -105,7 +105,7 @@ GLuint load_shaders(
 
   // Link the program
   INFO("Linking program");
-  GLuint ProgramID = gl->CreateProgram();
+  u32 ProgramID = gl->CreateProgram();
 
   if (vertex_file_path != NULL) gl->AttachShader(ProgramID, vertexShader.program);
   if (fragment_file_path != NULL) gl->AttachShader(ProgramID, fragmentShader.program);
@@ -114,10 +114,10 @@ GLuint load_shaders(
 
   // Check the program
   gl->GetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
-  gl->GetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
-  if ( InfoLogLength > 0 ){
-    char* msg = calloc(InfoLogLength + 1, sizeof(char));
-    gl->GetShaderInfoLog(ProgramID, InfoLogLength, NULL, msg);
+  gl->GetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &infolog_len);
+  if ( infolog_len > 0 ){
+    char* msg = calloc((usize)infolog_len  + 1, sizeof(char));
+    gl->GetShaderInfoLog(ProgramID, infolog_len, NULL, msg);
     ERROR("Compiling shader: " TERM_COLOR_YELLOW "%s" TERM_COLOR_RESET, msg);
     free(msg);
   }
@@ -134,7 +134,7 @@ GLuint load_shaders(
 /* Returns a shader program */
 Shader compose_shader(Shader *shaders, usize shaders_len) {
   const GladGLContext* gl = GLOBAL_PLATFORM->window->context;
-  GLint Result = GL_FALSE;
+  i32 Result = GL_FALSE;
 
   if (shaders_len == 0) {
     ERROR("No shaders provided!");
@@ -148,7 +148,7 @@ Shader compose_shader(Shader *shaders, usize shaders_len) {
     return (Shader){.program = 0, .type = Shader_Error};
   }
 
-  for (int i = 0; i < shaders_len; i++) {
+  for (usize i = 0; i < shaders_len; i++) {
     gl->AttachShader(prog, shaders[i].program);
     INFO("Attaching shader %d to %d", shaders[i].program, prog);
   }
@@ -159,10 +159,10 @@ Shader compose_shader(Shader *shaders, usize shaders_len) {
   gl->GetProgramiv(prog, GL_LINK_STATUS, &Result);
   if (Result != GL_TRUE) {
     // Get the size of the log
-    int log_len = 0;
-    int msg_len = 0;
+    i32 log_len = 0;
+    i32 msg_len = 0;
     gl->GetProgramiv(prog, GL_INFO_LOG_LENGTH, &log_len);
-    char* msg = calloc(log_len + 1, sizeof(char));
+    char* msg = calloc((usize)log_len + 1, sizeof(char));
 
     // Copy the log message(s)
     gl->GetProgramInfoLog(prog, log_len, &msg_len, msg);
@@ -171,17 +171,18 @@ Shader compose_shader(Shader *shaders, usize shaders_len) {
     free(msg);
   }
 
-  for (int i = 0; i < shaders_len; i++) {
+  for (usize i = 0; i < shaders_len; i++) {
     gl->DetachShader(prog, shaders[i].program);
   }
 
   return (Shader){.program = prog, .type = Shader_Program};
 }
 
-void shaders_delete(Shader* shader, isize shader_len) {
+/* Free up resources associated with `shader` */
+void shaders_delete(Shader* shader, usize shader_len) {
   const GladGLContext* gl = GLOBAL_PLATFORM->window->context;
 
-  for (isize i = 0; i < shader_len; i++) {
+  for (usize i = 0; i < shader_len; i++) {
     gl->DeleteShader(shader[i].program);
   }
 }
diff --git a/src/rendering/src/rendering.c b/src/rendering/src/rendering.c
index 1eb5438..9ffd970 100644
--- a/src/rendering/src/rendering.c
+++ b/src/rendering/src/rendering.c
@@ -227,8 +227,8 @@ void render_present(Window* w) {
   glm_vec3_sub(c.pos, c.dir, angle);
   glm_lookat(c.pos, angle, GLM_YUP, view);
 
-  for (i32 i = 0; i < drawcall_len; i++) {
-    RenderDrawCall dc = drawcalls[i];
+  for (i32 drawcall_idx = 0; drawcall_idx < drawcall_len; drawcall_idx++) {
+    RenderDrawCall dc = drawcalls[drawcall_idx];
     switch (dc.type) {
     case RenderDrawCallType_Sprite: {
       // TODO render a quad
@@ -242,7 +242,6 @@ void render_present(Window* w) {
       // bind index buffer
 
 
-      u64 t = get_time();
       RenderObject* o = dc.data.model.model;
       vec3 pos;
       glm_vec3_copy(dc.data.model.pos, pos);
@@ -267,7 +266,7 @@ void render_present(Window* w) {
         }
 
         // TODO: Do this only once during initialization
-        u32 matrix = o->mvp;
+        i32 matrix = o->mvp;
 
         gl->UniformMatrix4fv(matrix, 1, GL_FALSE, &modelviewprojection[0][0]);
       }
@@ -303,20 +302,6 @@ void render_present(Window* w) {
       //if (i == 8) {
       //  printf("\r obj: %.3f", (double)(get_time() - t) * 1000.);
       //}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
     } break;
     default:
       break;
@@ -331,18 +316,18 @@ void render_present(Window* w) {
 void drawcall_reset(void) { drawcall_len = 0; }
 
 void r_perspective(f32 fov, Camera *c) {
-  const f64 ratio = (f64)GLOBAL_PLATFORM->window->windowsize[0]
-                  / (f64)GLOBAL_PLATFORM->window->windowsize[1];
+  const f32 ratio = (f32)GLOBAL_PLATFORM->window->windowsize[0]
+                  / (f32)GLOBAL_PLATFORM->window->windowsize[1];
 
   c->type = Camera_Perspective;
   c->parameters.perspective.fov = fov;
 
-  glm_perspective(glm_rad(fov), ratio, 0.1, 100.0f, c->per);
+  glm_perspective(glm_rad(fov), ratio, 0.1f, 100.0f, c->per);
 }
 
 void r_perspective_ortho(f32 sz, Camera *c) {
-  const f64 ratio = (f64)GLOBAL_PLATFORM->window->windowsize[0]
-                  / (f64)GLOBAL_PLATFORM->window->windowsize[1];
+  const f32 ratio = (f32)GLOBAL_PLATFORM->window->windowsize[0]
+                  / (f32)GLOBAL_PLATFORM->window->windowsize[1];
 
   c->type = Camera_Orthogonal;
   c->parameters.orthogonal.sz = sz;
diff --git a/src/rendering/src/window.c b/src/rendering/src/window.c
index 5bb01b0..e3b5524 100644
--- a/src/rendering/src/window.c
+++ b/src/rendering/src/window.c
@@ -22,6 +22,7 @@
 extern Platform* GLOBAL_PLATFORM;
 
 void *window_poll_events = NULL;
+
 /* wrapper to get time in ms */
 u64 (*get_time)(void) = NULL;
 
@@ -62,22 +63,22 @@ GladGLContext* create_context(GLFWwindow *window) {
 
 /* Should honestly just write my own */
 static inline u64 glfw_gettime_msec() {
-  return glfwGetTime() * 1000;
+  return (u64)(glfwGetTime() * 1000.0);
 }
 
 /* Should honestly just write my own */
 static inline u64 glfw_gettime_usec() {
-  return (f64)glfwGetTime() * 1000000;
+  return (u64)(glfwGetTime() * 1000000.0);
 }
 
-static inline u64 platform_get_time_usec() {
+static inline u64 platform_get_time_usec(void) {
   struct timespec t;
   int res = clock_gettime(CLOCK_MONOTONIC, &t);
   if (res != 0) {
     // TODO: Check errno
     WARN("Failed to get system time");
   }
-  return (t.tv_sec * 1000000) + (t.tv_nsec / 1000);
+  return (u64)(t.tv_sec * 1000000 + t.tv_nsec / 1000);
 }
 
 Window* init_window_glfw(
@@ -141,7 +142,7 @@ Window* init_window_glfw(
   ret->renderer = WINDOW_RENDERER_NONE;
   glm_ivec2_copy(windowsize, ret->windowsize);
   ret->window = window;
-  // Last parameter is used for the renderer
+  /* Last parameter is used for the renderer */
   ret->context = NULL;
 
   window_poll_events = &glfwPollEvents;
@@ -151,7 +152,7 @@ Window* init_window_glfw(
   return ret;
 }
 
-// Initializes opengl using the window
+/* Initializes opengl using the window */
 void init_render_opengl(Window* w) {
   if (w == NULL || w->window == NULL) {
     ERROR("Window is not initialized");