Home Explore Help
Sign In
c
/
odin-lang.Odin
mirror of https://github.com/odin-lang/Odin
2
0
Fork 0
Files Issues 0 Wiki
Browse Source

Improve signatures for `[^][N*M]T` like matrix parameters

gingerBill 4 years ago
parent
ad56cf0038
commit
5c41f64829
2 changed files with 171 additions and 171 deletions
Split View Show Diff Stats
  1. 57 57
      vendor/OpenGL/impl.odin
  2. 114 114
      vendor/OpenGL/wrappers.odin

+ 57 - 57
vendor/OpenGL/impl.odin
View File 

@@ -358,9 +358,9 @@ impl_Uniform1iv:               proc "c" (location: i32, count: i32, value: [^]i3
 
 impl_Uniform2iv:               proc "c" (location: i32, count: i32, value: [^]i32);
 
 impl_Uniform3iv:               proc "c" (location: i32, count: i32, value: [^]i32);
 
 impl_Uniform4iv:               proc "c" (location: i32, count: i32, value: [^]i32);
 
-impl_UniformMatrix2fv:         proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
-impl_UniformMatrix3fv:         proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
-impl_UniformMatrix4fv:         proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_UniformMatrix2fv:         proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*2]f32);
 
+impl_UniformMatrix3fv:         proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*3]f32);
 
+impl_UniformMatrix4fv:         proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*4]f32);
 
 impl_ValidateProgram:          proc "c" (program: u32);
 
 impl_VertexAttrib1d:           proc "c" (index: u32, x: f64);
 
 impl_VertexAttrib1dv:          proc "c" (index: u32, v: ^[1]f64);
 
@@ -498,12 +498,12 @@ load_2_0 :: proc(set_proc_address: Set_Proc_Address_Type) {
 
 
 
 // VERSION_2_1
 
-impl_UniformMatrix2x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][3]f32);
 
-impl_UniformMatrix3x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][2]f32);
 
-impl_UniformMatrix2x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][4]f32);
 
-impl_UniformMatrix4x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][2]f32);
 
-impl_UniformMatrix3x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][4]f32);
 
-impl_UniformMatrix4x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][3]f32);
 
+impl_UniformMatrix2x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*3]f32);
 
+impl_UniformMatrix3x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*2]f32);
 
+impl_UniformMatrix2x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*4]f32);
 
+impl_UniformMatrix4x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*2]f32);
 
+impl_UniformMatrix3x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*4]f32);
 
+impl_UniformMatrix4x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*3]f32);
 
 
 load_2_1 :: proc(set_proc_address: Set_Proc_Address_Type) {
 
 	set_proc_address(&impl_UniformMatrix2x3fv, "glUniformMatrix2x3fv");
 
@@ -912,26 +912,26 @@ impl_Uniform1d:                      proc "c" (location: i32, x: f64);
 
 impl_Uniform2d:                      proc "c" (location: i32, x: f64, y: f64);
 
 impl_Uniform3d:                      proc "c" (location: i32, x: f64, y: f64, z: f64);
 
 impl_Uniform4d:                      proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64);
 
-impl_Uniform1dv:                     proc "c" (location: i32, count: i32, value: [^]f64);
 
-impl_Uniform2dv:                     proc "c" (location: i32, count: i32, value: [^]f64);
 
-impl_Uniform3dv:                     proc "c" (location: i32, count: i32, value: [^]f64);
 
-impl_Uniform4dv:                     proc "c" (location: i32, count: i32, value: [^]f64);
 
-impl_UniformMatrix2dv:               proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix3dv:               proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix4dv:               proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix2x3dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix2x4dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix3x2dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix3x4dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix4x2dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
-impl_UniformMatrix4x3dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_Uniform1dv:                     proc "c" (location: i32, count: i32, value: [^][1]f64);
 
+impl_Uniform2dv:                     proc "c" (location: i32, count: i32, value: [^][2]f64);
 
+impl_Uniform3dv:                     proc "c" (location: i32, count: i32, value: [^][3]f64);
 
+impl_Uniform4dv:                     proc "c" (location: i32, count: i32, value: [^][4]f64);
 
+impl_UniformMatrix2dv:               proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*2]f64);
 
+impl_UniformMatrix3dv:               proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*3]f64);
 
