Change some usages of `[^]T` to `^[N]T` where appropriate

vendor/OpenGL/impl.odin

@@ -326,10 +326,10 @@ impl_GetActiveUniform:         proc "c" (program: u32, index: u32, bufSize: i32,
 impl_GetAttachedShaders:       proc "c" (program: u32, maxCount: i32, count: ^i32, shaders: ^u32);
 impl_GetAttribLocation:        proc "c" (program: u32, name: cstring) -> i32;
 impl_GetProgramiv:             proc "c" (program: u32, pname: u32, params: [^]i32);
-impl_GetProgramInfoLog:        proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: ^u8);
+impl_GetProgramInfoLog:        proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8);
 impl_GetShaderiv:              proc "c" (shader: u32, pname: u32, params: [^]i32);
-impl_GetShaderInfoLog:         proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: ^u8);
-impl_GetShaderSource:          proc "c" (shader: u32, bufSize: i32, length: ^i32, source: ^u8);
+impl_GetShaderInfoLog:         proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8);
+impl_GetShaderSource:          proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8);
 impl_GetUniformLocation:       proc "c" (program: u32, name: cstring) -> i32;
 impl_GetUniformfv:             proc "c" (program: u32, location: i32, params: [^]f32);
 impl_GetUniformiv:             proc "c" (program: u32, location: i32, params: [^]i32);
@@ -363,41 +363,41 @@ impl_UniformMatrix3fv:         proc "c" (location: i32, count: i32, transpose: b
 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: [^]f64);
+impl_VertexAttrib1dv:          proc "c" (index: u32, v: ^[1]f64);
 impl_VertexAttrib1f:           proc "c" (index: u32, x: f32);
-impl_VertexAttrib1fv:          proc "c" (index: u32, v: [^]f32);
+impl_VertexAttrib1fv:          proc "c" (index: u32, v: ^[1]f32);
 impl_VertexAttrib1s:           proc "c" (index: u32, x: i16);
-impl_VertexAttrib1sv:          proc "c" (index: u32, v: [^]i16);
+impl_VertexAttrib1sv:          proc "c" (index: u32, v: ^[1]i16);
 impl_VertexAttrib2d:           proc "c" (index: u32, x: f64, y: f64);
-impl_VertexAttrib2dv:          proc "c" (index: u32, v: [^]f64);
+impl_VertexAttrib2dv:          proc "c" (index: u32, v: ^[2]f64);
 impl_VertexAttrib2f:           proc "c" (index: u32, x: f32, y: f32);
-impl_VertexAttrib2fv:          proc "c" (index: u32, v: [^]f32);
+impl_VertexAttrib2fv:          proc "c" (index: u32, v: ^[2]f32);
 impl_VertexAttrib2s:           proc "c" (index: u32, x: i16, y: i16);
-impl_VertexAttrib2sv:          proc "c" (index: u32, v: [^]i16);
+impl_VertexAttrib2sv:          proc "c" (index: u32, v: ^[2]i16);
 impl_VertexAttrib3d:           proc "c" (index: u32, x: f64, y: f64, z: f64);
-impl_VertexAttrib3dv:          proc "c" (index: u32, v: [^]f64);
+impl_VertexAttrib3dv:          proc "c" (index: u32, v: ^[3]f64);
 impl_VertexAttrib3f:           proc "c" (index: u32, x: f32, y: f32, z: f32);
-impl_VertexAttrib3fv:          proc "c" (index: u32, v: [^]f32);
+impl_VertexAttrib3fv:          proc "c" (index: u32, v: ^[3]f32);
 impl_VertexAttrib3s:           proc "c" (index: u32, x: i16, y: i16, z: i16);
