|
|
@@ -0,0 +1,1567 @@
|
|
|
+package odin_gl
|
|
|
+
|
|
|
+when !ODIN_DEBUG {
|
|
|
+ // VERSION_1_0
|
|
|
+ CullFace :: #force_inline proc "c" (mode: u32) { impl_CullFace(mode); }
|
|
|
+ FrontFace :: #force_inline proc "c" (mode: u32) { impl_FrontFace(mode); }
|
|
|
+ Hint :: #force_inline proc "c" (target, mode: u32) { impl_Hint(target, mode); }
|
|
|
+ LineWidth :: #force_inline proc "c" (width: f32) { impl_LineWidth(width); }
|
|
|
+ PointSize :: #force_inline proc "c" (size: f32) { impl_PointSize(size); }
|
|
|
+ PolygonMode :: #force_inline proc "c" (face, mode: u32) { impl_PolygonMode(face, mode); }
|
|
|
+ Scissor :: #force_inline proc "c" (x, y, width, height: i32) { impl_Scissor(x, y, width, height); }
|
|
|
+ TexParameterf :: #force_inline proc "c" (target, pname: u32, param: f32) { impl_TexParameterf(target, pname, param); }
|
|
|
+ TexParameterfv :: #force_inline proc "c" (target, pname: u32, params: [^]f32) { impl_TexParameterfv(target, pname, params); }
|
|
|
+ TexParameteri :: #force_inline proc "c" (target, pname: u32, param: i32) { impl_TexParameteri(target, pname, param); }
|
|
|
+ TexParameteriv :: #force_inline proc "c" (target, pname: u32, params: [^]i32) { impl_TexParameteriv(target, pname, params); }
|
|
|
+ TexImage1D :: #force_inline proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr) { impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels); }
|
|
|
+ TexImage2D :: #force_inline proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr) { impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); }
|
|
|
+ DrawBuffer :: #force_inline proc "c" (buf: u32) { impl_DrawBuffer(buf); }
|
|
|
+ Clear :: #force_inline proc "c" (mask: u32) { impl_Clear(mask); }
|
|
|
+ ClearColor :: #force_inline proc "c" (red, green, blue, alpha: f32) { impl_ClearColor(red, green, blue, alpha); }
|
|
|
+ ClearStencil :: #force_inline proc "c" (s: i32) { impl_ClearStencil(s); }
|
|
|
+ ClearDepth :: #force_inline proc "c" (depth: f64) { impl_ClearDepth(depth); }
|
|
|
+ StencilMask :: #force_inline proc "c" (mask: u32) { impl_StencilMask(mask); }
|
|
|
+ ColorMask :: #force_inline proc "c" (red, green, blue, alpha: u8) { impl_ColorMask(red, green, blue, alpha); }
|
|
|
+ DepthMask :: #force_inline proc "c" (flag: u8) { impl_DepthMask(flag); }
|
|
|
+ Disable :: #force_inline proc "c" (cap: u32) { impl_Disable(cap); }
|
|
|
+ Enable :: #force_inline proc "c" (cap: u32) { impl_Enable(cap); }
|
|
|
+ Finish :: #force_inline proc "c" () { impl_Finish(); }
|
|
|
+ Flush :: #force_inline proc "c" () { impl_Flush(); }
|
|
|
+ BlendFunc :: #force_inline proc "c" (sfactor, dfactor: u32) { impl_BlendFunc(sfactor, dfactor); }
|
|
|
+ LogicOp :: #force_inline proc "c" (opcode: u32) { impl_LogicOp(opcode); }
|
|
|
+ StencilFunc :: #force_inline proc "c" (func: u32, ref: i32, mask: u32) { impl_StencilFunc(func, ref, mask); }
|
|
|
+ StencilOp :: #force_inline proc "c" (fail, zfail, zpass: u32) { impl_StencilOp(fail, zfail, zpass); }
|
|
|
+ DepthFunc :: #force_inline proc "c" (func: u32) { impl_DepthFunc(func); }
|
|
|
+ PixelStoref :: #force_inline proc "c" (pname: u32, param: f32) { impl_PixelStoref(pname, param); }
|
|
|
+ PixelStorei :: #force_inline proc "c" (pname: u32, param: i32) { impl_PixelStorei(pname, param); }
|
|
|
+ ReadBuffer :: #force_inline proc "c" (src: u32) { impl_ReadBuffer(src); }
|
|
|
+ ReadPixels :: #force_inline proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr) { impl_ReadPixels(x, y, width, height, format, type, pixels); }
|
|
|
+ GetBooleanv :: #force_inline proc "c" (pname: u32, data: ^bool) { impl_GetBooleanv(pname, data); }
|
|
|
+ GetDoublev :: #force_inline proc "c" (pname: u32, data: ^f64) { impl_GetDoublev(pname, data); }
|
|
|
+ GetError :: #force_inline proc "c" () -> u32 { return impl_GetError(); }
|
|
|
+ GetFloatv :: #force_inline proc "c" (pname: u32, data: ^f32) { impl_GetFloatv(pname, data); }
|
|
|
+ GetIntegerv :: #force_inline proc "c" (pname: u32, data: ^i32) { impl_GetIntegerv(pname, data); }
|
|
|
+ GetString :: #force_inline proc "c" (name: u32) -> cstring { return impl_GetString(name); }
|
|
|
+ GetTexImage :: #force_inline proc "c" (target: u32, level: i32, format, type: u32, pixels: rawptr) { impl_GetTexImage(target, level, format, type, pixels); }
|
|
|
+ GetTexParameterfv :: #force_inline proc "c" (target, pname: u32, params: [^]f32) { impl_GetTexParameterfv(target, pname, params); }
|
|
|
+ GetTexParameteriv :: #force_inline proc "c" (target, pname: u32, params: [^]i32) { impl_GetTexParameteriv(target, pname, params); }
|
|
|
+ GetTexLevelParameterfv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]f32) { impl_GetTexLevelParameterfv(target, level, pname, params); }
|
|
|
+ GetTexLevelParameteriv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]i32) { impl_GetTexLevelParameteriv(target, level, pname, params); }
|
|
|
+ IsEnabled :: #force_inline proc "c" (cap: u32) -> bool { return impl_IsEnabled(cap); }
|
|
|
+ DepthRange :: #force_inline proc "c" (near, far: f64) { impl_DepthRange(near, far); }
|
|
|
+ Viewport :: #force_inline proc "c" (x, y, width, height: i32) { impl_Viewport(x, y, width, height); }
|
|
|
+
|
|
|
+ // VERSION_1_1
|
|
|
+ DrawArrays :: #force_inline proc "c" (mode: u32, first: i32, count: i32) { impl_DrawArrays(mode, first, count); }
|
|
|
+ DrawElements :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr) { impl_DrawElements(mode, count, type, indices); }
|
|
|
+ PolygonOffset :: #force_inline proc "c" (factor: f32, units: f32) { impl_PolygonOffset(factor, units); }
|
|
|
+ CopyTexImage1D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32) { impl_CopyTexImage1D(target, level, internalformat, x, y, width, border); }
|
|
|
+ CopyTexImage2D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32) { impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border); }
|
|
|
+ CopyTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32) { impl_CopyTexSubImage1D(target, level, xoffset, x, y, width); }
|
|
|
+ CopyTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32) { impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); }
|
|
|
+ TexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr) { impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels); }
|
|
|
+ TexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr) { impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); }
|
|
|
+ BindTexture :: #force_inline proc "c" (target: u32, texture: u32) { impl_BindTexture(target, texture); }
|
|
|
+ DeleteTextures :: #force_inline proc "c" (n: i32, textures: [^]u32) { impl_DeleteTextures(n, textures); }
|
|
|
+ GenTextures :: #force_inline proc "c" (n: i32, textures: [^]u32) { impl_GenTextures(n, textures); }
|
|
|
+ IsTexture :: #force_inline proc "c" (texture: u32) -> bool { return impl_IsTexture(texture); }
|
|
|
+
|
|
|
+ // VERSION_1_2
|
|
|
+ DrawRangeElements :: #force_inline proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr) { impl_DrawRangeElements(mode, start, end, count, type, indices); }
|
|
|
+ TexImage3D :: #force_inline proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr) { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); }
|
|
|
+ TexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
|
|
|
+ CopyTexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32) { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); }
|
|
|
+
|
|
|
+ // VERSION_1_3
|
|
|
+ ActiveTexture :: #force_inline proc "c" (texture: u32) { impl_ActiveTexture(texture); }
|
|
|
+ SampleCoverage :: #force_inline proc "c" (value: f32, invert: u8) { impl_SampleCoverage(value, invert); }
|
|
|
+ CompressedTexImage3D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr) { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); }
|
|
|
+ CompressedTexImage2D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr) { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); }
|
|
|
+ CompressedTexImage1D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr) { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); }
|
|
|
+ CompressedTexSubImage3D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
|
|
|
+ CompressedTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); }
|
|
|
+ CompressedTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); }
|
|
|
+ GetCompressedTexImage :: #force_inline proc "c" (target: u32, level: i32, img: rawptr) { impl_GetCompressedTexImage(target, level, img); }
|
|
|
+
|
|
|
+ // VERSION_1_4
|
|
|
+ BlendFuncSeparate :: #force_inline proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32) { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); }
|
|
|
+ MultiDrawArrays :: #force_inline proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32) { impl_MultiDrawArrays(mode, first, count, drawcount); }
|
|
|
+ MultiDrawElements :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32) { impl_MultiDrawElements(mode, count, type, indices, drawcount); }
|
|
|
+ PointParameterf :: #force_inline proc "c" (pname: u32, param: f32) { impl_PointParameterf(pname, param); }
|
|
|
+ PointParameterfv :: #force_inline proc "c" (pname: u32, params: [^]f32) { impl_PointParameterfv(pname, params); }
|
|
|
+ PointParameteri :: #force_inline proc "c" (pname: u32, param: i32) { impl_PointParameteri(pname, param); }
|
|
|
+ PointParameteriv :: #force_inline proc "c" (pname: u32, params: [^]i32) { impl_PointParameteriv(pname, params); }
|
|
|
+ BlendColor :: #force_inline proc "c" (red: f32, green: f32, blue: f32, alpha: f32) { impl_BlendColor(red, green, blue, alpha); }
|
|
|
+ BlendEquation :: #force_inline proc "c" (mode: u32) { impl_BlendEquation(mode); }
|
|
|
+
|
|
|
+ // VERSION_1_5
|
|
|
+ GenQueries :: #force_inline proc "c" (n: i32, ids: [^]u32) { impl_GenQueries(n, ids); }
|
|
|
+ DeleteQueries :: #force_inline proc "c" (n: i32, ids: [^]u32) { impl_DeleteQueries(n, ids); }
|
|
|
+ IsQuery :: #force_inline proc "c" (id: u32) -> bool { ret := impl_IsQuery(id); return ret; }
|
|
|
+ BeginQuery :: #force_inline proc "c" (target: u32, id: u32) { impl_BeginQuery(target, id); }
|
|
|
+ EndQuery :: #force_inline proc "c" (target: u32) { impl_EndQuery(target); }
|
|
|
+ GetQueryiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32) { impl_GetQueryiv(target, pname, params); }
|
|
|
+ GetQueryObjectiv :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i32) { impl_GetQueryObjectiv(id, pname, params); }
|
|
|
+ GetQueryObjectuiv :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u32) { impl_GetQueryObjectuiv(id, pname, params); }
|
|
|
+ BindBuffer :: #force_inline proc "c" (target: u32, buffer: u32) { impl_BindBuffer(target, buffer); }
|
|
|
+ DeleteBuffers :: #force_inline proc "c" (n: i32, buffers: [^]u32) { impl_DeleteBuffers(n, buffers); }
|
|
|
+ GenBuffers :: #force_inline proc "c" (n: i32, buffers: [^]u32) { impl_GenBuffers(n, buffers); }
|
|
|
+ IsBuffer :: #force_inline proc "c" (buffer: u32) -> bool { ret := impl_IsBuffer(buffer); return ret; }
|
|
|
+ BufferData :: #force_inline proc "c" (target: u32, size: int, data: rawptr, usage: u32) { impl_BufferData(target, size, data, usage); }
|
|
|
+ BufferSubData :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr) { impl_BufferSubData(target, offset, size, data); }
|
|
|
+ GetBufferSubData :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr) { impl_GetBufferSubData(target, offset, size, data); }
|
|
|
+ MapBuffer :: #force_inline proc "c" (target: u32, access: u32) -> rawptr { ret := impl_MapBuffer(target, access); return ret; }
|
|
|
+ UnmapBuffer :: #force_inline proc "c" (target: u32) -> bool { ret := impl_UnmapBuffer(target); return ret; }
|
|
|
+ GetBufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32) { impl_GetBufferParameteriv(target, pname, params); }
|
|
|
+ GetBufferPointerv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]rawptr) { impl_GetBufferPointerv(target, pname, params); }
|
|
|
+
|
|
|
+ // VERSION_2_0
|
|
|
+ BlendEquationSeparate :: #force_inline proc "c" (modeRGB: u32, modeAlpha: u32) { impl_BlendEquationSeparate(modeRGB, modeAlpha); }
|
|
|
+ DrawBuffers :: #force_inline proc "c" (n: i32, bufs: [^]u32) { impl_DrawBuffers(n, bufs); }
|
|
|
+ StencilOpSeparate :: #force_inline proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32) { impl_StencilOpSeparate(face, sfail, dpfail, dppass); }
|
|
|
+ StencilFuncSeparate :: #force_inline proc "c" (face: u32, func: u32, ref: i32, mask: u32) { impl_StencilFuncSeparate(face, func, ref, mask); }
|
|
|
+ StencilMaskSeparate :: #force_inline proc "c" (face: u32, mask: u32) { impl_StencilMaskSeparate(face, mask); }
|
|
|
+ AttachShader :: #force_inline proc "c" (program: u32, shader: u32) { impl_AttachShader(program, shader); }
|
|
|
+ BindAttribLocation :: #force_inline proc "c" (program: u32, index: u32, name: cstring) { impl_BindAttribLocation(program, index, name); }
|
|
|
+ CompileShader :: #force_inline proc "c" (shader: u32) { impl_CompileShader(shader); }
|
|
|
+ CreateProgram :: #force_inline proc "c" () -> u32 { ret := impl_CreateProgram(); return ret; }
|
|
|
+ CreateShader :: #force_inline proc "c" (type: u32) -> u32 { ret := impl_CreateShader(type); return ret; }
|
|
|
+ DeleteProgram :: #force_inline proc "c" (program: u32) { impl_DeleteProgram(program); }
|
|
|
+ DeleteShader :: #force_inline proc "c" (shader: u32) { impl_DeleteShader(shader); }
|
|
|
+ DetachShader :: #force_inline proc "c" (program: u32, shader: u32) { impl_DetachShader(program, shader); }
|
|
|
+ DisableVertexAttribArray :: #force_inline proc "c" (index: u32) { impl_DisableVertexAttribArray(index); }
|
|
|
+ EnableVertexAttribArray :: #force_inline proc "c" (index: u32) { impl_EnableVertexAttribArray(index); }
|
|
|
+ GetActiveAttrib :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8) { impl_GetActiveAttrib(program, index, bufSize, length, size, type, name); }
|
|
|
+ GetActiveUniform :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8) { impl_GetActiveUniform(program, index, bufSize, length, size, type, name); }
|
|
|
+ GetAttachedShaders :: #force_inline proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32) { impl_GetAttachedShaders(program, maxCount, count, shaders); }
|
|
|
+ GetAttribLocation :: #force_inline proc "c" (program: u32, name: cstring) -> i32 { ret := impl_GetAttribLocation(program, name); return ret; }
|
|
|
+ GetProgramiv :: #force_inline proc "c" (program: u32, pname: u32, params: [^]i32) { impl_GetProgramiv(program, pname, params); }
|
|
|
+ GetProgramInfoLog :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8) { impl_GetProgramInfoLog(program, bufSize, length, infoLog); }
|
|
|
+ GetShaderiv :: #force_inline proc "c" (shader: u32, pname: u32, params: [^]i32) { impl_GetShaderiv(shader, pname, params); }
|
|
|
+ GetShaderInfoLog :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8) { impl_GetShaderInfoLog(shader, bufSize, length, infoLog); }
|
|
|
+ GetShaderSource :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8) { impl_GetShaderSource(shader, bufSize, length, source); }
|
|
|
+ GetUniformLocation :: #force_inline proc "c" (program: u32, name: cstring) -> i32 { ret := impl_GetUniformLocation(program, name); return ret; }
|
|
|
+ GetUniformfv :: #force_inline proc "c" (program: u32, location: i32, params: [^]f32) { impl_GetUniformfv(program, location, params); }
|
|
|
+ GetUniformiv :: #force_inline proc "c" (program: u32, location: i32, params: [^]i32) { impl_GetUniformiv(program, location, params); }
|
|
|
+ GetVertexAttribdv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64) { impl_GetVertexAttribdv(index, pname, params); }
|
|
|
+ GetVertexAttribfv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f32) { impl_GetVertexAttribfv(index, pname, params); }
|
|
|
+ GetVertexAttribiv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32) { impl_GetVertexAttribiv(index, pname, params); }
|
|
|
+ GetVertexAttribPointerv :: #force_inline proc "c" (index: u32, pname: u32, pointer: ^rawptr) { impl_GetVertexAttribPointerv(index, pname, pointer); }
|
|
|
+ IsProgram :: #force_inline proc "c" (program: u32) -> bool { ret := impl_IsProgram(program); return ret; }
|
|
|
+ IsShader :: #force_inline proc "c" (shader: u32) -> bool { ret := impl_IsShader(shader); return ret; }
|
|
|
+ LinkProgram :: #force_inline proc "c" (program: u32) { impl_LinkProgram(program); }
|
|
|
+ ShaderSource :: #force_inline proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32) { impl_ShaderSource(shader, count, string, length); }
|
|
|
+ UseProgram :: #force_inline proc "c" (program: u32) { impl_UseProgram(program); }
|
|
|
+ Uniform1f :: #force_inline proc "c" (location: i32, v0: f32) { impl_Uniform1f(location, v0); }
|
|
|
+ Uniform2f :: #force_inline proc "c" (location: i32, v0: f32, v1: f32) { impl_Uniform2f(location, v0, v1); }
|
|
|
+ Uniform3f :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32) { impl_Uniform3f(location, v0, v1, v2); }
|
|
|
+ Uniform4f :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32) { impl_Uniform4f(location, v0, v1, v2, v3); }
|
|
|
+ Uniform1i :: #force_inline proc "c" (location: i32, v0: i32) { impl_Uniform1i(location, v0); }
|
|
|
+ Uniform2i :: #force_inline proc "c" (location: i32, v0: i32, v1: i32) { impl_Uniform2i(location, v0, v1); }
|
|
|
+ Uniform3i :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32) { impl_Uniform3i(location, v0, v1, v2); }
|
|
|
+ Uniform4i :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32) { impl_Uniform4i(location, v0, v1, v2, v3); }
|
|
|
+ Uniform1fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32) { impl_Uniform1fv(location, count, value); }
|
|
|
+ Uniform2fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32) { impl_Uniform2fv(location, count, value); }
|
|
|
+ Uniform3fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32) { impl_Uniform3fv(location, count, value); }
|
|
|
+ Uniform4fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32) { impl_Uniform4fv(location, count, value); }
|
|
|
+ Uniform1iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32) { impl_Uniform1iv(location, count, value); }
|
|
|
+ Uniform2iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32) { impl_Uniform2iv(location, count, value); }
|
|
|
+ Uniform3iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32) { impl_Uniform3iv(location, count, value); }
|
|
|
+ Uniform4iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32) { impl_Uniform4iv(location, count, value); }
|
|
|
+ UniformMatrix2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2fv(location, count, transpose, value); }
|
|
|
+ UniformMatrix3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3fv(location, count, transpose, value); }
|
|
|
+ UniformMatrix4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4fv(location, count, transpose, value); }
|
|
|
+ ValidateProgram :: #force_inline proc "c" (program: u32) { impl_ValidateProgram(program); }
|
|
|
+ VertexAttrib1d :: #force_inline proc "c" (index: u32, x: f64) { impl_VertexAttrib1d(index, x); }
|
|
|
+ VertexAttrib1dv :: #force_inline proc "c" (index: u32, v: ^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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+
|
|
|
+
|
|
|
+ // VERSION_3_0
|
|
|
+ ColorMaski :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8) { impl_ColorMaski(index, r, g, b, a); }
|
|
|
+ GetBooleani_v :: #force_inline proc "c" (target: u32, index: u32, data: ^bool) { impl_GetBooleani_v(target, index, data); }
|
|
|
+ GetIntegeri_v :: #force_inline proc "c" (target: u32, index: u32, data: ^i32) { impl_GetIntegeri_v(target, index, data); }
|
|
|
+ Enablei :: #force_inline proc "c" (target: u32, index: u32) { impl_Enablei(target, index); }
|
|
|
+ Disablei :: #force_inline proc "c" (target: u32, index: u32) { impl_Disablei(target, index); }
|
|
|
+ IsEnabledi :: #force_inline proc "c" (target: u32, index: u32) -> bool { ret := impl_IsEnabledi(target, index); return ret; }
|
|
|
+ BeginTransformFeedback :: #force_inline proc "c" (primitiveMode: u32) { impl_BeginTransformFeedback(primitiveMode); }
|
|
|
+ EndTransformFeedback :: #force_inline proc "c" () { impl_EndTransformFeedback(); }
|
|
|
+ BindBufferRange :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int) { impl_BindBufferRange(target, index, buffer, offset, size); }
|
|
|
+ BindBufferBase :: #force_inline proc "c" (target: u32, index: u32, buffer: u32) { impl_BindBufferBase(target, index, buffer); }
|
|
|
+ TransformFeedbackVaryings :: #force_inline proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32) { impl_TransformFeedbackVaryings(program, count, varyings, bufferMode); }
|
|
|
+ GetTransformFeedbackVarying :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8) { impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); }
|
|
|
+ ClampColor :: #force_inline proc "c" (target: u32, clamp: u32) { impl_ClampColor(target, clamp); }
|
|
|
+ BeginConditionalRender :: #force_inline proc "c" (id: u32, mode: u32) { impl_BeginConditionalRender(id, mode); }
|
|
|
+ EndConditionalRender :: #force_inline proc "c" () { impl_EndConditionalRender(); }
|
|
|
+ VertexAttribIPointer :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: rawptr) { impl_VertexAttribIPointer(index, size, type, stride, pointer); }
|
|
|
+ GetVertexAttribIiv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32) { impl_GetVertexAttribIiv(index, pname, params); }
|
|
|
+ GetVertexAttribIuiv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]u32) { impl_GetVertexAttribIuiv(index, pname, params); }
|
|
|
+ VertexAttribI1i :: #force_inline proc "c" (index: u32, x: i32) { impl_VertexAttribI1i(index, x); }
|
|
|
+ VertexAttribI2i :: #force_inline proc "c" (index: u32, x: i32, y: i32) { impl_VertexAttribI2i(index, x, y); }
|
|
|
+ VertexAttribI3i :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32) { impl_VertexAttribI3i(index, x, y, z); }
|
|
|
+ VertexAttribI4i :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32) { impl_VertexAttribI4i(index, x, y, z, w); }
|
|
|
+ VertexAttribI1ui :: #force_inline proc "c" (index: u32, x: u32) { impl_VertexAttribI1ui(index, x); }
|
|
|
+ VertexAttribI2ui :: #force_inline proc "c" (index: u32, x: u32, y: u32) { impl_VertexAttribI2ui(index, x, y); }
|
|
|
+ VertexAttribI3ui :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32) { impl_VertexAttribI3ui(index, x, y, z); }
|
|
|
+ VertexAttribI4ui :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32) { impl_VertexAttribI4ui(index, x, y, z, w); }
|
|
|
+ VertexAttribI1iv :: #force_inline proc "c" (index: u32, v: ^i32) { impl_VertexAttribI1iv(index, v); }
|
|
|
+ VertexAttribI2iv :: #force_inline proc "c" (index: u32, v: ^i32) { impl_VertexAttribI2iv(index, v); }
|
|
|
+ VertexAttribI3iv :: #force_inline proc "c" (index: u32, v: ^i32) { impl_VertexAttribI3iv(index, v); }
|
|
|
+ VertexAttribI4iv :: #force_inline proc "c" (index: u32, v: ^i32) { impl_VertexAttribI4iv(index, v); }
|
|
|
+ VertexAttribI1uiv :: #force_inline proc "c" (index: u32, v: ^u32) { impl_VertexAttribI1uiv(index, v); }
|
|
|
+ VertexAttribI2uiv :: #force_inline proc "c" (index: u32, v: ^u32) { impl_VertexAttribI2uiv(index, v); }
|
|
|
+ VertexAttribI3uiv :: #force_inline proc "c" (index: u32, v: ^u32) { impl_VertexAttribI3uiv(index, v); }
|
|
|
+ VertexAttribI4uiv :: #force_inline proc "c" (index: u32, v: ^u32) { impl_VertexAttribI4uiv(index, v); }
|
|
|
+ VertexAttribI4bv :: #force_inline proc "c" (index: u32, v: ^i8) { impl_VertexAttribI4bv(index, v); }
|
|
|
+ VertexAttribI4sv :: #force_inline proc "c" (index: u32, v: ^i16) { impl_VertexAttribI4sv(index, v); }
|
|
|
+ VertexAttribI4ubv :: #force_inline proc "c" (index: u32, v: ^u8) { impl_VertexAttribI4ubv(index, v); }
|
|
|
+ VertexAttribI4usv :: #force_inline proc "c" (index: u32, v: ^u16) { impl_VertexAttribI4usv(index, v); }
|
|
|
+ GetUniformuiv :: #force_inline proc "c" (program: u32, location: i32, params: [^]u32) { impl_GetUniformuiv(program, location, params); }
|
|
|
+ BindFragDataLocation :: #force_inline proc "c" (program: u32, color: u32, name: cstring) { impl_BindFragDataLocation(program, color, name); }
|
|
|
+ GetFragDataLocation :: #force_inline proc "c" (program: u32, name: cstring) -> i32 { ret := impl_GetFragDataLocation(program, name); return ret; }
|
|
|
+ Uniform1ui :: #force_inline proc "c" (location: i32, v0: u32) { impl_Uniform1ui(location, v0); }
|
|
|
+ Uniform2ui :: #force_inline proc "c" (location: i32, v0: u32, v1: u32) { impl_Uniform2ui(location, v0, v1); }
|
|
|
+ Uniform3ui :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32) { impl_Uniform3ui(location, v0, v1, v2); }
|
|
|
+ Uniform4ui :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32) { impl_Uniform4ui(location, v0, v1, v2, v3); }
|
|
|
+ Uniform1uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32) { impl_Uniform1uiv(location, count, value); }
|
|
|
+ Uniform2uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32) { impl_Uniform2uiv(location, count, value); }
|
|
|
+ Uniform3uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32) { impl_Uniform3uiv(location, count, value); }
|
|
|
+ Uniform4uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32) { impl_Uniform4uiv(location, count, value); }
|
|
|
+ TexParameterIiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32) { impl_TexParameterIiv(target, pname, params); }
|
|
|
+ TexParameterIuiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32) { impl_TexParameterIuiv(target, pname, params); }
|
|
|
+ GetTexParameterIiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32) { impl_GetTexParameterIiv(target, pname, params); }
|
|
|
+ GetTexParameterIuiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32) { impl_GetTexParameterIuiv(target, pname, params); }
|
|
|
+ ClearBufferiv :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^i32) { impl_ClearBufferiv(buffer, drawbuffer, value); }
|
|
|
+ ClearBufferuiv :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^u32) { impl_ClearBufferuiv(buffer, drawbuffer, value); }
|
|
|
+ ClearBufferfv :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^f32) { impl_ClearBufferfv(buffer, drawbuffer, value); }
|
|
|
+ ClearBufferfi :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> rawptr { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil); return ret; }
|
|
|
+ GetStringi :: #force_inline proc "c" (name: u32, index: u32) -> cstring { ret := impl_GetStringi(name, index); return ret; }
|
|
|
+ IsRenderbuffer :: #force_inline proc "c" (renderbuffer: u32) -> bool { ret := impl_IsRenderbuffer(renderbuffer); return ret; }
|
|
|
+ BindRenderbuffer :: #force_inline proc "c" (target: u32, renderbuffer: u32) { impl_BindRenderbuffer(target, renderbuffer); }
|
|
|
+ DeleteRenderbuffers :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32) { impl_DeleteRenderbuffers(n, renderbuffers); }
|
|
|
+ GenRenderbuffers :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32) { impl_GenRenderbuffers(n, renderbuffers); }
|
|
|
+ RenderbufferStorage :: #force_inline proc "c" (target: u32, internalformat: u32, width: i32, height: i32) { impl_RenderbufferStorage(target, internalformat, width, height); }
|
|
|
+ GetRenderbufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32) { impl_GetRenderbufferParameteriv(target, pname, params); }
|
|
|
+ IsFramebuffer :: #force_inline proc "c" (framebuffer: u32) -> bool { ret := impl_IsFramebuffer(framebuffer); return ret; }
|
|
|
+ BindFramebuffer :: #force_inline proc "c" (target: u32, framebuffer: u32) { impl_BindFramebuffer(target, framebuffer); }
|
|
|
+ DeleteFramebuffers :: #force_inline proc "c" (n: i32, framebuffers: [^]u32) { impl_DeleteFramebuffers(n, framebuffers); }
|
|
|
+ GenFramebuffers :: #force_inline proc "c" (n: i32, framebuffers: [^]u32) { impl_GenFramebuffers(n, framebuffers); }
|
|
|
+ CheckFramebufferStatus :: #force_inline proc "c" (target: u32) -> u32 { ret := impl_CheckFramebufferStatus(target); return ret; }
|
|
|
+ FramebufferTexture1D :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32) { impl_FramebufferTexture1D(target, attachment, textarget, texture, level); }
|
|
|
+ FramebufferTexture2D :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32) { impl_FramebufferTexture2D(target, attachment, textarget, texture, level); }
|
|
|
+ FramebufferTexture3D :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32) { impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); }
|
|
|
+ FramebufferRenderbuffer :: #force_inline proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32) { impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); }
|
|
|
+ GetFramebufferAttachmentParameteriv :: #force_inline proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32) { impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params); }
|
|
|
+ GenerateMipmap :: #force_inline proc "c" (target: u32) { impl_GenerateMipmap(target); }
|
|
|
+ BlitFramebuffer :: #force_inline proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) { impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); }
|
|
|
+ RenderbufferStorageMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32) { impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height); }
|
|
|
+ FramebufferTextureLayer :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32) { impl_FramebufferTextureLayer(target, attachment, texture, level, layer); }
|
|
|
+ MapBufferRange :: #force_inline proc "c" (target: u32, offset: int, length: int, access: u32) -> rawptr { ret := impl_MapBufferRange(target, offset, length, access); return ret; }
|
|
|
+ FlushMappedBufferRange :: #force_inline proc "c" (target: u32, offset: int, length: int) { impl_FlushMappedBufferRange(target, offset, length); }
|
|
|
+ BindVertexArray :: #force_inline proc "c" (array: u32) { impl_BindVertexArray(array); }
|
|
|
+ DeleteVertexArrays :: #force_inline proc "c" (n: i32, arrays: [^]u32) { impl_DeleteVertexArrays(n, arrays); }
|
|
|
+ GenVertexArrays :: #force_inline proc "c" (n: i32, arrays: [^]u32) { impl_GenVertexArrays(n, arrays); }
|
|
|
+ IsVertexArray :: #force_inline proc "c" (array: u32) -> bool { ret := impl_IsVertexArray(array); return ret; }
|
|
|
+
|
|
|
+ // VERSION_3_1
|
|
|
+ DrawArraysInstanced :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32) { impl_DrawArraysInstanced(mode, first, count, instancecount); }
|
|
|
+ DrawElementsInstanced :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32) { impl_DrawElementsInstanced(mode, count, type, indices, instancecount); }
|
|
|
+ TexBuffer :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32) { impl_TexBuffer(target, internalformat, buffer); }
|
|
|
+ PrimitiveRestartIndex :: #force_inline proc "c" (index: u32) { impl_PrimitiveRestartIndex(index); }
|
|
|
+ CopyBufferSubData :: #force_inline proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int) { impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); }
|
|
|
+ GetUniformIndices :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32) { impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices); }
|
|
|
+ GetActiveUniformsiv :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32) { impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); }
|
|
|
+ GetActiveUniformName :: #force_inline proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8) { impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); }
|
|
|
+ GetUniformBlockIndex :: #force_inline proc "c" (program: u32, uniformBlockName: cstring) -> u32 { ret := impl_GetUniformBlockIndex(program, uniformBlockName); return ret; }
|
|
|
+ GetActiveUniformBlockiv :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32) { impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); }
|
|
|
+ GetActiveUniformBlockName :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8) { impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); }
|
|
|
+ UniformBlockBinding :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32) { impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); }
|
|
|
+
|
|
|
+ // VERSION_3_2
|
|
|
+ DrawElementsBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32) { impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex); }
|
|
|
+ DrawRangeElementsBaseVertex :: #force_inline proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32) { impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); }
|
|
|
+ DrawElementsInstancedBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32) { impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); }
|
|
|
+ MultiDrawElementsBaseVertex :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32) { impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex); }
|
|
|
+ ProvokingVertex :: #force_inline proc "c" (mode: u32) { impl_ProvokingVertex(mode); }
|
|
|
+ FenceSync :: #force_inline proc "c" (condition: u32, flags: u32) -> sync_t { ret := impl_FenceSync(condition, flags); return ret; }
|
|
|
+ IsSync :: #force_inline proc "c" (sync: sync_t) -> bool { ret := impl_IsSync(sync); return ret; }
|
|
|
+ DeleteSync :: #force_inline proc "c" (sync: sync_t) { impl_DeleteSync(sync); }
|
|
|
+ ClientWaitSync :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64) -> u32 { ret := impl_ClientWaitSync(sync, flags, timeout); return ret; }
|
|
|
+ WaitSync :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64) { impl_WaitSync(sync, flags, timeout); }
|
|
|
+ GetInteger64v :: #force_inline proc "c" (pname: u32, data: ^i64) { impl_GetInteger64v(pname, data); }
|
|
|
+ GetSynciv :: #force_inline proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32) { impl_GetSynciv(sync, pname, bufSize, length, values); }
|
|
|
+ GetInteger64i_v :: #force_inline proc "c" (target: u32, index: u32, data: ^i64) { impl_GetInteger64i_v(target, index, data); }
|
|
|
+ GetBufferParameteri64v :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i64) { impl_GetBufferParameteri64v(target, pname, params); }
|
|
|
+ FramebufferTexture :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32) { impl_FramebufferTexture(target, attachment, texture, level); }
|
|
|
+ TexImage2DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8) { impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); }
|
|
|
+ TexImage3DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8) { impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); }
|
|
|
+ GetMultisamplefv :: #force_inline proc "c" (pname: u32, index: u32, val: ^f32) { impl_GetMultisamplefv(pname, index, val); }
|
|
|
+ SampleMaski :: #force_inline proc "c" (maskNumber: u32, mask: u32) { impl_SampleMaski(maskNumber, mask); }
|
|
|
+
|
|
|
+ // VERSION_3_3
|
|
|
+ BindFragDataLocationIndexed :: #force_inline proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring) { impl_BindFragDataLocationIndexed(program, colorNumber, index, name); }
|
|
|
+ GetFragDataIndex :: #force_inline proc "c" (program: u32, name: cstring) -> i32 { ret := impl_GetFragDataIndex(program, name); return ret; }
|
|
|
+ GenSamplers :: #force_inline proc "c" (count: i32, samplers: [^]u32) { impl_GenSamplers(count, samplers); }
|
|
|
+ DeleteSamplers :: #force_inline proc "c" (count: i32, samplers: [^]u32) { impl_DeleteSamplers(count, samplers); }
|
|
|
+ IsSampler :: #force_inline proc "c" (sampler: u32) -> bool { ret := impl_IsSampler(sampler); return ret; }
|
|
|
+ BindSampler :: #force_inline proc "c" (unit: u32, sampler: u32) { impl_BindSampler(unit, sampler); }
|
|
|
+ SamplerParameteri :: #force_inline proc "c" (sampler: u32, pname: u32, param: i32) { impl_SamplerParameteri(sampler, pname, param); }
|
|
|
+ SamplerParameteriv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32) { impl_SamplerParameteriv(sampler, pname, param); }
|
|
|
+ SamplerParameterf :: #force_inline proc "c" (sampler: u32, pname: u32, param: f32) { impl_SamplerParameterf(sampler, pname, param); }
|
|
|
+ SamplerParameterfv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^f32) { impl_SamplerParameterfv(sampler, pname, param); }
|
|
|
+ SamplerParameterIiv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32) { impl_SamplerParameterIiv(sampler, pname, param); }
|
|
|
+ SamplerParameterIuiv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^u32) { impl_SamplerParameterIuiv(sampler, pname, param); }
|
|
|
+ GetSamplerParameteriv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32) { impl_GetSamplerParameteriv(sampler, pname, params); }
|
|
|
+ GetSamplerParameterIiv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32) { impl_GetSamplerParameterIiv(sampler, pname, params); }
|
|
|
+ GetSamplerParameterfv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]f32) { impl_GetSamplerParameterfv(sampler, pname, params); }
|
|
|
+ GetSamplerParameterIuiv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]u32) { impl_GetSamplerParameterIuiv(sampler, pname, params); }
|
|
|
+ QueryCounter :: #force_inline proc "c" (id: u32, target: u32) { impl_QueryCounter(id, target); }
|
|
|
+ GetQueryObjecti64v :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i64) { impl_GetQueryObjecti64v(id, pname, params); }
|
|
|
+ GetQueryObjectui64v :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u64) { impl_GetQueryObjectui64v(id, pname, params); }
|
|
|
+ VertexAttribDivisor :: #force_inline proc "c" (index: u32, divisor: u32) { impl_VertexAttribDivisor(index, divisor); }
|
|
|
+ VertexAttribP1ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32) { impl_VertexAttribP1ui(index, type, normalized, value); }
|
|
|
+ VertexAttribP1uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32) { impl_VertexAttribP1uiv(index, type, normalized, value); }
|
|
|
+ VertexAttribP2ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32) { impl_VertexAttribP2ui(index, type, normalized, value); }
|
|
|
+ VertexAttribP2uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32) { impl_VertexAttribP2uiv(index, type, normalized, value); }
|
|
|
+ VertexAttribP3ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32) { impl_VertexAttribP3ui(index, type, normalized, value); }
|
|
|
+ VertexAttribP3uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32) { impl_VertexAttribP3uiv(index, type, normalized, value); }
|
|
|
+ VertexAttribP4ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32) { impl_VertexAttribP4ui(index, type, normalized, value); }
|
|
|
+ VertexAttribP4uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32) { impl_VertexAttribP4uiv(index, type, normalized, value); }
|
|
|
+ VertexP2ui :: #force_inline proc "c" (type: u32, value: u32) { impl_VertexP2ui(type, value); }
|
|
|
+ VertexP2uiv :: #force_inline proc "c" (type: u32, value: ^u32) { impl_VertexP2uiv(type, value); }
|
|
|
+ VertexP3ui :: #force_inline proc "c" (type: u32, value: u32) { impl_VertexP3ui(type, value); }
|
|
|
+ VertexP3uiv :: #force_inline proc "c" (type: u32, value: ^u32) { impl_VertexP3uiv(type, value); }
|
|
|
+ VertexP4ui :: #force_inline proc "c" (type: u32, value: u32) { impl_VertexP4ui(type, value); }
|
|
|
+ VertexP4uiv :: #force_inline proc "c" (type: u32, value: ^u32) { impl_VertexP4uiv(type, value); }
|
|
|
+ TexCoordP1ui :: #force_inline proc "c" (type: u32, coords: u32) { impl_TexCoordP1ui(type, coords); }
|
|
|
+ TexCoordP1uiv :: #force_inline proc "c" (type: u32, coords: [^]u32) { impl_TexCoordP1uiv(type, coords); }
|
|
|
+ TexCoordP2ui :: #force_inline proc "c" (type: u32, coords: u32) { impl_TexCoordP2ui(type, coords); }
|
|
|
+ TexCoordP2uiv :: #force_inline proc "c" (type: u32, coords: [^]u32) { impl_TexCoordP2uiv(type, coords); }
|
|
|
+ TexCoordP3ui :: #force_inline proc "c" (type: u32, coords: u32) { impl_TexCoordP3ui(type, coords); }
|
|
|
+ TexCoordP3uiv :: #force_inline proc "c" (type: u32, coords: [^]u32) { impl_TexCoordP3uiv(type, coords); }
|
|
|
+ TexCoordP4ui :: #force_inline proc "c" (type: u32, coords: u32) { impl_TexCoordP4ui(type, coords); }
|
|
|
+ TexCoordP4uiv :: #force_inline proc "c" (type: u32, coords: [^]u32) { impl_TexCoordP4uiv(type, coords); }
|
|
|
+ MultiTexCoordP1ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32) { impl_MultiTexCoordP1ui(texture, type, coords); }
|
|
|
+ MultiTexCoordP1uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32) { impl_MultiTexCoordP1uiv(texture, type, coords); }
|
|
|
+ MultiTexCoordP2ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32) { impl_MultiTexCoordP2ui(texture, type, coords); }
|
|
|
+ MultiTexCoordP2uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32) { impl_MultiTexCoordP2uiv(texture, type, coords); }
|
|
|
+ MultiTexCoordP3ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32) { impl_MultiTexCoordP3ui(texture, type, coords); }
|
|
|
+ MultiTexCoordP3uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32) { impl_MultiTexCoordP3uiv(texture, type, coords); }
|
|
|
+ MultiTexCoordP4ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32) { impl_MultiTexCoordP4ui(texture, type, coords); }
|
|
|
+ MultiTexCoordP4uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32) { impl_MultiTexCoordP4uiv(texture, type, coords); }
|
|
|
+ NormalP3ui :: #force_inline proc "c" (type: u32, coords: u32) { impl_NormalP3ui(type, coords); }
|
|
|
+ NormalP3uiv :: #force_inline proc "c" (type: u32, coords: [^]u32) { impl_NormalP3uiv(type, coords); }
|
|
|
+ ColorP3ui :: #force_inline proc "c" (type: u32, color: u32) { impl_ColorP3ui(type, color); }
|
|
|
+ ColorP3uiv :: #force_inline proc "c" (type: u32, color: ^u32) { impl_ColorP3uiv(type, color); }
|
|
|
+ ColorP4ui :: #force_inline proc "c" (type: u32, color: u32) { impl_ColorP4ui(type, color); }
|
|
|
+ ColorP4uiv :: #force_inline proc "c" (type: u32, color: ^u32) { impl_ColorP4uiv(type, color); }
|
|
|
+ SecondaryColorP3ui :: #force_inline proc "c" (type: u32, color: u32) { impl_SecondaryColorP3ui(type, color); }
|
|
|
+ SecondaryColorP3uiv :: #force_inline proc "c" (type: u32, color: ^u32) { impl_SecondaryColorP3uiv(type, color); }
|
|
|
+
|
|
|
+ // VERSION_4_0
|
|
|
+ MinSampleShading :: #force_inline proc "c" (value: f32) { impl_MinSampleShading(value); }
|
|
|
+ BlendEquationi :: #force_inline proc "c" (buf: u32, mode: u32) { impl_BlendEquationi(buf, mode); }
|
|
|
+ BlendEquationSeparatei :: #force_inline proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32) { impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha); }
|
|
|
+ BlendFunci :: #force_inline proc "c" (buf: u32, src: u32, dst: u32) { impl_BlendFunci(buf, src, dst); }
|
|
|
+ BlendFuncSeparatei :: #force_inline proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32) { impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); }
|
|
|
+ DrawArraysIndirect :: #force_inline proc "c" (mode: u32, indirect: rawptr) { impl_DrawArraysIndirect(mode, indirect); }
|
|
|
+ DrawElementsIndirect :: #force_inline proc "c" (mode: u32, type: u32, indirect: rawptr) { impl_DrawElementsIndirect(mode, type, indirect); }
|
|
|
+ Uniform1d :: #force_inline proc "c" (location: i32, x: f64) { impl_Uniform1d(location, x); }
|
|
|
+ Uniform2d :: #force_inline proc "c" (location: i32, x: f64, y: f64) { impl_Uniform2d(location, x, y); }
|
|
|
+ Uniform3d :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64) { impl_Uniform3d(location, x, y, z); }
|
|
|
+ Uniform4d :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64) { impl_Uniform4d(location, x, y, z, w); }
|
|
|
+ Uniform1dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64) { impl_Uniform1dv(location, count, value); }
|
|
|
+ Uniform2dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64) { impl_Uniform2dv(location, count, value); }
|
|
|
+ Uniform3dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64) { impl_Uniform3dv(location, count, value); }
|
|
|
+ Uniform4dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64) { impl_Uniform4dv(location, count, value); }
|
|
|
+ UniformMatrix2dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix2dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix3dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix3dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix4dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix4dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix2x3dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix2x3dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix2x4dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix2x4dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix3x2dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix3x2dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix3x4dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix3x4dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix4x2dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix4x2dv(location, count, transpose, value); }
|
|
|
+ UniformMatrix4x3dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64) { impl_UniformMatrix4x3dv(location, count, transpose, value); }
|
|
|
+ GetUniformdv :: #force_inline proc "c" (program: u32, location: i32, params: [^]f64) { impl_GetUniformdv(program, location, params); }
|
|
|
+ GetSubroutineUniformLocation :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring) -> i32 { ret := impl_GetSubroutineUniformLocation(program, shadertype, name); return ret; }
|
|
|
+ GetSubroutineIndex :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring) -> u32 { ret := impl_GetSubroutineIndex(program, shadertype, name); return ret; }
|
|
|
+ GetActiveSubroutineUniformiv :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32) { impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values); }
|
|
|
+ GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) { impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); }
|
|
|
+ GetActiveSubroutineName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) { impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name); }
|
|
|
+ UniformSubroutinesuiv :: #force_inline proc "c" (shadertype: u32, count: i32, indices: ^u32) { impl_UniformSubroutinesuiv(shadertype, count, indices); }
|
|
|
+ GetUniformSubroutineuiv :: #force_inline proc "c" (shadertype: u32, location: i32, params: [^]u32) { impl_GetUniformSubroutineuiv(shadertype, location, params); }
|
|
|
+ GetProgramStageiv :: #force_inline proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32) { impl_GetProgramStageiv(program, shadertype, pname, values); }
|
|
|
+ PatchParameteri :: #force_inline proc "c" (pname: u32, value: i32) { impl_PatchParameteri(pname, value); }
|
|
|
+ PatchParameterfv :: #force_inline proc "c" (pname: u32, values: [^]f32) { impl_PatchParameterfv(pname, values); }
|
|
|
+ BindTransformFeedback :: #force_inline proc "c" (target: u32, id: u32) { impl_BindTransformFeedback(target, id); }
|
|
|
+ DeleteTransformFeedbacks :: #force_inline proc "c" (n: i32, ids: [^]u32) { impl_DeleteTransformFeedbacks(n, ids); }
|
|
|
+ GenTransformFeedbacks :: #force_inline proc "c" (n: i32, ids: [^]u32) { impl_GenTransformFeedbacks(n, ids); }
|
|
|
+ IsTransformFeedback :: #force_inline proc "c" (id: u32) -> bool { ret := impl_IsTransformFeedback(id); return ret; }
|
|
|
+ PauseTransformFeedback :: #force_inline proc "c" () { impl_PauseTransformFeedback(); }
|
|
|
+ ResumeTransformFeedback :: #force_inline proc "c" () { impl_ResumeTransformFeedback(); }
|
|
|
+ DrawTransformFeedback :: #force_inline proc "c" (mode: u32, id: u32) { impl_DrawTransformFeedback(mode, id); }
|
|
|
+ DrawTransformFeedbackStream :: #force_inline proc "c" (mode: u32, id: u32, stream: u32) { impl_DrawTransformFeedbackStream(mode, id, stream); }
|
|
|
+ BeginQueryIndexed :: #force_inline proc "c" (target: u32, index: u32, id: u32) { impl_BeginQueryIndexed(target, index, id); }
|
|
|
+ EndQueryIndexed :: #force_inline proc "c" (target: u32, index: u32) { impl_EndQueryIndexed(target, index); }
|
|
|
+ GetQueryIndexediv :: #force_inline proc "c" (target: u32, index: u32, pname: u32, params: [^]i32) { impl_GetQueryIndexediv(target, index, pname, params); }
|
|
|
+
|
|
|
+ // VERSION_4_1
|
|
|
+ ReleaseShaderCompiler :: #force_inline proc "c" () { impl_ReleaseShaderCompiler(); }
|
|
|
+ ShaderBinary :: #force_inline proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32) { impl_ShaderBinary(count, shaders, binaryformat, binary, length); }
|
|
|
+ GetShaderPrecisionFormat :: #force_inline proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32) { impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); }
|
|
|
+ DepthRangef :: #force_inline proc "c" (n: f32, f: f32) { impl_DepthRangef(n, f); }
|
|
|
+ ClearDepthf :: #force_inline proc "c" (d: f32) { impl_ClearDepthf(d); }
|
|
|
+ GetProgramBinary :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr) { impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary); }
|
|
|
+ ProgramBinary :: #force_inline proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32) { impl_ProgramBinary(program, binaryFormat, binary, length); }
|
|
|
+ ProgramParameteri :: #force_inline proc "c" (program: u32, pname: u32, value: i32) { impl_ProgramParameteri(program, pname, value); }
|
|
|
+ UseProgramStages :: #force_inline proc "c" (pipeline: u32, stages: u32, program: u32) { impl_UseProgramStages(pipeline, stages, program); }
|
|
|
+ ActiveShaderProgram :: #force_inline proc "c" (pipeline: u32, program: u32) { impl_ActiveShaderProgram(pipeline, program); }
|
|
|
+ CreateShaderProgramv :: #force_inline proc "c" (type: u32, count: i32, strings: [^]cstring) -> u32 { ret := impl_CreateShaderProgramv(type, count, strings); return ret; }
|
|
|
+ BindProgramPipeline :: #force_inline proc "c" (pipeline: u32) { impl_BindProgramPipeline(pipeline); }
|
|
|
+ DeleteProgramPipelines :: #force_inline proc "c" (n: i32, pipelines: [^]u32) { impl_DeleteProgramPipelines(n, pipelines); }
|
|
|
+ GenProgramPipelines :: #force_inline proc "c" (n: i32, pipelines: [^]u32) { impl_GenProgramPipelines(n, pipelines); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ ProgramUniform1ui :: #force_inline proc "c" (program: u32, location: i32, v0: u32) { impl_ProgramUniform1ui(program, location, v0); }
|
|
|
+ ProgramUniform1uiv :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32) { impl_ProgramUniform1uiv(program, location, count, value); }
|
|
|
+ ProgramUniform2i :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32) { impl_ProgramUniform2i(program, location, v0, v1); }
|
|
|
+ ProgramUniform2iv :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+
|
|
|
+ // 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); }
|
|
|
+ DrawElementsInstancedBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32) { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); }
|
|
|
+ DrawElementsInstancedBaseVertexBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); }
|
|
|
+ GetInternalformativ :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32) { impl_GetInternalformativ(target, internalformat, pname, bufSize, params); }
|
|
|
+ GetActiveAtomicCounterBufferiv :: #force_inline proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32) { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); }
|
|
|
+ BindImageTexture :: #force_inline proc "c" (unit: u32, texture: u32, level: i32, layered: u8, layer: i32, access: u32, format: u32) { impl_BindImageTexture(unit, texture, level, layered, layer, access, format); }
|
|
|
+ MemoryBarrier :: #force_inline proc "c" (barriers: u32) { impl_MemoryBarrier(barriers); }
|
|
|
+ TexStorage1D :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32) { impl_TexStorage1D(target, levels, internalformat, width); }
|
|
|
+ TexStorage2D :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32) { impl_TexStorage2D(target, levels, internalformat, width, height); }
|
|
|
+ TexStorage3D :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32) { impl_TexStorage3D(target, levels, internalformat, width, height, depth); }
|
|
|
+ DrawTransformFeedbackInstanced :: #force_inline proc "c" (mode: u32, id: u32, instancecount: i32) { impl_DrawTransformFeedbackInstanced(mode, id, instancecount); }
|
|
|
+ DrawTransformFeedbackStreamInstanced :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32) { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); }
|
|
|
+
|
|
|
+ // VERSION_4_3
|
|
|
+ ClearBufferData :: #force_inline proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr) { impl_ClearBufferData(target, internalformat, format, type, data); }
|
|
|
+ ClearBufferSubData :: #force_inline proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr) { impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data); }
|
|
|
+ DispatchCompute :: #force_inline proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32) { impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z); }
|
|
|
+ DispatchComputeIndirect :: #force_inline proc "c" (indirect: int) { impl_DispatchComputeIndirect(indirect); }
|
|
|
+ CopyImageSubData :: #force_inline proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32) { impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); }
|
|
|
+ FramebufferParameteri :: #force_inline proc "c" (target: u32, pname: u32, param: i32) { impl_FramebufferParameteri(target, pname, param); }
|
|
|
+ GetFramebufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32) { impl_GetFramebufferParameteriv(target, pname, params); }
|
|
|
+ GetInternalformati64v :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64) { impl_GetInternalformati64v(target, internalformat, pname, bufSize, params); }
|
|
|
+ InvalidateTexSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32) { impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth); }
|
|
|
+ InvalidateTexImage :: #force_inline proc "c" (texture: u32, level: i32) { impl_InvalidateTexImage(texture, level); }
|
|
|
+ InvalidateBufferSubData :: #force_inline proc "c" (buffer: u32, offset: int, length: int) { impl_InvalidateBufferSubData(buffer, offset, length); }
|
|
|
+ InvalidateBufferData :: #force_inline proc "c" (buffer: u32) { impl_InvalidateBufferData(buffer); }
|
|
|
+ InvalidateFramebuffer :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32) { impl_InvalidateFramebuffer(target, numAttachments, attachments); }
|
|
|
+ InvalidateSubFramebuffer :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32) { impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); }
|
|
|
+ MultiDrawArraysIndirect :: #force_inline proc "c" (mode: u32, indirect: rawptr, drawcount: i32, stride: i32) { impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride); }
|
|
|
+ MultiDrawElementsIndirect :: #force_inline proc "c" (mode: u32, type: u32, indirect: rawptr, drawcount: i32, stride: i32) { impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride); }
|
|
|
+ GetProgramInterfaceiv :: #force_inline proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32) { impl_GetProgramInterfaceiv(program, programInterface, pname, params); }
|
|
|
+ GetProgramResourceIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring) -> u32 { ret := impl_GetProgramResourceIndex(program, programInterface, name) ; return ret; }
|
|
|
+ GetProgramResourceName :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8) { impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name); }
|
|
|
+ GetProgramResourceiv :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32) { impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); }
|
|
|
+ GetProgramResourceLocation :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring) -> i32 { ret := impl_GetProgramResourceLocation(program, programInterface, name); return ret; }
|
|
|
+ GetProgramResourceLocationIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring) -> i32 { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name); return ret; }
|
|
|
+ ShaderStorageBlockBinding :: #force_inline proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32) { impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); }
|
|
|
+ TexBufferRange :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int) { impl_TexBufferRange(target, internalformat, buffer, offset, size); }
|
|
|
+ TexStorage2DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8) { impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); }
|
|
|
+ TexStorage3DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8) { impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); }
|
|
|
+ TextureView :: #force_inline proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32) { impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); }
|
|
|
+ BindVertexBuffer :: #force_inline proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32) { impl_BindVertexBuffer(bindingindex, buffer, offset, stride); }
|
|
|
+ VertexAttribFormat :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32) { impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset); }
|
|
|
+ VertexAttribIFormat :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32) { impl_VertexAttribIFormat(attribindex, size, type, relativeoffset); }
|
|
|
+ VertexAttribLFormat :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32) { impl_VertexAttribLFormat(attribindex, size, type, relativeoffset); }
|
|
|
+ VertexAttribBinding :: #force_inline proc "c" (attribindex: u32, bindingindex: u32) { impl_VertexAttribBinding(attribindex, bindingindex); }
|
|
|
+ VertexBindingDivisor :: #force_inline proc "c" (bindingindex: u32, divisor: u32) { impl_VertexBindingDivisor(bindingindex, divisor); }
|
|
|
+ DebugMessageControl :: #force_inline proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: u8) { impl_DebugMessageControl(source, type, severity, count, ids, enabled); }
|
|
|
+ DebugMessageInsert :: #force_inline proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, buf: ^u8) { impl_DebugMessageInsert(source, type, id, severity, length, buf); }
|
|
|
+ DebugMessageCallback :: #force_inline proc "c" (callback: debug_proc_t, userParam: rawptr) { impl_DebugMessageCallback(callback, userParam); }
|
|
|
+ GetDebugMessageLog :: #force_inline proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8) -> u32 { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog); return ret; }
|
|
|
+ PushDebugGroup :: #force_inline proc "c" (source: u32, id: u32, length: i32, message: cstring) { impl_PushDebugGroup(source, id, length, message); }
|
|
|
+ PopDebugGroup :: #force_inline proc "c" () { impl_PopDebugGroup(); }
|
|
|
+ ObjectLabel :: #force_inline proc "c" (identifier: u32, name: u32, length: i32, label: [^]u8) { impl_ObjectLabel(identifier, name, length, label); }
|
|
|
+ GetObjectLabel :: #force_inline proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8) { impl_GetObjectLabel(identifier, name, bufSize, length, label); }
|
|
|
+ ObjectPtrLabel :: #force_inline proc "c" (ptr: rawptr, length: i32, label: [^]u8) { impl_ObjectPtrLabel(ptr, length, label); }
|
|
|
+ GetObjectPtrLabel :: #force_inline proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8) { impl_GetObjectPtrLabel(ptr, bufSize, length, label); }
|
|
|
+
|
|
|
+ // VERSION_4_4
|
|
|
+ BufferStorage :: #force_inline proc "c" (target: u32, size: int, data: rawptr, flags: u32) { impl_BufferStorage(target, size, data, flags); }
|
|
|
+ ClearTexImage :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr) { impl_ClearTexImage(texture, level, format, type, data); }
|
|
|
+ ClearTexSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); }
|
|
|
+ BindBuffersBase :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32) { impl_BindBuffersBase(target, first, count, buffers); }
|
|
|
+ BindBuffersRange :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int) { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes); }
|
|
|
+ BindTextures :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32) { impl_BindTextures(first, count, textures); }
|
|
|
+ BindSamplers :: #force_inline proc "c" (first: u32, count: i32, samplers: [^]u32) { impl_BindSamplers(first, count, samplers); }
|
|
|
+ BindImageTextures :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32) { impl_BindImageTextures(first, count, textures); }
|
|
|
+ BindVertexBuffers :: #force_inline proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32) { impl_BindVertexBuffers(first, count, buffers, offsets, strides); }
|
|
|
+
|
|
|
+ // VERSION_4_5
|
|
|
+ ClipControl :: #force_inline proc "c" (origin: u32, depth: u32) { impl_ClipControl(origin, depth); }
|
|
|
+ CreateTransformFeedbacks :: #force_inline proc "c" (n: i32, ids: [^]u32) { impl_CreateTransformFeedbacks(n, ids); }
|
|
|
+ TransformFeedbackBufferBase :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32) { impl_TransformFeedbackBufferBase(xfb, index, buffer); }
|
|
|
+ TransformFeedbackBufferRange :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int) { impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size); }
|
|
|
+ GetTransformFeedbackiv :: #force_inline proc "c" (xfb: u32, pname: u32, param: ^i32) { impl_GetTransformFeedbackiv(xfb, pname, param); }
|
|
|
+ GetTransformFeedbacki_v :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32) { impl_GetTransformFeedbacki_v(xfb, pname, index, param); }
|
|
|
+ GetTransformFeedbacki64_v :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64) { impl_GetTransformFeedbacki64_v(xfb, pname, index, param); }
|
|
|
+ CreateBuffers :: #force_inline proc "c" (n: i32, buffers: [^]u32) { impl_CreateBuffers(n, buffers); }
|
|
|
+ NamedBufferStorage :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, flags: u32) { impl_NamedBufferStorage(buffer, size, data, flags); }
|
|
|
+ NamedBufferData :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, usage: u32) { impl_NamedBufferData(buffer, size, data, usage); }
|
|
|
+ NamedBufferSubData :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr) { impl_NamedBufferSubData(buffer, offset, size, data); }
|
|
|
+ CopyNamedBufferSubData :: #force_inline proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int) { impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size); }
|
|
|
+ ClearNamedBufferData :: #force_inline proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr) { impl_ClearNamedBufferData(buffer, internalformat, format, type, data); }
|
|
|
+ ClearNamedBufferSubData :: #force_inline proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr) { impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data); }
|
|
|
+ MapNamedBuffer :: #force_inline proc "c" (buffer: u32, access: u32) -> rawptr { ret := impl_MapNamedBuffer(buffer, access); return ret; }
|
|
|
+ MapNamedBufferRange :: #force_inline proc "c" (buffer: u32, offset: int, length: int, access: u32) -> rawptr { ret := impl_MapNamedBufferRange(buffer, offset, length, access); return ret; }
|
|
|
+ UnmapNamedBuffer :: #force_inline proc "c" (buffer: u32) -> bool { ret := impl_UnmapNamedBuffer(buffer); return ret; }
|
|
|
+ FlushMappedNamedBufferRange :: #force_inline proc "c" (buffer: u32, offset: int, length: int) { impl_FlushMappedNamedBufferRange(buffer, offset, length); }
|
|
|
+ GetNamedBufferParameteriv :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i32) { impl_GetNamedBufferParameteriv(buffer, pname, params); }
|
|
|
+ GetNamedBufferParameteri64v :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i64) { impl_GetNamedBufferParameteri64v(buffer, pname, params); }
|
|
|
+ GetNamedBufferPointerv :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]rawptr) { impl_GetNamedBufferPointerv(buffer, pname, params); }
|
|
|
+ GetNamedBufferSubData :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr) { impl_GetNamedBufferSubData(buffer, offset, size, data); }
|
|
|
+ CreateFramebuffers :: #force_inline proc "c" (n: i32, framebuffers: [^]u32) { impl_CreateFramebuffers(n, framebuffers); }
|
|
|
+ NamedFramebufferRenderbuffer :: #force_inline proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32) { impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer); }
|
|
|
+ NamedFramebufferParameteri :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: i32) { impl_NamedFramebufferParameteri(framebuffer, pname, param); }
|
|
|
+ NamedFramebufferTexture :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32) { impl_NamedFramebufferTexture(framebuffer, attachment, texture, level); }
|
|
|
+ NamedFramebufferTextureLayer :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32) { impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer); }
|
|
|
+ NamedFramebufferDrawBuffer :: #force_inline proc "c" (framebuffer: u32, buf: u32) { impl_NamedFramebufferDrawBuffer(framebuffer, buf); }
|
|
|
+ NamedFramebufferDrawBuffers :: #force_inline proc "c" (framebuffer: u32, n: i32, bufs: [^]u32) { impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs); }
|
|
|
+ NamedFramebufferReadBuffer :: #force_inline proc "c" (framebuffer: u32, src: u32) { impl_NamedFramebufferReadBuffer(framebuffer, src); }
|
|
|
+ InvalidateNamedFramebufferData :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32) { impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments); }
|
|
|
+ InvalidateNamedFramebufferSubData :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32) { impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height); }
|
|
|
+ ClearNamedFramebufferiv :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32) { impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value); }
|
|
|
+ ClearNamedFramebufferuiv :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32) { impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value); }
|
|
|
+ ClearNamedFramebufferfv :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32) { impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value); }
|
|
|
+ ClearNamedFramebufferfi :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) { impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil); }
|
|
|
+ BlitNamedFramebuffer :: #force_inline proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) { impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); }
|
|
|
+ CheckNamedFramebufferStatus :: #force_inline proc "c" (framebuffer: u32, target: u32) -> u32 { ret := impl_CheckNamedFramebufferStatus(framebuffer, target); return ret; }
|
|
|
+ GetNamedFramebufferParameteriv :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: ^i32) { impl_GetNamedFramebufferParameteriv(framebuffer, pname, param); }
|
|
|
+ GetNamedFramebufferAttachmentParameteriv :: #force_inline proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32) { impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params); }
|
|
|
+ CreateRenderbuffers :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32) { impl_CreateRenderbuffers(n, renderbuffers); }
|
|
|
+ NamedRenderbufferStorage :: #force_inline proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32) { impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height); }
|
|
|
+ NamedRenderbufferStorageMultisample :: #force_inline proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32) { impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height); }
|
|
|
+ GetNamedRenderbufferParameteriv :: #force_inline proc "c" (renderbuffer: u32, pname: u32, params: [^]i32) { impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params); }
|
|
|
+ CreateTextures :: #force_inline proc "c" (target: u32, n: i32, textures: [^]u32) { impl_CreateTextures(target, n, textures); }
|
|
|
+ TextureBuffer :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32) { impl_TextureBuffer(texture, internalformat, buffer); }
|
|
|
+ TextureBufferRange :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int) { impl_TextureBufferRange(texture, internalformat, buffer, offset, size); }
|
|
|
+ TextureStorage1D :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32) { impl_TextureStorage1D(texture, levels, internalformat, width); }
|
|
|
+ TextureStorage2D :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32) { impl_TextureStorage2D(texture, levels, internalformat, width, height); }
|
|
|
+ TextureStorage3D :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32) { impl_TextureStorage3D(texture, levels, internalformat, width, height, depth); }
|
|
|
+ TextureStorage2DMultisample :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8) { impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations); }
|
|
|
+ TextureStorage3DMultisample :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8) { impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations); }
|
|
|
+ TextureSubImage1D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr) { impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels); }
|
|
|
+ TextureSubImage2D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr) { impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels); }
|
|
|
+ TextureSubImage3D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr) { impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
|
|
|
+ CompressedTextureSubImage1D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data); }
|
|
|
+ CompressedTextureSubImage2D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data); }
|
|
|
+ CompressedTextureSubImage3D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
|
|
|
+ CopyTextureSubImage1D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32) { impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width); }
|
|
|
+ CopyTextureSubImage2D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32) { impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height); }
|
|
|
+ CopyTextureSubImage3D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32) { impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height); }
|
|
|
+ TextureParameterf :: #force_inline proc "c" (texture: u32, pname: u32, param: f32) { impl_TextureParameterf(texture, pname, param); }
|
|
|
+ TextureParameterfv :: #force_inline proc "c" (texture: u32, pname: u32, param: ^f32) { impl_TextureParameterfv(texture, pname, param); }
|
|
|
+ TextureParameteri :: #force_inline proc "c" (texture: u32, pname: u32, param: i32) { impl_TextureParameteri(texture, pname, param); }
|
|
|
+ TextureParameterIiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32) { impl_TextureParameterIiv(texture, pname, params); }
|
|
|
+ TextureParameterIuiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32) { impl_TextureParameterIuiv(texture, pname, params); }
|
|
|
+ TextureParameteriv :: #force_inline proc "c" (texture: u32, pname: u32, param: ^i32) { impl_TextureParameteriv(texture, pname, param); }
|
|
|
+ GenerateTextureMipmap :: #force_inline proc "c" (texture: u32) { impl_GenerateTextureMipmap(texture); }
|
|
|
+ BindTextureUnit :: #force_inline proc "c" (unit: u32, texture: u32) { impl_BindTextureUnit(unit, texture); }
|
|
|
+ GetTextureImage :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr) { impl_GetTextureImage(texture, level, format, type, bufSize, pixels); }
|
|
|
+ GetCompressedTextureImage :: #force_inline proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr) { impl_GetCompressedTextureImage(texture, level, bufSize, pixels); }
|
|
|
+ GetTextureLevelParameterfv :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32) { impl_GetTextureLevelParameterfv(texture, level, pname, params); }
|
|
|
+ GetTextureLevelParameteriv :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32) { impl_GetTextureLevelParameteriv(texture, level, pname, params); }
|
|
|
+ GetTextureParameterfv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]f32) { impl_GetTextureParameterfv(texture, pname, params); }
|
|
|
+ GetTextureParameterIiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32) { impl_GetTextureParameterIiv(texture, pname, params); }
|
|
|
+ GetTextureParameterIuiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32) { impl_GetTextureParameterIuiv(texture, pname, params); }
|
|
|
+ GetTextureParameteriv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32) { impl_GetTextureParameteriv(texture, pname, params); }
|
|
|
+ CreateVertexArrays :: #force_inline proc "c" (n: i32, arrays: [^]u32) { impl_CreateVertexArrays(n, arrays); }
|
|
|
+ DisableVertexArrayAttrib :: #force_inline proc "c" (vaobj: u32, index: u32) { impl_DisableVertexArrayAttrib(vaobj, index); }
|
|
|
+ EnableVertexArrayAttrib :: #force_inline proc "c" (vaobj: u32, index: u32) { impl_EnableVertexArrayAttrib(vaobj, index); }
|
|
|
+ VertexArrayElementBuffer :: #force_inline proc "c" (vaobj: u32, buffer: u32) { impl_VertexArrayElementBuffer(vaobj, buffer); }
|
|
|
+ VertexArrayVertexBuffer :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32) { impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride); }
|
|
|
+ VertexArrayVertexBuffers :: #force_inline proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32) { impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides); }
|
|
|
+ VertexArrayAttribBinding :: #force_inline proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32) { impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex); }
|
|
|
+ VertexArrayAttribFormat :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32) { impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset); }
|
|
|
+ VertexArrayAttribIFormat :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32) { impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset); }
|
|
|
+ VertexArrayAttribLFormat :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32) { impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset); }
|
|
|
+ VertexArrayBindingDivisor :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, divisor: u32) { impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor); }
|
|
|
+ GetVertexArrayiv :: #force_inline proc "c" (vaobj: u32, pname: u32, param: ^i32) { impl_GetVertexArrayiv(vaobj, pname, param); }
|
|
|
+ GetVertexArrayIndexediv :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32) { impl_GetVertexArrayIndexediv(vaobj, index, pname, param); }
|
|
|
+ GetVertexArrayIndexed64iv :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64) { impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param); }
|
|
|
+ CreateSamplers :: #force_inline proc "c" (n: i32, samplers: [^]u32) { impl_CreateSamplers(n, samplers); }
|
|
|
+ CreateProgramPipelines :: #force_inline proc "c" (n: i32, pipelines: [^]u32) { impl_CreateProgramPipelines(n, pipelines); }
|
|
|
+ CreateQueries :: #force_inline proc "c" (target: u32, n: i32, ids: [^]u32) { impl_CreateQueries(target, n, ids); }
|
|
|
+ GetQueryBufferObjecti64v :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int) { impl_GetQueryBufferObjecti64v(id, buffer, pname, offset); }
|
|
|
+ GetQueryBufferObjectiv :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int) { impl_GetQueryBufferObjectiv(id, buffer, pname, offset); }
|
|
|
+ GetQueryBufferObjectui64v :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int) { impl_GetQueryBufferObjectui64v(id, buffer, pname, offset); }
|
|
|
+ GetQueryBufferObjectuiv :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int) { impl_GetQueryBufferObjectuiv(id, buffer, pname, offset); }
|
|
|
+ MemoryBarrierByRegion :: #force_inline proc "c" (barriers: u32) { impl_MemoryBarrierByRegion(barriers); }
|
|
|
+ GetTextureSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr) { impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); }
|
|
|
+ GetCompressedTextureSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr) { impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels); }
|
|
|
+ GetGraphicsResetStatus :: #force_inline proc "c" () -> u32 { ret := impl_GetGraphicsResetStatus(); return ret; }
|
|
|
+ GetnCompressedTexImage :: #force_inline proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr) { impl_GetnCompressedTexImage(target, lod, bufSize, pixels); }
|
|
|
+ GetnTexImage :: #force_inline proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr) { impl_GetnTexImage(target, level, format, type, bufSize, pixels); }
|
|
|
+ GetnUniformdv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64) { impl_GetnUniformdv(program, location, bufSize, params); }
|
|
|
+ GetnUniformfv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32) { impl_GetnUniformfv(program, location, bufSize, params); }
|
|
|
+ GetnUniformiv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32) { impl_GetnUniformiv(program, location, bufSize, params); }
|
|
|
+ GetnUniformuiv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32) { impl_GetnUniformuiv(program, location, bufSize, params); }
|
|
|
+ ReadnPixels :: #force_inline proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr) { impl_ReadnPixels(x, y, width, height, format, type, bufSize, data); }
|
|
|
+ GetnMapdv :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f64) { impl_GetnMapdv(target, query, bufSize, v); }
|
|
|
+ GetnMapfv :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f32) { impl_GetnMapfv(target, query, bufSize, v); }
|
|
|
+ GetnMapiv :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^i32) { impl_GetnMapiv(target, query, bufSize, v); }
|
|
|
+ GetnPixelMapusv :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u16) { impl_GetnPixelMapusv(map_, bufSize, values); }
|
|
|
+ GetnPixelMapfv :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]f32) { impl_GetnPixelMapfv(map_, bufSize, values); }
|
|
|
+ GetnPixelMapuiv :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u32) { impl_GetnPixelMapuiv(map_, bufSize, values); }
|
|
|
+ GetnPolygonStipple :: #force_inline proc "c" (bufSize: i32, pattern: ^u8) { impl_GetnPolygonStipple(bufSize, pattern); }
|
|
|
+ GetnColorTable :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr) { impl_GetnColorTable(target, format, type, bufSize, table); }
|
|
|
+ GetnConvolutionFilter :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr) { impl_GetnConvolutionFilter(target, format, type, bufSize, image); }
|
|
|
+ GetnSeparableFilter :: #force_inline proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr) { impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span); }
|
|
|
+ GetnHistogram :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type: u32, bufSize: i32, values: rawptr) { impl_GetnHistogram(target, reset, format, type, bufSize, values); }
|
|
|
+ GetnMinmax :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type: u32, bufSize: i32, values: rawptr) { impl_GetnMinmax(target, reset, format, type, bufSize, values); }
|
|
|
+ TextureBarrier :: #force_inline proc "c" () { impl_TextureBarrier(); }
|
|
|
+ GetUnsignedBytevEXT :: #force_inline proc "c" (pname: u32, data: ^byte) { impl_glGetUnsignedBytevEXT(pname, data); }
|
|
|
+ TexPageCommitmentARB :: #force_inline proc "c"(
|
|
|
+ target: u32,
|
|
|
+ level: i32,
|
|
|
+ xoffset: i32,
|
|
|
+ yoffset: i32,
|
|
|
+ zoffset: i32,
|
|
|
+ width: i32,
|
|
|
+ height: i32,
|
|
|
+ depth: i32,
|
|
|
+ commit: bool,
|
|
|
+ ) {
|
|
|
+ impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
|
|
|
+ }
|
|
|
+
|
|
|
+ // VERSION_4_6
|
|
|
+ SpecializeShader :: #force_inline proc "c" (shader: u32, pEntryPoint: ^u8, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); }
|
|
|
+ MultiDrawArraysIndirectCount :: #force_inline proc "c" (mode: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32) { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride); }
|
|
|
+ MultiDrawElementsIndirectCount :: #force_inline proc "c" (mode: i32, type: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32) { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride); }
|
|
|
+ PolygonOffsetClamp :: #force_inline proc "c" (factor, units, clamp: f32) { impl_PolygonOffsetClamp(factor, units, clamp); }
|
|
|
+} else {
|
|
|
+ import "core:runtime"
|
|
|
+ import "core:fmt"
|
|
|
+
|
|
|
+ debug_helper :: #force_inline proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) {
|
|
|
+ context = runtime.default_context();
|
|
|
+
|
|
|
+ Error_Enum :: enum {
|
|
|
+ NO_ERROR = NO_ERROR,
|
|
|
+ INVALID_VALUE = INVALID_VALUE,
|
|
|
+ INVALID_ENUM = INVALID_ENUM,
|
|
|
+ INVALID_OPERATION = INVALID_OPERATION,
|
|
|
+ INVALID_FRAMEBUFFER_OPERATION = INVALID_FRAMEBUFFER_OPERATION,
|
|
|
+ OUT_OF_MEMORY = OUT_OF_MEMORY,
|
|
|
+ STACK_UNDERFLOW = STACK_UNDERFLOW,
|
|
|
+ STACK_OVERFLOW = STACK_OVERFLOW,
|
|
|
+ // TODO: What if the return enum is invalid?
|
|
|
+ };
|
|
|
+
|
|
|
+ // There can be multiple errors, so we're required to continuously call glGetError until there are no more errors
|
|
|
+ for i := 0; /**/; i += 1 {
|
|
|
+ err := cast(Error_Enum)impl_GetError();
|
|
|
+ if err == .NO_ERROR do break;
|
|
|
+
|
|
|
+ fmt.printf("%d: glGetError() returned GL_%v\n", i, err);
|
|
|
+
|
|
|
+ // add function call
|
|
|
+ fmt.printf(" call: gl%s(", loc.procedure);
|
|
|
+ {
|
|
|
+ // add input arguments
|
|
|
+ for arg, i in args[num_ret:] {
|
|
|
+ if i > 0 do fmt.printf(", ");
|
|
|
+
|
|
|
+ if v, ok := arg.(u32); ok { // TODO: Assumes all u32 are GLenum (they're not, GLbitfield and GLuint are also mapped to u32), fix later by better typing
|
|
|
+ if err == .INVALID_ENUM {
|
|
|
+ fmt.printf("INVALID_ENUM=%d", v);
|
|
|
+ } else {
|
|
|
+ fmt.printf("GL_%v=%d", GL_Enum(v), v);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ fmt.printf("%v", arg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // add return arguments
|
|
|
+ if num_ret == 1 {
|
|
|
+ fmt.printf(") -> %v \n", args[0]);
|
|
|
+ } else if num_ret > 1 {
|
|
|
+ fmt.printf(") -> (");
|
|
|
+ for arg, i in args[1:num_ret] {
|
|
|
+ if i > 0 do fmt.printf(", ");
|
|
|
+ fmt.printf("%v", arg);
|
|
|
+ }
|
|
|
+ fmt.printf(")\n");
|
|
|
+ } else {
|
|
|
+ fmt.printf(")\n");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // add location
|
|
|
+ fmt.printf(" in: %s(%d:%d)\n", from_loc.file_path, from_loc.line, from_loc.column);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ CullFace :: #force_inline proc "c" (mode: u32, loc := #caller_location) { impl_CullFace(mode); debug_helper(loc, 0, mode); }
|
|
|
+ FrontFace :: #force_inline proc "c" (mode: u32, loc := #caller_location) { impl_FrontFace(mode); debug_helper(loc, 0, mode); }
|
|
|
+ Hint :: #force_inline proc "c" (target, mode: u32, loc := #caller_location) { impl_Hint(target, mode); debug_helper(loc, 0, target, mode); }
|
|
|
+ LineWidth :: #force_inline proc "c" (width: f32, loc := #caller_location) { impl_LineWidth(width); debug_helper(loc, 0, width); }
|
|
|
+ PointSize :: #force_inline proc "c" (size: f32, loc := #caller_location) { impl_PointSize(size); debug_helper(loc, 0, size); }
|
|
|
+ PolygonMode :: #force_inline proc "c" (face, mode: u32, loc := #caller_location) { impl_PolygonMode(face, mode); debug_helper(loc, 0, face, mode); }
|
|
|
+ Scissor :: #force_inline proc "c" (x, y, width, height: i32, loc := #caller_location) { impl_Scissor(x, y, width, height); debug_helper(loc, 0, x, y, width, height); }
|
|
|
+ TexParameterf :: #force_inline proc "c" (target, pname: u32, param: f32, loc := #caller_location) { impl_TexParameterf(target, pname, param); debug_helper(loc, 0, target, pname, param); }
|
|
|
+ TexParameterfv :: #force_inline proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location) { impl_TexParameterfv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ TexParameteri :: #force_inline proc "c" (target, pname: u32, param: i32, loc := #caller_location) { impl_TexParameteri(target, pname, param); debug_helper(loc, 0, target, pname, param); }
|
|
|
+ TexParameteriv :: #force_inline proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location) { impl_TexParameteriv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ TexImage1D :: #force_inline proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, border, format, type, pixels); }
|
|
|
+ TexImage2D :: #force_inline proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, height, border, format, type, pixels); }
|
|
|
+ DrawBuffer :: #force_inline proc "c" (buf: u32, loc := #caller_location) { impl_DrawBuffer(buf); debug_helper(loc, 0, buf); }
|
|
|
+ Clear :: #force_inline proc "c" (mask: u32, loc := #caller_location) { impl_Clear(mask); debug_helper(loc, 0, mask); }
|
|
|
+ ClearColor :: #force_inline proc "c" (red, green, blue, alpha: f32, loc := #caller_location) { impl_ClearColor(red, green, blue, alpha); debug_helper(loc, 0, red, green, blue, alpha); }
|
|
|
+ ClearStencil :: #force_inline proc "c" (s: i32, loc := #caller_location) { impl_ClearStencil(s); debug_helper(loc, 0, s); }
|
|
|
+ ClearDepth :: #force_inline proc "c" (depth: f64, loc := #caller_location) { impl_ClearDepth(depth); debug_helper(loc, 0, depth); }
|
|
|
+ StencilMask :: #force_inline proc "c" (mask: u32, loc := #caller_location) { impl_StencilMask(mask); debug_helper(loc, 0, mask); }
|
|
|
+ ColorMask :: #force_inline proc "c" (red, green, blue, alpha: u8, loc := #caller_location) { impl_ColorMask(red, green, blue, alpha); debug_helper(loc, 0, red, green, blue, alpha); }
|
|
|
+ DepthMask :: #force_inline proc "c" (flag: u8, loc := #caller_location) { impl_DepthMask(flag); debug_helper(loc, 0, flag); }
|
|
|
+ Disable :: #force_inline proc "c" (cap: u32, loc := #caller_location) { impl_Disable(cap); debug_helper(loc, 0, cap); }
|
|
|
+ Enable :: #force_inline proc "c" (cap: u32, loc := #caller_location) { impl_Enable(cap); debug_helper(loc, 0, cap); }
|
|
|
+ Finish :: #force_inline proc "c" (loc := #caller_location) { impl_Finish(); debug_helper(loc, 0); }
|
|
|
+ Flush :: #force_inline proc "c" (loc := #caller_location) { impl_Flush(); debug_helper(loc, 0); }
|
|
|
+ BlendFunc :: #force_inline proc "c" (sfactor, dfactor: u32, loc := #caller_location) { impl_BlendFunc(sfactor, dfactor); debug_helper(loc, 0, sfactor, dfactor); }
|
|
|
+ LogicOp :: #force_inline proc "c" (opcode: u32, loc := #caller_location) { impl_LogicOp(opcode); debug_helper(loc, 0, opcode); }
|
|
|
+ StencilFunc :: #force_inline proc "c" (func: u32, ref: i32, mask: u32, loc := #caller_location) { impl_StencilFunc(func, ref, mask); debug_helper(loc, 0, func, ref, mask); }
|
|
|
+ StencilOp :: #force_inline proc "c" (fail, zfail, zpass: u32, loc := #caller_location) { impl_StencilOp(fail, zfail, zpass); debug_helper(loc, 0, fail, zfail, zpass); }
|
|
|
+ DepthFunc :: #force_inline proc "c" (func: u32, loc := #caller_location) { impl_DepthFunc(func); debug_helper(loc, 0, func); }
|
|
|
+ PixelStoref :: #force_inline proc "c" (pname: u32, param: f32, loc := #caller_location) { impl_PixelStoref(pname, param); debug_helper(loc, 0, pname, param); }
|
|
|
+ PixelStorei :: #force_inline proc "c" (pname: u32, param: i32, loc := #caller_location) { impl_PixelStorei(pname, param); debug_helper(loc, 0, pname, param); }
|
|
|
+ ReadBuffer :: #force_inline proc "c" (src: u32, loc := #caller_location) { impl_ReadBuffer(src); debug_helper(loc, 0, src); }
|
|
|
+ ReadPixels :: #force_inline proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_ReadPixels(x, y, width, height, format, type, pixels); debug_helper(loc, 0, x, y, width, height, format, type, pixels); }
|
|
|
+ GetBooleanv :: #force_inline proc "c" (pname: u32, data: ^bool, loc := #caller_location) { impl_GetBooleanv(pname, data); debug_helper(loc, 0, pname, data); }
|
|
|
+ GetDoublev :: #force_inline proc "c" (pname: u32, data: ^f64, loc := #caller_location) { impl_GetDoublev(pname, data); debug_helper(loc, 0, pname, data); }
|
|
|
+ GetError :: #force_inline proc "c" (loc := #caller_location) -> u32 { ret := impl_GetError(); debug_helper(loc, 1, ret); return ret; }
|
|
|
+ GetFloatv :: #force_inline proc "c" (pname: u32, data: ^f32, loc := #caller_location) { impl_GetFloatv(pname, data); debug_helper(loc, 0, pname, data); }
|
|
|
+ GetIntegerv :: #force_inline proc "c" (pname: u32, data: ^i32, loc := #caller_location) { impl_GetIntegerv(pname, data); debug_helper(loc, 0, pname, data); }
|
|
|
+ GetString :: #force_inline proc "c" (name: u32, loc := #caller_location) -> cstring { ret := impl_GetString(name); debug_helper(loc, 1, ret, name); return ret; }
|
|
|
+ GetTexImage :: #force_inline proc "c" (target: u32, level: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_GetTexImage(target, level, format, type, pixels); debug_helper(loc, 0, target, level, format, type, pixels); }
|
|
|
+ GetTexParameterfv :: #force_inline proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location) { impl_GetTexParameterfv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetTexParameteriv :: #force_inline proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetTexParameteriv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetTexLevelParameterfv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location) { impl_GetTexLevelParameterfv(target, level, pname, params); debug_helper(loc, 0, target, level, pname, params); }
|
|
|
+ GetTexLevelParameteriv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetTexLevelParameteriv(target, level, pname, params); debug_helper(loc, 0, target, level, pname, params); }
|
|
|
+ IsEnabled :: #force_inline proc "c" (cap: u32, loc := #caller_location) -> bool { ret := impl_IsEnabled(cap); debug_helper(loc, 1, ret, cap); return ret; }
|
|
|
+ DepthRange :: #force_inline proc "c" (near, far: f64, loc := #caller_location) { impl_DepthRange(near, far); debug_helper(loc, 0, near, far); }
|
|
|
+ Viewport :: #force_inline proc "c" (x, y, width, height: i32, loc := #caller_location) { impl_Viewport(x, y, width, height); debug_helper(loc, 0, x, y, width, height); }
|
|
|
+
|
|
|
+ // VERSION_1_1
|
|
|
+ DrawArrays :: #force_inline proc "c" (mode: u32, first: i32, count: i32, loc := #caller_location) { impl_DrawArrays(mode, first, count); debug_helper(loc, 0, mode, first, count); }
|
|
|
+ DrawElements :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location) { impl_DrawElements(mode, count, type, indices); debug_helper(loc, 0, mode, count, type, indices); }
|
|
|
+ PolygonOffset :: #force_inline proc "c" (factor: f32, units: f32, loc := #caller_location) { impl_PolygonOffset(factor, units); debug_helper(loc, 0, factor, units); }
|
|
|
+ CopyTexImage1D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32, loc := #caller_location) { impl_CopyTexImage1D(target, level, internalformat, x, y, width, border); debug_helper(loc, 0, target, level, internalformat, x, y, width, border); }
|
|
|
+ CopyTexImage2D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32, loc := #caller_location) { impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border); debug_helper(loc, 0, target, level, internalformat, x, y, width, height, border); }
|
|
|
+ CopyTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location) { impl_CopyTexSubImage1D(target, level, xoffset, x, y, width); debug_helper(loc, 0, target, level, xoffset, x, y, width); }
|
|
|
+ CopyTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location) { impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); debug_helper(loc, 0, target, level, xoffset, yoffset, x, y, width, height); }
|
|
|
+ TexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, width, format, type, pixels); }
|
|
|
+ TexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, type, pixels); }
|
|
|
+ BindTexture :: #force_inline proc "c" (target: u32, texture: u32, loc := #caller_location) { impl_BindTexture(target, texture); debug_helper(loc, 0, target, texture); }
|
|
|
+ DeleteTextures :: #force_inline proc "c" (n: i32, textures: [^]u32, loc := #caller_location) { impl_DeleteTextures(n, textures); debug_helper(loc, 0, n, textures); }
|
|
|
+ GenTextures :: #force_inline proc "c" (n: i32, textures: [^]u32, loc := #caller_location) { impl_GenTextures(n, textures); debug_helper(loc, 0, n, textures); }
|
|
|
+ IsTexture :: #force_inline proc "c" (texture: u32, loc := #caller_location) -> bool { ret := impl_IsTexture(texture); debug_helper(loc, 1, ret, texture); return ret; }
|
|
|
+
|
|
|
+ // VERSION_1_2
|
|
|
+ DrawRangeElements :: #force_inline proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location) { impl_DrawRangeElements(mode, start, end, count, type, indices); debug_helper(loc, 0, mode, start, end, count, type, indices); }
|
|
|
+ TexImage3D :: #force_inline proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, format, type, pixels); }
|
|
|
+ TexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
|
|
|
+ CopyTexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32, loc := #caller_location) { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, x, y, width, height); }
|
|
|
+
|
|
|
+ // VERSION_1_3
|
|
|
+ ActiveTexture :: #force_inline proc "c" (texture: u32, loc := #caller_location) { impl_ActiveTexture(texture); debug_helper(loc, 0, texture); }
|
|
|
+ SampleCoverage :: #force_inline proc "c" (value: f32, invert: u8, loc := #caller_location) { impl_SampleCoverage(value, invert); debug_helper(loc, 0, value, invert); }
|
|
|
+ CompressedTexImage3D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, imageSize, data); }
|
|
|
+ CompressedTexImage2D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); debug_helper(loc, 0, target, level, internalformat, width, height, border, imageSize, data); }
|
|
|
+ CompressedTexImage1D :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); debug_helper(loc, 0, target, level, internalformat, width, border, imageSize, data); }
|
|
|
+ CompressedTexSubImage3D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
|
|
|
+ CompressedTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, imageSize, data); }
|
|
|
+ CompressedTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, width, format, imageSize, data); }
|
|
|
+ GetCompressedTexImage :: #force_inline proc "c" (target: u32, level: i32, img: rawptr, loc := #caller_location) { impl_GetCompressedTexImage(target, level, img); debug_helper(loc, 0, target, level, img); }
|
|
|
+
|
|
|
+ // VERSION_1_4
|
|
|
+ BlendFuncSeparate :: #force_inline proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32, loc := #caller_location) { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); debug_helper(loc, 0, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); }
|
|
|
+ MultiDrawArrays :: #force_inline proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32, loc := #caller_location) { impl_MultiDrawArrays(mode, first, count, drawcount); debug_helper(loc, 0, mode, first, count, drawcount); }
|
|
|
+ MultiDrawElements :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, loc := #caller_location) { impl_MultiDrawElements(mode, count, type, indices, drawcount); debug_helper(loc, 0, mode, count, type, indices, drawcount); }
|
|
|
+ PointParameterf :: #force_inline proc "c" (pname: u32, param: f32, loc := #caller_location) { impl_PointParameterf(pname, param); debug_helper(loc, 0, pname, param); }
|
|
|
+ PointParameterfv :: #force_inline proc "c" (pname: u32, params: [^]f32, loc := #caller_location) { impl_PointParameterfv(pname, params); debug_helper(loc, 0, pname, params); }
|
|
|
+ PointParameteri :: #force_inline proc "c" (pname: u32, param: i32, loc := #caller_location) { impl_PointParameteri(pname, param); debug_helper(loc, 0, pname, param); }
|
|
|
+ PointParameteriv :: #force_inline proc "c" (pname: u32, params: [^]i32, loc := #caller_location) { impl_PointParameteriv(pname, params); debug_helper(loc, 0, pname, params); }
|
|
|
+ BlendColor :: #force_inline proc "c" (red: f32, green: f32, blue: f32, alpha: f32, loc := #caller_location) { impl_BlendColor(red, green, blue, alpha); debug_helper(loc, 0, red, green, blue, alpha); }
|
|
|
+ BlendEquation :: #force_inline proc "c" (mode: u32, loc := #caller_location) { impl_BlendEquation(mode); debug_helper(loc, 0, mode); }
|
|
|
+
|
|
|
+ // VERSION_1_5
|
|
|
+ GenQueries :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location) { impl_GenQueries(n, ids); debug_helper(loc, 0, n, ids); }
|
|
|
+ DeleteQueries :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location) { impl_DeleteQueries(n, ids); debug_helper(loc, 0, n, ids); }
|
|
|
+ IsQuery :: #force_inline proc "c" (id: u32, loc := #caller_location) -> bool { ret := impl_IsQuery(id); debug_helper(loc, 1, ret, id); return ret; }
|
|
|
+ BeginQuery :: #force_inline proc "c" (target: u32, id: u32, loc := #caller_location) { impl_BeginQuery(target, id); debug_helper(loc, 0, target, id); }
|
|
|
+ EndQuery :: #force_inline proc "c" (target: u32, loc := #caller_location) { impl_EndQuery(target); debug_helper(loc, 0, target); }
|
|
|
+ GetQueryiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetQueryiv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetQueryObjectiv :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetQueryObjectiv(id, pname, params); debug_helper(loc, 0, id, pname, params); }
|
|
|
+ GetQueryObjectuiv :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_GetQueryObjectuiv(id, pname, params); debug_helper(loc, 0, id, pname, params); }
|
|
|
+ BindBuffer :: #force_inline proc "c" (target: u32, buffer: u32, loc := #caller_location) { impl_BindBuffer(target, buffer); debug_helper(loc, 0, target, buffer); }
|
|
|
+ DeleteBuffers :: #force_inline proc "c" (n: i32, buffers: [^]u32, loc := #caller_location) { impl_DeleteBuffers(n, buffers); debug_helper(loc, 0, n, buffers); }
|
|
|
+ GenBuffers :: #force_inline proc "c" (n: i32, buffers: [^]u32, loc := #caller_location) { impl_GenBuffers(n, buffers); debug_helper(loc, 0, n, buffers); }
|
|
|
+ IsBuffer :: #force_inline proc "c" (buffer: u32, loc := #caller_location) -> bool { ret := impl_IsBuffer(buffer); debug_helper(loc, 1, ret, buffer); return ret; }
|
|
|
+ BufferData :: #force_inline proc "c" (target: u32, size: int, data: rawptr, usage: u32, loc := #caller_location) { impl_BufferData(target, size, data, usage); debug_helper(loc, 0, target, size, data, usage); }
|
|
|
+ BufferSubData :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) { impl_BufferSubData(target, offset, size, data); debug_helper(loc, 0, target, offset, size, data); }
|
|
|
+ GetBufferSubData :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) { impl_GetBufferSubData(target, offset, size, data); debug_helper(loc, 0, target, offset, size, data); }
|
|
|
+ MapBuffer :: #force_inline proc "c" (target: u32, access: u32, loc := #caller_location) -> rawptr { ret := impl_MapBuffer(target, access); debug_helper(loc, 1, ret, target, access); return ret; }
|
|
|
+ UnmapBuffer :: #force_inline proc "c" (target: u32, loc := #caller_location) -> bool { ret := impl_UnmapBuffer(target); debug_helper(loc, 1, ret, target); return ret; }
|
|
|
+ GetBufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetBufferParameteriv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetBufferPointerv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]rawptr, loc := #caller_location) { impl_GetBufferPointerv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+
|
|
|
+ // VERSION_2_0
|
|
|
+ BlendEquationSeparate :: #force_inline proc "c" (modeRGB: u32, modeAlpha: u32, loc := #caller_location) { impl_BlendEquationSeparate(modeRGB, modeAlpha); debug_helper(loc, 0, modeRGB, modeAlpha); }
|
|
|
+ DrawBuffers :: #force_inline proc "c" (n: i32, bufs: [^]u32, loc := #caller_location) { impl_DrawBuffers(n, bufs); debug_helper(loc, 0, n, bufs); }
|
|
|
+ StencilOpSeparate :: #force_inline proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32, loc := #caller_location) { impl_StencilOpSeparate(face, sfail, dpfail, dppass); debug_helper(loc, 0, face, sfail, dpfail, dppass); }
|
|
|
+ StencilFuncSeparate :: #force_inline proc "c" (face: u32, func: u32, ref: i32, mask: u32, loc := #caller_location) { impl_StencilFuncSeparate(face, func, ref, mask); debug_helper(loc, 0, face, func, ref, mask); }
|
|
|
+ StencilMaskSeparate :: #force_inline proc "c" (face: u32, mask: u32, loc := #caller_location) { impl_StencilMaskSeparate(face, mask); debug_helper(loc, 0, face, mask); }
|
|
|
+ AttachShader :: #force_inline proc "c" (program: u32, shader: u32, loc := #caller_location) { impl_AttachShader(program, shader); debug_helper(loc, 0, program, shader); }
|
|
|
+ BindAttribLocation :: #force_inline proc "c" (program: u32, index: u32, name: cstring, loc := #caller_location) { impl_BindAttribLocation(program, index, name); debug_helper(loc, 0, program, index, name); }
|
|
|
+ CompileShader :: #force_inline proc "c" (shader: u32, loc := #caller_location) { impl_CompileShader(shader); debug_helper(loc, 0, shader); }
|
|
|
+ CreateProgram :: #force_inline proc "c" (loc := #caller_location) -> u32 { ret := impl_CreateProgram(); debug_helper(loc, 1, ret); return ret; }
|
|
|
+ CreateShader :: #force_inline proc "c" (type: u32, loc := #caller_location) -> u32 { ret := impl_CreateShader(type); debug_helper(loc, 1, ret, type); return ret; }
|
|
|
+ DeleteProgram :: #force_inline proc "c" (program: u32, loc := #caller_location) { impl_DeleteProgram(program); debug_helper(loc, 0, program); }
|
|
|
+ DeleteShader :: #force_inline proc "c" (shader: u32, loc := #caller_location) { impl_DeleteShader(shader); debug_helper(loc, 0, shader); }
|
|
|
+ DetachShader :: #force_inline proc "c" (program: u32, shader: u32, loc := #caller_location) { impl_DetachShader(program, shader); debug_helper(loc, 0, program, shader); }
|
|
|
+ DisableVertexAttribArray :: #force_inline proc "c" (index: u32, loc := #caller_location) { impl_DisableVertexAttribArray(index); debug_helper(loc, 0, index); }
|
|
|
+ EnableVertexAttribArray :: #force_inline proc "c" (index: u32, loc := #caller_location) { impl_EnableVertexAttribArray(index); debug_helper(loc, 0, index); }
|
|
|
+ GetActiveAttrib :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) { impl_GetActiveAttrib(program, index, bufSize, length, size, type, name); debug_helper(loc, 0, program, index, bufSize, length, size, type, name); }
|
|
|
+ GetActiveUniform :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) { impl_GetActiveUniform(program, index, bufSize, length, size, type, name); debug_helper(loc, 0, program, index, bufSize, length, size, type, name); }
|
|
|
+ GetAttachedShaders :: #force_inline proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32, loc := #caller_location) { impl_GetAttachedShaders(program, maxCount, count, shaders); debug_helper(loc, 0, program, maxCount, count, shaders); }
|
|
|
+ GetAttribLocation :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetAttribLocation(program, name); debug_helper(loc, 1, ret, program, name); return ret; }
|
|
|
+ GetProgramiv :: #force_inline proc "c" (program: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetProgramiv(program, pname, params); debug_helper(loc, 0, program, pname, params); }
|
|
|
+ GetProgramInfoLog :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location) { impl_GetProgramInfoLog(program, bufSize, length, infoLog); debug_helper(loc, 0, program, bufSize, length, infoLog); }
|
|
|
+ GetShaderiv :: #force_inline proc "c" (shader: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetShaderiv(shader, pname, params); debug_helper(loc, 0, shader, pname, params); }
|
|
|
+ GetShaderInfoLog :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location) { impl_GetShaderInfoLog(shader, bufSize, length, infoLog); debug_helper(loc, 0, shader, bufSize, length, infoLog); }
|
|
|
+ GetShaderSource :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8, loc := #caller_location) { impl_GetShaderSource(shader, bufSize, length, source); debug_helper(loc, 0, shader, bufSize, length, source); }
|
|
|
+ GetUniformLocation :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetUniformLocation(program, name); debug_helper(loc, 1, ret, program, name); return ret; }
|
|
|
+ GetUniformfv :: #force_inline proc "c" (program: u32, location: i32, params: [^]f32, loc := #caller_location) { impl_GetUniformfv(program, location, params); debug_helper(loc, 0, program, location, params); }
|
|
|
+ GetUniformiv :: #force_inline proc "c" (program: u32, location: i32, params: [^]i32, loc := #caller_location) { impl_GetUniformiv(program, location, params); debug_helper(loc, 0, program, location, params); }
|
|
|
+ GetVertexAttribdv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location) { impl_GetVertexAttribdv(index, pname, params); debug_helper(loc, 0, index, pname, params); }
|
|
|
+ GetVertexAttribfv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f32, loc := #caller_location) { impl_GetVertexAttribfv(index, pname, params); debug_helper(loc, 0, index, pname, params); }
|
|
|
+ GetVertexAttribiv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetVertexAttribiv(index, pname, params); debug_helper(loc, 0, index, pname, params); }
|
|
|
+ GetVertexAttribPointerv :: #force_inline proc "c" (index: u32, pname: u32, pointer: ^rawptr, loc := #caller_location) { impl_GetVertexAttribPointerv(index, pname, pointer); debug_helper(loc, 0, index, pname, pointer); }
|
|
|
+ IsProgram :: #force_inline proc "c" (program: u32, loc := #caller_location) -> bool { ret := impl_IsProgram(program); debug_helper(loc, 1, ret, program); return ret; }
|
|
|
+ IsShader :: #force_inline proc "c" (shader: u32, loc := #caller_location) -> bool { ret := impl_IsShader(shader); debug_helper(loc, 1, ret, shader); return ret; }
|
|
|
+ LinkProgram :: #force_inline proc "c" (program: u32, loc := #caller_location) { impl_LinkProgram(program); debug_helper(loc, 0, program); }
|
|
|
+ ShaderSource :: #force_inline proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32, loc := #caller_location) { impl_ShaderSource(shader, count, string, length); debug_helper(loc, 0, shader, count, string, length); }
|
|
|
+ UseProgram :: #force_inline proc "c" (program: u32, loc := #caller_location) { impl_UseProgram(program); debug_helper(loc, 0, program); }
|
|
|
+ Uniform1f :: #force_inline proc "c" (location: i32, v0: f32, loc := #caller_location) { impl_Uniform1f(location, v0); debug_helper(loc, 0, location, v0); }
|
|
|
+ Uniform2f :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, loc := #caller_location) { impl_Uniform2f(location, v0, v1); debug_helper(loc, 0, location, v0, v1); }
|
|
|
+ Uniform3f :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location) { impl_Uniform3f(location, v0, v1, v2); debug_helper(loc, 0, location, v0, v1, v2); }
|
|
|
+ Uniform4f :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location) { impl_Uniform4f(location, v0, v1, v2, v3); debug_helper(loc, 0, location, v0, v1, v2, v3); }
|
|
|
+ Uniform1i :: #force_inline proc "c" (location: i32, v0: i32, loc := #caller_location) { impl_Uniform1i(location, v0); debug_helper(loc, 0, location, v0); }
|
|
|
+ Uniform2i :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, loc := #caller_location) { impl_Uniform2i(location, v0, v1); debug_helper(loc, 0, location, v0, v1); }
|
|
|
+ Uniform3i :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location) { impl_Uniform3i(location, v0, v1, v2); debug_helper(loc, 0, location, v0, v1, v2); }
|
|
|
+ Uniform4i :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location) { impl_Uniform4i(location, v0, v1, v2, v3); debug_helper(loc, 0, location, v0, v1, v2, v3); }
|
|
|
+ Uniform1fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location) { impl_Uniform1fv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform2fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location) { impl_Uniform2fv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform3fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location) { impl_Uniform3fv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform4fv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location) { impl_Uniform4fv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform1iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location) { impl_Uniform1iv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform2iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location) { impl_Uniform2iv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform3iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location) { impl_Uniform3iv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform4iv :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location) { impl_Uniform4iv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ UniformMatrix2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ ValidateProgram :: #force_inline proc "c" (program: u32, loc := #caller_location) { impl_ValidateProgram(program); debug_helper(loc, 0, program); }
|
|
|
+ VertexAttrib1d :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location) { impl_VertexAttrib1d(index, x); debug_helper(loc, 0, index, x); }
|
|
|
+ VertexAttrib1dv :: #force_inline proc "c" (index: u32, v: ^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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+
|
|
|
+ // 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); }
|
|
|
+ GetBooleani_v :: #force_inline proc "c" (target: u32, index: u32, data: ^bool, loc := #caller_location) { impl_GetBooleani_v(target, index, data); debug_helper(loc, 0, target, index, data); }
|
|
|
+ GetIntegeri_v :: #force_inline proc "c" (target: u32, index: u32, data: ^i32, loc := #caller_location) { impl_GetIntegeri_v(target, index, data); debug_helper(loc, 0, target, index, data); }
|
|
|
+ Enablei :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location) { impl_Enablei(target, index); debug_helper(loc, 0, target, index); }
|
|
|
+ Disablei :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location) { impl_Disablei(target, index); debug_helper(loc, 0, target, index); }
|
|
|
+ IsEnabledi :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location) -> bool { ret := impl_IsEnabledi(target, index); debug_helper(loc, 1, ret, target, index); return ret; }
|
|
|
+ BeginTransformFeedback :: #force_inline proc "c" (primitiveMode: u32, loc := #caller_location) { impl_BeginTransformFeedback(primitiveMode); debug_helper(loc, 0, primitiveMode); }
|
|
|
+ EndTransformFeedback :: #force_inline proc "c" (loc := #caller_location) { impl_EndTransformFeedback(); debug_helper(loc, 0); }
|
|
|
+ BindBufferRange :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location) { impl_BindBufferRange(target, index, buffer, offset, size); debug_helper(loc, 0, target, index, buffer, offset, size); }
|
|
|
+ BindBufferBase :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, loc := #caller_location) { impl_BindBufferBase(target, index, buffer); debug_helper(loc, 0, target, index, buffer); }
|
|
|
+ TransformFeedbackVaryings :: #force_inline proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32, loc := #caller_location) { impl_TransformFeedbackVaryings(program, count, varyings, bufferMode); debug_helper(loc, 0, program, count, varyings, bufferMode); }
|
|
|
+ GetTransformFeedbackVarying :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) { impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); debug_helper(loc, 0, program, index, bufSize, length, size, type, name); }
|
|
|
+ ClampColor :: #force_inline proc "c" (target: u32, clamp: u32, loc := #caller_location) { impl_ClampColor(target, clamp); debug_helper(loc, 0, target, clamp); }
|
|
|
+ BeginConditionalRender :: #force_inline proc "c" (id: u32, mode: u32, loc := #caller_location) { impl_BeginConditionalRender(id, mode); debug_helper(loc, 0, id, mode); }
|
|
|
+ EndConditionalRender :: #force_inline proc "c" (loc := #caller_location) { impl_EndConditionalRender(); debug_helper(loc, 0); }
|
|
|
+ VertexAttribIPointer :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: rawptr, loc := #caller_location) { impl_VertexAttribIPointer(index, size, type, stride, pointer); debug_helper(loc, 0, index, size, type, stride, pointer); }
|
|
|
+ GetVertexAttribIiv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetVertexAttribIiv(index, pname, params); debug_helper(loc, 0, index, pname, params); }
|
|
|
+ GetVertexAttribIuiv :: #force_inline proc "c" (index: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_GetVertexAttribIuiv(index, pname, params); debug_helper(loc, 0, index, pname, params); }
|
|
|
+ VertexAttribI1i :: #force_inline proc "c" (index: u32, x: i32, loc := #caller_location) { impl_VertexAttribI1i(index, x); debug_helper(loc, 0, index, x); }
|
|
|
+ VertexAttribI2i :: #force_inline proc "c" (index: u32, x: i32, y: i32, loc := #caller_location) { impl_VertexAttribI2i(index, x, y); debug_helper(loc, 0, index, x, y); }
|
|
|
+ VertexAttribI3i :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, loc := #caller_location) { impl_VertexAttribI3i(index, x, y, z); debug_helper(loc, 0, index, x, y, z); }
|
|
|
+ VertexAttribI4i :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32, loc := #caller_location) { impl_VertexAttribI4i(index, x, y, z, w); debug_helper(loc, 0, index, x, y, z, w); }
|
|
|
+ VertexAttribI1ui :: #force_inline proc "c" (index: u32, x: u32, loc := #caller_location) { impl_VertexAttribI1ui(index, x); debug_helper(loc, 0, index, x); }
|
|
|
+ VertexAttribI2ui :: #force_inline proc "c" (index: u32, x: u32, y: u32, loc := #caller_location) { impl_VertexAttribI2ui(index, x, y); debug_helper(loc, 0, index, x, y); }
|
|
|
+ VertexAttribI3ui :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, loc := #caller_location) { impl_VertexAttribI3ui(index, x, y, z); debug_helper(loc, 0, index, x, y, z); }
|
|
|
+ VertexAttribI4ui :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32, loc := #caller_location) { impl_VertexAttribI4ui(index, x, y, z, w); debug_helper(loc, 0, index, x, y, z, w); }
|
|
|
+ VertexAttribI1iv :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location) { impl_VertexAttribI1iv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI2iv :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location) { impl_VertexAttribI2iv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI3iv :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location) { impl_VertexAttribI3iv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI4iv :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location) { impl_VertexAttribI4iv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI1uiv :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location) { impl_VertexAttribI1uiv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI2uiv :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location) { impl_VertexAttribI2uiv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI3uiv :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location) { impl_VertexAttribI3uiv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI4uiv :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location) { impl_VertexAttribI4uiv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI4bv :: #force_inline proc "c" (index: u32, v: ^i8, loc := #caller_location) { impl_VertexAttribI4bv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI4sv :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location) { impl_VertexAttribI4sv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI4ubv :: #force_inline proc "c" (index: u32, v: ^u8, loc := #caller_location) { impl_VertexAttribI4ubv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ VertexAttribI4usv :: #force_inline proc "c" (index: u32, v: ^u16, loc := #caller_location) { impl_VertexAttribI4usv(index, v); debug_helper(loc, 0, index, v); }
|
|
|
+ GetUniformuiv :: #force_inline proc "c" (program: u32, location: i32, params: [^]u32, loc := #caller_location) { impl_GetUniformuiv(program, location, params); debug_helper(loc, 0, program, location, params); }
|
|
|
+ BindFragDataLocation :: #force_inline proc "c" (program: u32, color: u32, name: cstring, loc := #caller_location) { impl_BindFragDataLocation(program, color, name); debug_helper(loc, 0, program, color, name); }
|
|
|
+ GetFragDataLocation :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetFragDataLocation(program, name); debug_helper(loc, 1, ret, program, name); return ret; }
|
|
|
+ Uniform1ui :: #force_inline proc "c" (location: i32, v0: u32, loc := #caller_location) { impl_Uniform1ui(location, v0); debug_helper(loc, 0, location, v0); }
|
|
|
+ Uniform2ui :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, loc := #caller_location) { impl_Uniform2ui(location, v0, v1); debug_helper(loc, 0, location, v0, v1); }
|
|
|
+ Uniform3ui :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location) { impl_Uniform3ui(location, v0, v1, v2); debug_helper(loc, 0, location, v0, v1, v2); }
|
|
|
+ Uniform4ui :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location) { impl_Uniform4ui(location, v0, v1, v2, v3); debug_helper(loc, 0, location, v0, v1, v2, v3); }
|
|
|
+ Uniform1uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location) { impl_Uniform1uiv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform2uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location) { impl_Uniform2uiv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform3uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location) { impl_Uniform3uiv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform4uiv :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location) { impl_Uniform4uiv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ TexParameterIiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_TexParameterIiv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ TexParameterIuiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_TexParameterIuiv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetTexParameterIiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetTexParameterIiv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetTexParameterIuiv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_GetTexParameterIuiv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ ClearBufferiv :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location) { impl_ClearBufferiv(buffer, drawbuffer, value); debug_helper(loc, 0, buffer, drawbuffer, value); }
|
|
|
+ ClearBufferuiv :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location) { impl_ClearBufferuiv(buffer, drawbuffer, value); debug_helper(loc, 0, buffer, drawbuffer, value); }
|
|
|
+ ClearBufferfv :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location) { impl_ClearBufferfv(buffer, drawbuffer, value); debug_helper(loc, 0, buffer, drawbuffer, value); }
|
|
|
+ ClearBufferfi :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location) -> rawptr { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil); debug_helper(loc, 1, ret, buffer, drawbuffer, depth, stencil); return ret; }
|
|
|
+ GetStringi :: #force_inline proc "c" (name: u32, index: u32, loc := #caller_location) -> cstring { ret := impl_GetStringi(name, index); debug_helper(loc, 1, ret, name, index); return ret; }
|
|
|
+ IsRenderbuffer :: #force_inline proc "c" (renderbuffer: u32, loc := #caller_location) -> bool { ret := impl_IsRenderbuffer(renderbuffer); debug_helper(loc, 1, ret, renderbuffer); return ret; }
|
|
|
+ BindRenderbuffer :: #force_inline proc "c" (target: u32, renderbuffer: u32, loc := #caller_location) { impl_BindRenderbuffer(target, renderbuffer); debug_helper(loc, 0, target, renderbuffer); }
|
|
|
+ DeleteRenderbuffers :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location) { impl_DeleteRenderbuffers(n, renderbuffers); debug_helper(loc, 0, n, renderbuffers); }
|
|
|
+ GenRenderbuffers :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location) { impl_GenRenderbuffers(n, renderbuffers); debug_helper(loc, 0, n, renderbuffers); }
|
|
|
+ RenderbufferStorage :: #force_inline proc "c" (target: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location) { impl_RenderbufferStorage(target, internalformat, width, height); debug_helper(loc, 0, target, internalformat, width, height); }
|
|
|
+ GetRenderbufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetRenderbufferParameteriv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ IsFramebuffer :: #force_inline proc "c" (framebuffer: u32, loc := #caller_location) -> bool { ret := impl_IsFramebuffer(framebuffer); debug_helper(loc, 1, ret, framebuffer); return ret; }
|
|
|
+ BindFramebuffer :: #force_inline proc "c" (target: u32, framebuffer: u32, loc := #caller_location) { impl_BindFramebuffer(target, framebuffer); debug_helper(loc, 0, target, framebuffer); }
|
|
|
+ DeleteFramebuffers :: #force_inline proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location) { impl_DeleteFramebuffers(n, framebuffers); debug_helper(loc, 0, n, framebuffers); }
|
|
|
+ GenFramebuffers :: #force_inline proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location) { impl_GenFramebuffers(n, framebuffers); debug_helper(loc, 0, n, framebuffers); }
|
|
|
+ CheckFramebufferStatus :: #force_inline proc "c" (target: u32, loc := #caller_location) -> u32 { ret := impl_CheckFramebufferStatus(target); debug_helper(loc, 1, ret, target); return ret; }
|
|
|
+ FramebufferTexture1D :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location) { impl_FramebufferTexture1D(target, attachment, textarget, texture, level); debug_helper(loc, 0, target, attachment, textarget, texture, level); }
|
|
|
+ FramebufferTexture2D :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location) { impl_FramebufferTexture2D(target, attachment, textarget, texture, level); debug_helper(loc, 0, target, attachment, textarget, texture, level); }
|
|
|
+ FramebufferTexture3D :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32, loc := #caller_location) { impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); debug_helper(loc, 0, target, attachment, textarget, texture, level, zoffset); }
|
|
|
+ FramebufferRenderbuffer :: #force_inline proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location) { impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); debug_helper(loc, 0, target, attachment, renderbuffertarget, renderbuffer); }
|
|
|
+ GetFramebufferAttachmentParameteriv :: #force_inline proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params); debug_helper(loc, 0, target, attachment, pname, params); }
|
|
|
+ GenerateMipmap :: #force_inline proc "c" (target: u32, loc := #caller_location) { impl_GenerateMipmap(target); debug_helper(loc, 0, target); }
|
|
|
+ BlitFramebuffer :: #force_inline proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) { impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); }
|
|
|
+ RenderbufferStorageMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location) { impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height); debug_helper(loc, 0, target, samples, internalformat, width, height); }
|
|
|
+ FramebufferTextureLayer :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location) { impl_FramebufferTextureLayer(target, attachment, texture, level, layer); debug_helper(loc, 0, target, attachment, texture, level, layer); }
|
|
|
+ MapBufferRange :: #force_inline proc "c" (target: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr { ret := impl_MapBufferRange(target, offset, length, access); debug_helper(loc, 1, ret, target, offset, length, access); return ret; }
|
|
|
+ FlushMappedBufferRange :: #force_inline proc "c" (target: u32, offset: int, length: int, loc := #caller_location) { impl_FlushMappedBufferRange(target, offset, length); debug_helper(loc, 0, target, offset, length); }
|
|
|
+ BindVertexArray :: #force_inline proc "c" (array: u32, loc := #caller_location) { impl_BindVertexArray(array); debug_helper(loc, 0, array); }
|
|
|
+ DeleteVertexArrays :: #force_inline proc "c" (n: i32, arrays: [^]u32, loc := #caller_location) { impl_DeleteVertexArrays(n, arrays); debug_helper(loc, 0, n, arrays); }
|
|
|
+ GenVertexArrays :: #force_inline proc "c" (n: i32, arrays: [^]u32, loc := #caller_location) { impl_GenVertexArrays(n, arrays); debug_helper(loc, 0, n, arrays); }
|
|
|
+ IsVertexArray :: #force_inline proc "c" (array: u32, loc := #caller_location) -> bool { ret := impl_IsVertexArray(array); debug_helper(loc, 1, ret, array); return ret; }
|
|
|
+
|
|
|
+ // VERSION_3_1
|
|
|
+ DrawArraysInstanced :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, loc := #caller_location) { impl_DrawArraysInstanced(mode, first, count, instancecount); debug_helper(loc, 0, mode, first, count, instancecount); }
|
|
|
+ DrawElementsInstanced :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, loc := #caller_location) { impl_DrawElementsInstanced(mode, count, type, indices, instancecount); debug_helper(loc, 0, mode, count, type, indices, instancecount); }
|
|
|
+ TexBuffer :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, loc := #caller_location) { impl_TexBuffer(target, internalformat, buffer); debug_helper(loc, 0, target, internalformat, buffer); }
|
|
|
+ PrimitiveRestartIndex :: #force_inline proc "c" (index: u32, loc := #caller_location) { impl_PrimitiveRestartIndex(index); debug_helper(loc, 0, index); }
|
|
|
+ CopyBufferSubData :: #force_inline proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location) { impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); debug_helper(loc, 0, readTarget, writeTarget, readOffset, writeOffset, size); }
|
|
|
+ GetUniformIndices :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32, loc := #caller_location) { impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices); debug_helper(loc, 0, program, uniformCount, uniformNames, uniformIndices); }
|
|
|
+ GetActiveUniformsiv :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); debug_helper(loc, 0, program, uniformCount, uniformIndices, pname, params); }
|
|
|
+ GetActiveUniformName :: #force_inline proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8, loc := #caller_location) { impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); debug_helper(loc, 0, program, uniformIndex, bufSize, length, uniformName); }
|
|
|
+ GetUniformBlockIndex :: #force_inline proc "c" (program: u32, uniformBlockName: cstring, loc := #caller_location) -> u32 { ret := impl_GetUniformBlockIndex(program, uniformBlockName); debug_helper(loc, 1, ret, program, uniformBlockName); return ret; }
|
|
|
+ GetActiveUniformBlockiv :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); debug_helper(loc, 0, program, uniformBlockIndex, pname, params); }
|
|
|
+ GetActiveUniformBlockName :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8, loc := #caller_location) { impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); debug_helper(loc, 0, program, uniformBlockIndex, bufSize, length, uniformBlockName); }
|
|
|
+ UniformBlockBinding :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32, loc := #caller_location) { impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); debug_helper(loc, 0, program, uniformBlockIndex, uniformBlockBinding); }
|
|
|
+
|
|
|
+ // VERSION_3_2
|
|
|
+ DrawElementsBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location) { impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex); debug_helper(loc, 0, mode, count, type, indices, basevertex); }
|
|
|
+ DrawRangeElementsBaseVertex :: #force_inline proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location) { impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); debug_helper(loc, 0, mode, start, end, count, type, indices, basevertex); }
|
|
|
+ DrawElementsInstancedBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, loc := #caller_location) { impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex); }
|
|
|
+ MultiDrawElementsBaseVertex :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32, loc := #caller_location) { impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex); debug_helper(loc, 0, mode, count, type, indices, drawcount, basevertex); }
|
|
|
+ ProvokingVertex :: #force_inline proc "c" (mode: u32, loc := #caller_location) { impl_ProvokingVertex(mode); debug_helper(loc, 0, mode); }
|
|
|
+ FenceSync :: #force_inline proc "c" (condition: u32, flags: u32, loc := #caller_location) -> sync_t { ret := impl_FenceSync(condition, flags); debug_helper(loc, 1, ret, condition, flags); return ret; }
|
|
|
+ IsSync :: #force_inline proc "c" (sync: sync_t, loc := #caller_location) -> bool { ret := impl_IsSync(sync); debug_helper(loc, 1, ret, sync); return ret; }
|
|
|
+ DeleteSync :: #force_inline proc "c" (sync: sync_t, loc := #caller_location) { impl_DeleteSync(sync); debug_helper(loc, 0, sync); }
|
|
|
+ ClientWaitSync :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location) -> u32 { ret := impl_ClientWaitSync(sync, flags, timeout); debug_helper(loc, 1, ret, sync, flags, timeout); return ret; }
|
|
|
+ WaitSync :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location) { impl_WaitSync(sync, flags, timeout); debug_helper(loc, 0, sync, flags, timeout); }
|
|
|
+ GetInteger64v :: #force_inline proc "c" (pname: u32, data: ^i64, loc := #caller_location) { impl_GetInteger64v(pname, data); debug_helper(loc, 0, pname, data); }
|
|
|
+ GetSynciv :: #force_inline proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32, loc := #caller_location) { impl_GetSynciv(sync, pname, bufSize, length, values); debug_helper(loc, 0, sync, pname, bufSize, length, values); }
|
|
|
+ GetInteger64i_v :: #force_inline proc "c" (target: u32, index: u32, data: ^i64, loc := #caller_location) { impl_GetInteger64i_v(target, index, data); debug_helper(loc, 0, target, index, data); }
|
|
|
+ GetBufferParameteri64v :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i64, loc := #caller_location) { impl_GetBufferParameteri64v(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ FramebufferTexture :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location) { impl_FramebufferTexture(target, attachment, texture, level); debug_helper(loc, 0, target, attachment, texture, level); }
|
|
|
+ TexImage2DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8, loc := #caller_location) { impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations); }
|
|
|
+ TexImage3DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8, loc := #caller_location) { impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations); }
|
|
|
+ GetMultisamplefv :: #force_inline proc "c" (pname: u32, index: u32, val: ^f32, loc := #caller_location) { impl_GetMultisamplefv(pname, index, val); debug_helper(loc, 0, pname, index, val); }
|
|
|
+ SampleMaski :: #force_inline proc "c" (maskNumber: u32, mask: u32, loc := #caller_location) { impl_SampleMaski(maskNumber, mask); debug_helper(loc, 0, maskNumber, mask); }
|
|
|
+
|
|
|
+ // VERSION_3_3
|
|
|
+ BindFragDataLocationIndexed :: #force_inline proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring, loc := #caller_location) { impl_BindFragDataLocationIndexed(program, colorNumber, index, name); debug_helper(loc, 0, program, colorNumber, index, name); }
|
|
|
+ GetFragDataIndex :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetFragDataIndex(program, name); debug_helper(loc, 1, ret, program, name); return ret; }
|
|
|
+ GenSamplers :: #force_inline proc "c" (count: i32, samplers: [^]u32, loc := #caller_location) { impl_GenSamplers(count, samplers); debug_helper(loc, 0, count, samplers); }
|
|
|
+ DeleteSamplers :: #force_inline proc "c" (count: i32, samplers: [^]u32, loc := #caller_location) { impl_DeleteSamplers(count, samplers); debug_helper(loc, 0, count, samplers); }
|
|
|
+ IsSampler :: #force_inline proc "c" (sampler: u32, loc := #caller_location) -> bool { ret := impl_IsSampler(sampler); debug_helper(loc, 1, ret, sampler); return ret; }
|
|
|
+ BindSampler :: #force_inline proc "c" (unit: u32, sampler: u32, loc := #caller_location) { impl_BindSampler(unit, sampler); debug_helper(loc, 0, unit, sampler); }
|
|
|
+ SamplerParameteri :: #force_inline proc "c" (sampler: u32, pname: u32, param: i32, loc := #caller_location) { impl_SamplerParameteri(sampler, pname, param); debug_helper(loc, 0, sampler, pname, param); }
|
|
|
+ SamplerParameteriv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_SamplerParameteriv(sampler, pname, param); debug_helper(loc, 0, sampler, pname, param); }
|
|
|
+ SamplerParameterf :: #force_inline proc "c" (sampler: u32, pname: u32, param: f32, loc := #caller_location) { impl_SamplerParameterf(sampler, pname, param); debug_helper(loc, 0, sampler, pname, param); }
|
|
|
+ SamplerParameterfv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^f32, loc := #caller_location) { impl_SamplerParameterfv(sampler, pname, param); debug_helper(loc, 0, sampler, pname, param); }
|
|
|
+ SamplerParameterIiv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_SamplerParameterIiv(sampler, pname, param); debug_helper(loc, 0, sampler, pname, param); }
|
|
|
+ SamplerParameterIuiv :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^u32, loc := #caller_location) { impl_SamplerParameterIuiv(sampler, pname, param); debug_helper(loc, 0, sampler, pname, param); }
|
|
|
+ GetSamplerParameteriv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetSamplerParameteriv(sampler, pname, params); debug_helper(loc, 0, sampler, pname, params); }
|
|
|
+ GetSamplerParameterIiv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetSamplerParameterIiv(sampler, pname, params); debug_helper(loc, 0, sampler, pname, params); }
|
|
|
+ GetSamplerParameterfv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]f32, loc := #caller_location) { impl_GetSamplerParameterfv(sampler, pname, params); debug_helper(loc, 0, sampler, pname, params); }
|
|
|
+ GetSamplerParameterIuiv :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_GetSamplerParameterIuiv(sampler, pname, params); debug_helper(loc, 0, sampler, pname, params); }
|
|
|
+ QueryCounter :: #force_inline proc "c" (id: u32, target: u32, loc := #caller_location) { impl_QueryCounter(id, target); debug_helper(loc, 0, id, target); }
|
|
|
+ GetQueryObjecti64v :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i64, loc := #caller_location) { impl_GetQueryObjecti64v(id, pname, params); debug_helper(loc, 0, id, pname, params); }
|
|
|
+ GetQueryObjectui64v :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u64, loc := #caller_location) { impl_GetQueryObjectui64v(id, pname, params); debug_helper(loc, 0, id, pname, params); }
|
|
|
+ VertexAttribDivisor :: #force_inline proc "c" (index: u32, divisor: u32, loc := #caller_location) { impl_VertexAttribDivisor(index, divisor); debug_helper(loc, 0, index, divisor); }
|
|
|
+ VertexAttribP1ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location) { impl_VertexAttribP1ui(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP1uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location) { impl_VertexAttribP1uiv(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP2ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location) { impl_VertexAttribP2ui(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP2uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location) { impl_VertexAttribP2uiv(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP3ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location) { impl_VertexAttribP3ui(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP3uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location) { impl_VertexAttribP3uiv(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP4ui :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location) { impl_VertexAttribP4ui(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexAttribP4uiv :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location) { impl_VertexAttribP4uiv(index, type, normalized, value); debug_helper(loc, 0, index, type, normalized, value); }
|
|
|
+ VertexP2ui :: #force_inline proc "c" (type: u32, value: u32, loc := #caller_location) { impl_VertexP2ui(type, value); debug_helper(loc, 0, type, value); }
|
|
|
+ VertexP2uiv :: #force_inline proc "c" (type: u32, value: ^u32, loc := #caller_location) { impl_VertexP2uiv(type, value); debug_helper(loc, 0, type, value); }
|
|
|
+ VertexP3ui :: #force_inline proc "c" (type: u32, value: u32, loc := #caller_location) { impl_VertexP3ui(type, value); debug_helper(loc, 0, type, value); }
|
|
|
+ VertexP3uiv :: #force_inline proc "c" (type: u32, value: ^u32, loc := #caller_location) { impl_VertexP3uiv(type, value); debug_helper(loc, 0, type, value); }
|
|
|
+ VertexP4ui :: #force_inline proc "c" (type: u32, value: u32, loc := #caller_location) { impl_VertexP4ui(type, value); debug_helper(loc, 0, type, value); }
|
|
|
+ VertexP4uiv :: #force_inline proc "c" (type: u32, value: ^u32, loc := #caller_location) { impl_VertexP4uiv(type, value); debug_helper(loc, 0, type, value); }
|
|
|
+ TexCoordP1ui :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location) { impl_TexCoordP1ui(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP1uiv :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location) { impl_TexCoordP1uiv(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP2ui :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location) { impl_TexCoordP2ui(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP2uiv :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location) { impl_TexCoordP2uiv(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP3ui :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location) { impl_TexCoordP3ui(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP3uiv :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location) { impl_TexCoordP3uiv(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP4ui :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location) { impl_TexCoordP4ui(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ TexCoordP4uiv :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location) { impl_TexCoordP4uiv(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ MultiTexCoordP1ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location) { impl_MultiTexCoordP1ui(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP1uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location) { impl_MultiTexCoordP1uiv(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP2ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location) { impl_MultiTexCoordP2ui(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP2uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location) { impl_MultiTexCoordP2uiv(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP3ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location) { impl_MultiTexCoordP3ui(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP3uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location) { impl_MultiTexCoordP3uiv(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP4ui :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location) { impl_MultiTexCoordP4ui(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ MultiTexCoordP4uiv :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location) { impl_MultiTexCoordP4uiv(texture, type, coords); debug_helper(loc, 0, texture, type, coords); }
|
|
|
+ NormalP3ui :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location) { impl_NormalP3ui(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ NormalP3uiv :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location) { impl_NormalP3uiv(type, coords); debug_helper(loc, 0, type, coords); }
|
|
|
+ ColorP3ui :: #force_inline proc "c" (type: u32, color: u32, loc := #caller_location) { impl_ColorP3ui(type, color); debug_helper(loc, 0, type, color); }
|
|
|
+ ColorP3uiv :: #force_inline proc "c" (type: u32, color: ^u32, loc := #caller_location) { impl_ColorP3uiv(type, color); debug_helper(loc, 0, type, color); }
|
|
|
+ ColorP4ui :: #force_inline proc "c" (type: u32, color: u32, loc := #caller_location) { impl_ColorP4ui(type, color); debug_helper(loc, 0, type, color); }
|
|
|
+ ColorP4uiv :: #force_inline proc "c" (type: u32, color: ^u32, loc := #caller_location) { impl_ColorP4uiv(type, color); debug_helper(loc, 0, type, color); }
|
|
|
+ SecondaryColorP3ui :: #force_inline proc "c" (type: u32, color: u32, loc := #caller_location) { impl_SecondaryColorP3ui(type, color); debug_helper(loc, 0, type, color); }
|
|
|
+ SecondaryColorP3uiv :: #force_inline proc "c" (type: u32, color: ^u32, loc := #caller_location) { impl_SecondaryColorP3uiv(type, color); debug_helper(loc, 0, type, color); }
|
|
|
+
|
|
|
+ // VERSION_4_0
|
|
|
+ MinSampleShading :: #force_inline proc "c" (value: f32, loc := #caller_location) { impl_MinSampleShading(value); debug_helper(loc, 0, value); }
|
|
|
+ BlendEquationi :: #force_inline proc "c" (buf: u32, mode: u32, loc := #caller_location) { impl_BlendEquationi(buf, mode); debug_helper(loc, 0, buf, mode); }
|
|
|
+ BlendEquationSeparatei :: #force_inline proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32, loc := #caller_location) { impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha); debug_helper(loc, 0, buf, modeRGB, modeAlpha); }
|
|
|
+ BlendFunci :: #force_inline proc "c" (buf: u32, src: u32, dst: u32, loc := #caller_location) { impl_BlendFunci(buf, src, dst); debug_helper(loc, 0, buf, src, dst); }
|
|
|
+ BlendFuncSeparatei :: #force_inline proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32, loc := #caller_location) { impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); debug_helper(loc, 0, buf, srcRGB, dstRGB, srcAlpha, dstAlpha); }
|
|
|
+ DrawArraysIndirect :: #force_inline proc "c" (mode: u32, indirect: rawptr, loc := #caller_location) { impl_DrawArraysIndirect(mode, indirect); debug_helper(loc, 0, mode, indirect); }
|
|
|
+ DrawElementsIndirect :: #force_inline proc "c" (mode: u32, type: u32, indirect: rawptr, loc := #caller_location) { impl_DrawElementsIndirect(mode, type, indirect); debug_helper(loc, 0, mode, type, indirect); }
|
|
|
+ Uniform1d :: #force_inline proc "c" (location: i32, x: f64, loc := #caller_location) { impl_Uniform1d(location, x); debug_helper(loc, 0, location, x); }
|
|
|
+ Uniform2d :: #force_inline proc "c" (location: i32, x: f64, y: f64, loc := #caller_location) { impl_Uniform2d(location, x, y); debug_helper(loc, 0, location, x, y); }
|
|
|
+ Uniform3d :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, loc := #caller_location) { impl_Uniform3d(location, x, y, z); debug_helper(loc, 0, location, x, y, z); }
|
|
|
+ Uniform4d :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location) { impl_Uniform4d(location, x, y, z, w); debug_helper(loc, 0, location, x, y, z, w); }
|
|
|
+ Uniform1dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location) { impl_Uniform1dv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform2dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location) { impl_Uniform2dv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform3dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location) { impl_Uniform3dv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ Uniform4dv :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location) { impl_Uniform4dv(location, count, value); debug_helper(loc, 0, location, count, value); }
|
|
|
+ UniformMatrix2dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix2dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix3dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix3dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix4dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix4dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix2x3dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix2x3dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix2x4dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix2x4dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix3x2dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix3x2dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix3x4dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix3x4dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix4x2dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix4x2dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ UniformMatrix4x3dv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location) { impl_UniformMatrix4x3dv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
|
|
|
+ GetUniformdv :: #force_inline proc "c" (program: u32, location: i32, params: [^]f64, loc := #caller_location) { impl_GetUniformdv(program, location, params); debug_helper(loc, 0, program, location, params); }
|
|
|
+ GetSubroutineUniformLocation :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetSubroutineUniformLocation(program, shadertype, name); debug_helper(loc, 1, ret, program, shadertype, name); return ret; }
|
|
|
+ GetSubroutineIndex :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> u32 { ret := impl_GetSubroutineIndex(program, shadertype, name); debug_helper(loc, 1, ret, program, shadertype, name); return ret; }
|
|
|
+ GetActiveSubroutineUniformiv :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32, loc := #caller_location) { impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values); debug_helper(loc, 0, program, shadertype, index, pname, values); }
|
|
|
+ GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) { impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype, index, bufsize, length, name); }
|
|
|
+ GetActiveSubroutineName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) { impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype, index, bufsize, length, name); }
|
|
|
+ UniformSubroutinesuiv :: #force_inline proc "c" (shadertype: u32, count: i32, indices: ^u32, loc := #caller_location) { impl_UniformSubroutinesuiv(shadertype, count, indices); debug_helper(loc, 0, shadertype, count, indices); }
|
|
|
+ GetUniformSubroutineuiv :: #force_inline proc "c" (shadertype: u32, location: i32, params: [^]u32, loc := #caller_location) { impl_GetUniformSubroutineuiv(shadertype, location, params); debug_helper(loc, 0, shadertype, location, params); }
|
|
|
+ GetProgramStageiv :: #force_inline proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32, loc := #caller_location) { impl_GetProgramStageiv(program, shadertype, pname, values); debug_helper(loc, 0, program, shadertype, pname, values); }
|
|
|
+ PatchParameteri :: #force_inline proc "c" (pname: u32, value: i32, loc := #caller_location) { impl_PatchParameteri(pname, value); debug_helper(loc, 0, pname, value); }
|
|
|
+ PatchParameterfv :: #force_inline proc "c" (pname: u32, values: [^]f32, loc := #caller_location) { impl_PatchParameterfv(pname, values); debug_helper(loc, 0, pname, values); }
|
|
|
+ BindTransformFeedback :: #force_inline proc "c" (target: u32, id: u32, loc := #caller_location) { impl_BindTransformFeedback(target, id); debug_helper(loc, 0, target, id); }
|
|
|
+ DeleteTransformFeedbacks :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location) { impl_DeleteTransformFeedbacks(n, ids); debug_helper(loc, 0, n, ids); }
|
|
|
+ GenTransformFeedbacks :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location) { impl_GenTransformFeedbacks(n, ids); debug_helper(loc, 0, n, ids); }
|
|
|
+ IsTransformFeedback :: #force_inline proc "c" (id: u32, loc := #caller_location) -> bool { ret := impl_IsTransformFeedback(id); debug_helper(loc, 1, ret, id); return ret; }
|
|
|
+ PauseTransformFeedback :: #force_inline proc "c" (loc := #caller_location) { impl_PauseTransformFeedback(); debug_helper(loc, 0); }
|
|
|
+ ResumeTransformFeedback :: #force_inline proc "c" (loc := #caller_location) { impl_ResumeTransformFeedback(); debug_helper(loc, 0); }
|
|
|
+ DrawTransformFeedback :: #force_inline proc "c" (mode: u32, id: u32, loc := #caller_location) { impl_DrawTransformFeedback(mode, id); debug_helper(loc, 0, mode, id); }
|
|
|
+ DrawTransformFeedbackStream :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, loc := #caller_location) { impl_DrawTransformFeedbackStream(mode, id, stream); debug_helper(loc, 0, mode, id, stream); }
|
|
|
+ BeginQueryIndexed :: #force_inline proc "c" (target: u32, index: u32, id: u32, loc := #caller_location) { impl_BeginQueryIndexed(target, index, id); debug_helper(loc, 0, target, index, id); }
|
|
|
+ EndQueryIndexed :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location) { impl_EndQueryIndexed(target, index); debug_helper(loc, 0, target, index); }
|
|
|
+ GetQueryIndexediv :: #force_inline proc "c" (target: u32, index: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetQueryIndexediv(target, index, pname, params); debug_helper(loc, 0, target, index, pname, params); }
|
|
|
+
|
|
|
+ // VERSION_4_1
|
|
|
+ ReleaseShaderCompiler :: #force_inline proc "c" (loc := #caller_location) { impl_ReleaseShaderCompiler(); debug_helper(loc, 0); }
|
|
|
+ ShaderBinary :: #force_inline proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32, loc := #caller_location) { impl_ShaderBinary(count, shaders, binaryformat, binary, length); debug_helper(loc, 0, count, shaders, binaryformat, binary, length); }
|
|
|
+ GetShaderPrecisionFormat :: #force_inline proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32, loc := #caller_location) { impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); debug_helper(loc, 0, shadertype, precisiontype, range, precision); }
|
|
|
+ DepthRangef :: #force_inline proc "c" (n: f32, f: f32, loc := #caller_location) { impl_DepthRangef(n, f); debug_helper(loc, 0, n, f); }
|
|
|
+ ClearDepthf :: #force_inline proc "c" (d: f32, loc := #caller_location) { impl_ClearDepthf(d); debug_helper(loc, 0, d); }
|
|
|
+ GetProgramBinary :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr, loc := #caller_location) { impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary); debug_helper(loc, 0, program, bufSize, length, binaryFormat, binary); }
|
|
|
+ ProgramBinary :: #force_inline proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32, loc := #caller_location) { impl_ProgramBinary(program, binaryFormat, binary, length); debug_helper(loc, 0, program, binaryFormat, binary, length); }
|
|
|
+ ProgramParameteri :: #force_inline proc "c" (program: u32, pname: u32, value: i32, loc := #caller_location) { impl_ProgramParameteri(program, pname, value); debug_helper(loc, 0, program, pname, value); }
|
|
|
+ UseProgramStages :: #force_inline proc "c" (pipeline: u32, stages: u32, program: u32, loc := #caller_location) { impl_UseProgramStages(pipeline, stages, program); debug_helper(loc, 0, pipeline, stages, program); }
|
|
|
+ ActiveShaderProgram :: #force_inline proc "c" (pipeline: u32, program: u32, loc := #caller_location) { impl_ActiveShaderProgram(pipeline, program); debug_helper(loc, 0, pipeline, program); }
|
|
|
+ CreateShaderProgramv :: #force_inline proc "c" (type: u32, count: i32, strings: [^]cstring, loc := #caller_location) -> u32 { ret := impl_CreateShaderProgramv(type, count, strings); debug_helper(loc, 1, ret, type, count, strings); return ret;; }
|
|
|
+ BindProgramPipeline :: #force_inline proc "c" (pipeline: u32, loc := #caller_location) { impl_BindProgramPipeline(pipeline); debug_helper(loc, 0, pipeline); }
|
|
|
+ DeleteProgramPipelines :: #force_inline proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location) { impl_DeleteProgramPipelines(n, pipelines); debug_helper(loc, 0, n, pipelines); }
|
|
|
+ GenProgramPipelines :: #force_inline proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location) { impl_GenProgramPipelines(n, pipelines); debug_helper(loc, 0, n, pipelines); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ ProgramUniform1ui :: #force_inline proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location) { impl_ProgramUniform1ui(program, location, v0); debug_helper(loc, 0, program, location, v0); }
|
|
|
+ ProgramUniform1uiv :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location) { impl_ProgramUniform1uiv(program, location, count, value); debug_helper(loc, 0, program, location, count, value); }
|
|
|
+ ProgramUniform2i :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location) { impl_ProgramUniform2i(program, location, v0, v1); debug_helper(loc, 0, program, location, v0, v1); }
|
|
|
+ ProgramUniform2iv :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ 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); }
|
|
|
+ GetDoublei_v :: #force_inline proc "c" (target: u32, index: u32, data: ^f64, loc := #caller_location) { impl_GetDoublei_v(target, index, data); debug_helper(loc, 0, target, index, data); }
|
|
|
+
|
|
|
+ // VERSION_4_2
|
|
|
+ DrawArraysInstancedBaseInstance :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32, loc := #caller_location) { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); debug_helper(loc, 0, mode, first, count, instancecount, baseinstance); }
|
|
|
+ DrawElementsInstancedBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32, loc := #caller_location) { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); debug_helper(loc, 0, mode, count, type, indices, instancecount, baseinstance); }
|
|
|
+ DrawElementsInstancedBaseVertexBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32, loc := #caller_location) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex, baseinstance); }
|
|
|
+ GetInternalformativ :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32, loc := #caller_location) { impl_GetInternalformativ(target, internalformat, pname, bufSize, params); debug_helper(loc, 0, target, internalformat, pname, bufSize, params); }
|
|
|
+ GetActiveAtomicCounterBufferiv :: #force_inline proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); debug_helper(loc, 0, program, bufferIndex, pname, params); }
|
|
|
+ BindImageTexture :: #force_inline proc "c" (unit: u32, texture: u32, level: i32, layered: u8, layer: i32, access: u32, format: u32, loc := #caller_location) { impl_BindImageTexture(unit, texture, level, layered, layer, access, format); debug_helper(loc, 0, unit, texture, level, layered, layer, access, format); }
|
|
|
+ MemoryBarrier :: #force_inline proc "c" (barriers: u32, loc := #caller_location) { impl_MemoryBarrier(barriers); debug_helper(loc, 0, barriers); }
|
|
|
+ TexStorage1D :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location) { impl_TexStorage1D(target, levels, internalformat, width); debug_helper(loc, 0, target, levels, internalformat, width); }
|
|
|
+ TexStorage2D :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location) { impl_TexStorage2D(target, levels, internalformat, width, height); debug_helper(loc, 0, target, levels, internalformat, width, height); }
|
|
|
+ TexStorage3D :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location) { impl_TexStorage3D(target, levels, internalformat, width, height, depth); debug_helper(loc, 0, target, levels, internalformat, width, height, depth); }
|
|
|
+ DrawTransformFeedbackInstanced :: #force_inline proc "c" (mode: u32, id: u32, instancecount: i32, loc := #caller_location) { impl_DrawTransformFeedbackInstanced(mode, id, instancecount); debug_helper(loc, 0, mode, id, instancecount); }
|
|
|
+ DrawTransformFeedbackStreamInstanced :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32, loc := #caller_location) { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); debug_helper(loc, 0, mode, id, stream, instancecount); }
|
|
|
+
|
|
|
+ // VERSION_4_3
|
|
|
+ ClearBufferData :: #force_inline proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearBufferData(target, internalformat, format, type, data); debug_helper(loc, 0, target, internalformat, format, type, data); }
|
|
|
+ ClearBufferSubData :: #force_inline proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data); debug_helper(loc, 0, target, internalformat, offset, size, format, type, data); }
|
|
|
+ DispatchCompute :: #force_inline proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32, loc := #caller_location) { impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z); debug_helper(loc, 0, num_groups_x, num_groups_y, num_groups_z); }
|
|
|
+ DispatchComputeIndirect :: #force_inline proc "c" (indirect: int, loc := #caller_location) { impl_DispatchComputeIndirect(indirect); debug_helper(loc, 0, indirect); }
|
|
|
+ CopyImageSubData :: #force_inline proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32, loc := #caller_location) { impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); debug_helper(loc, 0, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); }
|
|
|
+ FramebufferParameteri :: #force_inline proc "c" (target: u32, pname: u32, param: i32, loc := #caller_location) { impl_FramebufferParameteri(target, pname, param); debug_helper(loc, 0, target, pname, param); }
|
|
|
+ GetFramebufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetFramebufferParameteriv(target, pname, params); debug_helper(loc, 0, target, pname, params); }
|
|
|
+ GetInternalformati64v :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64, loc := #caller_location) { impl_GetInternalformati64v(target, internalformat, pname, bufSize, params); debug_helper(loc, 0, target, internalformat, pname, bufSize, params); }
|
|
|
+ InvalidateTexSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, loc := #caller_location) { impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth); }
|
|
|
+ InvalidateTexImage :: #force_inline proc "c" (texture: u32, level: i32, loc := #caller_location) { impl_InvalidateTexImage(texture, level); debug_helper(loc, 0, texture, level); }
|
|
|
+ InvalidateBufferSubData :: #force_inline proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location) { impl_InvalidateBufferSubData(buffer, offset, length); debug_helper(loc, 0, buffer, offset, length); }
|
|
|
+ InvalidateBufferData :: #force_inline proc "c" (buffer: u32, loc := #caller_location) { impl_InvalidateBufferData(buffer); debug_helper(loc, 0, buffer); }
|
|
|
+ InvalidateFramebuffer :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32, loc := #caller_location) { impl_InvalidateFramebuffer(target, numAttachments, attachments); debug_helper(loc, 0, target, numAttachments, attachments); }
|
|
|
+ InvalidateSubFramebuffer :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location) { impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); debug_helper(loc, 0, target, numAttachments, attachments, x, y, width, height); }
|
|
|
+ MultiDrawArraysIndirect :: #force_inline proc "c" (mode: u32, indirect: rawptr, drawcount: i32, stride: i32, loc := #caller_location) { impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride); debug_helper(loc, 0, mode, indirect, drawcount, stride); }
|
|
|
+ MultiDrawElementsIndirect :: #force_inline proc "c" (mode: u32, type: u32, indirect: rawptr, drawcount: i32, stride: i32, loc := #caller_location) { impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride); debug_helper(loc, 0, mode, type, indirect, drawcount, stride); }
|
|
|
+ GetProgramInterfaceiv :: #force_inline proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetProgramInterfaceiv(program, programInterface, pname, params); debug_helper(loc, 0, program, programInterface, pname, params); }
|
|
|
+ GetProgramResourceIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> u32 { ret := impl_GetProgramResourceIndex(program, programInterface, name); debug_helper(loc, 1, ret, program, programInterface, name); return ret; }
|
|
|
+ GetProgramResourceName :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8, loc := #caller_location) { impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name); debug_helper(loc, 0, program, programInterface, index, bufSize, length, name); }
|
|
|
+ GetProgramResourceiv :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32, loc := #caller_location) { impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); debug_helper(loc, 0, program, programInterface, index, propCount, props, bufSize, length, params); }
|
|
|
+ GetProgramResourceLocation :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetProgramResourceLocation(program, programInterface, name); debug_helper(loc, 1, ret, program, programInterface, name); return ret; }
|
|
|
+ GetProgramResourceLocationIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32 { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name); debug_helper(loc, 1, ret, program, programInterface, name); return ret; }
|
|
|
+ ShaderStorageBlockBinding :: #force_inline proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32, loc := #caller_location) { impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); debug_helper(loc, 0, program, storageBlockIndex, storageBlockBinding); }
|
|
|
+ TexBufferRange :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location) { impl_TexBufferRange(target, internalformat, buffer, offset, size); debug_helper(loc, 0, target, internalformat, buffer, offset, size); }
|
|
|
+ TexStorage2DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8, loc := #caller_location) { impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations); }
|
|
|
+ TexStorage3DMultisample :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8, loc := #caller_location) { impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations); }
|
|
|
+ TextureView :: #force_inline proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32, loc := #caller_location) { impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); debug_helper(loc, 0, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); }
|
|
|
+ BindVertexBuffer :: #force_inline proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location) { impl_BindVertexBuffer(bindingindex, buffer, offset, stride); debug_helper(loc, 0, bindingindex, buffer, offset, stride); }
|
|
|
+ VertexAttribFormat :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location) { impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset); debug_helper(loc, 0, attribindex, size, type, normalized, relativeoffset); }
|
|
|
+ VertexAttribIFormat :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location) { impl_VertexAttribIFormat(attribindex, size, type, relativeoffset); debug_helper(loc, 0, attribindex, size, type, relativeoffset); }
|
|
|
+ VertexAttribLFormat :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location) { impl_VertexAttribLFormat(attribindex, size, type, relativeoffset); debug_helper(loc, 0, attribindex, size, type, relativeoffset); }
|
|
|
+ VertexAttribBinding :: #force_inline proc "c" (attribindex: u32, bindingindex: u32, loc := #caller_location) { impl_VertexAttribBinding(attribindex, bindingindex); debug_helper(loc, 0, attribindex, bindingindex); }
|
|
|
+ VertexBindingDivisor :: #force_inline proc "c" (bindingindex: u32, divisor: u32, loc := #caller_location) { impl_VertexBindingDivisor(bindingindex, divisor); debug_helper(loc, 0, bindingindex, divisor); }
|
|
|
+ DebugMessageControl :: #force_inline proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: u8, loc := #caller_location) { impl_DebugMessageControl(source, type, severity, count, ids, enabled); debug_helper(loc, 0, source, type, severity, count, ids, enabled); }
|
|
|
+ DebugMessageInsert :: #force_inline proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, buf: ^u8, loc := #caller_location) { impl_DebugMessageInsert(source, type, id, severity, length, buf); debug_helper(loc, 0, source, type, id, severity, length, buf); }
|
|
|
+ DebugMessageCallback :: #force_inline proc "c" (callback: debug_proc_t, userParam: rawptr, loc := #caller_location) { impl_DebugMessageCallback(callback, userParam); debug_helper(loc, 0, callback, userParam); }
|
|
|
+ GetDebugMessageLog :: #force_inline proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8, loc := #caller_location) -> u32 { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog); debug_helper(loc, 1, ret, count, bufSize, sources, types, ids, severities, lengths, messageLog); return ret; }
|
|
|
+ PushDebugGroup :: #force_inline proc "c" (source: u32, id: u32, length: i32, message: cstring, loc := #caller_location) { impl_PushDebugGroup(source, id, length, message); debug_helper(loc, 0, source, id, length, message); }
|
|
|
+ PopDebugGroup :: #force_inline proc "c" (loc := #caller_location) { impl_PopDebugGroup(); debug_helper(loc, 0); }
|
|
|
+ ObjectLabel :: #force_inline proc "c" (identifier: u32, name: u32, length: i32, label: [^]u8, loc := #caller_location) { impl_ObjectLabel(identifier, name, length, label); debug_helper(loc, 0, identifier, name, length, label); }
|
|
|
+ GetObjectLabel :: #force_inline proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location) { impl_GetObjectLabel(identifier, name, bufSize, length, label); debug_helper(loc, 0, identifier, name, bufSize, length, label); }
|
|
|
+ ObjectPtrLabel :: #force_inline proc "c" (ptr: rawptr, length: i32, label: [^]u8, loc := #caller_location) { impl_ObjectPtrLabel(ptr, length, label); debug_helper(loc, 0, ptr, length, label); }
|
|
|
+ GetObjectPtrLabel :: #force_inline proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location) { impl_GetObjectPtrLabel(ptr, bufSize, length, label); debug_helper(loc, 0, ptr, bufSize, length, label); }
|
|
|
+
|
|
|
+ // VERSION_4_4
|
|
|
+ BufferStorage :: #force_inline proc "c" (target: u32, size: int, data: rawptr, flags: u32, loc := #caller_location) { impl_BufferStorage(target, size, data, flags); debug_helper(loc, 0, target, size, data, flags); }
|
|
|
+ ClearTexImage :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearTexImage(texture, level, format, type, data); debug_helper(loc, 0, texture, level, format, type, data); }
|
|
|
+ ClearTexSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); }
|
|
|
+ BindBuffersBase :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, loc := #caller_location) { impl_BindBuffersBase(target, first, count, buffers); debug_helper(loc, 0, target, first, count, buffers); }
|
|
|
+ BindBuffersRange :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int, loc := #caller_location) { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes); debug_helper(loc, 0, target, first, count, buffers, offsets, sizes); }
|
|
|
+ BindTextures :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location) { impl_BindTextures(first, count, textures); debug_helper(loc, 0, first, count, textures); }
|
|
|
+ BindSamplers :: #force_inline proc "c" (first: u32, count: i32, samplers: [^]u32, loc := #caller_location) { impl_BindSamplers(first, count, samplers); debug_helper(loc, 0, first, count, samplers); }
|
|
|
+ BindImageTextures :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location) { impl_BindImageTextures(first, count, textures); debug_helper(loc, 0, first, count, textures); }
|
|
|
+ BindVertexBuffers :: #force_inline proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location) { impl_BindVertexBuffers(first, count, buffers, offsets, strides); debug_helper(loc, 0, first, count, buffers, offsets, strides); }
|
|
|
+
|
|
|
+ // VERSION_4_5
|
|
|
+ ClipControl :: #force_inline proc "c" (origin: u32, depth: u32, loc := #caller_location) { impl_ClipControl(origin, depth); debug_helper(loc, 0, origin, depth); }
|
|
|
+ CreateTransformFeedbacks :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location) { impl_CreateTransformFeedbacks(n, ids); debug_helper(loc, 0, n, ids); }
|
|
|
+ TransformFeedbackBufferBase :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, loc := #caller_location) { impl_TransformFeedbackBufferBase(xfb, index, buffer); debug_helper(loc, 0, xfb, index, buffer); }
|
|
|
+ TransformFeedbackBufferRange :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location) { impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size); debug_helper(loc, 0, xfb, index, buffer, offset, size); }
|
|
|
+ GetTransformFeedbackiv :: #force_inline proc "c" (xfb: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_GetTransformFeedbackiv(xfb, pname, param); debug_helper(loc, 0, xfb, pname, param); }
|
|
|
+ GetTransformFeedbacki_v :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32, loc := #caller_location) { impl_GetTransformFeedbacki_v(xfb, pname, index, param); debug_helper(loc, 0, xfb, pname, index, param); }
|
|
|
+ GetTransformFeedbacki64_v :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64, loc := #caller_location) { impl_GetTransformFeedbacki64_v(xfb, pname, index, param); debug_helper(loc, 0, xfb, pname, index, param); }
|
|
|
+ CreateBuffers :: #force_inline proc "c" (n: i32, buffers: [^]u32, loc := #caller_location) { impl_CreateBuffers(n, buffers); debug_helper(loc, 0, n, buffers); }
|
|
|
+ NamedBufferStorage :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, flags: u32, loc := #caller_location) { impl_NamedBufferStorage(buffer, size, data, flags); debug_helper(loc, 0, buffer, size, data, flags); }
|
|
|
+ NamedBufferData :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, usage: u32, loc := #caller_location) { impl_NamedBufferData(buffer, size, data, usage); debug_helper(loc, 0, buffer, size, data, usage); }
|
|
|
+ NamedBufferSubData :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location) { impl_NamedBufferSubData(buffer, offset, size, data); debug_helper(loc, 0, buffer, offset, size, data); }
|
|
|
+ CopyNamedBufferSubData :: #force_inline proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location) { impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size); debug_helper(loc, 0, readBuffer, writeBuffer, readOffset, writeOffset, size); }
|
|
|
+ ClearNamedBufferData :: #force_inline proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearNamedBufferData(buffer, internalformat, format, type, data); debug_helper(loc, 0, buffer, internalformat, format, type, data); }
|
|
|
+ ClearNamedBufferSubData :: #force_inline proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data); debug_helper(loc, 0, buffer, internalformat, offset, size, format, type, data); }
|
|
|
+ MapNamedBuffer :: #force_inline proc "c" (buffer: u32, access: u32, loc := #caller_location) -> rawptr { ret := impl_MapNamedBuffer(buffer, access); debug_helper(loc, 1, ret, buffer, access); return ret; }
|
|
|
+ MapNamedBufferRange :: #force_inline proc "c" (buffer: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr { ret := impl_MapNamedBufferRange(buffer, offset, length, access); debug_helper(loc, 1, ret, buffer, offset, length, access); return ret; }
|
|
|
+ UnmapNamedBuffer :: #force_inline proc "c" (buffer: u32, loc := #caller_location) -> bool { ret := impl_UnmapNamedBuffer(buffer); debug_helper(loc, 1, ret, buffer); return ret; }
|
|
|
+ FlushMappedNamedBufferRange :: #force_inline proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location) { impl_FlushMappedNamedBufferRange(buffer, offset, length); debug_helper(loc, 0, buffer, offset, length); }
|
|
|
+ GetNamedBufferParameteriv :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetNamedBufferParameteriv(buffer, pname, params); debug_helper(loc, 0, buffer, pname, params); }
|
|
|
+ GetNamedBufferParameteri64v :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i64, loc := #caller_location) { impl_GetNamedBufferParameteri64v(buffer, pname, params); debug_helper(loc, 0, buffer, pname, params); }
|
|
|
+ GetNamedBufferPointerv :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]rawptr, loc := #caller_location) { impl_GetNamedBufferPointerv(buffer, pname, params); debug_helper(loc, 0, buffer, pname, params); }
|
|
|
+ GetNamedBufferSubData :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location) { impl_GetNamedBufferSubData(buffer, offset, size, data); debug_helper(loc, 0, buffer, offset, size, data); }
|
|
|
+ CreateFramebuffers :: #force_inline proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location) { impl_CreateFramebuffers(n, framebuffers); debug_helper(loc, 0, n, framebuffers); }
|
|
|
+ NamedFramebufferRenderbuffer :: #force_inline proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location) { impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer); debug_helper(loc, 0, framebuffer, attachment, renderbuffertarget, renderbuffer); }
|
|
|
+ NamedFramebufferParameteri :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: i32, loc := #caller_location) { impl_NamedFramebufferParameteri(framebuffer, pname, param); debug_helper(loc, 0, framebuffer, pname, param); }
|
|
|
+ NamedFramebufferTexture :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location) { impl_NamedFramebufferTexture(framebuffer, attachment, texture, level); debug_helper(loc, 0, framebuffer, attachment, texture, level); }
|
|
|
+ NamedFramebufferTextureLayer :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location) { impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer); debug_helper(loc, 0, framebuffer, attachment, texture, level, layer); }
|
|
|
+ NamedFramebufferDrawBuffer :: #force_inline proc "c" (framebuffer: u32, buf: u32, loc := #caller_location) { impl_NamedFramebufferDrawBuffer(framebuffer, buf); debug_helper(loc, 0, framebuffer, buf); }
|
|
|
+ NamedFramebufferDrawBuffers :: #force_inline proc "c" (framebuffer: u32, n: i32, bufs: [^]u32, loc := #caller_location) { impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs); debug_helper(loc, 0, framebuffer, n, bufs); }
|
|
|
+ NamedFramebufferReadBuffer :: #force_inline proc "c" (framebuffer: u32, src: u32, loc := #caller_location) { impl_NamedFramebufferReadBuffer(framebuffer, src); debug_helper(loc, 0, framebuffer, src); }
|
|
|
+ InvalidateNamedFramebufferData :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32, loc := #caller_location) { impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments); debug_helper(loc, 0, framebuffer, numAttachments, attachments); }
|
|
|
+ InvalidateNamedFramebufferSubData :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location) { impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height); debug_helper(loc, 0, framebuffer, numAttachments, attachments, x, y, width, height); }
|
|
|
+ ClearNamedFramebufferiv :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location) { impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value); debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value); }
|
|
|
+ ClearNamedFramebufferuiv :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location) { impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value); debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value); }
|
|
|
+ ClearNamedFramebufferfv :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location) { impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value); debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value); }
|
|
|
+ ClearNamedFramebufferfi :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location) { impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil); debug_helper(loc, 0, framebuffer, buffer, drawbuffer, depth, stencil); }
|
|
|
+ BlitNamedFramebuffer :: #force_inline proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) { impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); }
|
|
|
+ CheckNamedFramebufferStatus :: #force_inline proc "c" (framebuffer: u32, target: u32, loc := #caller_location) -> u32 { ret := impl_CheckNamedFramebufferStatus(framebuffer, target); debug_helper(loc, 1, ret, framebuffer, target); return ret; }
|
|
|
+ GetNamedFramebufferParameteriv :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_GetNamedFramebufferParameteriv(framebuffer, pname, param); debug_helper(loc, 0, framebuffer, pname, param); }
|
|
|
+ GetNamedFramebufferAttachmentParameteriv :: #force_inline proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params); debug_helper(loc, 0, framebuffer, attachment, pname, params); }
|
|
|
+ CreateRenderbuffers :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location) { impl_CreateRenderbuffers(n, renderbuffers); debug_helper(loc, 0, n, renderbuffers); }
|
|
|
+ NamedRenderbufferStorage :: #force_inline proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location) { impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height); debug_helper(loc, 0, renderbuffer, internalformat, width, height); }
|
|
|
+ NamedRenderbufferStorageMultisample :: #force_inline proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location) { impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height); debug_helper(loc, 0, renderbuffer, samples, internalformat, width, height); }
|
|
|
+ GetNamedRenderbufferParameteriv :: #force_inline proc "c" (renderbuffer: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params); debug_helper(loc, 0, renderbuffer, pname, params); }
|
|
|
+ CreateTextures :: #force_inline proc "c" (target: u32, n: i32, textures: [^]u32, loc := #caller_location) { impl_CreateTextures(target, n, textures); debug_helper(loc, 0, target, n, textures); }
|
|
|
+ TextureBuffer :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, loc := #caller_location) { impl_TextureBuffer(texture, internalformat, buffer); debug_helper(loc, 0, texture, internalformat, buffer); }
|
|
|
+ TextureBufferRange :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location) { impl_TextureBufferRange(texture, internalformat, buffer, offset, size); debug_helper(loc, 0, texture, internalformat, buffer, offset, size); }
|
|
|
+ TextureStorage1D :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location) { impl_TextureStorage1D(texture, levels, internalformat, width); debug_helper(loc, 0, texture, levels, internalformat, width); }
|
|
|
+ TextureStorage2D :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location) { impl_TextureStorage2D(texture, levels, internalformat, width, height); debug_helper(loc, 0, texture, levels, internalformat, width, height); }
|
|
|
+ TextureStorage3D :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location) { impl_TextureStorage3D(texture, levels, internalformat, width, height, depth); debug_helper(loc, 0, texture, levels, internalformat, width, height, depth); }
|
|
|
+ TextureStorage2DMultisample :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8, loc := #caller_location) { impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations); debug_helper(loc, 0, texture, samples, internalformat, width, height, fixedsamplelocations); }
|
|
|
+ TextureStorage3DMultisample :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8, loc := #caller_location) { impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, texture, samples, internalformat, width, height, depth, fixedsamplelocations); }
|
|
|
+ TextureSubImage1D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) { impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels); debug_helper(loc, 0, texture, level, xoffset, width, format, type, pixels); }
|
|
|
+ TextureSubImage2D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) { impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels); debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, type, pixels); }
|
|
|
+ TextureSubImage3D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) { impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
|
|
|
+ CompressedTextureSubImage1D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data); debug_helper(loc, 0, texture, level, xoffset, width, format, imageSize, data); }
|
|
|
+ CompressedTextureSubImage2D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, imageSize, data); }
|
|
|
+ CompressedTextureSubImage3D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
|
|
|
+ CopyTextureSubImage1D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location) { impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width); debug_helper(loc, 0, texture, level, xoffset, x, y, width); }
|
|
|
+ CopyTextureSubImage2D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location) { impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height); debug_helper(loc, 0, texture, level, xoffset, yoffset, x, y, width, height); }
|
|
|
+ CopyTextureSubImage3D :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location) { impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, x, y, width, height); }
|
|
|
+ TextureParameterf :: #force_inline proc "c" (texture: u32, pname: u32, param: f32, loc := #caller_location) { impl_TextureParameterf(texture, pname, param); debug_helper(loc, 0, texture, pname, param); }
|
|
|
+ TextureParameterfv :: #force_inline proc "c" (texture: u32, pname: u32, param: ^f32, loc := #caller_location) { impl_TextureParameterfv(texture, pname, param); debug_helper(loc, 0, texture, pname, param); }
|
|
|
+ TextureParameteri :: #force_inline proc "c" (texture: u32, pname: u32, param: i32, loc := #caller_location) { impl_TextureParameteri(texture, pname, param); debug_helper(loc, 0, texture, pname, param); }
|
|
|
+ TextureParameterIiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_TextureParameterIiv(texture, pname, params); debug_helper(loc, 0, texture, pname, params); }
|
|
|
+ TextureParameterIuiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_TextureParameterIuiv(texture, pname, params); debug_helper(loc, 0, texture, pname, params); }
|
|
|
+ TextureParameteriv :: #force_inline proc "c" (texture: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_TextureParameteriv(texture, pname, param); debug_helper(loc, 0, texture, pname, param); }
|
|
|
+ GenerateTextureMipmap :: #force_inline proc "c" (texture: u32, loc := #caller_location) { impl_GenerateTextureMipmap(texture); debug_helper(loc, 0, texture); }
|
|
|
+ BindTextureUnit :: #force_inline proc "c" (unit: u32, texture: u32, loc := #caller_location) { impl_BindTextureUnit(unit, texture); debug_helper(loc, 0, unit, texture); }
|
|
|
+ GetTextureImage :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location) { impl_GetTextureImage(texture, level, format, type, bufSize, pixels); debug_helper(loc, 0, texture, level, format, type, bufSize, pixels); }
|
|
|
+ GetCompressedTextureImage :: #force_inline proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr, loc := #caller_location) { impl_GetCompressedTextureImage(texture, level, bufSize, pixels); debug_helper(loc, 0, texture, level, bufSize, pixels); }
|
|
|
+ GetTextureLevelParameterfv :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location) { impl_GetTextureLevelParameterfv(texture, level, pname, params); debug_helper(loc, 0, texture, level, pname, params); }
|
|
|
+ GetTextureLevelParameteriv :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetTextureLevelParameteriv(texture, level, pname, params); debug_helper(loc, 0, texture, level, pname, params); }
|
|
|
+ GetTextureParameterfv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]f32, loc := #caller_location) { impl_GetTextureParameterfv(texture, pname, params); debug_helper(loc, 0, texture, pname, params); }
|
|
|
+ GetTextureParameterIiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetTextureParameterIiv(texture, pname, params); debug_helper(loc, 0, texture, pname, params); }
|
|
|
+ GetTextureParameterIuiv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location) { impl_GetTextureParameterIuiv(texture, pname, params); debug_helper(loc, 0, texture, pname, params); }
|
|
|
+ GetTextureParameteriv :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location) { impl_GetTextureParameteriv(texture, pname, params); debug_helper(loc, 0, texture, pname, params); }
|
|
|
+ CreateVertexArrays :: #force_inline proc "c" (n: i32, arrays: [^]u32, loc := #caller_location) { impl_CreateVertexArrays(n, arrays); debug_helper(loc, 0, n, arrays); }
|
|
|
+ DisableVertexArrayAttrib :: #force_inline proc "c" (vaobj: u32, index: u32, loc := #caller_location) { impl_DisableVertexArrayAttrib(vaobj, index); debug_helper(loc, 0, vaobj, index); }
|
|
|
+ EnableVertexArrayAttrib :: #force_inline proc "c" (vaobj: u32, index: u32, loc := #caller_location) { impl_EnableVertexArrayAttrib(vaobj, index); debug_helper(loc, 0, vaobj, index); }
|
|
|
+ VertexArrayElementBuffer :: #force_inline proc "c" (vaobj: u32, buffer: u32, loc := #caller_location) { impl_VertexArrayElementBuffer(vaobj, buffer); debug_helper(loc, 0, vaobj, buffer); }
|
|
|
+ VertexArrayVertexBuffer :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location) { impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride); debug_helper(loc, 0, vaobj, bindingindex, buffer, offset, stride); }
|
|
|
+ VertexArrayVertexBuffers :: #force_inline proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location) { impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides); debug_helper(loc, 0, vaobj, first, count, buffers, offsets, strides); }
|
|
|
+ VertexArrayAttribBinding :: #force_inline proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32, loc := #caller_location) { impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex); debug_helper(loc, 0, vaobj, attribindex, bindingindex); }
|
|
|
+ VertexArrayAttribFormat :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location) { impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset); debug_helper(loc, 0, vaobj, attribindex, size, type, normalized, relativeoffset); }
|
|
|
+ VertexArrayAttribIFormat :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location) { impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset); debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset); }
|
|
|
+ VertexArrayAttribLFormat :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location) { impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset); debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset); }
|
|
|
+ VertexArrayBindingDivisor :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, divisor: u32, loc := #caller_location) { impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor); debug_helper(loc, 0, vaobj, bindingindex, divisor); }
|
|
|
+ GetVertexArrayiv :: #force_inline proc "c" (vaobj: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_GetVertexArrayiv(vaobj, pname, param); debug_helper(loc, 0, vaobj, pname, param); }
|
|
|
+ GetVertexArrayIndexediv :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32, loc := #caller_location) { impl_GetVertexArrayIndexediv(vaobj, index, pname, param); debug_helper(loc, 0, vaobj, index, pname, param); }
|
|
|
+ GetVertexArrayIndexed64iv :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64, loc := #caller_location) { impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param); debug_helper(loc, 0, vaobj, index, pname, param); }
|
|
|
+ CreateSamplers :: #force_inline proc "c" (n: i32, samplers: [^]u32, loc := #caller_location) { impl_CreateSamplers(n, samplers); debug_helper(loc, 0, n, samplers); }
|
|
|
+ CreateProgramPipelines :: #force_inline proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location) { impl_CreateProgramPipelines(n, pipelines); debug_helper(loc, 0, n, pipelines); }
|
|
|
+ CreateQueries :: #force_inline proc "c" (target: u32, n: i32, ids: [^]u32, loc := #caller_location) { impl_CreateQueries(target, n, ids); debug_helper(loc, 0, target, n, ids); }
|
|
|
+ GetQueryBufferObjecti64v :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location) { impl_GetQueryBufferObjecti64v(id, buffer, pname, offset); debug_helper(loc, 0, id, buffer, pname, offset); }
|
|
|
+ GetQueryBufferObjectiv :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location) { impl_GetQueryBufferObjectiv(id, buffer, pname, offset); debug_helper(loc, 0, id, buffer, pname, offset); }
|
|
|
+ GetQueryBufferObjectui64v :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location) { impl_GetQueryBufferObjectui64v(id, buffer, pname, offset); debug_helper(loc, 0, id, buffer, pname, offset); }
|
|
|
+ GetQueryBufferObjectuiv :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location) { impl_GetQueryBufferObjectuiv(id, buffer, pname, offset); debug_helper(loc, 0, id, buffer, pname, offset); }
|
|
|
+ MemoryBarrierByRegion :: #force_inline proc "c" (barriers: u32, loc := #caller_location) { impl_MemoryBarrierByRegion(barriers); debug_helper(loc, 0, barriers); }
|
|
|
+ GetTextureSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location) { impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); }
|
|
|
+ GetCompressedTextureSubImage :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr, loc := #caller_location) { impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels); }
|
|
|
+ GetGraphicsResetStatus :: #force_inline proc "c" (loc := #caller_location) -> u32 { ret := impl_GetGraphicsResetStatus(); debug_helper(loc, 1, ret); return ret; }
|
|
|
+ GetnCompressedTexImage :: #force_inline proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr, loc := #caller_location) { impl_GetnCompressedTexImage(target, lod, bufSize, pixels); debug_helper(loc, 0, target, lod, bufSize, pixels); }
|
|
|
+ GetnTexImage :: #force_inline proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location) { impl_GetnTexImage(target, level, format, type, bufSize, pixels); debug_helper(loc, 0, target, level, format, type, bufSize, pixels); }
|
|
|
+ GetnUniformdv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64, loc := #caller_location) { impl_GetnUniformdv(program, location, bufSize, params); debug_helper(loc, 0, program, location, bufSize, params); }
|
|
|
+ GetnUniformfv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32, loc := #caller_location) { impl_GetnUniformfv(program, location, bufSize, params); debug_helper(loc, 0, program, location, bufSize, params); }
|
|
|
+ GetnUniformiv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32, loc := #caller_location) { impl_GetnUniformiv(program, location, bufSize, params); debug_helper(loc, 0, program, location, bufSize, params); }
|
|
|
+ GetnUniformuiv :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32, loc := #caller_location) { impl_GetnUniformuiv(program, location, bufSize, params); debug_helper(loc, 0, program, location, bufSize, params); }
|
|
|
+ ReadnPixels :: #force_inline proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr, loc := #caller_location) { impl_ReadnPixels(x, y, width, height, format, type, bufSize, data); debug_helper(loc, 0, x, y, width, height, format, type, bufSize, data); }
|
|
|
+ GetnMapdv :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f64, loc := #caller_location) { impl_GetnMapdv(target, query, bufSize, v); debug_helper(loc, 0, target, query, bufSize, v); }
|
|
|
+ GetnMapfv :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f32, loc := #caller_location) { impl_GetnMapfv(target, query, bufSize, v); debug_helper(loc, 0, target, query, bufSize, v); }
|
|
|
+ GetnMapiv :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^i32, loc := #caller_location) { impl_GetnMapiv(target, query, bufSize, v); debug_helper(loc, 0, target, query, bufSize, v); }
|
|
|
+ GetnPixelMapusv :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u16, loc := #caller_location) { impl_GetnPixelMapusv(map_, bufSize, values); debug_helper(loc, 0, map_, bufSize, values); }
|
|
|
+ GetnPixelMapfv :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]f32, loc := #caller_location) { impl_GetnPixelMapfv(map_, bufSize, values); debug_helper(loc, 0, map_, bufSize, values); }
|
|
|
+ GetnPixelMapuiv :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u32, loc := #caller_location) { impl_GetnPixelMapuiv(map_, bufSize, values); debug_helper(loc, 0, map_, bufSize, values); }
|
|
|
+ GetnPolygonStipple :: #force_inline proc "c" (bufSize: i32, pattern: ^u8, loc := #caller_location) { impl_GetnPolygonStipple(bufSize, pattern); debug_helper(loc, 0, bufSize, pattern); }
|
|
|
+ GetnColorTable :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr, loc := #caller_location) { impl_GetnColorTable(target, format, type, bufSize, table); debug_helper(loc, 0, target, format, type, bufSize, table); }
|
|
|
+ GetnConvolutionFilter :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr, loc := #caller_location) { impl_GetnConvolutionFilter(target, format, type, bufSize, image); debug_helper(loc, 0, target, format, type, bufSize, image); }
|
|
|
+ GetnSeparableFilter :: #force_inline proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr, loc := #caller_location) { impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span); debug_helper(loc, 0, target, format, type, rowBufSize, row, columnBufSize, column, span); }
|
|
|
+ GetnHistogram :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location) { impl_GetnHistogram(target, reset, format, type, bufSize, values); debug_helper(loc, 0, target, reset, format, type, bufSize, values); }
|
|
|
+ GetnMinmax :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location) { impl_GetnMinmax(target, reset, format, type, bufSize, values); debug_helper(loc, 0, target, reset, format, type, bufSize, values); }
|
|
|
+ TextureBarrier :: #force_inline proc "c" (loc := #caller_location) { impl_TextureBarrier(); debug_helper(loc, 0); }
|
|
|
+ GetUnsignedBytevEXT :: #force_inline proc "c" (pname: u32, data: ^byte, loc := #caller_location) { impl_glGetUnsignedBytevEXT(pname, data); debug_helper(loc, 0, pname, data); }
|
|
|
+ TexPageCommitmentARB :: #force_inline proc "c"(
|
|
|
+ target: u32,
|
|
|
+ level: i32,
|
|
|
+ xoffset: i32,
|
|
|
+ yoffset: i32,
|
|
|
+ zoffset: i32,
|
|
|
+ width: i32,
|
|
|
+ height: i32,
|
|
|
+ depth: i32,
|
|
|
+ commit: bool,
|
|
|
+ loc := #caller_location,
|
|
|
+ ) {
|
|
|
+ impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
|
|
|
+ debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
|
|
|
+ }
|
|
|
+ // VERSION_4_6
|
|
|
+ SpecializeShader :: #force_inline proc "c" (shader: u32, pEntryPoint: ^u8, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32, loc := #caller_location) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); debug_helper(loc, 0, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); }
|
|
|
+ MultiDrawArraysIndirectCount :: #force_inline proc "c" (mode: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32, loc := #caller_location) { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride); debug_helper(loc, 0, mode, indirect, drawcount, maxdrawcount, stride); }
|
|
|
+ MultiDrawElementsIndirectCount :: #force_inline proc "c" (mode: i32, type: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32, loc := #caller_location) { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride); debug_helper(loc, 0, mode, type, indirect, drawcount, maxdrawcount, stride); }
|
|
|
+ PolygonOffsetClamp :: #force_inline proc "c" (factor, units, clamp: f32, loc := #caller_location) { impl_PolygonOffsetClamp(factor, units, clamp); debug_helper(loc, 0, factor, units, clamp); }
|
|
|
+}
|
gingerBill