+impl_UniformMatrix4dv:               proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*4]f64);
 
+impl_UniformMatrix2x3dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*3]f64);
 
+impl_UniformMatrix2x4dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*4]f64);
 
+impl_UniformMatrix3x2dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*2]f64);
 
+impl_UniformMatrix3x4dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*4]f64);
 
+impl_UniformMatrix4x2dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*2]f64);
 
+impl_UniformMatrix4x3dv:             proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*3]f64);
 
 impl_GetUniformdv:                   proc "c" (program: u32, location: i32, params: [^]f64);
 
 impl_GetSubroutineUniformLocation:   proc "c" (program: u32, shadertype: u32, name: cstring) -> i32;
 
 impl_GetSubroutineIndex:             proc "c" (program: u32, shadertype: u32, name: cstring) -> u32;
 
 impl_GetActiveSubroutineUniformiv:   proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32);
 
 impl_GetActiveSubroutineUniformName: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8);
 
 impl_GetActiveSubroutineName:        proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8);
 
-impl_UniformSubroutinesuiv:          proc "c" (shadertype: u32, count: i32, indices: ^u32);
 
+impl_UniformSubroutinesuiv:          proc "c" (shadertype: u32, count: i32, indices: [^]u32);
 
 impl_GetUniformSubroutineuiv:        proc "c" (shadertype: u32, location: i32, params: [^]u32);
 
 impl_GetProgramStageiv:              proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32);
 
 impl_PatchParameteri:                proc "c" (pname: u32, value: i32);
 
@@ -1016,55 +1016,55 @@ impl_GenProgramPipelines:       proc "c" (n: i32, pipelines: [^]u32);
 
 impl_IsProgramPipeline:         proc "c" (pipeline: u32) -> bool;
 
 impl_GetProgramPipelineiv:      proc "c" (pipeline: u32, pname: u32, params: [^]i32);
 
 impl_ProgramUniform1i:          proc "c" (program: u32, location: i32, v0: i32);
 
-impl_ProgramUniform1iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[1]i32);
 
+impl_ProgramUniform1iv:         proc "c" (program: u32, location: i32, count: i32, value: [^][1]i32);
 
 impl_ProgramUniform1f:          proc "c" (program: u32, location: i32, v0: f32);
 
-impl_ProgramUniform1fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[1]f32);
 
+impl_ProgramUniform1fv:         proc "c" (program: u32, location: i32, count: i32, value: [^][1]f32);
 
 impl_ProgramUniform1d:          proc "c" (program: u32, location: i32, v0: f64);
 
-impl_ProgramUniform1dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[1]f64);
 
+impl_ProgramUniform1dv:         proc "c" (program: u32, location: i32, count: i32, value: [^][1]f64);
 
 impl_ProgramUniform1ui:         proc "c" (program: u32, location: i32, v0: u32);
 
-impl_ProgramUniform1uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[1]u32);
 
+impl_ProgramUniform1uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^][1]u32);
 
 impl_ProgramUniform2i:          proc "c" (program: u32, location: i32, v0: i32, v1: i32);
 
-impl_ProgramUniform2iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[2]i32);
 
+impl_ProgramUniform2iv:         proc "c" (program: u32, location: i32, count: i32, value: [^][2]i32);
 
 impl_ProgramUniform2f:          proc "c" (program: u32, location: i32, v0: f32, v1: f32);
 
-impl_ProgramUniform2fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[2]f32);
 
+impl_ProgramUniform2fv:         proc "c" (program: u32, location: i32, count: i32, value: [^][2]f32);
 
 impl_ProgramUniform2d:          proc "c" (program: u32, location: i32, v0: f64, v1: f64);
 
-impl_ProgramUniform2dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[2]f64);
 
+impl_ProgramUniform2dv:         proc "c" (program: u32, location: i32, count: i32, value: [^][2]f64);
 
 impl_ProgramUniform2ui:         proc "c" (program: u32, location: i32, v0: u32, v1: u32);
 
-impl_ProgramUniform2uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[2]u32);
 
+impl_ProgramUniform2uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^][2]u32);
 
 impl_ProgramUniform3i:          proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32);
 
-impl_ProgramUniform3iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[3]i32);
 
+impl_ProgramUniform3iv:         proc "c" (program: u32, location: i32, count: i32, value: [^][3]i32);
 
 impl_ProgramUniform3f:          proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32);
 