-impl_VertexAttrib3sv:          proc "c" (index: u32, v: [^]i16);
-impl_VertexAttrib4Nbv:         proc "c" (index: u32, v: [^]i8);
-impl_VertexAttrib4Niv:         proc "c" (index: u32, v: [^]i32);
-impl_VertexAttrib4Nsv:         proc "c" (index: u32, v: [^]i16);
+impl_VertexAttrib3sv:          proc "c" (index: u32, v: ^[3]i16);
+impl_VertexAttrib4Nbv:         proc "c" (index: u32, v: ^[4]i8);
+impl_VertexAttrib4Niv:         proc "c" (index: u32, v: ^[4]i32);
+impl_VertexAttrib4Nsv:         proc "c" (index: u32, v: ^[4]i16);
 impl_VertexAttrib4Nub:         proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8);
-impl_VertexAttrib4Nubv:        proc "c" (index: u32, v: [^]u8);
-impl_VertexAttrib4Nuiv:        proc "c" (index: u32, v: [^]u32);
-impl_VertexAttrib4Nusv:        proc "c" (index: u32, v: [^]u16);
-impl_VertexAttrib4bv:          proc "c" (index: u32, v: [^]i8);
+impl_VertexAttrib4Nubv:        proc "c" (index: u32, v: ^[4]u8);
+impl_VertexAttrib4Nuiv:        proc "c" (index: u32, v: ^[4]u32);
+impl_VertexAttrib4Nusv:        proc "c" (index: u32, v: ^[4]u16);
+impl_VertexAttrib4bv:          proc "c" (index: u32, v: ^[4]i8);
 impl_VertexAttrib4d:           proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64);
-impl_VertexAttrib4dv:          proc "c" (index: u32, v: [^]f64);
+impl_VertexAttrib4dv:          proc "c" (index: u32, v: ^[4]f64);
 impl_VertexAttrib4f:           proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32);
-impl_VertexAttrib4fv:          proc "c" (index: u32, v: [^]f32);
-impl_VertexAttrib4iv:          proc "c" (index: u32, v: [^]i32);
+impl_VertexAttrib4fv:          proc "c" (index: u32, v: ^[4]f32);
+impl_VertexAttrib4iv:          proc "c" (index: u32, v: ^[4]i32);
 impl_VertexAttrib4s:           proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16);
-impl_VertexAttrib4sv:          proc "c" (index: u32, v: [^]i16);
-impl_VertexAttrib4ubv:         proc "c" (index: u32, v: [^]u8);
-impl_VertexAttrib4uiv:         proc "c" (index: u32, v: [^]u32);
-impl_VertexAttrib4usv:         proc "c" (index: u32, v: [^]u16);
+impl_VertexAttrib4sv:          proc "c" (index: u32, v: ^[4]i16);
+impl_VertexAttrib4ubv:         proc "c" (index: u32, v: ^[4]u8);
+impl_VertexAttrib4uiv:         proc "c" (index: u32, v: ^[4]u32);
+impl_VertexAttrib4usv:         proc "c" (index: u32, v: ^[4]u16);
 impl_VertexAttribPointer:      proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: rawptr);
 
 load_2_0 :: proc(set_proc_address: Set_Proc_Address_Type) {
@@ -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: [^]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);
+impl_UniformMatrix2x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][3]f32);
+impl_UniformMatrix3x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][2]f32);
+impl_UniformMatrix2x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][4]f32);
+impl_UniformMatrix4x2fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][2]f32);
+impl_UniformMatrix3x4fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][4]f32);
+impl_UniformMatrix4x3fv: proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][3]f32);
 
 load_2_1 :: proc(set_proc_address: Set_Proc_Address_Type) {
 	set_proc_address(&impl_UniformMatrix2x3fv, "glUniformMatrix2x3fv");
@@ -1016,73 +1016,73 @@ impl_GenProgramPipelines:       proc "c" (n: i32, pipelines: [^]u32);
 impl_IsProgramPipeline:         proc "c" (pipeline: u32) -> bool;
 impl_GetProgramPipelineiv:      proc "c" (pipeline: u32, pname: u32, params: [^]i32);
 impl_ProgramUniform1i:          proc "c" (program: u32, location: i32, v0: i32);
-impl_ProgramUniform1iv:         proc "c" (program: u32, location: i32, count: i32, value: [^]i32);
+impl_ProgramUniform1iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[1]i32);
 impl_ProgramUniform1f:          proc "c" (program: u32, location: i32, v0: f32);
