use super::*;
pub unsafe fn load_gl_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
trace!("Loading all GL functions...");
load_all_functions(&mut load_fn)
}
unsafe fn load_all_functions(
load_fn: &mut dyn FnMut(*const c_char) -> *const c_void,
) {
ActiveTexture::load_with(&mut *load_fn);
AttachShader::load_with(&mut *load_fn);
BeginConditionalRender::load_with(&mut *load_fn);
BeginQuery::load_with(&mut *load_fn);
BeginTransformFeedback::load_with(&mut *load_fn);
BindAttribLocation::load_with(&mut *load_fn);
BindBuffer::load_with(&mut *load_fn);
BindBufferBase::load_with(&mut *load_fn);
BindBufferRange::load_with(&mut *load_fn);
BindFragDataLocation::load_with(&mut *load_fn);
BindFragDataLocationIndexed::load_with(&mut *load_fn);
BindFramebuffer::load_with(&mut *load_fn);
BindRenderbuffer::load_with(&mut *load_fn);
BindSampler::load_with(&mut *load_fn);
BindTexture::load_with(&mut *load_fn);
BindVertexArray::load_with(&mut *load_fn);
BlendColor::load_with(&mut *load_fn);
BlendEquation::load_with(&mut *load_fn);
BlendEquationSeparate::load_with(&mut *load_fn);
BlendFunc::load_with(&mut *load_fn);
BlendFuncSeparate::load_with(&mut *load_fn);
BlitFramebuffer::load_with(&mut *load_fn);
BufferData::load_with(&mut *load_fn);
BufferSubData::load_with(&mut *load_fn);
CheckFramebufferStatus::load_with(&mut *load_fn);
ClampColor::load_with(&mut *load_fn);
Clear::load_with(&mut *load_fn);
ClearBufferfi::load_with(&mut *load_fn);
ClearBufferfv::load_with(&mut *load_fn);
ClearBufferiv::load_with(&mut *load_fn);
ClearBufferuiv::load_with(&mut *load_fn);
ClearColor::load_with(&mut *load_fn);
ClearDepth::load_with(&mut *load_fn);
ClearStencil::load_with(&mut *load_fn);
ClientWaitSync::load_with(&mut *load_fn);
ColorMask::load_with(&mut *load_fn);
ColorMaski::load_with(&mut *load_fn);
#[cfg(feature = "compatibility_profile")]
{
ColorP3ui::load_with(&mut *load_fn);
ColorP3uiv::load_with(&mut *load_fn);
ColorP4ui::load_with(&mut *load_fn);
ColorP4uiv::load_with(&mut *load_fn);
}
CompileShader::load_with(&mut *load_fn);
CompressedTexImage1D::load_with(&mut *load_fn);
CompressedTexImage2D::load_with(&mut *load_fn);
CompressedTexImage3D::load_with(&mut *load_fn);
CompressedTexSubImage1D::load_with(&mut *load_fn);
CompressedTexSubImage2D::load_with(&mut *load_fn);
CompressedTexSubImage3D::load_with(&mut *load_fn);
CopyBufferSubData::load_with(&mut *load_fn);
CopyTexImage1D::load_with(&mut *load_fn);
CopyTexImage2D::load_with(&mut *load_fn);
CopyTexSubImage1D::load_with(&mut *load_fn);
CopyTexSubImage2D::load_with(&mut *load_fn);
CopyTexSubImage3D::load_with(&mut *load_fn);
CreateProgram::load_with(&mut *load_fn);
CreateShader::load_with(&mut *load_fn);
CullFace::load_with(&mut *load_fn);
DeleteBuffers::load_with(&mut *load_fn);
DeleteFramebuffers::load_with(&mut *load_fn);
DeleteProgram::load_with(&mut *load_fn);
DeleteQueries::load_with(&mut *load_fn);
DeleteRenderbuffers::load_with(&mut *load_fn);
DeleteSamplers::load_with(&mut *load_fn);
DeleteShader::load_with(&mut *load_fn);
DeleteSync::load_with(&mut *load_fn);
DeleteTextures::load_with(&mut *load_fn);
DeleteVertexArrays::load_with(&mut *load_fn);
DepthFunc::load_with(&mut *load_fn);
DepthMask::load_with(&mut *load_fn);
DepthRange::load_with(&mut *load_fn);
DetachShader::load_with(&mut *load_fn);
Disable::load_with(&mut *load_fn);
DisableVertexAttribArray::load_with(&mut *load_fn);
Disablei::load_with(&mut *load_fn);
DrawArrays::load_with(&mut *load_fn);
DrawArraysInstanced::load_with(&mut *load_fn);
DrawBuffer::load_with(&mut *load_fn);
DrawBuffers::load_with(&mut *load_fn);
DrawElements::load_with(&mut *load_fn);
DrawElementsBaseVertex::load_with(&mut *load_fn);
DrawElementsInstanced::load_with(&mut *load_fn);
DrawElementsInstancedBaseVertex::load_with(&mut *load_fn);
DrawRangeElements::load_with(&mut *load_fn);
DrawRangeElementsBaseVertex::load_with(&mut *load_fn);
Enable::load_with(&mut *load_fn);
EnableVertexAttribArray::load_with(&mut *load_fn);
Enablei::load_with(&mut *load_fn);
EndConditionalRender::load_with(&mut *load_fn);
EndQuery::load_with(&mut *load_fn);
EndTransformFeedback::load_with(&mut *load_fn);
FenceSync::load_with(&mut *load_fn);
Finish::load_with(&mut *load_fn);
Flush::load_with(&mut *load_fn);
FlushMappedBufferRange::load_with(&mut *load_fn);
FramebufferRenderbuffer::load_with(&mut *load_fn);
FramebufferTexture::load_with(&mut *load_fn);
FramebufferTexture1D::load_with(&mut *load_fn);
FramebufferTexture2D::load_with(&mut *load_fn);
FramebufferTexture3D::load_with(&mut *load_fn);
FramebufferTextureLayer::load_with(&mut *load_fn);
FrontFace::load_with(&mut *load_fn);
GenBuffers::load_with(&mut *load_fn);
GenFramebuffers::load_with(&mut *load_fn);
GenQueries::load_with(&mut *load_fn);
GenRenderbuffers::load_with(&mut *load_fn);
GenSamplers::load_with(&mut *load_fn);
GenTextures::load_with(&mut *load_fn);
GenVertexArrays::load_with(&mut *load_fn);
GenerateMipmap::load_with(&mut *load_fn);
GetActiveAttrib::load_with(&mut *load_fn);
GetActiveUniform::load_with(&mut *load_fn);
GetActiveUniformBlockName::load_with(&mut *load_fn);
GetActiveUniformBlockiv::load_with(&mut *load_fn);
GetActiveUniformName::load_with(&mut *load_fn);
GetActiveUniformsiv::load_with(&mut *load_fn);
GetAttachedShaders::load_with(&mut *load_fn);
GetAttribLocation::load_with(&mut *load_fn);
GetBooleani_v::load_with(&mut *load_fn);
GetBooleanv::load_with(&mut *load_fn);
GetBufferParameteri64v::load_with(&mut *load_fn);
GetBufferParameteriv::load_with(&mut *load_fn);
GetBufferPointerv::load_with(&mut *load_fn);
GetBufferSubData::load_with(&mut *load_fn);
GetCompressedTexImage::load_with(&mut *load_fn);
GetDoublev::load_with(&mut *load_fn);
GetError::load_with(&mut *load_fn);
GetFloatv::load_with(&mut *load_fn);
GetFragDataIndex::load_with(&mut *load_fn);
GetFragDataLocation::load_with(&mut *load_fn);
GetFramebufferAttachmentParameteriv::load_with(&mut *load_fn);
GetInteger64i_v::load_with(&mut *load_fn);
GetInteger64v::load_with(&mut *load_fn);
GetIntegeri_v::load_with(&mut *load_fn);
GetIntegerv::load_with(&mut *load_fn);
GetMultisamplefv::load_with(&mut *load_fn);
GetProgramInfoLog::load_with(&mut *load_fn);
GetProgramiv::load_with(&mut *load_fn);
GetQueryObjecti64v::load_with(&mut *load_fn);
GetQueryObjectiv::load_with(&mut *load_fn);
GetQueryObjectui64v::load_with(&mut *load_fn);
GetQueryObjectuiv::load_with(&mut *load_fn);
GetQueryiv::load_with(&mut *load_fn);
GetRenderbufferParameteriv::load_with(&mut *load_fn);
GetSamplerParameterIiv::load_with(&mut *load_fn);
GetSamplerParameterIuiv::load_with(&mut *load_fn);
GetSamplerParameterfv::load_with(&mut *load_fn);
GetSamplerParameteriv::load_with(&mut *load_fn);
GetShaderInfoLog::load_with(&mut *load_fn);
GetShaderSource::load_with(&mut *load_fn);
GetShaderiv::load_with(&mut *load_fn);
GetString::load_with(&mut *load_fn);
GetStringi::load_with(&mut *load_fn);
GetSynciv::load_with(&mut *load_fn);
GetTexImage::load_with(&mut *load_fn);
GetTexLevelParameterfv::load_with(&mut *load_fn);
GetTexLevelParameteriv::load_with(&mut *load_fn);
GetTexParameterIiv::load_with(&mut *load_fn);
GetTexParameterIuiv::load_with(&mut *load_fn);
GetTexParameterfv::load_with(&mut *load_fn);
GetTexParameteriv::load_with(&mut *load_fn);
GetTransformFeedbackVarying::load_with(&mut *load_fn);
GetUniformBlockIndex::load_with(&mut *load_fn);
GetUniformIndices::load_with(&mut *load_fn);
GetUniformLocation::load_with(&mut *load_fn);
GetUniformfv::load_with(&mut *load_fn);
GetUniformiv::load_with(&mut *load_fn);
GetUniformuiv::load_with(&mut *load_fn);
GetVertexAttribIiv::load_with(&mut *load_fn);
GetVertexAttribIuiv::load_with(&mut *load_fn);
GetVertexAttribPointerv::load_with(&mut *load_fn);
GetVertexAttribdv::load_with(&mut *load_fn);
GetVertexAttribfv::load_with(&mut *load_fn);
GetVertexAttribiv::load_with(&mut *load_fn);
Hint::load_with(&mut *load_fn);
IsBuffer::load_with(&mut *load_fn);
IsEnabled::load_with(&mut *load_fn);
IsEnabledi::load_with(&mut *load_fn);
IsFramebuffer::load_with(&mut *load_fn);
IsProgram::load_with(&mut *load_fn);
IsQuery::load_with(&mut *load_fn);
IsRenderbuffer::load_with(&mut *load_fn);
IsSampler::load_with(&mut *load_fn);
IsShader::load_with(&mut *load_fn);
IsSync::load_with(&mut *load_fn);
IsTexture::load_with(&mut *load_fn);
IsVertexArray::load_with(&mut *load_fn);
LineWidth::load_with(&mut *load_fn);
LinkProgram::load_with(&mut *load_fn);
LogicOp::load_with(&mut *load_fn);
MapBuffer::load_with(&mut *load_fn);
MapBufferRange::load_with(&mut *load_fn);
MultiDrawArrays::load_with(&mut *load_fn);
MultiDrawElements::load_with(&mut *load_fn);
MultiDrawElementsBaseVertex::load_with(&mut *load_fn);
#[cfg(feature = "compatibility_profile")]
{
MultiTexCoordP1ui::load_with(&mut *load_fn);
MultiTexCoordP1uiv::load_with(&mut *load_fn);
MultiTexCoordP2ui::load_with(&mut *load_fn);
MultiTexCoordP2uiv::load_with(&mut *load_fn);
MultiTexCoordP3ui::load_with(&mut *load_fn);
MultiTexCoordP3uiv::load_with(&mut *load_fn);
MultiTexCoordP4ui::load_with(&mut *load_fn);
MultiTexCoordP4uiv::load_with(&mut *load_fn);
NormalP3ui::load_with(&mut *load_fn);
NormalP3uiv::load_with(&mut *load_fn);
}
PixelStoref::load_with(&mut *load_fn);
PixelStorei::load_with(&mut *load_fn);
PointParameterf::load_with(&mut *load_fn);
PointParameterfv::load_with(&mut *load_fn);
PointParameteri::load_with(&mut *load_fn);
PointParameteriv::load_with(&mut *load_fn);
PointSize::load_with(&mut *load_fn);
PolygonMode::load_with(&mut *load_fn);
PolygonOffset::load_with(&mut *load_fn);
PrimitiveRestartIndex::load_with(&mut *load_fn);
ProvokingVertex::load_with(&mut *load_fn);
QueryCounter::load_with(&mut *load_fn);
ReadBuffer::load_with(&mut *load_fn);
ReadPixels::load_with(&mut *load_fn);
RenderbufferStorage::load_with(&mut *load_fn);
RenderbufferStorageMultisample::load_with(&mut *load_fn);
SampleCoverage::load_with(&mut *load_fn);
SampleMaski::load_with(&mut *load_fn);
SamplerParameterIiv::load_with(&mut *load_fn);
SamplerParameterIuiv::load_with(&mut *load_fn);
SamplerParameterf::load_with(&mut *load_fn);
SamplerParameterfv::load_with(&mut *load_fn);
SamplerParameteri::load_with(&mut *load_fn);
SamplerParameteriv::load_with(&mut *load_fn);
Scissor::load_with(&mut *load_fn);
#[cfg(feature = "compatibility_profile")]
{
SecondaryColorP3ui::load_with(&mut *load_fn);
SecondaryColorP3uiv::load_with(&mut *load_fn);
}
ShaderSource::load_with(&mut *load_fn);
StencilFunc::load_with(&mut *load_fn);
StencilFuncSeparate::load_with(&mut *load_fn);
StencilMask::load_with(&mut *load_fn);
StencilMaskSeparate::load_with(&mut *load_fn);
StencilOp::load_with(&mut *load_fn);
StencilOpSeparate::load_with(&mut *load_fn);
TexBuffer::load_with(&mut *load_fn);
#[cfg(feature = "compatibility_profile")]
{
TexCoordP1ui::load_with(&mut *load_fn);
TexCoordP1uiv::load_with(&mut *load_fn);
TexCoordP2ui::load_with(&mut *load_fn);
TexCoordP2uiv::load_with(&mut *load_fn);
TexCoordP3ui::load_with(&mut *load_fn);
TexCoordP3uiv::load_with(&mut *load_fn);
TexCoordP4ui::load_with(&mut *load_fn);
TexCoordP4uiv::load_with(&mut *load_fn);
}
TexImage1D::load_with(&mut *load_fn);
TexImage2D::load_with(&mut *load_fn);
TexImage2DMultisample::load_with(&mut *load_fn);
TexImage3D::load_with(&mut *load_fn);
TexImage3DMultisample::load_with(&mut *load_fn);
TexParameterIiv::load_with(&mut *load_fn);
TexParameterIuiv::load_with(&mut *load_fn);
TexParameterf::load_with(&mut *load_fn);
TexParameterfv::load_with(&mut *load_fn);
TexParameteri::load_with(&mut *load_fn);
TexParameteriv::load_with(&mut *load_fn);
TexSubImage1D::load_with(&mut *load_fn);
TexSubImage2D::load_with(&mut *load_fn);
TexSubImage3D::load_with(&mut *load_fn);
TransformFeedbackVaryings::load_with(&mut *load_fn);
Uniform1f::load_with(&mut *load_fn);
Uniform1fv::load_with(&mut *load_fn);
Uniform1i::load_with(&mut *load_fn);
Uniform1iv::load_with(&mut *load_fn);
Uniform1ui::load_with(&mut *load_fn);
Uniform1uiv::load_with(&mut *load_fn);
Uniform2f::load_with(&mut *load_fn);
Uniform2fv::load_with(&mut *load_fn);
Uniform2i::load_with(&mut *load_fn);
Uniform2iv::load_with(&mut *load_fn);
Uniform2ui::load_with(&mut *load_fn);
Uniform2uiv::load_with(&mut *load_fn);
Uniform3f::load_with(&mut *load_fn);
Uniform3fv::load_with(&mut *load_fn);
Uniform3i::load_with(&mut *load_fn);
Uniform3iv::load_with(&mut *load_fn);
Uniform3ui::load_with(&mut *load_fn);
Uniform3uiv::load_with(&mut *load_fn);
Uniform4f::load_with(&mut *load_fn);
Uniform4fv::load_with(&mut *load_fn);
Uniform4i::load_with(&mut *load_fn);
Uniform4iv::load_with(&mut *load_fn);
Uniform4ui::load_with(&mut *load_fn);
Uniform4uiv::load_with(&mut *load_fn);
UniformBlockBinding::load_with(&mut *load_fn);
UniformMatrix2fv::load_with(&mut *load_fn);
UniformMatrix2x3fv::load_with(&mut *load_fn);
UniformMatrix2x4fv::load_with(&mut *load_fn);
UniformMatrix3fv::load_with(&mut *load_fn);
UniformMatrix3x2fv::load_with(&mut *load_fn);
UniformMatrix3x4fv::load_with(&mut *load_fn);
UniformMatrix4fv::load_with(&mut *load_fn);
UniformMatrix4x2fv::load_with(&mut *load_fn);
UniformMatrix4x3fv::load_with(&mut *load_fn);
UnmapBuffer::load_with(&mut *load_fn);
UseProgram::load_with(&mut *load_fn);
ValidateProgram::load_with(&mut *load_fn);
VertexAttrib1d::load_with(&mut *load_fn);
VertexAttrib1dv::load_with(&mut *load_fn);
VertexAttrib1f::load_with(&mut *load_fn);
VertexAttrib1fv::load_with(&mut *load_fn);
VertexAttrib1s::load_with(&mut *load_fn);
VertexAttrib1sv::load_with(&mut *load_fn);
VertexAttrib2d::load_with(&mut *load_fn);
VertexAttrib2dv::load_with(&mut *load_fn);
VertexAttrib2f::load_with(&mut *load_fn);
VertexAttrib2fv::load_with(&mut *load_fn);
VertexAttrib2s::load_with(&mut *load_fn);
VertexAttrib2sv::load_with(&mut *load_fn);
VertexAttrib3d::load_with(&mut *load_fn);
VertexAttrib3dv::load_with(&mut *load_fn);
VertexAttrib3f::load_with(&mut *load_fn);
VertexAttrib3fv::load_with(&mut *load_fn);
VertexAttrib3s::load_with(&mut *load_fn);
VertexAttrib3sv::load_with(&mut *load_fn);
VertexAttrib4Nbv::load_with(&mut *load_fn);
VertexAttrib4Niv::load_with(&mut *load_fn);
VertexAttrib4Nsv::load_with(&mut *load_fn);
VertexAttrib4Nub::load_with(&mut *load_fn);
VertexAttrib4Nubv::load_with(&mut *load_fn);
VertexAttrib4Nuiv::load_with(&mut *load_fn);
VertexAttrib4Nusv::load_with(&mut *load_fn);
VertexAttrib4bv::load_with(&mut *load_fn);
VertexAttrib4d::load_with(&mut *load_fn);
VertexAttrib4dv::load_with(&mut *load_fn);
VertexAttrib4f::load_with(&mut *load_fn);
VertexAttrib4fv::load_with(&mut *load_fn);
VertexAttrib4iv::load_with(&mut *load_fn);
VertexAttrib4s::load_with(&mut *load_fn);
VertexAttrib4sv::load_with(&mut *load_fn);
VertexAttrib4ubv::load_with(&mut *load_fn);
VertexAttrib4uiv::load_with(&mut *load_fn);
VertexAttrib4usv::load_with(&mut *load_fn);
VertexAttribDivisor::load_with(&mut *load_fn);
VertexAttribI1i::load_with(&mut *load_fn);
VertexAttribI1iv::load_with(&mut *load_fn);
VertexAttribI1ui::load_with(&mut *load_fn);
VertexAttribI1uiv::load_with(&mut *load_fn);
VertexAttribI2i::load_with(&mut *load_fn);
VertexAttribI2iv::load_with(&mut *load_fn);
VertexAttribI2ui::load_with(&mut *load_fn);
VertexAttribI2uiv::load_with(&mut *load_fn);
VertexAttribI3i::load_with(&mut *load_fn);
VertexAttribI3iv::load_with(&mut *load_fn);
VertexAttribI3ui::load_with(&mut *load_fn);
VertexAttribI3uiv::load_with(&mut *load_fn);
VertexAttribI4bv::load_with(&mut *load_fn);
VertexAttribI4i::load_with(&mut *load_fn);
VertexAttribI4iv::load_with(&mut *load_fn);
VertexAttribI4sv::load_with(&mut *load_fn);
VertexAttribI4ubv::load_with(&mut *load_fn);
VertexAttribI4ui::load_with(&mut *load_fn);
VertexAttribI4uiv::load_with(&mut *load_fn);
VertexAttribI4usv::load_with(&mut *load_fn);
VertexAttribIPointer::load_with(&mut *load_fn);
VertexAttribP1ui::load_with(&mut *load_fn);
VertexAttribP1uiv::load_with(&mut *load_fn);
VertexAttribP2ui::load_with(&mut *load_fn);
VertexAttribP2uiv::load_with(&mut *load_fn);
VertexAttribP3ui::load_with(&mut *load_fn);
VertexAttribP3uiv::load_with(&mut *load_fn);
VertexAttribP4ui::load_with(&mut *load_fn);
VertexAttribP4uiv::load_with(&mut *load_fn);
VertexAttribPointer::load_with(&mut *load_fn);
#[cfg(feature = "compatibility_profile")]
{
VertexP2ui::load_with(&mut *load_fn);
VertexP2uiv::load_with(&mut *load_fn);
VertexP3ui::load_with(&mut *load_fn);
VertexP3uiv::load_with(&mut *load_fn);
VertexP4ui::load_with(&mut *load_fn);
VertexP4uiv::load_with(&mut *load_fn);
}
Viewport::load_with(&mut *load_fn);
WaitSync::load_with(&mut *load_fn);
}
fn fn_ptr_ok(p: *const c_void) -> bool {
let p_u = p as usize;
(p_u >= 8) && (p_u != (-1_isize) as usize)
}
unsafe fn meta_loader(
loader: &mut dyn FnMut(*const c_char) -> *const c_void,
names: &[&[u8]],
) -> OptVoidPtr {
for name in names.iter() {
debug_assert!(*name.iter().last().unwrap() == 0_u8);
let p = loader(name.as_ptr() as *const c_char);
if fn_ptr_ok(p) {
return NonNull::new(p as *mut c_void);
}
}
error!(
"glCouldn't load {:?}{}.",
core::str::from_utf8(&names[0][0..names[0].len() - 1]).unwrap(),
if names.len() > 1 { " or fallbacks" } else { "" }
);
None
}
pub use types::*;
pub mod types {
use super::*;
pub type GLenum = c_uint;
pub type GLboolean = c_uchar;
pub type GLbitfield = c_uint;
pub type GLvoid = c_void;
pub type GLbyte = c_char;
pub type GLshort = c_short;
pub type GLint = c_int;
pub type GLclampx = c_int;
pub type GLubyte = c_uchar;
pub type GLushort = c_ushort;
pub type GLuint = c_uint;
pub type GLsizei = c_int;
pub type GLfloat = c_float;
pub type GLclampf = c_float;
pub type GLdouble = c_double;
pub type GLclampd = c_double;
pub type GLeglImageOES = *const c_void;
pub type GLchar = c_char;
pub type GLcharARB = c_char;
#[cfg(target_os = "macos")]
pub type GLhandleARB = *const c_void;
#[cfg(not(target_os = "macos"))]
pub type GLhandleARB = c_uint;
pub type GLhalfARB = c_ushort;
pub type GLhalf = c_ushort;
pub type GLfixed = GLint;
pub type GLintptr = isize;
pub type GLsizeiptr = isize;
pub type GLint64 = i64;
pub type GLuint64 = u64;
pub type GLintptrARB = isize;
pub type GLsizeiptrARB = isize;
pub type GLint64EXT = i64;
pub type GLuint64EXT = u64;
pub enum __GLsync {}
pub type GLsync = *const __GLsync;
pub enum _cl_context {}
pub enum _cl_event {}
pub type GLDEBUGPROC = Option<
extern "system" fn(
source: GLenum,
gltype: GLenum,
id: GLuint,
severity: GLenum,
length: GLsizei,
message: *const GLchar,
userParam: *mut c_void,
),
>;
pub type GLDEBUGPROCARB = Option<
extern "system" fn(
source: GLenum,
gltype: GLenum,
id: GLuint,
severity: GLenum,
length: GLsizei,
message: *const GLchar,
userParam: *mut c_void,
),
>;
pub type GLDEBUGPROCKHR = Option<
extern "system" fn(
source: GLenum,
gltype: GLenum,
id: GLuint,
severity: GLenum,
length: GLsizei,
message: *const GLchar,
userParam: *mut c_void,
),
>;
pub type GLDEBUGPROCAMD = Option<
extern "system" fn(
id: GLuint,
category: GLenum,
severity: GLenum,
length: GLsizei,
message: *const GLchar,
userParam: *mut c_void,
),
>;
pub type GLhalfNV = c_ushort;
pub type GLvdpauSurfaceNV = GLintptr;
}
pub use consts::*;
pub mod consts {
use super::*;
pub const GL_ACTIVE_ATTRIBUTES: GLenum = 0x8B89;
pub const GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: GLenum = 0x8B8A;
pub const GL_ACTIVE_TEXTURE: GLenum = 0x84E0;
pub const GL_ACTIVE_UNIFORMS: GLenum = 0x8B86;
pub const GL_ACTIVE_UNIFORM_BLOCKS: GLenum = 0x8A36;
pub const GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: GLenum = 0x8A35;
pub const GL_ACTIVE_UNIFORM_MAX_LENGTH: GLenum = 0x8B87;
pub const GL_ALIASED_LINE_WIDTH_RANGE: GLenum = 0x846E;
pub const GL_ALPHA: GLenum = 0x1906;
pub const GL_ALREADY_SIGNALED: GLenum = 0x911A;
pub const GL_ALWAYS: GLenum = 0x0207;
pub const GL_AND: GLenum = 0x1501;
pub const GL_AND_INVERTED: GLenum = 0x1504;
pub const GL_AND_REVERSE: GLenum = 0x1502;
pub const GL_ANY_SAMPLES_PASSED: GLenum = 0x8C2F;
pub const GL_ARRAY_BUFFER: GLenum = 0x8892;
pub const GL_ARRAY_BUFFER_BINDING: GLenum = 0x8894;
pub const GL_ATTACHED_SHADERS: GLenum = 0x8B85;
pub const GL_BACK: GLenum = 0x0405;
pub const GL_BACK_LEFT: GLenum = 0x0402;
pub const GL_BACK_RIGHT: GLenum = 0x0403;
pub const GL_BGR: GLenum = 0x80E0;
pub const GL_BGRA: GLenum = 0x80E1;
pub const GL_BGRA_INTEGER: GLenum = 0x8D9B;
pub const GL_BGR_INTEGER: GLenum = 0x8D9A;
pub const GL_BLEND: GLenum = 0x0BE2;
pub const GL_BLEND_COLOR: GLenum = 0x8005;
pub const GL_BLEND_DST: GLenum = 0x0BE0;
pub const GL_BLEND_DST_ALPHA: GLenum = 0x80CA;
pub const GL_BLEND_DST_RGB: GLenum = 0x80C8;
pub const GL_BLEND_EQUATION: GLenum = 0x8009;
pub const GL_BLEND_EQUATION_ALPHA: GLenum = 0x883D;
pub const GL_BLEND_EQUATION_RGB: GLenum = 0x8009;
pub const GL_BLEND_SRC: GLenum = 0x0BE1;
pub const GL_BLEND_SRC_ALPHA: GLenum = 0x80CB;
pub const GL_BLEND_SRC_RGB: GLenum = 0x80C9;
pub const GL_BLUE: GLenum = 0x1905;
pub const GL_BLUE_INTEGER: GLenum = 0x8D96;
pub const GL_BOOL: GLenum = 0x8B56;
pub const GL_BOOL_VEC2: GLenum = 0x8B57;
pub const GL_BOOL_VEC3: GLenum = 0x8B58;
pub const GL_BOOL_VEC4: GLenum = 0x8B59;
pub const GL_BUFFER_ACCESS: GLenum = 0x88BB;
pub const GL_BUFFER_ACCESS_FLAGS: GLenum = 0x911F;
pub const GL_BUFFER_MAPPED: GLenum = 0x88BC;
pub const GL_BUFFER_MAP_LENGTH: GLenum = 0x9120;
pub const GL_BUFFER_MAP_OFFSET: GLenum = 0x9121;
pub const GL_BUFFER_MAP_POINTER: GLenum = 0x88BD;
pub const GL_BUFFER_SIZE: GLenum = 0x8764;
pub const GL_BUFFER_USAGE: GLenum = 0x8765;
pub const GL_BYTE: GLenum = 0x1400;
pub const GL_CCW: GLenum = 0x0901;
pub const GL_CLAMP_READ_COLOR: GLenum = 0x891C;
pub const GL_CLAMP_TO_BORDER: GLenum = 0x812D;
pub const GL_CLAMP_TO_EDGE: GLenum = 0x812F;
pub const GL_CLEAR: GLenum = 0x1500;
pub const GL_CLIP_DISTANCE0: GLenum = 0x3000;
pub const GL_CLIP_DISTANCE1: GLenum = 0x3001;
pub const GL_CLIP_DISTANCE2: GLenum = 0x3002;
pub const GL_CLIP_DISTANCE3: GLenum = 0x3003;
pub const GL_CLIP_DISTANCE4: GLenum = 0x3004;
pub const GL_CLIP_DISTANCE5: GLenum = 0x3005;
pub const GL_CLIP_DISTANCE6: GLenum = 0x3006;
pub const GL_CLIP_DISTANCE7: GLenum = 0x3007;
pub const GL_COLOR: GLenum = 0x1800;
pub const GL_COLOR_ATTACHMENT0: GLenum = 0x8CE0;
pub const GL_COLOR_ATTACHMENT1: GLenum = 0x8CE1;
pub const GL_COLOR_ATTACHMENT10: GLenum = 0x8CEA;
pub const GL_COLOR_ATTACHMENT11: GLenum = 0x8CEB;
pub const GL_COLOR_ATTACHMENT12: GLenum = 0x8CEC;
pub const GL_COLOR_ATTACHMENT13: GLenum = 0x8CED;
pub const GL_COLOR_ATTACHMENT14: GLenum = 0x8CEE;
pub const GL_COLOR_ATTACHMENT15: GLenum = 0x8CEF;
pub const GL_COLOR_ATTACHMENT16: GLenum = 0x8CF0;
pub const GL_COLOR_ATTACHMENT17: GLenum = 0x8CF1;
pub const GL_COLOR_ATTACHMENT18: GLenum = 0x8CF2;
pub const GL_COLOR_ATTACHMENT19: GLenum = 0x8CF3;
pub const GL_COLOR_ATTACHMENT2: GLenum = 0x8CE2;
pub const GL_COLOR_ATTACHMENT20: GLenum = 0x8CF4;
pub const GL_COLOR_ATTACHMENT21: GLenum = 0x8CF5;
pub const GL_COLOR_ATTACHMENT22: GLenum = 0x8CF6;
pub const GL_COLOR_ATTACHMENT23: GLenum = 0x8CF7;
pub const GL_COLOR_ATTACHMENT24: GLenum = 0x8CF8;
pub const GL_COLOR_ATTACHMENT25: GLenum = 0x8CF9;
pub const GL_COLOR_ATTACHMENT26: GLenum = 0x8CFA;
pub const GL_COLOR_ATTACHMENT27: GLenum = 0x8CFB;
pub const GL_COLOR_ATTACHMENT28: GLenum = 0x8CFC;
pub const GL_COLOR_ATTACHMENT29: GLenum = 0x8CFD;
pub const GL_COLOR_ATTACHMENT3: GLenum = 0x8CE3;
pub const GL_COLOR_ATTACHMENT30: GLenum = 0x8CFE;
pub const GL_COLOR_ATTACHMENT31: GLenum = 0x8CFF;
pub const GL_COLOR_ATTACHMENT4: GLenum = 0x8CE4;
pub const GL_COLOR_ATTACHMENT5: GLenum = 0x8CE5;
pub const GL_COLOR_ATTACHMENT6: GLenum = 0x8CE6;
pub const GL_COLOR_ATTACHMENT7: GLenum = 0x8CE7;
pub const GL_COLOR_ATTACHMENT8: GLenum = 0x8CE8;
pub const GL_COLOR_ATTACHMENT9: GLenum = 0x8CE9;
pub const GL_COLOR_BUFFER_BIT: GLenum = 0x00004000;
pub const GL_COLOR_CLEAR_VALUE: GLenum = 0x0C22;
pub const GL_COLOR_LOGIC_OP: GLenum = 0x0BF2;
pub const GL_COLOR_WRITEMASK: GLenum = 0x0C23;
pub const GL_COMPARE_REF_TO_TEXTURE: GLenum = 0x884E;
pub const GL_COMPILE_STATUS: GLenum = 0x8B81;
pub const GL_COMPRESSED_RED: GLenum = 0x8225;
pub const GL_COMPRESSED_RED_RGTC1: GLenum = 0x8DBB;
pub const GL_COMPRESSED_RG: GLenum = 0x8226;
pub const GL_COMPRESSED_RGB: GLenum = 0x84ED;
pub const GL_COMPRESSED_RGBA: GLenum = 0x84EE;
pub const GL_COMPRESSED_RG_RGTC2: GLenum = 0x8DBD;
pub const GL_COMPRESSED_SIGNED_RED_RGTC1: GLenum = 0x8DBC;
pub const GL_COMPRESSED_SIGNED_RG_RGTC2: GLenum = 0x8DBE;
pub const GL_COMPRESSED_SRGB: GLenum = 0x8C48;
pub const GL_COMPRESSED_SRGB_ALPHA: GLenum = 0x8C49;
pub const GL_COMPRESSED_TEXTURE_FORMATS: GLenum = 0x86A3;
pub const GL_CONDITION_SATISFIED: GLenum = 0x911C;
pub const GL_CONSTANT_ALPHA: GLenum = 0x8003;
pub const GL_CONSTANT_COLOR: GLenum = 0x8001;
pub const GL_CONTEXT_COMPATIBILITY_PROFILE_BIT: GLenum = 0x00000002;
pub const GL_CONTEXT_CORE_PROFILE_BIT: GLenum = 0x00000001;
pub const GL_CONTEXT_FLAGS: GLenum = 0x821E;
pub const GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT: GLenum = 0x00000001;
pub const GL_CONTEXT_PROFILE_MASK: GLenum = 0x9126;
pub const GL_COPY: GLenum = 0x1503;
pub const GL_COPY_INVERTED: GLenum = 0x150C;
pub const GL_COPY_READ_BUFFER: GLenum = 0x8F36;
pub const GL_COPY_WRITE_BUFFER: GLenum = 0x8F37;
pub const GL_CULL_FACE: GLenum = 0x0B44;
pub const GL_CULL_FACE_MODE: GLenum = 0x0B45;
pub const GL_CURRENT_PROGRAM: GLenum = 0x8B8D;
pub const GL_CURRENT_QUERY: GLenum = 0x8865;
pub const GL_CURRENT_VERTEX_ATTRIB: GLenum = 0x8626;
pub const GL_CW: GLenum = 0x0900;
pub const GL_DECR: GLenum = 0x1E03;
pub const GL_DECR_WRAP: GLenum = 0x8508;
pub const GL_DELETE_STATUS: GLenum = 0x8B80;
pub const GL_DEPTH: GLenum = 0x1801;
pub const GL_DEPTH24_STENCIL8: GLenum = 0x88F0;
pub const GL_DEPTH32F_STENCIL8: GLenum = 0x8CAD;
pub const GL_DEPTH_ATTACHMENT: GLenum = 0x8D00;
pub const GL_DEPTH_BUFFER_BIT: GLenum = 0x00000100;
pub const GL_DEPTH_CLAMP: GLenum = 0x864F;
pub const GL_DEPTH_CLEAR_VALUE: GLenum = 0x0B73;
pub const GL_DEPTH_COMPONENT: GLenum = 0x1902;
pub const GL_DEPTH_COMPONENT16: GLenum = 0x81A5;
pub const GL_DEPTH_COMPONENT24: GLenum = 0x81A6;
pub const GL_DEPTH_COMPONENT32: GLenum = 0x81A7;
pub const GL_DEPTH_COMPONENT32F: GLenum = 0x8CAC;
pub const GL_DEPTH_FUNC: GLenum = 0x0B74;
pub const GL_DEPTH_RANGE: GLenum = 0x0B70;
pub const GL_DEPTH_STENCIL: GLenum = 0x84F9;
pub const GL_DEPTH_STENCIL_ATTACHMENT: GLenum = 0x821A;
pub const GL_DEPTH_TEST: GLenum = 0x0B71;
pub const GL_DEPTH_WRITEMASK: GLenum = 0x0B72;
pub const GL_DITHER: GLenum = 0x0BD0;
pub const GL_DONT_CARE: GLenum = 0x1100;
pub const GL_DOUBLE: GLenum = 0x140A;
pub const GL_DOUBLEBUFFER: GLenum = 0x0C32;
pub const GL_DRAW_BUFFER: GLenum = 0x0C01;
pub const GL_DRAW_BUFFER0: GLenum = 0x8825;
pub const GL_DRAW_BUFFER1: GLenum = 0x8826;
pub const GL_DRAW_BUFFER10: GLenum = 0x882F;
pub const GL_DRAW_BUFFER11: GLenum = 0x8830;
pub const GL_DRAW_BUFFER12: GLenum = 0x8831;
pub const GL_DRAW_BUFFER13: GLenum = 0x8832;
pub const GL_DRAW_BUFFER14: GLenum = 0x8833;
pub const GL_DRAW_BUFFER15: GLenum = 0x8834;
pub const GL_DRAW_BUFFER2: GLenum = 0x8827;
pub const GL_DRAW_BUFFER3: GLenum = 0x8828;
pub const GL_DRAW_BUFFER4: GLenum = 0x8829;
pub const GL_DRAW_BUFFER5: GLenum = 0x882A;
pub const GL_DRAW_BUFFER6: GLenum = 0x882B;
pub const GL_DRAW_BUFFER7: GLenum = 0x882C;
pub const GL_DRAW_BUFFER8: GLenum = 0x882D;
pub const GL_DRAW_BUFFER9: GLenum = 0x882E;
pub const GL_DRAW_FRAMEBUFFER: GLenum = 0x8CA9;
pub const GL_DRAW_FRAMEBUFFER_BINDING: GLenum = 0x8CA6;
pub const GL_DST_ALPHA: GLenum = 0x0304;
pub const GL_DST_COLOR: GLenum = 0x0306;
pub const GL_DYNAMIC_COPY: GLenum = 0x88EA;
pub const GL_DYNAMIC_DRAW: GLenum = 0x88E8;
pub const GL_DYNAMIC_READ: GLenum = 0x88E9;
pub const GL_ELEMENT_ARRAY_BUFFER: GLenum = 0x8893;
pub const GL_ELEMENT_ARRAY_BUFFER_BINDING: GLenum = 0x8895;
pub const GL_EQUAL: GLenum = 0x0202;
pub const GL_EQUIV: GLenum = 0x1509;
pub const GL_EXTENSIONS: GLenum = 0x1F03;
pub const GL_FALSE: GLboolean = 0;
pub const GL_FASTEST: GLenum = 0x1101;
pub const GL_FILL: GLenum = 0x1B02;
pub const GL_FIRST_VERTEX_CONVENTION: GLenum = 0x8E4D;
pub const GL_FIXED_ONLY: GLenum = 0x891D;
pub const GL_FLOAT: GLenum = 0x1406;
pub const GL_FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum = 0x8DAD;
pub const GL_FLOAT_MAT2: GLenum = 0x8B5A;
pub const GL_FLOAT_MAT2x3: GLenum = 0x8B65;
pub const GL_FLOAT_MAT2x4: GLenum = 0x8B66;
pub const GL_FLOAT_MAT3: GLenum = 0x8B5B;
pub const GL_FLOAT_MAT3x2: GLenum = 0x8B67;
pub const GL_FLOAT_MAT3x4: GLenum = 0x8B68;
pub const GL_FLOAT_MAT4: GLenum = 0x8B5C;
pub const GL_FLOAT_MAT4x2: GLenum = 0x8B69;
pub const GL_FLOAT_MAT4x3: GLenum = 0x8B6A;
pub const GL_FLOAT_VEC2: GLenum = 0x8B50;
pub const GL_FLOAT_VEC3: GLenum = 0x8B51;
pub const GL_FLOAT_VEC4: GLenum = 0x8B52;
pub const GL_FRAGMENT_SHADER: GLenum = 0x8B30;
pub const GL_FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum = 0x8B8B;
pub const GL_FRAMEBUFFER: GLenum = 0x8D40;
pub const GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum = 0x8215;
pub const GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum = 0x8214;
pub const GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum = 0x8210;
pub const GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum = 0x8211;
pub const GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum = 0x8216;
pub const GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum = 0x8213;
pub const GL_FRAMEBUFFER_ATTACHMENT_LAYERED: GLenum = 0x8DA7;
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum = 0x8CD1;
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum = 0x8CD0;
pub const GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum = 0x8212;
pub const GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum = 0x8217;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum = 0x8CD3;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum = 0x8CD4;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum = 0x8CD2;
pub const GL_FRAMEBUFFER_BINDING: GLenum = 0x8CA6;
pub const GL_FRAMEBUFFER_COMPLETE: GLenum = 0x8CD5;
pub const GL_FRAMEBUFFER_DEFAULT: GLenum = 0x8218;
pub const GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum = 0x8CD6;
pub const GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: GLenum = 0x8CDB;
pub const GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS: GLenum = 0x8DA8;
pub const GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum = 0x8CD7;
pub const GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum = 0x8D56;
pub const GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: GLenum = 0x8CDC;
pub const GL_FRAMEBUFFER_SRGB: GLenum = 0x8DB9;
pub const GL_FRAMEBUFFER_UNDEFINED: GLenum = 0x8219;
pub const GL_FRAMEBUFFER_UNSUPPORTED: GLenum = 0x8CDD;
pub const GL_FRONT: GLenum = 0x0404;
pub const GL_FRONT_AND_BACK: GLenum = 0x0408;
pub const GL_FRONT_FACE: GLenum = 0x0B46;
pub const GL_FRONT_LEFT: GLenum = 0x0400;
pub const GL_FRONT_RIGHT: GLenum = 0x0401;
pub const GL_FUNC_ADD: GLenum = 0x8006;
pub const GL_FUNC_REVERSE_SUBTRACT: GLenum = 0x800B;
pub const GL_FUNC_SUBTRACT: GLenum = 0x800A;
pub const GL_GEOMETRY_INPUT_TYPE: GLenum = 0x8917;
pub const GL_GEOMETRY_OUTPUT_TYPE: GLenum = 0x8918;
pub const GL_GEOMETRY_SHADER: GLenum = 0x8DD9;
pub const GL_GEOMETRY_VERTICES_OUT: GLenum = 0x8916;
pub const GL_GEQUAL: GLenum = 0x0206;
pub const GL_GREATER: GLenum = 0x0204;
pub const GL_GREEN: GLenum = 0x1904;
pub const GL_GREEN_INTEGER: GLenum = 0x8D95;
pub const GL_HALF_FLOAT: GLenum = 0x140B;
pub const GL_INCR: GLenum = 0x1E02;
pub const GL_INCR_WRAP: GLenum = 0x8507;
pub const GL_INFO_LOG_LENGTH: GLenum = 0x8B84;
pub const GL_INT: GLenum = 0x1404;
pub const GL_INTERLEAVED_ATTRIBS: GLenum = 0x8C8C;
pub const GL_INT_2_10_10_10_REV: GLenum = 0x8D9F;
pub const GL_INT_SAMPLER_1D: GLenum = 0x8DC9;
pub const GL_INT_SAMPLER_1D_ARRAY: GLenum = 0x8DCE;
pub const GL_INT_SAMPLER_2D: GLenum = 0x8DCA;
pub const GL_INT_SAMPLER_2D_ARRAY: GLenum = 0x8DCF;
pub const GL_INT_SAMPLER_2D_MULTISAMPLE: GLenum = 0x9109;
pub const GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: GLenum = 0x910C;
pub const GL_INT_SAMPLER_2D_RECT: GLenum = 0x8DCD;
pub const GL_INT_SAMPLER_3D: GLenum = 0x8DCB;
pub const GL_INT_SAMPLER_BUFFER: GLenum = 0x8DD0;
pub const GL_INT_SAMPLER_CUBE: GLenum = 0x8DCC;
pub const GL_INT_VEC2: GLenum = 0x8B53;
pub const GL_INT_VEC3: GLenum = 0x8B54;
pub const GL_INT_VEC4: GLenum = 0x8B55;
pub const GL_INVALID_ENUM: GLenum = 0x0500;
pub const GL_INVALID_FRAMEBUFFER_OPERATION: GLenum = 0x0506;
pub const GL_INVALID_INDEX: GLuint = 0xFFFFFFFF;
pub const GL_INVALID_OPERATION: GLenum = 0x0502;
pub const GL_INVALID_VALUE: GLenum = 0x0501;
pub const GL_INVERT: GLenum = 0x150A;
pub const GL_KEEP: GLenum = 0x1E00;
pub const GL_LAST_VERTEX_CONVENTION: GLenum = 0x8E4E;
pub const GL_LEFT: GLenum = 0x0406;
pub const GL_LEQUAL: GLenum = 0x0203;
pub const GL_LESS: GLenum = 0x0201;
pub const GL_LINE: GLenum = 0x1B01;
pub const GL_LINEAR: GLenum = 0x2601;
pub const GL_LINEAR_MIPMAP_LINEAR: GLenum = 0x2703;
pub const GL_LINEAR_MIPMAP_NEAREST: GLenum = 0x2701;
pub const GL_LINES: GLenum = 0x0001;
pub const GL_LINES_ADJACENCY: GLenum = 0x000A;
pub const GL_LINE_LOOP: GLenum = 0x0002;
pub const GL_LINE_SMOOTH: GLenum = 0x0B20;
pub const GL_LINE_SMOOTH_HINT: GLenum = 0x0C52;
pub const GL_LINE_STRIP: GLenum = 0x0003;
pub const GL_LINE_STRIP_ADJACENCY: GLenum = 0x000B;
pub const GL_LINE_WIDTH: GLenum = 0x0B21;
pub const GL_LINE_WIDTH_GRANULARITY: GLenum = 0x0B23;
pub const GL_LINE_WIDTH_RANGE: GLenum = 0x0B22;
pub const GL_LINK_STATUS: GLenum = 0x8B82;
pub const GL_LOGIC_OP_MODE: GLenum = 0x0BF0;
pub const GL_LOWER_LEFT: GLenum = 0x8CA1;
pub const GL_MAJOR_VERSION: GLenum = 0x821B;
pub const GL_MAP_FLUSH_EXPLICIT_BIT: GLenum = 0x0010;
pub const GL_MAP_INVALIDATE_BUFFER_BIT: GLenum = 0x0008;
pub const GL_MAP_INVALIDATE_RANGE_BIT: GLenum = 0x0004;
pub const GL_MAP_READ_BIT: GLenum = 0x0001;
pub const GL_MAP_UNSYNCHRONIZED_BIT: GLenum = 0x0020;
pub const GL_MAP_WRITE_BIT: GLenum = 0x0002;
pub const GL_MAX: GLenum = 0x8008;
pub const GL_MAX_3D_TEXTURE_SIZE: GLenum = 0x8073;
pub const GL_MAX_ARRAY_TEXTURE_LAYERS: GLenum = 0x88FF;
pub const GL_MAX_CLIP_DISTANCES: GLenum = 0x0D32;
pub const GL_MAX_COLOR_ATTACHMENTS: GLenum = 0x8CDF;
pub const GL_MAX_COLOR_TEXTURE_SAMPLES: GLenum = 0x910E;
pub const GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum = 0x8A33;
pub const GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS: GLenum = 0x8A32;
pub const GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum = 0x8B4D;
pub const GL_MAX_COMBINED_UNIFORM_BLOCKS: GLenum = 0x8A2E;
pub const GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum = 0x8A31;
pub const GL_MAX_CUBE_MAP_TEXTURE_SIZE: GLenum = 0x851C;
pub const GL_MAX_DEPTH_TEXTURE_SAMPLES: GLenum = 0x910F;
pub const GL_MAX_DRAW_BUFFERS: GLenum = 0x8824;
pub const GL_MAX_DUAL_SOURCE_DRAW_BUFFERS: GLenum = 0x88FC;
pub const GL_MAX_ELEMENTS_INDICES: GLenum = 0x80E9;
pub const GL_MAX_ELEMENTS_VERTICES: GLenum = 0x80E8;
pub const GL_MAX_FRAGMENT_INPUT_COMPONENTS: GLenum = 0x9125;
pub const GL_MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum = 0x8A2D;
pub const GL_MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum = 0x8B49;
pub const GL_MAX_GEOMETRY_INPUT_COMPONENTS: GLenum = 0x9123;
pub const GL_MAX_GEOMETRY_OUTPUT_COMPONENTS: GLenum = 0x9124;
pub const GL_MAX_GEOMETRY_OUTPUT_VERTICES: GLenum = 0x8DE0;
pub const GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS: GLenum = 0x8C29;
pub const GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: GLenum = 0x8DE1;
pub const GL_MAX_GEOMETRY_UNIFORM_BLOCKS: GLenum = 0x8A2C;
pub const GL_MAX_GEOMETRY_UNIFORM_COMPONENTS: GLenum = 0x8DDF;
pub const GL_MAX_INTEGER_SAMPLES: GLenum = 0x9110;
pub const GL_MAX_PROGRAM_TEXEL_OFFSET: GLenum = 0x8905;
pub const GL_MAX_RECTANGLE_TEXTURE_SIZE: GLenum = 0x84F8;
pub const GL_MAX_RENDERBUFFER_SIZE: GLenum = 0x84E8;
pub const GL_MAX_SAMPLES: GLenum = 0x8D57;
pub const GL_MAX_SAMPLE_MASK_WORDS: GLenum = 0x8E59;
pub const GL_MAX_SERVER_WAIT_TIMEOUT: GLenum = 0x9111;
pub const GL_MAX_TEXTURE_BUFFER_SIZE: GLenum = 0x8C2B;
pub const GL_MAX_TEXTURE_IMAGE_UNITS: GLenum = 0x8872;
pub const GL_MAX_TEXTURE_LOD_BIAS: GLenum = 0x84FD;
pub const GL_MAX_TEXTURE_SIZE: GLenum = 0x0D33;
pub const GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum = 0x8C8A;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum = 0x8C8B;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum = 0x8C80;
pub const GL_MAX_UNIFORM_BLOCK_SIZE: GLenum = 0x8A30;
pub const GL_MAX_UNIFORM_BUFFER_BINDINGS: GLenum = 0x8A2F;
pub const GL_MAX_VARYING_COMPONENTS: GLenum = 0x8B4B;
pub const GL_MAX_VARYING_FLOATS: GLenum = 0x8B4B;
pub const GL_MAX_VERTEX_ATTRIBS: GLenum = 0x8869;
pub const GL_MAX_VERTEX_OUTPUT_COMPONENTS: GLenum = 0x9122;
pub const GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum = 0x8B4C;
pub const GL_MAX_VERTEX_UNIFORM_BLOCKS: GLenum = 0x8A2B;
pub const GL_MAX_VERTEX_UNIFORM_COMPONENTS: GLenum = 0x8B4A;
pub const GL_MAX_VIEWPORT_DIMS: GLenum = 0x0D3A;
pub const GL_MIN: GLenum = 0x8007;
pub const GL_MINOR_VERSION: GLenum = 0x821C;
pub const GL_MIN_PROGRAM_TEXEL_OFFSET: GLenum = 0x8904;
pub const GL_MIRRORED_REPEAT: GLenum = 0x8370;
pub const GL_MULTISAMPLE: GLenum = 0x809D;
pub const GL_NAND: GLenum = 0x150E;
pub const GL_NEAREST: GLenum = 0x2600;
pub const GL_NEAREST_MIPMAP_LINEAR: GLenum = 0x2702;
pub const GL_NEAREST_MIPMAP_NEAREST: GLenum = 0x2700;
pub const GL_NEVER: GLenum = 0x0200;
pub const GL_NICEST: GLenum = 0x1102;
pub const GL_NONE: GLenum = 0;
pub const GL_NOOP: GLenum = 0x1505;
pub const GL_NOR: GLenum = 0x1508;
pub const GL_NOTEQUAL: GLenum = 0x0205;
pub const GL_NO_ERROR: GLenum = 0;
pub const GL_NUM_COMPRESSED_TEXTURE_FORMATS: GLenum = 0x86A2;
pub const GL_NUM_EXTENSIONS: GLenum = 0x821D;
pub const GL_OBJECT_TYPE: GLenum = 0x9112;
pub const GL_ONE: GLenum = 1;
pub const GL_ONE_MINUS_CONSTANT_ALPHA: GLenum = 0x8004;
pub const GL_ONE_MINUS_CONSTANT_COLOR: GLenum = 0x8002;
pub const GL_ONE_MINUS_DST_ALPHA: GLenum = 0x0305;
pub const GL_ONE_MINUS_DST_COLOR: GLenum = 0x0307;
pub const GL_ONE_MINUS_SRC1_ALPHA: GLenum = 0x88FB;
pub const GL_ONE_MINUS_SRC1_COLOR: GLenum = 0x88FA;
pub const GL_ONE_MINUS_SRC_ALPHA: GLenum = 0x0303;
pub const GL_ONE_MINUS_SRC_COLOR: GLenum = 0x0301;
pub const GL_OR: GLenum = 0x1507;
pub const GL_OR_INVERTED: GLenum = 0x150D;
pub const GL_OR_REVERSE: GLenum = 0x150B;
pub const GL_OUT_OF_MEMORY: GLenum = 0x0505;
pub const GL_PACK_ALIGNMENT: GLenum = 0x0D05;
pub const GL_PACK_IMAGE_HEIGHT: GLenum = 0x806C;
pub const GL_PACK_LSB_FIRST: GLenum = 0x0D01;
pub const GL_PACK_ROW_LENGTH: GLenum = 0x0D02;
pub const GL_PACK_SKIP_IMAGES: GLenum = 0x806B;
pub const GL_PACK_SKIP_PIXELS: GLenum = 0x0D04;
pub const GL_PACK_SKIP_ROWS: GLenum = 0x0D03;
pub const GL_PACK_SWAP_BYTES: GLenum = 0x0D00;
pub const GL_PIXEL_PACK_BUFFER: GLenum = 0x88EB;
pub const GL_PIXEL_PACK_BUFFER_BINDING: GLenum = 0x88ED;
pub const GL_PIXEL_UNPACK_BUFFER: GLenum = 0x88EC;
pub const GL_PIXEL_UNPACK_BUFFER_BINDING: GLenum = 0x88EF;
pub const GL_POINT: GLenum = 0x1B00;
pub const GL_POINTS: GLenum = 0x0000;
pub const GL_POINT_FADE_THRESHOLD_SIZE: GLenum = 0x8128;
pub const GL_POINT_SIZE: GLenum = 0x0B11;
pub const GL_POINT_SIZE_GRANULARITY: GLenum = 0x0B13;
pub const GL_POINT_SIZE_RANGE: GLenum = 0x0B12;
pub const GL_POINT_SPRITE_COORD_ORIGIN: GLenum = 0x8CA0;
pub const GL_POLYGON_MODE: GLenum = 0x0B40;
pub const GL_POLYGON_OFFSET_FACTOR: GLenum = 0x8038;
pub const GL_POLYGON_OFFSET_FILL: GLenum = 0x8037;
pub const GL_POLYGON_OFFSET_LINE: GLenum = 0x2A02;
pub const GL_POLYGON_OFFSET_POINT: GLenum = 0x2A01;
pub const GL_POLYGON_OFFSET_UNITS: GLenum = 0x2A00;
pub const GL_POLYGON_SMOOTH: GLenum = 0x0B41;
pub const GL_POLYGON_SMOOTH_HINT: GLenum = 0x0C53;
pub const GL_PRIMITIVES_GENERATED: GLenum = 0x8C87;
pub const GL_PRIMITIVE_RESTART: GLenum = 0x8F9D;
pub const GL_PRIMITIVE_RESTART_INDEX: GLenum = 0x8F9E;
pub const GL_PROGRAM_POINT_SIZE: GLenum = 0x8642;
pub const GL_PROVOKING_VERTEX: GLenum = 0x8E4F;
pub const GL_PROXY_TEXTURE_1D: GLenum = 0x8063;
pub const GL_PROXY_TEXTURE_1D_ARRAY: GLenum = 0x8C19;
pub const GL_PROXY_TEXTURE_2D: GLenum = 0x8064;
pub const GL_PROXY_TEXTURE_2D_ARRAY: GLenum = 0x8C1B;
pub const GL_PROXY_TEXTURE_2D_MULTISAMPLE: GLenum = 0x9101;
pub const GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY: GLenum = 0x9103;
pub const GL_PROXY_TEXTURE_3D: GLenum = 0x8070;
pub const GL_PROXY_TEXTURE_CUBE_MAP: GLenum = 0x851B;
pub const GL_PROXY_TEXTURE_RECTANGLE: GLenum = 0x84F7;
pub const GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: GLenum = 0x8E4C;
pub const GL_QUERY_BY_REGION_NO_WAIT: GLenum = 0x8E16;
pub const GL_QUERY_BY_REGION_WAIT: GLenum = 0x8E15;
pub const GL_QUERY_COUNTER_BITS: GLenum = 0x8864;
pub const GL_QUERY_NO_WAIT: GLenum = 0x8E14;
pub const GL_QUERY_RESULT: GLenum = 0x8866;
pub const GL_QUERY_RESULT_AVAILABLE: GLenum = 0x8867;
pub const GL_QUERY_WAIT: GLenum = 0x8E13;
pub const GL_R11F_G11F_B10F: GLenum = 0x8C3A;
pub const GL_R16: GLenum = 0x822A;
pub const GL_R16F: GLenum = 0x822D;
pub const GL_R16I: GLenum = 0x8233;
pub const GL_R16UI: GLenum = 0x8234;
pub const GL_R16_SNORM: GLenum = 0x8F98;
pub const GL_R32F: GLenum = 0x822E;
pub const GL_R32I: GLenum = 0x8235;
pub const GL_R32UI: GLenum = 0x8236;
pub const GL_R3_G3_B2: GLenum = 0x2A10;
pub const GL_R8: GLenum = 0x8229;
pub const GL_R8I: GLenum = 0x8231;
pub const GL_R8UI: GLenum = 0x8232;
pub const GL_R8_SNORM: GLenum = 0x8F94;
pub const GL_RASTERIZER_DISCARD: GLenum = 0x8C89;
pub const GL_READ_BUFFER: GLenum = 0x0C02;
pub const GL_READ_FRAMEBUFFER: GLenum = 0x8CA8;
pub const GL_READ_FRAMEBUFFER_BINDING: GLenum = 0x8CAA;
pub const GL_READ_ONLY: GLenum = 0x88B8;
pub const GL_READ_WRITE: GLenum = 0x88BA;
pub const GL_RED: GLenum = 0x1903;
pub const GL_RED_INTEGER: GLenum = 0x8D94;
pub const GL_RENDERBUFFER: GLenum = 0x8D41;
pub const GL_RENDERBUFFER_ALPHA_SIZE: GLenum = 0x8D53;
pub const GL_RENDERBUFFER_BINDING: GLenum = 0x8CA7;
pub const GL_RENDERBUFFER_BLUE_SIZE: GLenum = 0x8D52;
pub const GL_RENDERBUFFER_DEPTH_SIZE: GLenum = 0x8D54;
pub const GL_RENDERBUFFER_GREEN_SIZE: GLenum = 0x8D51;
pub const GL_RENDERBUFFER_HEIGHT: GLenum = 0x8D43;
pub const GL_RENDERBUFFER_INTERNAL_FORMAT: GLenum = 0x8D44;
pub const GL_RENDERBUFFER_RED_SIZE: GLenum = 0x8D50;
pub const GL_RENDERBUFFER_SAMPLES: GLenum = 0x8CAB;
pub const GL_RENDERBUFFER_STENCIL_SIZE: GLenum = 0x8D55;
pub const GL_RENDERBUFFER_WIDTH: GLenum = 0x8D42;
pub const GL_RENDERER: GLenum = 0x1F01;
pub const GL_REPEAT: GLenum = 0x2901;
pub const GL_REPLACE: GLenum = 0x1E01;
pub const GL_RG: GLenum = 0x8227;
pub const GL_RG16: GLenum = 0x822C;
pub const GL_RG16F: GLenum = 0x822F;
pub const GL_RG16I: GLenum = 0x8239;
pub const GL_RG16UI: GLenum = 0x823A;
pub const GL_RG16_SNORM: GLenum = 0x8F99;
pub const GL_RG32F: GLenum = 0x8230;
pub const GL_RG32I: GLenum = 0x823B;
pub const GL_RG32UI: GLenum = 0x823C;
pub const GL_RG8: GLenum = 0x822B;
pub const GL_RG8I: GLenum = 0x8237;
pub const GL_RG8UI: GLenum = 0x8238;
pub const GL_RG8_SNORM: GLenum = 0x8F95;
pub const GL_RGB: GLenum = 0x1907;
pub const GL_RGB10: GLenum = 0x8052;
pub const GL_RGB10_A2: GLenum = 0x8059;
pub const GL_RGB10_A2UI: GLenum = 0x906F;
pub const GL_RGB12: GLenum = 0x8053;
pub const GL_RGB16: GLenum = 0x8054;
pub const GL_RGB16F: GLenum = 0x881B;
pub const GL_RGB16I: GLenum = 0x8D89;
pub const GL_RGB16UI: GLenum = 0x8D77;
pub const GL_RGB16_SNORM: GLenum = 0x8F9A;
pub const GL_RGB32F: GLenum = 0x8815;
pub const GL_RGB32I: GLenum = 0x8D83;
pub const GL_RGB32UI: GLenum = 0x8D71;
pub const GL_RGB4: GLenum = 0x804F;
pub const GL_RGB5: GLenum = 0x8050;
pub const GL_RGB5_A1: GLenum = 0x8057;
pub const GL_RGB8: GLenum = 0x8051;
pub const GL_RGB8I: GLenum = 0x8D8F;
pub const GL_RGB8UI: GLenum = 0x8D7D;
pub const GL_RGB8_SNORM: GLenum = 0x8F96;
pub const GL_RGB9_E5: GLenum = 0x8C3D;
pub const GL_RGBA: GLenum = 0x1908;
pub const GL_RGBA12: GLenum = 0x805A;
pub const GL_RGBA16: GLenum = 0x805B;
pub const GL_RGBA16F: GLenum = 0x881A;
pub const GL_RGBA16I: GLenum = 0x8D88;
pub const GL_RGBA16UI: GLenum = 0x8D76;
pub const GL_RGBA16_SNORM: GLenum = 0x8F9B;
pub const GL_RGBA2: GLenum = 0x8055;
pub const GL_RGBA32F: GLenum = 0x8814;
pub const GL_RGBA32I: GLenum = 0x8D82;
pub const GL_RGBA32UI: GLenum = 0x8D70;
pub const GL_RGBA4: GLenum = 0x8056;
pub const GL_RGBA8: GLenum = 0x8058;
pub const GL_RGBA8I: GLenum = 0x8D8E;
pub const GL_RGBA8UI: GLenum = 0x8D7C;
pub const GL_RGBA8_SNORM: GLenum = 0x8F97;
pub const GL_RGBA_INTEGER: GLenum = 0x8D99;
pub const GL_RGB_INTEGER: GLenum = 0x8D98;
pub const GL_RG_INTEGER: GLenum = 0x8228;
pub const GL_RIGHT: GLenum = 0x0407;
pub const GL_SAMPLER_1D: GLenum = 0x8B5D;
pub const GL_SAMPLER_1D_ARRAY: GLenum = 0x8DC0;
pub const GL_SAMPLER_1D_ARRAY_SHADOW: GLenum = 0x8DC3;
pub const GL_SAMPLER_1D_SHADOW: GLenum = 0x8B61;
pub const GL_SAMPLER_2D: GLenum = 0x8B5E;
pub const GL_SAMPLER_2D_ARRAY: GLenum = 0x8DC1;
pub const GL_SAMPLER_2D_ARRAY_SHADOW: GLenum = 0x8DC4;
pub const GL_SAMPLER_2D_MULTISAMPLE: GLenum = 0x9108;
pub const GL_SAMPLER_2D_MULTISAMPLE_ARRAY: GLenum = 0x910B;
pub const GL_SAMPLER_2D_RECT: GLenum = 0x8B63;
pub const GL_SAMPLER_2D_RECT_SHADOW: GLenum = 0x8B64;
pub const GL_SAMPLER_2D_SHADOW: GLenum = 0x8B62;
pub const GL_SAMPLER_3D: GLenum = 0x8B5F;
pub const GL_SAMPLER_BINDING: GLenum = 0x8919;
pub const GL_SAMPLER_BUFFER: GLenum = 0x8DC2;
pub const GL_SAMPLER_CUBE: GLenum = 0x8B60;
pub const GL_SAMPLER_CUBE_SHADOW: GLenum = 0x8DC5;
pub const GL_SAMPLES: GLenum = 0x80A9;
pub const GL_SAMPLES_PASSED: GLenum = 0x8914;
pub const GL_SAMPLE_ALPHA_TO_COVERAGE: GLenum = 0x809E;
pub const GL_SAMPLE_ALPHA_TO_ONE: GLenum = 0x809F;
pub const GL_SAMPLE_BUFFERS: GLenum = 0x80A8;
pub const GL_SAMPLE_COVERAGE: GLenum = 0x80A0;
pub const GL_SAMPLE_COVERAGE_INVERT: GLenum = 0x80AB;
pub const GL_SAMPLE_COVERAGE_VALUE: GLenum = 0x80AA;
pub const GL_SAMPLE_MASK: GLenum = 0x8E51;
pub const GL_SAMPLE_MASK_VALUE: GLenum = 0x8E52;
pub const GL_SAMPLE_POSITION: GLenum = 0x8E50;
pub const GL_SCISSOR_BOX: GLenum = 0x0C10;
pub const GL_SCISSOR_TEST: GLenum = 0x0C11;
pub const GL_SEPARATE_ATTRIBS: GLenum = 0x8C8D;
pub const GL_SET: GLenum = 0x150F;
pub const GL_SHADER_SOURCE_LENGTH: GLenum = 0x8B88;
pub const GL_SHADER_TYPE: GLenum = 0x8B4F;
pub const GL_SHADING_LANGUAGE_VERSION: GLenum = 0x8B8C;
pub const GL_SHORT: GLenum = 0x1402;
pub const GL_SIGNALED: GLenum = 0x9119;
pub const GL_SIGNED_NORMALIZED: GLenum = 0x8F9C;
pub const GL_SMOOTH_LINE_WIDTH_GRANULARITY: GLenum = 0x0B23;
pub const GL_SMOOTH_LINE_WIDTH_RANGE: GLenum = 0x0B22;
pub const GL_SMOOTH_POINT_SIZE_GRANULARITY: GLenum = 0x0B13;
pub const GL_SMOOTH_POINT_SIZE_RANGE: GLenum = 0x0B12;
pub const GL_SRC1_ALPHA: GLenum = 0x8589;
pub const GL_SRC1_COLOR: GLenum = 0x88F9;
pub const GL_SRC_ALPHA: GLenum = 0x0302;
pub const GL_SRC_ALPHA_SATURATE: GLenum = 0x0308;
pub const GL_SRC_COLOR: GLenum = 0x0300;
pub const GL_SRGB: GLenum = 0x8C40;
pub const GL_SRGB8: GLenum = 0x8C41;
pub const GL_SRGB8_ALPHA8: GLenum = 0x8C43;
pub const GL_SRGB_ALPHA: GLenum = 0x8C42;
pub const GL_STATIC_COPY: GLenum = 0x88E6;
pub const GL_STATIC_DRAW: GLenum = 0x88E4;
pub const GL_STATIC_READ: GLenum = 0x88E5;
pub const GL_STENCIL: GLenum = 0x1802;
pub const GL_STENCIL_ATTACHMENT: GLenum = 0x8D20;
pub const GL_STENCIL_BACK_FAIL: GLenum = 0x8801;
pub const GL_STENCIL_BACK_FUNC: GLenum = 0x8800;
pub const GL_STENCIL_BACK_PASS_DEPTH_FAIL: GLenum = 0x8802;
pub const GL_STENCIL_BACK_PASS_DEPTH_PASS: GLenum = 0x8803;
pub const GL_STENCIL_BACK_REF: GLenum = 0x8CA3;
pub const GL_STENCIL_BACK_VALUE_MASK: GLenum = 0x8CA4;
pub const GL_STENCIL_BACK_WRITEMASK: GLenum = 0x8CA5;
pub const GL_STENCIL_BUFFER_BIT: GLenum = 0x00000400;
pub const GL_STENCIL_CLEAR_VALUE: GLenum = 0x0B91;
pub const GL_STENCIL_FAIL: GLenum = 0x0B94;
pub const GL_STENCIL_FUNC: GLenum = 0x0B92;
pub const GL_STENCIL_INDEX: GLenum = 0x1901;
pub const GL_STENCIL_INDEX1: GLenum = 0x8D46;
pub const GL_STENCIL_INDEX16: GLenum = 0x8D49;
pub const GL_STENCIL_INDEX4: GLenum = 0x8D47;
pub const GL_STENCIL_INDEX8: GLenum = 0x8D48;
pub const GL_STENCIL_PASS_DEPTH_FAIL: GLenum = 0x0B95;
pub const GL_STENCIL_PASS_DEPTH_PASS: GLenum = 0x0B96;
pub const GL_STENCIL_REF: GLenum = 0x0B97;
pub const GL_STENCIL_TEST: GLenum = 0x0B90;
pub const GL_STENCIL_VALUE_MASK: GLenum = 0x0B93;
pub const GL_STENCIL_WRITEMASK: GLenum = 0x0B98;
pub const GL_STEREO: GLenum = 0x0C33;
pub const GL_STREAM_COPY: GLenum = 0x88E2;
pub const GL_STREAM_DRAW: GLenum = 0x88E0;
pub const GL_STREAM_READ: GLenum = 0x88E1;
pub const GL_SUBPIXEL_BITS: GLenum = 0x0D50;
pub const GL_SYNC_CONDITION: GLenum = 0x9113;
pub const GL_SYNC_FENCE: GLenum = 0x9116;
pub const GL_SYNC_FLAGS: GLenum = 0x9115;
pub const GL_SYNC_FLUSH_COMMANDS_BIT: GLenum = 0x00000001;
pub const GL_SYNC_GPU_COMMANDS_COMPLETE: GLenum = 0x9117;
pub const GL_SYNC_STATUS: GLenum = 0x9114;
pub const GL_TEXTURE: GLenum = 0x1702;
pub const GL_TEXTURE0: GLenum = 0x84C0;
pub const GL_TEXTURE1: GLenum = 0x84C1;
pub const GL_TEXTURE10: GLenum = 0x84CA;
pub const GL_TEXTURE11: GLenum = 0x84CB;
pub const GL_TEXTURE12: GLenum = 0x84CC;
pub const GL_TEXTURE13: GLenum = 0x84CD;
pub const GL_TEXTURE14: GLenum = 0x84CE;
pub const GL_TEXTURE15: GLenum = 0x84CF;
pub const GL_TEXTURE16: GLenum = 0x84D0;
pub const GL_TEXTURE17: GLenum = 0x84D1;
pub const GL_TEXTURE18: GLenum = 0x84D2;
pub const GL_TEXTURE19: GLenum = 0x84D3;
pub const GL_TEXTURE2: GLenum = 0x84C2;
pub const GL_TEXTURE20: GLenum = 0x84D4;
pub const GL_TEXTURE21: GLenum = 0x84D5;
pub const GL_TEXTURE22: GLenum = 0x84D6;
pub const GL_TEXTURE23: GLenum = 0x84D7;
pub const GL_TEXTURE24: GLenum = 0x84D8;
pub const GL_TEXTURE25: GLenum = 0x84D9;
pub const GL_TEXTURE26: GLenum = 0x84DA;
pub const GL_TEXTURE27: GLenum = 0x84DB;
pub const GL_TEXTURE28: GLenum = 0x84DC;
pub const GL_TEXTURE29: GLenum = 0x84DD;
pub const GL_TEXTURE3: GLenum = 0x84C3;
pub const GL_TEXTURE30: GLenum = 0x84DE;
pub const GL_TEXTURE31: GLenum = 0x84DF;
pub const GL_TEXTURE4: GLenum = 0x84C4;
pub const GL_TEXTURE5: GLenum = 0x84C5;
pub const GL_TEXTURE6: GLenum = 0x84C6;
pub const GL_TEXTURE7: GLenum = 0x84C7;
pub const GL_TEXTURE8: GLenum = 0x84C8;
pub const GL_TEXTURE9: GLenum = 0x84C9;
pub const GL_TEXTURE_1D: GLenum = 0x0DE0;
pub const GL_TEXTURE_1D_ARRAY: GLenum = 0x8C18;
pub const GL_TEXTURE_2D: GLenum = 0x0DE1;
pub const GL_TEXTURE_2D_ARRAY: GLenum = 0x8C1A;
pub const GL_TEXTURE_2D_MULTISAMPLE: GLenum = 0x9100;
pub const GL_TEXTURE_2D_MULTISAMPLE_ARRAY: GLenum = 0x9102;
pub const GL_TEXTURE_3D: GLenum = 0x806F;
pub const GL_TEXTURE_ALPHA_SIZE: GLenum = 0x805F;
pub const GL_TEXTURE_ALPHA_TYPE: GLenum = 0x8C13;
pub const GL_TEXTURE_BASE_LEVEL: GLenum = 0x813C;
pub const GL_TEXTURE_BINDING_1D: GLenum = 0x8068;
pub const GL_TEXTURE_BINDING_1D_ARRAY: GLenum = 0x8C1C;
pub const GL_TEXTURE_BINDING_2D: GLenum = 0x8069;
pub const GL_TEXTURE_BINDING_2D_ARRAY: GLenum = 0x8C1D;
pub const GL_TEXTURE_BINDING_2D_MULTISAMPLE: GLenum = 0x9104;
pub const GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY: GLenum = 0x9105;
pub const GL_TEXTURE_BINDING_3D: GLenum = 0x806A;
pub const GL_TEXTURE_BINDING_BUFFER: GLenum = 0x8C2C;
pub const GL_TEXTURE_BINDING_CUBE_MAP: GLenum = 0x8514;
pub const GL_TEXTURE_BINDING_RECTANGLE: GLenum = 0x84F6;
pub const GL_TEXTURE_BLUE_SIZE: GLenum = 0x805E;
pub const GL_TEXTURE_BLUE_TYPE: GLenum = 0x8C12;
pub const GL_TEXTURE_BORDER_COLOR: GLenum = 0x1004;
pub const GL_TEXTURE_BUFFER: GLenum = 0x8C2A;
pub const GL_TEXTURE_BUFFER_DATA_STORE_BINDING: GLenum = 0x8C2D;
pub const GL_TEXTURE_COMPARE_FUNC: GLenum = 0x884D;
pub const GL_TEXTURE_COMPARE_MODE: GLenum = 0x884C;
pub const GL_TEXTURE_COMPRESSED: GLenum = 0x86A1;
pub const GL_TEXTURE_COMPRESSED_IMAGE_SIZE: GLenum = 0x86A0;
pub const GL_TEXTURE_COMPRESSION_HINT: GLenum = 0x84EF;
pub const GL_TEXTURE_CUBE_MAP: GLenum = 0x8513;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum = 0x8516;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum = 0x8518;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum = 0x851A;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_X: GLenum = 0x8515;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum = 0x8517;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum = 0x8519;
pub const GL_TEXTURE_CUBE_MAP_SEAMLESS: GLenum = 0x884F;
pub const GL_TEXTURE_DEPTH: GLenum = 0x8071;
pub const GL_TEXTURE_DEPTH_SIZE: GLenum = 0x884A;
pub const GL_TEXTURE_DEPTH_TYPE: GLenum = 0x8C16;
pub const GL_TEXTURE_FIXED_SAMPLE_LOCATIONS: GLenum = 0x9107;
pub const GL_TEXTURE_GREEN_SIZE: GLenum = 0x805D;
pub const GL_TEXTURE_GREEN_TYPE: GLenum = 0x8C11;
pub const GL_TEXTURE_HEIGHT: GLenum = 0x1001;
pub const GL_TEXTURE_INTERNAL_FORMAT: GLenum = 0x1003;
pub const GL_TEXTURE_LOD_BIAS: GLenum = 0x8501;
pub const GL_TEXTURE_MAG_FILTER: GLenum = 0x2800;
pub const GL_TEXTURE_MAX_LEVEL: GLenum = 0x813D;
pub const GL_TEXTURE_MAX_LOD: GLenum = 0x813B;
pub const GL_TEXTURE_MIN_FILTER: GLenum = 0x2801;
pub const GL_TEXTURE_MIN_LOD: GLenum = 0x813A;
pub const GL_TEXTURE_RECTANGLE: GLenum = 0x84F5;
pub const GL_TEXTURE_RED_SIZE: GLenum = 0x805C;
pub const GL_TEXTURE_RED_TYPE: GLenum = 0x8C10;
pub const GL_TEXTURE_SAMPLES: GLenum = 0x9106;
pub const GL_TEXTURE_SHARED_SIZE: GLenum = 0x8C3F;
pub const GL_TEXTURE_STENCIL_SIZE: GLenum = 0x88F1;
pub const GL_TEXTURE_SWIZZLE_A: GLenum = 0x8E45;
pub const GL_TEXTURE_SWIZZLE_B: GLenum = 0x8E44;
pub const GL_TEXTURE_SWIZZLE_G: GLenum = 0x8E43;
pub const GL_TEXTURE_SWIZZLE_R: GLenum = 0x8E42;
pub const GL_TEXTURE_SWIZZLE_RGBA: GLenum = 0x8E46;
pub const GL_TEXTURE_WIDTH: GLenum = 0x1000;
pub const GL_TEXTURE_WRAP_R: GLenum = 0x8072;
pub const GL_TEXTURE_WRAP_S: GLenum = 0x2802;
pub const GL_TEXTURE_WRAP_T: GLenum = 0x2803;
pub const GL_TIMEOUT_EXPIRED: GLenum = 0x911B;
pub const GL_TIMEOUT_IGNORED: GLuint64 = 0xFFFFFFFFFFFFFFFF;
pub const GL_TIMESTAMP: GLenum = 0x8E28;
pub const GL_TIME_ELAPSED: GLenum = 0x88BF;
pub const GL_TRANSFORM_FEEDBACK_BUFFER: GLenum = 0x8C8E;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum = 0x8C8F;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum = 0x8C7F;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum = 0x8C85;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_START: GLenum = 0x8C84;
pub const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum = 0x8C88;
pub const GL_TRANSFORM_FEEDBACK_VARYINGS: GLenum = 0x8C83;
pub const GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: GLenum = 0x8C76;
pub const GL_TRIANGLES: GLenum = 0x0004;
pub const GL_TRIANGLES_ADJACENCY: GLenum = 0x000C;
pub const GL_TRIANGLE_FAN: GLenum = 0x0006;
pub const GL_TRIANGLE_STRIP: GLenum = 0x0005;
pub const GL_TRIANGLE_STRIP_ADJACENCY: GLenum = 0x000D;
pub const GL_TRUE: GLboolean = 1;
pub const GL_UNIFORM_ARRAY_STRIDE: GLenum = 0x8A3C;
pub const GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum = 0x8A42;
pub const GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum = 0x8A43;
pub const GL_UNIFORM_BLOCK_BINDING: GLenum = 0x8A3F;
pub const GL_UNIFORM_BLOCK_DATA_SIZE: GLenum = 0x8A40;
pub const GL_UNIFORM_BLOCK_INDEX: GLenum = 0x8A3A;
pub const GL_UNIFORM_BLOCK_NAME_LENGTH: GLenum = 0x8A41;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum = 0x8A46;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER: GLenum = 0x8A45;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum = 0x8A44;
pub const GL_UNIFORM_BUFFER: GLenum = 0x8A11;
pub const GL_UNIFORM_BUFFER_BINDING: GLenum = 0x8A28;
pub const GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum = 0x8A34;
pub const GL_UNIFORM_BUFFER_SIZE: GLenum = 0x8A2A;
pub const GL_UNIFORM_BUFFER_START: GLenum = 0x8A29;
pub const GL_UNIFORM_IS_ROW_MAJOR: GLenum = 0x8A3E;
pub const GL_UNIFORM_MATRIX_STRIDE: GLenum = 0x8A3D;
pub const GL_UNIFORM_NAME_LENGTH: GLenum = 0x8A39;
pub const GL_UNIFORM_OFFSET: GLenum = 0x8A3B;
pub const GL_UNIFORM_SIZE: GLenum = 0x8A38;
pub const GL_UNIFORM_TYPE: GLenum = 0x8A37;
pub const GL_UNPACK_ALIGNMENT: GLenum = 0x0CF5;
pub const GL_UNPACK_IMAGE_HEIGHT: GLenum = 0x806E;
pub const GL_UNPACK_LSB_FIRST: GLenum = 0x0CF1;
pub const GL_UNPACK_ROW_LENGTH: GLenum = 0x0CF2;
pub const GL_UNPACK_SKIP_IMAGES: GLenum = 0x806D;
pub const GL_UNPACK_SKIP_PIXELS: GLenum = 0x0CF4;
pub const GL_UNPACK_SKIP_ROWS: GLenum = 0x0CF3;
pub const GL_UNPACK_SWAP_BYTES: GLenum = 0x0CF0;
pub const GL_UNSIGNALED: GLenum = 0x9118;
pub const GL_UNSIGNED_BYTE: GLenum = 0x1401;
pub const GL_UNSIGNED_BYTE_2_3_3_REV: GLenum = 0x8362;
pub const GL_UNSIGNED_BYTE_3_3_2: GLenum = 0x8032;
pub const GL_UNSIGNED_INT: GLenum = 0x1405;
pub const GL_UNSIGNED_INT_10F_11F_11F_REV: GLenum = 0x8C3B;
pub const GL_UNSIGNED_INT_10_10_10_2: GLenum = 0x8036;
pub const GL_UNSIGNED_INT_24_8: GLenum = 0x84FA;
pub const GL_UNSIGNED_INT_2_10_10_10_REV: GLenum = 0x8368;
pub const GL_UNSIGNED_INT_5_9_9_9_REV: GLenum = 0x8C3E;
pub const GL_UNSIGNED_INT_8_8_8_8: GLenum = 0x8035;
pub const GL_UNSIGNED_INT_8_8_8_8_REV: GLenum = 0x8367;
pub const GL_UNSIGNED_INT_SAMPLER_1D: GLenum = 0x8DD1;
pub const GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: GLenum = 0x8DD6;
pub const GL_UNSIGNED_INT_SAMPLER_2D: GLenum = 0x8DD2;
pub const GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum = 0x8DD7;
pub const GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: GLenum = 0x910A;
pub const GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: GLenum = 0x910D;
pub const GL_UNSIGNED_INT_SAMPLER_2D_RECT: GLenum = 0x8DD5;
pub const GL_UNSIGNED_INT_SAMPLER_3D: GLenum = 0x8DD3;
pub const GL_UNSIGNED_INT_SAMPLER_BUFFER: GLenum = 0x8DD8;
pub const GL_UNSIGNED_INT_SAMPLER_CUBE: GLenum = 0x8DD4;
pub const GL_UNSIGNED_INT_VEC2: GLenum = 0x8DC6;
pub const GL_UNSIGNED_INT_VEC3: GLenum = 0x8DC7;
pub const GL_UNSIGNED_INT_VEC4: GLenum = 0x8DC8;
pub const GL_UNSIGNED_NORMALIZED: GLenum = 0x8C17;
pub const GL_UNSIGNED_SHORT: GLenum = 0x1403;
pub const GL_UNSIGNED_SHORT_1_5_5_5_REV: GLenum = 0x8366;
pub const GL_UNSIGNED_SHORT_4_4_4_4: GLenum = 0x8033;
pub const GL_UNSIGNED_SHORT_4_4_4_4_REV: GLenum = 0x8365;
pub const GL_UNSIGNED_SHORT_5_5_5_1: GLenum = 0x8034;
pub const GL_UNSIGNED_SHORT_5_6_5: GLenum = 0x8363;
pub const GL_UNSIGNED_SHORT_5_6_5_REV: GLenum = 0x8364;
pub const GL_UPPER_LEFT: GLenum = 0x8CA2;
pub const GL_VALIDATE_STATUS: GLenum = 0x8B83;
pub const GL_VENDOR: GLenum = 0x1F00;
pub const GL_VERSION: GLenum = 0x1F02;
pub const GL_VERTEX_ARRAY_BINDING: GLenum = 0x85B5;
pub const GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum = 0x889F;
pub const GL_VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum = 0x88FE;
pub const GL_VERTEX_ATTRIB_ARRAY_ENABLED: GLenum = 0x8622;
pub const GL_VERTEX_ATTRIB_ARRAY_INTEGER: GLenum = 0x88FD;
pub const GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum = 0x886A;
pub const GL_VERTEX_ATTRIB_ARRAY_POINTER: GLenum = 0x8645;
pub const GL_VERTEX_ATTRIB_ARRAY_SIZE: GLenum = 0x8623;
pub const GL_VERTEX_ATTRIB_ARRAY_STRIDE: GLenum = 0x8624;
pub const GL_VERTEX_ATTRIB_ARRAY_TYPE: GLenum = 0x8625;
pub const GL_VERTEX_PROGRAM_POINT_SIZE: GLenum = 0x8642;
pub const GL_VERTEX_SHADER: GLenum = 0x8B31;
pub const GL_VIEWPORT: GLenum = 0x0BA2;
pub const GL_WAIT_FAILED: GLenum = 0x911D;
pub const GL_WRITE_ONLY: GLenum = 0x88B9;
pub const GL_XOR: GLenum = 0x1506;
pub const GL_ZERO: GLenum = 0;
}
pub use functions::*;
pub mod functions {
use super::*;
#[inline]
pub unsafe fn glActiveTexture(texture: GLenum) {
trace!("glActiveTexture");
let p: *mut c_void = {
let temp_p = storage::ActiveTexture.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glActiveTexture not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(texture);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glActiveTexture({:?}): {}", texture, err);
}
}
out
}
#[inline]
pub unsafe fn glAttachShader(program: GLuint, shader: GLuint) {
trace!("glAttachShader");
let p: *mut c_void = {
let temp_p = storage::AttachShader.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glAttachShader not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLuint)>(p)(
program, shader,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glAttachShader({:?}, {:?}): {}", program, shader, err);
}
}
out
}
#[inline]
pub unsafe fn glBeginConditionalRender(id: GLuint, mode: GLenum) {
trace!("glBeginConditionalRender");
let p: *mut c_void = {
let temp_p = storage::BeginConditionalRender.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBeginConditionalRender not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLuint, GLenum)>(p)(id, mode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBeginConditionalRender({:?}, {:?}): {}", id, mode, err);
}
}
out
}
#[inline]
pub unsafe fn glBeginQuery(target: GLenum, id: GLuint) {
trace!("glBeginQuery");
let p: *mut c_void = {
let temp_p = storage::BeginQuery.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBeginQuery not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target, id,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBeginQuery({:?}, {:?}): {}", target, id, err);
}
}
out
}
#[inline]
pub unsafe fn glBeginTransformFeedback(primitiveMode: GLenum) {
trace!("glBeginTransformFeedback");
let p: *mut c_void = {
let temp_p = storage::BeginTransformFeedback.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBeginTransformFeedback not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(primitiveMode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBeginTransformFeedback({:?}): {}", primitiveMode, err);
}
}
out
}
#[inline]
pub unsafe fn glBindAttribLocation(
program: GLuint,
index: GLuint,
name: *const GLchar,
) {
trace!("glBindAttribLocation");
let p: *mut c_void = {
let temp_p = storage::BindAttribLocation.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindAttribLocation not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, *const GLchar),
>(p)(program, index, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBindAttribLocation({:?}, {:?}, {:?}): {}",
program, index, name, err
);
}
}
out
}
#[inline]
pub unsafe fn glBindBuffer(target: GLenum, buffer: GLuint) {
trace!("glBindBuffer");
let p: *mut c_void = {
let temp_p = storage::BindBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindBuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target, buffer,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBindBuffer({:?}, {:?}): {}", target, buffer, err);
}
}
out
}
#[inline]
pub unsafe fn glBindBufferBase(
target: GLenum,
index: GLuint,
buffer: GLuint,
) {
trace!("glBindBufferBase");
let p: *mut c_void = {
let temp_p = storage::BindBufferBase.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindBufferBase not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint, GLuint),
>(p)(target, index, buffer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBindBufferBase({:?}, {:?}, {:?}): {}",
target, index, buffer, err
);
}
}
out
}
#[inline]
pub unsafe fn glBindBufferRange(
target: GLenum,
index: GLuint,
buffer: GLuint,
offset: GLintptr,
size: GLsizeiptr,
) {
trace!("glBindBufferRange");
let p: *mut c_void = {
let temp_p = storage::BindBufferRange.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindBufferRange not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint, GLuint, GLintptr, GLsizeiptr),
>(p)(target, index, buffer, offset, size);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBindBufferRange({:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, index, buffer, offset, size, err
);
}
}
out
}
#[inline]
pub unsafe fn glBindFragDataLocation(
program: GLuint,
color: GLuint,
name: *const GLchar,
) {
trace!("glBindFragDataLocation");
let p: *mut c_void = {
let temp_p = storage::BindFragDataLocation.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindFragDataLocation not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, *const GLchar),
>(p)(program, color, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBindFragDataLocation({:?}, {:?}, {:?}): {}",
program, color, name, err
);
}
}
out
}
#[inline]
pub unsafe fn glBindFragDataLocationIndexed(
program: GLuint,
colorNumber: GLuint,
index: GLuint,
name: *const GLchar,
) {
trace!("glBindFragDataLocationIndexed");
let p: *mut c_void = {
let temp_p = storage::BindFragDataLocationIndexed.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindFragDataLocationIndexed not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLuint, *const GLchar),
>(p)(program, colorNumber, index, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBindFragDataLocationIndexed({:?}, {:?}, {:?}, {:?}): {}",
program, colorNumber, index, name, err
);
}
}
out
}
#[inline]
pub unsafe fn glBindFramebuffer(target: GLenum, framebuffer: GLuint) {
trace!("glBindFramebuffer");
let p: *mut c_void = {
let temp_p = storage::BindFramebuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindFramebuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target,
framebuffer,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBindFramebuffer({:?}, {:?}): {}", target, framebuffer, err);
}
}
out
}
#[inline]
pub unsafe fn glBindRenderbuffer(target: GLenum, renderbuffer: GLuint) {
trace!("glBindRenderbuffer");
let p: *mut c_void = {
let temp_p = storage::BindRenderbuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindRenderbuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target,
renderbuffer,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBindRenderbuffer({:?}, {:?}): {}", target, renderbuffer, err);
}
}
out
}
#[inline]
pub unsafe fn glBindSampler(unit: GLuint, sampler: GLuint) {
trace!("glBindSampler");
let p: *mut c_void = {
let temp_p = storage::BindSampler.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindSampler not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLuint)>(p)(
unit, sampler,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBindSampler({:?}, {:?}): {}", unit, sampler, err);
}
}
out
}
#[inline]
pub unsafe fn glBindTexture(target: GLenum, texture: GLuint) {
trace!("glBindTexture");
let p: *mut c_void = {
let temp_p = storage::BindTexture.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindTexture not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target, texture,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBindTexture({:?}, {:?}): {}", target, texture, err);
}
}
out
}
#[inline]
pub unsafe fn glBindVertexArray(array: GLuint) {
trace!("glBindVertexArray");
let p: *mut c_void = {
let temp_p = storage::BindVertexArray.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBindVertexArray not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(array);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBindVertexArray({:?}): {}", array, err);
}
}
out
}
#[inline]
pub unsafe fn glBlendColor(
red: GLfloat,
green: GLfloat,
blue: GLfloat,
alpha: GLfloat,
) {
trace!("glBlendColor");
let p: *mut c_void = {
let temp_p = storage::BlendColor.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBlendColor not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLfloat, GLfloat, GLfloat, GLfloat),
>(p)(red, green, blue, alpha);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBlendColor({:?}, {:?}, {:?}, {:?}): {}",
red, green, blue, alpha, err
);
}
}
out
}
#[inline]
pub unsafe fn glBlendEquation(mode: GLenum) {
trace!("glBlendEquation");
let p: *mut c_void = {
let temp_p = storage::BlendEquation.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBlendEquation not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(mode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBlendEquation({:?}): {}", mode, err);
}
}
out
}
#[inline]
pub unsafe fn glBlendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum) {
trace!("glBlendEquationSeparate");
let p: *mut c_void = {
let temp_p = storage::BlendEquationSeparate.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBlendEquationSeparate not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLenum)>(p)(
modeRGB, modeAlpha,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBlendEquationSeparate({:?}, {:?}): {}",
modeRGB, modeAlpha, err
);
}
}
out
}
#[inline]
pub unsafe fn glBlendFunc(sfactor: GLenum, dfactor: GLenum) {
trace!("glBlendFunc");
let p: *mut c_void = {
let temp_p = storage::BlendFunc.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBlendFunc not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLenum)>(p)(
sfactor, dfactor,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBlendFunc({:?}, {:?}): {}", sfactor, dfactor, err);
}
}
out
}
#[inline]
pub unsafe fn glBlendFuncSeparate(
sfactorRGB: GLenum,
dfactorRGB: GLenum,
sfactorAlpha: GLenum,
dfactorAlpha: GLenum,
) {
trace!("glBlendFuncSeparate");
let p: *mut c_void = {
let temp_p = storage::BlendFuncSeparate.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBlendFuncSeparate not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, GLenum),
>(p)(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBlendFuncSeparate({:?}, {:?}, {:?}, {:?}): {}",
sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha, err
);
}
}
out
}
#[inline]
pub unsafe fn glBlitFramebuffer(
srcX0: GLint,
srcY0: GLint,
srcX1: GLint,
srcY1: GLint,
dstX0: GLint,
dstY0: GLint,
dstX1: GLint,
dstY1: GLint,
mask: GLbitfield,
filter: GLenum,
) {
trace!("glBlitFramebuffer");
let p: *mut c_void = {
let temp_p = storage::BlitFramebuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBlitFramebuffer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLint,
GLint,
GLint,
GLint,
GLint,
GLint,
GLint,
GLint,
GLbitfield,
GLenum,
),
>(p)(
srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glBlitFramebuffer({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter, err);
}
}
out
}
#[inline]
pub unsafe fn glBufferData(
target: GLenum,
size: GLsizeiptr,
data: *const c_void,
usage: GLenum,
) {
trace!("glBufferData");
let p: *mut c_void = {
let temp_p = storage::BufferData.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBufferData not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLsizeiptr, *const c_void, GLenum),
>(p)(target, size, data, usage);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBufferData({:?}, {:?}, {:?}, {:?}): {}",
target, size, data, usage, err
);
}
}
out
}
#[inline]
pub unsafe fn glBufferSubData(
target: GLenum,
offset: GLintptr,
size: GLsizeiptr,
data: *const c_void,
) {
trace!("glBufferSubData");
let p: *mut c_void = {
let temp_p = storage::BufferSubData.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glBufferSubData not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLintptr, GLsizeiptr, *const c_void),
>(p)(target, offset, size, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glBufferSubData({:?}, {:?}, {:?}, {:?}): {}",
target, offset, size, data, err
);
}
}
out
}
#[inline]
pub unsafe fn glCheckFramebufferStatus(target: GLenum) -> GLenum {
trace!("glCheckFramebufferStatus");
let p: *mut c_void = {
let temp_p = storage::CheckFramebufferStatus.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCheckFramebufferStatus not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLenum) -> GLenum>(p)(target);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCheckFramebufferStatus({:?}): {}", target, err);
}
}
out
}
#[inline]
pub unsafe fn glClampColor(target: GLenum, clamp: GLenum) {
trace!("glClampColor");
let p: *mut c_void = {
let temp_p = storage::ClampColor.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClampColor not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLenum)>(p)(
target, clamp,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glClampColor({:?}, {:?}): {}", target, clamp, err);
}
}
out
}
#[inline]
pub unsafe fn glClear(mask: GLbitfield) {
trace!("glClear");
let p: *mut c_void = {
let temp_p = storage::Clear.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClear not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLbitfield)>(p)(mask);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glClear({:?}): {}", mask, err);
}
}
out
}
#[inline]
pub unsafe fn glClearBufferfi(
buffer: GLenum,
drawbuffer: GLint,
depth: GLfloat,
stencil: GLint,
) {
trace!("glClearBufferfi");
let p: *mut c_void = {
let temp_p = storage::ClearBufferfi.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearBufferfi not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLfloat, GLint),
>(p)(buffer, drawbuffer, depth, stencil);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glClearBufferfi({:?}, {:?}, {:?}, {:?}): {}",
buffer, drawbuffer, depth, stencil, err
);
}
}
out
}
#[inline]
pub unsafe fn glClearBufferfv(
buffer: GLenum,
drawbuffer: GLint,
value: *const GLfloat,
) {
trace!("glClearBufferfv");
let p: *mut c_void = {
let temp_p = storage::ClearBufferfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearBufferfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, *const GLfloat),
>(p)(buffer, drawbuffer, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glClearBufferfv({:?}, {:?}, {:?}): {}",
buffer, drawbuffer, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glClearBufferiv(
buffer: GLenum,
drawbuffer: GLint,
value: *const GLint,
) {
trace!("glClearBufferiv");
let p: *mut c_void = {
let temp_p = storage::ClearBufferiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearBufferiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, *const GLint),
>(p)(buffer, drawbuffer, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glClearBufferiv({:?}, {:?}, {:?}): {}",
buffer, drawbuffer, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glClearBufferuiv(
buffer: GLenum,
drawbuffer: GLint,
value: *const GLuint,
) {
trace!("glClearBufferuiv");
let p: *mut c_void = {
let temp_p = storage::ClearBufferuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearBufferuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, *const GLuint),
>(p)(buffer, drawbuffer, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glClearBufferuiv({:?}, {:?}, {:?}): {}",
buffer, drawbuffer, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glClearColor(
red: GLfloat,
green: GLfloat,
blue: GLfloat,
alpha: GLfloat,
) {
trace!("glClearColor");
let p: *mut c_void = {
let temp_p = storage::ClearColor.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearColor not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLfloat, GLfloat, GLfloat, GLfloat),
>(p)(red, green, blue, alpha);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glClearColor({:?}, {:?}, {:?}, {:?}): {}",
red, green, blue, alpha, err
);
}
}
out
}
#[inline]
pub unsafe fn glClearDepth(depth: GLdouble) {
trace!("glClearDepth");
let p: *mut c_void = {
let temp_p = storage::ClearDepth.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearDepth not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLdouble)>(p)(depth);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glClearDepth({:?}): {}", depth, err);
}
}
out
}
#[inline]
pub unsafe fn glClearStencil(s: GLint) {
trace!("glClearStencil");
let p: *mut c_void = {
let temp_p = storage::ClearStencil.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClearStencil not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLint)>(p)(s);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glClearStencil({:?}): {}", s, err);
}
}
out
}
#[inline]
pub unsafe fn glClientWaitSync(
sync: GLsync,
flags: GLbitfield,
timeout: GLuint64,
) -> GLenum {
trace!("glClientWaitSync");
let p: *mut c_void = {
let temp_p = storage::ClientWaitSync.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glClientWaitSync not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsync, GLbitfield, GLuint64) -> GLenum,
>(p)(sync, flags, timeout);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glClientWaitSync({:?}, {:?}, {:?}): {}",
sync, flags, timeout, err
);
}
}
out
}
#[inline]
pub unsafe fn glColorMask(
red: GLboolean,
green: GLboolean,
blue: GLboolean,
alpha: GLboolean,
) {
trace!("glColorMask");
let p: *mut c_void = {
let temp_p = storage::ColorMask.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glColorMask not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLboolean, GLboolean, GLboolean, GLboolean),
>(p)(red, green, blue, alpha);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glColorMask({:?}, {:?}, {:?}, {:?}): {}",
red, green, blue, alpha, err
);
}
}
out
}
#[inline]
pub unsafe fn glColorMaski(
index: GLuint,
r: GLboolean,
g: GLboolean,
b: GLboolean,
a: GLboolean,
) {
trace!("glColorMaski");
let p: *mut c_void = {
let temp_p = storage::ColorMaski.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glColorMaski not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLboolean, GLboolean, GLboolean, GLboolean),
>(p)(index, r, g, b, a);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glColorMaski({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, r, g, b, a, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glColorP3ui(type_: GLenum, color: GLuint) {
trace!("glColorP3ui");
let p: *mut c_void = {
let temp_p = storage::ColorP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glColorP3ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, color,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glColorP3ui({:?}, {:?}): {}", type_, color, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glColorP3uiv(type_: GLenum, color: *const GLuint) {
trace!("glColorP3uiv");
let p: *mut c_void = {
let temp_p = storage::ColorP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glColorP3uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, color);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glColorP3uiv({:?}, {:?}): {}", type_, color, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glColorP4ui(type_: GLenum, color: GLuint) {
trace!("glColorP4ui");
let p: *mut c_void = {
let temp_p = storage::ColorP4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glColorP4ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, color,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glColorP4ui({:?}, {:?}): {}", type_, color, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glColorP4uiv(type_: GLenum, color: *const GLuint) {
trace!("glColorP4ui");
let p: *mut c_void = {
let temp_p = storage::ColorP4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glColorP4uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, color);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glColorP4uiv({:?}, {:?}): {}", type_, color, err);
}
}
out
}
#[inline]
pub unsafe fn glCompileShader(shader: GLuint) {
trace!("glCompileShader");
let p: *mut c_void = {
let temp_p = storage::CompileShader.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompileShader not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(shader);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompileShader({:?}): {}", shader, err);
}
}
out
}
#[inline]
pub unsafe fn glCompressedTexImage1D(
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
trace!("glCompressedTexImage1D");
let p: *mut c_void = {
let temp_p = storage::CompressedTexImage1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompressedTexImage1D not loaded");
}
temp_p
};
let out =
transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLenum,
GLsizei,
GLint,
GLsizei,
*const c_void,
),
>(p)(target, level, internalformat, width, border, imageSize, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompressedTexImage1D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, level, internalformat, width, border, imageSize, data, err
);
}
}
out
}
#[inline]
pub unsafe fn glCompressedTexImage2D(
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
trace!("glCompressedTexImage2D");
let p: *mut c_void = {
let temp_p = storage::CompressedTexImage2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompressedTexImage2D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLenum,
GLsizei,
GLsizei,
GLint,
GLsizei,
*const c_void,
),
>(p)(
target,
level,
internalformat,
width,
height,
border,
imageSize,
data,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompressedTexImage2D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, internalformat, width, height, border, imageSize, data, err);
}
}
out
}
#[inline]
pub unsafe fn glCompressedTexImage3D(
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
trace!("glCompressedTexImage3D");
let p: *mut c_void = {
let temp_p = storage::CompressedTexImage3D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompressedTexImage3D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLenum,
GLsizei,
GLsizei,
GLsizei,
GLint,
GLsizei,
*const c_void,
),
>(p)(
target,
level,
internalformat,
width,
height,
depth,
border,
imageSize,
data,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompressedTexImage3D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, internalformat, width, height, depth, border, imageSize, data, err);
}
}
out
}
#[inline]
pub unsafe fn glCompressedTexSubImage1D(
target: GLenum,
level: GLint,
xoffset: GLint,
width: GLsizei,
format: GLenum,
imageSize: GLsizei,
data: *const c_void,
) {
trace!("glCompressedTexSubImage1D");
let p: *mut c_void = {
let temp_p = storage::CompressedTexSubImage1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompressedTexSubImage1D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLsizei,
GLenum,
GLsizei,
*const c_void,
),
>(p)(target, level, xoffset, width, format, imageSize, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompressedTexSubImage1D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, width, format, imageSize, data, err);
}
}
out
}
#[inline]
pub unsafe fn glCompressedTexSubImage2D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
imageSize: GLsizei,
data: *const c_void,
) {
trace!("glCompressedTexSubImage2D");
let p: *mut c_void = {
let temp_p = storage::CompressedTexSubImage2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompressedTexSubImage2D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLint,
GLsizei,
GLsizei,
GLenum,
GLsizei,
*const c_void,
),
>(p)(
target, level, xoffset, yoffset, width, height, format, imageSize, data,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompressedTexSubImage2D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, yoffset, width, height, format, imageSize, data, err);
}
}
out
}
#[inline]
pub unsafe fn glCompressedTexSubImage3D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
format: GLenum,
imageSize: GLsizei,
data: *const c_void,
) {
trace!("glCompressedTexSubImage3D");
let p: *mut c_void = {
let temp_p = storage::CompressedTexSubImage3D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCompressedTexSubImage3D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLint,
GLint,
GLsizei,
GLsizei,
GLsizei,
GLenum,
GLsizei,
*const c_void,
),
>(p)(
target, level, xoffset, yoffset, zoffset, width, height, depth, format,
imageSize, data,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCompressedTexSubImage3D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data, err);
}
}
out
}
#[inline]
pub unsafe fn glCopyBufferSubData(
readTarget: GLenum,
writeTarget: GLenum,
readOffset: GLintptr,
writeOffset: GLintptr,
size: GLsizeiptr,
) {
trace!("glCopyBufferSubData");
let p: *mut c_void = {
let temp_p = storage::CopyBufferSubData.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCopyBufferSubData not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr),
>(p)(readTarget, writeTarget, readOffset, writeOffset, size);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glCopyBufferSubData({:?}, {:?}, {:?}, {:?}, {:?}): {}",
readTarget, writeTarget, readOffset, writeOffset, size, err
);
}
}
out
}
#[inline]
pub unsafe fn glCopyTexImage1D(
target: GLenum,
level: GLint,
internalformat: GLenum,
x: GLint,
y: GLint,
width: GLsizei,
border: GLint,
) {
trace!("glCopyTexImage1D");
let p: *mut c_void = {
let temp_p = storage::CopyTexImage1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCopyTexImage1D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint),
>(p)(target, level, internalformat, x, y, width, border);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glCopyTexImage1D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, level, internalformat, x, y, width, border, err
);
}
}
out
}
#[inline]
pub unsafe fn glCopyTexImage2D(
target: GLenum,
level: GLint,
internalformat: GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
border: GLint,
) {
trace!("glCopyTexImage2D");
let p: *mut c_void = {
let temp_p = storage::CopyTexImage2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCopyTexImage2D not loaded");
}
temp_p
};
let out =
transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLenum,
GLint,
GLint,
GLsizei,
GLsizei,
GLint,
),
>(p)(target, level, internalformat, x, y, width, height, border);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCopyTexImage2D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, level, internalformat, x, y, width, height, border, err
);
}
}
out
}
#[inline]
pub unsafe fn glCopyTexSubImage1D(
target: GLenum,
level: GLint,
xoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
) {
trace!("glCopyTexSubImage1D");
let p: *mut c_void = {
let temp_p = storage::CopyTexSubImage1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCopyTexSubImage1D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLint, GLint, GLint, GLsizei),
>(p)(target, level, xoffset, x, y, width);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glCopyTexSubImage1D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, level, xoffset, x, y, width, err
);
}
}
out
}
#[inline]
pub unsafe fn glCopyTexSubImage2D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
trace!("glCopyTexSubImage2D");
let p: *mut c_void = {
let temp_p = storage::CopyTexSubImage2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCopyTexSubImage2D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLint,
GLint,
GLint,
GLsizei,
GLsizei,
),
>(p)(target, level, xoffset, yoffset, x, y, width, height);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCopyTexSubImage2D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, yoffset, x, y, width, height, err);
}
}
out
}
#[inline]
pub unsafe fn glCopyTexSubImage3D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
trace!("glCopyTexSubImage3D");
let p: *mut c_void = {
let temp_p = storage::CopyTexSubImage3D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCopyTexSubImage3D not loaded");
}
temp_p
};
let out =
transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLint,
GLint,
GLint,
GLint,
GLsizei,
GLsizei,
),
>(p)(target, level, xoffset, yoffset, zoffset, x, y, width, height);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCopyTexSubImage3D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, yoffset, zoffset, x, y, width, height, err);
}
}
out
}
#[inline]
pub unsafe fn glCreateProgram() -> GLuint {
trace!("glCreateProgram");
let p: *mut c_void = {
let temp_p = storage::CreateProgram.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCreateProgram not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn() -> GLuint>(p)();
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCreateProgram(): {}", err);
}
}
out
}
#[inline]
pub unsafe fn glCreateShader(type_: GLenum) -> GLuint {
trace!("glCreateShader");
let p: *mut c_void = {
let temp_p = storage::CreateShader.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCreateShader not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLenum) -> GLuint>(p)(type_);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCreateShader({:?}): {}", type_, err);
}
}
out
}
#[inline]
pub unsafe fn glCullFace(mode: GLenum) {
trace!("glCullFace");
let p: *mut c_void = {
let temp_p = storage::CullFace.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glCullFace not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(mode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glCullFace({:?}): {}", mode, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteBuffers(n: GLsizei, buffers: *const GLuint) {
trace!("glDeleteBuffers");
let p: *mut c_void = {
let temp_p = storage::DeleteBuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteBuffers not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(n, buffers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteBuffers({:?}, {:?}): {}", n, buffers, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteFramebuffers(n: GLsizei, framebuffers: *const GLuint) {
trace!("glDeleteFramebuffers");
let p: *mut c_void = {
let temp_p = storage::DeleteFramebuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteFramebuffers not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(n, framebuffers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteFramebuffers({:?}, {:?}): {}", n, framebuffers, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteProgram(program: GLuint) {
trace!("glDeleteProgram");
let p: *mut c_void = {
let temp_p = storage::DeleteProgram.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteProgram not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(program);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteProgram({:?}): {}", program, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteQueries(n: GLsizei, ids: *const GLuint) {
trace!("glDeleteQueries");
let p: *mut c_void = {
let temp_p = storage::DeleteQueries.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteQueries not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(n, ids);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteQueries({:?}, {:?}): {}", n, ids, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteRenderbuffers(
n: GLsizei,
renderbuffers: *const GLuint,
) {
trace!("glDeleteRenderbuffers");
let p: *mut c_void = {
let temp_p = storage::DeleteRenderbuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteRenderbuffers not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(n, renderbuffers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteRenderbuffers({:?}, {:?}): {}", n, renderbuffers, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteSamplers(count: GLsizei, samplers: *const GLuint) {
trace!("glDeleteSamplers");
let p: *mut c_void = {
let temp_p = storage::DeleteSamplers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteSamplers not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(count, samplers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteSamplers({:?}, {:?}): {}", count, samplers, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteShader(shader: GLuint) {
trace!("glDeleteShader");
let p: *mut c_void = {
let temp_p = storage::DeleteShader.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteShader not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(shader);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteShader({:?}): {}", shader, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteSync(sync: GLsync) {
trace!("glDeleteSync");
let p: *mut c_void = {
let temp_p = storage::DeleteSync.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteSync not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsync)>(p)(sync);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteSync({:?}): {}", sync, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteTextures(n: GLsizei, textures: *const GLuint) {
trace!("glDeleteTextures");
let p: *mut c_void = {
let temp_p = storage::DeleteTextures.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteTextures not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(n, textures);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteTextures({:?}, {:?}): {}", n, textures, err);
}
}
out
}
#[inline]
pub unsafe fn glDeleteVertexArrays(n: GLsizei, arrays: *const GLuint) {
trace!("glDeleteVertexArrays");
let p: *mut c_void = {
let temp_p = storage::DeleteVertexArrays.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDeleteVertexArrays not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLuint),
>(p)(n, arrays);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDeleteVertexArrays({:?}, {:?}): {}", n, arrays, err);
}
}
out
}
#[inline]
pub unsafe fn glDepthFunc(func: GLenum) {
trace!("glDepthFunc");
let p: *mut c_void = {
let temp_p = storage::DepthFunc.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDepthFunc not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(func);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDepthFunc({:?}): {}", func, err);
}
}
out
}
#[inline]
pub unsafe fn glDepthMask(flag: GLboolean) {
trace!("glDepthMask");
let p: *mut c_void = {
let temp_p = storage::DepthMask.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDepthMask not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLboolean)>(p)(flag);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDepthMask({:?}): {}", flag, err);
}
}
out
}
#[inline]
pub unsafe fn glDepthRange(n: GLdouble, f: GLdouble) {
trace!("glDepthRange");
let p: *mut c_void = {
let temp_p = storage::DepthRange.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDepthRange not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLdouble, GLdouble)>(p)(n, f);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDepthRange({:?}, {:?}): {}", n, f, err);
}
}
out
}
#[inline]
pub unsafe fn glDetachShader(program: GLuint, shader: GLuint) {
trace!("glDetachShader");
let p: *mut c_void = {
let temp_p = storage::DetachShader.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDetachShader not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLuint)>(p)(
program, shader,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDetachShader({:?}, {:?}): {}", program, shader, err);
}
}
out
}
#[inline]
pub unsafe fn glDisable(cap: GLenum) {
trace!("glDisable");
let p: *mut c_void = {
let temp_p = storage::Disable.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDisable not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(cap);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDisable({:?}): {}", cap, err);
}
}
out
}
#[inline]
pub unsafe fn glDisableVertexAttribArray(index: GLuint) {
trace!("glDisableVertexAttribArray");
let p: *mut c_void = {
let temp_p = storage::DisableVertexAttribArray.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDisableVertexAttribArray not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(index);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDisableVertexAttribArray({:?}): {}", index, err);
}
}
out
}
#[inline]
pub unsafe fn glDisablei(target: GLenum, index: GLuint) {
trace!("glDisablei");
let p: *mut c_void = {
let temp_p = storage::Disablei.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDisablei not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target, index,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDisablei({:?}, {:?}): {}", target, index, err);
}
}
out
}
#[inline]
pub unsafe fn glDrawArrays(mode: GLenum, first: GLint, count: GLsizei) {
trace!("glDrawArrays");
let p: *mut c_void = {
let temp_p = storage::DrawArrays.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawArrays not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLsizei),
>(p)(mode, first, count);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDrawArrays({:?}, {:?}, {:?}): {}", mode, first, count, err);
}
}
out
}
#[inline]
pub unsafe fn glDrawArraysInstanced(
mode: GLenum,
first: GLint,
count: GLsizei,
instancecount: GLsizei,
) {
trace!("glDrawArraysInstanced");
let p: *mut c_void = {
let temp_p = storage::DrawArraysInstanced.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawArraysInstanced not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLsizei, GLsizei),
>(p)(mode, first, count, instancecount);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glDrawArraysInstanced({:?}, {:?}, {:?}, {:?}): {}",
mode, first, count, instancecount, err
);
}
}
out
}
#[inline]
pub unsafe fn glDrawBuffer(buf: GLenum) {
trace!("glDrawBuffer");
let p: *mut c_void = {
let temp_p = storage::DrawBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawBuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(buf);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDrawBuffer({:?}): {}", buf, err);
}
}
out
}
#[inline]
pub unsafe fn glDrawBuffers(n: GLsizei, bufs: *const GLenum) {
trace!("glDrawBuffers");
let p: *mut c_void = {
let temp_p = storage::DrawBuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawBuffers not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsizei, *const GLenum),
>(p)(n, bufs);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDrawBuffers({:?}, {:?}): {}", n, bufs, err);
}
}
out
}
#[inline]
pub unsafe fn glDrawElements(
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
) {
trace!("glDrawElements");
let p: *mut c_void = {
let temp_p = storage::DrawElements.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawElements not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLsizei, GLenum, *const c_void),
>(p)(mode, count, type_, indices);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glDrawElements({:?}, {:?}, {:?}, {:?}): {}",
mode, count, type_, indices, err
);
}
}
out
}
#[inline]
pub unsafe fn glDrawElementsBaseVertex(
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
basevertex: GLint,
) {
trace!("glDrawElementsBaseVertex");
let p: *mut c_void = {
let temp_p = storage::DrawElementsBaseVertex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawElementsBaseVertex not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLsizei, GLenum, *const c_void, GLint),
>(p)(mode, count, type_, indices, basevertex);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glDrawElementsBaseVertex({:?}, {:?}, {:?}, {:?}, {:?}): {}",
mode, count, type_, indices, basevertex, err
);
}
}
out
}
#[inline]
pub unsafe fn glDrawElementsInstanced(
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
instancecount: GLsizei,
) {
trace!("glDrawElementsInstanced");
let p: *mut c_void = {
let temp_p = storage::DrawElementsInstanced.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawElementsInstanced not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLsizei, GLenum, *const c_void, GLsizei),
>(p)(mode, count, type_, indices, instancecount);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glDrawElementsInstanced({:?}, {:?}, {:?}, {:?}, {:?}): {}",
mode, count, type_, indices, instancecount, err
);
}
}
out
}
#[inline]
pub unsafe fn glDrawElementsInstancedBaseVertex(
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
instancecount: GLsizei,
basevertex: GLint,
) {
trace!("glDrawElementsInstancedBaseVertex");
let p: *mut c_void = {
let temp_p =
storage::DrawElementsInstancedBaseVertex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawElementsInstancedBaseVertex not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLsizei,
GLenum,
*const c_void,
GLsizei,
GLint,
),
>(p)(mode, count, type_, indices, instancecount, basevertex);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDrawElementsInstancedBaseVertex({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", mode, count, type_, indices, instancecount, basevertex, err);
}
}
out
}
#[inline]
pub unsafe fn glDrawRangeElements(
mode: GLenum,
start: GLuint,
end: GLuint,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
) {
trace!("glDrawRangeElements");
let p: *mut c_void = {
let temp_p = storage::DrawRangeElements.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawRangeElements not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLuint,
GLuint,
GLsizei,
GLenum,
*const c_void,
),
>(p)(mode, start, end, count, type_, indices);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glDrawRangeElements({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
mode, start, end, count, type_, indices, err
);
}
}
out
}
#[inline]
pub unsafe fn glDrawRangeElementsBaseVertex(
mode: GLenum,
start: GLuint,
end: GLuint,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
basevertex: GLint,
) {
trace!("glDrawRangeElementsBaseVertex");
let p: *mut c_void = {
let temp_p = storage::DrawRangeElementsBaseVertex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glDrawRangeElementsBaseVertex not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLuint,
GLuint,
GLsizei,
GLenum,
*const c_void,
GLint,
),
>(p)(mode, start, end, count, type_, indices, basevertex);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glDrawRangeElementsBaseVertex({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", mode, start, end, count, type_, indices, basevertex, err);
}
}
out
}
#[inline]
pub unsafe fn glEnable(cap: GLenum) {
trace!("glEnable");
let p: *mut c_void = {
let temp_p = storage::Enable.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glEnable not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(cap);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glEnable({:?}): {}", cap, err);
}
}
out
}
#[inline]
pub unsafe fn glEnableVertexAttribArray(index: GLuint) {
trace!("glEnableVertexAttribArray");
let p: *mut c_void = {
let temp_p = storage::EnableVertexAttribArray.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glEnableVertexAttribArray not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(index);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glEnableVertexAttribArray({:?}): {}", index, err);
}
}
out
}
#[inline]
pub unsafe fn glEnablei(target: GLenum, index: GLuint) {
trace!("glEnablei");
let p: *mut c_void = {
let temp_p = storage::Enablei.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glEnablei not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
target, index,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glEnablei({:?}, {:?}): {}", target, index, err);
}
}
out
}
#[inline]
pub unsafe fn glEndConditionalRender() {
trace!("glEndConditionalRender");
let p: *mut c_void = {
let temp_p = storage::EndConditionalRender.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glEndConditionalRender not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn()>(p)();
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glEndConditionalRender(): {}", err);
}
}
out
}
#[inline]
pub unsafe fn glEndQuery(target: GLenum) {
trace!("glEndQuery");
let p: *mut c_void = {
let temp_p = storage::EndQuery.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glEndQuery not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(target);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glEndQuery({:?}): {}", target, err);
}
}
out
}
#[inline]
pub unsafe fn glEndTransformFeedback() {
trace!("glEndTransformFeedback");
let p: *mut c_void = {
let temp_p = storage::EndTransformFeedback.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glEndTransformFeedback not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn()>(p)();
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glEndTransformFeedback(): {}", err);
}
}
out
}
#[inline]
pub unsafe fn glFenceSync(condition: GLenum, flags: GLbitfield) -> GLsync {
trace!("glFenceSync");
let p: *mut c_void = {
let temp_p = storage::FenceSync.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFenceSync not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLbitfield) -> GLsync,
>(p)(condition, flags);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glFenceSync({:?}, {:?}): {}", condition, flags, err);
}
}
out
}
#[inline]
pub unsafe fn glFinish() {
trace!("glFinish");
let p: *mut c_void = {
let temp_p = storage::Finish.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFinish not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn()>(p)();
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glFinish(): {}", err);
}
}
out
}
#[inline]
pub unsafe fn glFlush() {
trace!("glFlush");
let p: *mut c_void = {
let temp_p = storage::Flush.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFlush not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn()>(p)();
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glFlush(): {}", err);
}
}
out
}
#[inline]
pub unsafe fn glFlushMappedBufferRange(
target: GLenum,
offset: GLintptr,
length: GLsizeiptr,
) {
trace!("glFlushMappedBufferRange");
let p: *mut c_void = {
let temp_p = storage::FlushMappedBufferRange.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFlushMappedBufferRange not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLintptr, GLsizeiptr),
>(p)(target, offset, length);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFlushMappedBufferRange({:?}, {:?}, {:?}): {}",
target, offset, length, err
);
}
}
out
}
#[inline]
pub unsafe fn glFramebufferRenderbuffer(
target: GLenum,
attachment: GLenum,
renderbuffertarget: GLenum,
renderbuffer: GLuint,
) {
trace!("glFramebufferRenderbuffer");
let p: *mut c_void = {
let temp_p = storage::FramebufferRenderbuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFramebufferRenderbuffer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, GLuint),
>(p)(target, attachment, renderbuffertarget, renderbuffer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFramebufferRenderbuffer({:?}, {:?}, {:?}, {:?}): {}",
target, attachment, renderbuffertarget, renderbuffer, err
);
}
}
out
}
#[inline]
pub unsafe fn glFramebufferTexture(
target: GLenum,
attachment: GLenum,
texture: GLuint,
level: GLint,
) {
trace!("glFramebufferTexture");
let p: *mut c_void = {
let temp_p = storage::FramebufferTexture.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFramebufferTexture not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint, GLint),
>(p)(target, attachment, texture, level);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFramebufferTexture({:?}, {:?}, {:?}, {:?}): {}",
target, attachment, texture, level, err
);
}
}
out
}
#[inline]
pub unsafe fn glFramebufferTexture1D(
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint,
) {
trace!("glFramebufferTexture1D");
let p: *mut c_void = {
let temp_p = storage::FramebufferTexture1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFramebufferTexture1D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, GLuint, GLint),
>(p)(target, attachment, textarget, texture, level);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFramebufferTexture1D({:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, attachment, textarget, texture, level, err
);
}
}
out
}
#[inline]
pub unsafe fn glFramebufferTexture2D(
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint,
) {
trace!("glFramebufferTexture2D");
let p: *mut c_void = {
let temp_p = storage::FramebufferTexture2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFramebufferTexture2D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, GLuint, GLint),
>(p)(target, attachment, textarget, texture, level);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFramebufferTexture2D({:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, attachment, textarget, texture, level, err
);
}
}
out
}
#[inline]
pub unsafe fn glFramebufferTexture3D(
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint,
zoffset: GLint,
) {
trace!("glFramebufferTexture3D");
let p: *mut c_void = {
let temp_p = storage::FramebufferTexture3D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFramebufferTexture3D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, GLuint, GLint, GLint),
>(p)(target, attachment, textarget, texture, level, zoffset);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFramebufferTexture3D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, attachment, textarget, texture, level, zoffset, err
);
}
}
out
}
#[inline]
pub unsafe fn glFramebufferTextureLayer(
target: GLenum,
attachment: GLenum,
texture: GLuint,
level: GLint,
layer: GLint,
) {
trace!("glFramebufferTextureLayer");
let p: *mut c_void = {
let temp_p = storage::FramebufferTextureLayer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFramebufferTextureLayer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint, GLint, GLint),
>(p)(target, attachment, texture, level, layer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glFramebufferTextureLayer({:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, attachment, texture, level, layer, err
);
}
}
out
}
#[inline]
pub unsafe fn glFrontFace(mode: GLenum) {
trace!("glFrontFace");
let p: *mut c_void = {
let temp_p = storage::FrontFace.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glFrontFace not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(mode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glFrontFace({:?}): {}", mode, err);
}
}
out
}
#[inline]
pub unsafe fn glGenBuffers(n: GLsizei, buffers: *mut GLuint) {
trace!("glGenBuffers");
let p: *mut c_void = {
let temp_p = storage::GenBuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenBuffers not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(n, buffers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenBuffers({:?}, {:?}): {}", n, buffers, err);
}
}
out
}
#[inline]
pub unsafe fn glGenFramebuffers(n: GLsizei, framebuffers: *mut GLuint) {
trace!("glGenFramebuffers");
let p: *mut c_void = {
let temp_p = storage::GenFramebuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenFramebuffers not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(n, framebuffers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenFramebuffers({:?}, {:?}): {}", n, framebuffers, err);
}
}
out
}
#[inline]
pub unsafe fn glGenQueries(n: GLsizei, ids: *mut GLuint) {
trace!("glGenQueries");
let p: *mut c_void = {
let temp_p = storage::GenQueries.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenQueries not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(n, ids);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenQueries({:?}, {:?}): {}", n, ids, err);
}
}
out
}
#[inline]
pub unsafe fn glGenRenderbuffers(n: GLsizei, renderbuffers: *mut GLuint) {
trace!("glGenRenderbuffers");
let p: *mut c_void = {
let temp_p = storage::GenRenderbuffers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenRenderbuffers not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(n, renderbuffers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenRenderbuffers({:?}, {:?}): {}", n, renderbuffers, err);
}
}
out
}
#[inline]
pub unsafe fn glGenSamplers(count: GLsizei, samplers: *mut GLuint) {
trace!("glGenSamplers");
let p: *mut c_void = {
let temp_p = storage::GenSamplers.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenSamplers not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(count, samplers);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenSamplers({:?}, {:?}): {}", count, samplers, err);
}
}
out
}
#[inline]
pub unsafe fn glGenTextures(n: GLsizei, textures: *mut GLuint) {
trace!("glGenTextures");
let p: *mut c_void = {
let temp_p = storage::GenTextures.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenTextures not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(n, textures);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenTextures({:?}, {:?}): {}", n, textures, err);
}
}
out
}
#[inline]
pub unsafe fn glGenVertexArrays(n: GLsizei, arrays: *mut GLuint) {
trace!("glGenVertexArrays");
let p: *mut c_void = {
let temp_p = storage::GenVertexArrays.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenVertexArrays not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsizei, *mut GLuint)>(
p,
)(n, arrays);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenVertexArrays({:?}, {:?}): {}", n, arrays, err);
}
}
out
}
#[inline]
pub unsafe fn glGenerateMipmap(target: GLenum) {
trace!("glGenerateMipmap");
let p: *mut c_void = {
let temp_p = storage::GenerateMipmap.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGenerateMipmap not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(target);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGenerateMipmap({:?}): {}", target, err);
}
}
out
}
#[inline]
pub unsafe fn glGetActiveAttrib(
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLint,
type_: *mut GLenum,
name: *mut GLchar,
) {
trace!("glGetActiveAttrib");
let p: *mut c_void = {
let temp_p = storage::GetActiveAttrib.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetActiveAttrib not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLuint,
GLuint,
GLsizei,
*mut GLsizei,
*mut GLint,
*mut GLenum,
*mut GLchar,
),
>(p)(program, index, bufSize, length, size, type_, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetActiveAttrib({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
program, index, bufSize, length, size, type_, name, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetActiveUniform(
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLint,
type_: *mut GLenum,
name: *mut GLchar,
) {
trace!("glGetActiveUniform");
let p: *mut c_void = {
let temp_p = storage::GetActiveUniform.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetActiveUniform not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLuint,
GLuint,
GLsizei,
*mut GLsizei,
*mut GLint,
*mut GLenum,
*mut GLchar,
),
>(p)(program, index, bufSize, length, size, type_, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetActiveUniform({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
program, index, bufSize, length, size, type_, name, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetActiveUniformBlockName(
program: GLuint,
uniformBlockIndex: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
uniformBlockName: *mut GLchar,
) {
trace!("glGetActiveUniformBlockName");
let p: *mut c_void = {
let temp_p = storage::GetActiveUniformBlockName.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetActiveUniformBlockName not loaded");
}
temp_p
};
let out =
transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLsizei, *mut GLsizei, *mut GLchar),
>(p)(program, uniformBlockIndex, bufSize, length, uniformBlockName);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetActiveUniformBlockName({:?}, {:?}, {:?}, {:?}, {:?}): {}",
program, uniformBlockIndex, bufSize, length, uniformBlockName, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetActiveUniformBlockiv(
program: GLuint,
uniformBlockIndex: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetActiveUniformBlockiv");
let p: *mut c_void = {
let temp_p = storage::GetActiveUniformBlockiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetActiveUniformBlockiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLenum, *mut GLint),
>(p)(program, uniformBlockIndex, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetActiveUniformBlockiv({:?}, {:?}, {:?}, {:?}): {}",
program, uniformBlockIndex, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetActiveUniformName(
program: GLuint,
uniformIndex: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
uniformName: *mut GLchar,
) {
trace!("glGetActiveUniformName");
let p: *mut c_void = {
let temp_p = storage::GetActiveUniformName.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetActiveUniformName not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLsizei, *mut GLsizei, *mut GLchar),
>(p)(program, uniformIndex, bufSize, length, uniformName);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetActiveUniformName({:?}, {:?}, {:?}, {:?}, {:?}): {}",
program, uniformIndex, bufSize, length, uniformName, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetActiveUniformsiv(
program: GLuint,
uniformCount: GLsizei,
uniformIndices: *const GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetActiveUniformsiv");
let p: *mut c_void = {
let temp_p = storage::GetActiveUniformsiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetActiveUniformsiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *const GLuint, GLenum, *mut GLint),
>(p)(program, uniformCount, uniformIndices, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetActiveUniformsiv({:?}, {:?}, {:?}, {:?}, {:?}): {}",
program, uniformCount, uniformIndices, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetAttachedShaders(
program: GLuint,
maxCount: GLsizei,
count: *mut GLsizei,
shaders: *mut GLuint,
) {
trace!("glGetAttachedShaders");
let p: *mut c_void = {
let temp_p = storage::GetAttachedShaders.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetAttachedShaders not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *mut GLsizei, *mut GLuint),
>(p)(program, maxCount, count, shaders);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetAttachedShaders({:?}, {:?}, {:?}, {:?}): {}",
program, maxCount, count, shaders, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetAttribLocation(
program: GLuint,
name: *const GLchar,
) -> GLint {
trace!("glGetAttribLocation");
let p: *mut c_void = {
let temp_p = storage::GetAttribLocation.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetAttribLocation not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLchar) -> GLint,
>(p)(program, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetAttribLocation({:?}, {:?}): {}", program, name, err);
}
}
out
}
#[inline]
pub unsafe fn glGetBooleani_v(
target: GLenum,
index: GLuint,
data: *mut GLboolean,
) {
trace!("glGetBooleani_v");
let p: *mut c_void = {
let temp_p = storage::GetBooleani_v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetBooleani_v not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint, *mut GLboolean),
>(p)(target, index, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetBooleani_v({:?}, {:?}, {:?}): {}",
target, index, data, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetBooleanv(pname: GLenum, data: *mut GLboolean) {
trace!("glGetBooleanv");
let p: *mut c_void = {
let temp_p = storage::GetBooleanv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetBooleanv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, *mut GLboolean),
>(p)(pname, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetBooleanv({:?}, {:?}): {}", pname, data, err);
}
}
out
}
#[inline]
pub unsafe fn glGetBufferParameteri64v(
target: GLenum,
pname: GLenum,
params: *mut GLint64,
) {
trace!("glGetBufferParameteri64v");
let p: *mut c_void = {
let temp_p = storage::GetBufferParameteri64v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetBufferParameteri64v not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLint64),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetBufferParameteri64v({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetBufferParameteriv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetBufferParameteriv");
let p: *mut c_void = {
let temp_p = storage::GetBufferParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetBufferParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetBufferParameteriv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetBufferPointerv(
target: GLenum,
pname: GLenum,
params: *const *mut c_void,
) {
trace!("glGetBufferPointerv");
let p: *mut c_void = {
let temp_p = storage::GetBufferPointerv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetBufferPointerv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const *mut c_void),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetBufferPointerv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetBufferSubData(
target: GLenum,
offset: GLintptr,
size: GLsizeiptr,
data: *mut c_void,
) {
trace!("glGetBufferSubData");
let p: *mut c_void = {
let temp_p = storage::GetBufferSubData.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetBufferSubData not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLintptr, GLsizeiptr, *mut c_void),
>(p)(target, offset, size, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetBufferSubData({:?}, {:?}, {:?}, {:?}): {}",
target, offset, size, data, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetCompressedTexImage(
target: GLenum,
level: GLint,
img: *mut c_void,
) {
trace!("glGetCompressedTexImage");
let p: *mut c_void = {
let temp_p = storage::GetCompressedTexImage.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetCompressedTexImage not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, *mut c_void),
>(p)(target, level, img);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetCompressedTexImage({:?}, {:?}, {:?}): {}",
target, level, img, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetDoublev(pname: GLenum, data: *mut GLdouble) {
trace!("glGetDoublev");
let p: *mut c_void = {
let temp_p = storage::GetDoublev.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetDoublev not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *mut GLdouble)>(
p,
)(pname, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetDoublev({:?}, {:?}): {}", pname, data, err);
}
}
out
}
#[inline]
pub unsafe fn glGetError() -> GLenum {
trace!("glGetError");
let p: *mut c_void = {
let temp_p = storage::GetError.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetError not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn() -> GLenum>(p)();
out
}
#[inline]
pub unsafe fn glGetFloatv(pname: GLenum, data: *mut GLfloat) {
trace!("glGetFloatv");
let p: *mut c_void = {
let temp_p = storage::GetFloatv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetFloatv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *mut GLfloat)>(
p,
)(pname, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetFloatv({:?}, {:?}): {}", pname, data, err);
}
}
out
}
#[inline]
pub unsafe fn glGetFragDataIndex(
program: GLuint,
name: *const GLchar,
) -> GLint {
trace!("glGetFragDataIndex");
let p: *mut c_void = {
let temp_p = storage::GetFragDataIndex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetFragDataIndex not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLchar) -> GLint,
>(p)(program, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetFragDataIndex({:?}, {:?}): {}", program, name, err);
}
}
out
}
#[inline]
pub unsafe fn glGetFragDataLocation(
program: GLuint,
name: *const GLchar,
) -> GLint {
trace!("glGetFragDataLocation");
let p: *mut c_void = {
let temp_p = storage::GetFragDataLocation.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetFragDataLocation not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLchar) -> GLint,
>(p)(program, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetFragDataLocation({:?}, {:?}): {}", program, name, err);
}
}
out
}
#[inline]
pub unsafe fn glGetFramebufferAttachmentParameteriv(
target: GLenum,
attachment: GLenum,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetFramebufferAttachmentParameteriv");
let p: *mut c_void = {
let temp_p =
storage::GetFramebufferAttachmentParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetFramebufferAttachmentParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, *mut GLint),
>(p)(target, attachment, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetFramebufferAttachmentParameteriv({:?}, {:?}, {:?}, {:?}): {}",
target, attachment, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetInteger64i_v(
target: GLenum,
index: GLuint,
data: *mut GLint64,
) {
trace!("glGetInteger64i_v");
let p: *mut c_void = {
let temp_p = storage::GetInteger64i_v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetInteger64i_v not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint, *mut GLint64),
>(p)(target, index, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetInteger64i_v({:?}, {:?}, {:?}): {}",
target, index, data, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetInteger64v(pname: GLenum, data: *mut GLint64) {
trace!("glGetInteger64v");
let p: *mut c_void = {
let temp_p = storage::GetInteger64v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetInteger64v not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *mut GLint64)>(
p,
)(pname, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetInteger64v({:?}, {:?}): {}", pname, data, err);
}
}
out
}
#[inline]
pub unsafe fn glGetIntegeri_v(
target: GLenum,
index: GLuint,
data: *mut GLint,
) {
trace!("glGetIntegeri_v");
let p: *mut c_void = {
let temp_p = storage::GetIntegeri_v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetIntegeri_v not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint, *mut GLint),
>(p)(target, index, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetIntegeri_v({:?}, {:?}, {:?}): {}",
target, index, data, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetIntegerv(pname: GLenum, data: *mut GLint) {
trace!("glGetIntegerv");
let p: *mut c_void = {
let temp_p = storage::GetIntegerv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetIntegerv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *mut GLint)>(
p,
)(pname, data);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetIntegerv({:?}, {:?}): {}", pname, data, err);
}
}
out
}
#[inline]
pub unsafe fn glGetMultisamplefv(
pname: GLenum,
index: GLuint,
val: *mut GLfloat,
) {
trace!("glGetMultisamplefv");
let p: *mut c_void = {
let temp_p = storage::GetMultisamplefv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetMultisamplefv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint, *mut GLfloat),
>(p)(pname, index, val);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetMultisamplefv({:?}, {:?}, {:?}): {}",
pname, index, val, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetProgramInfoLog(
program: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
infoLog: *mut GLchar,
) {
trace!("glGetProgramInfoLog");
let p: *mut c_void = {
let temp_p = storage::GetProgramInfoLog.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetProgramInfoLog not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *mut GLsizei, *mut GLchar),
>(p)(program, bufSize, length, infoLog);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetProgramInfoLog({:?}, {:?}, {:?}, {:?}): {}",
program, bufSize, length, infoLog, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetProgramiv(
program: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetProgramiv");
let p: *mut c_void = {
let temp_p = storage::GetProgramiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetProgramiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(program, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetProgramiv({:?}, {:?}, {:?}): {}",
program, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetQueryObjecti64v(
id: GLuint,
pname: GLenum,
params: *mut GLint64,
) {
trace!("glGetQueryObjecti64v");
let p: *mut c_void = {
let temp_p = storage::GetQueryObjecti64v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetQueryObjecti64v not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint64),
>(p)(id, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetQueryObjecti64v({:?}, {:?}, {:?}): {}",
id, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetQueryObjectiv(
id: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetQueryObjectiv");
let p: *mut c_void = {
let temp_p = storage::GetQueryObjectiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetQueryObjectiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(id, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetQueryObjectiv({:?}, {:?}, {:?}): {}",
id, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetQueryObjectui64v(
id: GLuint,
pname: GLenum,
params: *mut GLuint64,
) {
trace!("glGetQueryObjectui64v");
let p: *mut c_void = {
let temp_p = storage::GetQueryObjectui64v.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetQueryObjectui64v not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLuint64),
>(p)(id, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetQueryObjectui64v({:?}, {:?}, {:?}): {}",
id, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetQueryObjectuiv(
id: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
trace!("glGetQueryObjectuiv");
let p: *mut c_void = {
let temp_p = storage::GetQueryObjectuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetQueryObjectuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLuint),
>(p)(id, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetQueryObjectuiv({:?}, {:?}, {:?}): {}",
id, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetQueryiv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetQueryiv");
let p: *mut c_void = {
let temp_p = storage::GetQueryiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetQueryiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetQueryiv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetRenderbufferParameteriv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetRenderbufferParameteriv");
let p: *mut c_void = {
let temp_p = storage::GetRenderbufferParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetRenderbufferParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetRenderbufferParameteriv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetSamplerParameterIiv(
sampler: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetSamplerParameterIiv");
let p: *mut c_void = {
let temp_p = storage::GetSamplerParameterIiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetSamplerParameterIiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(sampler, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetSamplerParameterIiv({:?}, {:?}, {:?}): {}",
sampler, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetSamplerParameterIuiv(
sampler: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
trace!("glGetSamplerParameterIuiv");
let p: *mut c_void = {
let temp_p = storage::GetSamplerParameterIuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetSamplerParameterIuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLuint),
>(p)(sampler, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetSamplerParameterIuiv({:?}, {:?}, {:?}): {}",
sampler, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetSamplerParameterfv(
sampler: GLuint,
pname: GLenum,
params: *mut GLfloat,
) {
trace!("glGetSamplerParameterfv");
let p: *mut c_void = {
let temp_p = storage::GetSamplerParameterfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetSamplerParameterfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLfloat),
>(p)(sampler, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetSamplerParameterfv({:?}, {:?}, {:?}): {}",
sampler, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetSamplerParameteriv(
sampler: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetSamplerParameteriv");
let p: *mut c_void = {
let temp_p = storage::GetSamplerParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetSamplerParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(sampler, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetSamplerParameteriv({:?}, {:?}, {:?}): {}",
sampler, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetShaderInfoLog(
shader: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
infoLog: *mut GLchar,
) {
trace!("glGetShaderInfoLog");
let p: *mut c_void = {
let temp_p = storage::GetShaderInfoLog.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetShaderInfoLog not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *mut GLsizei, *mut GLchar),
>(p)(shader, bufSize, length, infoLog);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetShaderInfoLog({:?}, {:?}, {:?}, {:?}): {}",
shader, bufSize, length, infoLog, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetShaderSource(
shader: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
source: *mut GLchar,
) {
trace!("glGetShaderSource");
let p: *mut c_void = {
let temp_p = storage::GetShaderSource.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetShaderSource not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *mut GLsizei, *mut GLchar),
>(p)(shader, bufSize, length, source);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetShaderSource({:?}, {:?}, {:?}, {:?}): {}",
shader, bufSize, length, source, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetShaderiv(
shader: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetShaderiv");
let p: *mut c_void = {
let temp_p = storage::GetShaderiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetShaderiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(shader, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetShaderiv({:?}, {:?}, {:?}): {}",
shader, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetString(name: GLenum) -> *const GLubyte {
trace!("glGetString");
let p: *mut c_void = {
let temp_p = storage::GetString.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetString not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum) -> *const GLubyte,
>(p)(name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetString({:?}): {}", name, err);
}
}
out
}
#[inline]
pub unsafe fn glGetStringi(name: GLenum, index: GLuint) -> *const GLubyte {
trace!("glGetStringi");
let p: *mut c_void = {
let temp_p = storage::GetStringi.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetStringi not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint) -> *const GLubyte,
>(p)(name, index);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetStringi({:?}, {:?}): {}", name, index, err);
}
}
out
}
#[inline]
pub unsafe fn glGetSynciv(
sync: GLsync,
pname: GLenum,
bufSize: GLsizei,
length: *mut GLsizei,
values: *mut GLint,
) {
trace!("glGetSynciv");
let p: *mut c_void = {
let temp_p = storage::GetSynciv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetSynciv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsync, GLenum, GLsizei, *mut GLsizei, *mut GLint),
>(p)(sync, pname, bufSize, length, values);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetSynciv({:?}, {:?}, {:?}, {:?}, {:?}): {}",
sync, pname, bufSize, length, values, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexImage(
target: GLenum,
level: GLint,
format: GLenum,
type_: GLenum,
pixels: *mut c_void,
) {
trace!("glGetTexImage");
let p: *mut c_void = {
let temp_p = storage::GetTexImage.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexImage not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLenum, GLenum, *mut c_void),
>(p)(target, level, format, type_, pixels);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexImage({:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, level, format, type_, pixels, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexLevelParameterfv(
target: GLenum,
level: GLint,
pname: GLenum,
params: *mut GLfloat,
) {
trace!("glGetTexLevelParameterfv");
let p: *mut c_void = {
let temp_p = storage::GetTexLevelParameterfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexLevelParameterfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLenum, *mut GLfloat),
>(p)(target, level, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexLevelParameterfv({:?}, {:?}, {:?}, {:?}): {}",
target, level, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexLevelParameteriv(
target: GLenum,
level: GLint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetTexLevelParameteriv");
let p: *mut c_void = {
let temp_p = storage::GetTexLevelParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexLevelParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLint, GLenum, *mut GLint),
>(p)(target, level, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexLevelParameteriv({:?}, {:?}, {:?}, {:?}): {}",
target, level, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexParameterIiv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetTexParameterIiv");
let p: *mut c_void = {
let temp_p = storage::GetTexParameterIiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexParameterIiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexParameterIiv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexParameterIuiv(
target: GLenum,
pname: GLenum,
params: *mut GLuint,
) {
trace!("glGetTexParameterIuiv");
let p: *mut c_void = {
let temp_p = storage::GetTexParameterIuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexParameterIuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLuint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexParameterIuiv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexParameterfv(
target: GLenum,
pname: GLenum,
params: *mut GLfloat,
) {
trace!("glGetTexParameterfv");
let p: *mut c_void = {
let temp_p = storage::GetTexParameterfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexParameterfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLfloat),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexParameterfv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTexParameteriv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetTexParameteriv");
let p: *mut c_void = {
let temp_p = storage::GetTexParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTexParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *mut GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetTexParameteriv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetTransformFeedbackVarying(
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLsizei,
type_: *mut GLenum,
name: *mut GLchar,
) {
trace!("glGetTransformFeedbackVarying");
let p: *mut c_void = {
let temp_p = storage::GetTransformFeedbackVarying.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetTransformFeedbackVarying not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLuint,
GLuint,
GLsizei,
*mut GLsizei,
*mut GLsizei,
*mut GLenum,
*mut GLchar,
),
>(p)(program, index, bufSize, length, size, type_, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetTransformFeedbackVarying({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", program, index, bufSize, length, size, type_, name, err);
}
}
out
}
#[inline]
pub unsafe fn glGetUniformBlockIndex(
program: GLuint,
uniformBlockName: *const GLchar,
) -> GLuint {
trace!("glGetUniformBlockIndex");
let p: *mut c_void = {
let temp_p = storage::GetUniformBlockIndex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetUniformBlockIndex not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLchar) -> GLuint,
>(p)(program, uniformBlockName);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetUniformBlockIndex({:?}, {:?}): {}",
program, uniformBlockName, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetUniformIndices(
program: GLuint,
uniformCount: GLsizei,
uniformNames: *const *const GLchar,
uniformIndices: *mut GLuint,
) {
trace!("glGetUniformIndices");
let p: *mut c_void = {
let temp_p = storage::GetUniformIndices.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetUniformIndices not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *const *const GLchar, *mut GLuint),
>(p)(program, uniformCount, uniformNames, uniformIndices);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetUniformIndices({:?}, {:?}, {:?}, {:?}): {}",
program, uniformCount, uniformNames, uniformIndices, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetUniformLocation(
program: GLuint,
name: *const GLchar,
) -> GLint {
trace!("glGetUniformLocation");
let p: *mut c_void = {
let temp_p = storage::GetUniformLocation.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetUniformLocation not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLchar) -> GLint,
>(p)(program, name);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glGetUniformLocation({:?}, {:?}): {}", program, name, err);
}
}
out
}
#[inline]
pub unsafe fn glGetUniformfv(
program: GLuint,
location: GLint,
params: *mut GLfloat,
) {
trace!("glGetUniformfv");
let p: *mut c_void = {
let temp_p = storage::GetUniformfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetUniformfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLint, *mut GLfloat),
>(p)(program, location, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetUniformfv({:?}, {:?}, {:?}): {}",
program, location, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetUniformiv(
program: GLuint,
location: GLint,
params: *mut GLint,
) {
trace!("glGetUniformiv");
let p: *mut c_void = {
let temp_p = storage::GetUniformiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetUniformiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLint, *mut GLint),
>(p)(program, location, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetUniformiv({:?}, {:?}, {:?}): {}",
program, location, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetUniformuiv(
program: GLuint,
location: GLint,
params: *mut GLuint,
) {
trace!("glGetUniformuiv");
let p: *mut c_void = {
let temp_p = storage::GetUniformuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetUniformuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLint, *mut GLuint),
>(p)(program, location, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetUniformuiv({:?}, {:?}, {:?}): {}",
program, location, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetVertexAttribIiv(
index: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetVertexAttribIiv");
let p: *mut c_void = {
let temp_p = storage::GetVertexAttribIiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetVertexAttribIiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(index, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetVertexAttribIiv({:?}, {:?}, {:?}): {}",
index, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetVertexAttribIuiv(
index: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
trace!("glGetVertexAttribIuiv");
let p: *mut c_void = {
let temp_p = storage::GetVertexAttribIuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetVertexAttribIuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLuint),
>(p)(index, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetVertexAttribIuiv({:?}, {:?}, {:?}): {}",
index, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetVertexAttribPointerv(
index: GLuint,
pname: GLenum,
pointer: *const *mut c_void,
) {
trace!("glGetVertexAttribPointerv");
let p: *mut c_void = {
let temp_p = storage::GetVertexAttribPointerv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetVertexAttribPointerv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *const *mut c_void),
>(p)(index, pname, pointer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetVertexAttribPointerv({:?}, {:?}, {:?}): {}",
index, pname, pointer, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetVertexAttribdv(
index: GLuint,
pname: GLenum,
params: *mut GLdouble,
) {
trace!("glGetVertexAttribdv");
let p: *mut c_void = {
let temp_p = storage::GetVertexAttribdv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetVertexAttribdv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLdouble),
>(p)(index, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetVertexAttribdv({:?}, {:?}, {:?}): {}",
index, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetVertexAttribfv(
index: GLuint,
pname: GLenum,
params: *mut GLfloat,
) {
trace!("glGetVertexAttribfv");
let p: *mut c_void = {
let temp_p = storage::GetVertexAttribfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetVertexAttribfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLfloat),
>(p)(index, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetVertexAttribfv({:?}, {:?}, {:?}): {}",
index, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glGetVertexAttribiv(
index: GLuint,
pname: GLenum,
params: *mut GLint,
) {
trace!("glGetVertexAttribiv");
let p: *mut c_void = {
let temp_p = storage::GetVertexAttribiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glGetVertexAttribiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *mut GLint),
>(p)(index, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glGetVertexAttribiv({:?}, {:?}, {:?}): {}",
index, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glHint(target: GLenum, mode: GLenum) {
trace!("glHint");
let p: *mut c_void = {
let temp_p = storage::Hint.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glHint not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLenum)>(p)(
target, mode,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glHint({:?}, {:?}): {}", target, mode, err);
}
}
out
}
#[inline]
pub unsafe fn glIsBuffer(buffer: GLuint) -> GLboolean {
trace!("glIsBuffer");
let p: *mut c_void = {
let temp_p = storage::IsBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsBuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(buffer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsBuffer({:?}): {}", buffer, err);
}
}
out
}
#[inline]
pub unsafe fn glIsEnabled(cap: GLenum) -> GLboolean {
trace!("glIsEnabled");
let p: *mut c_void = {
let temp_p = storage::IsEnabled.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsEnabled not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLenum) -> GLboolean>(p)(cap);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsEnabled({:?}): {}", cap, err);
}
}
out
}
#[inline]
pub unsafe fn glIsEnabledi(target: GLenum, index: GLuint) -> GLboolean {
trace!("glIsEnabledi");
let p: *mut c_void = {
let temp_p = storage::IsEnabledi.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsEnabledi not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLuint) -> GLboolean,
>(p)(target, index);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsEnabledi({:?}, {:?}): {}", target, index, err);
}
}
out
}
#[inline]
pub unsafe fn glIsFramebuffer(framebuffer: GLuint) -> GLboolean {
trace!("glIsFramebuffer");
let p: *mut c_void = {
let temp_p = storage::IsFramebuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsFramebuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(framebuffer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsFramebuffer({:?}): {}", framebuffer, err);
}
}
out
}
#[inline]
pub unsafe fn glIsProgram(program: GLuint) -> GLboolean {
trace!("glIsProgram");
let p: *mut c_void = {
let temp_p = storage::IsProgram.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsProgram not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(program);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsProgram({:?}): {}", program, err);
}
}
out
}
#[inline]
pub unsafe fn glIsQuery(id: GLuint) -> GLboolean {
trace!("glIsQuery");
let p: *mut c_void = {
let temp_p = storage::IsQuery.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsQuery not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(p)(id);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsQuery({:?}): {}", id, err);
}
}
out
}
#[inline]
pub unsafe fn glIsRenderbuffer(renderbuffer: GLuint) -> GLboolean {
trace!("glIsRenderbuffer");
let p: *mut c_void = {
let temp_p = storage::IsRenderbuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsRenderbuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(renderbuffer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsRenderbuffer({:?}): {}", renderbuffer, err);
}
}
out
}
#[inline]
pub unsafe fn glIsSampler(sampler: GLuint) -> GLboolean {
trace!("glIsSampler");
let p: *mut c_void = {
let temp_p = storage::IsSampler.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsSampler not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(sampler);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsSampler({:?}): {}", sampler, err);
}
}
out
}
#[inline]
pub unsafe fn glIsShader(shader: GLuint) -> GLboolean {
trace!("glIsShader");
let p: *mut c_void = {
let temp_p = storage::IsShader.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsShader not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(shader);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsShader({:?}): {}", shader, err);
}
}
out
}
#[inline]
pub unsafe fn glIsSync(sync: GLsync) -> GLboolean {
trace!("glIsSync");
let p: *mut c_void = {
let temp_p = storage::IsSync.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsSync not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLsync) -> GLboolean>(
p,
)(sync);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsSync({:?}): {}", sync, err);
}
}
out
}
#[inline]
pub unsafe fn glIsTexture(texture: GLuint) -> GLboolean {
trace!("glIsTexture");
let p: *mut c_void = {
let temp_p = storage::IsTexture.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsTexture not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(texture);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsTexture({:?}): {}", texture, err);
}
}
out
}
#[inline]
pub unsafe fn glIsVertexArray(array: GLuint) -> GLboolean {
trace!("glIsVertexArray");
let p: *mut c_void = {
let temp_p = storage::IsVertexArray.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glIsVertexArray not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint) -> GLboolean>(
p,
)(array);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glIsVertexArray({:?}): {}", array, err);
}
}
out
}
#[inline]
pub unsafe fn glLineWidth(width: GLfloat) {
trace!("glLineWidth");
let p: *mut c_void = {
let temp_p = storage::LineWidth.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glLineWidth not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLfloat)>(p)(width);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glLineWidth({:?}): {}", width, err);
}
}
out
}
#[inline]
pub unsafe fn glLinkProgram(program: GLuint) {
trace!("glLinkProgram");
let p: *mut c_void = {
let temp_p = storage::LinkProgram.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glLinkProgram not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(program);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glLinkProgram({:?}): {}", program, err);
}
}
out
}
#[inline]
pub unsafe fn glLogicOp(opcode: GLenum) {
trace!("glLogicOp");
let p: *mut c_void = {
let temp_p = storage::LogicOp.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glLogicOp not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(opcode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glLogicOp({:?}): {}", opcode, err);
}
}
out
}
#[inline]
pub unsafe fn glMapBuffer(target: GLenum, access: GLenum) -> *mut c_void {
trace!("glMapBuffer");
let p: *mut c_void = {
let temp_p = storage::MapBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMapBuffer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum) -> *mut c_void,
>(p)(target, access);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glMapBuffer({:?}, {:?}): {}", target, access, err);
}
}
out
}
#[inline]
pub unsafe fn glMapBufferRange(
target: GLenum,
offset: GLintptr,
length: GLsizeiptr,
access: GLbitfield,
) -> *mut c_void {
trace!("glMapBufferRange");
let p: *mut c_void = {
let temp_p = storage::MapBufferRange.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMapBufferRange not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLintptr,
GLsizeiptr,
GLbitfield,
) -> *mut c_void,
>(p)(target, offset, length, access);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMapBufferRange({:?}, {:?}, {:?}, {:?}): {}",
target, offset, length, access, err
);
}
}
out
}
#[inline]
pub unsafe fn glMultiDrawArrays(
mode: GLenum,
first: *const GLint,
count: *const GLsizei,
drawcount: GLsizei,
) {
trace!("glMultiDrawArrays");
let p: *mut c_void = {
let temp_p = storage::MultiDrawArrays.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiDrawArrays not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, *const GLint, *const GLsizei, GLsizei),
>(p)(mode, first, count, drawcount);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiDrawArrays({:?}, {:?}, {:?}, {:?}): {}",
mode, first, count, drawcount, err
);
}
}
out
}
#[inline]
pub unsafe fn glMultiDrawElements(
mode: GLenum,
count: *const GLsizei,
type_: GLenum,
indices: *const *const c_void,
drawcount: GLsizei,
) {
trace!("glMultiDrawElements");
let p: *mut c_void = {
let temp_p = storage::MultiDrawElements.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiDrawElements not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
*const GLsizei,
GLenum,
*const *const c_void,
GLsizei,
),
>(p)(mode, count, type_, indices, drawcount);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiDrawElements({:?}, {:?}, {:?}, {:?}, {:?}): {}",
mode, count, type_, indices, drawcount, err
);
}
}
out
}
#[inline]
pub unsafe fn glMultiDrawElementsBaseVertex(
mode: GLenum,
count: *const GLsizei,
type_: GLenum,
indices: *const *const c_void,
drawcount: GLsizei,
basevertex: *const GLint,
) {
trace!("glMultiDrawElementsBaseVertex");
let p: *mut c_void = {
let temp_p = storage::MultiDrawElementsBaseVertex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiDrawElementsBaseVertex not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
*const GLsizei,
GLenum,
*const *const c_void,
GLsizei,
*const GLint,
),
>(p)(mode, count, type_, indices, drawcount, basevertex);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glMultiDrawElementsBaseVertex({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
mode, count, type_, indices, drawcount, basevertex, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP1ui(
texture: GLenum,
type_: GLenum,
coords: GLuint,
) {
trace!("glMultiTexCoordP1ui");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP1ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP1ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP1ui({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP1uiv(
texture: GLenum,
type_: GLenum,
coords: *const GLuint,
) {
trace!("glMultiTexCoordP1uiv");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP1uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP1uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP1uiv({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP2ui(
texture: GLenum,
type_: GLenum,
coords: GLuint,
) {
trace!("glMultiTexCoordP2ui");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP2ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP2ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP2ui({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP2uiv(
texture: GLenum,
type_: GLenum,
coords: *const GLuint,
) {
trace!("glMultiTexCoordP2uiv");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP2uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP2uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP2uiv({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP3ui(
texture: GLenum,
type_: GLenum,
coords: GLuint,
) {
trace!("glMultiTexCoordP3ui");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP3ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP3ui({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP3uiv(
texture: GLenum,
type_: GLenum,
coords: *const GLuint,
) {
trace!("glMultiTexCoordP3uiv");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP3uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP3uiv({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP4ui(
texture: GLenum,
type_: GLenum,
coords: GLuint,
) {
trace!("glMultiTexCoordP4ui");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP4ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP4ui({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glMultiTexCoordP4uiv(
texture: GLenum,
type_: GLenum,
coords: *const GLuint,
) {
trace!("glMultiTexCoordP4uiv");
let p: *mut c_void = {
let temp_p = storage::MultiTexCoordP4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glMultiTexCoordP4uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLuint),
>(p)(texture, type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glMultiTexCoordP4uiv({:?}, {:?}, {:?}): {}",
texture, type_, coords, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glNormalP3ui(type_: GLenum, coords: GLuint) {
trace!("glNormalP3ui");
let p: *mut c_void = {
let temp_p = storage::NormalP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glNormalP3ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, coords,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glNormalP3ui({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glNormalP3uiv(type_: GLenum, coords: *const GLuint) {
trace!("glNormalP3uiv");
let p: *mut c_void = {
let temp_p = storage::NormalP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glNormalP3uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glNormalP3uiv({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[inline]
pub unsafe fn glPixelStoref(pname: GLenum, param: GLfloat) {
trace!("glPixelStoref");
let p: *mut c_void = {
let temp_p = storage::PixelStoref.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPixelStoref not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLfloat)>(p)(
pname, param,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPixelStoref({:?}, {:?}): {}", pname, param, err);
}
}
out
}
#[inline]
pub unsafe fn glPixelStorei(pname: GLenum, param: GLint) {
trace!("glPixelStorei");
let p: *mut c_void = {
let temp_p = storage::PixelStorei.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPixelStorei not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLint)>(p)(
pname, param,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPixelStorei({:?}, {:?}): {}", pname, param, err);
}
}
out
}
#[inline]
pub unsafe fn glPointParameterf(pname: GLenum, param: GLfloat) {
trace!("glPointParameterf");
let p: *mut c_void = {
let temp_p = storage::PointParameterf.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPointParameterf not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLfloat)>(p)(
pname, param,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPointParameterf({:?}, {:?}): {}", pname, param, err);
}
}
out
}
#[inline]
pub unsafe fn glPointParameterfv(pname: GLenum, params: *const GLfloat) {
trace!("glPointParameterfv");
let p: *mut c_void = {
let temp_p = storage::PointParameterfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPointParameterfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, *const GLfloat),
>(p)(pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPointParameterfv({:?}, {:?}): {}", pname, params, err);
}
}
out
}
#[inline]
pub unsafe fn glPointParameteri(pname: GLenum, param: GLint) {
trace!("glPointParameteri");
let p: *mut c_void = {
let temp_p = storage::PointParameteri.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPointParameteri not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLint)>(p)(
pname, param,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPointParameteri({:?}, {:?}): {}", pname, param, err);
}
}
out
}
#[inline]
pub unsafe fn glPointParameteriv(pname: GLenum, params: *const GLint) {
trace!("glPointParameteriv");
let p: *mut c_void = {
let temp_p = storage::PointParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPointParameteriv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLint)>(
p,
)(pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPointParameteriv({:?}, {:?}): {}", pname, params, err);
}
}
out
}
#[inline]
pub unsafe fn glPointSize(size: GLfloat) {
trace!("glPointSize");
let p: *mut c_void = {
let temp_p = storage::PointSize.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPointSize not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLfloat)>(p)(size);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPointSize({:?}): {}", size, err);
}
}
out
}
#[inline]
pub unsafe fn glPolygonMode(face: GLenum, mode: GLenum) {
trace!("glPolygonMode");
let p: *mut c_void = {
let temp_p = storage::PolygonMode.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPolygonMode not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLenum)>(p)(
face, mode,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPolygonMode({:?}, {:?}): {}", face, mode, err);
}
}
out
}
#[inline]
pub unsafe fn glPolygonOffset(factor: GLfloat, units: GLfloat) {
trace!("glPolygonOffset");
let p: *mut c_void = {
let temp_p = storage::PolygonOffset.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPolygonOffset not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLfloat, GLfloat)>(p)(
factor, units,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPolygonOffset({:?}, {:?}): {}", factor, units, err);
}
}
out
}
#[inline]
pub unsafe fn glPrimitiveRestartIndex(index: GLuint) {
trace!("glPrimitiveRestartIndex");
let p: *mut c_void = {
let temp_p = storage::PrimitiveRestartIndex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glPrimitiveRestartIndex not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(index);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glPrimitiveRestartIndex({:?}): {}", index, err);
}
}
out
}
#[inline]
pub unsafe fn glProvokingVertex(mode: GLenum) {
trace!("glProvokingVertex");
let p: *mut c_void = {
let temp_p = storage::ProvokingVertex.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glProvokingVertex not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(mode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glProvokingVertex({:?}): {}", mode, err);
}
}
out
}
#[inline]
pub unsafe fn glQueryCounter(id: GLuint, target: GLenum) {
trace!("glQueryCounter");
let p: *mut c_void = {
let temp_p = storage::QueryCounter.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glQueryCounter not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLenum)>(p)(
id, target,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glQueryCounter({:?}, {:?}): {}", id, target, err);
}
}
out
}
#[inline]
pub unsafe fn glReadBuffer(src: GLenum) {
trace!("glReadBuffer");
let p: *mut c_void = {
let temp_p = storage::ReadBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glReadBuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum)>(p)(src);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glReadBuffer({:?}): {}", src, err);
}
}
out
}
#[inline]
pub unsafe fn glReadPixels(
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *mut c_void,
) {
trace!("glReadPixels");
let p: *mut c_void = {
let temp_p = storage::ReadPixels.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glReadPixels not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLint,
GLint,
GLsizei,
GLsizei,
GLenum,
GLenum,
*mut c_void,
),
>(p)(x, y, width, height, format, type_, pixels);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glReadPixels({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
x, y, width, height, format, type_, pixels, err
);
}
}
out
}
#[inline]
pub unsafe fn glRenderbufferStorage(
target: GLenum,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
trace!("glRenderbufferStorage");
let p: *mut c_void = {
let temp_p = storage::RenderbufferStorage.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glRenderbufferStorage not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLsizei, GLsizei),
>(p)(target, internalformat, width, height);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glRenderbufferStorage({:?}, {:?}, {:?}, {:?}): {}",
target, internalformat, width, height, err
);
}
}
out
}
#[inline]
pub unsafe fn glRenderbufferStorageMultisample(
target: GLenum,
samples: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
trace!("glRenderbufferStorageMultisample");
let p: *mut c_void = {
let temp_p =
storage::RenderbufferStorageMultisample.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glRenderbufferStorageMultisample not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLsizei, GLenum, GLsizei, GLsizei),
>(p)(target, samples, internalformat, width, height);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glRenderbufferStorageMultisample({:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, samples, internalformat, width, height, err
);
}
}
out
}
#[inline]
pub unsafe fn glSampleCoverage(value: GLfloat, invert: GLboolean) {
trace!("glSampleCoverage");
let p: *mut c_void = {
let temp_p = storage::SampleCoverage.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSampleCoverage not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLfloat, GLboolean)>(
p,
)(value, invert);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glSampleCoverage({:?}, {:?}): {}", value, invert, err);
}
}
out
}
#[inline]
pub unsafe fn glSampleMaski(maskNumber: GLuint, mask: GLbitfield) {
trace!("glSampleMaski");
let p: *mut c_void = {
let temp_p = storage::SampleMaski.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSampleMaski not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLbitfield)>(
p,
)(maskNumber, mask);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glSampleMaski({:?}, {:?}): {}", maskNumber, mask, err);
}
}
out
}
#[inline]
pub unsafe fn glSamplerParameterIiv(
sampler: GLuint,
pname: GLenum,
param: *const GLint,
) {
trace!("glSamplerParameterIiv");
let p: *mut c_void = {
let temp_p = storage::SamplerParameterIiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSamplerParameterIiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *const GLint),
>(p)(sampler, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glSamplerParameterIiv({:?}, {:?}, {:?}): {}",
sampler, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glSamplerParameterIuiv(
sampler: GLuint,
pname: GLenum,
param: *const GLuint,
) {
trace!("glSamplerParameterIuiv");
let p: *mut c_void = {
let temp_p = storage::SamplerParameterIuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSamplerParameterIuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *const GLuint),
>(p)(sampler, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glSamplerParameterIuiv({:?}, {:?}, {:?}): {}",
sampler, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glSamplerParameterf(
sampler: GLuint,
pname: GLenum,
param: GLfloat,
) {
trace!("glSamplerParameterf");
let p: *mut c_void = {
let temp_p = storage::SamplerParameterf.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSamplerParameterf not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLfloat),
>(p)(sampler, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glSamplerParameterf({:?}, {:?}, {:?}): {}",
sampler, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glSamplerParameterfv(
sampler: GLuint,
pname: GLenum,
param: *const GLfloat,
) {
trace!("glSamplerParameterfv");
let p: *mut c_void = {
let temp_p = storage::SamplerParameterfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSamplerParameterfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *const GLfloat),
>(p)(sampler, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glSamplerParameterfv({:?}, {:?}, {:?}): {}",
sampler, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glSamplerParameteri(
sampler: GLuint,
pname: GLenum,
param: GLint,
) {
trace!("glSamplerParameteri");
let p: *mut c_void = {
let temp_p = storage::SamplerParameteri.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSamplerParameteri not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLenum, GLint)>(
p,
)(sampler, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glSamplerParameteri({:?}, {:?}, {:?}): {}",
sampler, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glSamplerParameteriv(
sampler: GLuint,
pname: GLenum,
param: *const GLint,
) {
trace!("glSamplerParameteriv");
let p: *mut c_void = {
let temp_p = storage::SamplerParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSamplerParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, *const GLint),
>(p)(sampler, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glSamplerParameteriv({:?}, {:?}, {:?}): {}",
sampler, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glScissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei) {
trace!("glScissor");
let p: *mut c_void = {
let temp_p = storage::Scissor.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glScissor not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLint, GLsizei, GLsizei),
>(p)(x, y, width, height);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glScissor({:?}, {:?}, {:?}, {:?}): {}",
x, y, width, height, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glSecondaryColorP3ui(type_: GLenum, color: GLuint) {
trace!("glSecondaryColorP3ui");
let p: *mut c_void = {
let temp_p = storage::SecondaryColorP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSecondaryColorP3ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, color,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glSecondaryColorP3ui({:?}, {:?}): {}", type_, color, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glSecondaryColorP3uiv(type_: GLenum, color: *const GLuint) {
trace!("glSecondaryColorP3uiv");
let p: *mut c_void = {
let temp_p = storage::SecondaryColorP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glSecondaryColorP3uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, color);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glSecondaryColorP3uiv({:?}, {:?}): {}", type_, color, err);
}
}
out
}
#[inline]
pub unsafe fn glShaderSource(
shader: GLuint,
count: GLsizei,
string: *const *const GLchar,
length: *const GLint,
) {
trace!("glShaderSource");
let p: *mut c_void = {
let temp_p = storage::ShaderSource.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glShaderSource not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *const *const GLchar, *const GLint),
>(p)(shader, count, string, length);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glShaderSource({:?}, {:?}, {:?}, {:?}): {}",
shader, count, string, length, err
);
}
}
out
}
#[inline]
pub unsafe fn glStencilFunc(func: GLenum, ref_: GLint, mask: GLuint) {
trace!("glStencilFunc");
let p: *mut c_void = {
let temp_p = storage::StencilFunc.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glStencilFunc not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLint, GLuint)>(
p,
)(func, ref_, mask);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glStencilFunc({:?}, {:?}, {:?}): {}", func, ref_, mask, err);
}
}
out
}
#[inline]
pub unsafe fn glStencilFuncSeparate(
face: GLenum,
func: GLenum,
ref_: GLint,
mask: GLuint,
) {
trace!("glStencilFuncSeparate");
let p: *mut c_void = {
let temp_p = storage::StencilFuncSeparate.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glStencilFuncSeparate not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLint, GLuint),
>(p)(face, func, ref_, mask);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glStencilFuncSeparate({:?}, {:?}, {:?}, {:?}): {}",
face, func, ref_, mask, err
);
}
}
out
}
#[inline]
pub unsafe fn glStencilMask(mask: GLuint) {
trace!("glStencilMask");
let p: *mut c_void = {
let temp_p = storage::StencilMask.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glStencilMask not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(mask);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glStencilMask({:?}): {}", mask, err);
}
}
out
}
#[inline]
pub unsafe fn glStencilMaskSeparate(face: GLenum, mask: GLuint) {
trace!("glStencilMaskSeparate");
let p: *mut c_void = {
let temp_p = storage::StencilMaskSeparate.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glStencilMaskSeparate not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
face, mask,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glStencilMaskSeparate({:?}, {:?}): {}", face, mask, err);
}
}
out
}
#[inline]
pub unsafe fn glStencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum) {
trace!("glStencilOp");
let p: *mut c_void = {
let temp_p = storage::StencilOp.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glStencilOp not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum),
>(p)(fail, zfail, zpass);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glStencilOp({:?}, {:?}, {:?}): {}", fail, zfail, zpass, err);
}
}
out
}
#[inline]
pub unsafe fn glStencilOpSeparate(
face: GLenum,
sfail: GLenum,
dpfail: GLenum,
dppass: GLenum,
) {
trace!("glStencilOpSeparate");
let p: *mut c_void = {
let temp_p = storage::StencilOpSeparate.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glStencilOpSeparate not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLenum, GLenum),
>(p)(face, sfail, dpfail, dppass);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glStencilOpSeparate({:?}, {:?}, {:?}, {:?}): {}",
face, sfail, dpfail, dppass, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexBuffer(
target: GLenum,
internalformat: GLenum,
buffer: GLuint,
) {
trace!("glTexBuffer");
let p: *mut c_void = {
let temp_p = storage::TexBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexBuffer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLuint),
>(p)(target, internalformat, buffer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexBuffer({:?}, {:?}, {:?}): {}",
target, internalformat, buffer, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP1ui(type_: GLenum, coords: GLuint) {
trace!("glTexCoordP1ui");
let p: *mut c_void = {
let temp_p = storage::TexCoordP1ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP1ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, coords,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP1ui({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP1uiv(type_: GLenum, coords: *const GLuint) {
trace!("glTexCoordP1uiv");
let p: *mut c_void = {
let temp_p = storage::TexCoordP1uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP1uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP1uiv({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP2ui(type_: GLenum, coords: GLuint) {
trace!("glTexCoordP2ui");
let p: *mut c_void = {
let temp_p = storage::TexCoordP2ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP2ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, coords,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP2ui({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP2uiv(type_: GLenum, coords: *const GLuint) {
trace!("glTexCoordP2uiv");
let p: *mut c_void = {
let temp_p = storage::TexCoordP2uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP2uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP2uiv({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP3ui(type_: GLenum, coords: GLuint) {
trace!("glTexCoordP3ui");
let p: *mut c_void = {
let temp_p = storage::TexCoordP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP3ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, coords,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP3ui({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP3uiv(type_: GLenum, coords: *const GLuint) {
trace!("glTexCoordP3uiv");
let p: *mut c_void = {
let temp_p = storage::TexCoordP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP3uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP3uiv({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP4ui(type_: GLenum, coords: GLuint) {
trace!("glTexCoordP4ui");
let p: *mut c_void = {
let temp_p = storage::TexCoordP4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP4ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, coords,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP4ui({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glTexCoordP4uiv(type_: GLenum, coords: *const GLuint) {
trace!("glTexCoordP4uiv");
let p: *mut c_void = {
let temp_p = storage::TexCoordP4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexCoordP4uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, coords);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexCoordP4uiv({:?}, {:?}): {}", type_, coords, err);
}
}
out
}
#[inline]
pub unsafe fn glTexImage1D(
target: GLenum,
level: GLint,
internalformat: GLint,
width: GLsizei,
border: GLint,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
trace!("glTexImage1D");
let p: *mut c_void = {
let temp_p = storage::TexImage1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexImage1D not loaded");
}
temp_p
};
let out =
transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLsizei,
GLint,
GLenum,
GLenum,
*const c_void,
),
>(p)(
target, level, internalformat, width, border, format, type_, pixels
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexImage1D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target,
level,
internalformat,
width,
border,
format,
type_,
pixels,
err
);
}
}
out
}
#[inline]
pub unsafe fn glTexImage2D(
target: GLenum,
level: GLint,
internalformat: GLint,
width: GLsizei,
height: GLsizei,
border: GLint,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
trace!("glTexImage2D");
let p: *mut c_void = {
let temp_p = storage::TexImage2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexImage2D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLsizei,
GLsizei,
GLint,
GLenum,
GLenum,
*const c_void,
),
>(p)(
target,
level,
internalformat,
width,
height,
border,
format,
type_,
pixels,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexImage2D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, internalformat, width, height, border, format, type_, pixels, err);
}
}
out
}
#[inline]
pub unsafe fn glTexImage2DMultisample(
target: GLenum,
samples: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
fixedsamplelocations: GLboolean,
) {
trace!("glTexImage2DMultisample");
let p: *mut c_void = {
let temp_p = storage::TexImage2DMultisample.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexImage2DMultisample not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean),
>(p)(
target,
samples,
internalformat,
width,
height,
fixedsamplelocations,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexImage2DMultisample({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target,
samples,
internalformat,
width,
height,
fixedsamplelocations,
err
);
}
}
out
}
#[inline]
pub unsafe fn glTexImage3D(
target: GLenum,
level: GLint,
internalformat: GLint,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
border: GLint,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
trace!("glTexImage3D");
let p: *mut c_void = {
let temp_p = storage::TexImage3D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexImage3D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLsizei,
GLsizei,
GLsizei,
GLint,
GLenum,
GLenum,
*const c_void,
),
>(p)(
target,
level,
internalformat,
width,
height,
depth,
border,
format,
type_,
pixels,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexImage3D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, internalformat, width, height, depth, border, format, type_, pixels, err);
}
}
out
}
#[inline]
pub unsafe fn glTexImage3DMultisample(
target: GLenum,
samples: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
fixedsamplelocations: GLboolean,
) {
trace!("glTexImage3DMultisample");
let p: *mut c_void = {
let temp_p = storage::TexImage3DMultisample.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexImage3DMultisample not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLsizei,
GLenum,
GLsizei,
GLsizei,
GLsizei,
GLboolean,
),
>(p)(
target,
samples,
internalformat,
width,
height,
depth,
fixedsamplelocations,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexImage3DMultisample({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target,
samples,
internalformat,
width,
height,
depth,
fixedsamplelocations,
err
);
}
}
out
}
#[inline]
pub unsafe fn glTexParameterIiv(
target: GLenum,
pname: GLenum,
params: *const GLint,
) {
trace!("glTexParameterIiv");
let p: *mut c_void = {
let temp_p = storage::TexParameterIiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexParameterIiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexParameterIiv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexParameterIuiv(
target: GLenum,
pname: GLenum,
params: *const GLuint,
) {
trace!("glTexParameterIuiv");
let p: *mut c_void = {
let temp_p = storage::TexParameterIuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexParameterIuiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLuint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexParameterIuiv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexParameterf(target: GLenum, pname: GLenum, param: GLfloat) {
trace!("glTexParameterf");
let p: *mut c_void = {
let temp_p = storage::TexParameterf.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexParameterf not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, GLfloat),
>(p)(target, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexParameterf({:?}, {:?}, {:?}): {}",
target, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexParameterfv(
target: GLenum,
pname: GLenum,
params: *const GLfloat,
) {
trace!("glTexParameterfv");
let p: *mut c_void = {
let temp_p = storage::TexParameterfv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexParameterfv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLfloat),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexParameterfv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexParameteri(target: GLenum, pname: GLenum, param: GLint) {
trace!("glTexParameteri");
let p: *mut c_void = {
let temp_p = storage::TexParameteri.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexParameteri not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLenum, GLint)>(
p,
)(target, pname, param);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexParameteri({:?}, {:?}, {:?}): {}",
target, pname, param, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexParameteriv(
target: GLenum,
pname: GLenum,
params: *const GLint,
) {
trace!("glTexParameteriv");
let p: *mut c_void = {
let temp_p = storage::TexParameteriv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexParameteriv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLenum, GLenum, *const GLint),
>(p)(target, pname, params);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexParameteriv({:?}, {:?}, {:?}): {}",
target, pname, params, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexSubImage1D(
target: GLenum,
level: GLint,
xoffset: GLint,
width: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
trace!("glTexSubImage1D");
let p: *mut c_void = {
let temp_p = storage::TexSubImage1D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexSubImage1D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLsizei,
GLenum,
GLenum,
*const c_void,
),
>(p)(target, level, xoffset, width, format, type_, pixels);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTexSubImage1D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
target, level, xoffset, width, format, type_, pixels, err
);
}
}
out
}
#[inline]
pub unsafe fn glTexSubImage2D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
trace!("glTexSubImage2D");
let p: *mut c_void = {
let temp_p = storage::TexSubImage2D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexSubImage2D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLint,
GLsizei,
GLsizei,
GLenum,
GLenum,
*const c_void,
),
>(p)(
target, level, xoffset, yoffset, width, height, format, type_, pixels,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexSubImage2D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, yoffset, width, height, format, type_, pixels, err);
}
}
out
}
#[inline]
pub unsafe fn glTexSubImage3D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
trace!("glTexSubImage3D");
let p: *mut c_void = {
let temp_p = storage::TexSubImage3D.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTexSubImage3D not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLenum,
GLint,
GLint,
GLint,
GLint,
GLsizei,
GLsizei,
GLsizei,
GLenum,
GLenum,
*const c_void,
),
>(p)(
target, level, xoffset, yoffset, zoffset, width, height, depth, format,
type_, pixels,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glTexSubImage3D({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, pixels, err);
}
}
out
}
#[inline]
pub unsafe fn glTransformFeedbackVaryings(
program: GLuint,
count: GLsizei,
varyings: *const *const GLchar,
bufferMode: GLenum,
) {
trace!("glTransformFeedbackVaryings");
let p: *mut c_void = {
let temp_p = storage::TransformFeedbackVaryings.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glTransformFeedbackVaryings not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLsizei, *const *const GLchar, GLenum),
>(p)(program, count, varyings, bufferMode);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glTransformFeedbackVaryings({:?}, {:?}, {:?}, {:?}): {}",
program, count, varyings, bufferMode, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform1f(location: GLint, v0: GLfloat) {
trace!("glUniform1f");
let p: *mut c_void = {
let temp_p = storage::Uniform1f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform1f not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLint, GLfloat)>(p)(
location, v0,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUniform1f({:?}, {:?}): {}", location, v0, err);
}
}
out
}
#[inline]
pub unsafe fn glUniform1fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
trace!("glUniform1fv");
let p: *mut c_void = {
let temp_p = storage::Uniform1fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform1fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLfloat),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform1fv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform1i(location: GLint, v0: GLint) {
trace!("glUniform1i");
let p: *mut c_void = {
let temp_p = storage::Uniform1i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform1i not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLint, GLint)>(p)(
location, v0,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUniform1i({:?}, {:?}): {}", location, v0, err);
}
}
out
}
#[inline]
pub unsafe fn glUniform1iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
trace!("glUniform1iv");
let p: *mut c_void = {
let temp_p = storage::Uniform1iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform1iv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform1iv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform1ui(location: GLint, v0: GLuint) {
trace!("glUniform1ui");
let p: *mut c_void = {
let temp_p = storage::Uniform1ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform1ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLint, GLuint)>(p)(
location, v0,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUniform1ui({:?}, {:?}): {}", location, v0, err);
}
}
out
}
#[inline]
pub unsafe fn glUniform1uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
trace!("glUniform1uiv");
let p: *mut c_void = {
let temp_p = storage::Uniform1uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform1uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLuint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform1uiv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform2f(location: GLint, v0: GLfloat, v1: GLfloat) {
trace!("glUniform2f");
let p: *mut c_void = {
let temp_p = storage::Uniform2f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform2f not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLfloat, GLfloat),
>(p)(location, v0, v1);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUniform2f({:?}, {:?}, {:?}): {}", location, v0, v1, err);
}
}
out
}
#[inline]
pub unsafe fn glUniform2fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
trace!("glUniform2fv");
let p: *mut c_void = {
let temp_p = storage::Uniform2fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform2fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLfloat),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform2fv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform2i(location: GLint, v0: GLint, v1: GLint) {
trace!("glUniform2i");
let p: *mut c_void = {
let temp_p = storage::Uniform2i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform2i not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLint, GLint, GLint)>(
p,
)(location, v0, v1);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUniform2i({:?}, {:?}, {:?}): {}", location, v0, v1, err);
}
}
out
}
#[inline]
pub unsafe fn glUniform2iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
trace!("glUniform2iv");
let p: *mut c_void = {
let temp_p = storage::Uniform2iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform2iv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform2iv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform2ui(location: GLint, v0: GLuint, v1: GLuint) {
trace!("glUniform2ui");
let p: *mut c_void = {
let temp_p = storage::Uniform2ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform2ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLint, GLuint, GLuint)>(
p,
)(location, v0, v1);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUniform2ui({:?}, {:?}, {:?}): {}", location, v0, v1, err);
}
}
out
}
#[inline]
pub unsafe fn glUniform2uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
trace!("glUniform2uiv");
let p: *mut c_void = {
let temp_p = storage::Uniform2uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform2uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLuint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform2uiv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform3f(
location: GLint,
v0: GLfloat,
v1: GLfloat,
v2: GLfloat,
) {
trace!("glUniform3f");
let p: *mut c_void = {
let temp_p = storage::Uniform3f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform3f not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLfloat, GLfloat, GLfloat),
>(p)(location, v0, v1, v2);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform3f({:?}, {:?}, {:?}, {:?}): {}",
location, v0, v1, v2, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform3fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
trace!("glUniform3fv");
let p: *mut c_void = {
let temp_p = storage::Uniform3fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform3fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLfloat),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform3fv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform3i(location: GLint, v0: GLint, v1: GLint, v2: GLint) {
trace!("glUniform3i");
let p: *mut c_void = {
let temp_p = storage::Uniform3i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform3i not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLint, GLint, GLint),
>(p)(location, v0, v1, v2);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform3i({:?}, {:?}, {:?}, {:?}): {}",
location, v0, v1, v2, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform3iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
trace!("glUniform3iv");
let p: *mut c_void = {
let temp_p = storage::Uniform3iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform3iv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform3iv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform3ui(
location: GLint,
v0: GLuint,
v1: GLuint,
v2: GLuint,
) {
trace!("glUniform3ui");
let p: *mut c_void = {
let temp_p = storage::Uniform3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform3ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLuint, GLuint, GLuint),
>(p)(location, v0, v1, v2);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform3ui({:?}, {:?}, {:?}, {:?}): {}",
location, v0, v1, v2, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform3uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
trace!("glUniform3uiv");
let p: *mut c_void = {
let temp_p = storage::Uniform3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform3uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLuint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform3uiv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform4f(
location: GLint,
v0: GLfloat,
v1: GLfloat,
v2: GLfloat,
v3: GLfloat,
) {
trace!("glUniform4f");
let p: *mut c_void = {
let temp_p = storage::Uniform4f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform4f not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLfloat, GLfloat, GLfloat, GLfloat),
>(p)(location, v0, v1, v2, v3);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform4f({:?}, {:?}, {:?}, {:?}, {:?}): {}",
location, v0, v1, v2, v3, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform4fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
trace!("glUniform4fv");
let p: *mut c_void = {
let temp_p = storage::Uniform4fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform4fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLfloat),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform4fv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform4i(
location: GLint,
v0: GLint,
v1: GLint,
v2: GLint,
v3: GLint,
) {
trace!("glUniform4i");
let p: *mut c_void = {
let temp_p = storage::Uniform4i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform4i not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLint, GLint, GLint, GLint),
>(p)(location, v0, v1, v2, v3);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform4i({:?}, {:?}, {:?}, {:?}, {:?}): {}",
location, v0, v1, v2, v3, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform4iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
trace!("glUniform4iv");
let p: *mut c_void = {
let temp_p = storage::Uniform4iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform4iv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform4iv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform4ui(
location: GLint,
v0: GLuint,
v1: GLuint,
v2: GLuint,
v3: GLuint,
) {
trace!("glUniform4ui");
let p: *mut c_void = {
let temp_p = storage::Uniform4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform4ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLuint, GLuint, GLuint, GLuint),
>(p)(location, v0, v1, v2, v3);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform4ui({:?}, {:?}, {:?}, {:?}, {:?}): {}",
location, v0, v1, v2, v3, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniform4uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
trace!("glUniform4uiv");
let p: *mut c_void = {
let temp_p = storage::Uniform4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniform4uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, *const GLuint),
>(p)(location, count, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniform4uiv({:?}, {:?}, {:?}): {}",
location, count, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformBlockBinding(
program: GLuint,
uniformBlockIndex: GLuint,
uniformBlockBinding: GLuint,
) {
trace!("glUniformBlockBinding");
let p: *mut c_void = {
let temp_p = storage::UniformBlockBinding.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformBlockBinding not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLuint),
>(p)(program, uniformBlockIndex, uniformBlockBinding);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformBlockBinding({:?}, {:?}, {:?}): {}",
program, uniformBlockIndex, uniformBlockBinding, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix2fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix2fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix2fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix2fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix2fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix2x3fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix2x3fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix2x3fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix2x3fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix2x3fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix2x4fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix2x4fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix2x4fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix2x4fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix2x4fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix3fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix3fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix3fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix3fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix3fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix3x2fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix3x2fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix3x2fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix3x2fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix3x2fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix3x4fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix3x4fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix3x4fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix3x4fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix3x4fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix4fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix4fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix4fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix4fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix4fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix4x2fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix4x2fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix4x2fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix4x2fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix4x2fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUniformMatrix4x3fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
trace!("glUniformMatrix4x3fv");
let p: *mut c_void = {
let temp_p = storage::UniformMatrix4x3fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUniformMatrix4x3fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLsizei, GLboolean, *const GLfloat),
>(p)(location, count, transpose, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glUniformMatrix4x3fv({:?}, {:?}, {:?}, {:?}): {}",
location, count, transpose, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glUnmapBuffer(target: GLenum) -> GLboolean {
trace!("glUnmapBuffer");
let p: *mut c_void = {
let temp_p = storage::UnmapBuffer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUnmapBuffer not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum) -> GLboolean>(
p,
)(target);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUnmapBuffer({:?}): {}", target, err);
}
}
out
}
#[inline]
pub unsafe fn glUseProgram(program: GLuint) {
trace!("glUseProgram");
let p: *mut c_void = {
let temp_p = storage::UseProgram.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glUseProgram not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(program);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glUseProgram({:?}): {}", program, err);
}
}
out
}
#[inline]
pub unsafe fn glValidateProgram(program: GLuint) {
trace!("glValidateProgram");
let p: *mut c_void = {
let temp_p = storage::ValidateProgram.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glValidateProgram not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint)>(p)(program);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glValidateProgram({:?}): {}", program, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib1d(index: GLuint, x: GLdouble) {
trace!("glVertexAttrib1d");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib1d.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib1d not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLdouble)>(p)(
index, x,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib1d({:?}, {:?}): {}", index, x, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib1dv(index: GLuint, v: *const GLdouble) {
trace!("glVertexAttrib1dv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib1dv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib1dv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLdouble),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib1dv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib1f(index: GLuint, x: GLfloat) {
trace!("glVertexAttrib1f");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib1f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib1f not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLfloat)>(p)(
index, x,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib1f({:?}, {:?}): {}", index, x, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib1fv(index: GLuint, v: *const GLfloat) {
trace!("glVertexAttrib1fv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib1fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib1fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLfloat),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib1fv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib1s(index: GLuint, x: GLshort) {
trace!("glVertexAttrib1s");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib1s.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib1s not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLshort)>(p)(
index, x,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib1s({:?}, {:?}): {}", index, x, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib1sv(index: GLuint, v: *const GLshort) {
trace!("glVertexAttrib1sv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib1sv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib1sv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLshort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib1sv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib2d(index: GLuint, x: GLdouble, y: GLdouble) {
trace!("glVertexAttrib2d");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib2d.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib2d not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLdouble, GLdouble),
>(p)(index, x, y);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib2d({:?}, {:?}, {:?}): {}", index, x, y, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib2dv(index: GLuint, v: *const GLdouble) {
trace!("glVertexAttrib2dv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib2dv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib2dv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLdouble),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib2dv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {
trace!("glVertexAttrib2f");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib2f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib2f not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLfloat, GLfloat),
>(p)(index, x, y);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib2f({:?}, {:?}, {:?}): {}", index, x, y, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib2fv(index: GLuint, v: *const GLfloat) {
trace!("glVertexAttrib2fv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib2fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib2fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLfloat),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib2fv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib2s(index: GLuint, x: GLshort, y: GLshort) {
trace!("glVertexAttrib2s");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib2s.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib2s not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLshort, GLshort),
>(p)(index, x, y);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib2s({:?}, {:?}, {:?}): {}", index, x, y, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib2sv(index: GLuint, v: *const GLshort) {
trace!("glVertexAttrib2sv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib2sv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib2sv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLshort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib2sv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib3d(
index: GLuint,
x: GLdouble,
y: GLdouble,
z: GLdouble,
) {
trace!("glVertexAttrib3d");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib3d.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib3d not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLdouble, GLdouble, GLdouble),
>(p)(index, x, y, z);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib3d({:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib3dv(index: GLuint, v: *const GLdouble) {
trace!("glVertexAttrib3dv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib3dv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib3dv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLdouble),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib3dv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib3f(
index: GLuint,
x: GLfloat,
y: GLfloat,
z: GLfloat,
) {
trace!("glVertexAttrib3f");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib3f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib3f not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLfloat, GLfloat, GLfloat),
>(p)(index, x, y, z);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib3f({:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib3fv(index: GLuint, v: *const GLfloat) {
trace!("glVertexAttrib3fv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib3fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib3fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLfloat),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib3fv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib3s(
index: GLuint,
x: GLshort,
y: GLshort,
z: GLshort,
) {
trace!("glVertexAttrib3s");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib3s.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib3s not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLshort, GLshort, GLshort),
>(p)(index, x, y, z);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib3s({:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib3sv(index: GLuint, v: *const GLshort) {
trace!("glVertexAttrib3sv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib3sv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib3sv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLshort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib3sv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Nbv(index: GLuint, v: *const GLbyte) {
trace!("glVertexAttrib4Nbv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Nbv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Nbv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLbyte)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4Nbv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Niv(index: GLuint, v: *const GLint) {
trace!("glVertexAttrib4Niv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Niv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Niv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4Niv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Nsv(index: GLuint, v: *const GLshort) {
trace!("glVertexAttrib4Nsv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Nsv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Nsv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLshort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4Nsv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Nub(
index: GLuint,
x: GLubyte,
y: GLubyte,
z: GLubyte,
w: GLubyte,
) {
trace!("glVertexAttrib4Nub");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Nub.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Nub not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLubyte, GLubyte, GLubyte, GLubyte),
>(p)(index, x, y, z, w);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib4Nub({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, w, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Nubv(index: GLuint, v: *const GLubyte) {
trace!("glVertexAttrib4Nubv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Nubv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Nubv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLubyte),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4Nubv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Nuiv(index: GLuint, v: *const GLuint) {
trace!("glVertexAttrib4Nuiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Nuiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Nuiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLuint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4Nuiv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4Nusv(index: GLuint, v: *const GLushort) {
trace!("glVertexAttrib4Nusv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4Nusv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4Nusv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLushort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4Nusv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4bv(index: GLuint, v: *const GLbyte) {
trace!("glVertexAttrib4bv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4bv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4bv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLbyte)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4bv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4d(
index: GLuint,
x: GLdouble,
y: GLdouble,
z: GLdouble,
w: GLdouble,
) {
trace!("glVertexAttrib4d");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4d.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4d not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLdouble, GLdouble, GLdouble, GLdouble),
>(p)(index, x, y, z, w);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib4d({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, w, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4dv(index: GLuint, v: *const GLdouble) {
trace!("glVertexAttrib4dv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4dv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4dv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLdouble),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4dv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4f(
index: GLuint,
x: GLfloat,
y: GLfloat,
z: GLfloat,
w: GLfloat,
) {
trace!("glVertexAttrib4f");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4f.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4f not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLfloat, GLfloat, GLfloat, GLfloat),
>(p)(index, x, y, z, w);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib4f({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, w, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4fv(index: GLuint, v: *const GLfloat) {
trace!("glVertexAttrib4fv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4fv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4fv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLfloat),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4fv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4iv(index: GLuint, v: *const GLint) {
trace!("glVertexAttrib4iv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4iv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4iv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4s(
index: GLuint,
x: GLshort,
y: GLshort,
z: GLshort,
w: GLshort,
) {
trace!("glVertexAttrib4s");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4s.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4s not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLshort, GLshort, GLshort, GLshort),
>(p)(index, x, y, z, w);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttrib4s({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, w, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4sv(index: GLuint, v: *const GLshort) {
trace!("glVertexAttrib4sv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4sv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4sv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLshort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4sv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4ubv(index: GLuint, v: *const GLubyte) {
trace!("glVertexAttrib4ubv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4ubv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4ubv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLubyte),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4ubv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4uiv(index: GLuint, v: *const GLuint) {
trace!("glVertexAttrib4uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLuint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4uiv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttrib4usv(index: GLuint, v: *const GLushort) {
trace!("glVertexAttrib4usv");
let p: *mut c_void = {
let temp_p = storage::VertexAttrib4usv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttrib4usv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLushort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttrib4usv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribDivisor(index: GLuint, divisor: GLuint) {
trace!("glVertexAttribDivisor");
let p: *mut c_void = {
let temp_p = storage::VertexAttribDivisor.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribDivisor not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLuint)>(p)(
index, divisor,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribDivisor({:?}, {:?}): {}", index, divisor, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI1i(index: GLuint, x: GLint) {
trace!("glVertexAttribI1i");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI1i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI1i not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLuint, GLint)>(p)(index, x);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI1i({:?}, {:?}): {}", index, x, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI1iv(index: GLuint, v: *const GLint) {
trace!("glVertexAttribI1iv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI1iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI1iv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI1iv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI1ui(index: GLuint, x: GLuint) {
trace!("glVertexAttribI1ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI1ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI1ui not loaded");
}
temp_p
};
let out =
transmute::<*mut c_void, extern "system" fn(GLuint, GLuint)>(p)(index, x);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI1ui({:?}, {:?}): {}", index, x, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI1uiv(index: GLuint, v: *const GLuint) {
trace!("glVertexAttribI1uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI1uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI1uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLuint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI1uiv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI2i(index: GLuint, x: GLint, y: GLint) {
trace!("glVertexAttribI2i");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI2i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI2i not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, GLint, GLint)>(
p,
)(index, x, y);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI2i({:?}, {:?}, {:?}): {}", index, x, y, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI2iv(index: GLuint, v: *const GLint) {
trace!("glVertexAttribI2iv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI2iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI2iv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI2iv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI2ui(index: GLuint, x: GLuint, y: GLuint) {
trace!("glVertexAttribI2ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI2ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI2ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLuint),
>(p)(index, x, y);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI2ui({:?}, {:?}, {:?}): {}", index, x, y, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI2uiv(index: GLuint, v: *const GLuint) {
trace!("glVertexAttribI2uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI2uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI2uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLuint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI2uiv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI3i(index: GLuint, x: GLint, y: GLint, z: GLint) {
trace!("glVertexAttribI3i");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI3i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI3i not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLint, GLint, GLint),
>(p)(index, x, y, z);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribI3i({:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI3iv(index: GLuint, v: *const GLint) {
trace!("glVertexAttribI3iv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI3iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI3iv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI3iv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI3ui(
index: GLuint,
x: GLuint,
y: GLuint,
z: GLuint,
) {
trace!("glVertexAttribI3ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI3ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLuint, GLuint),
>(p)(index, x, y, z);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribI3ui({:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI3uiv(index: GLuint, v: *const GLuint) {
trace!("glVertexAttribI3uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI3uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLuint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI3uiv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4bv(index: GLuint, v: *const GLbyte) {
trace!("glVertexAttribI4bv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4bv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4bv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLbyte)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI4bv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4i(
index: GLuint,
x: GLint,
y: GLint,
z: GLint,
w: GLint,
) {
trace!("glVertexAttribI4i");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4i.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4i not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLint, GLint, GLint, GLint),
>(p)(index, x, y, z, w);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribI4i({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, w, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4iv(index: GLuint, v: *const GLint) {
trace!("glVertexAttribI4iv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4iv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4iv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI4iv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4sv(index: GLuint, v: *const GLshort) {
trace!("glVertexAttribI4sv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4sv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4sv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLshort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI4sv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4ubv(index: GLuint, v: *const GLubyte) {
trace!("glVertexAttribI4ubv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4ubv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4ubv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLubyte),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI4ubv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4ui(
index: GLuint,
x: GLuint,
y: GLuint,
z: GLuint,
w: GLuint,
) {
trace!("glVertexAttribI4ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLuint, GLuint, GLuint, GLuint),
>(p)(index, x, y, z, w);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribI4ui({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, x, y, z, w, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4uiv(index: GLuint, v: *const GLuint) {
trace!("glVertexAttribI4uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLuint, *const GLuint)>(
p,
)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI4uiv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribI4usv(index: GLuint, v: *const GLushort) {
trace!("glVertexAttribI4usv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribI4usv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribI4usv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, *const GLushort),
>(p)(index, v);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexAttribI4usv({:?}, {:?}): {}", index, v, err);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribIPointer(
index: GLuint,
size: GLint,
type_: GLenum,
stride: GLsizei,
pointer: *const c_void,
) {
trace!("glVertexAttribIPointer");
let p: *mut c_void = {
let temp_p = storage::VertexAttribIPointer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribIPointer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLint, GLenum, GLsizei, *const c_void),
>(p)(index, size, type_, stride, pointer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribIPointer({:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, size, type_, stride, pointer, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP1ui(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: GLuint,
) {
trace!("glVertexAttribP1ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP1ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP1ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP1ui({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP1uiv(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: *const GLuint,
) {
trace!("glVertexAttribP1uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP1uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP1uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, *const GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP1uiv({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP2ui(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: GLuint,
) {
trace!("glVertexAttribP2ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP2ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP2ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP2ui({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP2uiv(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: *const GLuint,
) {
trace!("glVertexAttribP2uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP2uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP2uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, *const GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP2uiv({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP3ui(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: GLuint,
) {
trace!("glVertexAttribP3ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP3ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP3ui({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP3uiv(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: *const GLuint,
) {
trace!("glVertexAttribP3uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP3uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, *const GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP3uiv({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP4ui(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: GLuint,
) {
trace!("glVertexAttribP4ui");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP4ui not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP4ui({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribP4uiv(
index: GLuint,
type_: GLenum,
normalized: GLboolean,
value: *const GLuint,
) {
trace!("glVertexAttribP4uiv");
let p: *mut c_void = {
let temp_p = storage::VertexAttribP4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribP4uiv not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLuint, GLenum, GLboolean, *const GLuint),
>(p)(index, type_, normalized, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribP4uiv({:?}, {:?}, {:?}, {:?}): {}",
index, type_, normalized, value, err
);
}
}
out
}
#[inline]
pub unsafe fn glVertexAttribPointer(
index: GLuint,
size: GLint,
type_: GLenum,
normalized: GLboolean,
stride: GLsizei,
pointer: *const c_void,
) {
trace!("glVertexAttribPointer");
let p: *mut c_void = {
let temp_p = storage::VertexAttribPointer.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexAttribPointer not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(
GLuint,
GLint,
GLenum,
GLboolean,
GLsizei,
*const c_void,
),
>(p)(index, size, type_, normalized, stride, pointer);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glVertexAttribPointer({:?}, {:?}, {:?}, {:?}, {:?}, {:?}): {}",
index, size, type_, normalized, stride, pointer, err
);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glVertexP2ui(type_: GLenum, value: GLuint) {
trace!("glVertexP2ui");
let p: *mut c_void = {
let temp_p = storage::VertexP2ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexP2ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, value,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexP2ui({:?}, {:?}): {}", type_, value, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glVertexP2uiv(type_: GLenum, value: *const GLuint) {
trace!("glVertexP2uiv");
let p: *mut c_void = {
let temp_p = storage::VertexP2uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexP2uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexP2uiv({:?}, {:?}): {}", type_, value, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glVertexP3ui(type_: GLenum, value: GLuint) {
trace!("glVertexP3ui");
let p: *mut c_void = {
let temp_p = storage::VertexP3ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexP3ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, value,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexP3ui({:?}, {:?}): {}", type_, value, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glVertexP3uiv(type_: GLenum, value: *const GLuint) {
trace!("glVertexP3uiv");
let p: *mut c_void = {
let temp_p = storage::VertexP3uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexP3uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexP3uiv({:?}, {:?}): {}", type_, value, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glVertexP4ui(type_: GLenum, value: GLuint) {
trace!("glVertexP4ui");
let p: *mut c_void = {
let temp_p = storage::VertexP4ui.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexP4ui not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, GLuint)>(p)(
type_, value,
);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexP4ui({:?}, {:?}): {}", type_, value, err);
}
}
out
}
#[cfg(feature = "compatibility_profile")]
#[inline]
pub unsafe fn glVertexP4uiv(type_: GLenum, value: *const GLuint) {
trace!("glVertexP4uiv");
let p: *mut c_void = {
let temp_p = storage::VertexP4uiv.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glVertexP4uiv not loaded");
}
temp_p
};
let out = transmute::<*mut c_void, extern "system" fn(GLenum, *const GLuint)>(
p,
)(type_, value);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glVertexP4uiv({:?}, {:?}): {}", type_, value, err);
}
}
out
}
#[inline]
pub unsafe fn glViewport(
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
trace!("glViewport");
let p: *mut c_void = {
let temp_p = storage::Viewport.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glViewport not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLint, GLint, GLsizei, GLsizei),
>(p)(x, y, width, height);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!(
"glViewport({:?}, {:?}, {:?}, {:?}): {}",
x, y, width, height, err
);
}
}
out
}
#[inline]
pub unsafe fn glWaitSync(sync: GLsync, flags: GLbitfield, timeout: GLuint64) {
trace!("glWaitSync");
let p: *mut c_void = {
let temp_p = storage::WaitSync.load(Ordering::Relaxed);
if temp_p.is_null() {
panic!("glWaitSync not loaded");
}
temp_p
};
let out = transmute::<
*mut c_void,
extern "system" fn(GLsync, GLbitfield, GLuint64),
>(p)(sync, flags, timeout);
if cfg!(debug_assertions) {
let err = glGetError();
if err != GL_NO_ERROR {
error!("glWaitSync({:?}, {:?}, {:?}): {}", sync, flags, timeout, err);
}
}
out
}
}
mod storage {
use super::*;
pub static ActiveTexture: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static AttachShader: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BeginConditionalRender: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static BeginQuery: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BeginTransformFeedback: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static BindAttribLocation: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindBufferBase: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindBufferRange: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindFragDataLocation: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static BindFragDataLocationIndexed: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static BindFramebuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindRenderbuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindSampler: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindTexture: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BindVertexArray: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BlendColor: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BlendEquation: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BlendEquationSeparate: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static BlendFunc: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BlendFuncSeparate: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BlitFramebuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BufferData: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static BufferSubData: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CheckFramebufferStatus: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static ClampColor: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Clear: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearBufferfi: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearBufferfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearBufferiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearBufferuiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearColor: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearDepth: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClearStencil: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ClientWaitSync: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ColorMask: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ColorMaski: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static ColorP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static ColorP3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static ColorP4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static ColorP4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CompileShader: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CompressedTexImage1D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static CompressedTexImage2D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static CompressedTexImage3D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static CompressedTexSubImage1D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static CompressedTexSubImage2D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static CompressedTexSubImage3D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static CopyBufferSubData: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CopyTexImage1D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CopyTexImage2D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CopyTexSubImage1D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CopyTexSubImage2D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CopyTexSubImage3D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CreateProgram: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CreateShader: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static CullFace: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteBuffers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteFramebuffers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteProgram: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteQueries: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteRenderbuffers: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static DeleteSamplers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteShader: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteSync: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteTextures: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DeleteVertexArrays: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DepthFunc: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DepthMask: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DepthRange: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DetachShader: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Disable: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DisableVertexAttribArray: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static Disablei: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DrawArrays: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DrawArraysInstanced: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static DrawBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DrawBuffers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DrawElements: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DrawElementsBaseVertex: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static DrawElementsInstanced: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static DrawElementsInstancedBaseVertex: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static DrawRangeElements: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static DrawRangeElementsBaseVertex: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static Enable: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static EnableVertexAttribArray: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static Enablei: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static EndConditionalRender: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static EndQuery: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static EndTransformFeedback: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FenceSync: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Finish: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Flush: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static FlushMappedBufferRange: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FramebufferRenderbuffer: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FramebufferTexture: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static FramebufferTexture1D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FramebufferTexture2D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FramebufferTexture3D: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FramebufferTextureLayer: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static FrontFace: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenBuffers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenFramebuffers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenQueries: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenRenderbuffers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenSamplers: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenTextures: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenVertexArrays: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GenerateMipmap: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetActiveAttrib: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetActiveUniform: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetActiveUniformBlockName: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetActiveUniformBlockiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetActiveUniformName: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetActiveUniformsiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetAttachedShaders: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetAttribLocation: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetBooleani_v: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetBooleanv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetBufferParameteri64v: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetBufferParameteriv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetBufferPointerv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetBufferSubData: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetCompressedTexImage: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetDoublev: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetError: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetFloatv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetFragDataIndex: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetFragDataLocation: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetFramebufferAttachmentParameteriv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetInteger64i_v: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetInteger64v: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetIntegeri_v: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetIntegerv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetMultisamplefv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetProgramInfoLog: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetProgramiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetQueryObjecti64v: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetQueryObjectiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetQueryObjectui64v: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetQueryObjectuiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetQueryiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetRenderbufferParameteriv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetSamplerParameterIiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetSamplerParameterIuiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetSamplerParameterfv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetSamplerParameteriv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetShaderInfoLog: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetShaderSource: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetShaderiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetString: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetStringi: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetSynciv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetTexImage: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetTexLevelParameterfv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetTexLevelParameteriv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetTexParameterIiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetTexParameterIuiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetTexParameterfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetTexParameteriv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetTransformFeedbackVarying: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetUniformBlockIndex: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetUniformIndices: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetUniformLocation: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetUniformfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetUniformiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetUniformuiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetVertexAttribIiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetVertexAttribIuiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetVertexAttribPointerv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static GetVertexAttribdv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetVertexAttribfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static GetVertexAttribiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Hint: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsEnabled: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsEnabledi: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsFramebuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsProgram: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsQuery: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsRenderbuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsSampler: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsShader: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsSync: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsTexture: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static IsVertexArray: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static LineWidth: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static LinkProgram: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static LogicOp: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static MapBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static MapBufferRange: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static MultiDrawArrays: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static MultiDrawElements: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static MultiDrawElementsBaseVertex: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP1ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP1uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP2ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP2uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static MultiTexCoordP4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static NormalP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static NormalP3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PixelStoref: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PixelStorei: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PointParameterf: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PointParameterfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PointParameteri: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PointParameteriv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PointSize: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PolygonMode: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PolygonOffset: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static PrimitiveRestartIndex: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static ProvokingVertex: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static QueryCounter: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ReadBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ReadPixels: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static RenderbufferStorage: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static RenderbufferStorageMultisample: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static SampleCoverage: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static SampleMaski: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static SamplerParameterIiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static SamplerParameterIuiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static SamplerParameterf: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static SamplerParameterfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static SamplerParameteri: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static SamplerParameteriv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Scissor: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static SecondaryColorP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static SecondaryColorP3uiv: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static ShaderSource: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static StencilFunc: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static StencilFuncSeparate: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static StencilMask: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static StencilMaskSeparate: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static StencilOp: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static StencilOpSeparate: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP1ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP1uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP2ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP2uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static TexCoordP4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexImage1D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexImage2D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexImage2DMultisample: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static TexImage3D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexImage3DMultisample: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static TexParameterIiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexParameterIuiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexParameterf: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexParameterfv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexParameteri: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexParameteriv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexSubImage1D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexSubImage2D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TexSubImage3D: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static TransformFeedbackVaryings: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static Uniform1f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform1fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform1i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform1iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform1ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform1uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform2f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform2fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform2i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform2iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform2ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform2uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform3f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform3fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform3i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform3iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform4f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform4fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform4i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform4iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Uniform4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformBlockBinding: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static UniformMatrix2fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix2x3fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix2x4fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix3fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix3x2fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix3x4fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix4fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix4x2fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UniformMatrix4x3fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UnmapBuffer: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static UseProgram: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static ValidateProgram: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib1d: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib1dv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib1f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib1fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib1s: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib1sv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib2d: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib2dv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib2f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib2fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib2s: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib2sv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib3d: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib3dv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib3f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib3fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib3s: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib3sv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Nbv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Niv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Nsv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Nub: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Nubv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Nuiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4Nusv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4bv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4d: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4dv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4f: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4fv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4s: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4sv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4ubv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttrib4usv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribDivisor: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static VertexAttribI1i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI1iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI1ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI1uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI2i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI2iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI2ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI2uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI3i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI3iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4bv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4i: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4iv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4sv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4ubv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribI4usv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribIPointer: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
pub static VertexAttribP1ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP1uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP2ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP2uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribP4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static VertexAttribPointer: AtomicPtr<c_void> =
AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static VertexP2ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static VertexP2uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static VertexP3ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static VertexP3uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static VertexP4ui: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
#[cfg(feature = "compatibility_profile")]
pub static VertexP4uiv: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static Viewport: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
pub static WaitSync: AtomicPtr<c_void> = AtomicPtr::new(null_mut());
}
#[doc(hidden)]
pub mod ActiveTexture {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ActiveTexture.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glActiveTexture\0", b"glActiveTextureARB\0"],
) {
storage::ActiveTexture.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod AttachShader {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::AttachShader.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glAttachShader\0", b"glAttachObjectARB\0"])
{
storage::AttachShader.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BeginConditionalRender {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BeginConditionalRender.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBeginConditionalRender\0", b"glBeginConditionalRenderNV\0"],
) {
storage::BeginConditionalRender.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BeginQuery {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BeginQuery.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glBeginQuery\0", b"glBeginQueryARB\0"])
{
storage::BeginQuery.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BeginTransformFeedback {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BeginTransformFeedback.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glBeginTransformFeedback\0",
b"glBeginTransformFeedbackEXT\0",
b"glBeginTransformFeedbackNV\0",
],
) {
storage::BeginTransformFeedback.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindAttribLocation {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindAttribLocation.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBindAttribLocation\0", b"glBindAttribLocationARB\0"],
) {
storage::BindAttribLocation.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glBindBuffer\0", b"glBindBufferARB\0"])
{
storage::BindBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindBufferBase {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindBufferBase.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glBindBufferBase\0",
b"glBindBufferBaseEXT\0",
b"glBindBufferBaseNV\0",
],
) {
storage::BindBufferBase.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindBufferRange {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindBufferRange.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glBindBufferRange\0",
b"glBindBufferRangeEXT\0",
b"glBindBufferRangeNV\0",
],
) {
storage::BindBufferRange.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindFragDataLocation {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindFragDataLocation.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBindFragDataLocation\0", b"glBindFragDataLocationEXT\0"],
) {
storage::BindFragDataLocation.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindFragDataLocationIndexed {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindFragDataLocationIndexed.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glBindFragDataLocationIndexed\0",
b"glBindFragDataLocationIndexedEXT\0",
],
) {
storage::BindFragDataLocationIndexed.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindFramebuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindFramebuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glBindFramebuffer\0"]) {
storage::BindFramebuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindRenderbuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindRenderbuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glBindRenderbuffer\0"]) {
storage::BindRenderbuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindSampler {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindSampler.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glBindSampler\0"]) {
storage::BindSampler.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindTexture {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindTexture.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glBindTexture\0", b"glBindTextureEXT\0"])
{
storage::BindTexture.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BindVertexArray {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BindVertexArray.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBindVertexArray\0", b"glBindVertexArrayOES\0"],
) {
storage::BindVertexArray.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BlendColor {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BlendColor.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glBlendColor\0", b"glBlendColorEXT\0"])
{
storage::BlendColor.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BlendEquation {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BlendEquation.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBlendEquation\0", b"glBlendEquationEXT\0"],
) {
storage::BlendEquation.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BlendEquationSeparate {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BlendEquationSeparate.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBlendEquationSeparate\0", b"glBlendEquationSeparateEXT\0"],
) {
storage::BlendEquationSeparate.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BlendFunc {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BlendFunc.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glBlendFunc\0"]) {
storage::BlendFunc.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BlendFuncSeparate {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BlendFuncSeparate.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glBlendFuncSeparate\0",
b"glBlendFuncSeparateEXT\0",
b"glBlendFuncSeparateINGR\0",
],
) {
storage::BlendFuncSeparate.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BlitFramebuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BlitFramebuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glBlitFramebuffer\0",
b"glBlitFramebufferEXT\0",
b"glBlitFramebufferNV\0",
],
) {
storage::BlitFramebuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BufferData {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BufferData.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glBufferData\0", b"glBufferDataARB\0"])
{
storage::BufferData.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod BufferSubData {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::BufferSubData.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glBufferSubData\0", b"glBufferSubDataARB\0"],
) {
storage::BufferSubData.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CheckFramebufferStatus {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CheckFramebufferStatus.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCheckFramebufferStatus\0", b"glCheckFramebufferStatusEXT\0"],
) {
storage::CheckFramebufferStatus.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClampColor {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClampColor.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glClampColor\0", b"glClampColorARB\0"])
{
storage::ClampColor.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Clear {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Clear.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClear\0"]) {
storage::Clear.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearBufferfi {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearBufferfi.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearBufferfi\0"]) {
storage::ClearBufferfi.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearBufferfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearBufferfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearBufferfv\0"]) {
storage::ClearBufferfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearBufferiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearBufferiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearBufferiv\0"]) {
storage::ClearBufferiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearBufferuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearBufferuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearBufferuiv\0"]) {
storage::ClearBufferuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearColor {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearColor.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearColor\0"]) {
storage::ClearColor.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearDepth {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearDepth.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearDepth\0"]) {
storage::ClearDepth.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClearStencil {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClearStencil.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glClearStencil\0"]) {
storage::ClearStencil.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ClientWaitSync {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ClientWaitSync.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glClientWaitSync\0", b"glClientWaitSyncAPPLE\0"],
) {
storage::ClientWaitSync.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ColorMask {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ColorMask.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glColorMask\0"]) {
storage::ColorMask.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ColorMaski {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ColorMaski.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glColorMaski\0",
b"glColorMaskIndexedEXT\0",
b"glColorMaskiEXT\0",
b"glColorMaskiOES\0",
],
) {
storage::ColorMaski.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod ColorP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ColorP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glColorP3ui\0"]) {
storage::ColorP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod ColorP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ColorP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glColorP3uiv\0"]) {
storage::ColorP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod ColorP4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ColorP4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glColorP4ui\0"]) {
storage::ColorP4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod ColorP4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ColorP4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glColorP4uiv\0"]) {
storage::ColorP4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompileShader {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompileShader.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompileShader\0", b"glCompileShaderARB\0"],
) {
storage::CompileShader.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompressedTexImage1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompressedTexImage1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompressedTexImage1D\0", b"glCompressedTexImage1DARB\0"],
) {
storage::CompressedTexImage1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompressedTexImage2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompressedTexImage2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompressedTexImage2D\0", b"glCompressedTexImage2DARB\0"],
) {
storage::CompressedTexImage2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompressedTexImage3D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompressedTexImage3D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompressedTexImage3D\0", b"glCompressedTexImage3DARB\0"],
) {
storage::CompressedTexImage3D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompressedTexSubImage1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompressedTexSubImage1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompressedTexSubImage1D\0", b"glCompressedTexSubImage1DARB\0"],
) {
storage::CompressedTexSubImage1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompressedTexSubImage2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompressedTexSubImage2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompressedTexSubImage2D\0", b"glCompressedTexSubImage2DARB\0"],
) {
storage::CompressedTexSubImage2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CompressedTexSubImage3D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CompressedTexSubImage3D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCompressedTexSubImage3D\0", b"glCompressedTexSubImage3DARB\0"],
) {
storage::CompressedTexSubImage3D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CopyBufferSubData {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CopyBufferSubData.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCopyBufferSubData\0", b"glCopyBufferSubDataNV\0"],
) {
storage::CopyBufferSubData.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CopyTexImage1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CopyTexImage1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCopyTexImage1D\0", b"glCopyTexImage1DEXT\0"],
) {
storage::CopyTexImage1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CopyTexImage2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CopyTexImage2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCopyTexImage2D\0", b"glCopyTexImage2DEXT\0"],
) {
storage::CopyTexImage2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CopyTexSubImage1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CopyTexSubImage1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCopyTexSubImage1D\0", b"glCopyTexSubImage1DEXT\0"],
) {
storage::CopyTexSubImage1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CopyTexSubImage2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CopyTexSubImage2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCopyTexSubImage2D\0", b"glCopyTexSubImage2DEXT\0"],
) {
storage::CopyTexSubImage2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CopyTexSubImage3D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CopyTexSubImage3D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCopyTexSubImage3D\0", b"glCopyTexSubImage3DEXT\0"],
) {
storage::CopyTexSubImage3D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CreateProgram {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CreateProgram.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCreateProgram\0", b"glCreateProgramObjectARB\0"],
) {
storage::CreateProgram.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CreateShader {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CreateShader.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glCreateShader\0", b"glCreateShaderObjectARB\0"],
) {
storage::CreateShader.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod CullFace {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::CullFace.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glCullFace\0"]) {
storage::CullFace.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteBuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteBuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glDeleteBuffers\0", b"glDeleteBuffersARB\0"],
) {
storage::DeleteBuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteFramebuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteFramebuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glDeleteFramebuffers\0", b"glDeleteFramebuffersEXT\0"],
) {
storage::DeleteFramebuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteProgram {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteProgram.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDeleteProgram\0"]) {
storage::DeleteProgram.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteQueries {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteQueries.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glDeleteQueries\0", b"glDeleteQueriesARB\0"],
) {
storage::DeleteQueries.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteRenderbuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteRenderbuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glDeleteRenderbuffers\0", b"glDeleteRenderbuffersEXT\0"],
) {
storage::DeleteRenderbuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteSamplers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteSamplers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDeleteSamplers\0"]) {
storage::DeleteSamplers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteShader {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteShader.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDeleteShader\0"]) {
storage::DeleteShader.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteSync {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteSync.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glDeleteSync\0", b"glDeleteSyncAPPLE\0"])
{
storage::DeleteSync.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteTextures {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteTextures.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDeleteTextures\0"]) {
storage::DeleteTextures.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DeleteVertexArrays {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DeleteVertexArrays.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDeleteVertexArrays\0",
b"glDeleteVertexArraysAPPLE\0",
b"glDeleteVertexArraysOES\0",
],
) {
storage::DeleteVertexArrays.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DepthFunc {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DepthFunc.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDepthFunc\0"]) {
storage::DepthFunc.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DepthMask {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DepthMask.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDepthMask\0"]) {
storage::DepthMask.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DepthRange {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DepthRange.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDepthRange\0"]) {
storage::DepthRange.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DetachShader {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DetachShader.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glDetachShader\0", b"glDetachObjectARB\0"])
{
storage::DetachShader.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Disable {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Disable.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDisable\0"]) {
storage::Disable.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DisableVertexAttribArray {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DisableVertexAttribArray.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glDisableVertexAttribArray\0", b"glDisableVertexAttribArrayARB\0"],
) {
storage::DisableVertexAttribArray.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Disablei {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Disablei.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDisablei\0",
b"glDisableIndexedEXT\0",
b"glDisableiEXT\0",
b"glDisableiNV\0",
b"glDisableiOES\0",
],
) {
storage::Disablei.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawArrays {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawArrays.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glDrawArrays\0", b"glDrawArraysEXT\0"])
{
storage::DrawArrays.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawArraysInstanced {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawArraysInstanced.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDrawArraysInstanced\0",
b"glDrawArraysInstancedANGLE\0",
b"glDrawArraysInstancedARB\0",
b"glDrawArraysInstancedEXT\0",
b"glDrawArraysInstancedNV\0",
],
) {
storage::DrawArraysInstanced.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDrawBuffer\0"]) {
storage::DrawBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawBuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawBuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDrawBuffers\0",
b"glDrawBuffersARB\0",
b"glDrawBuffersATI\0",
b"glDrawBuffersEXT\0",
],
) {
storage::DrawBuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawElements {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawElements.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glDrawElements\0"]) {
storage::DrawElements.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawElementsBaseVertex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawElementsBaseVertex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDrawElementsBaseVertex\0",
b"glDrawElementsBaseVertexEXT\0",
b"glDrawElementsBaseVertexOES\0",
],
) {
storage::DrawElementsBaseVertex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawElementsInstanced {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawElementsInstanced.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDrawElementsInstanced\0",
b"glDrawElementsInstancedANGLE\0",
b"glDrawElementsInstancedARB\0",
b"glDrawElementsInstancedEXT\0",
b"glDrawElementsInstancedNV\0",
],
) {
storage::DrawElementsInstanced.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawElementsInstancedBaseVertex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawElementsInstancedBaseVertex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDrawElementsInstancedBaseVertex\0",
b"glDrawElementsInstancedBaseVertexEXT\0",
b"glDrawElementsInstancedBaseVertexOES\0",
],
) {
storage::DrawElementsInstancedBaseVertex
.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawRangeElements {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawRangeElements.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glDrawRangeElements\0", b"glDrawRangeElementsEXT\0"],
) {
storage::DrawRangeElements.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod DrawRangeElementsBaseVertex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::DrawRangeElementsBaseVertex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glDrawRangeElementsBaseVertex\0",
b"glDrawRangeElementsBaseVertexEXT\0",
b"glDrawRangeElementsBaseVertexOES\0",
],
) {
storage::DrawRangeElementsBaseVertex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Enable {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Enable.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glEnable\0"]) {
storage::Enable.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod EnableVertexAttribArray {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::EnableVertexAttribArray.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glEnableVertexAttribArray\0", b"glEnableVertexAttribArrayARB\0"],
) {
storage::EnableVertexAttribArray.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Enablei {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Enablei.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glEnablei\0",
b"glEnableIndexedEXT\0",
b"glEnableiEXT\0",
b"glEnableiNV\0",
b"glEnableiOES\0",
],
) {
storage::Enablei.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod EndConditionalRender {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::EndConditionalRender.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glEndConditionalRender\0",
b"glEndConditionalRenderNV\0",
b"glEndConditionalRenderNVX\0",
],
) {
storage::EndConditionalRender.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod EndQuery {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::EndQuery.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glEndQuery\0", b"glEndQueryARB\0"])
{
storage::EndQuery.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod EndTransformFeedback {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::EndTransformFeedback.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glEndTransformFeedback\0",
b"glEndTransformFeedbackEXT\0",
b"glEndTransformFeedbackNV\0",
],
) {
storage::EndTransformFeedback.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FenceSync {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FenceSync.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glFenceSync\0", b"glFenceSyncAPPLE\0"])
{
storage::FenceSync.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Finish {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Finish.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glFinish\0"]) {
storage::Finish.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Flush {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Flush.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glFlush\0"]) {
storage::Flush.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FlushMappedBufferRange {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FlushMappedBufferRange.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glFlushMappedBufferRange\0",
b"glFlushMappedBufferRangeAPPLE\0",
b"glFlushMappedBufferRangeEXT\0",
],
) {
storage::FlushMappedBufferRange.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FramebufferRenderbuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FramebufferRenderbuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glFramebufferRenderbuffer\0", b"glFramebufferRenderbufferEXT\0"],
) {
storage::FramebufferRenderbuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FramebufferTexture {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FramebufferTexture.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glFramebufferTexture\0",
b"glFramebufferTextureARB\0",
b"glFramebufferTextureEXT\0",
b"glFramebufferTextureOES\0",
],
) {
storage::FramebufferTexture.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FramebufferTexture1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FramebufferTexture1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glFramebufferTexture1D\0", b"glFramebufferTexture1DEXT\0"],
) {
storage::FramebufferTexture1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FramebufferTexture2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FramebufferTexture2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glFramebufferTexture2D\0", b"glFramebufferTexture2DEXT\0"],
) {
storage::FramebufferTexture2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FramebufferTexture3D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FramebufferTexture3D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glFramebufferTexture3D\0", b"glFramebufferTexture3DEXT\0"],
) {
storage::FramebufferTexture3D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FramebufferTextureLayer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FramebufferTextureLayer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glFramebufferTextureLayer\0",
b"glFramebufferTextureLayerARB\0",
b"glFramebufferTextureLayerEXT\0",
],
) {
storage::FramebufferTextureLayer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod FrontFace {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::FrontFace.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glFrontFace\0"]) {
storage::FrontFace.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenBuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenBuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGenBuffers\0", b"glGenBuffersARB\0"])
{
storage::GenBuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenFramebuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenFramebuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGenFramebuffers\0", b"glGenFramebuffersEXT\0"],
) {
storage::GenFramebuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenQueries {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenQueries.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGenQueries\0", b"glGenQueriesARB\0"])
{
storage::GenQueries.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenRenderbuffers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenRenderbuffers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGenRenderbuffers\0", b"glGenRenderbuffersEXT\0"],
) {
storage::GenRenderbuffers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenSamplers {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenSamplers.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGenSamplers\0"]) {
storage::GenSamplers.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenTextures {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenTextures.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGenTextures\0"]) {
storage::GenTextures.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenVertexArrays {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenVertexArrays.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGenVertexArrays\0",
b"glGenVertexArraysAPPLE\0",
b"glGenVertexArraysOES\0",
],
) {
storage::GenVertexArrays.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GenerateMipmap {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GenerateMipmap.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGenerateMipmap\0", b"glGenerateMipmapEXT\0"],
) {
storage::GenerateMipmap.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetActiveAttrib {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetActiveAttrib.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetActiveAttrib\0", b"glGetActiveAttribARB\0"],
) {
storage::GetActiveAttrib.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetActiveUniform {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetActiveUniform.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetActiveUniform\0", b"glGetActiveUniformARB\0"],
) {
storage::GetActiveUniform.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetActiveUniformBlockName {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetActiveUniformBlockName.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGetActiveUniformBlockName\0"])
{
storage::GetActiveUniformBlockName.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetActiveUniformBlockiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetActiveUniformBlockiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGetActiveUniformBlockiv\0"])
{
storage::GetActiveUniformBlockiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetActiveUniformName {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetActiveUniformName.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetActiveUniformName\0"]) {
storage::GetActiveUniformName.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetActiveUniformsiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetActiveUniformsiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetActiveUniformsiv\0"]) {
storage::GetActiveUniformsiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetAttachedShaders {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetAttachedShaders.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetAttachedShaders\0"]) {
storage::GetAttachedShaders.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetAttribLocation {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetAttribLocation.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetAttribLocation\0", b"glGetAttribLocationARB\0"],
) {
storage::GetAttribLocation.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetBooleani_v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetBooleani_v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetBooleani_v\0", b"glGetBooleanIndexedvEXT\0"],
) {
storage::GetBooleani_v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetBooleanv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetBooleanv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetBooleanv\0"]) {
storage::GetBooleanv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetBufferParameteri64v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetBufferParameteri64v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetBufferParameteri64v\0"])
{
storage::GetBufferParameteri64v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetBufferParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetBufferParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetBufferParameteriv\0", b"glGetBufferParameterivARB\0"],
) {
storage::GetBufferParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetBufferPointerv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetBufferPointerv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetBufferPointerv\0",
b"glGetBufferPointervARB\0",
b"glGetBufferPointervOES\0",
],
) {
storage::GetBufferPointerv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetBufferSubData {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetBufferSubData.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetBufferSubData\0", b"glGetBufferSubDataARB\0"],
) {
storage::GetBufferSubData.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetCompressedTexImage {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetCompressedTexImage.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetCompressedTexImage\0", b"glGetCompressedTexImageARB\0"],
) {
storage::GetCompressedTexImage.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetDoublev {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetDoublev.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetDoublev\0"]) {
storage::GetDoublev.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetError {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetError.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetError\0"]) {
storage::GetError.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetFloatv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetFloatv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetFloatv\0"]) {
storage::GetFloatv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetFragDataIndex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetFragDataIndex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetFragDataIndex\0", b"glGetFragDataIndexEXT\0"],
) {
storage::GetFragDataIndex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetFragDataLocation {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetFragDataLocation.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetFragDataLocation\0", b"glGetFragDataLocationEXT\0"],
) {
storage::GetFragDataLocation.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetFramebufferAttachmentParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetFramebufferAttachmentParameteriv
.load(Ordering::Relaxed)
.is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetFramebufferAttachmentParameteriv\0",
b"glGetFramebufferAttachmentParameterivEXT\0",
],
) {
storage::GetFramebufferAttachmentParameteriv
.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetInteger64i_v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetInteger64i_v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetInteger64i_v\0"]) {
storage::GetInteger64i_v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetInteger64v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetInteger64v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetInteger64v\0", b"glGetInteger64vAPPLE\0"],
) {
storage::GetInteger64v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetIntegeri_v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetIntegeri_v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetIntegeri_v\0", b"glGetIntegerIndexedvEXT\0"],
) {
storage::GetIntegeri_v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetIntegerv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetIntegerv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetIntegerv\0"]) {
storage::GetIntegerv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetMultisamplefv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetMultisamplefv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetMultisamplefv\0", b"glGetMultisamplefvNV\0"],
) {
storage::GetMultisamplefv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetProgramInfoLog {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetProgramInfoLog.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetProgramInfoLog\0"]) {
storage::GetProgramInfoLog.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetProgramiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetProgramiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetProgramiv\0"]) {
storage::GetProgramiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetQueryObjecti64v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetQueryObjecti64v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetQueryObjecti64v\0", b"glGetQueryObjecti64vEXT\0"],
) {
storage::GetQueryObjecti64v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetQueryObjectiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetQueryObjectiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetQueryObjectiv\0",
b"glGetQueryObjectivARB\0",
b"glGetQueryObjectivEXT\0",
],
) {
storage::GetQueryObjectiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetQueryObjectui64v {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetQueryObjectui64v.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetQueryObjectui64v\0", b"glGetQueryObjectui64vEXT\0"],
) {
storage::GetQueryObjectui64v.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetQueryObjectuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetQueryObjectuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetQueryObjectuiv\0", b"glGetQueryObjectuivARB\0"],
) {
storage::GetQueryObjectuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetQueryiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetQueryiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGetQueryiv\0", b"glGetQueryivARB\0"])
{
storage::GetQueryiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetRenderbufferParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetRenderbufferParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetRenderbufferParameteriv\0",
b"glGetRenderbufferParameterivEXT\0",
],
) {
storage::GetRenderbufferParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetSamplerParameterIiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetSamplerParameterIiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetSamplerParameterIiv\0",
b"glGetSamplerParameterIivEXT\0",
b"glGetSamplerParameterIivOES\0",
],
) {
storage::GetSamplerParameterIiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetSamplerParameterIuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetSamplerParameterIuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetSamplerParameterIuiv\0",
b"glGetSamplerParameterIuivEXT\0",
b"glGetSamplerParameterIuivOES\0",
],
) {
storage::GetSamplerParameterIuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetSamplerParameterfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetSamplerParameterfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetSamplerParameterfv\0"])
{
storage::GetSamplerParameterfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetSamplerParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetSamplerParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetSamplerParameteriv\0"])
{
storage::GetSamplerParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetShaderInfoLog {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetShaderInfoLog.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetShaderInfoLog\0"]) {
storage::GetShaderInfoLog.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetShaderSource {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetShaderSource.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetShaderSource\0", b"glGetShaderSourceARB\0"],
) {
storage::GetShaderSource.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetShaderiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetShaderiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetShaderiv\0"]) {
storage::GetShaderiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetString {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetString.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetString\0"]) {
storage::GetString.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetStringi {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetStringi.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetStringi\0"]) {
storage::GetStringi.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetSynciv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetSynciv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGetSynciv\0", b"glGetSyncivAPPLE\0"])
{
storage::GetSynciv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexImage {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexImage.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetTexImage\0"]) {
storage::GetTexImage.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexLevelParameterfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexLevelParameterfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetTexLevelParameterfv\0"])
{
storage::GetTexLevelParameterfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexLevelParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexLevelParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetTexLevelParameteriv\0"])
{
storage::GetTexLevelParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexParameterIiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexParameterIiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetTexParameterIiv\0",
b"glGetTexParameterIivEXT\0",
b"glGetTexParameterIivOES\0",
],
) {
storage::GetTexParameterIiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexParameterIuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexParameterIuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetTexParameterIuiv\0",
b"glGetTexParameterIuivEXT\0",
b"glGetTexParameterIuivOES\0",
],
) {
storage::GetTexParameterIuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexParameterfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexParameterfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetTexParameterfv\0"]) {
storage::GetTexParameterfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTexParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTexParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetTexParameteriv\0"]) {
storage::GetTexParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetTransformFeedbackVarying {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetTransformFeedbackVarying.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetTransformFeedbackVarying\0",
b"glGetTransformFeedbackVaryingEXT\0",
],
) {
storage::GetTransformFeedbackVarying.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetUniformBlockIndex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetUniformBlockIndex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetUniformBlockIndex\0"]) {
storage::GetUniformBlockIndex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetUniformIndices {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetUniformIndices.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glGetUniformIndices\0"]) {
storage::GetUniformIndices.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetUniformLocation {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetUniformLocation.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetUniformLocation\0", b"glGetUniformLocationARB\0"],
) {
storage::GetUniformLocation.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetUniformfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetUniformfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGetUniformfv\0", b"glGetUniformfvARB\0"])
{
storage::GetUniformfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetUniformiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetUniformiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glGetUniformiv\0", b"glGetUniformivARB\0"])
{
storage::GetUniformiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetUniformuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetUniformuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetUniformuiv\0", b"glGetUniformuivEXT\0"],
) {
storage::GetUniformuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetVertexAttribIiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetVertexAttribIiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetVertexAttribIiv\0", b"glGetVertexAttribIivEXT\0"],
) {
storage::GetVertexAttribIiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetVertexAttribIuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetVertexAttribIuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glGetVertexAttribIuiv\0", b"glGetVertexAttribIuivEXT\0"],
) {
storage::GetVertexAttribIuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetVertexAttribPointerv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetVertexAttribPointerv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetVertexAttribPointerv\0",
b"glGetVertexAttribPointervARB\0",
b"glGetVertexAttribPointervNV\0",
],
) {
storage::GetVertexAttribPointerv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetVertexAttribdv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetVertexAttribdv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetVertexAttribdv\0",
b"glGetVertexAttribdvARB\0",
b"glGetVertexAttribdvNV\0",
],
) {
storage::GetVertexAttribdv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetVertexAttribfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetVertexAttribfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetVertexAttribfv\0",
b"glGetVertexAttribfvARB\0",
b"glGetVertexAttribfvNV\0",
],
) {
storage::GetVertexAttribfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod GetVertexAttribiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::GetVertexAttribiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glGetVertexAttribiv\0",
b"glGetVertexAttribivARB\0",
b"glGetVertexAttribivNV\0",
],
) {
storage::GetVertexAttribiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Hint {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Hint.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glHint\0"]) {
storage::Hint.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glIsBuffer\0", b"glIsBufferARB\0"])
{
storage::IsBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsEnabled {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsEnabled.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glIsEnabled\0"]) {
storage::IsEnabled.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsEnabledi {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsEnabledi.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glIsEnabledi\0",
b"glIsEnabledIndexedEXT\0",
b"glIsEnablediEXT\0",
b"glIsEnablediNV\0",
b"glIsEnablediOES\0",
],
) {
storage::IsEnabledi.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsFramebuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsFramebuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glIsFramebuffer\0", b"glIsFramebufferEXT\0"],
) {
storage::IsFramebuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsProgram {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsProgram.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glIsProgram\0"]) {
storage::IsProgram.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsQuery {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsQuery.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glIsQuery\0", b"glIsQueryARB\0"])
{
storage::IsQuery.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsRenderbuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsRenderbuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glIsRenderbuffer\0", b"glIsRenderbufferEXT\0"],
) {
storage::IsRenderbuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsSampler {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsSampler.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glIsSampler\0"]) {
storage::IsSampler.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsShader {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsShader.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glIsShader\0"]) {
storage::IsShader.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsSync {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsSync.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glIsSync\0", b"glIsSyncAPPLE\0"])
{
storage::IsSync.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsTexture {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsTexture.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glIsTexture\0"]) {
storage::IsTexture.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod IsVertexArray {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::IsVertexArray.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glIsVertexArray\0",
b"glIsVertexArrayAPPLE\0",
b"glIsVertexArrayOES\0",
],
) {
storage::IsVertexArray.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod LineWidth {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::LineWidth.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glLineWidth\0"]) {
storage::LineWidth.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod LinkProgram {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::LinkProgram.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glLinkProgram\0", b"glLinkProgramARB\0"])
{
storage::LinkProgram.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod LogicOp {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::LogicOp.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glLogicOp\0"]) {
storage::LogicOp.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod MapBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MapBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glMapBuffer\0", b"glMapBufferARB\0", b"glMapBufferOES\0"],
) {
storage::MapBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod MapBufferRange {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MapBufferRange.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glMapBufferRange\0", b"glMapBufferRangeEXT\0"],
) {
storage::MapBufferRange.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod MultiDrawArrays {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiDrawArrays.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glMultiDrawArrays\0", b"glMultiDrawArraysEXT\0"],
) {
storage::MultiDrawArrays.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod MultiDrawElements {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiDrawElements.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glMultiDrawElements\0", b"glMultiDrawElementsEXT\0"],
) {
storage::MultiDrawElements.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod MultiDrawElementsBaseVertex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiDrawElementsBaseVertex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glMultiDrawElementsBaseVertex\0",
b"glMultiDrawElementsBaseVertexEXT\0",
],
) {
storage::MultiDrawElementsBaseVertex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP1ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP1ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP1ui\0"]) {
storage::MultiTexCoordP1ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP1uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP1uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP1uiv\0"]) {
storage::MultiTexCoordP1uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP2ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP2ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP2ui\0"]) {
storage::MultiTexCoordP2ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP2uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP2uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP2uiv\0"]) {
storage::MultiTexCoordP2uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP3ui\0"]) {
storage::MultiTexCoordP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP3uiv\0"]) {
storage::MultiTexCoordP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP4ui\0"]) {
storage::MultiTexCoordP4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod MultiTexCoordP4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::MultiTexCoordP4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glMultiTexCoordP4uiv\0"]) {
storage::MultiTexCoordP4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod NormalP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::NormalP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glNormalP3ui\0"]) {
storage::NormalP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod NormalP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::NormalP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glNormalP3uiv\0"]) {
storage::NormalP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PixelStoref {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PixelStoref.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glPixelStoref\0"]) {
storage::PixelStoref.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PixelStorei {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PixelStorei.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glPixelStorei\0"]) {
storage::PixelStorei.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PointParameterf {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PointParameterf.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glPointParameterf\0",
b"glPointParameterfARB\0",
b"glPointParameterfEXT\0",
b"glPointParameterfSGIS\0",
],
) {
storage::PointParameterf.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PointParameterfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PointParameterfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glPointParameterfv\0",
b"glPointParameterfvARB\0",
b"glPointParameterfvEXT\0",
b"glPointParameterfvSGIS\0",
],
) {
storage::PointParameterfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PointParameteri {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PointParameteri.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glPointParameteri\0", b"glPointParameteriNV\0"],
) {
storage::PointParameteri.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PointParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PointParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glPointParameteriv\0", b"glPointParameterivNV\0"],
) {
storage::PointParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PointSize {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PointSize.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glPointSize\0"]) {
storage::PointSize.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PolygonMode {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PolygonMode.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glPolygonMode\0", b"glPolygonModeNV\0"])
{
storage::PolygonMode.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PolygonOffset {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PolygonOffset.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glPolygonOffset\0"]) {
storage::PolygonOffset.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod PrimitiveRestartIndex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::PrimitiveRestartIndex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glPrimitiveRestartIndex\0"])
{
storage::PrimitiveRestartIndex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ProvokingVertex {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ProvokingVertex.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glProvokingVertex\0", b"glProvokingVertexEXT\0"],
) {
storage::ProvokingVertex.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod QueryCounter {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::QueryCounter.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glQueryCounter\0", b"glQueryCounterEXT\0"])
{
storage::QueryCounter.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ReadBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ReadBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glReadBuffer\0"]) {
storage::ReadBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ReadPixels {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ReadPixels.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glReadPixels\0"]) {
storage::ReadPixels.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod RenderbufferStorage {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::RenderbufferStorage.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glRenderbufferStorage\0", b"glRenderbufferStorageEXT\0"],
) {
storage::RenderbufferStorage.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod RenderbufferStorageMultisample {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::RenderbufferStorageMultisample.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glRenderbufferStorageMultisample\0",
b"glRenderbufferStorageMultisampleEXT\0",
b"glRenderbufferStorageMultisampleNV\0",
],
) {
storage::RenderbufferStorageMultisample
.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SampleCoverage {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SampleCoverage.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glSampleCoverage\0", b"glSampleCoverageARB\0"],
) {
storage::SampleCoverage.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SampleMaski {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SampleMaski.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSampleMaski\0"]) {
storage::SampleMaski.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SamplerParameterIiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SamplerParameterIiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glSamplerParameterIiv\0",
b"glSamplerParameterIivEXT\0",
b"glSamplerParameterIivOES\0",
],
) {
storage::SamplerParameterIiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SamplerParameterIuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SamplerParameterIuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glSamplerParameterIuiv\0",
b"glSamplerParameterIuivEXT\0",
b"glSamplerParameterIuivOES\0",
],
) {
storage::SamplerParameterIuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SamplerParameterf {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SamplerParameterf.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSamplerParameterf\0"]) {
storage::SamplerParameterf.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SamplerParameterfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SamplerParameterfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSamplerParameterfv\0"]) {
storage::SamplerParameterfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SamplerParameteri {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SamplerParameteri.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSamplerParameteri\0"]) {
storage::SamplerParameteri.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod SamplerParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SamplerParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSamplerParameteriv\0"]) {
storage::SamplerParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Scissor {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Scissor.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glScissor\0"]) {
storage::Scissor.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod SecondaryColorP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SecondaryColorP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSecondaryColorP3ui\0"]) {
storage::SecondaryColorP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod SecondaryColorP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::SecondaryColorP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glSecondaryColorP3uiv\0"]) {
storage::SecondaryColorP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ShaderSource {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ShaderSource.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glShaderSource\0", b"glShaderSourceARB\0"])
{
storage::ShaderSource.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod StencilFunc {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::StencilFunc.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glStencilFunc\0"]) {
storage::StencilFunc.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod StencilFuncSeparate {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::StencilFuncSeparate.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glStencilFuncSeparate\0"]) {
storage::StencilFuncSeparate.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod StencilMask {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::StencilMask.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glStencilMask\0"]) {
storage::StencilMask.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod StencilMaskSeparate {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::StencilMaskSeparate.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glStencilMaskSeparate\0"]) {
storage::StencilMaskSeparate.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod StencilOp {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::StencilOp.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glStencilOp\0"]) {
storage::StencilOp.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod StencilOpSeparate {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::StencilOpSeparate.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glStencilOpSeparate\0", b"glStencilOpSeparateATI\0"],
) {
storage::StencilOpSeparate.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glTexBuffer\0",
b"glTexBufferARB\0",
b"glTexBufferEXT\0",
b"glTexBufferOES\0",
],
) {
storage::TexBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP1ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP1ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP1ui\0"]) {
storage::TexCoordP1ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP1uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP1uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP1uiv\0"]) {
storage::TexCoordP1uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP2ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP2ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP2ui\0"]) {
storage::TexCoordP2ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP2uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP2uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP2uiv\0"]) {
storage::TexCoordP2uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP3ui\0"]) {
storage::TexCoordP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP3uiv\0"]) {
storage::TexCoordP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP4ui\0"]) {
storage::TexCoordP4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod TexCoordP4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexCoordP4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexCoordP4uiv\0"]) {
storage::TexCoordP4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexImage1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexImage1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexImage1D\0"]) {
storage::TexImage1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexImage2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexImage2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexImage2D\0"]) {
storage::TexImage2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexImage2DMultisample {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexImage2DMultisample.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexImage2DMultisample\0"])
{
storage::TexImage2DMultisample.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexImage3D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexImage3D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glTexImage3D\0", b"glTexImage3DEXT\0"])
{
storage::TexImage3D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexImage3DMultisample {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexImage3DMultisample.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexImage3DMultisample\0"])
{
storage::TexImage3DMultisample.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexParameterIiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexParameterIiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glTexParameterIiv\0",
b"glTexParameterIivEXT\0",
b"glTexParameterIivOES\0",
],
) {
storage::TexParameterIiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexParameterIuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexParameterIuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glTexParameterIuiv\0",
b"glTexParameterIuivEXT\0",
b"glTexParameterIuivOES\0",
],
) {
storage::TexParameterIuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexParameterf {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexParameterf.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexParameterf\0"]) {
storage::TexParameterf.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexParameterfv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexParameterfv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexParameterfv\0"]) {
storage::TexParameterfv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexParameteri {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexParameteri.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexParameteri\0"]) {
storage::TexParameteri.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexParameteriv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexParameteriv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glTexParameteriv\0"]) {
storage::TexParameteriv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexSubImage1D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexSubImage1D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glTexSubImage1D\0", b"glTexSubImage1DEXT\0"],
) {
storage::TexSubImage1D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexSubImage2D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexSubImage2D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glTexSubImage2D\0", b"glTexSubImage2DEXT\0"],
) {
storage::TexSubImage2D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TexSubImage3D {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TexSubImage3D.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glTexSubImage3D\0", b"glTexSubImage3DEXT\0"],
) {
storage::TexSubImage3D.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod TransformFeedbackVaryings {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::TransformFeedbackVaryings.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glTransformFeedbackVaryings\0", b"glTransformFeedbackVaryingsEXT\0"],
) {
storage::TransformFeedbackVaryings.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform1f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform1f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform1f\0", b"glUniform1fARB\0"])
{
storage::Uniform1f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform1fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform1fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform1fv\0", b"glUniform1fvARB\0"])
{
storage::Uniform1fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform1i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform1i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform1i\0", b"glUniform1iARB\0"])
{
storage::Uniform1i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform1iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform1iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform1iv\0", b"glUniform1ivARB\0"])
{
storage::Uniform1iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform1ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform1ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform1ui\0", b"glUniform1uiEXT\0"])
{
storage::Uniform1ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform1uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform1uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform1uiv\0", b"glUniform1uivEXT\0"])
{
storage::Uniform1uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform2f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform2f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform2f\0", b"glUniform2fARB\0"])
{
storage::Uniform2f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform2fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform2fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform2fv\0", b"glUniform2fvARB\0"])
{
storage::Uniform2fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform2i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform2i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform2i\0", b"glUniform2iARB\0"])
{
storage::Uniform2i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform2iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform2iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform2iv\0", b"glUniform2ivARB\0"])
{
storage::Uniform2iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform2ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform2ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform2ui\0", b"glUniform2uiEXT\0"])
{
storage::Uniform2ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform2uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform2uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform2uiv\0", b"glUniform2uivEXT\0"])
{
storage::Uniform2uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform3f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform3f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform3f\0", b"glUniform3fARB\0"])
{
storage::Uniform3f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform3fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform3fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform3fv\0", b"glUniform3fvARB\0"])
{
storage::Uniform3fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform3i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform3i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform3i\0", b"glUniform3iARB\0"])
{
storage::Uniform3i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform3iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform3iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform3iv\0", b"glUniform3ivARB\0"])
{
storage::Uniform3iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform3ui\0", b"glUniform3uiEXT\0"])
{
storage::Uniform3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform3uiv\0", b"glUniform3uivEXT\0"])
{
storage::Uniform3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform4f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform4f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform4f\0", b"glUniform4fARB\0"])
{
storage::Uniform4f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform4fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform4fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform4fv\0", b"glUniform4fvARB\0"])
{
storage::Uniform4fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform4i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform4i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform4i\0", b"glUniform4iARB\0"])
{
storage::Uniform4i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform4iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform4iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform4iv\0", b"glUniform4ivARB\0"])
{
storage::Uniform4iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform4ui\0", b"glUniform4uiEXT\0"])
{
storage::Uniform4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Uniform4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Uniform4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glUniform4uiv\0", b"glUniform4uivEXT\0"])
{
storage::Uniform4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformBlockBinding {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformBlockBinding.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glUniformBlockBinding\0"]) {
storage::UniformBlockBinding.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix2fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix2fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix2fv\0", b"glUniformMatrix2fvARB\0"],
) {
storage::UniformMatrix2fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix2x3fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix2x3fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix2x3fv\0", b"glUniformMatrix2x3fvNV\0"],
) {
storage::UniformMatrix2x3fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix2x4fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix2x4fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix2x4fv\0", b"glUniformMatrix2x4fvNV\0"],
) {
storage::UniformMatrix2x4fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix3fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix3fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix3fv\0", b"glUniformMatrix3fvARB\0"],
) {
storage::UniformMatrix3fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix3x2fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix3x2fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix3x2fv\0", b"glUniformMatrix3x2fvNV\0"],
) {
storage::UniformMatrix3x2fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix3x4fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix3x4fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix3x4fv\0", b"glUniformMatrix3x4fvNV\0"],
) {
storage::UniformMatrix3x4fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix4fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix4fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix4fv\0", b"glUniformMatrix4fvARB\0"],
) {
storage::UniformMatrix4fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix4x2fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix4x2fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix4x2fv\0", b"glUniformMatrix4x2fvNV\0"],
) {
storage::UniformMatrix4x2fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UniformMatrix4x3fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UniformMatrix4x3fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUniformMatrix4x3fv\0", b"glUniformMatrix4x3fvNV\0"],
) {
storage::UniformMatrix4x3fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UnmapBuffer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UnmapBuffer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUnmapBuffer\0", b"glUnmapBufferARB\0", b"glUnmapBufferOES\0"],
) {
storage::UnmapBuffer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod UseProgram {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::UseProgram.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glUseProgram\0", b"glUseProgramObjectARB\0"],
) {
storage::UseProgram.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod ValidateProgram {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::ValidateProgram.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glValidateProgram\0", b"glValidateProgramARB\0"],
) {
storage::ValidateProgram.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib1d {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib1d.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib1d\0",
b"glVertexAttrib1dARB\0",
b"glVertexAttrib1dNV\0",
],
) {
storage::VertexAttrib1d.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib1dv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib1dv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib1dv\0",
b"glVertexAttrib1dvARB\0",
b"glVertexAttrib1dvNV\0",
],
) {
storage::VertexAttrib1dv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib1f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib1f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib1f\0",
b"glVertexAttrib1fARB\0",
b"glVertexAttrib1fNV\0",
],
) {
storage::VertexAttrib1f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib1fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib1fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib1fv\0",
b"glVertexAttrib1fvARB\0",
b"glVertexAttrib1fvNV\0",
],
) {
storage::VertexAttrib1fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib1s {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib1s.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib1s\0",
b"glVertexAttrib1sARB\0",
b"glVertexAttrib1sNV\0",
],
) {
storage::VertexAttrib1s.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib1sv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib1sv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib1sv\0",
b"glVertexAttrib1svARB\0",
b"glVertexAttrib1svNV\0",
],
) {
storage::VertexAttrib1sv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib2d {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib2d.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib2d\0",
b"glVertexAttrib2dARB\0",
b"glVertexAttrib2dNV\0",
],
) {
storage::VertexAttrib2d.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib2dv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib2dv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib2dv\0",
b"glVertexAttrib2dvARB\0",
b"glVertexAttrib2dvNV\0",
],
) {
storage::VertexAttrib2dv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib2f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib2f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib2f\0",
b"glVertexAttrib2fARB\0",
b"glVertexAttrib2fNV\0",
],
) {
storage::VertexAttrib2f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib2fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib2fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib2fv\0",
b"glVertexAttrib2fvARB\0",
b"glVertexAttrib2fvNV\0",
],
) {
storage::VertexAttrib2fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib2s {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib2s.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib2s\0",
b"glVertexAttrib2sARB\0",
b"glVertexAttrib2sNV\0",
],
) {
storage::VertexAttrib2s.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib2sv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib2sv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib2sv\0",
b"glVertexAttrib2svARB\0",
b"glVertexAttrib2svNV\0",
],
) {
storage::VertexAttrib2sv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib3d {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib3d.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib3d\0",
b"glVertexAttrib3dARB\0",
b"glVertexAttrib3dNV\0",
],
) {
storage::VertexAttrib3d.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib3dv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib3dv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib3dv\0",
b"glVertexAttrib3dvARB\0",
b"glVertexAttrib3dvNV\0",
],
) {
storage::VertexAttrib3dv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib3f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib3f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib3f\0",
b"glVertexAttrib3fARB\0",
b"glVertexAttrib3fNV\0",
],
) {
storage::VertexAttrib3f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib3fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib3fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib3fv\0",
b"glVertexAttrib3fvARB\0",
b"glVertexAttrib3fvNV\0",
],
) {
storage::VertexAttrib3fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib3s {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib3s.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib3s\0",
b"glVertexAttrib3sARB\0",
b"glVertexAttrib3sNV\0",
],
) {
storage::VertexAttrib3s.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib3sv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib3sv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib3sv\0",
b"glVertexAttrib3svARB\0",
b"glVertexAttrib3svNV\0",
],
) {
storage::VertexAttrib3sv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Nbv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Nbv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4Nbv\0", b"glVertexAttrib4NbvARB\0"],
) {
storage::VertexAttrib4Nbv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Niv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Niv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4Niv\0", b"glVertexAttrib4NivARB\0"],
) {
storage::VertexAttrib4Niv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Nsv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Nsv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4Nsv\0", b"glVertexAttrib4NsvARB\0"],
) {
storage::VertexAttrib4Nsv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Nub {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Nub.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4Nub\0",
b"glVertexAttrib4NubARB\0",
b"glVertexAttrib4ubNV\0",
],
) {
storage::VertexAttrib4Nub.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Nubv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Nubv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4Nubv\0",
b"glVertexAttrib4NubvARB\0",
b"glVertexAttrib4ubvNV\0",
],
) {
storage::VertexAttrib4Nubv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Nuiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Nuiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4Nuiv\0", b"glVertexAttrib4NuivARB\0"],
) {
storage::VertexAttrib4Nuiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4Nusv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4Nusv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4Nusv\0", b"glVertexAttrib4NusvARB\0"],
) {
storage::VertexAttrib4Nusv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4bv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4bv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4bv\0", b"glVertexAttrib4bvARB\0"],
) {
storage::VertexAttrib4bv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4d {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4d.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4d\0",
b"glVertexAttrib4dARB\0",
b"glVertexAttrib4dNV\0",
],
) {
storage::VertexAttrib4d.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4dv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4dv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4dv\0",
b"glVertexAttrib4dvARB\0",
b"glVertexAttrib4dvNV\0",
],
) {
storage::VertexAttrib4dv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4f {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4f.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4f\0",
b"glVertexAttrib4fARB\0",
b"glVertexAttrib4fNV\0",
],
) {
storage::VertexAttrib4f.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4fv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4fv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4fv\0",
b"glVertexAttrib4fvARB\0",
b"glVertexAttrib4fvNV\0",
],
) {
storage::VertexAttrib4fv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4iv\0", b"glVertexAttrib4ivARB\0"],
) {
storage::VertexAttrib4iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4s {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4s.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4s\0",
b"glVertexAttrib4sARB\0",
b"glVertexAttrib4sNV\0",
],
) {
storage::VertexAttrib4s.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4sv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4sv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttrib4sv\0",
b"glVertexAttrib4svARB\0",
b"glVertexAttrib4svNV\0",
],
) {
storage::VertexAttrib4sv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4ubv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4ubv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4ubv\0", b"glVertexAttrib4ubvARB\0"],
) {
storage::VertexAttrib4ubv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4uiv\0", b"glVertexAttrib4uivARB\0"],
) {
storage::VertexAttrib4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttrib4usv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttrib4usv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttrib4usv\0", b"glVertexAttrib4usvARB\0"],
) {
storage::VertexAttrib4usv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribDivisor {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribDivisor.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[
b"glVertexAttribDivisor\0",
b"glVertexAttribDivisorANGLE\0",
b"glVertexAttribDivisorARB\0",
b"glVertexAttribDivisorEXT\0",
b"glVertexAttribDivisorNV\0",
],
) {
storage::VertexAttribDivisor.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI1i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI1i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI1i\0", b"glVertexAttribI1iEXT\0"],
) {
storage::VertexAttribI1i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI1iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI1iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI1iv\0", b"glVertexAttribI1ivEXT\0"],
) {
storage::VertexAttribI1iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI1ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI1ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI1ui\0", b"glVertexAttribI1uiEXT\0"],
) {
storage::VertexAttribI1ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI1uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI1uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI1uiv\0", b"glVertexAttribI1uivEXT\0"],
) {
storage::VertexAttribI1uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI2i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI2i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI2i\0", b"glVertexAttribI2iEXT\0"],
) {
storage::VertexAttribI2i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI2iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI2iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI2iv\0", b"glVertexAttribI2ivEXT\0"],
) {
storage::VertexAttribI2iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI2ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI2ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI2ui\0", b"glVertexAttribI2uiEXT\0"],
) {
storage::VertexAttribI2ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI2uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI2uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI2uiv\0", b"glVertexAttribI2uivEXT\0"],
) {
storage::VertexAttribI2uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI3i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI3i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI3i\0", b"glVertexAttribI3iEXT\0"],
) {
storage::VertexAttribI3i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI3iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI3iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI3iv\0", b"glVertexAttribI3ivEXT\0"],
) {
storage::VertexAttribI3iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI3ui\0", b"glVertexAttribI3uiEXT\0"],
) {
storage::VertexAttribI3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI3uiv\0", b"glVertexAttribI3uivEXT\0"],
) {
storage::VertexAttribI3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4bv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4bv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4bv\0", b"glVertexAttribI4bvEXT\0"],
) {
storage::VertexAttribI4bv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4i {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4i.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4i\0", b"glVertexAttribI4iEXT\0"],
) {
storage::VertexAttribI4i.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4iv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4iv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4iv\0", b"glVertexAttribI4ivEXT\0"],
) {
storage::VertexAttribI4iv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4sv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4sv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4sv\0", b"glVertexAttribI4svEXT\0"],
) {
storage::VertexAttribI4sv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4ubv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4ubv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4ubv\0", b"glVertexAttribI4ubvEXT\0"],
) {
storage::VertexAttribI4ubv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4ui\0", b"glVertexAttribI4uiEXT\0"],
) {
storage::VertexAttribI4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4uiv\0", b"glVertexAttribI4uivEXT\0"],
) {
storage::VertexAttribI4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribI4usv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribI4usv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribI4usv\0", b"glVertexAttribI4usvEXT\0"],
) {
storage::VertexAttribI4usv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribIPointer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribIPointer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribIPointer\0", b"glVertexAttribIPointerEXT\0"],
) {
storage::VertexAttribIPointer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP1ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP1ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP1ui\0"]) {
storage::VertexAttribP1ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP1uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP1uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP1uiv\0"]) {
storage::VertexAttribP1uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP2ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP2ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP2ui\0"]) {
storage::VertexAttribP2ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP2uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP2uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP2uiv\0"]) {
storage::VertexAttribP2uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP3ui\0"]) {
storage::VertexAttribP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP3uiv\0"]) {
storage::VertexAttribP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP4ui\0"]) {
storage::VertexAttribP4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribP4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribP4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexAttribP4uiv\0"]) {
storage::VertexAttribP4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod VertexAttribPointer {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexAttribPointer.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(
&mut load_fn,
&[b"glVertexAttribPointer\0", b"glVertexAttribPointerARB\0"],
) {
storage::VertexAttribPointer.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod VertexP2ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexP2ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexP2ui\0"]) {
storage::VertexP2ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod VertexP2uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexP2uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexP2uiv\0"]) {
storage::VertexP2uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod VertexP3ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexP3ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexP3ui\0"]) {
storage::VertexP3ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod VertexP3uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexP3uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexP3uiv\0"]) {
storage::VertexP3uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod VertexP4ui {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexP4ui.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexP4ui\0"]) {
storage::VertexP4ui.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
#[cfg(feature = "compatibility_profile")]
pub mod VertexP4uiv {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::VertexP4uiv.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glVertexP4uiv\0"]) {
storage::VertexP4uiv.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod Viewport {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::Viewport.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) = meta_loader(&mut load_fn, &[b"glViewport\0"]) {
storage::Viewport.store(p.as_ptr(), Ordering::SeqCst);
};
}
}
#[doc(hidden)]
pub mod WaitSync {
use super::*;
#[inline]
pub fn is_loaded() -> bool {
!storage::WaitSync.load(Ordering::Relaxed).is_null()
}
pub unsafe fn load_with<F>(mut load_fn: F)
where
F: FnMut(*const c_char) -> *const c_void,
{
if let Some(p) =
meta_loader(&mut load_fn, &[b"glWaitSync\0", b"glWaitSyncAPPLE\0"])
{
storage::WaitSync.store(p.as_ptr(), Ordering::SeqCst);
};
}
}