-impl_ProgramUniform3fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[3]f32);
 
+impl_ProgramUniform3fv:         proc "c" (program: u32, location: i32, count: i32, value: [^][3]f32);
 
 impl_ProgramUniform3d:          proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64);
 
-impl_ProgramUniform3dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[3]f64);
 
+impl_ProgramUniform3dv:         proc "c" (program: u32, location: i32, count: i32, value: [^][3]f64);
 
 impl_ProgramUniform3ui:         proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32);
 
-impl_ProgramUniform3uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[3]u32);
 
+impl_ProgramUniform3uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^][3]u32);
 
 impl_ProgramUniform4i:          proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32);
 
-impl_ProgramUniform4iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[4]i32);
 
+impl_ProgramUniform4iv:         proc "c" (program: u32, location: i32, count: i32, value: [^][4]i32);
 
 impl_ProgramUniform4f:          proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32);
 
-impl_ProgramUniform4fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[4]f32);
 
+impl_ProgramUniform4fv:         proc "c" (program: u32, location: i32, count: i32, value: [^][4]f32);
 
 impl_ProgramUniform4d:          proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64);
 
-impl_ProgramUniform4dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[4]f64);
 
+impl_ProgramUniform4dv:         proc "c" (program: u32, location: i32, count: i32, value: [^][4]f64);
 
 impl_ProgramUniform4ui:         proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32);
 
-impl_ProgramUniform4uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[4]u32);
 
-impl_ProgramUniformMatrix2fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f32);
 
-impl_ProgramUniformMatrix3fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f32);
 
-impl_ProgramUniformMatrix4fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f32);
 
-impl_ProgramUniformMatrix2dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f64);
 
-impl_ProgramUniformMatrix3dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f64);
 
-impl_ProgramUniformMatrix4dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f64);
 
-impl_ProgramUniformMatrix2x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f32);
 
-impl_ProgramUniformMatrix3x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f32);
 
-impl_ProgramUniformMatrix2x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f32);
 
-impl_ProgramUniformMatrix4x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f32);
 
-impl_ProgramUniformMatrix3x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f32);
 
-impl_ProgramUniformMatrix4x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f32);
 
-impl_ProgramUniformMatrix2x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f64);
 
-impl_ProgramUniformMatrix3x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f64);
 
-impl_ProgramUniformMatrix2x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f64);
 
-impl_ProgramUniformMatrix4x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f64);
 
-impl_ProgramUniformMatrix3x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f64);
 
-impl_ProgramUniformMatrix4x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f64);
 
+impl_ProgramUniform4uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^][4]u32);
 
+impl_ProgramUniformMatrix2fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*2]f32);
 
+impl_ProgramUniformMatrix3fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*3]f32);
 
+impl_ProgramUniformMatrix4fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*4]f32);
 
+impl_ProgramUniformMatrix2dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*2]f64);
 
+impl_ProgramUniformMatrix3dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*3]f64);
 
+impl_ProgramUniformMatrix4dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*4]f64);
 
+impl_ProgramUniformMatrix2x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*3]f32);
 
+impl_ProgramUniformMatrix3x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*2]f32);
 
+impl_ProgramUniformMatrix2x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*4]f32);
 
+impl_ProgramUniformMatrix4x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*2]f32);
 
+impl_ProgramUniformMatrix3x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*4]f32);
 
+impl_ProgramUniformMatrix4x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*3]f32);
 
+impl_ProgramUniformMatrix2x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*3]f64);
 
+impl_ProgramUniformMatrix3x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*2]f64);
 
+impl_ProgramUniformMatrix2x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*4]f64);
 
+impl_ProgramUniformMatrix4x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*2]f64);
 
+impl_ProgramUniformMatrix3x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*4]f64);
 
+impl_ProgramUniformMatrix4x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*3]f64);
 
 impl_ValidateProgramPipeline:   proc "c" (pipeline: u32);
 
 impl_GetProgramPipelineInfoLog: proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8);
 
 impl_VertexAttribL1d:           proc "c" (index: u32, x: f64);

+ 114 - 114
vendor/OpenGL/wrappers.odin
View File 