-impl_ProgramUniform1fv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f32);
+impl_ProgramUniform1fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[1]f32);
 impl_ProgramUniform1d:          proc "c" (program: u32, location: i32, v0: f64);
-impl_ProgramUniform1dv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f64);
+impl_ProgramUniform1dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[1]f64);
 impl_ProgramUniform1ui:         proc "c" (program: u32, location: i32, v0: u32);
-impl_ProgramUniform1uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^]u32);
+impl_ProgramUniform1uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[1]u32);
 impl_ProgramUniform2i:          proc "c" (program: u32, location: i32, v0: i32, v1: i32);
-impl_ProgramUniform2iv:         proc "c" (program: u32, location: i32, count: i32, value: [^]i32);
+impl_ProgramUniform2iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[2]i32);
 impl_ProgramUniform2f:          proc "c" (program: u32, location: i32, v0: f32, v1: f32);
-impl_ProgramUniform2fv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f32);
+impl_ProgramUniform2fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[2]f32);
 impl_ProgramUniform2d:          proc "c" (program: u32, location: i32, v0: f64, v1: f64);
-impl_ProgramUniform2dv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f64);
+impl_ProgramUniform2dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[2]f64);
 impl_ProgramUniform2ui:         proc "c" (program: u32, location: i32, v0: u32, v1: u32);
-impl_ProgramUniform2uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^]u32);
+impl_ProgramUniform2uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[2]u32);
 impl_ProgramUniform3i:          proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32);
-impl_ProgramUniform3iv:         proc "c" (program: u32, location: i32, count: i32, value: [^]i32);
+impl_ProgramUniform3iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[3]i32);
 impl_ProgramUniform3f:          proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32);
-impl_ProgramUniform3fv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f32);
+impl_ProgramUniform3fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[3]f32);
 impl_ProgramUniform3d:          proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64);
-impl_ProgramUniform3dv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f64);
+impl_ProgramUniform3dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[3]f64);
 impl_ProgramUniform3ui:         proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32);
-impl_ProgramUniform3uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^]u32);
+impl_ProgramUniform3uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[3]u32);
 impl_ProgramUniform4i:          proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32);
-impl_ProgramUniform4iv:         proc "c" (program: u32, location: i32, count: i32, value: [^]i32);
+impl_ProgramUniform4iv:         proc "c" (program: u32, location: i32, count: i32, value: ^[4]i32);
 impl_ProgramUniform4f:          proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32);
-impl_ProgramUniform4fv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f32);
+impl_ProgramUniform4fv:         proc "c" (program: u32, location: i32, count: i32, value: ^[4]f32);
 impl_ProgramUniform4d:          proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64);
-impl_ProgramUniform4dv:         proc "c" (program: u32, location: i32, count: i32, value: [^]f64);
+impl_ProgramUniform4dv:         proc "c" (program: u32, location: i32, count: i32, value: ^[4]f64);
 impl_ProgramUniform4ui:         proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32);
-impl_ProgramUniform4uiv:        proc "c" (program: u32, location: i32, count: i32, value: [^]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_ProgramUniform4uiv:        proc "c" (program: u32, location: i32, count: i32, value: ^[4]u32);
+impl_ProgramUniformMatrix2fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f32);
+impl_ProgramUniformMatrix3fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f32);
+impl_ProgramUniformMatrix4fv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f32);
+impl_ProgramUniformMatrix2dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f64);
+impl_ProgramUniformMatrix3dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f64);
+impl_ProgramUniformMatrix4dv:   proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f64);
+impl_ProgramUniformMatrix2x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f32);
+impl_ProgramUniformMatrix3x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f32);
+impl_ProgramUniformMatrix2x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f32);
+impl_ProgramUniformMatrix4x2fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f32);
+impl_ProgramUniformMatrix3x4fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f32);
+impl_ProgramUniformMatrix4x3fv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f32);
+impl_ProgramUniformMatrix2x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f64);
+impl_ProgramUniformMatrix3x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f64);
+impl_ProgramUniformMatrix2x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f64);
+impl_ProgramUniformMatrix4x2dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f64);
+impl_ProgramUniformMatrix3x4dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f64);
+impl_ProgramUniformMatrix4x3dv: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f64);
 impl_ValidateProgramPipeline:   proc "c" (pipeline: u32);
