Polygon-mode, better shader-compile-error log, material variable 'casts_shadow'

material.odin

@@ -14,10 +14,11 @@ Material :: struct {
 
     uniforms: []Uniform,
 
+    casts_shadow: bool,
     uv_scale: [2]f32, // TODO: SS - Move?
 }
 
-create_material :: proc(program: ^Shader_Program, textures: []^Texture, uniforms: []Uniform) -> (Material, bool) {
+create_material :: proc(program: ^Shader_Program, textures: []^Texture, uniforms: []Uniform, casts_shadow: bool) -> (Material, bool) {
     m: Material
     m.shader_program = program
     
@@ -43,6 +44,7 @@ create_material :: proc(program: ^Shader_Program, textures: []^Texture, uniforms
 
 
     m.uniforms = uniforms
+    m.casts_shadow = casts_shadow
     m.uv_scale = { 1.0, 1.0 } // NOTE: SS - Hardcoded.
 
     return m, true

renderer.odin

@@ -17,6 +17,8 @@ Renderer :: struct {
     vsync: bool,
     backend: rawptr,
 
+    polygon_mode: Polygon_Mode,
+
     pipeline: Pipeline,
 
     active_camera: ^Camera, // NOTE: SS - Hardcoded to 1 active camera. Split-screen is likely not possible due to this. Fix(?).
@@ -26,6 +28,12 @@ Renderer :: struct {
     fullscreen_mesh: Mesh,
 }
 
+Polygon_Mode :: enum {
+    Fill,
+    Line,
+    Point,
+}
+
 Viewport :: struct {
     x, y, width, height: u16,
 }
@@ -155,6 +163,8 @@ render_frame :: proc(renderer: ^Renderer, texture_to_present: ^Texture, clear_co
         execute_pass(renderer, renderer.pipeline.passes[i], camera_view_matrix, camera_projection_matrix)
     }
     
+    apply_polygon_mode(renderer, .Fill)
+
     if texture_to_present != nil { // Present.
         // Bind to the screen.
         bind_render_target(renderer, nil)
@@ -192,7 +202,7 @@ render_frame :: proc(renderer: ^Renderer, texture_to_present: ^Texture, clear_co
     }
 }
 
-execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_matrix: linalg.Matrix4x4f32) {
+execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_matrix: linalg.Matrix4x4f32) { // TODO: SS - Move to 'pass.odin'.
     // fmt.printfln("Executing pass '%v'.", pass.name)
     
     assert(renderer != nil)
@@ -200,6 +210,8 @@ execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_m
     
     switch &t in &pass.type {
         case Scene_Pass: {
+            apply_polygon_mode(renderer, renderer.polygon_mode)
+            
             assert(t.output_rt != nil)
             bind_render_target(renderer, t.output_rt)
             defer bind_render_target(renderer, nil)
@@ -246,6 +258,7 @@ execute_pass :: proc(renderer: ^Renderer, pass: ^Pass, view_matrix, projection_m
 
             // TODO: SS - "Deactivate" the pass?
 
+            apply_polygon_mode(renderer, .Fill)
         }
         case Post_Processing_Pass: {
             // Execute the post-processing nodes.
@@ -478,3 +491,11 @@ distance_to_camera :: proc(camera: ^Camera, position: [3]f32) -> f32 {
         opengl_deactivate_fullscreen_material()
     }
 }
+
+@(private) apply_polygon_mode :: proc(renderer: ^Renderer, mode: Polygon_Mode) {
+    assert(renderer != nil)
+
+    when RENDER_BACKEND_OPENGL {
+        opengl_apply_polygon_mode(renderer, mode)
+    }
+}

renderer_backend_opengl_windows.odin

@@ -1,6 +1,7 @@
 #+private
 package renderer
 
+import "core:log"
 import "core:math/linalg"
 import "core:bytes"
 import "core:slice"
@@ -207,7 +208,7 @@ when RENDER_BACKEND_OPENGL {
         return m, true
     }
 
-    opengl_create_shader :: proc(renderer: ^Renderer, type: Shader_Type, data: []u8) -> (Shader_OpenGL, bool) {
+    opengl_create_shader :: proc(renderer: ^Renderer, type: Shader_Type, path: string, data: []u8) -> (Shader_OpenGL, bool) {
         handle: u32
         
         switch type {
@@ -232,7 +233,10 @@ when RENDER_BACKEND_OPENGL {
         gl.GetShaderiv(handle, gl.COMPILE_STATUS, &success)
         if success != 1 {
             gl.GetShaderInfoLog(handle, 512, nil, raw_data(&info_log))
-            fmt.printfln("OPENGL: Failed to compile shader of type %v. Log: '%v'.", type, info_log)
+            str := string(transmute(cstring)(&info_log))
+            b := transmute([]u8)str
+            b = b[:len(b) - 1]
+            log.errorf("OPENGL: Failed to compile shader '%v' of type %v. Log: '%v'.", path, type, string(b))
 
             return {}, false
         }
@@ -258,7 +262,10 @@ when RENDER_BACKEND_OPENGL {
         gl.GetProgramiv(handle, gl.LINK_STATUS, &success)
         if success != 1 {
             gl.GetProgramInfoLog(handle, 512, nil, raw_data(&info_log))
-            fmt.printfln("OPENGL: Failed to create shader-program. Log: '%v'.", info_log)
+            str := string(transmute(cstring)(&info_log))
+            b := transmute([]u8)str
+            b = b[:len(b) - 1]
+            log.errorf("OPENGL: Failed to create shader-program. Log: '%v'.", string(b))
             
             return {}, false
         }
@@ -656,5 +663,17 @@ when RENDER_BACKEND_OPENGL {
         
         return true
     }
-}
 
+    opengl_apply_polygon_mode :: proc(renderer: ^Renderer, mode: Polygon_Mode) {
+        assert(renderer != nil)
+
+        m: u32 = gl.FILL
+        switch mode {
+            case .Fill: m = gl.FILL
+            case .Line: m = gl.LINE
+            case .Point: m = gl.POINT
+        }
+
+        gl.PolygonMode(gl.FRONT_AND_BACK, m)
+    }
+}

shader.odin

@@ -33,7 +33,7 @@ create_shader :: proc(renderer: ^Renderer, type: Shader_Type, path: string) -> (
     s.path = path
     
     when RENDER_BACKEND_OPENGL {
-        shader_opengl, ok := opengl_create_shader(renderer, type, bytes)
+        shader_opengl, ok := opengl_create_shader(renderer, type, path, bytes)
         if !ok {
             return {}, false
         }