@@ -168,9 +168,9 @@ when !ODIN_DEBUG {
 
 	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                   {        impl_Uniform2iv(location, count, value);                                               }
 
 	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                   {        impl_Uniform3iv(location, count, value);                                               }
 
 	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                   {        impl_Uniform4iv(location, count, value);                                               }
 
-	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                                  {        impl_UniformMatrix2fv(location, count, transpose, value);                              }
 
-	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                                  {        impl_UniformMatrix3fv(location, count, transpose, value);                              }
 
-	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                                  {        impl_UniformMatrix4fv(location, count, transpose, value);                              }
 
+	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*2]f32)                               {        impl_UniformMatrix2fv(location, count, transpose, value);                              }
 
+	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*3]f32)                               {        impl_UniformMatrix3fv(location, count, transpose, value);                              }
 
+	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*4]f32)                               {        impl_UniformMatrix4fv(location, count, transpose, value);                              }
 
 	ValidateProgram          :: #force_inline proc "c" (program: u32)                                                                               {        impl_ValidateProgram(program);                                                         }
 
 	VertexAttrib1d           :: #force_inline proc "c" (index: u32, x: f64)                                                                         {        impl_VertexAttrib1d(index, x);                                                         }
 
 	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^[1]f64)                                                                        {        impl_VertexAttrib1dv(index, v);                                                        }
 
@@ -211,12 +211,12 @@ when !ODIN_DEBUG {
 
 	VertexAttribPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: rawptr)           {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer);             }
 
 
 	// VERSION_2_1
 
-	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][3]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value); }
 
-	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][2]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value); }
 
-	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][4]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value); }
 
-	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][2]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value); }
 
-	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][4]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value); }
 
-	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][3]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value); }
 
+	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*3]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value); }
 
+	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*2]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value); }
 
+	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*4]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value); }
 
+	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*2]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value); }
 
+	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*4]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value); }
 
+	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*3]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value); }
 
 
 
 	// VERSION_3_0
 
@@ -412,26 +412,26 @@ when !ODIN_DEBUG {
 
 	Uniform2d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64)                                                      {        impl_Uniform2d(location, x, y);                                                                      }
 
 	Uniform3d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64)                                              {        impl_Uniform3d(location, x, y, z);                                                                   }
 
 	Uniform4d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64)                                      {        impl_Uniform4d(location, x, y, z, w);                                                                }
 
-	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                           {        impl_Uniform1dv(location, count, value);                                                             }
 
-	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                           {        impl_Uniform2dv(location, count, value);                                                             }
 
-	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                           {        impl_Uniform3dv(location, count, value);                                                             }
 
-	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                           {        impl_Uniform4dv(location, count, value);                                                             }
 
-	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix2dv(location, count, transpose, value);                                            }
 
-	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix3dv(location, count, transpose, value);                                            }
 
-	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix4dv(location, count, transpose, value);                                            }
 
-	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix2x3dv(location, count, transpose, value);                                          }
 
-	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix2x4dv(location, count, transpose, value);                                          }
 
-	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix3x2dv(location, count, transpose, value);                                          }
 
-	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix3x4dv(location, count, transpose, value);                                          }
 
-	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix4x2dv(location, count, transpose, value);                                          }
 
-	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                          {        impl_UniformMatrix4x3dv(location, count, transpose, value);                                          }
 
+	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][1]f64)                                          {        impl_Uniform1dv(location, count, value);                                                             }
 
+	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]f64)                                          {        impl_Uniform2dv(location, count, value);                                                             }
 
+	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]f64)                                          {        impl_Uniform3dv(location, count, value);                                                             }
 
+	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]f64)                                          {        impl_Uniform4dv(location, count, value);                                                             }
 
+	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*2]f64)                       {        impl_UniformMatrix2dv(location, count, transpose, value);                                            }
 
+	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*3]f64)                       {        impl_UniformMatrix3dv(location, count, transpose, value);                                            }
 
+	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*4]f64)                       {        impl_UniformMatrix4dv(location, count, transpose, value);                                            }
 
+	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*3]f64)                       {        impl_UniformMatrix2x3dv(location, count, transpose, value);                                          }
 
+	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*4]f64)                       {        impl_UniformMatrix2x4dv(location, count, transpose, value);                                          }
 
+	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*2]f64)                       {        impl_UniformMatrix3x2dv(location, count, transpose, value);                                          }
 