-impl_GetProgramPipelineInfoLog: proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: ^u8);
+impl_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: [^]f64);
-impl_VertexAttribL2dv:          proc "c" (index: u32, v: [^]f64);
-impl_VertexAttribL3dv:          proc "c" (index: u32, v: [^]f64);
-impl_VertexAttribL4dv:          proc "c" (index: u32, v: [^]f64);
+impl_VertexAttribL1dv:          proc "c" (index: u32, v: ^[1]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);
 impl_VertexAttribLPointer:      proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: rawptr);
 impl_GetVertexAttribLdv:        proc "c" (index: u32, pname: u32, params: [^]f64);
 impl_ViewportArrayv:            proc "c" (first: u32, count: i32, v: [^]f32);
 impl_ViewportIndexedf:          proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32);
-impl_ViewportIndexedfv:         proc "c" (index: u32, v: [^]f32);
+impl_ViewportIndexedfv:         proc "c" (index: u32, v: ^[4]f32);
 impl_ScissorArrayv:             proc "c" (first: u32, count: i32, v: [^]i32);
 impl_ScissorIndexed:            proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32);
-impl_ScissorIndexedv:           proc "c" (index: u32, v: [^]i32);
+impl_ScissorIndexedv:           proc "c" (index: u32, v: ^[4]i32);
 impl_DepthRangeArrayv:          proc "c" (first: u32, count: i32, v: [^]f64);
 impl_DepthRangeIndexed:         proc "c" (index: u32, n: f64, f: f64);
 impl_GetFloati_v:               proc "c" (target: u32, index: u32, data: ^f32);

vendor/OpenGL/wrappers.odin

@@ -173,50 +173,50 @@ when !ODIN_DEBUG {
 	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: [^]f64)                                                                        {        impl_VertexAttrib1dv(index, v);                                                        }
+	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^[1]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: [^]f32)                                                                        {        impl_VertexAttrib1fv(index, v);                                                        }
+	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^[1]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: [^]i16)                                                                      {        impl_VertexAttrib1sv(index, v);                                                        }
+	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^[1]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: [^]f64)                                                                      {        impl_VertexAttrib2dv(index, v);                                                        }
+	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);                                                      }
-	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: [^]f32)                                                                      {        impl_VertexAttrib2fv(index, v);                                                        }
+	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: ^[2]f32)                                                                      {        impl_VertexAttrib2fv(index, v);                                                        }
 	VertexAttrib2s           :: #force_inline proc "c" (index: u32, x: i16, y: i16)                                                                 {        impl_VertexAttrib2s(index, x, y);                                                      }
-	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: [^]i16)                                                                      {        impl_VertexAttrib2sv(index, v);                                                        }
+	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: ^[2]i16)                                                                      {        impl_VertexAttrib2sv(index, v);                                                        }
 	VertexAttrib3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64)                                                         {        impl_VertexAttrib3d(index, x, y, z);                                                   }
-	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: [^]f64)                                                                      {        impl_VertexAttrib3dv(index, v);                                                        }
+	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64)                                                                      {        impl_VertexAttrib3dv(index, v);                                                        }
 	VertexAttrib3f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32)                                                         {        impl_VertexAttrib3f(index, x, y, z);                                                   }
-	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: [^]f32)                                                                      {        impl_VertexAttrib3fv(index, v);                                                        }
+	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: ^[3]f32)                                                                      {        impl_VertexAttrib3fv(index, v);                                                        }
 	VertexAttrib3s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16)                                                         {        impl_VertexAttrib3s(index, x, y, z);                                                   }
