OpenGL: If-statement instead of asserting when activating material with mvp

renderer_backend_opengl_windows.odin

@@ -277,19 +277,22 @@ when RENDER_BACKEND_OPENGL {
         opengl_activate_bind_textures_in_material(material)
 
         model_matrix_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_model_matrix")
-        assert(model_matrix_loc >= 0)
+        if model_matrix_loc >= 0 {
-        model_matrix_as_f32_array := transmute([16]f32)(model_matrix)
+            model_matrix_as_f32_array := transmute([16]f32)(model_matrix)
-        gl.UniformMatrix4fv(model_matrix_loc, 1, false, &model_matrix_as_f32_array[0])
+            gl.UniformMatrix4fv(model_matrix_loc, 1, false, &model_matrix_as_f32_array[0])
+        }
 
         view_matrix_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_view_matrix")
-        assert(view_matrix_loc >= 0)
+        if view_matrix_loc >= 0 {
-        view_matrix_as_f32_array := transmute([16]f32)(view_matrix)
+            view_matrix_as_f32_array := transmute([16]f32)(view_matrix)
-        gl.UniformMatrix4fv(view_matrix_loc, 1, false, &view_matrix_as_f32_array[0])
+            gl.UniformMatrix4fv(view_matrix_loc, 1, false, &view_matrix_as_f32_array[0])
+        }
         
         projection_matrix_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_projection_matrix")
-        assert(projection_matrix_loc >= 0)
+        if projection_matrix_loc >= 0 {
-        projection_matrix_as_f32_array := transmute([16]f32)(projection_matrix)
+            projection_matrix_as_f32_array := transmute([16]f32)(projection_matrix)
-        gl.UniformMatrix4fv(projection_matrix_loc, 1, false, &projection_matrix_as_f32_array[0])
+            gl.UniformMatrix4fv(projection_matrix_loc, 1, false, &projection_matrix_as_f32_array[0])
+        }
     }
     
     opengl_activate_fullscreen_material :: proc(material: ^Material) { // TODO: SS - Maybe remove.

shader.odin

@@ -1,5 +1,6 @@
 package renderer
 
+import "core:fmt"
 import os "core:os/os2"
 
 Shader :: struct {
@@ -9,7 +10,7 @@ Shader :: struct {
 }
 
 Shader_Program :: struct {
-    vertex_shader, fragment_shader: Shader,
+    vertex_shader, fragment_shader: ^Shader,
     backend: Shader_Program_Backend,
 }
 
@@ -20,6 +21,7 @@ Shader_Type :: enum {
 }
 
 create_shader :: proc(renderer: ^Renderer, type: Shader_Type, path: string) -> (Shader, bool) {
+    fmt.printfln("Creating shader")
     bytes, error := os.read_entire_file_from_path(path, context.allocator)
     if error != nil {
         return {}, false
@@ -36,6 +38,7 @@ create_shader :: proc(renderer: ^Renderer, type: Shader_Type, path: string) -> (
             return {}, false
         }
         s.backend = shader_opengl
+        fmt.printfln("Backend id: %v", s.backend)
     }
     else {
         #assert(false)
@@ -57,8 +60,8 @@ create_shader_program :: proc(renderer: ^Renderer, vertex_shader, fragment_shade
     assert(fragment_shader != nil)
 
     p: Shader_Program
-    p.vertex_shader = vertex_shader^
+    p.vertex_shader = vertex_shader
-    p.fragment_shader = fragment_shader^
+    p.fragment_shader = fragment_shader
 
     when RENDER_BACKEND_OPENGL {
         program_opengl, ok := opengl_create_shader_program(renderer, vertex_shader, fragment_shader)
@@ -80,4 +83,42 @@ delete_shader_program :: proc(renderer: ^Renderer, shader_program: ^Shader_Progr
     when RENDER_BACKEND_OPENGL {
         opengl_delete_shader_program(renderer, shader_program)
     }
-}
+}
+
+reload_shader_program :: proc(renderer: ^Renderer, p: ^Shader_Program) -> bool {
+    assert(renderer != nil)
+    assert(p != nil)
+    assert(p.vertex_shader != nil)
+    assert(p.fragment_shader != nil)
+
+    new_vs, vs_ok := create_shader(renderer, p.vertex_shader.type, p.vertex_shader.path)
+    if !vs_ok {
+        fmt.printfln("Failed to reload vertex shader")
+        return false
+    }
+
+    new_fs, fs_ok := create_shader(renderer, p.fragment_shader.type, p.fragment_shader.path)
+    if !fs_ok {
+        fmt.printfln("Failed to reload fragment shader")
+        delete_shader(renderer, &new_vs)
+        return false
+    }
+
+    new_program, program_ok := create_shader_program(renderer, &new_vs, &new_fs)
+    if !program_ok {
+        fmt.printfln("Failed to relink shader program")
+        delete_shader(renderer, &new_vs)
+        delete_shader(renderer, &new_fs)
+        return false
+    }
+
+    delete_shader_program(renderer, p)
+    delete_shader(renderer, p.vertex_shader)
+    delete_shader(renderer, p.fragment_shader)
+
+    p.backend         = new_program.backend
+    p.vertex_shader^  = new_vs
+    p.fragment_shader^ = new_fs
+
+    return true
+}