+	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*4]f64)                       {        impl_UniformMatrix3x4dv(location, count, transpose, value);                                          }
 
+	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*2]f64)                       {        impl_UniformMatrix4x2dv(location, count, transpose, value);                                          }
 
+	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*3]f64)                       {        impl_UniformMatrix4x3dv(location, count, transpose, value);                                          }
 
 	GetUniformdv                   :: #force_inline proc "c" (program: u32, location: i32, params: [^]f64)                                        {        impl_GetUniformdv(program, location, params);                                                        }
 
 	GetSubroutineUniformLocation   :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           return ret; }
 
 	GetSubroutineIndex             :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     return ret; }
 
 	GetActiveSubroutineUniformiv   :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);                       }
 
 	GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);             }
 
 	GetActiveSubroutineName        :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);                    }
 
-	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype: u32, count: i32, indices: ^u32)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                             }
 
+	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype: u32, count: i32, indices: [^]u32)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                             }
 
 	GetUniformSubroutineuiv        :: #force_inline proc "c" (shadertype: u32, location: i32, params: [^]u32)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params);                                         }
 
 	GetProgramStageiv              :: #force_inline proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32)                          {        impl_GetProgramStageiv(program, shadertype, pname, values);                                         }
 
 	PatchParameteri                :: #force_inline proc "c" (pname: u32, value: i32)                                                             {        impl_PatchParameteri(pname, value);                                                                  }
 
@@ -466,55 +466,55 @@ when !ODIN_DEBUG {
 
 	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             return ret; }
 
 	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: [^]i32)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                                       }
 
 	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32)                                         {        impl_ProgramUniform1i(program, location, v0);                                             }
 
-	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]i32)                      {        impl_ProgramUniform1iv(program, location, count, value);                                  }
 
+	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]i32)                      {        impl_ProgramUniform1iv(program, location, count, value);                                  }
 
 	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32)                                         {        impl_ProgramUniform1f(program, location, v0);                                             }
 
-	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f32)                      {        impl_ProgramUniform1fv(program, location, count, value);                                  }
 
+	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]f32)                      {        impl_ProgramUniform1fv(program, location, count, value);                                  }
 
 	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64)                                         {        impl_ProgramUniform1d(program, location, v0);                                             }
 
-	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f64)                      {        impl_ProgramUniform1dv(program, location, count, value);                                  }
 
+	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]f64)                      {        impl_ProgramUniform1dv(program, location, count, value);                                  }
 
 	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32)                                         {        impl_ProgramUniform1ui(program, location, v0);                                            }
 
-	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]u32)                      {        impl_ProgramUniform1uiv(program, location, count, value);                                 }
 
+	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]u32)                      {        impl_ProgramUniform1uiv(program, location, count, value);                                 }
 
 	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32)                                {        impl_ProgramUniform2i(program, location, v0, v1);                                         }
 
-	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]i32)                       {        impl_ProgramUniform2iv(program, location, count, value);                                  }
 
+	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]i32)                       {        impl_ProgramUniform2iv(program, location, count, value);                                  }
 
 	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32)                                {        impl_ProgramUniform2f(program, location, v0, v1);                                         }
 
-	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f32)                       {        impl_ProgramUniform2fv(program, location, count, value);                                  }
 
+	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]f32)                       {        impl_ProgramUniform2fv(program, location, count, value);                                  }
 
 	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64)                                {        impl_ProgramUniform2d(program, location, v0, v1);                                         }
 
-	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f64)                       {        impl_ProgramUniform2dv(program, location, count, value);                                  }
 
+	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]f64)                       {        impl_ProgramUniform2dv(program, location, count, value);                                  }
 
 	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                                        }
 
-	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value);                                 }
 
+	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value);                                 }
 
 	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                                     }
 
-	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]i32)                       {        impl_ProgramUniform3iv(program, location, count, value);                                  }
 
+	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]i32)                       {        impl_ProgramUniform3iv(program, location, count, value);                                  }
 
 	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                                     }
 
-	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f32)                       {        impl_ProgramUniform3fv(program, location, count, value);                                  }
 
+	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]f32)                       {        impl_ProgramUniform3fv(program, location, count, value);                                  }
 
 	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                                     }
 
-	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f64)                       {        impl_ProgramUniform3dv(program, location, count, value);                                  }
 