-	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: [^]i16)                                                                      {        impl_VertexAttrib3sv(index, v);                                                        }
-	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: [^]i8)                                                                       {        impl_VertexAttrib4Nbv(index, v);                                                       }
-	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: [^]i32)                                                                      {        impl_VertexAttrib4Niv(index, v);                                                       }
-	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: [^]i16)                                                                      {        impl_VertexAttrib4Nsv(index, v);                                                       }
+	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: ^[3]i16)                                                                      {        impl_VertexAttrib3sv(index, v);                                                        }
+	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4Nbv(index, v);                                                       }
+	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4Niv(index, v);                                                       }
+	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4Nsv(index, v);                                                       }
 	VertexAttrib4Nub         :: #force_inline proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8)                                                     {        impl_VertexAttrib4Nub(index, x, y, z, w);                                              }
-	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: [^]u8)                                                                       {        impl_VertexAttrib4Nubv(index, v);                                                      }
-	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: [^]u32)                                                                      {        impl_VertexAttrib4Nuiv(index, v);                                                      }
-	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: [^]u16)                                                                      {        impl_VertexAttrib4Nusv(index, v);                                                      }
-	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: [^]i8)                                                                       {        impl_VertexAttrib4bv(index, v);                                                        }
+	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4Nubv(index, v);                                                      }
+	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4Nuiv(index, v);                                                      }
+	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4Nusv(index, v);                                                      }
+	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4bv(index, v);                                                        }
 	VertexAttrib4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                                 {        impl_VertexAttrib4d(index, x, y, z, w);                                                }
-	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: [^]f64)                                                                      {        impl_VertexAttrib4dv(index, v);                                                        }
+	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64)                                                                      {        impl_VertexAttrib4dv(index, v);                                                        }
 	VertexAttrib4f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32)                                                 {        impl_VertexAttrib4f(index, x, y, z, w);                                                }
-	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: [^]f32)                                                                      {        impl_VertexAttrib4fv(index, v);                                                        }
-	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: [^]i32)                                                                      {        impl_VertexAttrib4iv(index, v);                                                        }
+	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: ^[4]f32)                                                                      {        impl_VertexAttrib4fv(index, v);                                                        }
+	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4iv(index, v);                                                        }
 	VertexAttrib4s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16)                                                 {        impl_VertexAttrib4s(index, x, y, z, w);                                                }
-	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: [^]i16)                                                                      {        impl_VertexAttrib4sv(index, v);                                                        }
-	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: [^]u8)                                                                       {        impl_VertexAttrib4ubv(index, v);                                                       }
-	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: [^]u32)                                                                      {        impl_VertexAttrib4uiv(index, v);                                                       }
-	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: [^]u16)                                                                      {        impl_VertexAttrib4usv(index, v);                                                       }
+	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4sv(index, v);                                                        }
+	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4ubv(index, v);                                                       }
+	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4uiv(index, v);                                                       }
+	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4usv(index, v);                                                       }
 	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: [^]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); }
+	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][3]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value); }
+	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][2]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value); }
+	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][4]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value); }
+	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][2]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value); }
+	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][4]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value); }
+	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][3]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value); }
 
 
 	// VERSION_3_0
@@ -466,77 +466,77 @@ when !ODIN_DEBUG {
 	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             return ret; }
 	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: [^]i32)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                                       }
 	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32)                                         {        impl_ProgramUniform1i(program, location, v0);                                             }
-	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform1iv(program, location, count, value);                                  }
+	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]i32)                      {        impl_ProgramUniform1iv(program, location, count, value);                                  }
 	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32)                                         {        impl_ProgramUniform1f(program, location, v0);                                             }
-	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform1fv(program, location, count, value);                                  }
+	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f32)                      {        impl_ProgramUniform1fv(program, location, count, value);                                  }
 	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64)                                         {        impl_ProgramUniform1d(program, location, v0);                                             }
