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

Change to `[^][N]` to just `[^]`

gingerBill 4 years ago
parent
27fd702692
commit
d399d2256b
2 changed files with 193 additions and 193 deletions
Split View Show Diff Stats
  1. 65 65
      vendor/OpenGL/impl.odin
  2. 128 128
      vendor/OpenGL/wrappers.odin

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

@@ -6,7 +6,7 @@ loaded_up_to_minor := 0;
 
 
 Set_Proc_Address_Type :: #type proc(p: rawptr, name: cstring);
 
 
-load_up_to :: proc(major, minor : int, set_proc_address: Set_Proc_Address_Type) {
 
+load_up_to :: proc(major, minor: int, set_proc_address: Set_Proc_Address_Type) {
 
 	loaded_up_to = {0, 0};
 
 	loaded_up_to[0] = major;
 
 	loaded_up_to[1] = minor;
 
@@ -351,23 +351,23 @@ impl_Uniform2i:                proc "c" (location: i32, v0: i32, v1: i32);
 
 impl_Uniform3i:                proc "c" (location: i32, v0: i32, v1: i32, v2: i32);
 
 impl_Uniform4i:                proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32);
 
 impl_Uniform1fv:               proc "c" (location: i32, count: i32, value: [^]f32);
 
-impl_Uniform2fv:               proc "c" (location: i32, count: i32, value: [^][2]f32);
 
-impl_Uniform3fv:               proc "c" (location: i32, count: i32, value: [^][3]f32);
 
-impl_Uniform4fv:               proc "c" (location: i32, count: i32, value: [^][4]f32);
 
+impl_Uniform2fv:               proc "c" (location: i32, count: i32, value: [^]f32);
 
+impl_Uniform3fv:               proc "c" (location: i32, count: i32, value: [^]f32);
 
+impl_Uniform4fv:               proc "c" (location: i32, count: i32, value: [^]f32);
 
 impl_Uniform1iv:               proc "c" (location: i32, count: i32, value: [^]i32);
 
-impl_Uniform2iv:               proc "c" (location: i32, count: i32, value: [^][2]i32);
 
-impl_Uniform3iv:               proc "c" (location: i32, count: i32, value: [^][3]i32);
 
-impl_Uniform4iv:               proc "c" (location: i32, count: i32, value: [^][4]i32);
 
-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_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_ValidateProgram:          proc "c" (program: u32);
 
 impl_VertexAttrib1d:           proc "c" (index: u32, x: f64);
 
-impl_VertexAttrib1dv:          proc "c" (index: u32, v: ^[1]f64);
 
+impl_VertexAttrib1dv:          proc "c" (index: u32, v: ^f64);
 
 impl_VertexAttrib1f:           proc "c" (index: u32, x: f32);
 
-impl_VertexAttrib1fv:          proc "c" (index: u32, v: ^[1]f32);
 
+impl_VertexAttrib1fv:          proc "c" (index: u32, v: ^f32);
 
 impl_VertexAttrib1s:           proc "c" (index: u32, x: i16);
 
-impl_VertexAttrib1sv:          proc "c" (index: u32, v: ^[1]i16);
 
+impl_VertexAttrib1sv:          proc "c" (index: u32, v: ^i16);
 
 impl_VertexAttrib2d:           proc "c" (index: u32, x: f64, y: f64);
 
 impl_VertexAttrib2dv:          proc "c" (index: u32, v: ^[2]f64);
 
 impl_VertexAttrib2f:           proc "c" (index: u32, x: f32, y: f32);
 
@@ -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: [^]f32);
 
+impl_UniformMatrix3x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_UniformMatrix2x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_UniformMatrix4x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_UniformMatrix3x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_UniformMatrix4x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32);
 
 
 load_2_1 :: proc(set_proc_address: Set_Proc_Address_Type) {
 
 	set_proc_address(&impl_UniformMatrix2x3fv, "glUniformMatrix2x3fv");
 
@@ -562,9 +562,9 @@ impl_Uniform2ui:                          proc "c" (location: i32, v0: u32, v1:
 
 impl_Uniform3ui:                          proc "c" (location: i32, v0: u32, v1: u32, v2: u32);
 
 impl_Uniform4ui:                          proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32);
 
 impl_Uniform1uiv:                         proc "c" (location: i32, count: i32, value: [^]u32);
 
-impl_Uniform2uiv:                         proc "c" (location: i32, count: i32, value: [^][2]u32);
 
-impl_Uniform3uiv:                         proc "c" (location: i32, count: i32, value: [^][3]u32);
 
-impl_Uniform4uiv:                         proc "c" (location: i32, count: i32, value: [^][4]u32);
 
+impl_Uniform2uiv:                         proc "c" (location: i32, count: i32, value: [^]u32);
 
+impl_Uniform3uiv:                         proc "c" (location: i32, count: i32, value: [^]u32);
 
+impl_Uniform4uiv:                         proc "c" (location: i32, count: i32, value: [^]u32);
 
 impl_TexParameterIiv:                     proc "c" (target: u32, pname: u32, params: [^]i32);
 
 impl_TexParameterIuiv:                    proc "c" (target: u32, pname: u32, params: [^]u32);
 
 impl_GetTexParameterIiv:                  proc "c" (target: u32, pname: u32, params: [^]i32);
 
@@ -913,18 +913,18 @@ 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: [^][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_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_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;
 
@@ -1024,54 +1024,54 @@ impl_ProgramUniform1dv:         proc "c" (program: u32, location: i32, count: i3
 
 impl_ProgramUniform1ui:         proc "c" (program: u32, location: i32, v0: u32);
 
 impl_ProgramUniform1uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]u32);
 
+impl_ProgramUniformMatrix2fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix3fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix4fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix2dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix3dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix4dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix2x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix3x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix2x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix4x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix3x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix4x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32);
 