+	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]f64)                       {        impl_ProgramUniform3dv(program, location, count, value);                                  }
 
 	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                                    }
 
-	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value);                                 }
 
+	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value);                                 }
 
 	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                                 }
 
-	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]i32)                       {        impl_ProgramUniform4iv(program, location, count, value);                                  }
 
+	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]i32)                       {        impl_ProgramUniform4iv(program, location, count, value);                                  }
 
 	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                                 }
 
-	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f32)                       {        impl_ProgramUniform4fv(program, location, count, value);                                  }
 
+	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]f32)                       {        impl_ProgramUniform4fv(program, location, count, value);                                  }
 
 	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                                 }
 
-	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f64)                       {        impl_ProgramUniform4dv(program, location, count, value);                                  }
 
+	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]f64)                       {        impl_ProgramUniform4dv(program, location, count, value);                                  }
 
 	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                                }
 
-	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value);                                 }
 
-	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);               }
 
-	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f64)  {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);               }
 
+	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value);                                 }
 
+	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*2]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*3]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*4]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*2]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*3]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*4]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*3]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*2]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*4]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*2]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*4]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*3]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*3]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*2]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*4]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*2]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*4]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*3]f64)  {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);               }
 
 	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32)                                                                {        impl_ValidateProgramPipeline(pipeline);                                                   }
 
 	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);                       }
 
 	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64)                                                           {        impl_VertexAttribL1d(index, x);                                                           }
 
@@ -969,9 +969,9 @@ when !ODIN_DEBUG {
 
 	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform2iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
 	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform3iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
 	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform4iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
-	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                                 {        impl_UniformMatrix2fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                                 {        impl_UniformMatrix3fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                                 {        impl_UniformMatrix4fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*2]f32, loc := #caller_location)                              {        impl_UniformMatrix2fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*3]f32, loc := #caller_location)                              {        impl_UniformMatrix3fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*4]f32, loc := #caller_location)                              {        impl_UniformMatrix4fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
 
 	ValidateProgram          :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_ValidateProgram(program);                                             debug_helper(loc, 0, program);                                                        }
 
 	VertexAttrib1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                                        {        impl_VertexAttrib1d(index, x);                                             debug_helper(loc, 0, index, x);                                                       }
 
 	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^[1]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
@@ -1012,12 +1012,12 @@ when !ODIN_DEBUG {
 
 	VertexAttribPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: rawptr, loc := #caller_location)          {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer); debug_helper(loc, 0, index, size, type, normalized, stride, pointer);                }
 
 
 	// VERSION_2_1
 
-	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][3]f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
-	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][2]f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
-	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][4]f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
-	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][2]f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
-	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][4]f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
-	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][3]f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
+	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*3]f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
+	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*2]f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
+	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*4]f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
+	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*2]f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
+	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*4]f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
+	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*3]f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
 
 		// VERSION_3_0
 
 	ColorMaski                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8, loc := #caller_location)                                                                                 {        impl_ColorMaski(index, r, g, b, a);                                                         debug_helper(loc, 0, index, r, g, b, a);                                                                }
 
@@ -1212,26 +1212,26 @@ when !ODIN_DEBUG {
 
 	Uniform2d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, loc := #caller_location)                                                      {        impl_Uniform2d(location, x, y);                                                          debug_helper(loc, 0, location, x, y);                                                 }
 
 	Uniform3d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, loc := #caller_location)                                              {        impl_Uniform3d(location, x, y, z);                                                       debug_helper(loc, 0, location, x, y, z);                                              }
 
 	Uniform4d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                      {        impl_Uniform4d(location, x, y, z, w);                                                    debug_helper(loc, 0, location, x, y, z, w);                                           }
 
-	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform1dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform2dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform3dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform4dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
-	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
-	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][1]f64, loc := #caller_location)                                           {        impl_Uniform1dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
+	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]f64, loc := #caller_location)                                           {        impl_Uniform2dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
+	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]f64, loc := #caller_location)                                           {        impl_Uniform3dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
+	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]f64, loc := #caller_location)                                           {        impl_Uniform4dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
 