-	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform1dv(program, location, count, value);                                  }
+	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f64)                      {        impl_ProgramUniform1dv(program, location, count, value);                                  }
 	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32)                                         {        impl_ProgramUniform1ui(program, location, v0);                                            }
-	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform1uiv(program, location, count, value);                                 }
+	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]u32)                      {        impl_ProgramUniform1uiv(program, location, count, value);                                 }
 	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32)                                {        impl_ProgramUniform2i(program, location, v0, v1);                                         }
-	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform2iv(program, location, count, value);                                  }
+	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]i32)                       {        impl_ProgramUniform2iv(program, location, count, value);                                  }
 	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32)                                {        impl_ProgramUniform2f(program, location, v0, v1);                                         }
-	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform2fv(program, location, count, value);                                  }
+	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f32)                       {        impl_ProgramUniform2fv(program, location, count, value);                                  }
 	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64)                                {        impl_ProgramUniform2d(program, location, v0, v1);                                         }
-	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform2dv(program, location, count, value);                                  }
+	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f64)                       {        impl_ProgramUniform2dv(program, location, count, value);                                  }
 	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                                        }
-	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value);                                 }
+	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value);                                 }
 	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                                     }
-	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform3iv(program, location, count, value);                                  }
+	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]i32)                       {        impl_ProgramUniform3iv(program, location, count, value);                                  }
 	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                                     }
-	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform3fv(program, location, count, value);                                  }
+	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f32)                       {        impl_ProgramUniform3fv(program, location, count, value);                                  }
 	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                                     }
-	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform3dv(program, location, count, value);                                  }
+	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f64)                       {        impl_ProgramUniform3dv(program, location, count, value);                                  }
 	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                                    }
-	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value);                                 }
+	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value);                                 }
 	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                                 }
-	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform4iv(program, location, count, value);                                  }
+	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]i32)                       {        impl_ProgramUniform4iv(program, location, count, value);                                  }
 	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                                 }
-	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform4fv(program, location, count, value);                                  }
+	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f32)                       {        impl_ProgramUniform4fv(program, location, count, value);                                  }
 	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                                 }
-	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform4dv(program, location, count, value);                                  }
+	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f64)                       {        impl_ProgramUniform4dv(program, location, count, value);                                  }
 	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                                }
-	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]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);               }
+	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value);                                 }
+	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);               }
+	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f64)  {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);               }
 	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32)                                                                {        impl_ValidateProgramPipeline(pipeline);                                                   }
 	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);                       }
 	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64)                                                           {        impl_VertexAttribL1d(index, x);                                                           }
 	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: [^]f64)                                                          {        impl_VertexAttribL1dv(index, v);                                                          }
-	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: [^]f64)                                                          {        impl_VertexAttribL2dv(index, v);                                                          }
-	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: [^]f64)                                                          {        impl_VertexAttribL3dv(index, v);                                                          }
-	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: [^]f64)                                                          {        impl_VertexAttribL4dv(index, v);                                                          }
+	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^[1]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);                                                          }
 	VertexAttribLPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: rawptr)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer);                           }
 	GetVertexAttribLdv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64)                                       {        impl_GetVertexAttribLdv(index, pname, params);                                            }
 	ViewportArrayv            :: #force_inline proc "c" (first: u32, count: i32, v: [^]f32)                                            {        impl_ViewportArrayv(first, count, v);                                                     }
 	ViewportIndexedf          :: #force_inline proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                                 }
-	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: [^]f32)                                                          {        impl_ViewportIndexedfv(index, v);                                                         }
+	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: ^[4]f32)                                                          {        impl_ViewportIndexedfv(index, v);                                                         }
 	ScissorArrayv             :: #force_inline proc "c" (first: u32, count: i32, v: [^]i32)                                            {        impl_ScissorArrayv(first, count, v);                                                      }
 	ScissorIndexed            :: #force_inline proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                                  }