+impl_ProgramUniformMatrix2x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix3x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix2x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix4x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix3x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64);
 
+impl_ProgramUniformMatrix4x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]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);
 
 impl_VertexAttribL2d:           proc "c" (index: u32, x: f64, y: f64);
 
 impl_VertexAttribL3d:           proc "c" (index: u32, x: f64, y: f64, z: f64);
 
 impl_VertexAttribL4d:           proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64);
 
-impl_VertexAttribL1dv:          proc "c" (index: u32, v: ^[1]f64);
 
+impl_VertexAttribL1dv:          proc "c" (index: u32, v: ^f64);
 
 impl_VertexAttribL2dv:          proc "c" (index: u32, v: ^[2]f64);
 
 impl_VertexAttribL3dv:          proc "c" (index: u32, v: ^[3]f64);
 
 impl_VertexAttribL4dv:          proc "c" (index: u32, v: ^[4]f64);

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

@@ -161,23 +161,23 @@ when !ODIN_DEBUG {
 
 	Uniform3i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32)                                                   {        impl_Uniform3i(location, v0, v1, v2);                                                  }
 
 	Uniform4i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32)                                          {        impl_Uniform4i(location, v0, v1, v2, v3);                                              }
 
 	Uniform1fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform1fv(location, count, value);                                               }
 
-	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]f32)                                                {        impl_Uniform2fv(location, count, value);                                               }
 
-	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]f32)                                                {        impl_Uniform3fv(location, count, value);                                               }
 
-	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]f32)                                                {        impl_Uniform4fv(location, count, value);                                               }
 
+	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform2fv(location, count, value);                                               }
 
+	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform3fv(location, count, value);                                               }
 
+	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform4fv(location, count, value);                                               }
 
 	Uniform1iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform1iv(location, count, value);                                               }
 
-	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]i32)                                                {        impl_Uniform2iv(location, count, value);                                               }
 
-	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]i32)                                                {        impl_Uniform3iv(location, count, value);                                               }
 
-	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]i32)                                                {        impl_Uniform4iv(location, count, 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);                              }
 
+	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);                              }
 
 	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);                                                        }
 
+	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                                        {        impl_VertexAttrib1dv(index, v);                                                        }
 
 	VertexAttrib1f           :: #force_inline proc "c" (index: u32, x: f32)                                                                         {        impl_VertexAttrib1f(index, x);                                                         }
 
-	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^[1]f32)                                                                        {        impl_VertexAttrib1fv(index, v);                                                        }
 
+	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^f32)                                                                        {        impl_VertexAttrib1fv(index, v);                                                        }
 
 	VertexAttrib1s           :: #force_inline proc "c" (index: u32, x: i16)                                                                         {        impl_VertexAttrib1s(index, x);                                                         }
 
-	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^[1]i16)                                                                      {        impl_VertexAttrib1sv(index, v);                                                        }
 
+	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib1sv(index, v);                                                        }
 
 	VertexAttrib2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64)                                                                 {        impl_VertexAttrib2d(index, x, y);                                                      }
 
 	VertexAttrib2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64)                                                                      {        impl_VertexAttrib2dv(index, v);                                                        }
 
 	VertexAttrib2f           :: #force_inline proc "c" (index: u32, x: f32, y: f32)                                                                 {        impl_VertexAttrib2f(index, x, y);                                                      }
 
@@ -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: [^]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value); }
 
+	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value); }
 
+	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value); }
 
+	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value); }
 
+	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value); }
 
+	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value); }
 
 
 
 	// VERSION_3_0
 
@@ -266,9 +266,9 @@ when !ODIN_DEBUG {
 
 	Uniform3ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                                  }
 
 	Uniform4ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                              }
 
 	Uniform1uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform1uiv(location, count, value);                                                               }
 
-	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]u32)                                                                               {        impl_Uniform2uiv(location, count, value);                                                               }
 
-	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]u32)                                                                               {        impl_Uniform3uiv(location, count, value);                                                               }
 
-	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]u32)                                                                               {        impl_Uniform4uiv(location, count, value);                                                               }
 
+	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform2uiv(location, count, value);                                                               }
 
+	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform3uiv(location, count, value);                                                               }
 