+	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*2]f64, loc := #caller_location)                          {        impl_UniformMatrix2dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*3]f64, loc := #caller_location)                          {        impl_UniformMatrix3dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*4]f64, loc := #caller_location)                          {        impl_UniformMatrix4dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*3]f64, loc := #caller_location)                          {        impl_UniformMatrix2x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][2*4]f64, loc := #caller_location)                          {        impl_UniformMatrix2x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*2]f64, loc := #caller_location)                          {        impl_UniformMatrix3x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][3*4]f64, loc := #caller_location)                          {        impl_UniformMatrix3x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*2]f64, loc := #caller_location)                          {        impl_UniformMatrix4x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
+	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^][4*3]f64, loc := #caller_location)                          {        impl_UniformMatrix4x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
 
 	GetUniformdv                   :: #force_inline proc "c" (program: u32, location: i32, params: [^]f64, loc := #caller_location)                                        {        impl_GetUniformdv(program, location, params);                                            debug_helper(loc, 0, program, location, params);                                      }
 
 	GetSubroutineUniformLocation   :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           debug_helper(loc, 1, ret, program, shadertype, name);                    return ret; }
 
 	GetSubroutineIndex             :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     debug_helper(loc, 1, ret, program, shadertype, name);                    return ret; }
 
 	GetActiveSubroutineUniformiv   :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32, loc := #caller_location)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);           debug_helper(loc, 0, program, shadertype, index, pname, values);                     }
 
 	GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype, index, bufsize, length, name);             }
 
 	GetActiveSubroutineName        :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);        debug_helper(loc, 0, program, shadertype, index, bufsize, length, name);             }
 
-	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype: u32, count: i32, indices: ^u32, loc := #caller_location)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                 debug_helper(loc, 0, shadertype, count, indices);                                    }
 
+	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype: u32, count: i32, indices: [^]u32, loc := #caller_location)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                 debug_helper(loc, 0, shadertype, count, indices);                                    }
 
 	GetUniformSubroutineuiv        :: #force_inline proc "c" (shadertype: u32, location: i32, params: [^]u32, loc := #caller_location)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params);                             debug_helper(loc, 0, shadertype, location, params);                                  }
 
 	GetProgramStageiv              :: #force_inline proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32, loc := #caller_location)                          {        impl_GetProgramStageiv(program, shadertype, pname, values);                             debug_helper(loc, 0, program, shadertype, pname, values);                            }
 
 	PatchParameteri                :: #force_inline proc "c" (pname: u32, value: i32, loc := #caller_location)                                                             {        impl_PatchParameteri(pname, value);                                                      debug_helper(loc, 0, pname, value);                                                   }
 
@@ -1266,55 +1266,55 @@ when !ODIN_DEBUG {
 
 	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32, loc := #caller_location) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             debug_helper(loc, 1, ret, pipeline);                                 return ret;; }
 
 	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: [^]i32, loc := #caller_location)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                           debug_helper(loc, 0, pipeline, pname, params);                                    }
 
 	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, loc := #caller_location)                                         {        impl_ProgramUniform1i(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
 
-	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, loc := #caller_location)                                         {        impl_ProgramUniform1f(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
 
-	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, loc := #caller_location)                                         {        impl_ProgramUniform1d(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
 
-	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location)                                         {        impl_ProgramUniform1ui(program, location, v0);                                debug_helper(loc, 0, program, location, v0);                                      }
 
-	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][1]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location)                                {        impl_ProgramUniform2i(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
 
-	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, loc := #caller_location)                                {        impl_ProgramUniform2f(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
 
-	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, loc := #caller_location)                                {        impl_ProgramUniform2d(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
 
-	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, loc := #caller_location)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                            debug_helper(loc, 0, program, location, v0, v1);                                  }
 
-	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][2]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
 
-	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
 
-	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, loc := #caller_location)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
 
-	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                        debug_helper(loc, 0, program, location, v0, v1, v2);                              }
 
-	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][3]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
 
-	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
 
-	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64, loc := #caller_location)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
 
-	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 
 	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                    debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
 
-	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]u32, loc := #caller_location)                       {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
-	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
-	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^][4]u32, loc := #caller_location)                       {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 
+	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][2*4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][3*4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^][4*3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 
 	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_ValidateProgramPipeline(pipeline);                                       debug_helper(loc, 0, pipeline);                                                   }
 
 	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);           debug_helper(loc, 0, pipeline, bufSize, length, infoLog);                         }
 
 	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                           {        impl_VertexAttribL1d(index, x);                                               debug_helper(loc, 0, index, x);                                                   }