-	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: [^]i32)                                                          {        impl_ScissorIndexedv(index, v);                                                           }
+	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: ^[4]i32)                                                          {        impl_ScissorIndexedv(index, v);                                                           }
 	DepthRangeArrayv          :: #force_inline proc "c" (first: u32, count: i32, v: [^]f64)                                            {        impl_DepthRangeArrayv(first, count, v);                                                   }
 	DepthRangeIndexed         :: #force_inline proc "c" (index: u32, n: f64, f: f64)                                                   {        impl_DepthRangeIndexed(index, n, f);                                                      }
-	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: [^]f32)                                          {        impl_GetFloati_v(target, index, data);                                                    }
-	GetDoublei_v              :: #force_inline proc "c" (target: u32, index: u32, data: [^]f64)                                          {        impl_GetDoublei_v(target, index, data);                                                   }
+	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: ^f32)                                          {        impl_GetFloati_v(target, index, data);                                                    }
+	GetDoublei_v              :: #force_inline proc "c" (target: u32, index: u32, data: ^f64)                                          {        impl_GetDoublei_v(target, index, data);                                                   }
 
 	// VERSION_4_2
 	DrawArraysInstancedBaseInstance             :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32)                                   { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);                                  }
@@ -974,50 +974,50 @@ when !ODIN_DEBUG {
 	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: [^]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^[1]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: [^]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^[1]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: [^]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^[1]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: [^]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib2dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	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);                                                    }
-	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: [^]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib2fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: ^[2]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib2fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib2s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, loc := #caller_location)                                                                {        impl_VertexAttrib2s(index, x, y);                                          debug_helper(loc, 0, index, x, y);                                                    }
-	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib2sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: ^[2]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib2sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                                        {        impl_VertexAttrib3d(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z);                                                 }
-	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: [^]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib3dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib3dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib3f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, loc := #caller_location)                                                        {        impl_VertexAttrib3f(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z);                                                 }
-	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: [^]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib3fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: ^[3]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib3fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib3s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, loc := #caller_location)                                                        {        impl_VertexAttrib3s(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z);                                                 }
-	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib3sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: [^]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nbv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Niv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nsv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: ^[3]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib3sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nbv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Niv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nsv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib4Nub         :: #force_inline proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8, loc := #caller_location)                                                    {        impl_VertexAttrib4Nub(index, x, y, z, w);                                  debug_helper(loc, 0, index, x, y, z, w);                                              }
-	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: [^]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nubv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nuiv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: [^]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nusv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: [^]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4bv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nubv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nuiv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nusv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4bv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                                {        impl_VertexAttrib4d(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w);                                              }
-	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: [^]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib4dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib4dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib4f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32, loc := #caller_location)                                                {        impl_VertexAttrib4f(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w);                                              }
-	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: [^]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib4fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4iv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib4fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4iv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
 	VertexAttrib4s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16, loc := #caller_location)                                                {        impl_VertexAttrib4s(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w);                                              }
-	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: [^]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4ubv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4uiv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
-	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: [^]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4usv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4ubv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4uiv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
+	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4usv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
 	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: [^]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); }
+	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][3]f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
+	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][2]f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
+	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[2][4]f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
+	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][2]f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
+	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[3][4]f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
+	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: ^[4][3]f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
 
 		// VERSION_3_0
 	ColorMaski                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8, loc := #caller_location)                                                                                 {        impl_ColorMaski(index, r, g, b, a);                                                         debug_helper(loc, 0, index, r, g, b, a);                                                                }
@@ -1266,73 +1266,73 @@ when !ODIN_DEBUG {
 	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32, loc := #caller_location) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             debug_helper(loc, 1, ret, pipeline);                                 return ret;; }
 	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: [^]i32, loc := #caller_location)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                           debug_helper(loc, 0, pipeline, pname, params);                                    }
 	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, loc := #caller_location)                                         {        impl_ProgramUniform1i(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
-	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, loc := #caller_location)                                         {        impl_ProgramUniform1f(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
-	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, loc := #caller_location)                                         {        impl_ProgramUniform1d(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
-	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location)                                         {        impl_ProgramUniform1ui(program, location, v0);                                debug_helper(loc, 0, program, location, v0);                                      }
-	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[1]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location)                                {        impl_ProgramUniform2i(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
-	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, loc := #caller_location)                                {        impl_ProgramUniform2f(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
-	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, loc := #caller_location)                                {        impl_ProgramUniform2d(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
-	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, loc := #caller_location)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                            debug_helper(loc, 0, program, location, v0, v1);                                  }
-	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[2]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
-	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
-	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, loc := #caller_location)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
-	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                        debug_helper(loc, 0, program, location, v0, v1, v2);                              }
-	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[3]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
-	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
-	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64, loc := #caller_location)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
-	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
 	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                    debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
-	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]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);                 }
+	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^[4]u32, loc := #caller_location)                       {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
+	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[2][4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][2]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[3][4]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
+	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: ^[4][3]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
 	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_ValidateProgramPipeline(pipeline);                                       debug_helper(loc, 0, pipeline);                                                   }
 	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);           debug_helper(loc, 0, pipeline, bufSize, length, infoLog);                         }
 	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                           {        impl_VertexAttribL1d(index, x);                                               debug_helper(loc, 0, index, x);                                                   }
 	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: [^]f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
-	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: [^]f64, loc := #caller_location)                                                          {        impl_VertexAttribL2dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
-	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: [^]f64, loc := #caller_location)                                                          {        impl_VertexAttribL3dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
-	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: [^]f64, loc := #caller_location)                                                          {        impl_VertexAttribL4dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
+	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^[1]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);                                                   }
 	VertexAttribLPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: rawptr, loc := #caller_location)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer);               debug_helper(loc, 0, index, size, type, stride, pointer);                        }
 	GetVertexAttribLdv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                       {        impl_GetVertexAttribLdv(index, pname, params);                                debug_helper(loc, 0, index, pname, params);                                       }
 	ViewportArrayv            :: #force_inline proc "c" (first: u32, count: i32, v: [^]f32, loc := #caller_location)                                            {        impl_ViewportArrayv(first, count, v);                                         debug_helper(loc, 0, first, count, v);                                            }
 	ViewportIndexedf          :: #force_inline proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32, loc := #caller_location)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                     debug_helper(loc, 0, index, x, y, w, h);                                          }
-	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: [^]f32, loc := #caller_location)                                                          {        impl_ViewportIndexedfv(index, v);                                             debug_helper(loc, 0, index, v);                                                   }
+	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                          {        impl_ViewportIndexedfv(index, v);                                             debug_helper(loc, 0, index, v);                                                   }
 	ScissorArrayv             :: #force_inline proc "c" (first: u32, count: i32, v: [^]i32, loc := #caller_location)                                            {        impl_ScissorArrayv(first, count, v);                                          debug_helper(loc, 0, first, count, v);                                            }
 	ScissorIndexed            :: #force_inline proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32, loc := #caller_location)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                      debug_helper(loc, 0, index, left, bottom, width, height);                         }
-	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                          {        impl_ScissorIndexedv(index, v);                                               debug_helper(loc, 0, index, v);                                                   }
+	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                          {        impl_ScissorIndexedv(index, v);                                               debug_helper(loc, 0, index, v);                                                   }
 	DepthRangeArrayv          :: #force_inline proc "c" (first: u32, count: i32, v: [^]f64, loc := #caller_location)                                            {        impl_DepthRangeArrayv(first, count, v);                                       debug_helper(loc, 0, first, count, v);                                            }
 	DepthRangeIndexed         :: #force_inline proc "c" (index: u32, n: f64, f: f64, loc := #caller_location)                                                   {        impl_DepthRangeIndexed(index, n, f);                                          debug_helper(loc, 0, index, n, f);                                                }
 	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: ^f32, loc := #caller_location)                                          {        impl_GetFloati_v(target, index, data);                                        debug_helper(loc, 0, target, index, data);                                        }