Working on GL uniforms

default_shader_fragment.glsl

@@ -1,5 +1,5 @@
 #version 330
-in vec2 frag_uv;
+in vec2 frag_texcoord;
 in vec4 frag_color;
 out vec4 final_color;
 
@@ -7,7 +7,6 @@ uniform sampler2D tex;
 
 void main()
 {
-    //vec4 c = texture(tex, frag_uv);
-    //final_color = c * frag_color;
-    final_color = vec4(frag_color.rgb + vec3(frag_uv.x*0.000001, 0, 0), 1);
+    vec4 c = texture(tex, frag_texcoord);
+    final_color = c * frag_color;
 }

default_shader_vertex.glsl

@@ -1,9 +1,9 @@
 #version 330
-layout(location = 0) in vec3 POS;
-layout(location = 1) in vec2 UV;
-layout(location = 2) in vec4 COL;
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec2 texcoord;
+layout(location = 2) in vec4 color;
 
-out vec2 frag_uv;
+out vec2 frag_texcoord;
 out vec4 frag_color;
 
 layout(std140) uniform constants {
@@ -12,7 +12,7 @@ layout(std140) uniform constants {
 
 void main()
 {
-    frag_uv = UV;
-    frag_color = COL;
-    gl_Position = mvp * vec4(POS, 1.0);
+    frag_texcoord = texcoord;
+    frag_color = color;
+    gl_Position = mvp * vec4(position, 1.0);
 }

examples/snake/shader.hlsl

@@ -2,15 +2,15 @@ cbuffer constants : register(b0) {
 	float4x4 mvp;
 }
 struct vs_in {
-	float3 position : POS;
-	float2 uv       : UV;
-	float4 color    : COL;
-	float2 wobble   : WAA;
+	float3 position : position;
+	float2 uv       : texcoord;
+	float4 color    : color;
+	float2 wobble   : wobble;
 };
 struct vs_out {
 	float4 position : SV_POSITION;
-	float2 uv       : UV;
-	float4 color    : COL;
+	float2 uv       : texcoord;
+	float4 color    : color;
 };
 Texture2D    tex : register(t0);
 SamplerState smp : register(s0);

karl2d.odin

@@ -277,7 +277,25 @@ set_window_flags :: proc(flags: Window_Flags) {
 // VERTEX_BUFFER_MAX / shader.vertex_size
 draw_current_batch :: proc() {
 	update_font(s.batch_font)
-	rb.draw(s.batch_shader, s.batch_texture, s.proj_matrix * s.view_matrix, s.batch_scissor, s.vertex_buffer_cpu[:s.vertex_buffer_cpu_used])
+
+	shader := s.batch_shader
+
+	mvp := s.proj_matrix * s.view_matrix
+	for mloc, builtin in shader.constant_builtin_locations {
+		loc, loc_ok := mloc.?
+
+		if !loc_ok {
+			continue
+		}
+
+		switch builtin {
+		case .MVP:
+			dst := (^matrix[4,4]f32)(&shader.constant_buffers[loc.buffer_idx].cpu_data[loc.offset])
+			dst^ = mvp
+		}
+	}
+
+	rb.draw(shader, s.batch_texture, s.batch_scissor, s.vertex_buffer_cpu[:s.vertex_buffer_cpu_used])
 	s.vertex_buffer_cpu_used = 0
 }
 
@@ -1508,11 +1526,11 @@ win: Window_Interface
 rb: Render_Backend_Interface
 
 get_shader_input_default_type :: proc(name: string, type: Shader_Input_Type) -> Shader_Default_Inputs {
-	if name == "POS" && type == .Vec3 {
+	if name == "position" && type == .Vec3 {
 		return .Position
-	} else if name == "UV" && type == .Vec2 {
+	} else if name == "texcoord" && type == .Vec2 {
 		return .UV
-	} else if name == "COL" && type == .Vec4 {
+	} else if name == "color" && type == .Vec4 {
 		return .Color
 	}
 

render_backend_d3d11.odin

@@ -191,7 +191,7 @@ d3d11_present :: proc() {
 	ch(s.swapchain->Present(1, {}))
 }
 
-d3d11_draw :: proc(shd: Shader, texture: Texture_Handle, view_proj: Mat4, scissor: Maybe(Rect), vertex_buffer: []u8) {
+d3d11_draw :: proc(shd: Shader, texture: Texture_Handle, scissor: Maybe(Rect), vertex_buffer: []u8) {
 	if len(vertex_buffer) == 0 {
 		return
 	}
@@ -228,20 +228,6 @@ d3d11_draw :: proc(shd: Shader, texture: Texture_Handle, view_proj: Mat4, scisso
 	vertex_buffer_stride := u32(shd.vertex_size)
 	dc->IASetVertexBuffers(0, 1, &s.vertex_buffer_gpu, &vertex_buffer_stride, &vertex_buffer_offset)
 
-	for mloc, builtin in shd.constant_builtin_locations {
-		loc, loc_ok := mloc.?
-
-		if !loc_ok {
-			continue
-		}
-
-		switch builtin {
-		case .MVP:
-			dst := (^matrix[4,4]f32)(&shd.constant_buffers[loc.buffer_idx].cpu_data[loc.offset])
-			dst^ = view_proj
-		}
-	}
-
 	dc->VSSetShader(d3d_shd.vertex_shader, nil, 0)
 
 	assert(len(shd.constant_buffers) == len(d3d_shd.constant_buffers))

render_backend_gl.odin

@@ -109,7 +109,7 @@ gl_present :: proc() {
 	_gl_present(s.window_handle)
 }
 
-gl_draw :: proc(shd: Shader, texture: Texture_Handle, view_proj: Mat4, scissor: Maybe(Rect), vertex_buffer: []u8) {
+gl_draw :: proc(shd: Shader, texture: Texture_Handle, scissor: Maybe(Rect), vertex_buffer: []u8) {
 	shader := hm.get(&s.shaders, shd.handle)
 
 	if shader == nil {
@@ -121,15 +121,14 @@ gl_draw :: proc(shd: Shader, texture: Texture_Handle, view_proj: Mat4, scissor:
 	gl.EnableVertexAttribArray(2)
 
 	gl.UseProgram(shader.program)
-
-	// temp test
-	{
-		b := shader.constant_buffers[0]
-		gl.BindBuffer(gl.UNIFORM_BUFFER, b.buffer)
-		mvp := view_proj
-		gl.BufferData(gl.UNIFORM_BUFFER, b.size, &mvp, gl.DYNAMIC_DRAW)
-		gl.BindBufferBase(gl.UNIFORM_BUFFER, 0, b.buffer)
-		//gl.UniformBlockBinding(shader.program, b.block_index, b.buffer)
+	assert(len(shd.constant_buffers) == len(shader.constant_buffers))
+
+	for cb_idx in 0..<len(shader.constant_buffers) {
+		cpu_data := shd.constant_buffers[cb_idx].cpu_data
+		gpu_data := shader.constant_buffers[cb_idx].buffer
+		gl.BindBuffer(gl.UNIFORM_BUFFER, gpu_data)
+		gl.BufferData(gl.UNIFORM_BUFFER, len(cpu_data), raw_data(cpu_data), gl.DYNAMIC_DRAW)
+		gl.BindBufferBase(gl.UNIFORM_BUFFER, u32(cb_idx), gpu_data)
 	}
 	
 	gl.BindBuffer(gl.ARRAY_BUFFER, s.vertex_buffer_gpu)
@@ -336,13 +335,32 @@ gl_load_shader :: proc(vs_source: string, fs_source: string, desc_allocator := f
 		offset += format_size
 	}
 
+	/*{
+		num_uniforms: i32
+		uniform_name_buf: [256]u8
+		gl.GetProgramiv(program, gl.ACTIVE_UNIFORMS, &num_uniforms)
+		
+		for u_idx in 0..<num_uniforms {
+			name_len: i32
+			size: i32
+			type: u32
+			gl.GetActiveUniform(program, u32(u_idx), len(uniform_name_buf), &name_len, &size, &type, raw_data(&uniform_name_buf))
+
+			if type == gl.SAMPLER_2D {
+
+			}
+		}
+	}*/
 
 	{
 		num_uniform_blocks: i32
 		gl.GetProgramiv(program, gl.ACTIVE_UNIFORM_BLOCKS, &num_uniform_blocks)
 		desc.constant_buffers = make([]Shader_Constant_Buffer_Desc, num_uniform_blocks, desc_allocator)
 		shader.constant_buffers = make([]GL_Shader_Constant_Buffer, num_uniform_blocks, s.allocator)
+
+
 		uniform_block_name_buf: [256]u8
+		uniform_name_buf: [256]u8
 
 		for cb_idx in 0..<num_uniform_blocks {
 			name_len: i32
@@ -369,7 +387,6 @@ gl_load_shader :: proc(vs_source: string, fs_source: string, desc_allocator := f
 			gl.GenBuffers(1, &buf)
 			gl.BindBuffer(gl.UNIFORM_BUFFER, buf)
 			gl.BufferData(gl.UNIFORM_BUFFER, int(size), nil, gl.DYNAMIC_DRAW)
-			//gl.UniformBlockBinding(program, idx, buf)
 			gl.BindBufferBase(gl.UNIFORM_BUFFER, idx, buf)
 
 			shader.constant_buffers[cb_idx] = {
@@ -382,17 +399,34 @@ gl_load_shader :: proc(vs_source: string, fs_source: string, desc_allocator := f
 				name = strings.clone_from_cstring(name_cstr, desc_allocator),
 				size = int(size),
 			}
-		}
 
-	
-		/*
-		GetUniformIndices         :: proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices)                               }
-	GetActiveUniformsiv       :: proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params)                            }
-	GetActiveUniformName      :: proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName)                            }
-	GetUniformBlockIndex      :: proc "c" (program: u32, uniformBlockName: cstring) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          return ret }
-	GetActiveUniformBlockiv   :: proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params)                                   }
-
-*/		
+			num_uniforms: i32
+			gl.GetActiveUniformBlockiv(program, idx, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS, &num_uniforms)
+
+			uniform_indices := make([]i32, num_uniforms, frame_allocator)
+			gl.GetActiveUniformBlockiv(program, idx, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, raw_data(uniform_indices))
+
+			variables := make([]Shader_Constant_Buffer_Variable_Desc, num_uniforms, desc_allocator)
+			desc.constant_buffers[cb_idx].variables = variables
+
+			for var_idx in 0..<num_uniforms {
+				uniform_idx := u32(uniform_indices[var_idx])
+
+				offset: i32
+				gl.GetActiveUniformsiv(program, 1, &uniform_idx, gl.UNIFORM_OFFSET, &offset)
+
+				variable_name_len: i32
+				gl.GetActiveUniformName(program, uniform_idx, len(uniform_name_buf), &variable_name_len, raw_data(&uniform_name_buf))
+
+				variables[var_idx] = {
+					name = strings.clone(string(uniform_name_buf[:variable_name_len]), desc_allocator),
+					loc = {
+						buffer_idx = u32(cb_idx),
+						offset = u32(offset),
+					},
+				}
+			}
+		}
 	}
 
 	h := hm.add(&s.shaders, shader)

render_backend_interface.odin

@@ -22,7 +22,7 @@ Render_Backend_Interface :: struct {
 	shutdown: proc(),
 	clear: proc(color: Color),
 	present: proc(),
-	draw: proc(shader: Shader, texture: Texture_Handle, view_proj: Mat4, scissor: Maybe(Rect), vertex_buffer: []u8),
+	draw: proc(shader: Shader, texture: Texture_Handle, scissor: Maybe(Rect), vertex_buffer: []u8),
 	set_internal_state: proc(state: rawptr),
 
 	create_texture: proc(width: int, height: int, format: Pixel_Format) -> Texture_Handle,

shader.hlsl

@@ -2,25 +2,25 @@ cbuffer constants : register(b0) {
 	float4x4 mvp;
 }
 struct vs_in {
-	float3 position : POS;
-	float2 uv       : UV;
-	float4 color    : COL;
+	float3 position : position;
+	float2 texcoord : texcoord;
+	float4 color    : color;
 };
 struct vs_out {
 	float4 position : SV_POSITION;
-	float2 uv       : UV;
-	float4 color    : COL;
+	float2 texcoord : texcoord;
+	float4 color    : color;
 };
 Texture2D    tex : register(t0);
 SamplerState smp : register(s0);
 vs_out vs_main(vs_in input) {
 	vs_out output;
 	output.position = mul(mvp, float4(input.position, 1.0f));
-	output.uv = input.uv;
+	output.texcoord = input.texcoord;
 	output.color = input.color;
 	return output;
 }
 float4 ps_main(vs_out input) : SV_TARGET {
-	float4 c = tex.Sample(smp, input.uv);
+	float4 c = tex.Sample(smp, input.texcoord);
 	return c * input.color;
 }