+	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform4uiv(location, count, value);                                                               }
 
 	TexParameterIiv                     :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_TexParameterIiv(target, pname, params);                                                            }
 
 	TexParameterIuiv                    :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_TexParameterIuiv(target, pname, params);                                                           }
 
 	GetTexParameterIiv                  :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetTexParameterIiv(target, pname, params);                                                         }
 
@@ -413,18 +413,18 @@ when !ODIN_DEBUG {
 
 	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: [^][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);                                          }
 
+	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);                                          }
 
 	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; }
 
@@ -474,54 +474,54 @@ when !ODIN_DEBUG {
 
 	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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value);                                 }
 
+	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);                 }
 
+	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);               }
 
+	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]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);                                                           }
 
 	VertexAttribL2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64)                                                   {        impl_VertexAttribL2d(index, x, y);                                                        }
 
 	VertexAttribL3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64)                                           {        impl_VertexAttribL3d(index, x, y, z);                                                     }
 
 	VertexAttribL4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                                  }
 
-	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^[1]f64)                                                       {        impl_VertexAttribL1dv(index, v);                                                          }
 
+	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                       {        impl_VertexAttribL1dv(index, v);                                                          }
 
 	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64)                                                       {        impl_VertexAttribL2dv(index, v);                                                          }
 
 	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64)                                                       {        impl_VertexAttribL3dv(index, v);                                                          }
 
 	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64)                                                       {        impl_VertexAttribL4dv(index, v);                                                          }
 
@@ -962,23 +962,23 @@ when !ODIN_DEBUG {
 
 	Uniform3i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                                                  {        impl_Uniform3i(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2);                                           }
 
 	Uniform4i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)                                         {        impl_Uniform4i(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3);                                       }
 
 	Uniform1fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform1fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]f32, loc := #caller_location)                                                  {        impl_Uniform2fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]f32, loc := #caller_location)                                                  {        impl_Uniform3fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]f32, loc := #caller_location)                                                  {        impl_Uniform4fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
+	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform2fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
+	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform3fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
+	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform4fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
 	Uniform1iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform1iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
 
-	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]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: [^][3]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: [^][4]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: [^][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);                              }
 
+	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);                              }
 
 	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);                                                       }
 
+	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
 	VertexAttrib1f           :: #force_inline proc "c" (index: u32, x: f32, loc := #caller_location)                                                                        {        impl_VertexAttrib1f(index, x);                                             debug_helper(loc, 0, index, x);                                                       }
 
-	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^[1]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
+	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
 	VertexAttrib1s           :: #force_inline proc "c" (index: u32, x: i16, loc := #caller_location)                                                                        {        impl_VertexAttrib1s(index, x);                                             debug_helper(loc, 0, index, x);                                                       }
 
-	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^[1]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
+	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
 	VertexAttrib2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                                {        impl_VertexAttrib2d(index, x, y);                                          debug_helper(loc, 0, index, x, y);                                                    }
 
 	VertexAttrib2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib2dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 
 	VertexAttrib2f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, loc := #caller_location)                                                                {        impl_VertexAttrib2f(index, x, y);                                          debug_helper(loc, 0, index, x, y);                                                    }
 
@@ -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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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);                                                                }
 
@@ -1066,9 +1066,9 @@ when !ODIN_DEBUG {
 
 	Uniform3ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                      debug_helper(loc, 0, location, v0, v1, v2);                                                             }
 
 	Uniform4ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                  debug_helper(loc, 0, location, v0, v1, v2, v3);                                                         }
 
 	Uniform1uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform1uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
-	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^][2]u32, loc := #caller_location)                                                                               {        impl_Uniform2uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
-	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^][3]u32, loc := #caller_location)                                                                               {        impl_Uniform3uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
-	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^][4]u32, loc := #caller_location)                                                                               {        impl_Uniform4uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
+	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform2uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
+	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform3uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
+	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform4uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
 
 	TexParameterIiv                     :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_TexParameterIiv(target, pname, params);                                                debug_helper(loc, 0, target, pname, params);                                                            }
 
 	TexParameterIuiv                    :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_TexParameterIuiv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params);                                                            }
 
 	GetTexParameterIiv                  :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetTexParameterIiv(target, pname, params);                                             debug_helper(loc, 0, target, pname, params);                                                            }
 
@@ -1213,18 +1213,18 @@ when !ODIN_DEBUG {
 
 	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: [^][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);                              }
 
+	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);                              }
 
 	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; }
 
@@ -1274,54 +1274,54 @@ when !ODIN_DEBUG {
 
 	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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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: [^]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);                                                   }
 
 	VertexAttribL2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                   {        impl_VertexAttribL2d(index, x, y);                                            debug_helper(loc, 0, index, x, y);                                                }
 
 	VertexAttribL3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                           {        impl_VertexAttribL3d(index, x, y, z);                                         debug_helper(loc, 0, index, x, y, z);                                             }
 
 	VertexAttribL4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                      debug_helper(loc, 0, index, x, y, z, w);                                          }
 
-	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^[1]f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
 
+	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
 
 	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                          {        impl_VertexAttribL2dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
 
 	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                          {        impl_VertexAttribL3dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
 
 	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                          {        impl_VertexAttribL4dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }