Allowed setting uniforms in shader

renderer.odin

@@ -135,6 +135,9 @@ render_frame :: proc(renderer: ^Renderer, texture_to_present: ^Texture, clear_co
     view_matrix, _       := get_camera_view_matrix(renderer.active_camera)
     projection_matrix, _ := get_camera_projection_matrix(renderer, renderer.active_camera)
 
+    set_clear_color(renderer, clear_color)
+    clear_screen(renderer, true, true)
+
     for i in 0 ..< renderer.pipeline.amount_of_passes {
         execute_pass(renderer, renderer.pipeline.passes[i], view_matrix, projection_matrix)
     }
@@ -149,7 +152,7 @@ render_frame :: proc(renderer: ^Renderer, texture_to_present: ^Texture, clear_co
         // Clear
         set_clear_color(renderer, clear_color)
         clear_screen(renderer, true, true)
-        
+
         // Create a temporary Material.
         mat := Material {
             shader_program = &renderer.fullscreen_shader_program,
@@ -159,12 +162,16 @@ render_frame :: proc(renderer: ^Renderer, texture_to_present: ^Texture, clear_co
             texture_count = 1,
         }
 
+        apply_blend_mode(renderer, .Alpha)
+
         // Activate.
         activate_fullscreen_material(renderer, &mat)
         defer deactivate_fullscreen_material(renderer)
 
         // Draw.
         draw_mesh(&renderer.fullscreen_mesh)
+
+        apply_blend_mode(renderer, .None)
     }
     
     when RENDER_BACKEND_OPENGL {
@@ -182,6 +189,7 @@ execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_m
         case Scene_Pass: {
             assert(t.output_rt != nil)
             bind_render_target(renderer, t.output_rt)
+            defer bind_render_target(renderer, nil)
 
             should_write_depth := t.output_rt.depth_texture != nil
             should_test_depth  := should_write_depth
@@ -194,6 +202,7 @@ execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_m
             apply_depth(renderer, should_test_depth, should_write_depth)
         
             apply_blend_mode(renderer, t.blend_mode)
+            defer apply_blend_mode(renderer, .None)
         
             sort_draw_commands(renderer, &t)
         
@@ -223,6 +232,7 @@ execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_m
             clear(&t.draw_commands)
 
             // TODO: SS - "Deactivate" the pass?
+
         }
         case Post_Processing_Pass: {
             // Execute the post-processing nodes.
@@ -243,47 +253,57 @@ execute_post_processing_node :: proc(renderer: ^Renderer, node: ^Post_Processing
 
     assert(node.output != nil)
     bind_render_target(renderer, node.output)
+    defer bind_render_target(renderer, nil)
 
     apply_depth(renderer, false, false)
+    set_clear_color(renderer, RGBA_Color { 0, 0, 0, 0 })
     clear_screen(renderer, true, false)
 
     // fmt.printfln("TODO: SS - Execute post-processing node '%v' (VS: '%v', FS: '%v').", "NAME", node.program.vertex_shader.path, node.program.fragment_shader.path)
 
-    t: [MATERIAL_MAX_TEXTURES]^Texture
-    t_count := u8(0)
-    for input_texture, i in node.input {
-        if i > MATERIAL_MAX_TEXTURES {
-            break
+    mat: Material
+    mat.shader_program = node.program
+
+    fs_path := node.program.fragment_shader != nil  ? node.program.fragment_shader.path : "nil"
+    vs_path := node.program.vertex_shader != nil    ? node.program.vertex_shader.path   : "nil"
+    
+    for u, i in node.uniforms {
+        switch &t in u {
+            case Uniform_Texture: {
+                if mat.texture_count > MATERIAL_MAX_TEXTURES {
+                    continue
+                }
+
+                if set_shader_uniform(node.program, t) {
+                    mat.textures[mat.texture_count] = t.value
+                    mat.texture_count += 1
+                }
+                else {
+                    fmt.printfln("Failed to set uniform-texture %v in program (vs: '%s', fs: '%s').", t.index, vs_path, fs_path)
+                }
+            }
+            case Uniform_Float: {
+                if !set_shader_uniform(node.program, t) {
+                    fmt.printfln("Failed to set uniform-float '%s' in program (vs: '%s', fs: '%s').", t.name, vs_path, fs_path)
+                }
+            }
+            case Uniform_Matrix4f32: {
+                if !set_shader_uniform(node.program, t) {
+                    fmt.printfln("Failed to set uniform-matrix4f32 '%s' in program (vs: '%s', fs: '%s').", t.name, vs_path, fs_path)
+                }
+            }
+            case Uniform_Vector3: {
+                if !set_shader_uniform(node.program, t) {
+                    fmt.printfln("Failed to set uniform-vector3 '%s' in program (vs: '%s', fs: '%s').", t.name, vs_path, fs_path)
+                }
+            }
         }
-
-        set_shader_value(node.program, input_texture, u8(i))
-        t[i] = input_texture
-        t_count += 1
-    }
-
-    mat := Material {
-        shader_program = node.program,
-        textures = t,
-        texture_count = t_count,
     }
 
     activate_fullscreen_material(renderer, &mat)
     draw_mesh(&renderer.fullscreen_mesh)
 }
 
-set_shader_value :: proc {
-    set_shader_value_texture,
-}
-
-set_shader_value_texture :: proc(program: ^Shader_Program, value: ^Texture, index: u8) {
-    assert(program != nil)
-    assert(value != nil)
-
-    when RENDER_BACKEND_OPENGL {
-        opengl_set_shader_value_texture(program, value, index)
-    }
-}
-
 destroy :: proc(renderer: ^Renderer) {
     when RENDER_BACKEND_OPENGL {
         opengl_destroy(renderer)
@@ -293,7 +313,7 @@ destroy :: proc(renderer: ^Renderer) {
     free(renderer)
 }
 
-@(private) activate_material :: proc(material: ^Material, model_matrix, view_matrix, projection_matrix: linalg.Matrix4x4f32) {
+@(private) activate_material :: proc(material: ^Material, model_matrix, view_matrix, projection_matrix: linalg.Matrix4x4f32, uv_scale: [2]f32 = { 1.0, 1.0 }) {
     assert(material != nil)
 
     when RENDER_BACKEND_OPENGL {