#![no_std]
#![allow(bad_style)]
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
#[cfg(any(
all(
not(feature = "log"),
any(feature = "debug_trace_calls", feature = "debug_automatic_glGetError")
),
not(feature = "chlorine"),
))]
extern crate std;
#[cfg(feature = "chlorine")]
use chlorine::*;
#[cfg(not(feature = "chlorine"))]
use std::os::raw::*;
#[cfg(feature = "log")]
#[allow(unused)]
use log::{error, trace};
#[cfg(all(
not(feature = "log"),
any(feature = "debug_trace_calls", feature = "debug_automatic_glGetError")
))]
#[allow(unused)]
use std::{eprintln, println};
#[cfg(all(not(feature = "log"), feature = "debug_trace_calls"))]
macro_rules! trace { ($($arg:tt)*) => { println!($($arg)*) } }
#[cfg(all(not(feature = "log"), feature = "debug_automatic_glGetError"))]
macro_rules! error { ($($arg:tt)*) => { eprintln!($($arg)*) } }
use core::{
mem::transmute,
ptr::null_mut,
sync::atomic::{AtomicPtr, Ordering},
};
#[allow(dead_code)]
const RELAX: Ordering = Ordering::Relaxed;
#[allow(dead_code)]
type APcv = AtomicPtr<c_void>;
#[cfg(feature = "global_loader")]
const fn ap_null() -> APcv {
AtomicPtr::new(null_mut())
}
pub use types::*;
#[allow(missing_docs)]
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 = i8;
pub type GLubyte = u8;
pub type GLshort = i16;
pub type GLushort = u16;
pub type GLint = c_int;
pub type GLuint = c_uint;
pub type GLclampx = i32;
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 GLeglClientBufferEXT = *mut c_void;
pub type GLeglImageOES = *mut c_void;
pub type GLchar = c_char;
pub type GLcharARB = c_char;
#[cfg(any(target_os = "macos", target_os = "ios"))]
pub type GLhandleARB = *mut c_void;
#[cfg(not(any(target_os = "macos", target_os = "ios")))]
pub type GLhandleARB = c_uint;
pub type GLhalf = u16;
pub type GLhalfARB = u16;
pub type GLfixed = i32;
pub type GLintptr = isize;
pub type GLintptrARB = isize;
pub type GLsizeiptr = isize;
pub type GLsizeiptrARB = isize;
pub type GLint64 = i64;
pub type GLint64EXT = i64;
pub type GLuint64 = u64;
pub type GLuint64EXT = u64;
#[doc(hidden)]
pub struct __GLsync {
_priv: u8,
}
impl core::fmt::Debug for __GLsync {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "__GLsync")
}
}
pub type GLsync = *mut __GLsync;
pub struct _cl_context {
_priv: u8,
}
impl core::fmt::Debug for _cl_context {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "_cl_context")
}
}
pub struct _cl_event {
_priv: u8,
}
impl core::fmt::Debug for _cl_event {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "_cl_event")
}
}
pub type GLDEBUGPROC = Option<
unsafe 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 type GLVULKANPROCNV = Option<extern "system" fn()>;
}
pub use enums::*;
pub mod enums {
use super::*;
#[doc = "`GL_ACTIVE_ATTRIBUTES: GLenum = 0x8B89`\n* **Group:** ProgramPropertyARB"]
pub const GL_ACTIVE_ATTRIBUTES: GLenum = 0x8B89;
#[doc = "`GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: GLenum = 0x8B8A`\n* **Group:** ProgramPropertyARB"]
pub const GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: GLenum = 0x8B8A;
#[doc = "`GL_ACTIVE_TEXTURE: GLenum = 0x84E0`\n* **Group:** GetPName"]
pub const GL_ACTIVE_TEXTURE: GLenum = 0x84E0;
#[doc = "`GL_ACTIVE_UNIFORMS: GLenum = 0x8B86`\n* **Group:** ProgramPropertyARB"]
pub const GL_ACTIVE_UNIFORMS: GLenum = 0x8B86;
#[doc = "`GL_ACTIVE_UNIFORM_BLOCKS: GLenum = 0x8A36`\n* **Group:** ProgramPropertyARB"]
pub const GL_ACTIVE_UNIFORM_BLOCKS: GLenum = 0x8A36;
#[doc = "`GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: GLenum = 0x8A35`\n* **Group:** ProgramPropertyARB"]
pub const GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: GLenum = 0x8A35;
#[doc = "`GL_ACTIVE_UNIFORM_MAX_LENGTH: GLenum = 0x8B87`\n* **Group:** ProgramPropertyARB"]
pub const GL_ACTIVE_UNIFORM_MAX_LENGTH: GLenum = 0x8B87;
#[doc = "`GL_ALIASED_LINE_WIDTH_RANGE: GLenum = 0x846E`\n* **Group:** GetPName"]
pub const GL_ALIASED_LINE_WIDTH_RANGE: GLenum = 0x846E;
#[doc = "`GL_ALIASED_POINT_SIZE_RANGE: GLenum = 0x846D`\n* **Group:** GetPName"]
pub const GL_ALIASED_POINT_SIZE_RANGE: GLenum = 0x846D;
#[doc = "`GL_ALPHA: GLenum = 0x1906`\n* **Groups:** TextureSwizzle, CombinerPortionNV, PathColorFormat, CombinerComponentUsageNV, PixelFormat"]
pub const GL_ALPHA: GLenum = 0x1906;
#[doc = "`GL_ALPHA_BITS: GLenum = 0x0D55`\n* **Group:** GetPName"]
pub const GL_ALPHA_BITS: GLenum = 0x0D55;
#[doc = "`GL_ALREADY_SIGNALED: GLenum = 0x911A`\n* **Group:** SyncStatus"]
pub const GL_ALREADY_SIGNALED: GLenum = 0x911A;
#[doc = "`GL_ALWAYS: GLenum = 0x0207`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_ALWAYS: GLenum = 0x0207;
#[doc = "`GL_ANY_SAMPLES_PASSED: GLenum = 0x8C2F`\n* **Group:** QueryTarget"]
pub const GL_ANY_SAMPLES_PASSED: GLenum = 0x8C2F;
#[doc = "`GL_ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum = 0x8D6A`\n* **Group:** QueryTarget"]
pub const GL_ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum = 0x8D6A;
#[doc = "`GL_ARRAY_BUFFER: GLenum = 0x8892`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_ARRAY_BUFFER: GLenum = 0x8892;
#[doc = "`GL_ARRAY_BUFFER_BINDING: GLenum = 0x8894`\n* **Group:** GetPName"]
pub const GL_ARRAY_BUFFER_BINDING: GLenum = 0x8894;
#[doc = "`GL_ATTACHED_SHADERS: GLenum = 0x8B85`\n* **Group:** ProgramPropertyARB"]
pub const GL_ATTACHED_SHADERS: GLenum = 0x8B85;
#[doc = "`GL_BACK: GLenum = 0x0405`\n* **Groups:** ColorBuffer, ColorMaterialFace, CullFaceMode, DrawBufferMode, ReadBufferMode, StencilFaceDirection, MaterialFace"]
pub const GL_BACK: GLenum = 0x0405;
#[doc = "`GL_BLEND: GLenum = 0x0BE2`\n* **Groups:** TextureEnvMode, EnableCap, GetPName"]
pub const GL_BLEND: GLenum = 0x0BE2;
#[doc = "`GL_BLEND_COLOR: GLenum = 0x8005`\n* **Group:** GetPName"]
pub const GL_BLEND_COLOR: GLenum = 0x8005;
#[doc = "`GL_BLEND_DST_ALPHA: GLenum = 0x80CA`\n* **Group:** GetPName"]
pub const GL_BLEND_DST_ALPHA: GLenum = 0x80CA;
#[doc = "`GL_BLEND_DST_RGB: GLenum = 0x80C8`\n* **Group:** GetPName"]
pub const GL_BLEND_DST_RGB: GLenum = 0x80C8;
#[doc = "`GL_BLEND_EQUATION: GLenum = 0x8009`"]
pub const GL_BLEND_EQUATION: GLenum = 0x8009;
#[doc = "`GL_BLEND_EQUATION_ALPHA: GLenum = 0x883D`\n* **Group:** GetPName"]
pub const GL_BLEND_EQUATION_ALPHA: GLenum = 0x883D;
#[doc = "`GL_BLEND_EQUATION_RGB: GLenum = 0x8009`\n* **Group:** GetPName"]
pub const GL_BLEND_EQUATION_RGB: GLenum = 0x8009;
#[doc = "`GL_BLEND_SRC_ALPHA: GLenum = 0x80CB`\n* **Group:** GetPName"]
pub const GL_BLEND_SRC_ALPHA: GLenum = 0x80CB;
#[doc = "`GL_BLEND_SRC_RGB: GLenum = 0x80C9`\n* **Group:** GetPName"]
pub const GL_BLEND_SRC_RGB: GLenum = 0x80C9;
#[doc = "`GL_BLUE: GLenum = 0x1905`\n* **Groups:** TextureSwizzle, CombinerComponentUsageNV, PixelFormat"]
pub const GL_BLUE: GLenum = 0x1905;
#[doc = "`GL_BLUE_BITS: GLenum = 0x0D54`\n* **Group:** GetPName"]
pub const GL_BLUE_BITS: GLenum = 0x0D54;
#[doc = "`GL_BOOL: GLenum = 0x8B56`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_BOOL: GLenum = 0x8B56;
#[doc = "`GL_BOOL_VEC2: GLenum = 0x8B57`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_BOOL_VEC2: GLenum = 0x8B57;
#[doc = "`GL_BOOL_VEC3: GLenum = 0x8B58`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_BOOL_VEC3: GLenum = 0x8B58;
#[doc = "`GL_BOOL_VEC4: GLenum = 0x8B59`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_BOOL_VEC4: GLenum = 0x8B59;
#[doc = "`GL_BUFFER_ACCESS_FLAGS: GLenum = 0x911F`\n* **Groups:** VertexBufferObjectParameter, BufferPNameARB"]
pub const GL_BUFFER_ACCESS_FLAGS: GLenum = 0x911F;
#[doc = "`GL_BUFFER_MAPPED: GLenum = 0x88BC`\n* **Groups:** VertexBufferObjectParameter, BufferPNameARB"]
pub const GL_BUFFER_MAPPED: GLenum = 0x88BC;
#[doc = "`GL_BUFFER_MAP_LENGTH: GLenum = 0x9120`\n* **Groups:** VertexBufferObjectParameter, BufferPNameARB"]
pub const GL_BUFFER_MAP_LENGTH: GLenum = 0x9120;
#[doc = "`GL_BUFFER_MAP_OFFSET: GLenum = 0x9121`\n* **Groups:** VertexBufferObjectParameter, BufferPNameARB"]
pub const GL_BUFFER_MAP_OFFSET: GLenum = 0x9121;
#[doc = "`GL_BUFFER_MAP_POINTER: GLenum = 0x88BD`\n* **Group:** BufferPointerNameARB"]
pub const GL_BUFFER_MAP_POINTER: GLenum = 0x88BD;
#[doc = "`GL_BUFFER_SIZE: GLenum = 0x8764`\n* **Groups:** VertexBufferObjectParameter, BufferPNameARB"]
pub const GL_BUFFER_SIZE: GLenum = 0x8764;
#[doc = "`GL_BUFFER_USAGE: GLenum = 0x8765`\n* **Groups:** VertexBufferObjectParameter, BufferPNameARB"]
pub const GL_BUFFER_USAGE: GLenum = 0x8765;
#[doc = "`GL_BYTE: GLenum = 0x1400`\n* **Groups:** VertexAttribIType, WeightPointerTypeARB, TangentPointerTypeEXT, BinormalPointerTypeEXT, ColorPointerType, ListNameType, NormalPointerType, PixelType, VertexAttribType, VertexAttribPointerType"]
pub const GL_BYTE: GLenum = 0x1400;
#[doc = "`GL_CCW: GLenum = 0x0901`\n* **Group:** FrontFaceDirection"]
pub const GL_CCW: GLenum = 0x0901;
#[doc = "`GL_CLAMP_TO_EDGE: GLenum = 0x812F`\n* **Group:** TextureWrapMode"]
pub const GL_CLAMP_TO_EDGE: GLenum = 0x812F;
#[doc = "`GL_COLOR: GLenum = 0x1800`\n* **Groups:** Buffer, PixelCopyType, InvalidateFramebufferAttachment"]
pub const GL_COLOR: GLenum = 0x1800;
#[doc = "`GL_COLOR_ATTACHMENT0: GLenum = 0x8CE0`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT0: GLenum = 0x8CE0;
#[doc = "`GL_COLOR_ATTACHMENT1: GLenum = 0x8CE1`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT1: GLenum = 0x8CE1;
#[doc = "`GL_COLOR_ATTACHMENT10: GLenum = 0x8CEA`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT10: GLenum = 0x8CEA;
#[doc = "`GL_COLOR_ATTACHMENT11: GLenum = 0x8CEB`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT11: GLenum = 0x8CEB;
#[doc = "`GL_COLOR_ATTACHMENT12: GLenum = 0x8CEC`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT12: GLenum = 0x8CEC;
#[doc = "`GL_COLOR_ATTACHMENT13: GLenum = 0x8CED`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT13: GLenum = 0x8CED;
#[doc = "`GL_COLOR_ATTACHMENT14: GLenum = 0x8CEE`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT14: GLenum = 0x8CEE;
#[doc = "`GL_COLOR_ATTACHMENT15: GLenum = 0x8CEF`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT15: GLenum = 0x8CEF;
#[doc = "`GL_COLOR_ATTACHMENT16: GLenum = 0x8CF0`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT16: GLenum = 0x8CF0;
#[doc = "`GL_COLOR_ATTACHMENT17: GLenum = 0x8CF1`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT17: GLenum = 0x8CF1;
#[doc = "`GL_COLOR_ATTACHMENT18: GLenum = 0x8CF2`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT18: GLenum = 0x8CF2;
#[doc = "`GL_COLOR_ATTACHMENT19: GLenum = 0x8CF3`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT19: GLenum = 0x8CF3;
#[doc = "`GL_COLOR_ATTACHMENT2: GLenum = 0x8CE2`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT2: GLenum = 0x8CE2;
#[doc = "`GL_COLOR_ATTACHMENT20: GLenum = 0x8CF4`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT20: GLenum = 0x8CF4;
#[doc = "`GL_COLOR_ATTACHMENT21: GLenum = 0x8CF5`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT21: GLenum = 0x8CF5;
#[doc = "`GL_COLOR_ATTACHMENT22: GLenum = 0x8CF6`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT22: GLenum = 0x8CF6;
#[doc = "`GL_COLOR_ATTACHMENT23: GLenum = 0x8CF7`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT23: GLenum = 0x8CF7;
#[doc = "`GL_COLOR_ATTACHMENT24: GLenum = 0x8CF8`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT24: GLenum = 0x8CF8;
#[doc = "`GL_COLOR_ATTACHMENT25: GLenum = 0x8CF9`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT25: GLenum = 0x8CF9;
#[doc = "`GL_COLOR_ATTACHMENT26: GLenum = 0x8CFA`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT26: GLenum = 0x8CFA;
#[doc = "`GL_COLOR_ATTACHMENT27: GLenum = 0x8CFB`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT27: GLenum = 0x8CFB;
#[doc = "`GL_COLOR_ATTACHMENT28: GLenum = 0x8CFC`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT28: GLenum = 0x8CFC;
#[doc = "`GL_COLOR_ATTACHMENT29: GLenum = 0x8CFD`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT29: GLenum = 0x8CFD;
#[doc = "`GL_COLOR_ATTACHMENT3: GLenum = 0x8CE3`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT3: GLenum = 0x8CE3;
#[doc = "`GL_COLOR_ATTACHMENT30: GLenum = 0x8CFE`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT30: GLenum = 0x8CFE;
#[doc = "`GL_COLOR_ATTACHMENT31: GLenum = 0x8CFF`\n* **Groups:** ColorBuffer, DrawBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT31: GLenum = 0x8CFF;
#[doc = "`GL_COLOR_ATTACHMENT4: GLenum = 0x8CE4`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT4: GLenum = 0x8CE4;
#[doc = "`GL_COLOR_ATTACHMENT5: GLenum = 0x8CE5`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT5: GLenum = 0x8CE5;
#[doc = "`GL_COLOR_ATTACHMENT6: GLenum = 0x8CE6`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT6: GLenum = 0x8CE6;
#[doc = "`GL_COLOR_ATTACHMENT7: GLenum = 0x8CE7`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT7: GLenum = 0x8CE7;
#[doc = "`GL_COLOR_ATTACHMENT8: GLenum = 0x8CE8`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT8: GLenum = 0x8CE8;
#[doc = "`GL_COLOR_ATTACHMENT9: GLenum = 0x8CE9`\n* **Groups:** ColorBuffer, DrawBufferMode, ReadBufferMode, FramebufferAttachment, InvalidateFramebufferAttachment"]
pub const GL_COLOR_ATTACHMENT9: GLenum = 0x8CE9;
#[doc = "`GL_COLOR_BUFFER_BIT: GLbitfield = 0x00004000`\n* **Groups:** ClearBufferMask, AttribMask"]
pub const GL_COLOR_BUFFER_BIT: GLbitfield = 0x00004000;
#[doc = "`GL_COLOR_CLEAR_VALUE: GLenum = 0x0C22`\n* **Group:** GetPName"]
pub const GL_COLOR_CLEAR_VALUE: GLenum = 0x0C22;
#[doc = "`GL_COLOR_WRITEMASK: GLenum = 0x0C23`\n* **Group:** GetPName"]
pub const GL_COLOR_WRITEMASK: GLenum = 0x0C23;
#[doc = "`GL_COMPARE_REF_TO_TEXTURE: GLenum = 0x884E`\n* **Group:** TextureCompareMode\n* **Alias Of:** `GL_COMPARE_R_TO_TEXTURE`"]
pub const GL_COMPARE_REF_TO_TEXTURE: GLenum = 0x884E;
#[doc = "`GL_COMPILE_STATUS: GLenum = 0x8B81`\n* **Group:** ShaderParameterName"]
pub const GL_COMPILE_STATUS: GLenum = 0x8B81;
#[doc = "`GL_COMPRESSED_R11_EAC: GLenum = 0x9270`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_R11_EAC: GLenum = 0x9270;
#[doc = "`GL_COMPRESSED_RG11_EAC: GLenum = 0x9272`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_RG11_EAC: GLenum = 0x9272;
#[doc = "`GL_COMPRESSED_RGB8_ETC2: GLenum = 0x9274`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_RGB8_ETC2: GLenum = 0x9274;
#[doc = "`GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum = 0x9276`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum = 0x9276;
#[doc = "`GL_COMPRESSED_RGBA8_ETC2_EAC: GLenum = 0x9278`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_RGBA8_ETC2_EAC: GLenum = 0x9278;
#[doc = "`GL_COMPRESSED_SIGNED_R11_EAC: GLenum = 0x9271`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_SIGNED_R11_EAC: GLenum = 0x9271;
#[doc = "`GL_COMPRESSED_SIGNED_RG11_EAC: GLenum = 0x9273`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_SIGNED_RG11_EAC: GLenum = 0x9273;
#[doc = "`GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: GLenum = 0x9279`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: GLenum = 0x9279;
#[doc = "`GL_COMPRESSED_SRGB8_ETC2: GLenum = 0x9275`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_SRGB8_ETC2: GLenum = 0x9275;
#[doc = "`GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum = 0x9277`\n* **Group:** InternalFormat"]
pub const GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: GLenum = 0x9277;
#[doc = "`GL_COMPRESSED_TEXTURE_FORMATS: GLenum = 0x86A3`\n* **Group:** GetPName"]
pub const GL_COMPRESSED_TEXTURE_FORMATS: GLenum = 0x86A3;
#[doc = "`GL_CONDITION_SATISFIED: GLenum = 0x911C`\n* **Group:** SyncStatus"]
pub const GL_CONDITION_SATISFIED: GLenum = 0x911C;
#[doc = "`GL_CONSTANT_ALPHA: GLenum = 0x8003`\n* **Group:** BlendingFactor"]
pub const GL_CONSTANT_ALPHA: GLenum = 0x8003;
#[doc = "`GL_CONSTANT_COLOR: GLenum = 0x8001`\n* **Group:** BlendingFactor"]
pub const GL_CONSTANT_COLOR: GLenum = 0x8001;
#[doc = "`GL_COPY_READ_BUFFER: GLenum = 0x8F36`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_COPY_READ_BUFFER: GLenum = 0x8F36;
#[doc = "`GL_COPY_READ_BUFFER_BINDING: GLenum = 0x8F36`\n* **Alias Of:** `GL_COPY_READ_BUFFER`"]
pub const GL_COPY_READ_BUFFER_BINDING: GLenum = 0x8F36;
#[doc = "`GL_COPY_WRITE_BUFFER: GLenum = 0x8F37`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_COPY_WRITE_BUFFER: GLenum = 0x8F37;
#[doc = "`GL_COPY_WRITE_BUFFER_BINDING: GLenum = 0x8F37`\n* **Alias Of:** `GL_COPY_WRITE_BUFFER`"]
pub const GL_COPY_WRITE_BUFFER_BINDING: GLenum = 0x8F37;
#[doc = "`GL_CULL_FACE: GLenum = 0x0B44`\n* **Groups:** GetPName, EnableCap"]
pub const GL_CULL_FACE: GLenum = 0x0B44;
#[doc = "`GL_CULL_FACE_MODE: GLenum = 0x0B45`\n* **Group:** GetPName"]
pub const GL_CULL_FACE_MODE: GLenum = 0x0B45;
#[doc = "`GL_CURRENT_PROGRAM: GLenum = 0x8B8D`\n* **Group:** GetPName"]
pub const GL_CURRENT_PROGRAM: GLenum = 0x8B8D;
#[doc = "`GL_CURRENT_QUERY: GLenum = 0x8865`\n* **Group:** QueryParameterName"]
pub const GL_CURRENT_QUERY: GLenum = 0x8865;
#[doc = "`GL_CURRENT_VERTEX_ATTRIB: GLenum = 0x8626`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB"]
pub const GL_CURRENT_VERTEX_ATTRIB: GLenum = 0x8626;
#[doc = "`GL_CW: GLenum = 0x0900`\n* **Group:** FrontFaceDirection"]
pub const GL_CW: GLenum = 0x0900;
#[doc = "`GL_DECR: GLenum = 0x1E03`\n* **Group:** StencilOp"]
pub const GL_DECR: GLenum = 0x1E03;
#[doc = "`GL_DECR_WRAP: GLenum = 0x8508`\n* **Group:** StencilOp"]
pub const GL_DECR_WRAP: GLenum = 0x8508;
#[doc = "`GL_DELETE_STATUS: GLenum = 0x8B80`\n* **Groups:** ProgramPropertyARB, ShaderParameterName"]
pub const GL_DELETE_STATUS: GLenum = 0x8B80;
#[doc = "`GL_DEPTH: GLenum = 0x1801`\n* **Groups:** Buffer, PixelCopyType, InvalidateFramebufferAttachment"]
pub const GL_DEPTH: GLenum = 0x1801;
#[doc = "`GL_DEPTH24_STENCIL8: GLenum = 0x88F0`\n* **Group:** InternalFormat"]
pub const GL_DEPTH24_STENCIL8: GLenum = 0x88F0;
#[doc = "`GL_DEPTH32F_STENCIL8: GLenum = 0x8CAD`\n* **Group:** InternalFormat"]
pub const GL_DEPTH32F_STENCIL8: GLenum = 0x8CAD;
#[doc = "`GL_DEPTH_ATTACHMENT: GLenum = 0x8D00`\n* **Group:** InvalidateFramebufferAttachment"]
pub const GL_DEPTH_ATTACHMENT: GLenum = 0x8D00;
#[doc = "`GL_DEPTH_BITS: GLenum = 0x0D56`\n* **Group:** GetPName"]
pub const GL_DEPTH_BITS: GLenum = 0x0D56;
#[doc = "`GL_DEPTH_BUFFER_BIT: GLbitfield = 0x00000100`\n* **Groups:** ClearBufferMask, AttribMask"]
pub const GL_DEPTH_BUFFER_BIT: GLbitfield = 0x00000100;
#[doc = "`GL_DEPTH_CLEAR_VALUE: GLenum = 0x0B73`\n* **Group:** GetPName"]
pub const GL_DEPTH_CLEAR_VALUE: GLenum = 0x0B73;
#[doc = "`GL_DEPTH_COMPONENT: GLenum = 0x1902`\n* **Groups:** InternalFormat, PixelFormat"]
pub const GL_DEPTH_COMPONENT: GLenum = 0x1902;
#[doc = "`GL_DEPTH_COMPONENT16: GLenum = 0x81A5`\n* **Group:** InternalFormat"]
pub const GL_DEPTH_COMPONENT16: GLenum = 0x81A5;
#[doc = "`GL_DEPTH_COMPONENT24: GLenum = 0x81A6`"]
pub const GL_DEPTH_COMPONENT24: GLenum = 0x81A6;
#[doc = "`GL_DEPTH_COMPONENT32F: GLenum = 0x8CAC`\n* **Group:** InternalFormat"]
pub const GL_DEPTH_COMPONENT32F: GLenum = 0x8CAC;
#[doc = "`GL_DEPTH_FUNC: GLenum = 0x0B74`\n* **Group:** GetPName"]
pub const GL_DEPTH_FUNC: GLenum = 0x0B74;
#[doc = "`GL_DEPTH_RANGE: GLenum = 0x0B70`\n* **Group:** GetPName"]
pub const GL_DEPTH_RANGE: GLenum = 0x0B70;
#[doc = "`GL_DEPTH_STENCIL: GLenum = 0x84F9`\n* **Groups:** InternalFormat, PixelFormat"]
pub const GL_DEPTH_STENCIL: GLenum = 0x84F9;
#[doc = "`GL_DEPTH_STENCIL_ATTACHMENT: GLenum = 0x821A`\n* **Group:** InvalidateFramebufferAttachment"]
pub const GL_DEPTH_STENCIL_ATTACHMENT: GLenum = 0x821A;
#[doc = "`GL_DEPTH_TEST: GLenum = 0x0B71`\n* **Groups:** GetPName, EnableCap"]
pub const GL_DEPTH_TEST: GLenum = 0x0B71;
#[doc = "`GL_DEPTH_WRITEMASK: GLenum = 0x0B72`\n* **Group:** GetPName"]
pub const GL_DEPTH_WRITEMASK: GLenum = 0x0B72;
#[doc = "`GL_DITHER: GLenum = 0x0BD0`\n* **Groups:** GetPName, EnableCap"]
pub const GL_DITHER: GLenum = 0x0BD0;
#[doc = "`GL_DONT_CARE: GLenum = 0x1100`\n* **Groups:** DebugSeverity, HintMode, DebugSource, DebugType"]
pub const GL_DONT_CARE: GLenum = 0x1100;
#[doc = "`GL_DRAW_BUFFER0: GLenum = 0x8825`"]
pub const GL_DRAW_BUFFER0: GLenum = 0x8825;
#[doc = "`GL_DRAW_BUFFER1: GLenum = 0x8826`"]
pub const GL_DRAW_BUFFER1: GLenum = 0x8826;
#[doc = "`GL_DRAW_BUFFER10: GLenum = 0x882F`"]
pub const GL_DRAW_BUFFER10: GLenum = 0x882F;
#[doc = "`GL_DRAW_BUFFER11: GLenum = 0x8830`"]
pub const GL_DRAW_BUFFER11: GLenum = 0x8830;
#[doc = "`GL_DRAW_BUFFER12: GLenum = 0x8831`"]
pub const GL_DRAW_BUFFER12: GLenum = 0x8831;
#[doc = "`GL_DRAW_BUFFER13: GLenum = 0x8832`"]
pub const GL_DRAW_BUFFER13: GLenum = 0x8832;
#[doc = "`GL_DRAW_BUFFER14: GLenum = 0x8833`"]
pub const GL_DRAW_BUFFER14: GLenum = 0x8833;
#[doc = "`GL_DRAW_BUFFER15: GLenum = 0x8834`"]
pub const GL_DRAW_BUFFER15: GLenum = 0x8834;
#[doc = "`GL_DRAW_BUFFER2: GLenum = 0x8827`"]
pub const GL_DRAW_BUFFER2: GLenum = 0x8827;
#[doc = "`GL_DRAW_BUFFER3: GLenum = 0x8828`"]
pub const GL_DRAW_BUFFER3: GLenum = 0x8828;
#[doc = "`GL_DRAW_BUFFER4: GLenum = 0x8829`"]
pub const GL_DRAW_BUFFER4: GLenum = 0x8829;
#[doc = "`GL_DRAW_BUFFER5: GLenum = 0x882A`"]
pub const GL_DRAW_BUFFER5: GLenum = 0x882A;
#[doc = "`GL_DRAW_BUFFER6: GLenum = 0x882B`"]
pub const GL_DRAW_BUFFER6: GLenum = 0x882B;
#[doc = "`GL_DRAW_BUFFER7: GLenum = 0x882C`"]
pub const GL_DRAW_BUFFER7: GLenum = 0x882C;
#[doc = "`GL_DRAW_BUFFER8: GLenum = 0x882D`"]
pub const GL_DRAW_BUFFER8: GLenum = 0x882D;
#[doc = "`GL_DRAW_BUFFER9: GLenum = 0x882E`"]
pub const GL_DRAW_BUFFER9: GLenum = 0x882E;
#[doc = "`GL_DRAW_FRAMEBUFFER: GLenum = 0x8CA9`\n* **Groups:** CheckFramebufferStatusTarget, FramebufferTarget"]
pub const GL_DRAW_FRAMEBUFFER: GLenum = 0x8CA9;
#[doc = "`GL_DRAW_FRAMEBUFFER_BINDING: GLenum = 0x8CA6`\n* **Group:** GetPName"]
pub const GL_DRAW_FRAMEBUFFER_BINDING: GLenum = 0x8CA6;
#[doc = "`GL_DST_ALPHA: GLenum = 0x0304`\n* **Group:** BlendingFactor"]
pub const GL_DST_ALPHA: GLenum = 0x0304;
#[doc = "`GL_DST_COLOR: GLenum = 0x0306`\n* **Group:** BlendingFactor"]
pub const GL_DST_COLOR: GLenum = 0x0306;
#[doc = "`GL_DYNAMIC_COPY: GLenum = 0x88EA`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_DYNAMIC_COPY: GLenum = 0x88EA;
#[doc = "`GL_DYNAMIC_DRAW: GLenum = 0x88E8`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_DYNAMIC_DRAW: GLenum = 0x88E8;
#[doc = "`GL_DYNAMIC_READ: GLenum = 0x88E9`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_DYNAMIC_READ: GLenum = 0x88E9;
#[doc = "`GL_ELEMENT_ARRAY_BUFFER: GLenum = 0x8893`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_ELEMENT_ARRAY_BUFFER: GLenum = 0x8893;
#[doc = "`GL_ELEMENT_ARRAY_BUFFER_BINDING: GLenum = 0x8895`\n* **Group:** GetPName"]
pub const GL_ELEMENT_ARRAY_BUFFER_BINDING: GLenum = 0x8895;
#[doc = "`GL_EQUAL: GLenum = 0x0202`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_EQUAL: GLenum = 0x0202;
#[doc = "`GL_EXTENSIONS: GLenum = 0x1F03`\n* **Group:** StringName"]
pub const GL_EXTENSIONS: GLenum = 0x1F03;
#[doc = "`GL_FALSE: GLenum = 0`\n* **Groups:** Boolean, VertexShaderWriteMaskEXT, ClampColorModeARB"]
pub const GL_FALSE: GLenum = 0;
#[doc = "`GL_FASTEST: GLenum = 0x1101`\n* **Group:** HintMode"]
pub const GL_FASTEST: GLenum = 0x1101;
#[doc = "`GL_FIXED: GLenum = 0x140C`\n* **Groups:** VertexAttribPointerType, VertexAttribType"]
pub const GL_FIXED: GLenum = 0x140C;
#[doc = "`GL_FLOAT: GLenum = 0x1406`\n* **Groups:** GlslTypeToken, MapTypeNV, SecondaryColorPointerTypeIBM, WeightPointerTypeARB, VertexWeightPointerTypeEXT, TangentPointerTypeEXT, BinormalPointerTypeEXT, FogCoordinatePointerType, FogPointerTypeEXT, FogPointerTypeIBM, IndexPointerType, ListNameType, NormalPointerType, PixelType, TexCoordPointerType, VertexPointerType, VertexAttribType, AttributeType, UniformType, VertexAttribPointerType"]
pub const GL_FLOAT: GLenum = 0x1406;
#[doc = "`GL_FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum = 0x8DAD`"]
pub const GL_FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum = 0x8DAD;
#[doc = "`GL_FLOAT_MAT2: GLenum = 0x8B5A`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT2: GLenum = 0x8B5A;
#[doc = "`GL_FLOAT_MAT2x3: GLenum = 0x8B65`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT2x3: GLenum = 0x8B65;
#[doc = "`GL_FLOAT_MAT2x4: GLenum = 0x8B66`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT2x4: GLenum = 0x8B66;
#[doc = "`GL_FLOAT_MAT3: GLenum = 0x8B5B`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT3: GLenum = 0x8B5B;
#[doc = "`GL_FLOAT_MAT3x2: GLenum = 0x8B67`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT3x2: GLenum = 0x8B67;
#[doc = "`GL_FLOAT_MAT3x4: GLenum = 0x8B68`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT3x4: GLenum = 0x8B68;
#[doc = "`GL_FLOAT_MAT4: GLenum = 0x8B5C`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT4: GLenum = 0x8B5C;
#[doc = "`GL_FLOAT_MAT4x2: GLenum = 0x8B69`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT4x2: GLenum = 0x8B69;
#[doc = "`GL_FLOAT_MAT4x3: GLenum = 0x8B6A`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_MAT4x3: GLenum = 0x8B6A;
#[doc = "`GL_FLOAT_VEC2: GLenum = 0x8B50`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_VEC2: GLenum = 0x8B50;
#[doc = "`GL_FLOAT_VEC3: GLenum = 0x8B51`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_VEC3: GLenum = 0x8B51;
#[doc = "`GL_FLOAT_VEC4: GLenum = 0x8B52`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_FLOAT_VEC4: GLenum = 0x8B52;
#[doc = "`GL_FRAGMENT_SHADER: GLenum = 0x8B30`\n* **Groups:** PipelineParameterName, ShaderType"]
pub const GL_FRAGMENT_SHADER: GLenum = 0x8B30;
#[doc = "`GL_FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum = 0x8B8B`\n* **Groups:** HintTarget, GetPName"]
pub const GL_FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum = 0x8B8B;
#[doc = "`GL_FRAMEBUFFER: GLenum = 0x8D40`\n* **Groups:** ObjectIdentifier, FramebufferTarget, CheckFramebufferStatusTarget"]
pub const GL_FRAMEBUFFER: GLenum = 0x8D40;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum = 0x8215`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum = 0x8215;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum = 0x8214`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum = 0x8214;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum = 0x8210`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum = 0x8210;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum = 0x8211`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum = 0x8211;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum = 0x8216`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum = 0x8216;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum = 0x8213`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum = 0x8213;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum = 0x8CD1`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum = 0x8CD1;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum = 0x8CD0`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum = 0x8CD0;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum = 0x8212`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum = 0x8212;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum = 0x8217`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum = 0x8217;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum = 0x8CD3`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum = 0x8CD3;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum = 0x8CD4`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum = 0x8CD4;
#[doc = "`GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum = 0x8CD2`\n* **Group:** FramebufferAttachmentParameterName"]
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum = 0x8CD2;
#[doc = "`GL_FRAMEBUFFER_BINDING: GLenum = 0x8CA6`"]
pub const GL_FRAMEBUFFER_BINDING: GLenum = 0x8CA6;
#[doc = "`GL_FRAMEBUFFER_COMPLETE: GLenum = 0x8CD5`\n* **Group:** FramebufferStatus"]
pub const GL_FRAMEBUFFER_COMPLETE: GLenum = 0x8CD5;
#[doc = "`GL_FRAMEBUFFER_DEFAULT: GLenum = 0x8218`"]
pub const GL_FRAMEBUFFER_DEFAULT: GLenum = 0x8218;
#[doc = "`GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum = 0x8CD6`\n* **Group:** FramebufferStatus"]
pub const GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum = 0x8CD6;
#[doc = "`GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum = 0x8CD9`"]
pub const GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum = 0x8CD9;
#[doc = "`GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum = 0x8CD7`\n* **Group:** FramebufferStatus"]
pub const GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum = 0x8CD7;
#[doc = "`GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum = 0x8D56`\n* **Group:** FramebufferStatus"]
pub const GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum = 0x8D56;
#[doc = "`GL_FRAMEBUFFER_UNDEFINED: GLenum = 0x8219`\n* **Group:** FramebufferStatus"]
pub const GL_FRAMEBUFFER_UNDEFINED: GLenum = 0x8219;
#[doc = "`GL_FRAMEBUFFER_UNSUPPORTED: GLenum = 0x8CDD`\n* **Group:** FramebufferStatus"]
pub const GL_FRAMEBUFFER_UNSUPPORTED: GLenum = 0x8CDD;
#[doc = "`GL_FRONT: GLenum = 0x0404`\n* **Groups:** ColorBuffer, ColorMaterialFace, CullFaceMode, DrawBufferMode, ReadBufferMode, StencilFaceDirection, MaterialFace"]
pub const GL_FRONT: GLenum = 0x0404;
#[doc = "`GL_FRONT_AND_BACK: GLenum = 0x0408`\n* **Groups:** ColorBuffer, ColorMaterialFace, CullFaceMode, DrawBufferMode, StencilFaceDirection, MaterialFace"]
pub const GL_FRONT_AND_BACK: GLenum = 0x0408;
#[doc = "`GL_FRONT_FACE: GLenum = 0x0B46`\n* **Group:** GetPName"]
pub const GL_FRONT_FACE: GLenum = 0x0B46;
#[doc = "`GL_FUNC_ADD: GLenum = 0x8006`\n* **Group:** BlendEquationModeEXT"]
pub const GL_FUNC_ADD: GLenum = 0x8006;
#[doc = "`GL_FUNC_REVERSE_SUBTRACT: GLenum = 0x800B`\n* **Group:** BlendEquationModeEXT"]
pub const GL_FUNC_REVERSE_SUBTRACT: GLenum = 0x800B;
#[doc = "`GL_FUNC_SUBTRACT: GLenum = 0x800A`\n* **Group:** BlendEquationModeEXT"]
pub const GL_FUNC_SUBTRACT: GLenum = 0x800A;
#[doc = "`GL_GENERATE_MIPMAP_HINT: GLenum = 0x8192`\n* **Group:** HintTarget"]
pub const GL_GENERATE_MIPMAP_HINT: GLenum = 0x8192;
#[doc = "`GL_GEQUAL: GLenum = 0x0206`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_GEQUAL: GLenum = 0x0206;
#[doc = "`GL_GREATER: GLenum = 0x0204`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_GREATER: GLenum = 0x0204;
#[doc = "`GL_GREEN: GLenum = 0x1904`\n* **Groups:** TextureSwizzle, PixelFormat"]
pub const GL_GREEN: GLenum = 0x1904;
#[doc = "`GL_GREEN_BITS: GLenum = 0x0D53`\n* **Group:** GetPName"]
pub const GL_GREEN_BITS: GLenum = 0x0D53;
#[doc = "`GL_HALF_FLOAT: GLenum = 0x140B`\n* **Groups:** VertexAttribPointerType, VertexAttribType"]
pub const GL_HALF_FLOAT: GLenum = 0x140B;
#[doc = "`GL_HIGH_FLOAT: GLenum = 0x8DF2`\n* **Group:** PrecisionType"]
pub const GL_HIGH_FLOAT: GLenum = 0x8DF2;
#[doc = "`GL_HIGH_INT: GLenum = 0x8DF5`\n* **Group:** PrecisionType"]
pub const GL_HIGH_INT: GLenum = 0x8DF5;
#[doc = "`GL_IMPLEMENTATION_COLOR_READ_FORMAT: GLenum = 0x8B9B`\n* **Groups:** GetFramebufferParameter, GetPName"]
pub const GL_IMPLEMENTATION_COLOR_READ_FORMAT: GLenum = 0x8B9B;
#[doc = "`GL_IMPLEMENTATION_COLOR_READ_TYPE: GLenum = 0x8B9A`\n* **Groups:** GetFramebufferParameter, GetPName"]
pub const GL_IMPLEMENTATION_COLOR_READ_TYPE: GLenum = 0x8B9A;
#[doc = "`GL_INCR: GLenum = 0x1E02`\n* **Group:** StencilOp"]
pub const GL_INCR: GLenum = 0x1E02;
#[doc = "`GL_INCR_WRAP: GLenum = 0x8507`\n* **Group:** StencilOp"]
pub const GL_INCR_WRAP: GLenum = 0x8507;
#[doc = "`GL_INFO_LOG_LENGTH: GLenum = 0x8B84`\n* **Groups:** ProgramPropertyARB, ShaderParameterName, PipelineParameterName"]
pub const GL_INFO_LOG_LENGTH: GLenum = 0x8B84;
#[doc = "`GL_INT: GLenum = 0x1404`\n* **Groups:** VertexAttribIType, SecondaryColorPointerTypeIBM, WeightPointerTypeARB, TangentPointerTypeEXT, BinormalPointerTypeEXT, IndexPointerType, ListNameType, NormalPointerType, PixelType, TexCoordPointerType, VertexPointerType, VertexAttribType, AttributeType, UniformType, VertexAttribPointerType, GlslTypeToken"]
pub const GL_INT: GLenum = 0x1404;
#[doc = "`GL_INTERLEAVED_ATTRIBS: GLenum = 0x8C8C`\n* **Group:** TransformFeedbackBufferMode"]
pub const GL_INTERLEAVED_ATTRIBS: GLenum = 0x8C8C;
#[doc = "`GL_INT_2_10_10_10_REV: GLenum = 0x8D9F`\n* **Groups:** VertexAttribPointerType, VertexAttribType"]
pub const GL_INT_2_10_10_10_REV: GLenum = 0x8D9F;
#[doc = "`GL_INT_SAMPLER_2D: GLenum = 0x8DCA`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_SAMPLER_2D: GLenum = 0x8DCA;
#[doc = "`GL_INT_SAMPLER_2D_ARRAY: GLenum = 0x8DCF`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_SAMPLER_2D_ARRAY: GLenum = 0x8DCF;
#[doc = "`GL_INT_SAMPLER_3D: GLenum = 0x8DCB`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_SAMPLER_3D: GLenum = 0x8DCB;
#[doc = "`GL_INT_SAMPLER_CUBE: GLenum = 0x8DCC`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_SAMPLER_CUBE: GLenum = 0x8DCC;
#[doc = "`GL_INT_VEC2: GLenum = 0x8B53`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_VEC2: GLenum = 0x8B53;
#[doc = "`GL_INT_VEC3: GLenum = 0x8B54`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_VEC3: GLenum = 0x8B54;
#[doc = "`GL_INT_VEC4: GLenum = 0x8B55`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_INT_VEC4: GLenum = 0x8B55;
#[doc = "`GL_INVALID_ENUM: GLenum = 0x0500`\n* **Group:** ErrorCode"]
pub const GL_INVALID_ENUM: GLenum = 0x0500;
#[doc = "`GL_INVALID_FRAMEBUFFER_OPERATION: GLenum = 0x0506`\n* **Group:** ErrorCode"]
pub const GL_INVALID_FRAMEBUFFER_OPERATION: GLenum = 0x0506;
#[doc = "`GL_INVALID_INDEX: GLenum = 0xFFFFFFFF`"]
pub const GL_INVALID_INDEX: GLenum = 0xFFFFFFFF;
#[doc = "`GL_INVALID_OPERATION: GLenum = 0x0502`\n* **Group:** ErrorCode"]
pub const GL_INVALID_OPERATION: GLenum = 0x0502;
#[doc = "`GL_INVALID_VALUE: GLenum = 0x0501`\n* **Group:** ErrorCode"]
pub const GL_INVALID_VALUE: GLenum = 0x0501;
#[doc = "`GL_INVERT: GLenum = 0x150A`\n* **Groups:** PathFillMode, LogicOp, StencilOp"]
pub const GL_INVERT: GLenum = 0x150A;
#[doc = "`GL_KEEP: GLenum = 0x1E00`\n* **Group:** StencilOp"]
pub const GL_KEEP: GLenum = 0x1E00;
#[doc = "`GL_LEQUAL: GLenum = 0x0203`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_LEQUAL: GLenum = 0x0203;
#[doc = "`GL_LESS: GLenum = 0x0201`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_LESS: GLenum = 0x0201;
#[doc = "`GL_LINEAR: GLenum = 0x2601`\n* **Groups:** BlitFramebufferFilter, FogMode, TextureMagFilter, TextureMinFilter"]
pub const GL_LINEAR: GLenum = 0x2601;
#[doc = "`GL_LINEAR_MIPMAP_LINEAR: GLenum = 0x2703`\n* **Groups:** TextureWrapMode, TextureMinFilter"]
pub const GL_LINEAR_MIPMAP_LINEAR: GLenum = 0x2703;
#[doc = "`GL_LINEAR_MIPMAP_NEAREST: GLenum = 0x2701`\n* **Group:** TextureMinFilter"]
pub const GL_LINEAR_MIPMAP_NEAREST: GLenum = 0x2701;
#[doc = "`GL_LINES: GLenum = 0x0001`\n* **Group:** PrimitiveType"]
pub const GL_LINES: GLenum = 0x0001;
#[doc = "`GL_LINE_LOOP: GLenum = 0x0002`\n* **Group:** PrimitiveType"]
pub const GL_LINE_LOOP: GLenum = 0x0002;
#[doc = "`GL_LINE_STRIP: GLenum = 0x0003`\n* **Group:** PrimitiveType"]
pub const GL_LINE_STRIP: GLenum = 0x0003;
#[doc = "`GL_LINE_WIDTH: GLenum = 0x0B21`\n* **Group:** GetPName"]
pub const GL_LINE_WIDTH: GLenum = 0x0B21;
#[doc = "`GL_LINK_STATUS: GLenum = 0x8B82`\n* **Group:** ProgramPropertyARB"]
pub const GL_LINK_STATUS: GLenum = 0x8B82;
#[doc = "`GL_LOW_FLOAT: GLenum = 0x8DF0`\n* **Group:** PrecisionType"]
pub const GL_LOW_FLOAT: GLenum = 0x8DF0;
#[doc = "`GL_LOW_INT: GLenum = 0x8DF3`\n* **Group:** PrecisionType"]
pub const GL_LOW_INT: GLenum = 0x8DF3;
#[doc = "`GL_LUMINANCE: GLenum = 0x1909`\n* **Groups:** PixelTexGenMode, PathColorFormat, PixelFormat"]
pub const GL_LUMINANCE: GLenum = 0x1909;
#[doc = "`GL_LUMINANCE_ALPHA: GLenum = 0x190A`\n* **Groups:** PixelTexGenMode, PathColorFormat, PixelFormat"]
pub const GL_LUMINANCE_ALPHA: GLenum = 0x190A;
#[doc = "`GL_MAJOR_VERSION: GLenum = 0x821B`\n* **Group:** GetPName"]
pub const GL_MAJOR_VERSION: GLenum = 0x821B;
#[doc = "`GL_MAP_FLUSH_EXPLICIT_BIT: GLbitfield = 0x0010`\n* **Group:** MapBufferAccessMask"]
pub const GL_MAP_FLUSH_EXPLICIT_BIT: GLbitfield = 0x0010;
#[doc = "`GL_MAP_INVALIDATE_BUFFER_BIT: GLbitfield = 0x0008`\n* **Group:** MapBufferAccessMask"]
pub const GL_MAP_INVALIDATE_BUFFER_BIT: GLbitfield = 0x0008;
#[doc = "`GL_MAP_INVALIDATE_RANGE_BIT: GLbitfield = 0x0004`\n* **Group:** MapBufferAccessMask"]
pub const GL_MAP_INVALIDATE_RANGE_BIT: GLbitfield = 0x0004;
#[doc = "`GL_MAP_READ_BIT: GLbitfield = 0x0001`\n* **Groups:** MapBufferAccessMask, BufferStorageMask"]
pub const GL_MAP_READ_BIT: GLbitfield = 0x0001;
#[doc = "`GL_MAP_UNSYNCHRONIZED_BIT: GLbitfield = 0x0020`\n* **Group:** MapBufferAccessMask"]
pub const GL_MAP_UNSYNCHRONIZED_BIT: GLbitfield = 0x0020;
#[doc = "`GL_MAP_WRITE_BIT: GLbitfield = 0x0002`\n* **Groups:** MapBufferAccessMask, BufferStorageMask"]
pub const GL_MAP_WRITE_BIT: GLbitfield = 0x0002;
#[doc = "`GL_MAX: GLenum = 0x8008`\n* **Group:** BlendEquationModeEXT"]
pub const GL_MAX: GLenum = 0x8008;
#[doc = "`GL_MAX_3D_TEXTURE_SIZE: GLenum = 0x8073`\n* **Group:** GetPName"]
pub const GL_MAX_3D_TEXTURE_SIZE: GLenum = 0x8073;
#[doc = "`GL_MAX_ARRAY_TEXTURE_LAYERS: GLenum = 0x88FF`\n* **Group:** GetPName"]
pub const GL_MAX_ARRAY_TEXTURE_LAYERS: GLenum = 0x88FF;
#[doc = "`GL_MAX_COLOR_ATTACHMENTS: GLenum = 0x8CDF`"]
pub const GL_MAX_COLOR_ATTACHMENTS: GLenum = 0x8CDF;
#[doc = "`GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum = 0x8A33`\n* **Group:** GetPName"]
pub const GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum = 0x8A33;
#[doc = "`GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum = 0x8B4D`\n* **Group:** GetPName"]
pub const GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum = 0x8B4D;
#[doc = "`GL_MAX_COMBINED_UNIFORM_BLOCKS: GLenum = 0x8A2E`\n* **Group:** GetPName"]
pub const GL_MAX_COMBINED_UNIFORM_BLOCKS: GLenum = 0x8A2E;
#[doc = "`GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum = 0x8A31`\n* **Group:** GetPName"]
pub const GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum = 0x8A31;
#[doc = "`GL_MAX_CUBE_MAP_TEXTURE_SIZE: GLenum = 0x851C`\n* **Group:** GetPName"]
pub const GL_MAX_CUBE_MAP_TEXTURE_SIZE: GLenum = 0x851C;
#[doc = "`GL_MAX_DRAW_BUFFERS: GLenum = 0x8824`\n* **Group:** GetPName"]
pub const GL_MAX_DRAW_BUFFERS: GLenum = 0x8824;
#[doc = "`GL_MAX_ELEMENTS_INDICES: GLenum = 0x80E9`\n* **Group:** GetPName"]
pub const GL_MAX_ELEMENTS_INDICES: GLenum = 0x80E9;
#[doc = "`GL_MAX_ELEMENTS_VERTICES: GLenum = 0x80E8`\n* **Group:** GetPName"]
pub const GL_MAX_ELEMENTS_VERTICES: GLenum = 0x80E8;
#[doc = "`GL_MAX_ELEMENT_INDEX: GLenum = 0x8D6B`\n* **Group:** GetPName"]
pub const GL_MAX_ELEMENT_INDEX: GLenum = 0x8D6B;
#[doc = "`GL_MAX_FRAGMENT_INPUT_COMPONENTS: GLenum = 0x9125`\n* **Group:** GetPName"]
pub const GL_MAX_FRAGMENT_INPUT_COMPONENTS: GLenum = 0x9125;
#[doc = "`GL_MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum = 0x8A2D`\n* **Group:** GetPName"]
pub const GL_MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum = 0x8A2D;
#[doc = "`GL_MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum = 0x8B49`\n* **Group:** GetPName"]
pub const GL_MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum = 0x8B49;
#[doc = "`GL_MAX_FRAGMENT_UNIFORM_VECTORS: GLenum = 0x8DFD`\n* **Group:** GetPName"]
pub const GL_MAX_FRAGMENT_UNIFORM_VECTORS: GLenum = 0x8DFD;
#[doc = "`GL_MAX_PROGRAM_TEXEL_OFFSET: GLenum = 0x8905`\n* **Group:** GetPName"]
pub const GL_MAX_PROGRAM_TEXEL_OFFSET: GLenum = 0x8905;
#[doc = "`GL_MAX_RENDERBUFFER_SIZE: GLenum = 0x84E8`\n* **Group:** GetPName"]
pub const GL_MAX_RENDERBUFFER_SIZE: GLenum = 0x84E8;
#[doc = "`GL_MAX_SAMPLES: GLenum = 0x8D57`"]
pub const GL_MAX_SAMPLES: GLenum = 0x8D57;
#[doc = "`GL_MAX_SERVER_WAIT_TIMEOUT: GLenum = 0x9111`\n* **Group:** GetPName"]
pub const GL_MAX_SERVER_WAIT_TIMEOUT: GLenum = 0x9111;
#[doc = "`GL_MAX_TEXTURE_IMAGE_UNITS: GLenum = 0x8872`\n* **Group:** GetPName"]
pub const GL_MAX_TEXTURE_IMAGE_UNITS: GLenum = 0x8872;
#[doc = "`GL_MAX_TEXTURE_LOD_BIAS: GLenum = 0x84FD`\n* **Group:** GetPName"]
pub const GL_MAX_TEXTURE_LOD_BIAS: GLenum = 0x84FD;
#[doc = "`GL_MAX_TEXTURE_SIZE: GLenum = 0x0D33`\n* **Group:** GetPName"]
pub const GL_MAX_TEXTURE_SIZE: GLenum = 0x0D33;
#[doc = "`GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum = 0x8C8A`"]
pub const GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum = 0x8C8A;
#[doc = "`GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum = 0x8C8B`"]
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum = 0x8C8B;
#[doc = "`GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum = 0x8C80`"]
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum = 0x8C80;
#[doc = "`GL_MAX_UNIFORM_BLOCK_SIZE: GLenum = 0x8A30`\n* **Group:** GetPName"]
pub const GL_MAX_UNIFORM_BLOCK_SIZE: GLenum = 0x8A30;
#[doc = "`GL_MAX_UNIFORM_BUFFER_BINDINGS: GLenum = 0x8A2F`\n* **Group:** GetPName"]
pub const GL_MAX_UNIFORM_BUFFER_BINDINGS: GLenum = 0x8A2F;
#[doc = "`GL_MAX_VARYING_COMPONENTS: GLenum = 0x8B4B`\n* **Group:** GetPName\n* **Alias Of:** `MAX_VARYING_FLOATS`"]
pub const GL_MAX_VARYING_COMPONENTS: GLenum = 0x8B4B;
#[doc = "`GL_MAX_VARYING_VECTORS: GLenum = 0x8DFC`\n* **Group:** GetPName"]
pub const GL_MAX_VARYING_VECTORS: GLenum = 0x8DFC;
#[doc = "`GL_MAX_VERTEX_ATTRIBS: GLenum = 0x8869`\n* **Group:** GetPName"]
pub const GL_MAX_VERTEX_ATTRIBS: GLenum = 0x8869;
#[doc = "`GL_MAX_VERTEX_OUTPUT_COMPONENTS: GLenum = 0x9122`\n* **Group:** GetPName"]
pub const GL_MAX_VERTEX_OUTPUT_COMPONENTS: GLenum = 0x9122;
#[doc = "`GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum = 0x8B4C`\n* **Group:** GetPName"]
pub const GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum = 0x8B4C;
#[doc = "`GL_MAX_VERTEX_UNIFORM_BLOCKS: GLenum = 0x8A2B`\n* **Group:** GetPName"]
pub const GL_MAX_VERTEX_UNIFORM_BLOCKS: GLenum = 0x8A2B;
#[doc = "`GL_MAX_VERTEX_UNIFORM_COMPONENTS: GLenum = 0x8B4A`\n* **Group:** GetPName"]
pub const GL_MAX_VERTEX_UNIFORM_COMPONENTS: GLenum = 0x8B4A;
#[doc = "`GL_MAX_VERTEX_UNIFORM_VECTORS: GLenum = 0x8DFB`\n* **Group:** GetPName"]
pub const GL_MAX_VERTEX_UNIFORM_VECTORS: GLenum = 0x8DFB;
#[doc = "`GL_MAX_VIEWPORT_DIMS: GLenum = 0x0D3A`\n* **Group:** GetPName"]
pub const GL_MAX_VIEWPORT_DIMS: GLenum = 0x0D3A;
#[doc = "`GL_MEDIUM_FLOAT: GLenum = 0x8DF1`\n* **Group:** PrecisionType"]
pub const GL_MEDIUM_FLOAT: GLenum = 0x8DF1;
#[doc = "`GL_MEDIUM_INT: GLenum = 0x8DF4`\n* **Group:** PrecisionType"]
pub const GL_MEDIUM_INT: GLenum = 0x8DF4;
#[doc = "`GL_MIN: GLenum = 0x8007`\n* **Group:** BlendEquationModeEXT"]
pub const GL_MIN: GLenum = 0x8007;
#[doc = "`GL_MINOR_VERSION: GLenum = 0x821C`\n* **Group:** GetPName"]
pub const GL_MINOR_VERSION: GLenum = 0x821C;
#[doc = "`GL_MIN_PROGRAM_TEXEL_OFFSET: GLenum = 0x8904`\n* **Group:** GetPName"]
pub const GL_MIN_PROGRAM_TEXEL_OFFSET: GLenum = 0x8904;
#[doc = "`GL_MIRRORED_REPEAT: GLenum = 0x8370`\n* **Group:** TextureWrapMode"]
pub const GL_MIRRORED_REPEAT: GLenum = 0x8370;
#[doc = "`GL_NEAREST: GLenum = 0x2600`\n* **Groups:** BlitFramebufferFilter, TextureMagFilter, TextureMinFilter"]
pub const GL_NEAREST: GLenum = 0x2600;
#[doc = "`GL_NEAREST_MIPMAP_LINEAR: GLenum = 0x2702`\n* **Group:** TextureMinFilter"]
pub const GL_NEAREST_MIPMAP_LINEAR: GLenum = 0x2702;
#[doc = "`GL_NEAREST_MIPMAP_NEAREST: GLenum = 0x2700`\n* **Group:** TextureMinFilter"]
pub const GL_NEAREST_MIPMAP_NEAREST: GLenum = 0x2700;
#[doc = "`GL_NEVER: GLenum = 0x0200`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_NEVER: GLenum = 0x0200;
#[doc = "`GL_NICEST: GLenum = 0x1102`\n* **Group:** HintMode"]
pub const GL_NICEST: GLenum = 0x1102;
#[doc = "`GL_NONE: GLenum = 0`\n* **Groups:** TextureCompareMode, PathColorFormat, CombinerBiasNV, CombinerScaleNV, DrawBufferMode, PixelTexGenMode, ReadBufferMode, ColorBuffer, PathGenMode, PathTransformType, PathFontStyle"]
pub const GL_NONE: GLenum = 0;
#[doc = "`GL_NOTEQUAL: GLenum = 0x0205`\n* **Groups:** StencilFunction, IndexFunctionEXT, AlphaFunction, DepthFunction"]
pub const GL_NOTEQUAL: GLenum = 0x0205;
#[doc = "`GL_NO_ERROR: GLenum = 0`\n* **Groups:** GraphicsResetStatus, ErrorCode"]
pub const GL_NO_ERROR: GLenum = 0;
#[doc = "`GL_NUM_COMPRESSED_TEXTURE_FORMATS: GLenum = 0x86A2`\n* **Group:** GetPName"]
pub const GL_NUM_COMPRESSED_TEXTURE_FORMATS: GLenum = 0x86A2;
#[doc = "`GL_NUM_EXTENSIONS: GLenum = 0x821D`\n* **Group:** GetPName"]
pub const GL_NUM_EXTENSIONS: GLenum = 0x821D;
#[doc = "`GL_NUM_PROGRAM_BINARY_FORMATS: GLenum = 0x87FE`\n* **Group:** GetPName"]
pub const GL_NUM_PROGRAM_BINARY_FORMATS: GLenum = 0x87FE;
#[doc = "`GL_NUM_SAMPLE_COUNTS: GLenum = 0x9380`\n* **Group:** InternalFormatPName"]
pub const GL_NUM_SAMPLE_COUNTS: GLenum = 0x9380;
#[doc = "`GL_NUM_SHADER_BINARY_FORMATS: GLenum = 0x8DF9`\n* **Group:** GetPName"]
pub const GL_NUM_SHADER_BINARY_FORMATS: GLenum = 0x8DF9;
#[doc = "`GL_OBJECT_TYPE: GLenum = 0x9112`\n* **Group:** SyncParameterName"]
pub const GL_OBJECT_TYPE: GLenum = 0x9112;
#[doc = "`GL_ONE: GLenum = 1`\n* **Groups:** TextureSwizzle, BlendingFactor"]
pub const GL_ONE: GLenum = 1;
#[doc = "`GL_ONE_MINUS_CONSTANT_ALPHA: GLenum = 0x8004`\n* **Group:** BlendingFactor"]
pub const GL_ONE_MINUS_CONSTANT_ALPHA: GLenum = 0x8004;
#[doc = "`GL_ONE_MINUS_CONSTANT_COLOR: GLenum = 0x8002`\n* **Group:** BlendingFactor"]
pub const GL_ONE_MINUS_CONSTANT_COLOR: GLenum = 0x8002;
#[doc = "`GL_ONE_MINUS_DST_ALPHA: GLenum = 0x0305`\n* **Group:** BlendingFactor"]
pub const GL_ONE_MINUS_DST_ALPHA: GLenum = 0x0305;
#[doc = "`GL_ONE_MINUS_DST_COLOR: GLenum = 0x0307`\n* **Group:** BlendingFactor"]
pub const GL_ONE_MINUS_DST_COLOR: GLenum = 0x0307;
#[doc = "`GL_ONE_MINUS_SRC_ALPHA: GLenum = 0x0303`\n* **Group:** BlendingFactor"]
pub const GL_ONE_MINUS_SRC_ALPHA: GLenum = 0x0303;
#[doc = "`GL_ONE_MINUS_SRC_COLOR: GLenum = 0x0301`\n* **Group:** BlendingFactor"]
pub const GL_ONE_MINUS_SRC_COLOR: GLenum = 0x0301;
#[doc = "`GL_OUT_OF_MEMORY: GLenum = 0x0505`\n* **Group:** ErrorCode"]
pub const GL_OUT_OF_MEMORY: GLenum = 0x0505;
#[doc = "`GL_PACK_ALIGNMENT: GLenum = 0x0D05`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_PACK_ALIGNMENT: GLenum = 0x0D05;
#[doc = "`GL_PACK_ROW_LENGTH: GLenum = 0x0D02`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_PACK_ROW_LENGTH: GLenum = 0x0D02;
#[doc = "`GL_PACK_SKIP_PIXELS: GLenum = 0x0D04`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_PACK_SKIP_PIXELS: GLenum = 0x0D04;
#[doc = "`GL_PACK_SKIP_ROWS: GLenum = 0x0D03`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_PACK_SKIP_ROWS: GLenum = 0x0D03;
#[doc = "`GL_PIXEL_PACK_BUFFER: GLenum = 0x88EB`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_PIXEL_PACK_BUFFER: GLenum = 0x88EB;
#[doc = "`GL_PIXEL_PACK_BUFFER_BINDING: GLenum = 0x88ED`\n* **Group:** GetPName"]
pub const GL_PIXEL_PACK_BUFFER_BINDING: GLenum = 0x88ED;
#[doc = "`GL_PIXEL_UNPACK_BUFFER: GLenum = 0x88EC`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_PIXEL_UNPACK_BUFFER: GLenum = 0x88EC;
#[doc = "`GL_PIXEL_UNPACK_BUFFER_BINDING: GLenum = 0x88EF`\n* **Group:** GetPName"]
pub const GL_PIXEL_UNPACK_BUFFER_BINDING: GLenum = 0x88EF;
#[doc = "`GL_POINTS: GLenum = 0x0000`\n* **Group:** PrimitiveType"]
pub const GL_POINTS: GLenum = 0x0000;
#[doc = "`GL_POLYGON_OFFSET_FACTOR: GLenum = 0x8038`\n* **Group:** GetPName"]
pub const GL_POLYGON_OFFSET_FACTOR: GLenum = 0x8038;
#[doc = "`GL_POLYGON_OFFSET_FILL: GLenum = 0x8037`\n* **Groups:** GetPName, EnableCap"]
pub const GL_POLYGON_OFFSET_FILL: GLenum = 0x8037;
#[doc = "`GL_POLYGON_OFFSET_UNITS: GLenum = 0x2A00`\n* **Group:** GetPName"]
pub const GL_POLYGON_OFFSET_UNITS: GLenum = 0x2A00;
#[doc = "`GL_PRIMITIVE_RESTART_FIXED_INDEX: GLenum = 0x8D69`\n* **Group:** EnableCap"]
pub const GL_PRIMITIVE_RESTART_FIXED_INDEX: GLenum = 0x8D69;
#[doc = "`GL_PROGRAM_BINARY_FORMATS: GLenum = 0x87FF`\n* **Group:** GetPName"]
pub const GL_PROGRAM_BINARY_FORMATS: GLenum = 0x87FF;
#[doc = "`GL_PROGRAM_BINARY_LENGTH: GLenum = 0x8741`\n* **Group:** ProgramPropertyARB"]
pub const GL_PROGRAM_BINARY_LENGTH: GLenum = 0x8741;
#[doc = "`GL_PROGRAM_BINARY_RETRIEVABLE_HINT: GLenum = 0x8257`\n* **Groups:** ProgramParameterPName, HintTarget"]
pub const GL_PROGRAM_BINARY_RETRIEVABLE_HINT: GLenum = 0x8257;
#[doc = "`GL_QUERY_RESULT: GLenum = 0x8866`\n* **Group:** QueryObjectParameterName"]
pub const GL_QUERY_RESULT: GLenum = 0x8866;
#[doc = "`GL_QUERY_RESULT_AVAILABLE: GLenum = 0x8867`\n* **Group:** QueryObjectParameterName"]
pub const GL_QUERY_RESULT_AVAILABLE: GLenum = 0x8867;
#[doc = "`GL_R11F_G11F_B10F: GLenum = 0x8C3A`\n* **Group:** InternalFormat"]
pub const GL_R11F_G11F_B10F: GLenum = 0x8C3A;
#[doc = "`GL_R16F: GLenum = 0x822D`\n* **Group:** InternalFormat"]
pub const GL_R16F: GLenum = 0x822D;
#[doc = "`GL_R16I: GLenum = 0x8233`\n* **Group:** InternalFormat"]
pub const GL_R16I: GLenum = 0x8233;
#[doc = "`GL_R16UI: GLenum = 0x8234`\n* **Group:** InternalFormat"]
pub const GL_R16UI: GLenum = 0x8234;
#[doc = "`GL_R32F: GLenum = 0x822E`\n* **Group:** InternalFormat"]
pub const GL_R32F: GLenum = 0x822E;
#[doc = "`GL_R32I: GLenum = 0x8235`\n* **Group:** InternalFormat"]
pub const GL_R32I: GLenum = 0x8235;
#[doc = "`GL_R32UI: GLenum = 0x8236`\n* **Group:** InternalFormat"]
pub const GL_R32UI: GLenum = 0x8236;
#[doc = "`GL_R8: GLenum = 0x8229`\n* **Group:** InternalFormat"]
pub const GL_R8: GLenum = 0x8229;
#[doc = "`GL_R8I: GLenum = 0x8231`\n* **Group:** InternalFormat"]
pub const GL_R8I: GLenum = 0x8231;
#[doc = "`GL_R8UI: GLenum = 0x8232`\n* **Group:** InternalFormat"]
pub const GL_R8UI: GLenum = 0x8232;
#[doc = "`GL_R8_SNORM: GLenum = 0x8F94`\n* **Group:** InternalFormat"]
pub const GL_R8_SNORM: GLenum = 0x8F94;
#[doc = "`GL_RASTERIZER_DISCARD: GLenum = 0x8C89`\n* **Group:** EnableCap"]
pub const GL_RASTERIZER_DISCARD: GLenum = 0x8C89;
#[doc = "`GL_READ_BUFFER: GLenum = 0x0C02`\n* **Group:** GetPName"]
pub const GL_READ_BUFFER: GLenum = 0x0C02;
#[doc = "`GL_READ_FRAMEBUFFER: GLenum = 0x8CA8`\n* **Groups:** CheckFramebufferStatusTarget, FramebufferTarget"]
pub const GL_READ_FRAMEBUFFER: GLenum = 0x8CA8;
#[doc = "`GL_READ_FRAMEBUFFER_BINDING: GLenum = 0x8CAA`\n* **Group:** GetPName"]
pub const GL_READ_FRAMEBUFFER_BINDING: GLenum = 0x8CAA;
#[doc = "`GL_RED: GLenum = 0x1903`\n* **Groups:** TextureSwizzle, PixelFormat, InternalFormat"]
pub const GL_RED: GLenum = 0x1903;
#[doc = "`GL_RED_BITS: GLenum = 0x0D52`\n* **Group:** GetPName"]
pub const GL_RED_BITS: GLenum = 0x0D52;
#[doc = "`GL_RED_INTEGER: GLenum = 0x8D94`\n* **Group:** PixelFormat"]
pub const GL_RED_INTEGER: GLenum = 0x8D94;
#[doc = "`GL_RENDERBUFFER: GLenum = 0x8D41`\n* **Groups:** ObjectIdentifier, RenderbufferTarget, CopyImageSubDataTarget"]
pub const GL_RENDERBUFFER: GLenum = 0x8D41;
#[doc = "`GL_RENDERBUFFER_ALPHA_SIZE: GLenum = 0x8D53`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_ALPHA_SIZE: GLenum = 0x8D53;
#[doc = "`GL_RENDERBUFFER_BINDING: GLenum = 0x8CA7`\n* **Group:** GetPName"]
pub const GL_RENDERBUFFER_BINDING: GLenum = 0x8CA7;
#[doc = "`GL_RENDERBUFFER_BLUE_SIZE: GLenum = 0x8D52`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_BLUE_SIZE: GLenum = 0x8D52;
#[doc = "`GL_RENDERBUFFER_DEPTH_SIZE: GLenum = 0x8D54`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_DEPTH_SIZE: GLenum = 0x8D54;
#[doc = "`GL_RENDERBUFFER_GREEN_SIZE: GLenum = 0x8D51`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_GREEN_SIZE: GLenum = 0x8D51;
#[doc = "`GL_RENDERBUFFER_HEIGHT: GLenum = 0x8D43`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_HEIGHT: GLenum = 0x8D43;
#[doc = "`GL_RENDERBUFFER_INTERNAL_FORMAT: GLenum = 0x8D44`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_INTERNAL_FORMAT: GLenum = 0x8D44;
#[doc = "`GL_RENDERBUFFER_RED_SIZE: GLenum = 0x8D50`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_RED_SIZE: GLenum = 0x8D50;
#[doc = "`GL_RENDERBUFFER_SAMPLES: GLenum = 0x8CAB`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_SAMPLES: GLenum = 0x8CAB;
#[doc = "`GL_RENDERBUFFER_STENCIL_SIZE: GLenum = 0x8D55`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_STENCIL_SIZE: GLenum = 0x8D55;
#[doc = "`GL_RENDERBUFFER_WIDTH: GLenum = 0x8D42`\n* **Group:** RenderbufferParameterName"]
pub const GL_RENDERBUFFER_WIDTH: GLenum = 0x8D42;
#[doc = "`GL_RENDERER: GLenum = 0x1F01`\n* **Group:** StringName"]
pub const GL_RENDERER: GLenum = 0x1F01;
#[doc = "`GL_REPEAT: GLenum = 0x2901`\n* **Group:** TextureWrapMode"]
pub const GL_REPEAT: GLenum = 0x2901;
#[doc = "`GL_REPLACE: GLenum = 0x1E01`\n* **Groups:** StencilOp, LightEnvModeSGIX"]
pub const GL_REPLACE: GLenum = 0x1E01;
#[doc = "`GL_RG: GLenum = 0x8227`\n* **Groups:** InternalFormat, PixelFormat"]
pub const GL_RG: GLenum = 0x8227;
#[doc = "`GL_RG16F: GLenum = 0x822F`\n* **Group:** InternalFormat"]
pub const GL_RG16F: GLenum = 0x822F;
#[doc = "`GL_RG16I: GLenum = 0x8239`\n* **Group:** InternalFormat"]
pub const GL_RG16I: GLenum = 0x8239;
#[doc = "`GL_RG16UI: GLenum = 0x823A`\n* **Group:** InternalFormat"]
pub const GL_RG16UI: GLenum = 0x823A;
#[doc = "`GL_RG32F: GLenum = 0x8230`\n* **Group:** InternalFormat"]
pub const GL_RG32F: GLenum = 0x8230;
#[doc = "`GL_RG32I: GLenum = 0x823B`\n* **Group:** InternalFormat"]
pub const GL_RG32I: GLenum = 0x823B;
#[doc = "`GL_RG32UI: GLenum = 0x823C`\n* **Group:** InternalFormat"]
pub const GL_RG32UI: GLenum = 0x823C;
#[doc = "`GL_RG8: GLenum = 0x822B`\n* **Group:** InternalFormat"]
pub const GL_RG8: GLenum = 0x822B;
#[doc = "`GL_RG8I: GLenum = 0x8237`\n* **Group:** InternalFormat"]
pub const GL_RG8I: GLenum = 0x8237;
#[doc = "`GL_RG8UI: GLenum = 0x8238`\n* **Group:** InternalFormat"]
pub const GL_RG8UI: GLenum = 0x8238;
#[doc = "`GL_RG8_SNORM: GLenum = 0x8F95`\n* **Group:** InternalFormat"]
pub const GL_RG8_SNORM: GLenum = 0x8F95;
#[doc = "`GL_RGB: GLenum = 0x1907`\n* **Groups:** PixelTexGenMode, CombinerPortionNV, PathColorFormat, CombinerComponentUsageNV, PixelFormat, InternalFormat"]
pub const GL_RGB: GLenum = 0x1907;
#[doc = "`GL_RGB10_A2: GLenum = 0x8059`\n* **Group:** InternalFormat"]
pub const GL_RGB10_A2: GLenum = 0x8059;
#[doc = "`GL_RGB10_A2UI: GLenum = 0x906F`\n* **Group:** InternalFormat"]
pub const GL_RGB10_A2UI: GLenum = 0x906F;
#[doc = "`GL_RGB16F: GLenum = 0x881B`\n* **Group:** InternalFormat"]
pub const GL_RGB16F: GLenum = 0x881B;
#[doc = "`GL_RGB16I: GLenum = 0x8D89`\n* **Group:** InternalFormat"]
pub const GL_RGB16I: GLenum = 0x8D89;
#[doc = "`GL_RGB16UI: GLenum = 0x8D77`\n* **Group:** InternalFormat"]
pub const GL_RGB16UI: GLenum = 0x8D77;
#[doc = "`GL_RGB32F: GLenum = 0x8815`\n* **Group:** InternalFormat"]
pub const GL_RGB32F: GLenum = 0x8815;
#[doc = "`GL_RGB32I: GLenum = 0x8D83`\n* **Group:** InternalFormat"]
pub const GL_RGB32I: GLenum = 0x8D83;
#[doc = "`GL_RGB32UI: GLenum = 0x8D71`\n* **Group:** InternalFormat"]
pub const GL_RGB32UI: GLenum = 0x8D71;
#[doc = "`GL_RGB565: GLenum = 0x8D62`"]
pub const GL_RGB565: GLenum = 0x8D62;
#[doc = "`GL_RGB5_A1: GLenum = 0x8057`\n* **Group:** InternalFormat"]
pub const GL_RGB5_A1: GLenum = 0x8057;
#[doc = "`GL_RGB8: GLenum = 0x8051`\n* **Group:** InternalFormat"]
pub const GL_RGB8: GLenum = 0x8051;
#[doc = "`GL_RGB8I: GLenum = 0x8D8F`\n* **Group:** InternalFormat"]
pub const GL_RGB8I: GLenum = 0x8D8F;
#[doc = "`GL_RGB8UI: GLenum = 0x8D7D`\n* **Group:** InternalFormat"]
pub const GL_RGB8UI: GLenum = 0x8D7D;
#[doc = "`GL_RGB8_SNORM: GLenum = 0x8F96`\n* **Group:** InternalFormat"]
pub const GL_RGB8_SNORM: GLenum = 0x8F96;
#[doc = "`GL_RGB9_E5: GLenum = 0x8C3D`\n* **Group:** InternalFormat"]
pub const GL_RGB9_E5: GLenum = 0x8C3D;
#[doc = "`GL_RGBA: GLenum = 0x1908`\n* **Groups:** PixelTexGenMode, PathColorFormat, PixelFormat, InternalFormat"]
pub const GL_RGBA: GLenum = 0x1908;
#[doc = "`GL_RGBA16F: GLenum = 0x881A`\n* **Group:** InternalFormat"]
pub const GL_RGBA16F: GLenum = 0x881A;
#[doc = "`GL_RGBA16I: GLenum = 0x8D88`\n* **Group:** InternalFormat"]
pub const GL_RGBA16I: GLenum = 0x8D88;
#[doc = "`GL_RGBA16UI: GLenum = 0x8D76`\n* **Group:** InternalFormat"]
pub const GL_RGBA16UI: GLenum = 0x8D76;
#[doc = "`GL_RGBA32F: GLenum = 0x8814`\n* **Group:** InternalFormat"]
pub const GL_RGBA32F: GLenum = 0x8814;
#[doc = "`GL_RGBA32I: GLenum = 0x8D82`\n* **Group:** InternalFormat"]
pub const GL_RGBA32I: GLenum = 0x8D82;
#[doc = "`GL_RGBA32UI: GLenum = 0x8D70`\n* **Group:** InternalFormat"]
pub const GL_RGBA32UI: GLenum = 0x8D70;
#[doc = "`GL_RGBA4: GLenum = 0x8056`\n* **Group:** InternalFormat"]
pub const GL_RGBA4: GLenum = 0x8056;
#[doc = "`GL_RGBA8: GLenum = 0x8058`\n* **Group:** InternalFormat"]
pub const GL_RGBA8: GLenum = 0x8058;
#[doc = "`GL_RGBA8I: GLenum = 0x8D8E`\n* **Group:** InternalFormat"]
pub const GL_RGBA8I: GLenum = 0x8D8E;
#[doc = "`GL_RGBA8UI: GLenum = 0x8D7C`\n* **Group:** InternalFormat"]
pub const GL_RGBA8UI: GLenum = 0x8D7C;
#[doc = "`GL_RGBA8_SNORM: GLenum = 0x8F97`\n* **Group:** InternalFormat"]
pub const GL_RGBA8_SNORM: GLenum = 0x8F97;
#[doc = "`GL_RGBA_INTEGER: GLenum = 0x8D99`\n* **Group:** PixelFormat"]
pub const GL_RGBA_INTEGER: GLenum = 0x8D99;
#[doc = "`GL_RGB_INTEGER: GLenum = 0x8D98`\n* **Group:** PixelFormat"]
pub const GL_RGB_INTEGER: GLenum = 0x8D98;
#[doc = "`GL_RG_INTEGER: GLenum = 0x8228`\n* **Group:** PixelFormat"]
pub const GL_RG_INTEGER: GLenum = 0x8228;
#[doc = "`GL_SAMPLER_2D: GLenum = 0x8B5E`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_SAMPLER_2D: GLenum = 0x8B5E;
#[doc = "`GL_SAMPLER_2D_ARRAY: GLenum = 0x8DC1`\n* **Groups:** GlslTypeToken, UniformType"]
pub const GL_SAMPLER_2D_ARRAY: GLenum = 0x8DC1;
#[doc = "`GL_SAMPLER_2D_ARRAY_SHADOW: GLenum = 0x8DC4`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_SAMPLER_2D_ARRAY_SHADOW: GLenum = 0x8DC4;
#[doc = "`GL_SAMPLER_2D_SHADOW: GLenum = 0x8B62`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_SAMPLER_2D_SHADOW: GLenum = 0x8B62;
#[doc = "`GL_SAMPLER_3D: GLenum = 0x8B5F`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_SAMPLER_3D: GLenum = 0x8B5F;
#[doc = "`GL_SAMPLER_BINDING: GLenum = 0x8919`\n* **Group:** GetPName"]
pub const GL_SAMPLER_BINDING: GLenum = 0x8919;
#[doc = "`GL_SAMPLER_CUBE: GLenum = 0x8B60`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_SAMPLER_CUBE: GLenum = 0x8B60;
#[doc = "`GL_SAMPLER_CUBE_SHADOW: GLenum = 0x8DC5`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_SAMPLER_CUBE_SHADOW: GLenum = 0x8DC5;
#[doc = "`GL_SAMPLES: GLenum = 0x80A9`\n* **Groups:** GetFramebufferParameter, GetPName, InternalFormatPName"]
pub const GL_SAMPLES: GLenum = 0x80A9;
#[doc = "`GL_SAMPLE_ALPHA_TO_COVERAGE: GLenum = 0x809E`\n* **Group:** EnableCap"]
pub const GL_SAMPLE_ALPHA_TO_COVERAGE: GLenum = 0x809E;
#[doc = "`GL_SAMPLE_BUFFERS: GLenum = 0x80A8`\n* **Groups:** GetFramebufferParameter, GetPName"]
pub const GL_SAMPLE_BUFFERS: GLenum = 0x80A8;
#[doc = "`GL_SAMPLE_COVERAGE: GLenum = 0x80A0`\n* **Group:** EnableCap"]
pub const GL_SAMPLE_COVERAGE: GLenum = 0x80A0;
#[doc = "`GL_SAMPLE_COVERAGE_INVERT: GLenum = 0x80AB`\n* **Group:** GetPName"]
pub const GL_SAMPLE_COVERAGE_INVERT: GLenum = 0x80AB;
#[doc = "`GL_SAMPLE_COVERAGE_VALUE: GLenum = 0x80AA`\n* **Group:** GetPName"]
pub const GL_SAMPLE_COVERAGE_VALUE: GLenum = 0x80AA;
#[doc = "`GL_SCISSOR_BOX: GLenum = 0x0C10`\n* **Group:** GetPName"]
pub const GL_SCISSOR_BOX: GLenum = 0x0C10;
#[doc = "`GL_SCISSOR_TEST: GLenum = 0x0C11`\n* **Groups:** GetPName, EnableCap"]
pub const GL_SCISSOR_TEST: GLenum = 0x0C11;
#[doc = "`GL_SEPARATE_ATTRIBS: GLenum = 0x8C8D`\n* **Group:** TransformFeedbackBufferMode"]
pub const GL_SEPARATE_ATTRIBS: GLenum = 0x8C8D;
#[doc = "`GL_SHADER_BINARY_FORMATS: GLenum = 0x8DF8`"]
pub const GL_SHADER_BINARY_FORMATS: GLenum = 0x8DF8;
#[doc = "`GL_SHADER_COMPILER: GLenum = 0x8DFA`\n* **Group:** GetPName"]
pub const GL_SHADER_COMPILER: GLenum = 0x8DFA;
#[doc = "`GL_SHADER_SOURCE_LENGTH: GLenum = 0x8B88`\n* **Group:** ShaderParameterName"]
pub const GL_SHADER_SOURCE_LENGTH: GLenum = 0x8B88;
#[doc = "`GL_SHADER_TYPE: GLenum = 0x8B4F`\n* **Group:** ShaderParameterName"]
pub const GL_SHADER_TYPE: GLenum = 0x8B4F;
#[doc = "`GL_SHADING_LANGUAGE_VERSION: GLenum = 0x8B8C`\n* **Group:** StringName"]
pub const GL_SHADING_LANGUAGE_VERSION: GLenum = 0x8B8C;
#[doc = "`GL_SHORT: GLenum = 0x1402`\n* **Groups:** VertexAttribIType, SecondaryColorPointerTypeIBM, WeightPointerTypeARB, TangentPointerTypeEXT, BinormalPointerTypeEXT, IndexPointerType, ListNameType, NormalPointerType, PixelType, TexCoordPointerType, VertexPointerType, VertexAttribType, VertexAttribPointerType"]
pub const GL_SHORT: GLenum = 0x1402;
#[doc = "`GL_SIGNALED: GLenum = 0x9119`"]
pub const GL_SIGNALED: GLenum = 0x9119;
#[doc = "`GL_SIGNED_NORMALIZED: GLenum = 0x8F9C`"]
pub const GL_SIGNED_NORMALIZED: GLenum = 0x8F9C;
#[doc = "`GL_SRC_ALPHA: GLenum = 0x0302`\n* **Group:** BlendingFactor"]
pub const GL_SRC_ALPHA: GLenum = 0x0302;
#[doc = "`GL_SRC_ALPHA_SATURATE: GLenum = 0x0308`\n* **Group:** BlendingFactor"]
pub const GL_SRC_ALPHA_SATURATE: GLenum = 0x0308;
#[doc = "`GL_SRC_COLOR: GLenum = 0x0300`\n* **Group:** BlendingFactor"]
pub const GL_SRC_COLOR: GLenum = 0x0300;
#[doc = "`GL_SRGB: GLenum = 0x8C40`\n* **Group:** InternalFormat"]
pub const GL_SRGB: GLenum = 0x8C40;
#[doc = "`GL_SRGB8: GLenum = 0x8C41`\n* **Group:** InternalFormat"]
pub const GL_SRGB8: GLenum = 0x8C41;
#[doc = "`GL_SRGB8_ALPHA8: GLenum = 0x8C43`\n* **Group:** InternalFormat"]
pub const GL_SRGB8_ALPHA8: GLenum = 0x8C43;
#[doc = "`GL_STACK_OVERFLOW: GLenum = 0x0503`\n* **Group:** ErrorCode"]
pub const GL_STACK_OVERFLOW: GLenum = 0x0503;
#[doc = "`GL_STACK_UNDERFLOW: GLenum = 0x0504`\n* **Group:** ErrorCode"]
pub const GL_STACK_UNDERFLOW: GLenum = 0x0504;
#[doc = "`GL_STATIC_COPY: GLenum = 0x88E6`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_STATIC_COPY: GLenum = 0x88E6;
#[doc = "`GL_STATIC_DRAW: GLenum = 0x88E4`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_STATIC_DRAW: GLenum = 0x88E4;
#[doc = "`GL_STATIC_READ: GLenum = 0x88E5`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_STATIC_READ: GLenum = 0x88E5;
#[doc = "`GL_STENCIL: GLenum = 0x1802`\n* **Groups:** Buffer, PixelCopyType, InvalidateFramebufferAttachment"]
pub const GL_STENCIL: GLenum = 0x1802;
#[doc = "`GL_STENCIL_ATTACHMENT: GLenum = 0x8D20`\n* **Group:** FramebufferAttachment"]
pub const GL_STENCIL_ATTACHMENT: GLenum = 0x8D20;
#[doc = "`GL_STENCIL_BACK_FAIL: GLenum = 0x8801`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_FAIL: GLenum = 0x8801;
#[doc = "`GL_STENCIL_BACK_FUNC: GLenum = 0x8800`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_FUNC: GLenum = 0x8800;
#[doc = "`GL_STENCIL_BACK_PASS_DEPTH_FAIL: GLenum = 0x8802`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_PASS_DEPTH_FAIL: GLenum = 0x8802;
#[doc = "`GL_STENCIL_BACK_PASS_DEPTH_PASS: GLenum = 0x8803`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_PASS_DEPTH_PASS: GLenum = 0x8803;
#[doc = "`GL_STENCIL_BACK_REF: GLenum = 0x8CA3`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_REF: GLenum = 0x8CA3;
#[doc = "`GL_STENCIL_BACK_VALUE_MASK: GLenum = 0x8CA4`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_VALUE_MASK: GLenum = 0x8CA4;
#[doc = "`GL_STENCIL_BACK_WRITEMASK: GLenum = 0x8CA5`\n* **Group:** GetPName"]
pub const GL_STENCIL_BACK_WRITEMASK: GLenum = 0x8CA5;
#[doc = "`GL_STENCIL_BITS: GLenum = 0x0D57`\n* **Group:** GetPName"]
pub const GL_STENCIL_BITS: GLenum = 0x0D57;
#[doc = "`GL_STENCIL_BUFFER_BIT: GLbitfield = 0x00000400`\n* **Groups:** ClearBufferMask, AttribMask"]
pub const GL_STENCIL_BUFFER_BIT: GLbitfield = 0x00000400;
#[doc = "`GL_STENCIL_CLEAR_VALUE: GLenum = 0x0B91`\n* **Group:** GetPName"]
pub const GL_STENCIL_CLEAR_VALUE: GLenum = 0x0B91;
#[doc = "`GL_STENCIL_FAIL: GLenum = 0x0B94`\n* **Group:** GetPName"]
pub const GL_STENCIL_FAIL: GLenum = 0x0B94;
#[doc = "`GL_STENCIL_FUNC: GLenum = 0x0B92`\n* **Group:** GetPName"]
pub const GL_STENCIL_FUNC: GLenum = 0x0B92;
#[doc = "`GL_STENCIL_INDEX8: GLenum = 0x8D48`\n* **Group:** InternalFormat"]
pub const GL_STENCIL_INDEX8: GLenum = 0x8D48;
#[doc = "`GL_STENCIL_PASS_DEPTH_FAIL: GLenum = 0x0B95`\n* **Group:** GetPName"]
pub const GL_STENCIL_PASS_DEPTH_FAIL: GLenum = 0x0B95;
#[doc = "`GL_STENCIL_PASS_DEPTH_PASS: GLenum = 0x0B96`\n* **Group:** GetPName"]
pub const GL_STENCIL_PASS_DEPTH_PASS: GLenum = 0x0B96;
#[doc = "`GL_STENCIL_REF: GLenum = 0x0B97`\n* **Group:** GetPName"]
pub const GL_STENCIL_REF: GLenum = 0x0B97;
#[doc = "`GL_STENCIL_TEST: GLenum = 0x0B90`\n* **Groups:** GetPName, EnableCap"]
pub const GL_STENCIL_TEST: GLenum = 0x0B90;
#[doc = "`GL_STENCIL_VALUE_MASK: GLenum = 0x0B93`\n* **Group:** GetPName"]
pub const GL_STENCIL_VALUE_MASK: GLenum = 0x0B93;
#[doc = "`GL_STENCIL_WRITEMASK: GLenum = 0x0B98`\n* **Group:** GetPName"]
pub const GL_STENCIL_WRITEMASK: GLenum = 0x0B98;
#[doc = "`GL_STREAM_COPY: GLenum = 0x88E2`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_STREAM_COPY: GLenum = 0x88E2;
#[doc = "`GL_STREAM_DRAW: GLenum = 0x88E0`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_STREAM_DRAW: GLenum = 0x88E0;
#[doc = "`GL_STREAM_READ: GLenum = 0x88E1`\n* **Groups:** VertexBufferObjectUsage, BufferUsageARB"]
pub const GL_STREAM_READ: GLenum = 0x88E1;
#[doc = "`GL_SUBPIXEL_BITS: GLenum = 0x0D50`\n* **Group:** GetPName"]
pub const GL_SUBPIXEL_BITS: GLenum = 0x0D50;
#[doc = "`GL_SYNC_CONDITION: GLenum = 0x9113`\n* **Group:** SyncParameterName"]
pub const GL_SYNC_CONDITION: GLenum = 0x9113;
#[doc = "`GL_SYNC_FENCE: GLenum = 0x9116`"]
pub const GL_SYNC_FENCE: GLenum = 0x9116;
#[doc = "`GL_SYNC_FLAGS: GLenum = 0x9115`\n* **Group:** SyncParameterName"]
pub const GL_SYNC_FLAGS: GLenum = 0x9115;
#[doc = "`GL_SYNC_FLUSH_COMMANDS_BIT: GLbitfield = 0x00000001`\n* **Group:** SyncObjectMask"]
pub const GL_SYNC_FLUSH_COMMANDS_BIT: GLbitfield = 0x00000001;
#[doc = "`GL_SYNC_GPU_COMMANDS_COMPLETE: GLenum = 0x9117`\n* **Group:** SyncCondition"]
pub const GL_SYNC_GPU_COMMANDS_COMPLETE: GLenum = 0x9117;
#[doc = "`GL_SYNC_STATUS: GLenum = 0x9114`\n* **Group:** SyncParameterName"]
pub const GL_SYNC_STATUS: GLenum = 0x9114;
#[doc = "`GL_TEXTURE: GLenum = 0x1702`\n* **Groups:** ObjectIdentifier, MatrixMode"]
pub const GL_TEXTURE: GLenum = 0x1702;
#[doc = "`GL_TEXTURE0: GLenum = 0x84C0`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE0: GLenum = 0x84C0;
#[doc = "`GL_TEXTURE1: GLenum = 0x84C1`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE1: GLenum = 0x84C1;
#[doc = "`GL_TEXTURE10: GLenum = 0x84CA`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE10: GLenum = 0x84CA;
#[doc = "`GL_TEXTURE11: GLenum = 0x84CB`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE11: GLenum = 0x84CB;
#[doc = "`GL_TEXTURE12: GLenum = 0x84CC`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE12: GLenum = 0x84CC;
#[doc = "`GL_TEXTURE13: GLenum = 0x84CD`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE13: GLenum = 0x84CD;
#[doc = "`GL_TEXTURE14: GLenum = 0x84CE`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE14: GLenum = 0x84CE;
#[doc = "`GL_TEXTURE15: GLenum = 0x84CF`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE15: GLenum = 0x84CF;
#[doc = "`GL_TEXTURE16: GLenum = 0x84D0`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE16: GLenum = 0x84D0;
#[doc = "`GL_TEXTURE17: GLenum = 0x84D1`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE17: GLenum = 0x84D1;
#[doc = "`GL_TEXTURE18: GLenum = 0x84D2`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE18: GLenum = 0x84D2;
#[doc = "`GL_TEXTURE19: GLenum = 0x84D3`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE19: GLenum = 0x84D3;
#[doc = "`GL_TEXTURE2: GLenum = 0x84C2`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE2: GLenum = 0x84C2;
#[doc = "`GL_TEXTURE20: GLenum = 0x84D4`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE20: GLenum = 0x84D4;
#[doc = "`GL_TEXTURE21: GLenum = 0x84D5`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE21: GLenum = 0x84D5;
#[doc = "`GL_TEXTURE22: GLenum = 0x84D6`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE22: GLenum = 0x84D6;
#[doc = "`GL_TEXTURE23: GLenum = 0x84D7`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE23: GLenum = 0x84D7;
#[doc = "`GL_TEXTURE24: GLenum = 0x84D8`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE24: GLenum = 0x84D8;
#[doc = "`GL_TEXTURE25: GLenum = 0x84D9`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE25: GLenum = 0x84D9;
#[doc = "`GL_TEXTURE26: GLenum = 0x84DA`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE26: GLenum = 0x84DA;
#[doc = "`GL_TEXTURE27: GLenum = 0x84DB`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE27: GLenum = 0x84DB;
#[doc = "`GL_TEXTURE28: GLenum = 0x84DC`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE28: GLenum = 0x84DC;
#[doc = "`GL_TEXTURE29: GLenum = 0x84DD`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE29: GLenum = 0x84DD;
#[doc = "`GL_TEXTURE3: GLenum = 0x84C3`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE3: GLenum = 0x84C3;
#[doc = "`GL_TEXTURE30: GLenum = 0x84DE`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE30: GLenum = 0x84DE;
#[doc = "`GL_TEXTURE31: GLenum = 0x84DF`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE31: GLenum = 0x84DF;
#[doc = "`GL_TEXTURE4: GLenum = 0x84C4`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE4: GLenum = 0x84C4;
#[doc = "`GL_TEXTURE5: GLenum = 0x84C5`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE5: GLenum = 0x84C5;
#[doc = "`GL_TEXTURE6: GLenum = 0x84C6`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE6: GLenum = 0x84C6;
#[doc = "`GL_TEXTURE7: GLenum = 0x84C7`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE7: GLenum = 0x84C7;
#[doc = "`GL_TEXTURE8: GLenum = 0x84C8`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE8: GLenum = 0x84C8;
#[doc = "`GL_TEXTURE9: GLenum = 0x84C9`\n* **Group:** TextureUnit"]
pub const GL_TEXTURE9: GLenum = 0x84C9;
#[doc = "`GL_TEXTURE_2D: GLenum = 0x0DE1`\n* **Groups:** CopyImageSubDataTarget, EnableCap, GetPName, TextureTarget"]
pub const GL_TEXTURE_2D: GLenum = 0x0DE1;
#[doc = "`GL_TEXTURE_2D_ARRAY: GLenum = 0x8C1A`\n* **Groups:** CopyImageSubDataTarget, TextureTarget"]
pub const GL_TEXTURE_2D_ARRAY: GLenum = 0x8C1A;
#[doc = "`GL_TEXTURE_3D: GLenum = 0x806F`\n* **Groups:** CopyImageSubDataTarget, TextureTarget"]
pub const GL_TEXTURE_3D: GLenum = 0x806F;
#[doc = "`GL_TEXTURE_BASE_LEVEL: GLenum = 0x813C`\n* **Group:** TextureParameterName"]
pub const GL_TEXTURE_BASE_LEVEL: GLenum = 0x813C;
#[doc = "`GL_TEXTURE_BINDING_2D: GLenum = 0x8069`\n* **Group:** GetPName"]
pub const GL_TEXTURE_BINDING_2D: GLenum = 0x8069;
#[doc = "`GL_TEXTURE_BINDING_2D_ARRAY: GLenum = 0x8C1D`\n* **Group:** GetPName"]
pub const GL_TEXTURE_BINDING_2D_ARRAY: GLenum = 0x8C1D;
#[doc = "`GL_TEXTURE_BINDING_3D: GLenum = 0x806A`\n* **Group:** GetPName"]
pub const GL_TEXTURE_BINDING_3D: GLenum = 0x806A;
#[doc = "`GL_TEXTURE_BINDING_CUBE_MAP: GLenum = 0x8514`\n* **Group:** GetPName"]
pub const GL_TEXTURE_BINDING_CUBE_MAP: GLenum = 0x8514;
#[doc = "`GL_TEXTURE_COMPARE_FUNC: GLenum = 0x884D`\n* **Groups:** SamplerParameterI, TextureParameterName"]
pub const GL_TEXTURE_COMPARE_FUNC: GLenum = 0x884D;
#[doc = "`GL_TEXTURE_COMPARE_MODE: GLenum = 0x884C`\n* **Groups:** SamplerParameterI, TextureParameterName"]
pub const GL_TEXTURE_COMPARE_MODE: GLenum = 0x884C;
#[doc = "`GL_TEXTURE_CUBE_MAP: GLenum = 0x8513`\n* **Groups:** CopyImageSubDataTarget, TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP: GLenum = 0x8513;
#[doc = "`GL_TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum = 0x8516`\n* **Group:** TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum = 0x8516;
#[doc = "`GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum = 0x8518`\n* **Group:** TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum = 0x8518;
#[doc = "`GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum = 0x851A`\n* **Group:** TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum = 0x851A;
#[doc = "`GL_TEXTURE_CUBE_MAP_POSITIVE_X: GLenum = 0x8515`\n* **Group:** TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_X: GLenum = 0x8515;
#[doc = "`GL_TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum = 0x8517`\n* **Group:** TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum = 0x8517;
#[doc = "`GL_TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum = 0x8519`\n* **Group:** TextureTarget"]
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum = 0x8519;
#[doc = "`GL_TEXTURE_IMMUTABLE_FORMAT: GLenum = 0x912F`"]
pub const GL_TEXTURE_IMMUTABLE_FORMAT: GLenum = 0x912F;
#[doc = "`GL_TEXTURE_IMMUTABLE_LEVELS: GLenum = 0x82DF`"]
pub const GL_TEXTURE_IMMUTABLE_LEVELS: GLenum = 0x82DF;
#[doc = "`GL_TEXTURE_MAG_FILTER: GLenum = 0x2800`\n* **Groups:** SamplerParameterI, GetTextureParameter, TextureParameterName"]
pub const GL_TEXTURE_MAG_FILTER: GLenum = 0x2800;
#[doc = "`GL_TEXTURE_MAX_LEVEL: GLenum = 0x813D`\n* **Group:** TextureParameterName"]
pub const GL_TEXTURE_MAX_LEVEL: GLenum = 0x813D;
#[doc = "`GL_TEXTURE_MAX_LOD: GLenum = 0x813B`\n* **Groups:** SamplerParameterF, TextureParameterName"]
pub const GL_TEXTURE_MAX_LOD: GLenum = 0x813B;
#[doc = "`GL_TEXTURE_MIN_FILTER: GLenum = 0x2801`\n* **Groups:** SamplerParameterI, GetTextureParameter, TextureParameterName"]
pub const GL_TEXTURE_MIN_FILTER: GLenum = 0x2801;
#[doc = "`GL_TEXTURE_MIN_LOD: GLenum = 0x813A`\n* **Groups:** SamplerParameterF, TextureParameterName"]
pub const GL_TEXTURE_MIN_LOD: GLenum = 0x813A;
#[doc = "`GL_TEXTURE_SWIZZLE_A: GLenum = 0x8E45`\n* **Group:** TextureParameterName"]
pub const GL_TEXTURE_SWIZZLE_A: GLenum = 0x8E45;
#[doc = "`GL_TEXTURE_SWIZZLE_B: GLenum = 0x8E44`\n* **Group:** TextureParameterName"]
pub const GL_TEXTURE_SWIZZLE_B: GLenum = 0x8E44;
#[doc = "`GL_TEXTURE_SWIZZLE_G: GLenum = 0x8E43`\n* **Group:** TextureParameterName"]
pub const GL_TEXTURE_SWIZZLE_G: GLenum = 0x8E43;
#[doc = "`GL_TEXTURE_SWIZZLE_R: GLenum = 0x8E42`\n* **Group:** TextureParameterName"]
pub const GL_TEXTURE_SWIZZLE_R: GLenum = 0x8E42;
#[doc = "`GL_TEXTURE_WRAP_R: GLenum = 0x8072`\n* **Groups:** SamplerParameterI, TextureParameterName"]
pub const GL_TEXTURE_WRAP_R: GLenum = 0x8072;
#[doc = "`GL_TEXTURE_WRAP_S: GLenum = 0x2802`\n* **Groups:** SamplerParameterI, GetTextureParameter, TextureParameterName"]
pub const GL_TEXTURE_WRAP_S: GLenum = 0x2802;
#[doc = "`GL_TEXTURE_WRAP_T: GLenum = 0x2803`\n* **Groups:** SamplerParameterI, GetTextureParameter, TextureParameterName"]
pub const GL_TEXTURE_WRAP_T: GLenum = 0x2803;
#[doc = "`GL_TIMEOUT_EXPIRED: GLenum = 0x911B`\n* **Group:** SyncStatus"]
pub const GL_TIMEOUT_EXPIRED: GLenum = 0x911B;
#[doc = "`GL_TIMEOUT_IGNORED: u64 = 0xFFFFFFFFFFFFFFFF`"]
pub const GL_TIMEOUT_IGNORED: u64 = 0xFFFFFFFFFFFFFFFF;
#[doc = "`GL_TRANSFORM_FEEDBACK: GLenum = 0x8E22`\n* **Groups:** ObjectIdentifier, BindTransformFeedbackTarget"]
pub const GL_TRANSFORM_FEEDBACK: GLenum = 0x8E22;
#[doc = "`GL_TRANSFORM_FEEDBACK_ACTIVE: GLenum = 0x8E24`\n* **Group:** TransformFeedbackPName\n* **Alias Of:** `GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE`"]
pub const GL_TRANSFORM_FEEDBACK_ACTIVE: GLenum = 0x8E24;
#[doc = "`GL_TRANSFORM_FEEDBACK_BINDING: GLenum = 0x8E25`"]
pub const GL_TRANSFORM_FEEDBACK_BINDING: GLenum = 0x8E25;
#[doc = "`GL_TRANSFORM_FEEDBACK_BUFFER: GLenum = 0x8C8E`\n* **Groups:** ProgramInterface, BufferTargetARB, BufferStorageTarget, CopyBufferSubDataTarget"]
pub const GL_TRANSFORM_FEEDBACK_BUFFER: GLenum = 0x8C8E;
#[doc = "`GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum = 0x8C8F`\n* **Groups:** TransformFeedbackPName, GetPName"]
pub const GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum = 0x8C8F;
#[doc = "`GL_TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum = 0x8C7F`\n* **Group:** ProgramPropertyARB"]
pub const GL_TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum = 0x8C7F;
#[doc = "`GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum = 0x8C85`\n* **Groups:** TransformFeedbackPName, GetPName"]
pub const GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum = 0x8C85;
#[doc = "`GL_TRANSFORM_FEEDBACK_BUFFER_START: GLenum = 0x8C84`\n* **Groups:** TransformFeedbackPName, GetPName"]
pub const GL_TRANSFORM_FEEDBACK_BUFFER_START: GLenum = 0x8C84;
#[doc = "`GL_TRANSFORM_FEEDBACK_PAUSED: GLenum = 0x8E23`\n* **Group:** TransformFeedbackPName\n* **Alias Of:** `GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED`"]
pub const GL_TRANSFORM_FEEDBACK_PAUSED: GLenum = 0x8E23;
#[doc = "`GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum = 0x8C88`\n* **Group:** QueryTarget"]
pub const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum = 0x8C88;
#[doc = "`GL_TRANSFORM_FEEDBACK_VARYINGS: GLenum = 0x8C83`\n* **Group:** ProgramPropertyARB"]
pub const GL_TRANSFORM_FEEDBACK_VARYINGS: GLenum = 0x8C83;
#[doc = "`GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: GLenum = 0x8C76`\n* **Group:** ProgramPropertyARB"]
pub const GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: GLenum = 0x8C76;
#[doc = "`GL_TRIANGLES: GLenum = 0x0004`\n* **Group:** PrimitiveType"]
pub const GL_TRIANGLES: GLenum = 0x0004;
#[doc = "`GL_TRIANGLE_FAN: GLenum = 0x0006`\n* **Group:** PrimitiveType"]
pub const GL_TRIANGLE_FAN: GLenum = 0x0006;
#[doc = "`GL_TRIANGLE_STRIP: GLenum = 0x0005`\n* **Group:** PrimitiveType"]
pub const GL_TRIANGLE_STRIP: GLenum = 0x0005;
#[doc = "`GL_TRUE: GLenum = 1`\n* **Groups:** Boolean, VertexShaderWriteMaskEXT, ClampColorModeARB"]
pub const GL_TRUE: GLenum = 1;
#[doc = "`GL_UNIFORM_ARRAY_STRIDE: GLenum = 0x8A3C`\n* **Group:** UniformPName"]
pub const GL_UNIFORM_ARRAY_STRIDE: GLenum = 0x8A3C;
#[doc = "`GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum = 0x8A42`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum = 0x8A42;
#[doc = "`GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum = 0x8A43`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum = 0x8A43;
#[doc = "`GL_UNIFORM_BLOCK_BINDING: GLenum = 0x8A3F`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_BINDING: GLenum = 0x8A3F;
#[doc = "`GL_UNIFORM_BLOCK_DATA_SIZE: GLenum = 0x8A40`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_DATA_SIZE: GLenum = 0x8A40;
#[doc = "`GL_UNIFORM_BLOCK_INDEX: GLenum = 0x8A3A`\n* **Group:** UniformPName"]
pub const GL_UNIFORM_BLOCK_INDEX: GLenum = 0x8A3A;
#[doc = "`GL_UNIFORM_BLOCK_NAME_LENGTH: GLenum = 0x8A41`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_NAME_LENGTH: GLenum = 0x8A41;
#[doc = "`GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum = 0x8A46`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum = 0x8A46;
#[doc = "`GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum = 0x8A44`\n* **Group:** UniformBlockPName"]
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum = 0x8A44;
#[doc = "`GL_UNIFORM_BUFFER: GLenum = 0x8A11`\n* **Groups:** CopyBufferSubDataTarget, BufferTargetARB, BufferStorageTarget"]
pub const GL_UNIFORM_BUFFER: GLenum = 0x8A11;
#[doc = "`GL_UNIFORM_BUFFER_BINDING: GLenum = 0x8A28`\n* **Group:** GetPName"]
pub const GL_UNIFORM_BUFFER_BINDING: GLenum = 0x8A28;
#[doc = "`GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum = 0x8A34`\n* **Group:** GetPName"]
pub const GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum = 0x8A34;
#[doc = "`GL_UNIFORM_BUFFER_SIZE: GLenum = 0x8A2A`\n* **Group:** GetPName"]
pub const GL_UNIFORM_BUFFER_SIZE: GLenum = 0x8A2A;
#[doc = "`GL_UNIFORM_BUFFER_START: GLenum = 0x8A29`\n* **Group:** GetPName"]
pub const GL_UNIFORM_BUFFER_START: GLenum = 0x8A29;
#[doc = "`GL_UNIFORM_IS_ROW_MAJOR: GLenum = 0x8A3E`\n* **Group:** UniformPName"]
pub const GL_UNIFORM_IS_ROW_MAJOR: GLenum = 0x8A3E;
#[doc = "`GL_UNIFORM_MATRIX_STRIDE: GLenum = 0x8A3D`\n* **Group:** UniformPName"]
pub const GL_UNIFORM_MATRIX_STRIDE: GLenum = 0x8A3D;
#[doc = "`GL_UNIFORM_NAME_LENGTH: GLenum = 0x8A39`\n* **Groups:** SubroutineParameterName, UniformPName"]
pub const GL_UNIFORM_NAME_LENGTH: GLenum = 0x8A39;
#[doc = "`GL_UNIFORM_OFFSET: GLenum = 0x8A3B`\n* **Group:** UniformPName"]
pub const GL_UNIFORM_OFFSET: GLenum = 0x8A3B;
#[doc = "`GL_UNIFORM_SIZE: GLenum = 0x8A38`\n* **Groups:** SubroutineParameterName, UniformPName"]
pub const GL_UNIFORM_SIZE: GLenum = 0x8A38;
#[doc = "`GL_UNIFORM_TYPE: GLenum = 0x8A37`\n* **Group:** UniformPName"]
pub const GL_UNIFORM_TYPE: GLenum = 0x8A37;
#[doc = "`GL_UNPACK_ALIGNMENT: GLenum = 0x0CF5`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_UNPACK_ALIGNMENT: GLenum = 0x0CF5;
#[doc = "`GL_UNPACK_IMAGE_HEIGHT: GLenum = 0x806E`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_UNPACK_IMAGE_HEIGHT: GLenum = 0x806E;
#[doc = "`GL_UNPACK_ROW_LENGTH: GLenum = 0x0CF2`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_UNPACK_ROW_LENGTH: GLenum = 0x0CF2;
#[doc = "`GL_UNPACK_SKIP_IMAGES: GLenum = 0x806D`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_UNPACK_SKIP_IMAGES: GLenum = 0x806D;
#[doc = "`GL_UNPACK_SKIP_PIXELS: GLenum = 0x0CF4`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_UNPACK_SKIP_PIXELS: GLenum = 0x0CF4;
#[doc = "`GL_UNPACK_SKIP_ROWS: GLenum = 0x0CF3`\n* **Groups:** PixelStoreParameter, GetPName"]
pub const GL_UNPACK_SKIP_ROWS: GLenum = 0x0CF3;
#[doc = "`GL_UNSIGNALED: GLenum = 0x9118`"]
pub const GL_UNSIGNALED: GLenum = 0x9118;
#[doc = "`GL_UNSIGNED_BYTE: GLenum = 0x1401`\n* **Groups:** VertexAttribIType, ScalarType, ReplacementCodeTypeSUN, ElementPointerTypeATI, MatrixIndexPointerTypeARB, WeightPointerTypeARB, ColorPointerType, DrawElementsType, ListNameType, PixelType, VertexAttribType, VertexAttribPointerType"]
pub const GL_UNSIGNED_BYTE: GLenum = 0x1401;
#[doc = "`GL_UNSIGNED_INT: GLenum = 0x1405`\n* **Groups:** VertexAttribIType, ScalarType, ReplacementCodeTypeSUN, ElementPointerTypeATI, MatrixIndexPointerTypeARB, WeightPointerTypeARB, ColorPointerType, DrawElementsType, ListNameType, PixelFormat, PixelType, VertexAttribType, AttributeType, UniformType, VertexAttribPointerType, GlslTypeToken"]
pub const GL_UNSIGNED_INT: GLenum = 0x1405;
#[doc = "`GL_UNSIGNED_INT_10F_11F_11F_REV: GLenum = 0x8C3B`\n* **Groups:** VertexAttribPointerType, VertexAttribType"]
pub const GL_UNSIGNED_INT_10F_11F_11F_REV: GLenum = 0x8C3B;
#[doc = "`GL_UNSIGNED_INT_24_8: GLenum = 0x84FA`"]
pub const GL_UNSIGNED_INT_24_8: GLenum = 0x84FA;
#[doc = "`GL_UNSIGNED_INT_2_10_10_10_REV: GLenum = 0x8368`\n* **Groups:** VertexAttribPointerType, VertexAttribType"]
pub const GL_UNSIGNED_INT_2_10_10_10_REV: GLenum = 0x8368;
#[doc = "`GL_UNSIGNED_INT_5_9_9_9_REV: GLenum = 0x8C3E`"]
pub const GL_UNSIGNED_INT_5_9_9_9_REV: GLenum = 0x8C3E;
#[doc = "`GL_UNSIGNED_INT_SAMPLER_2D: GLenum = 0x8DD2`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_SAMPLER_2D: GLenum = 0x8DD2;
#[doc = "`GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum = 0x8DD7`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum = 0x8DD7;
#[doc = "`GL_UNSIGNED_INT_SAMPLER_3D: GLenum = 0x8DD3`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_SAMPLER_3D: GLenum = 0x8DD3;
#[doc = "`GL_UNSIGNED_INT_SAMPLER_CUBE: GLenum = 0x8DD4`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_SAMPLER_CUBE: GLenum = 0x8DD4;
#[doc = "`GL_UNSIGNED_INT_VEC2: GLenum = 0x8DC6`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_VEC2: GLenum = 0x8DC6;
#[doc = "`GL_UNSIGNED_INT_VEC3: GLenum = 0x8DC7`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_VEC3: GLenum = 0x8DC7;
#[doc = "`GL_UNSIGNED_INT_VEC4: GLenum = 0x8DC8`\n* **Groups:** GlslTypeToken, AttributeType, UniformType"]
pub const GL_UNSIGNED_INT_VEC4: GLenum = 0x8DC8;
#[doc = "`GL_UNSIGNED_NORMALIZED: GLenum = 0x8C17`"]
pub const GL_UNSIGNED_NORMALIZED: GLenum = 0x8C17;
#[doc = "`GL_UNSIGNED_SHORT: GLenum = 0x1403`\n* **Groups:** VertexAttribIType, ScalarType, ReplacementCodeTypeSUN, ElementPointerTypeATI, MatrixIndexPointerTypeARB, WeightPointerTypeARB, ColorPointerType, DrawElementsType, ListNameType, PixelFormat, PixelType, VertexAttribType, VertexAttribPointerType"]
pub const GL_UNSIGNED_SHORT: GLenum = 0x1403;
#[doc = "`GL_UNSIGNED_SHORT_4_4_4_4: GLenum = 0x8033`\n* **Group:** PixelType"]
pub const GL_UNSIGNED_SHORT_4_4_4_4: GLenum = 0x8033;
#[doc = "`GL_UNSIGNED_SHORT_5_5_5_1: GLenum = 0x8034`\n* **Group:** PixelType"]
pub const GL_UNSIGNED_SHORT_5_5_5_1: GLenum = 0x8034;
#[doc = "`GL_UNSIGNED_SHORT_5_6_5: GLenum = 0x8363`"]
pub const GL_UNSIGNED_SHORT_5_6_5: GLenum = 0x8363;
#[doc = "`GL_VALIDATE_STATUS: GLenum = 0x8B83`\n* **Group:** ProgramPropertyARB"]
pub const GL_VALIDATE_STATUS: GLenum = 0x8B83;
#[doc = "`GL_VENDOR: GLenum = 0x1F00`\n* **Group:** StringName"]
pub const GL_VENDOR: GLenum = 0x1F00;
#[doc = "`GL_VERSION: GLenum = 0x1F02`\n* **Group:** StringName"]
pub const GL_VERSION: GLenum = 0x1F02;
#[doc = "`GL_VERTEX_ARRAY_BINDING: GLenum = 0x85B5`\n* **Group:** GetPName"]
pub const GL_VERTEX_ARRAY_BINDING: GLenum = 0x85B5;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum = 0x889F`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB"]
pub const GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum = 0x889F;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum = 0x88FE`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum = 0x88FE;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_ENABLED: GLenum = 0x8622`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_ENABLED: GLenum = 0x8622;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_INTEGER: GLenum = 0x88FD`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_INTEGER: GLenum = 0x88FD;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum = 0x886A`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum = 0x886A;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_POINTER: GLenum = 0x8645`\n* **Group:** VertexAttribPointerPropertyARB"]
pub const GL_VERTEX_ATTRIB_ARRAY_POINTER: GLenum = 0x8645;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_SIZE: GLenum = 0x8623`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_SIZE: GLenum = 0x8623;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_STRIDE: GLenum = 0x8624`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_STRIDE: GLenum = 0x8624;
#[doc = "`GL_VERTEX_ATTRIB_ARRAY_TYPE: GLenum = 0x8625`\n* **Groups:** VertexAttribEnum, VertexAttribPropertyARB, VertexArrayPName"]
pub const GL_VERTEX_ATTRIB_ARRAY_TYPE: GLenum = 0x8625;
#[doc = "`GL_VERTEX_SHADER: GLenum = 0x8B31`\n* **Groups:** PipelineParameterName, ShaderType"]
pub const GL_VERTEX_SHADER: GLenum = 0x8B31;
#[doc = "`GL_VIEWPORT: GLenum = 0x0BA2`\n* **Group:** GetPName"]
pub const GL_VIEWPORT: GLenum = 0x0BA2;
#[doc = "`GL_WAIT_FAILED: GLenum = 0x911D`\n* **Group:** SyncStatus"]
pub const GL_WAIT_FAILED: GLenum = 0x911D;
#[doc = "`GL_ZERO: GLenum = 0`\n* **Groups:** TextureSwizzle, StencilOp, BlendingFactor"]
pub const GL_ZERO: GLenum = 0;
}
#[cold]
#[inline(never)]
#[allow(dead_code)]
fn go_panic_because_fn_not_loaded(name: &str) -> ! {
panic!("called {name} but it was not loaded.", name = name)
}
#[inline(never)]
#[allow(dead_code)]
fn load_dyn_name_atomic_ptr(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
fn_name: &[u8],
ptr: &APcv,
) -> bool {
debug_assert_eq!(*fn_name.last().unwrap(), 0);
let p: *mut c_void = get_proc_address(fn_name.as_ptr() as *const c_char);
let p_usize = p as usize;
if p_usize == core::usize::MAX || p_usize < 8 {
ptr.store(null_mut(), RELAX);
false
} else {
ptr.store(p, RELAX);
true
}
}
#[inline(never)]
#[cfg(feature = "debug_automatic_glGetError")]
fn report_error_code_from(name: &str, err: GLenum) {
match err {
GL_NO_ERROR => return,
GL_INVALID_ENUM => error!("Invalid Enum to {name}.", name = name),
GL_INVALID_VALUE => error!("Invalid Value to {name}.", name = name),
GL_INVALID_OPERATION => error!("Invalid Operation to {name}.", name = name),
GL_INVALID_FRAMEBUFFER_OPERATION => {
error!("Invalid Framebuffer Operation to {name}.", name = name)
}
GL_OUT_OF_MEMORY => error!("Out of Memory in {name}.", name = name),
GL_STACK_UNDERFLOW => error!("Stack Underflow in {name}.", name = name),
GL_STACK_OVERFLOW => error!("Stack Overflow in {name}.", name = name),
unknown => error!(
"Unknown error code {unknown} to {name}.",
name = name,
unknown = unknown
),
}
}
pub const NUMBER_OF_GENERATED_GL_COMMANDS: usize = 246;
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_0arg<Ret>(name: &str, ptr: &APcv) -> Ret {
let p = ptr.load(RELAX);
match transmute::<*mut c_void, Option<extern "system" fn() -> Ret>>(p) {
Some(fn_p) => fn_p(),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_1arg<Ret, A>(name: &str, ptr: &APcv, a: A) -> Ret {
let p = ptr.load(RELAX);
match transmute::<*mut c_void, Option<extern "system" fn(A) -> Ret>>(p) {
Some(fn_p) => fn_p(a),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_2arg<Ret, A, B>(
name: &str,
ptr: &APcv,
a: A,
b: B,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<*mut c_void, Option<extern "system" fn(A, B) -> Ret>>(p) {
Some(fn_p) => fn_p(a, b),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_3arg<Ret, A, B, C>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<*mut c_void, Option<extern "system" fn(A, B, C) -> Ret>>(p)
{
Some(fn_p) => fn_p(a, b, c),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_4arg<Ret, A, B, C, D>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<*mut c_void, Option<extern "system" fn(A, B, C, D) -> Ret>>(
p,
) {
Some(fn_p) => fn_p(a, b, c, d),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_5arg<Ret, A, B, C, D, E>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<*mut c_void, Option<extern "system" fn(A, B, C, D, E) -> Ret>>(
p,
) {
Some(fn_p) => fn_p(a, b, c, d, e),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_6arg<Ret, A, B, C, D, E, F>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
f: F,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<
*mut c_void,
Option<extern "system" fn(A, B, C, D, E, F) -> Ret>,
>(p)
{
Some(fn_p) => fn_p(a, b, c, d, e, f),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_7arg<Ret, A, B, C, D, E, F, G>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
f: F,
g: G,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<
*mut c_void,
Option<extern "system" fn(A, B, C, D, E, F, G) -> Ret>,
>(p)
{
Some(fn_p) => fn_p(a, b, c, d, e, f, g),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_8arg<Ret, A, B, C, D, E, F, G, H>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
f: F,
g: G,
h: H,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<
*mut c_void,
Option<extern "system" fn(A, B, C, D, E, F, G, H) -> Ret>,
>(p)
{
Some(fn_p) => fn_p(a, b, c, d, e, f, g, h),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_9arg<Ret, A, B, C, D, E, F, G, H, I>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
f: F,
g: G,
h: H,
i: I,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<
*mut c_void,
Option<extern "system" fn(A, B, C, D, E, F, G, H, I) -> Ret>,
>(p)
{
Some(fn_p) => fn_p(a, b, c, d, e, f, g, h, i),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_10arg<Ret, A, B, C, D, E, F, G, H, I, J>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
f: F,
g: G,
h: H,
i: I,
j: J,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<
*mut c_void,
Option<extern "system" fn(A, B, C, D, E, F, G, H, I, J) -> Ret>,
>(p)
{
Some(fn_p) => fn_p(a, b, c, d, e, f, g, h, i, j),
None => go_panic_because_fn_not_loaded(name),
}
}
#[inline(always)]
#[allow(dead_code)]
unsafe fn call_atomic_ptr_11arg<Ret, A, B, C, D, E, F, G, H, I, J, K>(
name: &str,
ptr: &APcv,
a: A,
b: B,
c: C,
d: D,
e: E,
f: F,
g: G,
h: H,
i: I,
j: J,
k: K,
) -> Ret {
let p = ptr.load(RELAX);
match transmute::<
*mut c_void,
Option<extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret>,
>(p)
{
Some(fn_p) => fn_p(a, b, c, d, e, f, g, h, i, j, k),
None => go_panic_because_fn_not_loaded(name),
}
}
#[cfg(feature = "global_loader")]
pub use global_commands::*;
#[cfg(feature = "global_loader")]
pub mod global_commands {
use super::*;
pub unsafe fn load_global_gl_with<F>(mut get_proc_address: F) -> usize
where
F: FnMut(*const c_char) -> *mut c_void,
{
let mut count = 0;
count += glActiveTexture_load_with_dyn(&mut get_proc_address) as usize;
count += glAttachShader_load_with_dyn(&mut get_proc_address) as usize;
count += glBeginQuery_load_with_dyn(&mut get_proc_address) as usize;
count +=
glBeginTransformFeedback_load_with_dyn(&mut get_proc_address) as usize;
count += glBindAttribLocation_load_with_dyn(&mut get_proc_address) as usize;
count += glBindBuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glBindBufferBase_load_with_dyn(&mut get_proc_address) as usize;
count += glBindBufferRange_load_with_dyn(&mut get_proc_address) as usize;
count += glBindFramebuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glBindRenderbuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glBindSampler_load_with_dyn(&mut get_proc_address) as usize;
count += glBindTexture_load_with_dyn(&mut get_proc_address) as usize;
count +=
glBindTransformFeedback_load_with_dyn(&mut get_proc_address) as usize;
count += glBindVertexArray_load_with_dyn(&mut get_proc_address) as usize;
count += glBlendColor_load_with_dyn(&mut get_proc_address) as usize;
count += glBlendEquation_load_with_dyn(&mut get_proc_address) as usize;
count +=
glBlendEquationSeparate_load_with_dyn(&mut get_proc_address) as usize;
count += glBlendFunc_load_with_dyn(&mut get_proc_address) as usize;
count += glBlendFuncSeparate_load_with_dyn(&mut get_proc_address) as usize;
count += glBlitFramebuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glBufferData_load_with_dyn(&mut get_proc_address) as usize;
count += glBufferSubData_load_with_dyn(&mut get_proc_address) as usize;
count +=
glCheckFramebufferStatus_load_with_dyn(&mut get_proc_address) as usize;
count += glClear_load_with_dyn(&mut get_proc_address) as usize;
count += glClearBufferfi_load_with_dyn(&mut get_proc_address) as usize;
count += glClearBufferfv_load_with_dyn(&mut get_proc_address) as usize;
count += glClearBufferiv_load_with_dyn(&mut get_proc_address) as usize;
count += glClearBufferuiv_load_with_dyn(&mut get_proc_address) as usize;
count += glClearColor_load_with_dyn(&mut get_proc_address) as usize;
count += glClearDepthf_load_with_dyn(&mut get_proc_address) as usize;
count += glClearStencil_load_with_dyn(&mut get_proc_address) as usize;
count += glClientWaitSync_load_with_dyn(&mut get_proc_address) as usize;
count += glColorMask_load_with_dyn(&mut get_proc_address) as usize;
count += glCompileShader_load_with_dyn(&mut get_proc_address) as usize;
count +=
glCompressedTexImage2D_load_with_dyn(&mut get_proc_address) as usize;
count +=
glCompressedTexImage3D_load_with_dyn(&mut get_proc_address) as usize;
count +=
glCompressedTexSubImage2D_load_with_dyn(&mut get_proc_address) as usize;
count +=
glCompressedTexSubImage3D_load_with_dyn(&mut get_proc_address) as usize;
count += glCopyBufferSubData_load_with_dyn(&mut get_proc_address) as usize;
count += glCopyTexImage2D_load_with_dyn(&mut get_proc_address) as usize;
count += glCopyTexSubImage2D_load_with_dyn(&mut get_proc_address) as usize;
count += glCopyTexSubImage3D_load_with_dyn(&mut get_proc_address) as usize;
count += glCreateProgram_load_with_dyn(&mut get_proc_address) as usize;
count += glCreateShader_load_with_dyn(&mut get_proc_address) as usize;
count += glCullFace_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteBuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteFramebuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteProgram_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteQueries_load_with_dyn(&mut get_proc_address) as usize;
count +=
glDeleteRenderbuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteSamplers_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteShader_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteSync_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteTextures_load_with_dyn(&mut get_proc_address) as usize;
count +=
glDeleteTransformFeedbacks_load_with_dyn(&mut get_proc_address) as usize;
count += glDeleteVertexArrays_load_with_dyn(&mut get_proc_address) as usize;
count += glDepthFunc_load_with_dyn(&mut get_proc_address) as usize;
count += glDepthMask_load_with_dyn(&mut get_proc_address) as usize;
count += glDepthRangef_load_with_dyn(&mut get_proc_address) as usize;
count += glDetachShader_load_with_dyn(&mut get_proc_address) as usize;
count += glDisable_load_with_dyn(&mut get_proc_address) as usize;
count +=
glDisableVertexAttribArray_load_with_dyn(&mut get_proc_address) as usize;
count += glDrawArrays_load_with_dyn(&mut get_proc_address) as usize;
count +=
glDrawArraysInstanced_load_with_dyn(&mut get_proc_address) as usize;
count += glDrawBuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glDrawElements_load_with_dyn(&mut get_proc_address) as usize;
count +=
glDrawElementsInstanced_load_with_dyn(&mut get_proc_address) as usize;
count += glDrawRangeElements_load_with_dyn(&mut get_proc_address) as usize;
count += glEnable_load_with_dyn(&mut get_proc_address) as usize;
count +=
glEnableVertexAttribArray_load_with_dyn(&mut get_proc_address) as usize;
count += glEndQuery_load_with_dyn(&mut get_proc_address) as usize;
count +=
glEndTransformFeedback_load_with_dyn(&mut get_proc_address) as usize;
count += glFenceSync_load_with_dyn(&mut get_proc_address) as usize;
count += glFinish_load_with_dyn(&mut get_proc_address) as usize;
count += glFlush_load_with_dyn(&mut get_proc_address) as usize;
count +=
glFlushMappedBufferRange_load_with_dyn(&mut get_proc_address) as usize;
count +=
glFramebufferRenderbuffer_load_with_dyn(&mut get_proc_address) as usize;
count +=
glFramebufferTexture2D_load_with_dyn(&mut get_proc_address) as usize;
count +=
glFramebufferTextureLayer_load_with_dyn(&mut get_proc_address) as usize;
count += glFrontFace_load_with_dyn(&mut get_proc_address) as usize;
count += glGenBuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glGenFramebuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glGenQueries_load_with_dyn(&mut get_proc_address) as usize;
count += glGenRenderbuffers_load_with_dyn(&mut get_proc_address) as usize;
count += glGenSamplers_load_with_dyn(&mut get_proc_address) as usize;
count += glGenTextures_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGenTransformFeedbacks_load_with_dyn(&mut get_proc_address) as usize;
count += glGenVertexArrays_load_with_dyn(&mut get_proc_address) as usize;
count += glGenerateMipmap_load_with_dyn(&mut get_proc_address) as usize;
count += glGetActiveAttrib_load_with_dyn(&mut get_proc_address) as usize;
count += glGetActiveUniform_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetActiveUniformBlockName_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetActiveUniformBlockiv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetActiveUniformsiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetAttachedShaders_load_with_dyn(&mut get_proc_address) as usize;
count += glGetAttribLocation_load_with_dyn(&mut get_proc_address) as usize;
count += glGetBooleanv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetBufferParameteri64v_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetBufferParameteriv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetBufferPointerv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetError_load_with_dyn(&mut get_proc_address) as usize;
count += glGetFloatv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetFragDataLocation_load_with_dyn(&mut get_proc_address) as usize;
count += glGetFramebufferAttachmentParameteriv_load_with_dyn(
&mut get_proc_address,
) as usize;
count += glGetInteger64i_v_load_with_dyn(&mut get_proc_address) as usize;
count += glGetInteger64v_load_with_dyn(&mut get_proc_address) as usize;
count += glGetIntegeri_v_load_with_dyn(&mut get_proc_address) as usize;
count += glGetIntegerv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetInternalformativ_load_with_dyn(&mut get_proc_address) as usize;
count += glGetProgramBinary_load_with_dyn(&mut get_proc_address) as usize;
count += glGetProgramInfoLog_load_with_dyn(&mut get_proc_address) as usize;
count += glGetProgramiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetQueryObjectuiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetQueryiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetRenderbufferParameteriv_load_with_dyn(&mut get_proc_address)
as usize;
count +=
glGetSamplerParameterfv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetSamplerParameteriv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetShaderInfoLog_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetShaderPrecisionFormat_load_with_dyn(&mut get_proc_address) as usize;
count += glGetShaderSource_load_with_dyn(&mut get_proc_address) as usize;
count += glGetShaderiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetString_load_with_dyn(&mut get_proc_address) as usize;
count += glGetStringi_load_with_dyn(&mut get_proc_address) as usize;
count += glGetSynciv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetTexParameterfv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetTexParameteriv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetTransformFeedbackVarying_load_with_dyn(&mut get_proc_address)
as usize;
count +=
glGetUniformBlockIndex_load_with_dyn(&mut get_proc_address) as usize;
count += glGetUniformIndices_load_with_dyn(&mut get_proc_address) as usize;
count += glGetUniformLocation_load_with_dyn(&mut get_proc_address) as usize;
count += glGetUniformfv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetUniformiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetUniformuiv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetVertexAttribIiv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetVertexAttribIuiv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glGetVertexAttribPointerv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetVertexAttribfv_load_with_dyn(&mut get_proc_address) as usize;
count += glGetVertexAttribiv_load_with_dyn(&mut get_proc_address) as usize;
count += glHint_load_with_dyn(&mut get_proc_address) as usize;
count +=
glInvalidateFramebuffer_load_with_dyn(&mut get_proc_address) as usize;
count +=
glInvalidateSubFramebuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glIsBuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glIsEnabled_load_with_dyn(&mut get_proc_address) as usize;
count += glIsFramebuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glIsProgram_load_with_dyn(&mut get_proc_address) as usize;
count += glIsQuery_load_with_dyn(&mut get_proc_address) as usize;
count += glIsRenderbuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glIsSampler_load_with_dyn(&mut get_proc_address) as usize;
count += glIsShader_load_with_dyn(&mut get_proc_address) as usize;
count += glIsSync_load_with_dyn(&mut get_proc_address) as usize;
count += glIsTexture_load_with_dyn(&mut get_proc_address) as usize;
count +=
glIsTransformFeedback_load_with_dyn(&mut get_proc_address) as usize;
count += glIsVertexArray_load_with_dyn(&mut get_proc_address) as usize;
count += glLineWidth_load_with_dyn(&mut get_proc_address) as usize;
count += glLinkProgram_load_with_dyn(&mut get_proc_address) as usize;
count += glMapBufferRange_load_with_dyn(&mut get_proc_address) as usize;
count +=
glPauseTransformFeedback_load_with_dyn(&mut get_proc_address) as usize;
count += glPixelStorei_load_with_dyn(&mut get_proc_address) as usize;
count += glPolygonOffset_load_with_dyn(&mut get_proc_address) as usize;
count += glProgramBinary_load_with_dyn(&mut get_proc_address) as usize;
count += glProgramParameteri_load_with_dyn(&mut get_proc_address) as usize;
count += glReadBuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glReadPixels_load_with_dyn(&mut get_proc_address) as usize;
count +=
glReleaseShaderCompiler_load_with_dyn(&mut get_proc_address) as usize;
count +=
glRenderbufferStorage_load_with_dyn(&mut get_proc_address) as usize;
count +=
glRenderbufferStorageMultisample_load_with_dyn(&mut get_proc_address)
as usize;
count +=
glResumeTransformFeedback_load_with_dyn(&mut get_proc_address) as usize;
count += glSampleCoverage_load_with_dyn(&mut get_proc_address) as usize;
count += glSamplerParameterf_load_with_dyn(&mut get_proc_address) as usize;
count += glSamplerParameterfv_load_with_dyn(&mut get_proc_address) as usize;
count += glSamplerParameteri_load_with_dyn(&mut get_proc_address) as usize;
count += glSamplerParameteriv_load_with_dyn(&mut get_proc_address) as usize;
count += glScissor_load_with_dyn(&mut get_proc_address) as usize;
count += glShaderBinary_load_with_dyn(&mut get_proc_address) as usize;
count += glShaderSource_load_with_dyn(&mut get_proc_address) as usize;
count += glStencilFunc_load_with_dyn(&mut get_proc_address) as usize;
count +=
glStencilFuncSeparate_load_with_dyn(&mut get_proc_address) as usize;
count += glStencilMask_load_with_dyn(&mut get_proc_address) as usize;
count +=
glStencilMaskSeparate_load_with_dyn(&mut get_proc_address) as usize;
count += glStencilOp_load_with_dyn(&mut get_proc_address) as usize;
count += glStencilOpSeparate_load_with_dyn(&mut get_proc_address) as usize;
count += glTexImage2D_load_with_dyn(&mut get_proc_address) as usize;
count += glTexImage3D_load_with_dyn(&mut get_proc_address) as usize;
count += glTexParameterf_load_with_dyn(&mut get_proc_address) as usize;
count += glTexParameterfv_load_with_dyn(&mut get_proc_address) as usize;
count += glTexParameteri_load_with_dyn(&mut get_proc_address) as usize;
count += glTexParameteriv_load_with_dyn(&mut get_proc_address) as usize;
count += glTexStorage2D_load_with_dyn(&mut get_proc_address) as usize;
count += glTexStorage3D_load_with_dyn(&mut get_proc_address) as usize;
count += glTexSubImage2D_load_with_dyn(&mut get_proc_address) as usize;
count += glTexSubImage3D_load_with_dyn(&mut get_proc_address) as usize;
count +=
glTransformFeedbackVaryings_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform1f_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform1fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform1i_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform1iv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform1ui_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform1uiv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform2f_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform2fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform2i_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform2iv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform2ui_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform2uiv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform3f_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform3fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform3i_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform3iv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform3ui_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform3uiv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform4f_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform4fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform4i_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform4iv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform4ui_load_with_dyn(&mut get_proc_address) as usize;
count += glUniform4uiv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glUniformBlockBinding_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix2fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix2x3fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix2x4fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix3fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix3x2fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix3x4fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix4fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix4x2fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUniformMatrix4x3fv_load_with_dyn(&mut get_proc_address) as usize;
count += glUnmapBuffer_load_with_dyn(&mut get_proc_address) as usize;
count += glUseProgram_load_with_dyn(&mut get_proc_address) as usize;
count += glValidateProgram_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib1f_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib1fv_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib2f_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib2fv_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib3f_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib3fv_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib4f_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttrib4fv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glVertexAttribDivisor_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttribI4i_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttribI4iv_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttribI4ui_load_with_dyn(&mut get_proc_address) as usize;
count += glVertexAttribI4uiv_load_with_dyn(&mut get_proc_address) as usize;
count +=
glVertexAttribIPointer_load_with_dyn(&mut get_proc_address) as usize;
count +=
glVertexAttribPointer_load_with_dyn(&mut get_proc_address) as usize;
count += glViewport_load_with_dyn(&mut get_proc_address) as usize;
count += glWaitSync_load_with_dyn(&mut get_proc_address) as usize;
count
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glActiveTexture(texture: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glActiveTexture({:#X});", texture);
}
let out =
call_atomic_ptr_1arg("glActiveTexture", &glActiveTexture_p, texture);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glActiveTexture", err);
err = glGetError();
}
}
out
}
static glActiveTexture_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glActiveTexture_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glActiveTexture\0",
&glActiveTexture_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glActiveTexture_is_loaded() -> bool {
!glActiveTexture_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glAttachShader(program: GLuint, shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glAttachShader({:?}, {:?});", program, shader);
}
let out = call_atomic_ptr_2arg(
"glAttachShader",
&glAttachShader_p,
program,
shader,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glAttachShader", err);
err = glGetError();
}
}
out
}
static glAttachShader_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glAttachShader_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glAttachShader\0",
&glAttachShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glAttachShader_is_loaded() -> bool {
!glAttachShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBeginQuery(target: GLenum, id: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBeginQuery({:#X}, {:?});", target, id);
}
let out = call_atomic_ptr_2arg("glBeginQuery", &glBeginQuery_p, target, id);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBeginQuery", err);
err = glGetError();
}
}
out
}
static glBeginQuery_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBeginQuery_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBeginQuery\0",
&glBeginQuery_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBeginQuery_is_loaded() -> bool {
!glBeginQuery_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBeginTransformFeedback(primitiveMode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBeginTransformFeedback({:#X});", primitiveMode);
}
let out = call_atomic_ptr_1arg(
"glBeginTransformFeedback",
&glBeginTransformFeedback_p,
primitiveMode,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBeginTransformFeedback", err);
err = glGetError();
}
}
out
}
static glBeginTransformFeedback_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBeginTransformFeedback_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBeginTransformFeedback\0",
&glBeginTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBeginTransformFeedback_is_loaded() -> bool {
!glBeginTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindAttribLocation(
program: GLuint,
index: GLuint,
name: *const GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBindAttribLocation({:?}, {:?}, {:p});",
program,
index,
name
);
}
let out = call_atomic_ptr_3arg(
"glBindAttribLocation",
&glBindAttribLocation_p,
program,
index,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindAttribLocation", err);
err = glGetError();
}
}
out
}
static glBindAttribLocation_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindAttribLocation_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindAttribLocation\0",
&glBindAttribLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindAttribLocation_is_loaded() -> bool {
!glBindAttribLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindBuffer(target: GLenum, buffer: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindBuffer({:#X}, {:?});", target, buffer);
}
let out =
call_atomic_ptr_2arg("glBindBuffer", &glBindBuffer_p, target, buffer);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindBuffer", err);
err = glGetError();
}
}
out
}
static glBindBuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindBuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindBuffer\0",
&glBindBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindBuffer_is_loaded() -> bool {
!glBindBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindBufferBase(
target: GLenum,
index: GLuint,
buffer: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBindBufferBase({:#X}, {:?}, {:?});",
target,
index,
buffer
);
}
let out = call_atomic_ptr_3arg(
"glBindBufferBase",
&glBindBufferBase_p,
target,
index,
buffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindBufferBase", err);
err = glGetError();
}
}
out
}
static glBindBufferBase_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindBufferBase_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindBufferBase\0",
&glBindBufferBase_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindBufferBase_is_loaded() -> bool {
!glBindBufferBase_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindBufferRange(
target: GLenum,
index: GLuint,
buffer: GLuint,
offset: GLintptr,
size: GLsizeiptr,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBindBufferRange({:#X}, {:?}, {:?}, {:?}, {:?});",
target,
index,
buffer,
offset,
size
);
}
let out = call_atomic_ptr_5arg(
"glBindBufferRange",
&glBindBufferRange_p,
target,
index,
buffer,
offset,
size,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindBufferRange", err);
err = glGetError();
}
}
out
}
static glBindBufferRange_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindBufferRange_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindBufferRange\0",
&glBindBufferRange_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindBufferRange_is_loaded() -> bool {
!glBindBufferRange_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindFramebuffer(target: GLenum, framebuffer: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindFramebuffer({:#X}, {:?});", target, framebuffer);
}
let out = call_atomic_ptr_2arg(
"glBindFramebuffer",
&glBindFramebuffer_p,
target,
framebuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindFramebuffer", err);
err = glGetError();
}
}
out
}
static glBindFramebuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindFramebuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindFramebuffer\0",
&glBindFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindFramebuffer_is_loaded() -> bool {
!glBindFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindRenderbuffer(target: GLenum, renderbuffer: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindRenderbuffer({:#X}, {:?});", target, renderbuffer);
}
let out = call_atomic_ptr_2arg(
"glBindRenderbuffer",
&glBindRenderbuffer_p,
target,
renderbuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindRenderbuffer", err);
err = glGetError();
}
}
out
}
static glBindRenderbuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindRenderbuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindRenderbuffer\0",
&glBindRenderbuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindRenderbuffer_is_loaded() -> bool {
!glBindRenderbuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindSampler(unit: GLuint, sampler: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindSampler({:?}, {:?});", unit, sampler);
}
let out =
call_atomic_ptr_2arg("glBindSampler", &glBindSampler_p, unit, sampler);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindSampler", err);
err = glGetError();
}
}
out
}
static glBindSampler_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindSampler_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindSampler\0",
&glBindSampler_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindSampler_is_loaded() -> bool {
!glBindSampler_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindTexture(target: GLenum, texture: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindTexture({:#X}, {:?});", target, texture);
}
let out =
call_atomic_ptr_2arg("glBindTexture", &glBindTexture_p, target, texture);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindTexture", err);
err = glGetError();
}
}
out
}
static glBindTexture_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindTexture_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindTexture\0",
&glBindTexture_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindTexture_is_loaded() -> bool {
!glBindTexture_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindTransformFeedback(target: GLenum, id: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindTransformFeedback({:#X}, {:?});", target, id);
}
let out = call_atomic_ptr_2arg(
"glBindTransformFeedback",
&glBindTransformFeedback_p,
target,
id,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindTransformFeedback", err);
err = glGetError();
}
}
out
}
static glBindTransformFeedback_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindTransformFeedback_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindTransformFeedback\0",
&glBindTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindTransformFeedback_is_loaded() -> bool {
!glBindTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBindVertexArray(array: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBindVertexArray({:?});", array);
}
let out =
call_atomic_ptr_1arg("glBindVertexArray", &glBindVertexArray_p, array);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindVertexArray", err);
err = glGetError();
}
}
out
}
static glBindVertexArray_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBindVertexArray_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindVertexArray\0",
&glBindVertexArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBindVertexArray_is_loaded() -> bool {
!glBindVertexArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBlendColor(
red: GLfloat,
green: GLfloat,
blue: GLfloat,
alpha: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBlendColor({:?}, {:?}, {:?}, {:?});",
red,
green,
blue,
alpha
);
}
let out = call_atomic_ptr_4arg(
"glBlendColor",
&glBlendColor_p,
red,
green,
blue,
alpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendColor", err);
err = glGetError();
}
}
out
}
static glBlendColor_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBlendColor_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendColor\0",
&glBlendColor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBlendColor_is_loaded() -> bool {
!glBlendColor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBlendEquation(mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBlendEquation({:#X});", mode);
}
let out = call_atomic_ptr_1arg("glBlendEquation", &glBlendEquation_p, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendEquation", err);
err = glGetError();
}
}
out
}
static glBlendEquation_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBlendEquation_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendEquation\0",
&glBlendEquation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBlendEquation_is_loaded() -> bool {
!glBlendEquation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBlendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBlendEquationSeparate({:#X}, {:#X});",
modeRGB,
modeAlpha
);
}
let out = call_atomic_ptr_2arg(
"glBlendEquationSeparate",
&glBlendEquationSeparate_p,
modeRGB,
modeAlpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendEquationSeparate", err);
err = glGetError();
}
}
out
}
static glBlendEquationSeparate_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBlendEquationSeparate_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendEquationSeparate\0",
&glBlendEquationSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBlendEquationSeparate_is_loaded() -> bool {
!glBlendEquationSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBlendFunc(sfactor: GLenum, dfactor: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBlendFunc({:#X}, {:#X});", sfactor, dfactor);
}
let out =
call_atomic_ptr_2arg("glBlendFunc", &glBlendFunc_p, sfactor, dfactor);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendFunc", err);
err = glGetError();
}
}
out
}
static glBlendFunc_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBlendFunc_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glBlendFunc\0", &glBlendFunc_p)
}
#[inline]
#[doc(hidden)]
pub fn glBlendFunc_is_loaded() -> bool {
!glBlendFunc_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBlendFuncSeparate(
sfactorRGB: GLenum,
dfactorRGB: GLenum,
sfactorAlpha: GLenum,
dfactorAlpha: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBlendFuncSeparate({:#X}, {:#X}, {:#X}, {:#X});",
sfactorRGB,
dfactorRGB,
sfactorAlpha,
dfactorAlpha
);
}
let out = call_atomic_ptr_4arg(
"glBlendFuncSeparate",
&glBlendFuncSeparate_p,
sfactorRGB,
dfactorRGB,
sfactorAlpha,
dfactorAlpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendFuncSeparate", err);
err = glGetError();
}
}
out
}
static glBlendFuncSeparate_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBlendFuncSeparate_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendFuncSeparate\0",
&glBlendFuncSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBlendFuncSeparate_is_loaded() -> bool {
!glBlendFuncSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBlitFramebuffer(
srcX0: GLint,
srcY0: GLint,
srcX1: GLint,
srcY1: GLint,
dstX0: GLint,
dstY0: GLint,
dstX1: GLint,
dstY1: GLint,
mask: GLbitfield,
filter: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glBlitFramebuffer({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X});", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
let out = call_atomic_ptr_10arg(
"glBlitFramebuffer",
&glBlitFramebuffer_p,
srcX0,
srcY0,
srcX1,
srcY1,
dstX0,
dstY0,
dstX1,
dstY1,
mask,
filter,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlitFramebuffer", err);
err = glGetError();
}
}
out
}
static glBlitFramebuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBlitFramebuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlitFramebuffer\0",
&glBlitFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBlitFramebuffer_is_loaded() -> bool {
!glBlitFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBufferData(
target: GLenum,
size: GLsizeiptr,
data: *const c_void,
usage: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBufferData({:#X}, {:?}, {:p}, {:#X});",
target,
size,
data,
usage
);
}
let out = call_atomic_ptr_4arg(
"glBufferData",
&glBufferData_p,
target,
size,
data,
usage,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBufferData", err);
err = glGetError();
}
}
out
}
static glBufferData_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBufferData_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBufferData\0",
&glBufferData_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBufferData_is_loaded() -> bool {
!glBufferData_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glBufferSubData(
target: GLenum,
offset: GLintptr,
size: GLsizeiptr,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glBufferSubData({:#X}, {:?}, {:?}, {:p});",
target,
offset,
size,
data
);
}
let out = call_atomic_ptr_4arg(
"glBufferSubData",
&glBufferSubData_p,
target,
offset,
size,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glBufferSubData", err);
err = glGetError();
}
}
out
}
static glBufferSubData_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glBufferSubData_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBufferSubData\0",
&glBufferSubData_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glBufferSubData_is_loaded() -> bool {
!glBufferSubData_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCheckFramebufferStatus(target: GLenum) -> GLenum {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCheckFramebufferStatus({:#X});", target);
}
let out = call_atomic_ptr_1arg(
"glCheckFramebufferStatus",
&glCheckFramebufferStatus_p,
target,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCheckFramebufferStatus", err);
err = glGetError();
}
}
out
}
static glCheckFramebufferStatus_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCheckFramebufferStatus_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCheckFramebufferStatus\0",
&glCheckFramebufferStatus_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCheckFramebufferStatus_is_loaded() -> bool {
!glCheckFramebufferStatus_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClear(mask: GLbitfield) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glClear({:?});", mask);
}
let out = call_atomic_ptr_1arg("glClear", &glClear_p, mask);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClear", err);
err = glGetError();
}
}
out
}
static glClear_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClear_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glClear\0", &glClear_p)
}
#[inline]
#[doc(hidden)]
pub fn glClear_is_loaded() -> bool {
!glClear_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearBufferfi(
buffer: GLenum,
drawbuffer: GLint,
depth: GLfloat,
stencil: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glClearBufferfi({:#X}, {:?}, {:?}, {:?});",
buffer,
drawbuffer,
depth,
stencil
);
}
let out = call_atomic_ptr_4arg(
"glClearBufferfi",
&glClearBufferfi_p,
buffer,
drawbuffer,
depth,
stencil,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferfi", err);
err = glGetError();
}
}
out
}
static glClearBufferfi_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearBufferfi_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferfi\0",
&glClearBufferfi_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearBufferfi_is_loaded() -> bool {
!glClearBufferfi_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearBufferfv(
buffer: GLenum,
drawbuffer: GLint,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glClearBufferfv({:#X}, {:?}, {:p});",
buffer,
drawbuffer,
value
);
}
let out = call_atomic_ptr_3arg(
"glClearBufferfv",
&glClearBufferfv_p,
buffer,
drawbuffer,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferfv", err);
err = glGetError();
}
}
out
}
static glClearBufferfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearBufferfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferfv\0",
&glClearBufferfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearBufferfv_is_loaded() -> bool {
!glClearBufferfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearBufferiv(
buffer: GLenum,
drawbuffer: GLint,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glClearBufferiv({:#X}, {:?}, {:p});",
buffer,
drawbuffer,
value
);
}
let out = call_atomic_ptr_3arg(
"glClearBufferiv",
&glClearBufferiv_p,
buffer,
drawbuffer,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferiv", err);
err = glGetError();
}
}
out
}
static glClearBufferiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearBufferiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferiv\0",
&glClearBufferiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearBufferiv_is_loaded() -> bool {
!glClearBufferiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearBufferuiv(
buffer: GLenum,
drawbuffer: GLint,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glClearBufferuiv({:#X}, {:?}, {:p});",
buffer,
drawbuffer,
value
);
}
let out = call_atomic_ptr_3arg(
"glClearBufferuiv",
&glClearBufferuiv_p,
buffer,
drawbuffer,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferuiv", err);
err = glGetError();
}
}
out
}
static glClearBufferuiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearBufferuiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferuiv\0",
&glClearBufferuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearBufferuiv_is_loaded() -> bool {
!glClearBufferuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearColor(
red: GLfloat,
green: GLfloat,
blue: GLfloat,
alpha: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glClearColor({:?}, {:?}, {:?}, {:?});",
red,
green,
blue,
alpha
);
}
let out = call_atomic_ptr_4arg(
"glClearColor",
&glClearColor_p,
red,
green,
blue,
alpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearColor", err);
err = glGetError();
}
}
out
}
static glClearColor_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearColor_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearColor\0",
&glClearColor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearColor_is_loaded() -> bool {
!glClearColor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearDepthf(d: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glClearDepthf({:?});", d);
}
let out = call_atomic_ptr_1arg("glClearDepthf", &glClearDepthf_p, d);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearDepthf", err);
err = glGetError();
}
}
out
}
static glClearDepthf_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearDepthf_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearDepthf\0",
&glClearDepthf_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearDepthf_is_loaded() -> bool {
!glClearDepthf_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClearStencil(s: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glClearStencil({:?});", s);
}
let out = call_atomic_ptr_1arg("glClearStencil", &glClearStencil_p, s);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearStencil", err);
err = glGetError();
}
}
out
}
static glClearStencil_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClearStencil_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearStencil\0",
&glClearStencil_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClearStencil_is_loaded() -> bool {
!glClearStencil_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glClientWaitSync(
sync: GLsync,
flags: GLbitfield,
timeout: GLuint64,
) -> GLenum {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glClientWaitSync({:p}, {:?}, {:?});",
sync,
flags,
timeout
);
}
let out = call_atomic_ptr_3arg(
"glClientWaitSync",
&glClientWaitSync_p,
sync,
flags,
timeout,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glClientWaitSync", err);
err = glGetError();
}
}
out
}
static glClientWaitSync_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glClientWaitSync_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClientWaitSync\0",
&glClientWaitSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glClientWaitSync_is_loaded() -> bool {
!glClientWaitSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glColorMask(
red: GLboolean,
green: GLboolean,
blue: GLboolean,
alpha: GLboolean,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glColorMask({:?}, {:?}, {:?}, {:?});",
red,
green,
blue,
alpha
);
}
let out = call_atomic_ptr_4arg(
"glColorMask",
&glColorMask_p,
red,
green,
blue,
alpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glColorMask", err);
err = glGetError();
}
}
out
}
static glColorMask_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glColorMask_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glColorMask\0", &glColorMask_p)
}
#[inline]
#[doc(hidden)]
pub fn glColorMask_is_loaded() -> bool {
!glColorMask_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCompileShader(shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCompileShader({:?});", shader);
}
let out =
call_atomic_ptr_1arg("glCompileShader", &glCompileShader_p, shader);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompileShader", err);
err = glGetError();
}
}
out
}
static glCompileShader_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCompileShader_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompileShader\0",
&glCompileShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCompileShader_is_loaded() -> bool {
!glCompileShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCompressedTexImage2D(
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCompressedTexImage2D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?}, {:?}, {:p});", target, level, internalformat, width, height, border, imageSize, data);
}
let out = call_atomic_ptr_8arg(
"glCompressedTexImage2D",
&glCompressedTexImage2D_p,
target,
level,
internalformat,
width,
height,
border,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexImage2D", err);
err = glGetError();
}
}
out
}
static glCompressedTexImage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCompressedTexImage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexImage2D\0",
&glCompressedTexImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCompressedTexImage2D_is_loaded() -> bool {
!glCompressedTexImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCompressedTexImage3D(
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCompressedTexImage3D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:p});", target, level, internalformat, width, height, depth, border, imageSize, data);
}
let out = call_atomic_ptr_9arg(
"glCompressedTexImage3D",
&glCompressedTexImage3D_p,
target,
level,
internalformat,
width,
height,
depth,
border,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexImage3D", err);
err = glGetError();
}
}
out
}
static glCompressedTexImage3D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCompressedTexImage3D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexImage3D\0",
&glCompressedTexImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCompressedTexImage3D_is_loaded() -> bool {
!glCompressedTexImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCompressedTexSubImage2D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCompressedTexSubImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:?}, {:p});", target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
let out = call_atomic_ptr_9arg(
"glCompressedTexSubImage2D",
&glCompressedTexSubImage2D_p,
target,
level,
xoffset,
yoffset,
width,
height,
format,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexSubImage2D", err);
err = glGetError();
}
}
out
}
static glCompressedTexSubImage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCompressedTexSubImage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexSubImage2D\0",
&glCompressedTexSubImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCompressedTexSubImage2D_is_loaded() -> bool {
!glCompressedTexSubImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
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,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCompressedTexSubImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:?}, {:p});", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
let out = call_atomic_ptr_11arg(
"glCompressedTexSubImage3D",
&glCompressedTexSubImage3D_p,
target,
level,
xoffset,
yoffset,
zoffset,
width,
height,
depth,
format,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexSubImage3D", err);
err = glGetError();
}
}
out
}
static glCompressedTexSubImage3D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCompressedTexSubImage3D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexSubImage3D\0",
&glCompressedTexSubImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCompressedTexSubImage3D_is_loaded() -> bool {
!glCompressedTexSubImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCopyBufferSubData(
readTarget: GLenum,
writeTarget: GLenum,
readOffset: GLintptr,
writeOffset: GLintptr,
size: GLsizeiptr,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glCopyBufferSubData({:#X}, {:#X}, {:?}, {:?}, {:?});",
readTarget,
writeTarget,
readOffset,
writeOffset,
size
);
}
let out = call_atomic_ptr_5arg(
"glCopyBufferSubData",
&glCopyBufferSubData_p,
readTarget,
writeTarget,
readOffset,
writeOffset,
size,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyBufferSubData", err);
err = glGetError();
}
}
out
}
static glCopyBufferSubData_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCopyBufferSubData_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyBufferSubData\0",
&glCopyBufferSubData_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCopyBufferSubData_is_loaded() -> bool {
!glCopyBufferSubData_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCopyTexImage2D(
target: GLenum,
level: GLint,
internalformat: GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
border: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCopyTexImage2D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?}, {:?}, {:?});", target, level, internalformat, x, y, width, height, border);
}
let out = call_atomic_ptr_8arg(
"glCopyTexImage2D",
&glCopyTexImage2D_p,
target,
level,
internalformat,
x,
y,
width,
height,
border,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyTexImage2D", err);
err = glGetError();
}
}
out
}
static glCopyTexImage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCopyTexImage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyTexImage2D\0",
&glCopyTexImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCopyTexImage2D_is_loaded() -> bool {
!glCopyTexImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCopyTexSubImage2D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCopyTexSubImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?});", target, level, xoffset, yoffset, x, y, width, height);
}
let out = call_atomic_ptr_8arg(
"glCopyTexSubImage2D",
&glCopyTexSubImage2D_p,
target,
level,
xoffset,
yoffset,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyTexSubImage2D", err);
err = glGetError();
}
}
out
}
static glCopyTexSubImage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCopyTexSubImage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyTexSubImage2D\0",
&glCopyTexSubImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCopyTexSubImage2D_is_loaded() -> bool {
!glCopyTexSubImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCopyTexSubImage3D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCopyTexSubImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?});", target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
let out = call_atomic_ptr_9arg(
"glCopyTexSubImage3D",
&glCopyTexSubImage3D_p,
target,
level,
xoffset,
yoffset,
zoffset,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyTexSubImage3D", err);
err = glGetError();
}
}
out
}
static glCopyTexSubImage3D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCopyTexSubImage3D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyTexSubImage3D\0",
&glCopyTexSubImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCopyTexSubImage3D_is_loaded() -> bool {
!glCopyTexSubImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCreateProgram() -> GLuint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCreateProgram();",);
}
let out = call_atomic_ptr_0arg("glCreateProgram", &glCreateProgram_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCreateProgram", err);
err = glGetError();
}
}
out
}
static glCreateProgram_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCreateProgram_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCreateProgram\0",
&glCreateProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCreateProgram_is_loaded() -> bool {
!glCreateProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCreateShader(type_: GLenum) -> GLuint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCreateShader({:#X});", type_);
}
let out = call_atomic_ptr_1arg("glCreateShader", &glCreateShader_p, type_);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCreateShader", err);
err = glGetError();
}
}
out
}
static glCreateShader_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCreateShader_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCreateShader\0",
&glCreateShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glCreateShader_is_loaded() -> bool {
!glCreateShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glCullFace(mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glCullFace({:#X});", mode);
}
let out = call_atomic_ptr_1arg("glCullFace", &glCullFace_p, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glCullFace", err);
err = glGetError();
}
}
out
}
static glCullFace_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glCullFace_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glCullFace\0", &glCullFace_p)
}
#[inline]
#[doc(hidden)]
pub fn glCullFace_is_loaded() -> bool {
!glCullFace_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteBuffers(n: GLsizei, buffers: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteBuffers({:?}, {:p});", n, buffers);
}
let out =
call_atomic_ptr_2arg("glDeleteBuffers", &glDeleteBuffers_p, n, buffers);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteBuffers", err);
err = glGetError();
}
}
out
}
static glDeleteBuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteBuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteBuffers\0",
&glDeleteBuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteBuffers_is_loaded() -> bool {
!glDeleteBuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteFramebuffers(n: GLsizei, framebuffers: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteFramebuffers({:?}, {:p});", n, framebuffers);
}
let out = call_atomic_ptr_2arg(
"glDeleteFramebuffers",
&glDeleteFramebuffers_p,
n,
framebuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteFramebuffers", err);
err = glGetError();
}
}
out
}
static glDeleteFramebuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteFramebuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteFramebuffers\0",
&glDeleteFramebuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteFramebuffers_is_loaded() -> bool {
!glDeleteFramebuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteProgram(program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteProgram({:?});", program);
}
let out =
call_atomic_ptr_1arg("glDeleteProgram", &glDeleteProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteProgram", err);
err = glGetError();
}
}
out
}
static glDeleteProgram_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteProgram_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteProgram\0",
&glDeleteProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteProgram_is_loaded() -> bool {
!glDeleteProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteQueries(n: GLsizei, ids: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteQueries({:?}, {:p});", n, ids);
}
let out =
call_atomic_ptr_2arg("glDeleteQueries", &glDeleteQueries_p, n, ids);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteQueries", err);
err = glGetError();
}
}
out
}
static glDeleteQueries_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteQueries_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteQueries\0",
&glDeleteQueries_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteQueries_is_loaded() -> bool {
!glDeleteQueries_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteRenderbuffers(
n: GLsizei,
renderbuffers: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteRenderbuffers({:?}, {:p});", n, renderbuffers);
}
let out = call_atomic_ptr_2arg(
"glDeleteRenderbuffers",
&glDeleteRenderbuffers_p,
n,
renderbuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteRenderbuffers", err);
err = glGetError();
}
}
out
}
static glDeleteRenderbuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteRenderbuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteRenderbuffers\0",
&glDeleteRenderbuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteRenderbuffers_is_loaded() -> bool {
!glDeleteRenderbuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteSamplers(count: GLsizei, samplers: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteSamplers({:?}, {:p});", count, samplers);
}
let out = call_atomic_ptr_2arg(
"glDeleteSamplers",
&glDeleteSamplers_p,
count,
samplers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteSamplers", err);
err = glGetError();
}
}
out
}
static glDeleteSamplers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteSamplers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteSamplers\0",
&glDeleteSamplers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteSamplers_is_loaded() -> bool {
!glDeleteSamplers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteShader(shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteShader({:?});", shader);
}
let out = call_atomic_ptr_1arg("glDeleteShader", &glDeleteShader_p, shader);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteShader", err);
err = glGetError();
}
}
out
}
static glDeleteShader_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteShader_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteShader\0",
&glDeleteShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteShader_is_loaded() -> bool {
!glDeleteShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteSync(sync: GLsync) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteSync({:p});", sync);
}
let out = call_atomic_ptr_1arg("glDeleteSync", &glDeleteSync_p, sync);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteSync", err);
err = glGetError();
}
}
out
}
static glDeleteSync_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteSync_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteSync\0",
&glDeleteSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteSync_is_loaded() -> bool {
!glDeleteSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteTextures(n: GLsizei, textures: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteTextures({:?}, {:p});", n, textures);
}
let out = call_atomic_ptr_2arg(
"glDeleteTextures",
&glDeleteTextures_p,
n,
textures,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteTextures", err);
err = glGetError();
}
}
out
}
static glDeleteTextures_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteTextures_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteTextures\0",
&glDeleteTextures_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteTextures_is_loaded() -> bool {
!glDeleteTextures_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteTransformFeedbacks(n: GLsizei, ids: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteTransformFeedbacks({:?}, {:p});", n, ids);
}
let out = call_atomic_ptr_2arg(
"glDeleteTransformFeedbacks",
&glDeleteTransformFeedbacks_p,
n,
ids,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteTransformFeedbacks", err);
err = glGetError();
}
}
out
}
static glDeleteTransformFeedbacks_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteTransformFeedbacks_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteTransformFeedbacks\0",
&glDeleteTransformFeedbacks_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteTransformFeedbacks_is_loaded() -> bool {
!glDeleteTransformFeedbacks_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDeleteVertexArrays(n: GLsizei, arrays: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDeleteVertexArrays({:?}, {:p});", n, arrays);
}
let out = call_atomic_ptr_2arg(
"glDeleteVertexArrays",
&glDeleteVertexArrays_p,
n,
arrays,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteVertexArrays", err);
err = glGetError();
}
}
out
}
static glDeleteVertexArrays_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDeleteVertexArrays_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteVertexArrays\0",
&glDeleteVertexArrays_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDeleteVertexArrays_is_loaded() -> bool {
!glDeleteVertexArrays_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDepthFunc(func: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDepthFunc({:#X});", func);
}
let out = call_atomic_ptr_1arg("glDepthFunc", &glDepthFunc_p, func);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDepthFunc", err);
err = glGetError();
}
}
out
}
static glDepthFunc_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDepthFunc_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glDepthFunc\0", &glDepthFunc_p)
}
#[inline]
#[doc(hidden)]
pub fn glDepthFunc_is_loaded() -> bool {
!glDepthFunc_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDepthMask(flag: GLboolean) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDepthMask({:?});", flag);
}
let out = call_atomic_ptr_1arg("glDepthMask", &glDepthMask_p, flag);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDepthMask", err);
err = glGetError();
}
}
out
}
static glDepthMask_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDepthMask_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glDepthMask\0", &glDepthMask_p)
}
#[inline]
#[doc(hidden)]
pub fn glDepthMask_is_loaded() -> bool {
!glDepthMask_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDepthRangef(n: GLfloat, f: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDepthRangef({:?}, {:?});", n, f);
}
let out = call_atomic_ptr_2arg("glDepthRangef", &glDepthRangef_p, n, f);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDepthRangef", err);
err = glGetError();
}
}
out
}
static glDepthRangef_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDepthRangef_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDepthRangef\0",
&glDepthRangef_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDepthRangef_is_loaded() -> bool {
!glDepthRangef_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDetachShader(program: GLuint, shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDetachShader({:?}, {:?});", program, shader);
}
let out = call_atomic_ptr_2arg(
"glDetachShader",
&glDetachShader_p,
program,
shader,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDetachShader", err);
err = glGetError();
}
}
out
}
static glDetachShader_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDetachShader_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDetachShader\0",
&glDetachShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDetachShader_is_loaded() -> bool {
!glDetachShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDisable(cap: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDisable({:#X});", cap);
}
let out = call_atomic_ptr_1arg("glDisable", &glDisable_p, cap);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDisable", err);
err = glGetError();
}
}
out
}
static glDisable_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDisable_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glDisable\0", &glDisable_p)
}
#[inline]
#[doc(hidden)]
pub fn glDisable_is_loaded() -> bool {
!glDisable_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDisableVertexAttribArray(index: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDisableVertexAttribArray({:?});", index);
}
let out = call_atomic_ptr_1arg(
"glDisableVertexAttribArray",
&glDisableVertexAttribArray_p,
index,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDisableVertexAttribArray", err);
err = glGetError();
}
}
out
}
static glDisableVertexAttribArray_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDisableVertexAttribArray_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDisableVertexAttribArray\0",
&glDisableVertexAttribArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDisableVertexAttribArray_is_loaded() -> bool {
!glDisableVertexAttribArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDrawArrays(mode: GLenum, first: GLint, count: GLsizei) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDrawArrays({:#X}, {:?}, {:?});", mode, first, count);
}
let out =
call_atomic_ptr_3arg("glDrawArrays", &glDrawArrays_p, mode, first, count);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawArrays", err);
err = glGetError();
}
}
out
}
static glDrawArrays_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDrawArrays_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawArrays\0",
&glDrawArrays_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDrawArrays_is_loaded() -> bool {
!glDrawArrays_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDrawArraysInstanced(
mode: GLenum,
first: GLint,
count: GLsizei,
instancecount: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glDrawArraysInstanced({:#X}, {:?}, {:?}, {:?});",
mode,
first,
count,
instancecount
);
}
let out = call_atomic_ptr_4arg(
"glDrawArraysInstanced",
&glDrawArraysInstanced_p,
mode,
first,
count,
instancecount,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawArraysInstanced", err);
err = glGetError();
}
}
out
}
static glDrawArraysInstanced_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDrawArraysInstanced_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawArraysInstanced\0",
&glDrawArraysInstanced_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDrawArraysInstanced_is_loaded() -> bool {
!glDrawArraysInstanced_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDrawBuffers(n: GLsizei, bufs: *const GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glDrawBuffers({:?}, {:p});", n, bufs);
}
let out = call_atomic_ptr_2arg("glDrawBuffers", &glDrawBuffers_p, n, bufs);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawBuffers", err);
err = glGetError();
}
}
out
}
static glDrawBuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDrawBuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawBuffers\0",
&glDrawBuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDrawBuffers_is_loaded() -> bool {
!glDrawBuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDrawElements(
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glDrawElements({:#X}, {:?}, {:#X}, {:p});",
mode,
count,
type_,
indices
);
}
let out = call_atomic_ptr_4arg(
"glDrawElements",
&glDrawElements_p,
mode,
count,
type_,
indices,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawElements", err);
err = glGetError();
}
}
out
}
static glDrawElements_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDrawElements_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawElements\0",
&glDrawElements_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDrawElements_is_loaded() -> bool {
!glDrawElements_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDrawElementsInstanced(
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
instancecount: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glDrawElementsInstanced({:#X}, {:?}, {:#X}, {:p}, {:?});",
mode,
count,
type_,
indices,
instancecount
);
}
let out = call_atomic_ptr_5arg(
"glDrawElementsInstanced",
&glDrawElementsInstanced_p,
mode,
count,
type_,
indices,
instancecount,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawElementsInstanced", err);
err = glGetError();
}
}
out
}
static glDrawElementsInstanced_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDrawElementsInstanced_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawElementsInstanced\0",
&glDrawElementsInstanced_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDrawElementsInstanced_is_loaded() -> bool {
!glDrawElementsInstanced_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glDrawRangeElements(
mode: GLenum,
start: GLuint,
end: GLuint,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glDrawRangeElements({:#X}, {:?}, {:?}, {:?}, {:#X}, {:p});",
mode,
start,
end,
count,
type_,
indices
);
}
let out = call_atomic_ptr_6arg(
"glDrawRangeElements",
&glDrawRangeElements_p,
mode,
start,
end,
count,
type_,
indices,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawRangeElements", err);
err = glGetError();
}
}
out
}
static glDrawRangeElements_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glDrawRangeElements_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawRangeElements\0",
&glDrawRangeElements_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glDrawRangeElements_is_loaded() -> bool {
!glDrawRangeElements_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glEnable(cap: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glEnable({:#X});", cap);
}
let out = call_atomic_ptr_1arg("glEnable", &glEnable_p, cap);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glEnable", err);
err = glGetError();
}
}
out
}
static glEnable_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glEnable_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glEnable\0", &glEnable_p)
}
#[inline]
#[doc(hidden)]
pub fn glEnable_is_loaded() -> bool {
!glEnable_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glEnableVertexAttribArray(index: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glEnableVertexAttribArray({:?});", index);
}
let out = call_atomic_ptr_1arg(
"glEnableVertexAttribArray",
&glEnableVertexAttribArray_p,
index,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glEnableVertexAttribArray", err);
err = glGetError();
}
}
out
}
static glEnableVertexAttribArray_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glEnableVertexAttribArray_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glEnableVertexAttribArray\0",
&glEnableVertexAttribArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glEnableVertexAttribArray_is_loaded() -> bool {
!glEnableVertexAttribArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glEndQuery(target: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glEndQuery({:#X});", target);
}
let out = call_atomic_ptr_1arg("glEndQuery", &glEndQuery_p, target);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glEndQuery", err);
err = glGetError();
}
}
out
}
static glEndQuery_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glEndQuery_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glEndQuery\0", &glEndQuery_p)
}
#[inline]
#[doc(hidden)]
pub fn glEndQuery_is_loaded() -> bool {
!glEndQuery_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glEndTransformFeedback() {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glEndTransformFeedback();",);
}
let out =
call_atomic_ptr_0arg("glEndTransformFeedback", &glEndTransformFeedback_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glEndTransformFeedback", err);
err = glGetError();
}
}
out
}
static glEndTransformFeedback_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glEndTransformFeedback_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glEndTransformFeedback\0",
&glEndTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glEndTransformFeedback_is_loaded() -> bool {
!glEndTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFenceSync(condition: GLenum, flags: GLbitfield) -> GLsync {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glFenceSync({:#X}, {:?});", condition, flags);
}
let out =
call_atomic_ptr_2arg("glFenceSync", &glFenceSync_p, condition, flags);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFenceSync", err);
err = glGetError();
}
}
out
}
static glFenceSync_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFenceSync_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glFenceSync\0", &glFenceSync_p)
}
#[inline]
#[doc(hidden)]
pub fn glFenceSync_is_loaded() -> bool {
!glFenceSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFinish() {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glFinish();",);
}
let out = call_atomic_ptr_0arg("glFinish", &glFinish_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFinish", err);
err = glGetError();
}
}
out
}
static glFinish_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFinish_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glFinish\0", &glFinish_p)
}
#[inline]
#[doc(hidden)]
pub fn glFinish_is_loaded() -> bool {
!glFinish_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFlush() {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glFlush();",);
}
let out = call_atomic_ptr_0arg("glFlush", &glFlush_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFlush", err);
err = glGetError();
}
}
out
}
static glFlush_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFlush_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glFlush\0", &glFlush_p)
}
#[inline]
#[doc(hidden)]
pub fn glFlush_is_loaded() -> bool {
!glFlush_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFlushMappedBufferRange(
target: GLenum,
offset: GLintptr,
length: GLsizeiptr,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glFlushMappedBufferRange({:#X}, {:?}, {:?});",
target,
offset,
length
);
}
let out = call_atomic_ptr_3arg(
"glFlushMappedBufferRange",
&glFlushMappedBufferRange_p,
target,
offset,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFlushMappedBufferRange", err);
err = glGetError();
}
}
out
}
static glFlushMappedBufferRange_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFlushMappedBufferRange_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFlushMappedBufferRange\0",
&glFlushMappedBufferRange_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glFlushMappedBufferRange_is_loaded() -> bool {
!glFlushMappedBufferRange_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFramebufferRenderbuffer(
target: GLenum,
attachment: GLenum,
renderbuffertarget: GLenum,
renderbuffer: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glFramebufferRenderbuffer({:#X}, {:#X}, {:#X}, {:?});",
target,
attachment,
renderbuffertarget,
renderbuffer
);
}
let out = call_atomic_ptr_4arg(
"glFramebufferRenderbuffer",
&glFramebufferRenderbuffer_p,
target,
attachment,
renderbuffertarget,
renderbuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFramebufferRenderbuffer", err);
err = glGetError();
}
}
out
}
static glFramebufferRenderbuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFramebufferRenderbuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFramebufferRenderbuffer\0",
&glFramebufferRenderbuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glFramebufferRenderbuffer_is_loaded() -> bool {
!glFramebufferRenderbuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFramebufferTexture2D(
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glFramebufferTexture2D({:#X}, {:#X}, {:#X}, {:?}, {:?});",
target,
attachment,
textarget,
texture,
level
);
}
let out = call_atomic_ptr_5arg(
"glFramebufferTexture2D",
&glFramebufferTexture2D_p,
target,
attachment,
textarget,
texture,
level,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFramebufferTexture2D", err);
err = glGetError();
}
}
out
}
static glFramebufferTexture2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFramebufferTexture2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFramebufferTexture2D\0",
&glFramebufferTexture2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glFramebufferTexture2D_is_loaded() -> bool {
!glFramebufferTexture2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFramebufferTextureLayer(
target: GLenum,
attachment: GLenum,
texture: GLuint,
level: GLint,
layer: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glFramebufferTextureLayer({:#X}, {:#X}, {:?}, {:?}, {:?});",
target,
attachment,
texture,
level,
layer
);
}
let out = call_atomic_ptr_5arg(
"glFramebufferTextureLayer",
&glFramebufferTextureLayer_p,
target,
attachment,
texture,
level,
layer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFramebufferTextureLayer", err);
err = glGetError();
}
}
out
}
static glFramebufferTextureLayer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFramebufferTextureLayer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFramebufferTextureLayer\0",
&glFramebufferTextureLayer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glFramebufferTextureLayer_is_loaded() -> bool {
!glFramebufferTextureLayer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glFrontFace(mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glFrontFace({:#X});", mode);
}
let out = call_atomic_ptr_1arg("glFrontFace", &glFrontFace_p, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glFrontFace", err);
err = glGetError();
}
}
out
}
static glFrontFace_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glFrontFace_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glFrontFace\0", &glFrontFace_p)
}
#[inline]
#[doc(hidden)]
pub fn glFrontFace_is_loaded() -> bool {
!glFrontFace_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenBuffers(n: GLsizei, buffers: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenBuffers({:?}, {:p});", n, buffers);
}
let out = call_atomic_ptr_2arg("glGenBuffers", &glGenBuffers_p, n, buffers);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenBuffers", err);
err = glGetError();
}
}
out
}
static glGenBuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenBuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenBuffers\0",
&glGenBuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenBuffers_is_loaded() -> bool {
!glGenBuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenFramebuffers(n: GLsizei, framebuffers: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenFramebuffers({:?}, {:p});", n, framebuffers);
}
let out = call_atomic_ptr_2arg(
"glGenFramebuffers",
&glGenFramebuffers_p,
n,
framebuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenFramebuffers", err);
err = glGetError();
}
}
out
}
static glGenFramebuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenFramebuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenFramebuffers\0",
&glGenFramebuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenFramebuffers_is_loaded() -> bool {
!glGenFramebuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenQueries(n: GLsizei, ids: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenQueries({:?}, {:p});", n, ids);
}
let out = call_atomic_ptr_2arg("glGenQueries", &glGenQueries_p, n, ids);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenQueries", err);
err = glGetError();
}
}
out
}
static glGenQueries_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenQueries_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenQueries\0",
&glGenQueries_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenQueries_is_loaded() -> bool {
!glGenQueries_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenRenderbuffers(n: GLsizei, renderbuffers: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenRenderbuffers({:?}, {:p});", n, renderbuffers);
}
let out = call_atomic_ptr_2arg(
"glGenRenderbuffers",
&glGenRenderbuffers_p,
n,
renderbuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenRenderbuffers", err);
err = glGetError();
}
}
out
}
static glGenRenderbuffers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenRenderbuffers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenRenderbuffers\0",
&glGenRenderbuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenRenderbuffers_is_loaded() -> bool {
!glGenRenderbuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenSamplers(count: GLsizei, samplers: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenSamplers({:?}, {:p});", count, samplers);
}
let out =
call_atomic_ptr_2arg("glGenSamplers", &glGenSamplers_p, count, samplers);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenSamplers", err);
err = glGetError();
}
}
out
}
static glGenSamplers_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenSamplers_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenSamplers\0",
&glGenSamplers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenSamplers_is_loaded() -> bool {
!glGenSamplers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenTextures(n: GLsizei, textures: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenTextures({:?}, {:p});", n, textures);
}
let out =
call_atomic_ptr_2arg("glGenTextures", &glGenTextures_p, n, textures);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenTextures", err);
err = glGetError();
}
}
out
}
static glGenTextures_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenTextures_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenTextures\0",
&glGenTextures_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenTextures_is_loaded() -> bool {
!glGenTextures_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenTransformFeedbacks(n: GLsizei, ids: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenTransformFeedbacks({:?}, {:p});", n, ids);
}
let out = call_atomic_ptr_2arg(
"glGenTransformFeedbacks",
&glGenTransformFeedbacks_p,
n,
ids,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenTransformFeedbacks", err);
err = glGetError();
}
}
out
}
static glGenTransformFeedbacks_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenTransformFeedbacks_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenTransformFeedbacks\0",
&glGenTransformFeedbacks_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenTransformFeedbacks_is_loaded() -> bool {
!glGenTransformFeedbacks_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenVertexArrays(n: GLsizei, arrays: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenVertexArrays({:?}, {:p});", n, arrays);
}
let out = call_atomic_ptr_2arg(
"glGenVertexArrays",
&glGenVertexArrays_p,
n,
arrays,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenVertexArrays", err);
err = glGetError();
}
}
out
}
static glGenVertexArrays_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenVertexArrays_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenVertexArrays\0",
&glGenVertexArrays_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenVertexArrays_is_loaded() -> bool {
!glGenVertexArrays_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGenerateMipmap(target: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGenerateMipmap({:#X});", target);
}
let out =
call_atomic_ptr_1arg("glGenerateMipmap", &glGenerateMipmap_p, target);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenerateMipmap", err);
err = glGetError();
}
}
out
}
static glGenerateMipmap_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGenerateMipmap_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenerateMipmap\0",
&glGenerateMipmap_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGenerateMipmap_is_loaded() -> bool {
!glGenerateMipmap_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetActiveAttrib(
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLint,
type_: *mut GLenum,
name: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetActiveAttrib({:?}, {:?}, {:?}, {:p}, {:p}, {:p}, {:p});",
program,
index,
bufSize,
length,
size,
type_,
name
);
}
let out = call_atomic_ptr_7arg(
"glGetActiveAttrib",
&glGetActiveAttrib_p,
program,
index,
bufSize,
length,
size,
type_,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveAttrib", err);
err = glGetError();
}
}
out
}
static glGetActiveAttrib_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetActiveAttrib_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveAttrib\0",
&glGetActiveAttrib_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetActiveAttrib_is_loaded() -> bool {
!glGetActiveAttrib_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetActiveUniform(
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLint,
type_: *mut GLenum,
name: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetActiveUniform({:?}, {:?}, {:?}, {:p}, {:p}, {:p}, {:p});",
program,
index,
bufSize,
length,
size,
type_,
name
);
}
let out = call_atomic_ptr_7arg(
"glGetActiveUniform",
&glGetActiveUniform_p,
program,
index,
bufSize,
length,
size,
type_,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniform", err);
err = glGetError();
}
}
out
}
static glGetActiveUniform_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetActiveUniform_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniform\0",
&glGetActiveUniform_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetActiveUniform_is_loaded() -> bool {
!glGetActiveUniform_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetActiveUniformBlockName(
program: GLuint,
uniformBlockIndex: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
uniformBlockName: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetActiveUniformBlockName({:?}, {:?}, {:?}, {:p}, {:p});",
program,
uniformBlockIndex,
bufSize,
length,
uniformBlockName
);
}
let out = call_atomic_ptr_5arg(
"glGetActiveUniformBlockName",
&glGetActiveUniformBlockName_p,
program,
uniformBlockIndex,
bufSize,
length,
uniformBlockName,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniformBlockName", err);
err = glGetError();
}
}
out
}
static glGetActiveUniformBlockName_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetActiveUniformBlockName_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniformBlockName\0",
&glGetActiveUniformBlockName_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetActiveUniformBlockName_is_loaded() -> bool {
!glGetActiveUniformBlockName_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetActiveUniformBlockiv(
program: GLuint,
uniformBlockIndex: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetActiveUniformBlockiv({:?}, {:?}, {:#X}, {:p});",
program,
uniformBlockIndex,
pname,
params
);
}
let out = call_atomic_ptr_4arg(
"glGetActiveUniformBlockiv",
&glGetActiveUniformBlockiv_p,
program,
uniformBlockIndex,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniformBlockiv", err);
err = glGetError();
}
}
out
}
static glGetActiveUniformBlockiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetActiveUniformBlockiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniformBlockiv\0",
&glGetActiveUniformBlockiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetActiveUniformBlockiv_is_loaded() -> bool {
!glGetActiveUniformBlockiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetActiveUniformsiv(
program: GLuint,
uniformCount: GLsizei,
uniformIndices: *const GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetActiveUniformsiv({:?}, {:?}, {:p}, {:#X}, {:p});",
program,
uniformCount,
uniformIndices,
pname,
params
);
}
let out = call_atomic_ptr_5arg(
"glGetActiveUniformsiv",
&glGetActiveUniformsiv_p,
program,
uniformCount,
uniformIndices,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniformsiv", err);
err = glGetError();
}
}
out
}
static glGetActiveUniformsiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetActiveUniformsiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniformsiv\0",
&glGetActiveUniformsiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetActiveUniformsiv_is_loaded() -> bool {
!glGetActiveUniformsiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetAttachedShaders(
program: GLuint,
maxCount: GLsizei,
count: *mut GLsizei,
shaders: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetAttachedShaders({:?}, {:?}, {:p}, {:p});",
program,
maxCount,
count,
shaders
);
}
let out = call_atomic_ptr_4arg(
"glGetAttachedShaders",
&glGetAttachedShaders_p,
program,
maxCount,
count,
shaders,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetAttachedShaders", err);
err = glGetError();
}
}
out
}
static glGetAttachedShaders_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetAttachedShaders_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetAttachedShaders\0",
&glGetAttachedShaders_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetAttachedShaders_is_loaded() -> bool {
!glGetAttachedShaders_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetAttribLocation(
program: GLuint,
name: *const GLchar,
) -> GLint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetAttribLocation({:?}, {:p});", program, name);
}
let out = call_atomic_ptr_2arg(
"glGetAttribLocation",
&glGetAttribLocation_p,
program,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetAttribLocation", err);
err = glGetError();
}
}
out
}
static glGetAttribLocation_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetAttribLocation_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetAttribLocation\0",
&glGetAttribLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetAttribLocation_is_loaded() -> bool {
!glGetAttribLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetBooleanv(pname: GLenum, data: *mut GLboolean) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetBooleanv({:#X}, {:p});", pname, data);
}
let out =
call_atomic_ptr_2arg("glGetBooleanv", &glGetBooleanv_p, pname, data);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBooleanv", err);
err = glGetError();
}
}
out
}
static glGetBooleanv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetBooleanv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBooleanv\0",
&glGetBooleanv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetBooleanv_is_loaded() -> bool {
!glGetBooleanv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetBufferParameteri64v(
target: GLenum,
pname: GLenum,
params: *mut GLint64,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetBufferParameteri64v({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetBufferParameteri64v",
&glGetBufferParameteri64v_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBufferParameteri64v", err);
err = glGetError();
}
}
out
}
static glGetBufferParameteri64v_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetBufferParameteri64v_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBufferParameteri64v\0",
&glGetBufferParameteri64v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetBufferParameteri64v_is_loaded() -> bool {
!glGetBufferParameteri64v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetBufferParameteriv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetBufferParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetBufferParameteriv",
&glGetBufferParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBufferParameteriv", err);
err = glGetError();
}
}
out
}
static glGetBufferParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetBufferParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBufferParameteriv\0",
&glGetBufferParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetBufferParameteriv_is_loaded() -> bool {
!glGetBufferParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetBufferPointerv(
target: GLenum,
pname: GLenum,
params: *mut *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetBufferPointerv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetBufferPointerv",
&glGetBufferPointerv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBufferPointerv", err);
err = glGetError();
}
}
out
}
static glGetBufferPointerv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetBufferPointerv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBufferPointerv\0",
&glGetBufferPointerv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetBufferPointerv_is_loaded() -> bool {
!glGetBufferPointerv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetError() -> GLenum {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetError();",);
}
let out = call_atomic_ptr_0arg("glGetError", &glGetError_p);
out
}
static glGetError_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetError_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glGetError\0", &glGetError_p)
}
#[inline]
#[doc(hidden)]
pub fn glGetError_is_loaded() -> bool {
!glGetError_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetFloatv(pname: GLenum, data: *mut GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetFloatv({:#X}, {:p});", pname, data);
}
let out = call_atomic_ptr_2arg("glGetFloatv", &glGetFloatv_p, pname, data);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetFloatv", err);
err = glGetError();
}
}
out
}
static glGetFloatv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetFloatv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glGetFloatv\0", &glGetFloatv_p)
}
#[inline]
#[doc(hidden)]
pub fn glGetFloatv_is_loaded() -> bool {
!glGetFloatv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetFragDataLocation(
program: GLuint,
name: *const GLchar,
) -> GLint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetFragDataLocation({:?}, {:p});", program, name);
}
let out = call_atomic_ptr_2arg(
"glGetFragDataLocation",
&glGetFragDataLocation_p,
program,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetFragDataLocation", err);
err = glGetError();
}
}
out
}
static glGetFragDataLocation_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetFragDataLocation_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetFragDataLocation\0",
&glGetFragDataLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetFragDataLocation_is_loaded() -> bool {
!glGetFragDataLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetFramebufferAttachmentParameteriv(
target: GLenum,
attachment: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetFramebufferAttachmentParameteriv({:#X}, {:#X}, {:#X}, {:p});", target, attachment, pname, params);
}
let out = call_atomic_ptr_4arg(
"glGetFramebufferAttachmentParameteriv",
&glGetFramebufferAttachmentParameteriv_p,
target,
attachment,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetFramebufferAttachmentParameteriv", err);
err = glGetError();
}
}
out
}
static glGetFramebufferAttachmentParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetFramebufferAttachmentParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetFramebufferAttachmentParameteriv\0",
&glGetFramebufferAttachmentParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetFramebufferAttachmentParameteriv_is_loaded() -> bool {
!glGetFramebufferAttachmentParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetInteger64i_v(
target: GLenum,
index: GLuint,
data: *mut GLint64,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetInteger64i_v({:#X}, {:?}, {:p});",
target,
index,
data
);
}
let out = call_atomic_ptr_3arg(
"glGetInteger64i_v",
&glGetInteger64i_v_p,
target,
index,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetInteger64i_v", err);
err = glGetError();
}
}
out
}
static glGetInteger64i_v_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetInteger64i_v_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetInteger64i_v\0",
&glGetInteger64i_v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetInteger64i_v_is_loaded() -> bool {
!glGetInteger64i_v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetInteger64v(pname: GLenum, data: *mut GLint64) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetInteger64v({:#X}, {:p});", pname, data);
}
let out =
call_atomic_ptr_2arg("glGetInteger64v", &glGetInteger64v_p, pname, data);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetInteger64v", err);
err = glGetError();
}
}
out
}
static glGetInteger64v_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetInteger64v_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetInteger64v\0",
&glGetInteger64v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetInteger64v_is_loaded() -> bool {
!glGetInteger64v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetIntegeri_v(
target: GLenum,
index: GLuint,
data: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetIntegeri_v({:#X}, {:?}, {:p});",
target,
index,
data
);
}
let out = call_atomic_ptr_3arg(
"glGetIntegeri_v",
&glGetIntegeri_v_p,
target,
index,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetIntegeri_v", err);
err = glGetError();
}
}
out
}
static glGetIntegeri_v_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetIntegeri_v_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetIntegeri_v\0",
&glGetIntegeri_v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetIntegeri_v_is_loaded() -> bool {
!glGetIntegeri_v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetIntegerv(pname: GLenum, data: *mut GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetIntegerv({:#X}, {:p});", pname, data);
}
let out =
call_atomic_ptr_2arg("glGetIntegerv", &glGetIntegerv_p, pname, data);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetIntegerv", err);
err = glGetError();
}
}
out
}
static glGetIntegerv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetIntegerv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetIntegerv\0",
&glGetIntegerv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetIntegerv_is_loaded() -> bool {
!glGetIntegerv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetInternalformativ(
target: GLenum,
internalformat: GLenum,
pname: GLenum,
count: GLsizei,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetInternalformativ({:#X}, {:#X}, {:#X}, {:?}, {:p});",
target,
internalformat,
pname,
count,
params
);
}
let out = call_atomic_ptr_5arg(
"glGetInternalformativ",
&glGetInternalformativ_p,
target,
internalformat,
pname,
count,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetInternalformativ", err);
err = glGetError();
}
}
out
}
static glGetInternalformativ_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetInternalformativ_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetInternalformativ\0",
&glGetInternalformativ_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetInternalformativ_is_loaded() -> bool {
!glGetInternalformativ_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetProgramBinary(
program: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
binaryFormat: *mut GLenum,
binary: *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetProgramBinary({:?}, {:?}, {:p}, {:p}, {:p});",
program,
bufSize,
length,
binaryFormat,
binary
);
}
let out = call_atomic_ptr_5arg(
"glGetProgramBinary",
&glGetProgramBinary_p,
program,
bufSize,
length,
binaryFormat,
binary,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetProgramBinary", err);
err = glGetError();
}
}
out
}
static glGetProgramBinary_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetProgramBinary_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetProgramBinary\0",
&glGetProgramBinary_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetProgramBinary_is_loaded() -> bool {
!glGetProgramBinary_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetProgramInfoLog(
program: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
infoLog: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetProgramInfoLog({:?}, {:?}, {:p}, {:p});",
program,
bufSize,
length,
infoLog
);
}
let out = call_atomic_ptr_4arg(
"glGetProgramInfoLog",
&glGetProgramInfoLog_p,
program,
bufSize,
length,
infoLog,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetProgramInfoLog", err);
err = glGetError();
}
}
out
}
static glGetProgramInfoLog_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetProgramInfoLog_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetProgramInfoLog\0",
&glGetProgramInfoLog_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetProgramInfoLog_is_loaded() -> bool {
!glGetProgramInfoLog_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetProgramiv(
program: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetProgramiv({:?}, {:#X}, {:p});",
program,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetProgramiv",
&glGetProgramiv_p,
program,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetProgramiv", err);
err = glGetError();
}
}
out
}
static glGetProgramiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetProgramiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetProgramiv\0",
&glGetProgramiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetProgramiv_is_loaded() -> bool {
!glGetProgramiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetQueryObjectuiv(
id: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetQueryObjectuiv({:?}, {:#X}, {:p});",
id,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetQueryObjectuiv",
&glGetQueryObjectuiv_p,
id,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetQueryObjectuiv", err);
err = glGetError();
}
}
out
}
static glGetQueryObjectuiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetQueryObjectuiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetQueryObjectuiv\0",
&glGetQueryObjectuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetQueryObjectuiv_is_loaded() -> bool {
!glGetQueryObjectuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetQueryiv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetQueryiv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetQueryiv",
&glGetQueryiv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetQueryiv", err);
err = glGetError();
}
}
out
}
static glGetQueryiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetQueryiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetQueryiv\0",
&glGetQueryiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetQueryiv_is_loaded() -> bool {
!glGetQueryiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetRenderbufferParameteriv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetRenderbufferParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetRenderbufferParameteriv",
&glGetRenderbufferParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetRenderbufferParameteriv", err);
err = glGetError();
}
}
out
}
static glGetRenderbufferParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetRenderbufferParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetRenderbufferParameteriv\0",
&glGetRenderbufferParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetRenderbufferParameteriv_is_loaded() -> bool {
!glGetRenderbufferParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetSamplerParameterfv(
sampler: GLuint,
pname: GLenum,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetSamplerParameterfv({:?}, {:#X}, {:p});",
sampler,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetSamplerParameterfv",
&glGetSamplerParameterfv_p,
sampler,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetSamplerParameterfv", err);
err = glGetError();
}
}
out
}
static glGetSamplerParameterfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetSamplerParameterfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetSamplerParameterfv\0",
&glGetSamplerParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetSamplerParameterfv_is_loaded() -> bool {
!glGetSamplerParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetSamplerParameteriv(
sampler: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetSamplerParameteriv({:?}, {:#X}, {:p});",
sampler,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetSamplerParameteriv",
&glGetSamplerParameteriv_p,
sampler,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetSamplerParameteriv", err);
err = glGetError();
}
}
out
}
static glGetSamplerParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetSamplerParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetSamplerParameteriv\0",
&glGetSamplerParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetSamplerParameteriv_is_loaded() -> bool {
!glGetSamplerParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetShaderInfoLog(
shader: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
infoLog: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetShaderInfoLog({:?}, {:?}, {:p}, {:p});",
shader,
bufSize,
length,
infoLog
);
}
let out = call_atomic_ptr_4arg(
"glGetShaderInfoLog",
&glGetShaderInfoLog_p,
shader,
bufSize,
length,
infoLog,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderInfoLog", err);
err = glGetError();
}
}
out
}
static glGetShaderInfoLog_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetShaderInfoLog_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderInfoLog\0",
&glGetShaderInfoLog_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetShaderInfoLog_is_loaded() -> bool {
!glGetShaderInfoLog_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetShaderPrecisionFormat(
shadertype: GLenum,
precisiontype: GLenum,
range: *mut GLint,
precision: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetShaderPrecisionFormat({:#X}, {:#X}, {:p}, {:p});",
shadertype,
precisiontype,
range,
precision
);
}
let out = call_atomic_ptr_4arg(
"glGetShaderPrecisionFormat",
&glGetShaderPrecisionFormat_p,
shadertype,
precisiontype,
range,
precision,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderPrecisionFormat", err);
err = glGetError();
}
}
out
}
static glGetShaderPrecisionFormat_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetShaderPrecisionFormat_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderPrecisionFormat\0",
&glGetShaderPrecisionFormat_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetShaderPrecisionFormat_is_loaded() -> bool {
!glGetShaderPrecisionFormat_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetShaderSource(
shader: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
source: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetShaderSource({:?}, {:?}, {:p}, {:p});",
shader,
bufSize,
length,
source
);
}
let out = call_atomic_ptr_4arg(
"glGetShaderSource",
&glGetShaderSource_p,
shader,
bufSize,
length,
source,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderSource", err);
err = glGetError();
}
}
out
}
static glGetShaderSource_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetShaderSource_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderSource\0",
&glGetShaderSource_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetShaderSource_is_loaded() -> bool {
!glGetShaderSource_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetShaderiv(
shader: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetShaderiv({:?}, {:#X}, {:p});",
shader,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetShaderiv",
&glGetShaderiv_p,
shader,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderiv", err);
err = glGetError();
}
}
out
}
static glGetShaderiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetShaderiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderiv\0",
&glGetShaderiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetShaderiv_is_loaded() -> bool {
!glGetShaderiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetString(name: GLenum) -> *const GLubyte {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetString({:#X});", name);
}
let out = call_atomic_ptr_1arg("glGetString", &glGetString_p, name);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetString", err);
err = glGetError();
}
}
out
}
static glGetString_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetString_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glGetString\0", &glGetString_p)
}
#[inline]
#[doc(hidden)]
pub fn glGetString_is_loaded() -> bool {
!glGetString_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetStringi(name: GLenum, index: GLuint) -> *const GLubyte {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetStringi({:#X}, {:?});", name, index);
}
let out =
call_atomic_ptr_2arg("glGetStringi", &glGetStringi_p, name, index);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetStringi", err);
err = glGetError();
}
}
out
}
static glGetStringi_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetStringi_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetStringi\0",
&glGetStringi_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetStringi_is_loaded() -> bool {
!glGetStringi_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetSynciv(
sync: GLsync,
pname: GLenum,
count: GLsizei,
length: *mut GLsizei,
values: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetSynciv({:p}, {:#X}, {:?}, {:p}, {:p});",
sync,
pname,
count,
length,
values
);
}
let out = call_atomic_ptr_5arg(
"glGetSynciv",
&glGetSynciv_p,
sync,
pname,
count,
length,
values,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetSynciv", err);
err = glGetError();
}
}
out
}
static glGetSynciv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetSynciv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glGetSynciv\0", &glGetSynciv_p)
}
#[inline]
#[doc(hidden)]
pub fn glGetSynciv_is_loaded() -> bool {
!glGetSynciv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetTexParameterfv(
target: GLenum,
pname: GLenum,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetTexParameterfv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetTexParameterfv",
&glGetTexParameterfv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetTexParameterfv", err);
err = glGetError();
}
}
out
}
static glGetTexParameterfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetTexParameterfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetTexParameterfv\0",
&glGetTexParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetTexParameterfv_is_loaded() -> bool {
!glGetTexParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetTexParameteriv(
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetTexParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetTexParameteriv",
&glGetTexParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetTexParameteriv", err);
err = glGetError();
}
}
out
}
static glGetTexParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetTexParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetTexParameteriv\0",
&glGetTexParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetTexParameteriv_is_loaded() -> bool {
!glGetTexParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetTransformFeedbackVarying(
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLsizei,
type_: *mut GLenum,
name: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetTransformFeedbackVarying({:?}, {:?}, {:?}, {:p}, {:p}, {:p}, {:p});", program, index, bufSize, length, size, type_, name);
}
let out = call_atomic_ptr_7arg(
"glGetTransformFeedbackVarying",
&glGetTransformFeedbackVarying_p,
program,
index,
bufSize,
length,
size,
type_,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetTransformFeedbackVarying", err);
err = glGetError();
}
}
out
}
static glGetTransformFeedbackVarying_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetTransformFeedbackVarying_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetTransformFeedbackVarying\0",
&glGetTransformFeedbackVarying_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetTransformFeedbackVarying_is_loaded() -> bool {
!glGetTransformFeedbackVarying_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetUniformBlockIndex(
program: GLuint,
uniformBlockName: *const GLchar,
) -> GLuint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetUniformBlockIndex({:?}, {:p});",
program,
uniformBlockName
);
}
let out = call_atomic_ptr_2arg(
"glGetUniformBlockIndex",
&glGetUniformBlockIndex_p,
program,
uniformBlockName,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformBlockIndex", err);
err = glGetError();
}
}
out
}
static glGetUniformBlockIndex_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetUniformBlockIndex_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformBlockIndex\0",
&glGetUniformBlockIndex_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetUniformBlockIndex_is_loaded() -> bool {
!glGetUniformBlockIndex_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetUniformIndices(
program: GLuint,
uniformCount: GLsizei,
uniformNames: *const *const GLchar,
uniformIndices: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetUniformIndices({:?}, {:?}, {:p}, {:p});",
program,
uniformCount,
uniformNames,
uniformIndices
);
}
let out = call_atomic_ptr_4arg(
"glGetUniformIndices",
&glGetUniformIndices_p,
program,
uniformCount,
uniformNames,
uniformIndices,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformIndices", err);
err = glGetError();
}
}
out
}
static glGetUniformIndices_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetUniformIndices_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformIndices\0",
&glGetUniformIndices_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetUniformIndices_is_loaded() -> bool {
!glGetUniformIndices_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetUniformLocation(
program: GLuint,
name: *const GLchar,
) -> GLint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glGetUniformLocation({:?}, {:p});", program, name);
}
let out = call_atomic_ptr_2arg(
"glGetUniformLocation",
&glGetUniformLocation_p,
program,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformLocation", err);
err = glGetError();
}
}
out
}
static glGetUniformLocation_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetUniformLocation_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformLocation\0",
&glGetUniformLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetUniformLocation_is_loaded() -> bool {
!glGetUniformLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetUniformfv(
program: GLuint,
location: GLint,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetUniformfv({:?}, {:?}, {:p});",
program,
location,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetUniformfv",
&glGetUniformfv_p,
program,
location,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformfv", err);
err = glGetError();
}
}
out
}
static glGetUniformfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetUniformfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformfv\0",
&glGetUniformfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetUniformfv_is_loaded() -> bool {
!glGetUniformfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetUniformiv(
program: GLuint,
location: GLint,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetUniformiv({:?}, {:?}, {:p});",
program,
location,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetUniformiv",
&glGetUniformiv_p,
program,
location,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformiv", err);
err = glGetError();
}
}
out
}
static glGetUniformiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetUniformiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformiv\0",
&glGetUniformiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetUniformiv_is_loaded() -> bool {
!glGetUniformiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetUniformuiv(
program: GLuint,
location: GLint,
params: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetUniformuiv({:?}, {:?}, {:p});",
program,
location,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetUniformuiv",
&glGetUniformuiv_p,
program,
location,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformuiv", err);
err = glGetError();
}
}
out
}
static glGetUniformuiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetUniformuiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformuiv\0",
&glGetUniformuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetUniformuiv_is_loaded() -> bool {
!glGetUniformuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetVertexAttribIiv(
index: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetVertexAttribIiv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribIiv",
&glGetVertexAttribIiv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribIiv", err);
err = glGetError();
}
}
out
}
static glGetVertexAttribIiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetVertexAttribIiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribIiv\0",
&glGetVertexAttribIiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetVertexAttribIiv_is_loaded() -> bool {
!glGetVertexAttribIiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetVertexAttribIuiv(
index: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetVertexAttribIuiv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribIuiv",
&glGetVertexAttribIuiv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribIuiv", err);
err = glGetError();
}
}
out
}
static glGetVertexAttribIuiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetVertexAttribIuiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribIuiv\0",
&glGetVertexAttribIuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetVertexAttribIuiv_is_loaded() -> bool {
!glGetVertexAttribIuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetVertexAttribPointerv(
index: GLuint,
pname: GLenum,
pointer: *mut *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetVertexAttribPointerv({:?}, {:#X}, {:p});",
index,
pname,
pointer
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribPointerv",
&glGetVertexAttribPointerv_p,
index,
pname,
pointer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribPointerv", err);
err = glGetError();
}
}
out
}
static glGetVertexAttribPointerv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetVertexAttribPointerv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribPointerv\0",
&glGetVertexAttribPointerv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetVertexAttribPointerv_is_loaded() -> bool {
!glGetVertexAttribPointerv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetVertexAttribfv(
index: GLuint,
pname: GLenum,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetVertexAttribfv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribfv",
&glGetVertexAttribfv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribfv", err);
err = glGetError();
}
}
out
}
static glGetVertexAttribfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetVertexAttribfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribfv\0",
&glGetVertexAttribfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetVertexAttribfv_is_loaded() -> bool {
!glGetVertexAttribfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glGetVertexAttribiv(
index: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glGetVertexAttribiv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribiv",
&glGetVertexAttribiv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribiv", err);
err = glGetError();
}
}
out
}
static glGetVertexAttribiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glGetVertexAttribiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribiv\0",
&glGetVertexAttribiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glGetVertexAttribiv_is_loaded() -> bool {
!glGetVertexAttribiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glHint(target: GLenum, mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glHint({:#X}, {:#X});", target, mode);
}
let out = call_atomic_ptr_2arg("glHint", &glHint_p, target, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glHint", err);
err = glGetError();
}
}
out
}
static glHint_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glHint_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glHint\0", &glHint_p)
}
#[inline]
#[doc(hidden)]
pub fn glHint_is_loaded() -> bool {
!glHint_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glInvalidateFramebuffer(
target: GLenum,
numAttachments: GLsizei,
attachments: *const GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glInvalidateFramebuffer({:#X}, {:?}, {:p});",
target,
numAttachments,
attachments
);
}
let out = call_atomic_ptr_3arg(
"glInvalidateFramebuffer",
&glInvalidateFramebuffer_p,
target,
numAttachments,
attachments,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glInvalidateFramebuffer", err);
err = glGetError();
}
}
out
}
static glInvalidateFramebuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glInvalidateFramebuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glInvalidateFramebuffer\0",
&glInvalidateFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glInvalidateFramebuffer_is_loaded() -> bool {
!glInvalidateFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glInvalidateSubFramebuffer(
target: GLenum,
numAttachments: GLsizei,
attachments: *const GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glInvalidateSubFramebuffer({:#X}, {:?}, {:p}, {:?}, {:?}, {:?}, {:?});", target, numAttachments, attachments, x, y, width, height);
}
let out = call_atomic_ptr_7arg(
"glInvalidateSubFramebuffer",
&glInvalidateSubFramebuffer_p,
target,
numAttachments,
attachments,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glInvalidateSubFramebuffer", err);
err = glGetError();
}
}
out
}
static glInvalidateSubFramebuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glInvalidateSubFramebuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glInvalidateSubFramebuffer\0",
&glInvalidateSubFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glInvalidateSubFramebuffer_is_loaded() -> bool {
!glInvalidateSubFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsBuffer(buffer: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsBuffer({:?});", buffer);
}
let out = call_atomic_ptr_1arg("glIsBuffer", &glIsBuffer_p, buffer);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsBuffer", err);
err = glGetError();
}
}
out
}
static glIsBuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsBuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsBuffer\0", &glIsBuffer_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsBuffer_is_loaded() -> bool {
!glIsBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsEnabled(cap: GLenum) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsEnabled({:#X});", cap);
}
let out = call_atomic_ptr_1arg("glIsEnabled", &glIsEnabled_p, cap);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsEnabled", err);
err = glGetError();
}
}
out
}
static glIsEnabled_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsEnabled_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsEnabled\0", &glIsEnabled_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsEnabled_is_loaded() -> bool {
!glIsEnabled_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsFramebuffer(framebuffer: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsFramebuffer({:?});", framebuffer);
}
let out =
call_atomic_ptr_1arg("glIsFramebuffer", &glIsFramebuffer_p, framebuffer);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsFramebuffer", err);
err = glGetError();
}
}
out
}
static glIsFramebuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsFramebuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsFramebuffer\0",
&glIsFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glIsFramebuffer_is_loaded() -> bool {
!glIsFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsProgram(program: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsProgram({:?});", program);
}
let out = call_atomic_ptr_1arg("glIsProgram", &glIsProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsProgram", err);
err = glGetError();
}
}
out
}
static glIsProgram_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsProgram_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsProgram\0", &glIsProgram_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsProgram_is_loaded() -> bool {
!glIsProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsQuery(id: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsQuery({:?});", id);
}
let out = call_atomic_ptr_1arg("glIsQuery", &glIsQuery_p, id);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsQuery", err);
err = glGetError();
}
}
out
}
static glIsQuery_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsQuery_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsQuery\0", &glIsQuery_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsQuery_is_loaded() -> bool {
!glIsQuery_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsRenderbuffer(renderbuffer: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsRenderbuffer({:?});", renderbuffer);
}
let out = call_atomic_ptr_1arg(
"glIsRenderbuffer",
&glIsRenderbuffer_p,
renderbuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsRenderbuffer", err);
err = glGetError();
}
}
out
}
static glIsRenderbuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsRenderbuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsRenderbuffer\0",
&glIsRenderbuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glIsRenderbuffer_is_loaded() -> bool {
!glIsRenderbuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsSampler(sampler: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsSampler({:?});", sampler);
}
let out = call_atomic_ptr_1arg("glIsSampler", &glIsSampler_p, sampler);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsSampler", err);
err = glGetError();
}
}
out
}
static glIsSampler_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsSampler_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsSampler\0", &glIsSampler_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsSampler_is_loaded() -> bool {
!glIsSampler_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsShader(shader: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsShader({:?});", shader);
}
let out = call_atomic_ptr_1arg("glIsShader", &glIsShader_p, shader);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsShader", err);
err = glGetError();
}
}
out
}
static glIsShader_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsShader_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsShader\0", &glIsShader_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsShader_is_loaded() -> bool {
!glIsShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsSync(sync: GLsync) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsSync({:p});", sync);
}
let out = call_atomic_ptr_1arg("glIsSync", &glIsSync_p, sync);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsSync", err);
err = glGetError();
}
}
out
}
static glIsSync_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsSync_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsSync\0", &glIsSync_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsSync_is_loaded() -> bool {
!glIsSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsTexture(texture: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsTexture({:?});", texture);
}
let out = call_atomic_ptr_1arg("glIsTexture", &glIsTexture_p, texture);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsTexture", err);
err = glGetError();
}
}
out
}
static glIsTexture_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsTexture_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glIsTexture\0", &glIsTexture_p)
}
#[inline]
#[doc(hidden)]
pub fn glIsTexture_is_loaded() -> bool {
!glIsTexture_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsTransformFeedback(id: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsTransformFeedback({:?});", id);
}
let out = call_atomic_ptr_1arg(
"glIsTransformFeedback",
&glIsTransformFeedback_p,
id,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsTransformFeedback", err);
err = glGetError();
}
}
out
}
static glIsTransformFeedback_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsTransformFeedback_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsTransformFeedback\0",
&glIsTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glIsTransformFeedback_is_loaded() -> bool {
!glIsTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glIsVertexArray(array: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glIsVertexArray({:?});", array);
}
let out =
call_atomic_ptr_1arg("glIsVertexArray", &glIsVertexArray_p, array);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsVertexArray", err);
err = glGetError();
}
}
out
}
static glIsVertexArray_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glIsVertexArray_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsVertexArray\0",
&glIsVertexArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glIsVertexArray_is_loaded() -> bool {
!glIsVertexArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glLineWidth(width: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glLineWidth({:?});", width);
}
let out = call_atomic_ptr_1arg("glLineWidth", &glLineWidth_p, width);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glLineWidth", err);
err = glGetError();
}
}
out
}
static glLineWidth_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glLineWidth_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glLineWidth\0", &glLineWidth_p)
}
#[inline]
#[doc(hidden)]
pub fn glLineWidth_is_loaded() -> bool {
!glLineWidth_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glLinkProgram(program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glLinkProgram({:?});", program);
}
let out = call_atomic_ptr_1arg("glLinkProgram", &glLinkProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glLinkProgram", err);
err = glGetError();
}
}
out
}
static glLinkProgram_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glLinkProgram_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glLinkProgram\0",
&glLinkProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glLinkProgram_is_loaded() -> bool {
!glLinkProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glMapBufferRange(
target: GLenum,
offset: GLintptr,
length: GLsizeiptr,
access: GLbitfield,
) -> *mut c_void {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glMapBufferRange({:#X}, {:?}, {:?}, {:?});",
target,
offset,
length,
access
);
}
let out = call_atomic_ptr_4arg(
"glMapBufferRange",
&glMapBufferRange_p,
target,
offset,
length,
access,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glMapBufferRange", err);
err = glGetError();
}
}
out
}
static glMapBufferRange_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glMapBufferRange_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glMapBufferRange\0",
&glMapBufferRange_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glMapBufferRange_is_loaded() -> bool {
!glMapBufferRange_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glPauseTransformFeedback() {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glPauseTransformFeedback();",);
}
let out = call_atomic_ptr_0arg(
"glPauseTransformFeedback",
&glPauseTransformFeedback_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glPauseTransformFeedback", err);
err = glGetError();
}
}
out
}
static glPauseTransformFeedback_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glPauseTransformFeedback_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glPauseTransformFeedback\0",
&glPauseTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glPauseTransformFeedback_is_loaded() -> bool {
!glPauseTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glPixelStorei(pname: GLenum, param: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glPixelStorei({:#X}, {:?});", pname, param);
}
let out =
call_atomic_ptr_2arg("glPixelStorei", &glPixelStorei_p, pname, param);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glPixelStorei", err);
err = glGetError();
}
}
out
}
static glPixelStorei_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glPixelStorei_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glPixelStorei\0",
&glPixelStorei_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glPixelStorei_is_loaded() -> bool {
!glPixelStorei_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glPolygonOffset(factor: GLfloat, units: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glPolygonOffset({:?}, {:?});", factor, units);
}
let out = call_atomic_ptr_2arg(
"glPolygonOffset",
&glPolygonOffset_p,
factor,
units,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glPolygonOffset", err);
err = glGetError();
}
}
out
}
static glPolygonOffset_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glPolygonOffset_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glPolygonOffset\0",
&glPolygonOffset_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glPolygonOffset_is_loaded() -> bool {
!glPolygonOffset_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glProgramBinary(
program: GLuint,
binaryFormat: GLenum,
binary: *const c_void,
length: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glProgramBinary({:?}, {:#X}, {:p}, {:?});",
program,
binaryFormat,
binary,
length
);
}
let out = call_atomic_ptr_4arg(
"glProgramBinary",
&glProgramBinary_p,
program,
binaryFormat,
binary,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glProgramBinary", err);
err = glGetError();
}
}
out
}
static glProgramBinary_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glProgramBinary_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glProgramBinary\0",
&glProgramBinary_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glProgramBinary_is_loaded() -> bool {
!glProgramBinary_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glProgramParameteri(
program: GLuint,
pname: GLenum,
value: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glProgramParameteri({:?}, {:#X}, {:?});",
program,
pname,
value
);
}
let out = call_atomic_ptr_3arg(
"glProgramParameteri",
&glProgramParameteri_p,
program,
pname,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glProgramParameteri", err);
err = glGetError();
}
}
out
}
static glProgramParameteri_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glProgramParameteri_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glProgramParameteri\0",
&glProgramParameteri_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glProgramParameteri_is_loaded() -> bool {
!glProgramParameteri_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glReadBuffer(src: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glReadBuffer({:#X});", src);
}
let out = call_atomic_ptr_1arg("glReadBuffer", &glReadBuffer_p, src);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glReadBuffer", err);
err = glGetError();
}
}
out
}
static glReadBuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glReadBuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glReadBuffer\0",
&glReadBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glReadBuffer_is_loaded() -> bool {
!glReadBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glReadPixels(
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glReadPixels({:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});",
x,
y,
width,
height,
format,
type_,
pixels
);
}
let out = call_atomic_ptr_7arg(
"glReadPixels",
&glReadPixels_p,
x,
y,
width,
height,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glReadPixels", err);
err = glGetError();
}
}
out
}
static glReadPixels_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glReadPixels_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glReadPixels\0",
&glReadPixels_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glReadPixels_is_loaded() -> bool {
!glReadPixels_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glReleaseShaderCompiler() {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glReleaseShaderCompiler();",);
}
let out = call_atomic_ptr_0arg(
"glReleaseShaderCompiler",
&glReleaseShaderCompiler_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glReleaseShaderCompiler", err);
err = glGetError();
}
}
out
}
static glReleaseShaderCompiler_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glReleaseShaderCompiler_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glReleaseShaderCompiler\0",
&glReleaseShaderCompiler_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glReleaseShaderCompiler_is_loaded() -> bool {
!glReleaseShaderCompiler_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glRenderbufferStorage(
target: GLenum,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glRenderbufferStorage({:#X}, {:#X}, {:?}, {:?});",
target,
internalformat,
width,
height
);
}
let out = call_atomic_ptr_4arg(
"glRenderbufferStorage",
&glRenderbufferStorage_p,
target,
internalformat,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glRenderbufferStorage", err);
err = glGetError();
}
}
out
}
static glRenderbufferStorage_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glRenderbufferStorage_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glRenderbufferStorage\0",
&glRenderbufferStorage_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glRenderbufferStorage_is_loaded() -> bool {
!glRenderbufferStorage_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glRenderbufferStorageMultisample(
target: GLenum,
samples: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glRenderbufferStorageMultisample({:#X}, {:?}, {:#X}, {:?}, {:?});", target, samples, internalformat, width, height);
}
let out = call_atomic_ptr_5arg(
"glRenderbufferStorageMultisample",
&glRenderbufferStorageMultisample_p,
target,
samples,
internalformat,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glRenderbufferStorageMultisample", err);
err = glGetError();
}
}
out
}
static glRenderbufferStorageMultisample_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glRenderbufferStorageMultisample_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glRenderbufferStorageMultisample\0",
&glRenderbufferStorageMultisample_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glRenderbufferStorageMultisample_is_loaded() -> bool {
!glRenderbufferStorageMultisample_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glResumeTransformFeedback() {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glResumeTransformFeedback();",);
}
let out = call_atomic_ptr_0arg(
"glResumeTransformFeedback",
&glResumeTransformFeedback_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glResumeTransformFeedback", err);
err = glGetError();
}
}
out
}
static glResumeTransformFeedback_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glResumeTransformFeedback_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glResumeTransformFeedback\0",
&glResumeTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glResumeTransformFeedback_is_loaded() -> bool {
!glResumeTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glSampleCoverage(value: GLfloat, invert: GLboolean) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glSampleCoverage({:?}, {:?});", value, invert);
}
let out = call_atomic_ptr_2arg(
"glSampleCoverage",
&glSampleCoverage_p,
value,
invert,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glSampleCoverage", err);
err = glGetError();
}
}
out
}
static glSampleCoverage_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glSampleCoverage_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSampleCoverage\0",
&glSampleCoverage_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glSampleCoverage_is_loaded() -> bool {
!glSampleCoverage_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glSamplerParameterf(
sampler: GLuint,
pname: GLenum,
param: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glSamplerParameterf({:?}, {:#X}, {:?});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameterf",
&glSamplerParameterf_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameterf", err);
err = glGetError();
}
}
out
}
static glSamplerParameterf_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glSamplerParameterf_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameterf\0",
&glSamplerParameterf_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glSamplerParameterf_is_loaded() -> bool {
!glSamplerParameterf_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glSamplerParameterfv(
sampler: GLuint,
pname: GLenum,
param: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glSamplerParameterfv({:?}, {:#X}, {:p});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameterfv",
&glSamplerParameterfv_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameterfv", err);
err = glGetError();
}
}
out
}
static glSamplerParameterfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glSamplerParameterfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameterfv\0",
&glSamplerParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glSamplerParameterfv_is_loaded() -> bool {
!glSamplerParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glSamplerParameteri(
sampler: GLuint,
pname: GLenum,
param: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glSamplerParameteri({:?}, {:#X}, {:?});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameteri",
&glSamplerParameteri_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameteri", err);
err = glGetError();
}
}
out
}
static glSamplerParameteri_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glSamplerParameteri_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameteri\0",
&glSamplerParameteri_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glSamplerParameteri_is_loaded() -> bool {
!glSamplerParameteri_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glSamplerParameteriv(
sampler: GLuint,
pname: GLenum,
param: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glSamplerParameteriv({:?}, {:#X}, {:p});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameteriv",
&glSamplerParameteriv_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameteriv", err);
err = glGetError();
}
}
out
}
static glSamplerParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glSamplerParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameteriv\0",
&glSamplerParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glSamplerParameteriv_is_loaded() -> bool {
!glSamplerParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glScissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glScissor({:?}, {:?}, {:?}, {:?});", x, y, width, height);
}
let out =
call_atomic_ptr_4arg("glScissor", &glScissor_p, x, y, width, height);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glScissor", err);
err = glGetError();
}
}
out
}
static glScissor_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glScissor_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glScissor\0", &glScissor_p)
}
#[inline]
#[doc(hidden)]
pub fn glScissor_is_loaded() -> bool {
!glScissor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glShaderBinary(
count: GLsizei,
shaders: *const GLuint,
binaryformat: GLenum,
binary: *const c_void,
length: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glShaderBinary({:?}, {:p}, {:#X}, {:p}, {:?});",
count,
shaders,
binaryformat,
binary,
length
);
}
let out = call_atomic_ptr_5arg(
"glShaderBinary",
&glShaderBinary_p,
count,
shaders,
binaryformat,
binary,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glShaderBinary", err);
err = glGetError();
}
}
out
}
static glShaderBinary_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glShaderBinary_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glShaderBinary\0",
&glShaderBinary_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glShaderBinary_is_loaded() -> bool {
!glShaderBinary_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glShaderSource(
shader: GLuint,
count: GLsizei,
string: *const *const GLchar,
length: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glShaderSource({:?}, {:?}, {:p}, {:p});",
shader,
count,
string,
length
);
}
let out = call_atomic_ptr_4arg(
"glShaderSource",
&glShaderSource_p,
shader,
count,
string,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glShaderSource", err);
err = glGetError();
}
}
out
}
static glShaderSource_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glShaderSource_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glShaderSource\0",
&glShaderSource_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glShaderSource_is_loaded() -> bool {
!glShaderSource_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glStencilFunc(func: GLenum, ref_: GLint, mask: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glStencilFunc({:#X}, {:?}, {:?});", func, ref_, mask);
}
let out =
call_atomic_ptr_3arg("glStencilFunc", &glStencilFunc_p, func, ref_, mask);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilFunc", err);
err = glGetError();
}
}
out
}
static glStencilFunc_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glStencilFunc_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilFunc\0",
&glStencilFunc_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glStencilFunc_is_loaded() -> bool {
!glStencilFunc_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glStencilFuncSeparate(
face: GLenum,
func: GLenum,
ref_: GLint,
mask: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glStencilFuncSeparate({:#X}, {:#X}, {:?}, {:?});",
face,
func,
ref_,
mask
);
}
let out = call_atomic_ptr_4arg(
"glStencilFuncSeparate",
&glStencilFuncSeparate_p,
face,
func,
ref_,
mask,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilFuncSeparate", err);
err = glGetError();
}
}
out
}
static glStencilFuncSeparate_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glStencilFuncSeparate_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilFuncSeparate\0",
&glStencilFuncSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glStencilFuncSeparate_is_loaded() -> bool {
!glStencilFuncSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glStencilMask(mask: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glStencilMask({:?});", mask);
}
let out = call_atomic_ptr_1arg("glStencilMask", &glStencilMask_p, mask);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilMask", err);
err = glGetError();
}
}
out
}
static glStencilMask_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glStencilMask_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilMask\0",
&glStencilMask_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glStencilMask_is_loaded() -> bool {
!glStencilMask_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glStencilMaskSeparate(face: GLenum, mask: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glStencilMaskSeparate({:#X}, {:?});", face, mask);
}
let out = call_atomic_ptr_2arg(
"glStencilMaskSeparate",
&glStencilMaskSeparate_p,
face,
mask,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilMaskSeparate", err);
err = glGetError();
}
}
out
}
static glStencilMaskSeparate_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glStencilMaskSeparate_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilMaskSeparate\0",
&glStencilMaskSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glStencilMaskSeparate_is_loaded() -> bool {
!glStencilMaskSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glStencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glStencilOp({:#X}, {:#X}, {:#X});", fail, zfail, zpass);
}
let out =
call_atomic_ptr_3arg("glStencilOp", &glStencilOp_p, fail, zfail, zpass);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilOp", err);
err = glGetError();
}
}
out
}
static glStencilOp_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glStencilOp_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glStencilOp\0", &glStencilOp_p)
}
#[inline]
#[doc(hidden)]
pub fn glStencilOp_is_loaded() -> bool {
!glStencilOp_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glStencilOpSeparate(
face: GLenum,
sfail: GLenum,
dpfail: GLenum,
dppass: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glStencilOpSeparate({:#X}, {:#X}, {:#X}, {:#X});",
face,
sfail,
dpfail,
dppass
);
}
let out = call_atomic_ptr_4arg(
"glStencilOpSeparate",
&glStencilOpSeparate_p,
face,
sfail,
dpfail,
dppass,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilOpSeparate", err);
err = glGetError();
}
}
out
}
static glStencilOpSeparate_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glStencilOpSeparate_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilOpSeparate\0",
&glStencilOpSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glStencilOpSeparate_is_loaded() -> bool {
!glStencilOpSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexImage2D(
target: GLenum,
level: GLint,
internalformat: GLint,
width: GLsizei,
height: GLsizei,
border: GLint,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glTexImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, internalformat, width, height, border, format, type_, pixels);
}
let out = call_atomic_ptr_9arg(
"glTexImage2D",
&glTexImage2D_p,
target,
level,
internalformat,
width,
height,
border,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexImage2D", err);
err = glGetError();
}
}
out
}
static glTexImage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexImage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexImage2D\0",
&glTexImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexImage2D_is_loaded() -> bool {
!glTexImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
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,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glTexImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, internalformat, width, height, depth, border, format, type_, pixels);
}
let out = call_atomic_ptr_10arg(
"glTexImage3D",
&glTexImage3D_p,
target,
level,
internalformat,
width,
height,
depth,
border,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexImage3D", err);
err = glGetError();
}
}
out
}
static glTexImage3D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexImage3D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexImage3D\0",
&glTexImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexImage3D_is_loaded() -> bool {
!glTexImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexParameterf(target: GLenum, pname: GLenum, param: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTexParameterf({:#X}, {:#X}, {:?});",
target,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glTexParameterf",
&glTexParameterf_p,
target,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameterf", err);
err = glGetError();
}
}
out
}
static glTexParameterf_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexParameterf_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameterf\0",
&glTexParameterf_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexParameterf_is_loaded() -> bool {
!glTexParameterf_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexParameterfv(
target: GLenum,
pname: GLenum,
params: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTexParameterfv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glTexParameterfv",
&glTexParameterfv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameterfv", err);
err = glGetError();
}
}
out
}
static glTexParameterfv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexParameterfv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameterfv\0",
&glTexParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexParameterfv_is_loaded() -> bool {
!glTexParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexParameteri(target: GLenum, pname: GLenum, param: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTexParameteri({:#X}, {:#X}, {:?});",
target,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glTexParameteri",
&glTexParameteri_p,
target,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameteri", err);
err = glGetError();
}
}
out
}
static glTexParameteri_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexParameteri_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameteri\0",
&glTexParameteri_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexParameteri_is_loaded() -> bool {
!glTexParameteri_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexParameteriv(
target: GLenum,
pname: GLenum,
params: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTexParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glTexParameteriv",
&glTexParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameteriv", err);
err = glGetError();
}
}
out
}
static glTexParameteriv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexParameteriv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameteriv\0",
&glTexParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexParameteriv_is_loaded() -> bool {
!glTexParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexStorage2D(
target: GLenum,
levels: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTexStorage2D({:#X}, {:?}, {:#X}, {:?}, {:?});",
target,
levels,
internalformat,
width,
height
);
}
let out = call_atomic_ptr_5arg(
"glTexStorage2D",
&glTexStorage2D_p,
target,
levels,
internalformat,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexStorage2D", err);
err = glGetError();
}
}
out
}
static glTexStorage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexStorage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexStorage2D\0",
&glTexStorage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexStorage2D_is_loaded() -> bool {
!glTexStorage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexStorage3D(
target: GLenum,
levels: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTexStorage3D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?});",
target,
levels,
internalformat,
width,
height,
depth
);
}
let out = call_atomic_ptr_6arg(
"glTexStorage3D",
&glTexStorage3D_p,
target,
levels,
internalformat,
width,
height,
depth,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexStorage3D", err);
err = glGetError();
}
}
out
}
static glTexStorage3D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexStorage3D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexStorage3D\0",
&glTexStorage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexStorage3D_is_loaded() -> bool {
!glTexStorage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTexSubImage2D(
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glTexSubImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, xoffset, yoffset, width, height, format, type_, pixels);
}
let out = call_atomic_ptr_9arg(
"glTexSubImage2D",
&glTexSubImage2D_p,
target,
level,
xoffset,
yoffset,
width,
height,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexSubImage2D", err);
err = glGetError();
}
}
out
}
static glTexSubImage2D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexSubImage2D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexSubImage2D\0",
&glTexSubImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexSubImage2D_is_loaded() -> bool {
!glTexSubImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
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,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glTexSubImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, pixels);
}
let out = call_atomic_ptr_11arg(
"glTexSubImage3D",
&glTexSubImage3D_p,
target,
level,
xoffset,
yoffset,
zoffset,
width,
height,
depth,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexSubImage3D", err);
err = glGetError();
}
}
out
}
static glTexSubImage3D_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTexSubImage3D_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexSubImage3D\0",
&glTexSubImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTexSubImage3D_is_loaded() -> bool {
!glTexSubImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glTransformFeedbackVaryings(
program: GLuint,
count: GLsizei,
varyings: *const *const GLchar,
bufferMode: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glTransformFeedbackVaryings({:?}, {:?}, {:p}, {:#X});",
program,
count,
varyings,
bufferMode
);
}
let out = call_atomic_ptr_4arg(
"glTransformFeedbackVaryings",
&glTransformFeedbackVaryings_p,
program,
count,
varyings,
bufferMode,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glTransformFeedbackVaryings", err);
err = glGetError();
}
}
out
}
static glTransformFeedbackVaryings_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glTransformFeedbackVaryings_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTransformFeedbackVaryings\0",
&glTransformFeedbackVaryings_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glTransformFeedbackVaryings_is_loaded() -> bool {
!glTransformFeedbackVaryings_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform1f(location: GLint, v0: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform1f({:?}, {:?});", location, v0);
}
let out = call_atomic_ptr_2arg("glUniform1f", &glUniform1f_p, location, v0);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1f", err);
err = glGetError();
}
}
out
}
static glUniform1f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform1f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform1f\0", &glUniform1f_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform1f_is_loaded() -> bool {
!glUniform1f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform1fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform1fv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform1fv",
&glUniform1fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1fv", err);
err = glGetError();
}
}
out
}
static glUniform1fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform1fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1fv\0",
&glUniform1fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform1fv_is_loaded() -> bool {
!glUniform1fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform1i(location: GLint, v0: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform1i({:?}, {:?});", location, v0);
}
let out = call_atomic_ptr_2arg("glUniform1i", &glUniform1i_p, location, v0);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1i", err);
err = glGetError();
}
}
out
}
static glUniform1i_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform1i_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform1i\0", &glUniform1i_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform1i_is_loaded() -> bool {
!glUniform1i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform1iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform1iv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform1iv",
&glUniform1iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1iv", err);
err = glGetError();
}
}
out
}
static glUniform1iv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform1iv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1iv\0",
&glUniform1iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform1iv_is_loaded() -> bool {
!glUniform1iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform1ui(location: GLint, v0: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform1ui({:?}, {:?});", location, v0);
}
let out =
call_atomic_ptr_2arg("glUniform1ui", &glUniform1ui_p, location, v0);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1ui", err);
err = glGetError();
}
}
out
}
static glUniform1ui_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform1ui_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1ui\0",
&glUniform1ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform1ui_is_loaded() -> bool {
!glUniform1ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform1uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform1uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform1uiv",
&glUniform1uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1uiv", err);
err = glGetError();
}
}
out
}
static glUniform1uiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform1uiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1uiv\0",
&glUniform1uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform1uiv_is_loaded() -> bool {
!glUniform1uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform2f(location: GLint, v0: GLfloat, v1: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform2f({:?}, {:?}, {:?});", location, v0, v1);
}
let out =
call_atomic_ptr_3arg("glUniform2f", &glUniform2f_p, location, v0, v1);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2f", err);
err = glGetError();
}
}
out
}
static glUniform2f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform2f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform2f\0", &glUniform2f_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform2f_is_loaded() -> bool {
!glUniform2f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform2fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform2fv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform2fv",
&glUniform2fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2fv", err);
err = glGetError();
}
}
out
}
static glUniform2fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform2fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2fv\0",
&glUniform2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform2fv_is_loaded() -> bool {
!glUniform2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform2i(location: GLint, v0: GLint, v1: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform2i({:?}, {:?}, {:?});", location, v0, v1);
}
let out =
call_atomic_ptr_3arg("glUniform2i", &glUniform2i_p, location, v0, v1);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2i", err);
err = glGetError();
}
}
out
}
static glUniform2i_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform2i_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform2i\0", &glUniform2i_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform2i_is_loaded() -> bool {
!glUniform2i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform2iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform2iv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform2iv",
&glUniform2iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2iv", err);
err = glGetError();
}
}
out
}
static glUniform2iv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform2iv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2iv\0",
&glUniform2iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform2iv_is_loaded() -> bool {
!glUniform2iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform2ui(location: GLint, v0: GLuint, v1: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform2ui({:?}, {:?}, {:?});", location, v0, v1);
}
let out =
call_atomic_ptr_3arg("glUniform2ui", &glUniform2ui_p, location, v0, v1);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2ui", err);
err = glGetError();
}
}
out
}
static glUniform2ui_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform2ui_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2ui\0",
&glUniform2ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform2ui_is_loaded() -> bool {
!glUniform2ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform2uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform2uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform2uiv",
&glUniform2uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2uiv", err);
err = glGetError();
}
}
out
}
static glUniform2uiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform2uiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2uiv\0",
&glUniform2uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform2uiv_is_loaded() -> bool {
!glUniform2uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform3f(
location: GLint,
v0: GLfloat,
v1: GLfloat,
v2: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform3f({:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2
);
}
let out =
call_atomic_ptr_4arg("glUniform3f", &glUniform3f_p, location, v0, v1, v2);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3f", err);
err = glGetError();
}
}
out
}
static glUniform3f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform3f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform3f\0", &glUniform3f_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform3f_is_loaded() -> bool {
!glUniform3f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform3fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform3fv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform3fv",
&glUniform3fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3fv", err);
err = glGetError();
}
}
out
}
static glUniform3fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform3fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3fv\0",
&glUniform3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform3fv_is_loaded() -> bool {
!glUniform3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform3i(location: GLint, v0: GLint, v1: GLint, v2: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform3i({:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2
);
}
let out =
call_atomic_ptr_4arg("glUniform3i", &glUniform3i_p, location, v0, v1, v2);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3i", err);
err = glGetError();
}
}
out
}
static glUniform3i_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform3i_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform3i\0", &glUniform3i_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform3i_is_loaded() -> bool {
!glUniform3i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform3iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform3iv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform3iv",
&glUniform3iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3iv", err);
err = glGetError();
}
}
out
}
static glUniform3iv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform3iv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3iv\0",
&glUniform3iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform3iv_is_loaded() -> bool {
!glUniform3iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform3ui(
location: GLint,
v0: GLuint,
v1: GLuint,
v2: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform3ui({:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2
);
}
let out = call_atomic_ptr_4arg(
"glUniform3ui",
&glUniform3ui_p,
location,
v0,
v1,
v2,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3ui", err);
err = glGetError();
}
}
out
}
static glUniform3ui_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform3ui_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3ui\0",
&glUniform3ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform3ui_is_loaded() -> bool {
!glUniform3ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform3uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform3uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform3uiv",
&glUniform3uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3uiv", err);
err = glGetError();
}
}
out
}
static glUniform3uiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform3uiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3uiv\0",
&glUniform3uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform3uiv_is_loaded() -> bool {
!glUniform3uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform4f(
location: GLint,
v0: GLfloat,
v1: GLfloat,
v2: GLfloat,
v3: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform4f({:?}, {:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2,
v3
);
}
let out = call_atomic_ptr_5arg(
"glUniform4f",
&glUniform4f_p,
location,
v0,
v1,
v2,
v3,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4f", err);
err = glGetError();
}
}
out
}
static glUniform4f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform4f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform4f\0", &glUniform4f_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform4f_is_loaded() -> bool {
!glUniform4f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform4fv(
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform4fv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform4fv",
&glUniform4fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4fv", err);
err = glGetError();
}
}
out
}
static glUniform4fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform4fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4fv\0",
&glUniform4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform4fv_is_loaded() -> bool {
!glUniform4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform4i(
location: GLint,
v0: GLint,
v1: GLint,
v2: GLint,
v3: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform4i({:?}, {:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2,
v3
);
}
let out = call_atomic_ptr_5arg(
"glUniform4i",
&glUniform4i_p,
location,
v0,
v1,
v2,
v3,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4i", err);
err = glGetError();
}
}
out
}
static glUniform4i_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform4i_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glUniform4i\0", &glUniform4i_p)
}
#[inline]
#[doc(hidden)]
pub fn glUniform4i_is_loaded() -> bool {
!glUniform4i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform4iv(
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUniform4iv({:?}, {:?}, {:p});", location, count, value);
}
let out = call_atomic_ptr_3arg(
"glUniform4iv",
&glUniform4iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4iv", err);
err = glGetError();
}
}
out
}
static glUniform4iv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform4iv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4iv\0",
&glUniform4iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform4iv_is_loaded() -> bool {
!glUniform4iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform4ui(
location: GLint,
v0: GLuint,
v1: GLuint,
v2: GLuint,
v3: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform4ui({:?}, {:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2,
v3
);
}
let out = call_atomic_ptr_5arg(
"glUniform4ui",
&glUniform4ui_p,
location,
v0,
v1,
v2,
v3,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4ui", err);
err = glGetError();
}
}
out
}
static glUniform4ui_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform4ui_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4ui\0",
&glUniform4ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform4ui_is_loaded() -> bool {
!glUniform4ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniform4uiv(
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniform4uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform4uiv",
&glUniform4uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4uiv", err);
err = glGetError();
}
}
out
}
static glUniform4uiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniform4uiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4uiv\0",
&glUniform4uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniform4uiv_is_loaded() -> bool {
!glUniform4uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformBlockBinding(
program: GLuint,
uniformBlockIndex: GLuint,
uniformBlockBinding: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformBlockBinding({:?}, {:?}, {:?});",
program,
uniformBlockIndex,
uniformBlockBinding
);
}
let out = call_atomic_ptr_3arg(
"glUniformBlockBinding",
&glUniformBlockBinding_p,
program,
uniformBlockIndex,
uniformBlockBinding,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformBlockBinding", err);
err = glGetError();
}
}
out
}
static glUniformBlockBinding_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformBlockBinding_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformBlockBinding\0",
&glUniformBlockBinding_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformBlockBinding_is_loaded() -> bool {
!glUniformBlockBinding_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix2fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix2fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix2fv",
&glUniformMatrix2fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix2fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix2fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix2fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix2fv\0",
&glUniformMatrix2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix2fv_is_loaded() -> bool {
!glUniformMatrix2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix2x3fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix2x3fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix2x3fv",
&glUniformMatrix2x3fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix2x3fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix2x3fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix2x3fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix2x3fv\0",
&glUniformMatrix2x3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix2x3fv_is_loaded() -> bool {
!glUniformMatrix2x3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix2x4fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix2x4fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix2x4fv",
&glUniformMatrix2x4fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix2x4fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix2x4fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix2x4fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix2x4fv\0",
&glUniformMatrix2x4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix2x4fv_is_loaded() -> bool {
!glUniformMatrix2x4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix3fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix3fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix3fv",
&glUniformMatrix3fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix3fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix3fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix3fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix3fv\0",
&glUniformMatrix3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix3fv_is_loaded() -> bool {
!glUniformMatrix3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix3x2fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix3x2fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix3x2fv",
&glUniformMatrix3x2fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix3x2fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix3x2fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix3x2fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix3x2fv\0",
&glUniformMatrix3x2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix3x2fv_is_loaded() -> bool {
!glUniformMatrix3x2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix3x4fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix3x4fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix3x4fv",
&glUniformMatrix3x4fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix3x4fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix3x4fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix3x4fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix3x4fv\0",
&glUniformMatrix3x4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix3x4fv_is_loaded() -> bool {
!glUniformMatrix3x4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix4fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix4fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix4fv",
&glUniformMatrix4fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix4fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix4fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix4fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix4fv\0",
&glUniformMatrix4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix4fv_is_loaded() -> bool {
!glUniformMatrix4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix4x2fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix4x2fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix4x2fv",
&glUniformMatrix4x2fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix4x2fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix4x2fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix4x2fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix4x2fv\0",
&glUniformMatrix4x2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix4x2fv_is_loaded() -> bool {
!glUniformMatrix4x2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUniformMatrix4x3fv(
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glUniformMatrix4x3fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix4x3fv",
&glUniformMatrix4x3fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix4x3fv", err);
err = glGetError();
}
}
out
}
static glUniformMatrix4x3fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUniformMatrix4x3fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix4x3fv\0",
&glUniformMatrix4x3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUniformMatrix4x3fv_is_loaded() -> bool {
!glUniformMatrix4x3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUnmapBuffer(target: GLenum) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUnmapBuffer({:#X});", target);
}
let out = call_atomic_ptr_1arg("glUnmapBuffer", &glUnmapBuffer_p, target);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUnmapBuffer", err);
err = glGetError();
}
}
out
}
static glUnmapBuffer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUnmapBuffer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUnmapBuffer\0",
&glUnmapBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUnmapBuffer_is_loaded() -> bool {
!glUnmapBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glUseProgram(program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glUseProgram({:?});", program);
}
let out = call_atomic_ptr_1arg("glUseProgram", &glUseProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glUseProgram", err);
err = glGetError();
}
}
out
}
static glUseProgram_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glUseProgram_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUseProgram\0",
&glUseProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glUseProgram_is_loaded() -> bool {
!glUseProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glValidateProgram(program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glValidateProgram({:?});", program);
}
let out =
call_atomic_ptr_1arg("glValidateProgram", &glValidateProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glValidateProgram", err);
err = glGetError();
}
}
out
}
static glValidateProgram_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glValidateProgram_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glValidateProgram\0",
&glValidateProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glValidateProgram_is_loaded() -> bool {
!glValidateProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib1f(index: GLuint, x: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttrib1f({:?}, {:?});", index, x);
}
let out =
call_atomic_ptr_2arg("glVertexAttrib1f", &glVertexAttrib1f_p, index, x);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib1f", err);
err = glGetError();
}
}
out
}
static glVertexAttrib1f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib1f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib1f\0",
&glVertexAttrib1f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib1f_is_loaded() -> bool {
!glVertexAttrib1f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib1fv(index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttrib1fv({:?}, {:p});", index, v);
}
let out =
call_atomic_ptr_2arg("glVertexAttrib1fv", &glVertexAttrib1fv_p, index, v);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib1fv", err);
err = glGetError();
}
}
out
}
static glVertexAttrib1fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib1fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib1fv\0",
&glVertexAttrib1fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib1fv_is_loaded() -> bool {
!glVertexAttrib1fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttrib2f({:?}, {:?}, {:?});", index, x, y);
}
let out = call_atomic_ptr_3arg(
"glVertexAttrib2f",
&glVertexAttrib2f_p,
index,
x,
y,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib2f", err);
err = glGetError();
}
}
out
}
static glVertexAttrib2f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib2f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib2f\0",
&glVertexAttrib2f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib2f_is_loaded() -> bool {
!glVertexAttrib2f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib2fv(index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttrib2fv({:?}, {:p});", index, v);
}
let out =
call_atomic_ptr_2arg("glVertexAttrib2fv", &glVertexAttrib2fv_p, index, v);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib2fv", err);
err = glGetError();
}
}
out
}
static glVertexAttrib2fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib2fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib2fv\0",
&glVertexAttrib2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib2fv_is_loaded() -> bool {
!glVertexAttrib2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib3f(
index: GLuint,
x: GLfloat,
y: GLfloat,
z: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glVertexAttrib3f({:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z
);
}
let out = call_atomic_ptr_4arg(
"glVertexAttrib3f",
&glVertexAttrib3f_p,
index,
x,
y,
z,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib3f", err);
err = glGetError();
}
}
out
}
static glVertexAttrib3f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib3f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib3f\0",
&glVertexAttrib3f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib3f_is_loaded() -> bool {
!glVertexAttrib3f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib3fv(index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttrib3fv({:?}, {:p});", index, v);
}
let out =
call_atomic_ptr_2arg("glVertexAttrib3fv", &glVertexAttrib3fv_p, index, v);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib3fv", err);
err = glGetError();
}
}
out
}
static glVertexAttrib3fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib3fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib3fv\0",
&glVertexAttrib3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib3fv_is_loaded() -> bool {
!glVertexAttrib3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib4f(
index: GLuint,
x: GLfloat,
y: GLfloat,
z: GLfloat,
w: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glVertexAttrib4f({:?}, {:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z,
w
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttrib4f",
&glVertexAttrib4f_p,
index,
x,
y,
z,
w,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib4f", err);
err = glGetError();
}
}
out
}
static glVertexAttrib4f_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib4f_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib4f\0",
&glVertexAttrib4f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib4f_is_loaded() -> bool {
!glVertexAttrib4f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttrib4fv(index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttrib4fv({:?}, {:p});", index, v);
}
let out =
call_atomic_ptr_2arg("glVertexAttrib4fv", &glVertexAttrib4fv_p, index, v);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib4fv", err);
err = glGetError();
}
}
out
}
static glVertexAttrib4fv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttrib4fv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib4fv\0",
&glVertexAttrib4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttrib4fv_is_loaded() -> bool {
!glVertexAttrib4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribDivisor(index: GLuint, divisor: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttribDivisor({:?}, {:?});", index, divisor);
}
let out = call_atomic_ptr_2arg(
"glVertexAttribDivisor",
&glVertexAttribDivisor_p,
index,
divisor,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribDivisor", err);
err = glGetError();
}
}
out
}
static glVertexAttribDivisor_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribDivisor_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribDivisor\0",
&glVertexAttribDivisor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribDivisor_is_loaded() -> bool {
!glVertexAttribDivisor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribI4i(
index: GLuint,
x: GLint,
y: GLint,
z: GLint,
w: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glVertexAttribI4i({:?}, {:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z,
w
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttribI4i",
&glVertexAttribI4i_p,
index,
x,
y,
z,
w,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4i", err);
err = glGetError();
}
}
out
}
static glVertexAttribI4i_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribI4i_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4i\0",
&glVertexAttribI4i_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribI4i_is_loaded() -> bool {
!glVertexAttribI4i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribI4iv(index: GLuint, v: *const GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttribI4iv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttribI4iv",
&glVertexAttribI4iv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4iv", err);
err = glGetError();
}
}
out
}
static glVertexAttribI4iv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribI4iv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4iv\0",
&glVertexAttribI4iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribI4iv_is_loaded() -> bool {
!glVertexAttribI4iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribI4ui(
index: GLuint,
x: GLuint,
y: GLuint,
z: GLuint,
w: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glVertexAttribI4ui({:?}, {:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z,
w
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttribI4ui",
&glVertexAttribI4ui_p,
index,
x,
y,
z,
w,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4ui", err);
err = glGetError();
}
}
out
}
static glVertexAttribI4ui_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribI4ui_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4ui\0",
&glVertexAttribI4ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribI4ui_is_loaded() -> bool {
!glVertexAttribI4ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribI4uiv(index: GLuint, v: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glVertexAttribI4uiv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttribI4uiv",
&glVertexAttribI4uiv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4uiv", err);
err = glGetError();
}
}
out
}
static glVertexAttribI4uiv_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribI4uiv_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4uiv\0",
&glVertexAttribI4uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribI4uiv_is_loaded() -> bool {
!glVertexAttribI4uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribIPointer(
index: GLuint,
size: GLint,
type_: GLenum,
stride: GLsizei,
pointer: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glVertexAttribIPointer({:?}, {:?}, {:#X}, {:?}, {:p});",
index,
size,
type_,
stride,
pointer
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttribIPointer",
&glVertexAttribIPointer_p,
index,
size,
type_,
stride,
pointer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribIPointer", err);
err = glGetError();
}
}
out
}
static glVertexAttribIPointer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribIPointer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribIPointer\0",
&glVertexAttribIPointer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribIPointer_is_loaded() -> bool {
!glVertexAttribIPointer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glVertexAttribPointer(
index: GLuint,
size: GLint,
type_: GLenum,
normalized: GLboolean,
stride: GLsizei,
pointer: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glVertexAttribPointer({:?}, {:?}, {:#X}, {:?}, {:?}, {:p});",
index,
size,
type_,
normalized,
stride,
pointer
);
}
let out = call_atomic_ptr_6arg(
"glVertexAttribPointer",
&glVertexAttribPointer_p,
index,
size,
type_,
normalized,
stride,
pointer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribPointer", err);
err = glGetError();
}
}
out
}
static glVertexAttribPointer_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glVertexAttribPointer_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribPointer\0",
&glVertexAttribPointer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn glVertexAttribPointer_is_loaded() -> bool {
!glVertexAttribPointer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glViewport(
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling glViewport({:?}, {:?}, {:?}, {:?});",
x,
y,
width,
height
);
}
let out =
call_atomic_ptr_4arg("glViewport", &glViewport_p, x, y, width, height);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glViewport", err);
err = glGetError();
}
}
out
}
static glViewport_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glViewport_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glViewport\0", &glViewport_p)
}
#[inline]
#[doc(hidden)]
pub fn glViewport_is_loaded() -> bool {
!glViewport_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn glWaitSync(sync: GLsync, flags: GLbitfield, timeout: GLuint64) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling glWaitSync({:p}, {:?}, {:?});", sync, flags, timeout);
}
let out =
call_atomic_ptr_3arg("glWaitSync", &glWaitSync_p, sync, flags, timeout);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = glGetError();
while err != GL_NO_ERROR {
report_error_code_from("glWaitSync", err);
err = glGetError();
}
}
out
}
static glWaitSync_p: APcv = ap_null();
#[doc(hidden)]
pub unsafe fn glWaitSync_load_with_dyn(
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glWaitSync\0", &glWaitSync_p)
}
#[inline]
#[doc(hidden)]
pub fn glWaitSync_is_loaded() -> bool {
!glWaitSync_p.load(RELAX).is_null()
}
}
#[cfg(feature = "struct_loader")]
pub use struct_commands::*;
#[cfg(feature = "struct_loader")]
pub mod struct_commands {
use super::*;
impl GlFns {
pub unsafe fn load_with<F>(mut get_proc_address: F) -> Self
where
F: FnMut(*const c_char) -> *mut c_void,
{
let out: Self = core::mem::zeroed();
out.load_all_with_dyn(&mut get_proc_address);
out
}
#[doc(hidden)]
#[inline(never)]
pub unsafe fn load_all_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) {
self.ActiveTexture_load_with_dyn(get_proc_address);
self.AttachShader_load_with_dyn(get_proc_address);
self.BeginQuery_load_with_dyn(get_proc_address);
self.BeginTransformFeedback_load_with_dyn(get_proc_address);
self.BindAttribLocation_load_with_dyn(get_proc_address);
self.BindBuffer_load_with_dyn(get_proc_address);
self.BindBufferBase_load_with_dyn(get_proc_address);
self.BindBufferRange_load_with_dyn(get_proc_address);
self.BindFramebuffer_load_with_dyn(get_proc_address);
self.BindRenderbuffer_load_with_dyn(get_proc_address);
self.BindSampler_load_with_dyn(get_proc_address);
self.BindTexture_load_with_dyn(get_proc_address);
self.BindTransformFeedback_load_with_dyn(get_proc_address);
self.BindVertexArray_load_with_dyn(get_proc_address);
self.BlendColor_load_with_dyn(get_proc_address);
self.BlendEquation_load_with_dyn(get_proc_address);
self.BlendEquationSeparate_load_with_dyn(get_proc_address);
self.BlendFunc_load_with_dyn(get_proc_address);
self.BlendFuncSeparate_load_with_dyn(get_proc_address);
self.BlitFramebuffer_load_with_dyn(get_proc_address);
self.BufferData_load_with_dyn(get_proc_address);
self.BufferSubData_load_with_dyn(get_proc_address);
self.CheckFramebufferStatus_load_with_dyn(get_proc_address);
self.Clear_load_with_dyn(get_proc_address);
self.ClearBufferfi_load_with_dyn(get_proc_address);
self.ClearBufferfv_load_with_dyn(get_proc_address);
self.ClearBufferiv_load_with_dyn(get_proc_address);
self.ClearBufferuiv_load_with_dyn(get_proc_address);
self.ClearColor_load_with_dyn(get_proc_address);
self.ClearDepthf_load_with_dyn(get_proc_address);
self.ClearStencil_load_with_dyn(get_proc_address);
self.ClientWaitSync_load_with_dyn(get_proc_address);
self.ColorMask_load_with_dyn(get_proc_address);
self.CompileShader_load_with_dyn(get_proc_address);
self.CompressedTexImage2D_load_with_dyn(get_proc_address);
self.CompressedTexImage3D_load_with_dyn(get_proc_address);
self.CompressedTexSubImage2D_load_with_dyn(get_proc_address);
self.CompressedTexSubImage3D_load_with_dyn(get_proc_address);
self.CopyBufferSubData_load_with_dyn(get_proc_address);
self.CopyTexImage2D_load_with_dyn(get_proc_address);
self.CopyTexSubImage2D_load_with_dyn(get_proc_address);
self.CopyTexSubImage3D_load_with_dyn(get_proc_address);
self.CreateProgram_load_with_dyn(get_proc_address);
self.CreateShader_load_with_dyn(get_proc_address);
self.CullFace_load_with_dyn(get_proc_address);
self.DeleteBuffers_load_with_dyn(get_proc_address);
self.DeleteFramebuffers_load_with_dyn(get_proc_address);
self.DeleteProgram_load_with_dyn(get_proc_address);
self.DeleteQueries_load_with_dyn(get_proc_address);
self.DeleteRenderbuffers_load_with_dyn(get_proc_address);
self.DeleteSamplers_load_with_dyn(get_proc_address);
self.DeleteShader_load_with_dyn(get_proc_address);
self.DeleteSync_load_with_dyn(get_proc_address);
self.DeleteTextures_load_with_dyn(get_proc_address);
self.DeleteTransformFeedbacks_load_with_dyn(get_proc_address);
self.DeleteVertexArrays_load_with_dyn(get_proc_address);
self.DepthFunc_load_with_dyn(get_proc_address);
self.DepthMask_load_with_dyn(get_proc_address);
self.DepthRangef_load_with_dyn(get_proc_address);
self.DetachShader_load_with_dyn(get_proc_address);
self.Disable_load_with_dyn(get_proc_address);
self.DisableVertexAttribArray_load_with_dyn(get_proc_address);
self.DrawArrays_load_with_dyn(get_proc_address);
self.DrawArraysInstanced_load_with_dyn(get_proc_address);
self.DrawBuffers_load_with_dyn(get_proc_address);
self.DrawElements_load_with_dyn(get_proc_address);
self.DrawElementsInstanced_load_with_dyn(get_proc_address);
self.DrawRangeElements_load_with_dyn(get_proc_address);
self.Enable_load_with_dyn(get_proc_address);
self.EnableVertexAttribArray_load_with_dyn(get_proc_address);
self.EndQuery_load_with_dyn(get_proc_address);
self.EndTransformFeedback_load_with_dyn(get_proc_address);
self.FenceSync_load_with_dyn(get_proc_address);
self.Finish_load_with_dyn(get_proc_address);
self.Flush_load_with_dyn(get_proc_address);
self.FlushMappedBufferRange_load_with_dyn(get_proc_address);
self.FramebufferRenderbuffer_load_with_dyn(get_proc_address);
self.FramebufferTexture2D_load_with_dyn(get_proc_address);
self.FramebufferTextureLayer_load_with_dyn(get_proc_address);
self.FrontFace_load_with_dyn(get_proc_address);
self.GenBuffers_load_with_dyn(get_proc_address);
self.GenFramebuffers_load_with_dyn(get_proc_address);
self.GenQueries_load_with_dyn(get_proc_address);
self.GenRenderbuffers_load_with_dyn(get_proc_address);
self.GenSamplers_load_with_dyn(get_proc_address);
self.GenTextures_load_with_dyn(get_proc_address);
self.GenTransformFeedbacks_load_with_dyn(get_proc_address);
self.GenVertexArrays_load_with_dyn(get_proc_address);
self.GenerateMipmap_load_with_dyn(get_proc_address);
self.GetActiveAttrib_load_with_dyn(get_proc_address);
self.GetActiveUniform_load_with_dyn(get_proc_address);
self.GetActiveUniformBlockName_load_with_dyn(get_proc_address);
self.GetActiveUniformBlockiv_load_with_dyn(get_proc_address);
self.GetActiveUniformsiv_load_with_dyn(get_proc_address);
self.GetAttachedShaders_load_with_dyn(get_proc_address);
self.GetAttribLocation_load_with_dyn(get_proc_address);
self.GetBooleanv_load_with_dyn(get_proc_address);
self.GetBufferParameteri64v_load_with_dyn(get_proc_address);
self.GetBufferParameteriv_load_with_dyn(get_proc_address);
self.GetBufferPointerv_load_with_dyn(get_proc_address);
self.GetError_load_with_dyn(get_proc_address);
self.GetFloatv_load_with_dyn(get_proc_address);
self.GetFragDataLocation_load_with_dyn(get_proc_address);
self.GetFramebufferAttachmentParameteriv_load_with_dyn(get_proc_address);
self.GetInteger64i_v_load_with_dyn(get_proc_address);
self.GetInteger64v_load_with_dyn(get_proc_address);
self.GetIntegeri_v_load_with_dyn(get_proc_address);
self.GetIntegerv_load_with_dyn(get_proc_address);
self.GetInternalformativ_load_with_dyn(get_proc_address);
self.GetProgramBinary_load_with_dyn(get_proc_address);
self.GetProgramInfoLog_load_with_dyn(get_proc_address);
self.GetProgramiv_load_with_dyn(get_proc_address);
self.GetQueryObjectuiv_load_with_dyn(get_proc_address);
self.GetQueryiv_load_with_dyn(get_proc_address);
self.GetRenderbufferParameteriv_load_with_dyn(get_proc_address);
self.GetSamplerParameterfv_load_with_dyn(get_proc_address);
self.GetSamplerParameteriv_load_with_dyn(get_proc_address);
self.GetShaderInfoLog_load_with_dyn(get_proc_address);
self.GetShaderPrecisionFormat_load_with_dyn(get_proc_address);
self.GetShaderSource_load_with_dyn(get_proc_address);
self.GetShaderiv_load_with_dyn(get_proc_address);
self.GetString_load_with_dyn(get_proc_address);
self.GetStringi_load_with_dyn(get_proc_address);
self.GetSynciv_load_with_dyn(get_proc_address);
self.GetTexParameterfv_load_with_dyn(get_proc_address);
self.GetTexParameteriv_load_with_dyn(get_proc_address);
self.GetTransformFeedbackVarying_load_with_dyn(get_proc_address);
self.GetUniformBlockIndex_load_with_dyn(get_proc_address);
self.GetUniformIndices_load_with_dyn(get_proc_address);
self.GetUniformLocation_load_with_dyn(get_proc_address);
self.GetUniformfv_load_with_dyn(get_proc_address);
self.GetUniformiv_load_with_dyn(get_proc_address);
self.GetUniformuiv_load_with_dyn(get_proc_address);
self.GetVertexAttribIiv_load_with_dyn(get_proc_address);
self.GetVertexAttribIuiv_load_with_dyn(get_proc_address);
self.GetVertexAttribPointerv_load_with_dyn(get_proc_address);
self.GetVertexAttribfv_load_with_dyn(get_proc_address);
self.GetVertexAttribiv_load_with_dyn(get_proc_address);
self.Hint_load_with_dyn(get_proc_address);
self.InvalidateFramebuffer_load_with_dyn(get_proc_address);
self.InvalidateSubFramebuffer_load_with_dyn(get_proc_address);
self.IsBuffer_load_with_dyn(get_proc_address);
self.IsEnabled_load_with_dyn(get_proc_address);
self.IsFramebuffer_load_with_dyn(get_proc_address);
self.IsProgram_load_with_dyn(get_proc_address);
self.IsQuery_load_with_dyn(get_proc_address);
self.IsRenderbuffer_load_with_dyn(get_proc_address);
self.IsSampler_load_with_dyn(get_proc_address);
self.IsShader_load_with_dyn(get_proc_address);
self.IsSync_load_with_dyn(get_proc_address);
self.IsTexture_load_with_dyn(get_proc_address);
self.IsTransformFeedback_load_with_dyn(get_proc_address);
self.IsVertexArray_load_with_dyn(get_proc_address);
self.LineWidth_load_with_dyn(get_proc_address);
self.LinkProgram_load_with_dyn(get_proc_address);
self.MapBufferRange_load_with_dyn(get_proc_address);
self.PauseTransformFeedback_load_with_dyn(get_proc_address);
self.PixelStorei_load_with_dyn(get_proc_address);
self.PolygonOffset_load_with_dyn(get_proc_address);
self.ProgramBinary_load_with_dyn(get_proc_address);
self.ProgramParameteri_load_with_dyn(get_proc_address);
self.ReadBuffer_load_with_dyn(get_proc_address);
self.ReadPixels_load_with_dyn(get_proc_address);
self.ReleaseShaderCompiler_load_with_dyn(get_proc_address);
self.RenderbufferStorage_load_with_dyn(get_proc_address);
self.RenderbufferStorageMultisample_load_with_dyn(get_proc_address);
self.ResumeTransformFeedback_load_with_dyn(get_proc_address);
self.SampleCoverage_load_with_dyn(get_proc_address);
self.SamplerParameterf_load_with_dyn(get_proc_address);
self.SamplerParameterfv_load_with_dyn(get_proc_address);
self.SamplerParameteri_load_with_dyn(get_proc_address);
self.SamplerParameteriv_load_with_dyn(get_proc_address);
self.Scissor_load_with_dyn(get_proc_address);
self.ShaderBinary_load_with_dyn(get_proc_address);
self.ShaderSource_load_with_dyn(get_proc_address);
self.StencilFunc_load_with_dyn(get_proc_address);
self.StencilFuncSeparate_load_with_dyn(get_proc_address);
self.StencilMask_load_with_dyn(get_proc_address);
self.StencilMaskSeparate_load_with_dyn(get_proc_address);
self.StencilOp_load_with_dyn(get_proc_address);
self.StencilOpSeparate_load_with_dyn(get_proc_address);
self.TexImage2D_load_with_dyn(get_proc_address);
self.TexImage3D_load_with_dyn(get_proc_address);
self.TexParameterf_load_with_dyn(get_proc_address);
self.TexParameterfv_load_with_dyn(get_proc_address);
self.TexParameteri_load_with_dyn(get_proc_address);
self.TexParameteriv_load_with_dyn(get_proc_address);
self.TexStorage2D_load_with_dyn(get_proc_address);
self.TexStorage3D_load_with_dyn(get_proc_address);
self.TexSubImage2D_load_with_dyn(get_proc_address);
self.TexSubImage3D_load_with_dyn(get_proc_address);
self.TransformFeedbackVaryings_load_with_dyn(get_proc_address);
self.Uniform1f_load_with_dyn(get_proc_address);
self.Uniform1fv_load_with_dyn(get_proc_address);
self.Uniform1i_load_with_dyn(get_proc_address);
self.Uniform1iv_load_with_dyn(get_proc_address);
self.Uniform1ui_load_with_dyn(get_proc_address);
self.Uniform1uiv_load_with_dyn(get_proc_address);
self.Uniform2f_load_with_dyn(get_proc_address);
self.Uniform2fv_load_with_dyn(get_proc_address);
self.Uniform2i_load_with_dyn(get_proc_address);
self.Uniform2iv_load_with_dyn(get_proc_address);
self.Uniform2ui_load_with_dyn(get_proc_address);
self.Uniform2uiv_load_with_dyn(get_proc_address);
self.Uniform3f_load_with_dyn(get_proc_address);
self.Uniform3fv_load_with_dyn(get_proc_address);
self.Uniform3i_load_with_dyn(get_proc_address);
self.Uniform3iv_load_with_dyn(get_proc_address);
self.Uniform3ui_load_with_dyn(get_proc_address);
self.Uniform3uiv_load_with_dyn(get_proc_address);
self.Uniform4f_load_with_dyn(get_proc_address);
self.Uniform4fv_load_with_dyn(get_proc_address);
self.Uniform4i_load_with_dyn(get_proc_address);
self.Uniform4iv_load_with_dyn(get_proc_address);
self.Uniform4ui_load_with_dyn(get_proc_address);
self.Uniform4uiv_load_with_dyn(get_proc_address);
self.UniformBlockBinding_load_with_dyn(get_proc_address);
self.UniformMatrix2fv_load_with_dyn(get_proc_address);
self.UniformMatrix2x3fv_load_with_dyn(get_proc_address);
self.UniformMatrix2x4fv_load_with_dyn(get_proc_address);
self.UniformMatrix3fv_load_with_dyn(get_proc_address);
self.UniformMatrix3x2fv_load_with_dyn(get_proc_address);
self.UniformMatrix3x4fv_load_with_dyn(get_proc_address);
self.UniformMatrix4fv_load_with_dyn(get_proc_address);
self.UniformMatrix4x2fv_load_with_dyn(get_proc_address);
self.UniformMatrix4x3fv_load_with_dyn(get_proc_address);
self.UnmapBuffer_load_with_dyn(get_proc_address);
self.UseProgram_load_with_dyn(get_proc_address);
self.ValidateProgram_load_with_dyn(get_proc_address);
self.VertexAttrib1f_load_with_dyn(get_proc_address);
self.VertexAttrib1fv_load_with_dyn(get_proc_address);
self.VertexAttrib2f_load_with_dyn(get_proc_address);
self.VertexAttrib2fv_load_with_dyn(get_proc_address);
self.VertexAttrib3f_load_with_dyn(get_proc_address);
self.VertexAttrib3fv_load_with_dyn(get_proc_address);
self.VertexAttrib4f_load_with_dyn(get_proc_address);
self.VertexAttrib4fv_load_with_dyn(get_proc_address);
self.VertexAttribDivisor_load_with_dyn(get_proc_address);
self.VertexAttribI4i_load_with_dyn(get_proc_address);
self.VertexAttribI4iv_load_with_dyn(get_proc_address);
self.VertexAttribI4ui_load_with_dyn(get_proc_address);
self.VertexAttribI4uiv_load_with_dyn(get_proc_address);
self.VertexAttribIPointer_load_with_dyn(get_proc_address);
self.VertexAttribPointer_load_with_dyn(get_proc_address);
self.Viewport_load_with_dyn(get_proc_address);
self.WaitSync_load_with_dyn(get_proc_address);
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ActiveTexture(&self, texture: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ActiveTexture({:#X});", texture);
}
let out = call_atomic_ptr_1arg(
"glActiveTexture",
&self.glActiveTexture_p,
texture,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glActiveTexture", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ActiveTexture_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glActiveTexture\0",
&self.glActiveTexture_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ActiveTexture_is_loaded(&self) -> bool {
!self.glActiveTexture_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn AttachShader(&self, program: GLuint, shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.AttachShader({:?}, {:?});", program, shader);
}
let out = call_atomic_ptr_2arg(
"glAttachShader",
&self.glAttachShader_p,
program,
shader,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glAttachShader", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn AttachShader_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glAttachShader\0",
&self.glAttachShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn AttachShader_is_loaded(&self) -> bool {
!self.glAttachShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BeginQuery(&self, target: GLenum, id: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BeginQuery({:#X}, {:?});", target, id);
}
let out =
call_atomic_ptr_2arg("glBeginQuery", &self.glBeginQuery_p, target, id);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBeginQuery", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BeginQuery_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBeginQuery\0",
&self.glBeginQuery_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BeginQuery_is_loaded(&self) -> bool {
!self.glBeginQuery_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BeginTransformFeedback(&self, primitiveMode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BeginTransformFeedback({:#X});", primitiveMode);
}
let out = call_atomic_ptr_1arg(
"glBeginTransformFeedback",
&self.glBeginTransformFeedback_p,
primitiveMode,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBeginTransformFeedback", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BeginTransformFeedback_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBeginTransformFeedback\0",
&self.glBeginTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BeginTransformFeedback_is_loaded(&self) -> bool {
!self.glBeginTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindAttribLocation(
&self,
program: GLuint,
index: GLuint,
name: *const GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BindAttribLocation({:?}, {:?}, {:p});",
program,
index,
name
);
}
let out = call_atomic_ptr_3arg(
"glBindAttribLocation",
&self.glBindAttribLocation_p,
program,
index,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindAttribLocation", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindAttribLocation_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindAttribLocation\0",
&self.glBindAttribLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindAttribLocation_is_loaded(&self) -> bool {
!self.glBindAttribLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindBuffer(&self, target: GLenum, buffer: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BindBuffer({:#X}, {:?});", target, buffer);
}
let out = call_atomic_ptr_2arg(
"glBindBuffer",
&self.glBindBuffer_p,
target,
buffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindBuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindBuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindBuffer\0",
&self.glBindBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindBuffer_is_loaded(&self) -> bool {
!self.glBindBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindBufferBase(
&self,
target: GLenum,
index: GLuint,
buffer: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BindBufferBase({:#X}, {:?}, {:?});",
target,
index,
buffer
);
}
let out = call_atomic_ptr_3arg(
"glBindBufferBase",
&self.glBindBufferBase_p,
target,
index,
buffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindBufferBase", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindBufferBase_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindBufferBase\0",
&self.glBindBufferBase_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindBufferBase_is_loaded(&self) -> bool {
!self.glBindBufferBase_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindBufferRange(
&self,
target: GLenum,
index: GLuint,
buffer: GLuint,
offset: GLintptr,
size: GLsizeiptr,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BindBufferRange({:#X}, {:?}, {:?}, {:?}, {:?});",
target,
index,
buffer,
offset,
size
);
}
let out = call_atomic_ptr_5arg(
"glBindBufferRange",
&self.glBindBufferRange_p,
target,
index,
buffer,
offset,
size,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindBufferRange", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindBufferRange_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindBufferRange\0",
&self.glBindBufferRange_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindBufferRange_is_loaded(&self) -> bool {
!self.glBindBufferRange_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindFramebuffer(&self, target: GLenum, framebuffer: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BindFramebuffer({:#X}, {:?});", target, framebuffer);
}
let out = call_atomic_ptr_2arg(
"glBindFramebuffer",
&self.glBindFramebuffer_p,
target,
framebuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindFramebuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindFramebuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindFramebuffer\0",
&self.glBindFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindFramebuffer_is_loaded(&self) -> bool {
!self.glBindFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindRenderbuffer(
&self,
target: GLenum,
renderbuffer: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BindRenderbuffer({:#X}, {:?});",
target,
renderbuffer
);
}
let out = call_atomic_ptr_2arg(
"glBindRenderbuffer",
&self.glBindRenderbuffer_p,
target,
renderbuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindRenderbuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindRenderbuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindRenderbuffer\0",
&self.glBindRenderbuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindRenderbuffer_is_loaded(&self) -> bool {
!self.glBindRenderbuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindSampler(&self, unit: GLuint, sampler: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BindSampler({:?}, {:?});", unit, sampler);
}
let out = call_atomic_ptr_2arg(
"glBindSampler",
&self.glBindSampler_p,
unit,
sampler,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindSampler", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindSampler_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindSampler\0",
&self.glBindSampler_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindSampler_is_loaded(&self) -> bool {
!self.glBindSampler_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindTexture(&self, target: GLenum, texture: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BindTexture({:#X}, {:?});", target, texture);
}
let out = call_atomic_ptr_2arg(
"glBindTexture",
&self.glBindTexture_p,
target,
texture,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindTexture", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindTexture_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindTexture\0",
&self.glBindTexture_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindTexture_is_loaded(&self) -> bool {
!self.glBindTexture_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindTransformFeedback(&self, target: GLenum, id: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BindTransformFeedback({:#X}, {:?});", target, id);
}
let out = call_atomic_ptr_2arg(
"glBindTransformFeedback",
&self.glBindTransformFeedback_p,
target,
id,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindTransformFeedback", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindTransformFeedback_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindTransformFeedback\0",
&self.glBindTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindTransformFeedback_is_loaded(&self) -> bool {
!self.glBindTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BindVertexArray(&self, array: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BindVertexArray({:?});", array);
}
let out = call_atomic_ptr_1arg(
"glBindVertexArray",
&self.glBindVertexArray_p,
array,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBindVertexArray", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BindVertexArray_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBindVertexArray\0",
&self.glBindVertexArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BindVertexArray_is_loaded(&self) -> bool {
!self.glBindVertexArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BlendColor(
&self,
red: GLfloat,
green: GLfloat,
blue: GLfloat,
alpha: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BlendColor({:?}, {:?}, {:?}, {:?});",
red,
green,
blue,
alpha
);
}
let out = call_atomic_ptr_4arg(
"glBlendColor",
&self.glBlendColor_p,
red,
green,
blue,
alpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendColor", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BlendColor_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendColor\0",
&self.glBlendColor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BlendColor_is_loaded(&self) -> bool {
!self.glBlendColor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BlendEquation(&self, mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BlendEquation({:#X});", mode);
}
let out =
call_atomic_ptr_1arg("glBlendEquation", &self.glBlendEquation_p, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendEquation", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BlendEquation_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendEquation\0",
&self.glBlendEquation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BlendEquation_is_loaded(&self) -> bool {
!self.glBlendEquation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BlendEquationSeparate(
&self,
modeRGB: GLenum,
modeAlpha: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BlendEquationSeparate({:#X}, {:#X});",
modeRGB,
modeAlpha
);
}
let out = call_atomic_ptr_2arg(
"glBlendEquationSeparate",
&self.glBlendEquationSeparate_p,
modeRGB,
modeAlpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendEquationSeparate", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BlendEquationSeparate_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendEquationSeparate\0",
&self.glBlendEquationSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BlendEquationSeparate_is_loaded(&self) -> bool {
!self.glBlendEquationSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BlendFunc(&self, sfactor: GLenum, dfactor: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BlendFunc({:#X}, {:#X});", sfactor, dfactor);
}
let out = call_atomic_ptr_2arg(
"glBlendFunc",
&self.glBlendFunc_p,
sfactor,
dfactor,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendFunc", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BlendFunc_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendFunc\0",
&self.glBlendFunc_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BlendFunc_is_loaded(&self) -> bool {
!self.glBlendFunc_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BlendFuncSeparate(
&self,
sfactorRGB: GLenum,
dfactorRGB: GLenum,
sfactorAlpha: GLenum,
dfactorAlpha: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BlendFuncSeparate({:#X}, {:#X}, {:#X}, {:#X});",
sfactorRGB,
dfactorRGB,
sfactorAlpha,
dfactorAlpha
);
}
let out = call_atomic_ptr_4arg(
"glBlendFuncSeparate",
&self.glBlendFuncSeparate_p,
sfactorRGB,
dfactorRGB,
sfactorAlpha,
dfactorAlpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlendFuncSeparate", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BlendFuncSeparate_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlendFuncSeparate\0",
&self.glBlendFuncSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BlendFuncSeparate_is_loaded(&self) -> bool {
!self.glBlendFuncSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BlitFramebuffer(
&self,
srcX0: GLint,
srcY0: GLint,
srcX1: GLint,
srcY1: GLint,
dstX0: GLint,
dstY0: GLint,
dstX1: GLint,
dstY1: GLint,
mask: GLbitfield,
filter: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.BlitFramebuffer({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X});", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
let out = call_atomic_ptr_10arg(
"glBlitFramebuffer",
&self.glBlitFramebuffer_p,
srcX0,
srcY0,
srcX1,
srcY1,
dstX0,
dstY0,
dstX1,
dstY1,
mask,
filter,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBlitFramebuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BlitFramebuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBlitFramebuffer\0",
&self.glBlitFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BlitFramebuffer_is_loaded(&self) -> bool {
!self.glBlitFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BufferData(
&self,
target: GLenum,
size: GLsizeiptr,
data: *const c_void,
usage: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BufferData({:#X}, {:?}, {:p}, {:#X});",
target,
size,
data,
usage
);
}
let out = call_atomic_ptr_4arg(
"glBufferData",
&self.glBufferData_p,
target,
size,
data,
usage,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBufferData", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BufferData_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBufferData\0",
&self.glBufferData_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BufferData_is_loaded(&self) -> bool {
!self.glBufferData_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn BufferSubData(
&self,
target: GLenum,
offset: GLintptr,
size: GLsizeiptr,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.BufferSubData({:#X}, {:?}, {:?}, {:p});",
target,
offset,
size,
data
);
}
let out = call_atomic_ptr_4arg(
"glBufferSubData",
&self.glBufferSubData_p,
target,
offset,
size,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glBufferSubData", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn BufferSubData_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glBufferSubData\0",
&self.glBufferSubData_p,
)
}
#[inline]
#[doc(hidden)]
pub fn BufferSubData_is_loaded(&self) -> bool {
!self.glBufferSubData_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CheckFramebufferStatus(&self, target: GLenum) -> GLenum {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CheckFramebufferStatus({:#X});", target);
}
let out = call_atomic_ptr_1arg(
"glCheckFramebufferStatus",
&self.glCheckFramebufferStatus_p,
target,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCheckFramebufferStatus", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CheckFramebufferStatus_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCheckFramebufferStatus\0",
&self.glCheckFramebufferStatus_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CheckFramebufferStatus_is_loaded(&self) -> bool {
!self.glCheckFramebufferStatus_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Clear(&self, mask: GLbitfield) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Clear({:?});", mask);
}
let out = call_atomic_ptr_1arg("glClear", &self.glClear_p, mask);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClear", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Clear_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glClear\0", &self.glClear_p)
}
#[inline]
#[doc(hidden)]
pub fn Clear_is_loaded(&self) -> bool {
!self.glClear_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearBufferfi(
&self,
buffer: GLenum,
drawbuffer: GLint,
depth: GLfloat,
stencil: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ClearBufferfi({:#X}, {:?}, {:?}, {:?});",
buffer,
drawbuffer,
depth,
stencil
);
}
let out = call_atomic_ptr_4arg(
"glClearBufferfi",
&self.glClearBufferfi_p,
buffer,
drawbuffer,
depth,
stencil,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferfi", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearBufferfi_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferfi\0",
&self.glClearBufferfi_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearBufferfi_is_loaded(&self) -> bool {
!self.glClearBufferfi_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearBufferfv(
&self,
buffer: GLenum,
drawbuffer: GLint,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ClearBufferfv({:#X}, {:?}, {:p});",
buffer,
drawbuffer,
value
);
}
let out = call_atomic_ptr_3arg(
"glClearBufferfv",
&self.glClearBufferfv_p,
buffer,
drawbuffer,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearBufferfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferfv\0",
&self.glClearBufferfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearBufferfv_is_loaded(&self) -> bool {
!self.glClearBufferfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearBufferiv(
&self,
buffer: GLenum,
drawbuffer: GLint,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ClearBufferiv({:#X}, {:?}, {:p});",
buffer,
drawbuffer,
value
);
}
let out = call_atomic_ptr_3arg(
"glClearBufferiv",
&self.glClearBufferiv_p,
buffer,
drawbuffer,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearBufferiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferiv\0",
&self.glClearBufferiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearBufferiv_is_loaded(&self) -> bool {
!self.glClearBufferiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearBufferuiv(
&self,
buffer: GLenum,
drawbuffer: GLint,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ClearBufferuiv({:#X}, {:?}, {:p});",
buffer,
drawbuffer,
value
);
}
let out = call_atomic_ptr_3arg(
"glClearBufferuiv",
&self.glClearBufferuiv_p,
buffer,
drawbuffer,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearBufferuiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearBufferuiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearBufferuiv\0",
&self.glClearBufferuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearBufferuiv_is_loaded(&self) -> bool {
!self.glClearBufferuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearColor(
&self,
red: GLfloat,
green: GLfloat,
blue: GLfloat,
alpha: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ClearColor({:?}, {:?}, {:?}, {:?});",
red,
green,
blue,
alpha
);
}
let out = call_atomic_ptr_4arg(
"glClearColor",
&self.glClearColor_p,
red,
green,
blue,
alpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearColor", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearColor_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearColor\0",
&self.glClearColor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearColor_is_loaded(&self) -> bool {
!self.glClearColor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearDepthf(&self, d: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ClearDepthf({:?});", d);
}
let out = call_atomic_ptr_1arg("glClearDepthf", &self.glClearDepthf_p, d);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearDepthf", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearDepthf_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearDepthf\0",
&self.glClearDepthf_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearDepthf_is_loaded(&self) -> bool {
!self.glClearDepthf_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClearStencil(&self, s: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ClearStencil({:?});", s);
}
let out =
call_atomic_ptr_1arg("glClearStencil", &self.glClearStencil_p, s);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClearStencil", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClearStencil_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClearStencil\0",
&self.glClearStencil_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClearStencil_is_loaded(&self) -> bool {
!self.glClearStencil_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ClientWaitSync(
&self,
sync: GLsync,
flags: GLbitfield,
timeout: GLuint64,
) -> GLenum {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ClientWaitSync({:p}, {:?}, {:?});",
sync,
flags,
timeout
);
}
let out = call_atomic_ptr_3arg(
"glClientWaitSync",
&self.glClientWaitSync_p,
sync,
flags,
timeout,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glClientWaitSync", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ClientWaitSync_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glClientWaitSync\0",
&self.glClientWaitSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ClientWaitSync_is_loaded(&self) -> bool {
!self.glClientWaitSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ColorMask(
&self,
red: GLboolean,
green: GLboolean,
blue: GLboolean,
alpha: GLboolean,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ColorMask({:?}, {:?}, {:?}, {:?});",
red,
green,
blue,
alpha
);
}
let out = call_atomic_ptr_4arg(
"glColorMask",
&self.glColorMask_p,
red,
green,
blue,
alpha,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glColorMask", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ColorMask_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glColorMask\0",
&self.glColorMask_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ColorMask_is_loaded(&self) -> bool {
!self.glColorMask_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CompileShader(&self, shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CompileShader({:?});", shader);
}
let out = call_atomic_ptr_1arg(
"glCompileShader",
&self.glCompileShader_p,
shader,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompileShader", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CompileShader_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompileShader\0",
&self.glCompileShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CompileShader_is_loaded(&self) -> bool {
!self.glCompileShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CompressedTexImage2D(
&self,
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CompressedTexImage2D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?}, {:?}, {:p});", target, level, internalformat, width, height, border, imageSize, data);
}
let out = call_atomic_ptr_8arg(
"glCompressedTexImage2D",
&self.glCompressedTexImage2D_p,
target,
level,
internalformat,
width,
height,
border,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexImage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CompressedTexImage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexImage2D\0",
&self.glCompressedTexImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CompressedTexImage2D_is_loaded(&self) -> bool {
!self.glCompressedTexImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CompressedTexImage3D(
&self,
target: GLenum,
level: GLint,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
border: GLint,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CompressedTexImage3D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:p});", target, level, internalformat, width, height, depth, border, imageSize, data);
}
let out = call_atomic_ptr_9arg(
"glCompressedTexImage3D",
&self.glCompressedTexImage3D_p,
target,
level,
internalformat,
width,
height,
depth,
border,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexImage3D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CompressedTexImage3D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexImage3D\0",
&self.glCompressedTexImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CompressedTexImage3D_is_loaded(&self) -> bool {
!self.glCompressedTexImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CompressedTexSubImage2D(
&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CompressedTexSubImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:?}, {:p});", target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
let out = call_atomic_ptr_9arg(
"glCompressedTexSubImage2D",
&self.glCompressedTexSubImage2D_p,
target,
level,
xoffset,
yoffset,
width,
height,
format,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexSubImage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CompressedTexSubImage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexSubImage2D\0",
&self.glCompressedTexSubImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CompressedTexSubImage2D_is_loaded(&self) -> bool {
!self.glCompressedTexSubImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CompressedTexSubImage3D(
&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
format: GLenum,
imageSize: GLsizei,
data: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CompressedTexSubImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:?}, {:p});", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
let out = call_atomic_ptr_11arg(
"glCompressedTexSubImage3D",
&self.glCompressedTexSubImage3D_p,
target,
level,
xoffset,
yoffset,
zoffset,
width,
height,
depth,
format,
imageSize,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCompressedTexSubImage3D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CompressedTexSubImage3D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCompressedTexSubImage3D\0",
&self.glCompressedTexSubImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CompressedTexSubImage3D_is_loaded(&self) -> bool {
!self.glCompressedTexSubImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CopyBufferSubData(
&self,
readTarget: GLenum,
writeTarget: GLenum,
readOffset: GLintptr,
writeOffset: GLintptr,
size: GLsizeiptr,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.CopyBufferSubData({:#X}, {:#X}, {:?}, {:?}, {:?});",
readTarget,
writeTarget,
readOffset,
writeOffset,
size
);
}
let out = call_atomic_ptr_5arg(
"glCopyBufferSubData",
&self.glCopyBufferSubData_p,
readTarget,
writeTarget,
readOffset,
writeOffset,
size,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyBufferSubData", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CopyBufferSubData_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyBufferSubData\0",
&self.glCopyBufferSubData_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CopyBufferSubData_is_loaded(&self) -> bool {
!self.glCopyBufferSubData_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CopyTexImage2D(
&self,
target: GLenum,
level: GLint,
internalformat: GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
border: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CopyTexImage2D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?}, {:?}, {:?});", target, level, internalformat, x, y, width, height, border);
}
let out = call_atomic_ptr_8arg(
"glCopyTexImage2D",
&self.glCopyTexImage2D_p,
target,
level,
internalformat,
x,
y,
width,
height,
border,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyTexImage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CopyTexImage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyTexImage2D\0",
&self.glCopyTexImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CopyTexImage2D_is_loaded(&self) -> bool {
!self.glCopyTexImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CopyTexSubImage2D(
&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CopyTexSubImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?});", target, level, xoffset, yoffset, x, y, width, height);
}
let out = call_atomic_ptr_8arg(
"glCopyTexSubImage2D",
&self.glCopyTexSubImage2D_p,
target,
level,
xoffset,
yoffset,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyTexSubImage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CopyTexSubImage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyTexSubImage2D\0",
&self.glCopyTexSubImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CopyTexSubImage2D_is_loaded(&self) -> bool {
!self.glCopyTexSubImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CopyTexSubImage3D(
&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CopyTexSubImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?});", target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
let out = call_atomic_ptr_9arg(
"glCopyTexSubImage3D",
&self.glCopyTexSubImage3D_p,
target,
level,
xoffset,
yoffset,
zoffset,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCopyTexSubImage3D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CopyTexSubImage3D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCopyTexSubImage3D\0",
&self.glCopyTexSubImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CopyTexSubImage3D_is_loaded(&self) -> bool {
!self.glCopyTexSubImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CreateProgram(&self) -> GLuint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CreateProgram();",);
}
let out =
call_atomic_ptr_0arg("glCreateProgram", &self.glCreateProgram_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCreateProgram", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CreateProgram_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCreateProgram\0",
&self.glCreateProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CreateProgram_is_loaded(&self) -> bool {
!self.glCreateProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CreateShader(&self, type_: GLenum) -> GLuint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CreateShader({:#X});", type_);
}
let out =
call_atomic_ptr_1arg("glCreateShader", &self.glCreateShader_p, type_);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCreateShader", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CreateShader_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCreateShader\0",
&self.glCreateShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CreateShader_is_loaded(&self) -> bool {
!self.glCreateShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn CullFace(&self, mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.CullFace({:#X});", mode);
}
let out = call_atomic_ptr_1arg("glCullFace", &self.glCullFace_p, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glCullFace", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn CullFace_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glCullFace\0",
&self.glCullFace_p,
)
}
#[inline]
#[doc(hidden)]
pub fn CullFace_is_loaded(&self) -> bool {
!self.glCullFace_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteBuffers(&self, n: GLsizei, buffers: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteBuffers({:?}, {:p});", n, buffers);
}
let out = call_atomic_ptr_2arg(
"glDeleteBuffers",
&self.glDeleteBuffers_p,
n,
buffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteBuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteBuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteBuffers\0",
&self.glDeleteBuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteBuffers_is_loaded(&self) -> bool {
!self.glDeleteBuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteFramebuffers(
&self,
n: GLsizei,
framebuffers: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteFramebuffers({:?}, {:p});", n, framebuffers);
}
let out = call_atomic_ptr_2arg(
"glDeleteFramebuffers",
&self.glDeleteFramebuffers_p,
n,
framebuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteFramebuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteFramebuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteFramebuffers\0",
&self.glDeleteFramebuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteFramebuffers_is_loaded(&self) -> bool {
!self.glDeleteFramebuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteProgram(&self, program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteProgram({:?});", program);
}
let out = call_atomic_ptr_1arg(
"glDeleteProgram",
&self.glDeleteProgram_p,
program,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteProgram", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteProgram_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteProgram\0",
&self.glDeleteProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteProgram_is_loaded(&self) -> bool {
!self.glDeleteProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteQueries(&self, n: GLsizei, ids: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteQueries({:?}, {:p});", n, ids);
}
let out = call_atomic_ptr_2arg(
"glDeleteQueries",
&self.glDeleteQueries_p,
n,
ids,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteQueries", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteQueries_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteQueries\0",
&self.glDeleteQueries_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteQueries_is_loaded(&self) -> bool {
!self.glDeleteQueries_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteRenderbuffers(
&self,
n: GLsizei,
renderbuffers: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteRenderbuffers({:?}, {:p});", n, renderbuffers);
}
let out = call_atomic_ptr_2arg(
"glDeleteRenderbuffers",
&self.glDeleteRenderbuffers_p,
n,
renderbuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteRenderbuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteRenderbuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteRenderbuffers\0",
&self.glDeleteRenderbuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteRenderbuffers_is_loaded(&self) -> bool {
!self.glDeleteRenderbuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteSamplers(
&self,
count: GLsizei,
samplers: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteSamplers({:?}, {:p});", count, samplers);
}
let out = call_atomic_ptr_2arg(
"glDeleteSamplers",
&self.glDeleteSamplers_p,
count,
samplers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteSamplers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteSamplers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteSamplers\0",
&self.glDeleteSamplers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteSamplers_is_loaded(&self) -> bool {
!self.glDeleteSamplers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteShader(&self, shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteShader({:?});", shader);
}
let out =
call_atomic_ptr_1arg("glDeleteShader", &self.glDeleteShader_p, shader);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteShader", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteShader_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteShader\0",
&self.glDeleteShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteShader_is_loaded(&self) -> bool {
!self.glDeleteShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteSync(&self, sync: GLsync) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteSync({:p});", sync);
}
let out =
call_atomic_ptr_1arg("glDeleteSync", &self.glDeleteSync_p, sync);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteSync", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteSync_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteSync\0",
&self.glDeleteSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteSync_is_loaded(&self) -> bool {
!self.glDeleteSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteTextures(&self, n: GLsizei, textures: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteTextures({:?}, {:p});", n, textures);
}
let out = call_atomic_ptr_2arg(
"glDeleteTextures",
&self.glDeleteTextures_p,
n,
textures,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteTextures", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteTextures_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteTextures\0",
&self.glDeleteTextures_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteTextures_is_loaded(&self) -> bool {
!self.glDeleteTextures_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteTransformFeedbacks(
&self,
n: GLsizei,
ids: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteTransformFeedbacks({:?}, {:p});", n, ids);
}
let out = call_atomic_ptr_2arg(
"glDeleteTransformFeedbacks",
&self.glDeleteTransformFeedbacks_p,
n,
ids,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteTransformFeedbacks", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteTransformFeedbacks_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteTransformFeedbacks\0",
&self.glDeleteTransformFeedbacks_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteTransformFeedbacks_is_loaded(&self) -> bool {
!self.glDeleteTransformFeedbacks_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DeleteVertexArrays(&self, n: GLsizei, arrays: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DeleteVertexArrays({:?}, {:p});", n, arrays);
}
let out = call_atomic_ptr_2arg(
"glDeleteVertexArrays",
&self.glDeleteVertexArrays_p,
n,
arrays,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDeleteVertexArrays", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DeleteVertexArrays_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDeleteVertexArrays\0",
&self.glDeleteVertexArrays_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DeleteVertexArrays_is_loaded(&self) -> bool {
!self.glDeleteVertexArrays_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DepthFunc(&self, func: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DepthFunc({:#X});", func);
}
let out = call_atomic_ptr_1arg("glDepthFunc", &self.glDepthFunc_p, func);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDepthFunc", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DepthFunc_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDepthFunc\0",
&self.glDepthFunc_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DepthFunc_is_loaded(&self) -> bool {
!self.glDepthFunc_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DepthMask(&self, flag: GLboolean) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DepthMask({:?});", flag);
}
let out = call_atomic_ptr_1arg("glDepthMask", &self.glDepthMask_p, flag);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDepthMask", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DepthMask_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDepthMask\0",
&self.glDepthMask_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DepthMask_is_loaded(&self) -> bool {
!self.glDepthMask_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DepthRangef(&self, n: GLfloat, f: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DepthRangef({:?}, {:?});", n, f);
}
let out =
call_atomic_ptr_2arg("glDepthRangef", &self.glDepthRangef_p, n, f);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDepthRangef", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DepthRangef_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDepthRangef\0",
&self.glDepthRangef_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DepthRangef_is_loaded(&self) -> bool {
!self.glDepthRangef_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DetachShader(&self, program: GLuint, shader: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DetachShader({:?}, {:?});", program, shader);
}
let out = call_atomic_ptr_2arg(
"glDetachShader",
&self.glDetachShader_p,
program,
shader,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDetachShader", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DetachShader_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDetachShader\0",
&self.glDetachShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DetachShader_is_loaded(&self) -> bool {
!self.glDetachShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Disable(&self, cap: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Disable({:#X});", cap);
}
let out = call_atomic_ptr_1arg("glDisable", &self.glDisable_p, cap);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDisable", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Disable_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDisable\0",
&self.glDisable_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Disable_is_loaded(&self) -> bool {
!self.glDisable_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DisableVertexAttribArray(&self, index: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DisableVertexAttribArray({:?});", index);
}
let out = call_atomic_ptr_1arg(
"glDisableVertexAttribArray",
&self.glDisableVertexAttribArray_p,
index,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDisableVertexAttribArray", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DisableVertexAttribArray_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDisableVertexAttribArray\0",
&self.glDisableVertexAttribArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DisableVertexAttribArray_is_loaded(&self) -> bool {
!self.glDisableVertexAttribArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DrawArrays(
&self,
mode: GLenum,
first: GLint,
count: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DrawArrays({:#X}, {:?}, {:?});", mode, first, count);
}
let out = call_atomic_ptr_3arg(
"glDrawArrays",
&self.glDrawArrays_p,
mode,
first,
count,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawArrays", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DrawArrays_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawArrays\0",
&self.glDrawArrays_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DrawArrays_is_loaded(&self) -> bool {
!self.glDrawArrays_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DrawArraysInstanced(
&self,
mode: GLenum,
first: GLint,
count: GLsizei,
instancecount: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.DrawArraysInstanced({:#X}, {:?}, {:?}, {:?});",
mode,
first,
count,
instancecount
);
}
let out = call_atomic_ptr_4arg(
"glDrawArraysInstanced",
&self.glDrawArraysInstanced_p,
mode,
first,
count,
instancecount,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawArraysInstanced", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DrawArraysInstanced_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawArraysInstanced\0",
&self.glDrawArraysInstanced_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DrawArraysInstanced_is_loaded(&self) -> bool {
!self.glDrawArraysInstanced_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DrawBuffers(&self, n: GLsizei, bufs: *const GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.DrawBuffers({:?}, {:p});", n, bufs);
}
let out =
call_atomic_ptr_2arg("glDrawBuffers", &self.glDrawBuffers_p, n, bufs);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawBuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DrawBuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawBuffers\0",
&self.glDrawBuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DrawBuffers_is_loaded(&self) -> bool {
!self.glDrawBuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DrawElements(
&self,
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.DrawElements({:#X}, {:?}, {:#X}, {:p});",
mode,
count,
type_,
indices
);
}
let out = call_atomic_ptr_4arg(
"glDrawElements",
&self.glDrawElements_p,
mode,
count,
type_,
indices,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawElements", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DrawElements_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawElements\0",
&self.glDrawElements_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DrawElements_is_loaded(&self) -> bool {
!self.glDrawElements_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DrawElementsInstanced(
&self,
mode: GLenum,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
instancecount: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.DrawElementsInstanced({:#X}, {:?}, {:#X}, {:p}, {:?});",
mode,
count,
type_,
indices,
instancecount
);
}
let out = call_atomic_ptr_5arg(
"glDrawElementsInstanced",
&self.glDrawElementsInstanced_p,
mode,
count,
type_,
indices,
instancecount,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawElementsInstanced", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DrawElementsInstanced_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawElementsInstanced\0",
&self.glDrawElementsInstanced_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DrawElementsInstanced_is_loaded(&self) -> bool {
!self.glDrawElementsInstanced_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn DrawRangeElements(
&self,
mode: GLenum,
start: GLuint,
end: GLuint,
count: GLsizei,
type_: GLenum,
indices: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.DrawRangeElements({:#X}, {:?}, {:?}, {:?}, {:#X}, {:p});",
mode,
start,
end,
count,
type_,
indices
);
}
let out = call_atomic_ptr_6arg(
"glDrawRangeElements",
&self.glDrawRangeElements_p,
mode,
start,
end,
count,
type_,
indices,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glDrawRangeElements", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn DrawRangeElements_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glDrawRangeElements\0",
&self.glDrawRangeElements_p,
)
}
#[inline]
#[doc(hidden)]
pub fn DrawRangeElements_is_loaded(&self) -> bool {
!self.glDrawRangeElements_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Enable(&self, cap: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Enable({:#X});", cap);
}
let out = call_atomic_ptr_1arg("glEnable", &self.glEnable_p, cap);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glEnable", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Enable_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glEnable\0",
&self.glEnable_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Enable_is_loaded(&self) -> bool {
!self.glEnable_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn EnableVertexAttribArray(&self, index: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.EnableVertexAttribArray({:?});", index);
}
let out = call_atomic_ptr_1arg(
"glEnableVertexAttribArray",
&self.glEnableVertexAttribArray_p,
index,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glEnableVertexAttribArray", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn EnableVertexAttribArray_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glEnableVertexAttribArray\0",
&self.glEnableVertexAttribArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn EnableVertexAttribArray_is_loaded(&self) -> bool {
!self.glEnableVertexAttribArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn EndQuery(&self, target: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.EndQuery({:#X});", target);
}
let out = call_atomic_ptr_1arg("glEndQuery", &self.glEndQuery_p, target);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glEndQuery", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn EndQuery_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glEndQuery\0",
&self.glEndQuery_p,
)
}
#[inline]
#[doc(hidden)]
pub fn EndQuery_is_loaded(&self) -> bool {
!self.glEndQuery_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn EndTransformFeedback(&self) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.EndTransformFeedback();",);
}
let out = call_atomic_ptr_0arg(
"glEndTransformFeedback",
&self.glEndTransformFeedback_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glEndTransformFeedback", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn EndTransformFeedback_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glEndTransformFeedback\0",
&self.glEndTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn EndTransformFeedback_is_loaded(&self) -> bool {
!self.glEndTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn FenceSync(
&self,
condition: GLenum,
flags: GLbitfield,
) -> GLsync {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.FenceSync({:#X}, {:?});", condition, flags);
}
let out = call_atomic_ptr_2arg(
"glFenceSync",
&self.glFenceSync_p,
condition,
flags,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFenceSync", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn FenceSync_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFenceSync\0",
&self.glFenceSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn FenceSync_is_loaded(&self) -> bool {
!self.glFenceSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Finish(&self) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Finish();",);
}
let out = call_atomic_ptr_0arg("glFinish", &self.glFinish_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFinish", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Finish_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFinish\0",
&self.glFinish_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Finish_is_loaded(&self) -> bool {
!self.glFinish_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Flush(&self) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Flush();",);
}
let out = call_atomic_ptr_0arg("glFlush", &self.glFlush_p);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFlush", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Flush_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glFlush\0", &self.glFlush_p)
}
#[inline]
#[doc(hidden)]
pub fn Flush_is_loaded(&self) -> bool {
!self.glFlush_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn FlushMappedBufferRange(
&self,
target: GLenum,
offset: GLintptr,
length: GLsizeiptr,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.FlushMappedBufferRange({:#X}, {:?}, {:?});",
target,
offset,
length
);
}
let out = call_atomic_ptr_3arg(
"glFlushMappedBufferRange",
&self.glFlushMappedBufferRange_p,
target,
offset,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFlushMappedBufferRange", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn FlushMappedBufferRange_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFlushMappedBufferRange\0",
&self.glFlushMappedBufferRange_p,
)
}
#[inline]
#[doc(hidden)]
pub fn FlushMappedBufferRange_is_loaded(&self) -> bool {
!self.glFlushMappedBufferRange_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn FramebufferRenderbuffer(
&self,
target: GLenum,
attachment: GLenum,
renderbuffertarget: GLenum,
renderbuffer: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.FramebufferRenderbuffer({:#X}, {:#X}, {:#X}, {:?});",
target,
attachment,
renderbuffertarget,
renderbuffer
);
}
let out = call_atomic_ptr_4arg(
"glFramebufferRenderbuffer",
&self.glFramebufferRenderbuffer_p,
target,
attachment,
renderbuffertarget,
renderbuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFramebufferRenderbuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn FramebufferRenderbuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFramebufferRenderbuffer\0",
&self.glFramebufferRenderbuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn FramebufferRenderbuffer_is_loaded(&self) -> bool {
!self.glFramebufferRenderbuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn FramebufferTexture2D(
&self,
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.FramebufferTexture2D({:#X}, {:#X}, {:#X}, {:?}, {:?});",
target,
attachment,
textarget,
texture,
level
);
}
let out = call_atomic_ptr_5arg(
"glFramebufferTexture2D",
&self.glFramebufferTexture2D_p,
target,
attachment,
textarget,
texture,
level,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFramebufferTexture2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn FramebufferTexture2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFramebufferTexture2D\0",
&self.glFramebufferTexture2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn FramebufferTexture2D_is_loaded(&self) -> bool {
!self.glFramebufferTexture2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn FramebufferTextureLayer(
&self,
target: GLenum,
attachment: GLenum,
texture: GLuint,
level: GLint,
layer: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.FramebufferTextureLayer({:#X}, {:#X}, {:?}, {:?}, {:?});",
target,
attachment,
texture,
level,
layer
);
}
let out = call_atomic_ptr_5arg(
"glFramebufferTextureLayer",
&self.glFramebufferTextureLayer_p,
target,
attachment,
texture,
level,
layer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFramebufferTextureLayer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn FramebufferTextureLayer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFramebufferTextureLayer\0",
&self.glFramebufferTextureLayer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn FramebufferTextureLayer_is_loaded(&self) -> bool {
!self.glFramebufferTextureLayer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn FrontFace(&self, mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.FrontFace({:#X});", mode);
}
let out = call_atomic_ptr_1arg("glFrontFace", &self.glFrontFace_p, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glFrontFace", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn FrontFace_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glFrontFace\0",
&self.glFrontFace_p,
)
}
#[inline]
#[doc(hidden)]
pub fn FrontFace_is_loaded(&self) -> bool {
!self.glFrontFace_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenBuffers(&self, n: GLsizei, buffers: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenBuffers({:?}, {:p});", n, buffers);
}
let out =
call_atomic_ptr_2arg("glGenBuffers", &self.glGenBuffers_p, n, buffers);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenBuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenBuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenBuffers\0",
&self.glGenBuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenBuffers_is_loaded(&self) -> bool {
!self.glGenBuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenFramebuffers(
&self,
n: GLsizei,
framebuffers: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenFramebuffers({:?}, {:p});", n, framebuffers);
}
let out = call_atomic_ptr_2arg(
"glGenFramebuffers",
&self.glGenFramebuffers_p,
n,
framebuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenFramebuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenFramebuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenFramebuffers\0",
&self.glGenFramebuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenFramebuffers_is_loaded(&self) -> bool {
!self.glGenFramebuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenQueries(&self, n: GLsizei, ids: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenQueries({:?}, {:p});", n, ids);
}
let out =
call_atomic_ptr_2arg("glGenQueries", &self.glGenQueries_p, n, ids);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenQueries", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenQueries_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenQueries\0",
&self.glGenQueries_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenQueries_is_loaded(&self) -> bool {
!self.glGenQueries_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenRenderbuffers(
&self,
n: GLsizei,
renderbuffers: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenRenderbuffers({:?}, {:p});", n, renderbuffers);
}
let out = call_atomic_ptr_2arg(
"glGenRenderbuffers",
&self.glGenRenderbuffers_p,
n,
renderbuffers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenRenderbuffers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenRenderbuffers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenRenderbuffers\0",
&self.glGenRenderbuffers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenRenderbuffers_is_loaded(&self) -> bool {
!self.glGenRenderbuffers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenSamplers(&self, count: GLsizei, samplers: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenSamplers({:?}, {:p});", count, samplers);
}
let out = call_atomic_ptr_2arg(
"glGenSamplers",
&self.glGenSamplers_p,
count,
samplers,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenSamplers", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenSamplers_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenSamplers\0",
&self.glGenSamplers_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenSamplers_is_loaded(&self) -> bool {
!self.glGenSamplers_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenTextures(&self, n: GLsizei, textures: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenTextures({:?}, {:p});", n, textures);
}
let out = call_atomic_ptr_2arg(
"glGenTextures",
&self.glGenTextures_p,
n,
textures,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenTextures", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenTextures_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenTextures\0",
&self.glGenTextures_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenTextures_is_loaded(&self) -> bool {
!self.glGenTextures_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenTransformFeedbacks(&self, n: GLsizei, ids: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenTransformFeedbacks({:?}, {:p});", n, ids);
}
let out = call_atomic_ptr_2arg(
"glGenTransformFeedbacks",
&self.glGenTransformFeedbacks_p,
n,
ids,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenTransformFeedbacks", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenTransformFeedbacks_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenTransformFeedbacks\0",
&self.glGenTransformFeedbacks_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenTransformFeedbacks_is_loaded(&self) -> bool {
!self.glGenTransformFeedbacks_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenVertexArrays(&self, n: GLsizei, arrays: *mut GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenVertexArrays({:?}, {:p});", n, arrays);
}
let out = call_atomic_ptr_2arg(
"glGenVertexArrays",
&self.glGenVertexArrays_p,
n,
arrays,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenVertexArrays", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenVertexArrays_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenVertexArrays\0",
&self.glGenVertexArrays_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenVertexArrays_is_loaded(&self) -> bool {
!self.glGenVertexArrays_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GenerateMipmap(&self, target: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GenerateMipmap({:#X});", target);
}
let out = call_atomic_ptr_1arg(
"glGenerateMipmap",
&self.glGenerateMipmap_p,
target,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGenerateMipmap", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GenerateMipmap_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGenerateMipmap\0",
&self.glGenerateMipmap_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GenerateMipmap_is_loaded(&self) -> bool {
!self.glGenerateMipmap_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetActiveAttrib(
&self,
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLint,
type_: *mut GLenum,
name: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetActiveAttrib({:?}, {:?}, {:?}, {:p}, {:p}, {:p}, {:p});", program, index, bufSize, length, size, type_, name);
}
let out = call_atomic_ptr_7arg(
"glGetActiveAttrib",
&self.glGetActiveAttrib_p,
program,
index,
bufSize,
length,
size,
type_,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveAttrib", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetActiveAttrib_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveAttrib\0",
&self.glGetActiveAttrib_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetActiveAttrib_is_loaded(&self) -> bool {
!self.glGetActiveAttrib_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetActiveUniform(
&self,
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLint,
type_: *mut GLenum,
name: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetActiveUniform({:?}, {:?}, {:?}, {:p}, {:p}, {:p}, {:p});", program, index, bufSize, length, size, type_, name);
}
let out = call_atomic_ptr_7arg(
"glGetActiveUniform",
&self.glGetActiveUniform_p,
program,
index,
bufSize,
length,
size,
type_,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniform", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetActiveUniform_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniform\0",
&self.glGetActiveUniform_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetActiveUniform_is_loaded(&self) -> bool {
!self.glGetActiveUniform_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetActiveUniformBlockName(
&self,
program: GLuint,
uniformBlockIndex: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
uniformBlockName: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetActiveUniformBlockName({:?}, {:?}, {:?}, {:p}, {:p});",
program,
uniformBlockIndex,
bufSize,
length,
uniformBlockName
);
}
let out = call_atomic_ptr_5arg(
"glGetActiveUniformBlockName",
&self.glGetActiveUniformBlockName_p,
program,
uniformBlockIndex,
bufSize,
length,
uniformBlockName,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniformBlockName", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetActiveUniformBlockName_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniformBlockName\0",
&self.glGetActiveUniformBlockName_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetActiveUniformBlockName_is_loaded(&self) -> bool {
!self.glGetActiveUniformBlockName_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetActiveUniformBlockiv(
&self,
program: GLuint,
uniformBlockIndex: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetActiveUniformBlockiv({:?}, {:?}, {:#X}, {:p});",
program,
uniformBlockIndex,
pname,
params
);
}
let out = call_atomic_ptr_4arg(
"glGetActiveUniformBlockiv",
&self.glGetActiveUniformBlockiv_p,
program,
uniformBlockIndex,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniformBlockiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetActiveUniformBlockiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniformBlockiv\0",
&self.glGetActiveUniformBlockiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetActiveUniformBlockiv_is_loaded(&self) -> bool {
!self.glGetActiveUniformBlockiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetActiveUniformsiv(
&self,
program: GLuint,
uniformCount: GLsizei,
uniformIndices: *const GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetActiveUniformsiv({:?}, {:?}, {:p}, {:#X}, {:p});",
program,
uniformCount,
uniformIndices,
pname,
params
);
}
let out = call_atomic_ptr_5arg(
"glGetActiveUniformsiv",
&self.glGetActiveUniformsiv_p,
program,
uniformCount,
uniformIndices,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetActiveUniformsiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetActiveUniformsiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetActiveUniformsiv\0",
&self.glGetActiveUniformsiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetActiveUniformsiv_is_loaded(&self) -> bool {
!self.glGetActiveUniformsiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetAttachedShaders(
&self,
program: GLuint,
maxCount: GLsizei,
count: *mut GLsizei,
shaders: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetAttachedShaders({:?}, {:?}, {:p}, {:p});",
program,
maxCount,
count,
shaders
);
}
let out = call_atomic_ptr_4arg(
"glGetAttachedShaders",
&self.glGetAttachedShaders_p,
program,
maxCount,
count,
shaders,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetAttachedShaders", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetAttachedShaders_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetAttachedShaders\0",
&self.glGetAttachedShaders_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetAttachedShaders_is_loaded(&self) -> bool {
!self.glGetAttachedShaders_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetAttribLocation(
&self,
program: GLuint,
name: *const GLchar,
) -> GLint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetAttribLocation({:?}, {:p});", program, name);
}
let out = call_atomic_ptr_2arg(
"glGetAttribLocation",
&self.glGetAttribLocation_p,
program,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetAttribLocation", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetAttribLocation_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetAttribLocation\0",
&self.glGetAttribLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetAttribLocation_is_loaded(&self) -> bool {
!self.glGetAttribLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetBooleanv(&self, pname: GLenum, data: *mut GLboolean) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetBooleanv({:#X}, {:p});", pname, data);
}
let out = call_atomic_ptr_2arg(
"glGetBooleanv",
&self.glGetBooleanv_p,
pname,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBooleanv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetBooleanv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBooleanv\0",
&self.glGetBooleanv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetBooleanv_is_loaded(&self) -> bool {
!self.glGetBooleanv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetBufferParameteri64v(
&self,
target: GLenum,
pname: GLenum,
params: *mut GLint64,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetBufferParameteri64v({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetBufferParameteri64v",
&self.glGetBufferParameteri64v_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBufferParameteri64v", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetBufferParameteri64v_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBufferParameteri64v\0",
&self.glGetBufferParameteri64v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetBufferParameteri64v_is_loaded(&self) -> bool {
!self.glGetBufferParameteri64v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetBufferParameteriv(
&self,
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetBufferParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetBufferParameteriv",
&self.glGetBufferParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBufferParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetBufferParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBufferParameteriv\0",
&self.glGetBufferParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetBufferParameteriv_is_loaded(&self) -> bool {
!self.glGetBufferParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetBufferPointerv(
&self,
target: GLenum,
pname: GLenum,
params: *mut *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetBufferPointerv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetBufferPointerv",
&self.glGetBufferPointerv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetBufferPointerv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetBufferPointerv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetBufferPointerv\0",
&self.glGetBufferPointerv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetBufferPointerv_is_loaded(&self) -> bool {
!self.glGetBufferPointerv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetError(&self) -> GLenum {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetError();",);
}
let out = call_atomic_ptr_0arg("glGetError", &self.glGetError_p);
out
}
#[doc(hidden)]
pub unsafe fn GetError_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetError\0",
&self.glGetError_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetError_is_loaded(&self) -> bool {
!self.glGetError_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetFloatv(&self, pname: GLenum, data: *mut GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetFloatv({:#X}, {:p});", pname, data);
}
let out =
call_atomic_ptr_2arg("glGetFloatv", &self.glGetFloatv_p, pname, data);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetFloatv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetFloatv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetFloatv\0",
&self.glGetFloatv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetFloatv_is_loaded(&self) -> bool {
!self.glGetFloatv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetFragDataLocation(
&self,
program: GLuint,
name: *const GLchar,
) -> GLint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetFragDataLocation({:?}, {:p});", program, name);
}
let out = call_atomic_ptr_2arg(
"glGetFragDataLocation",
&self.glGetFragDataLocation_p,
program,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetFragDataLocation", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetFragDataLocation_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetFragDataLocation\0",
&self.glGetFragDataLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetFragDataLocation_is_loaded(&self) -> bool {
!self.glGetFragDataLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetFramebufferAttachmentParameteriv(
&self,
target: GLenum,
attachment: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetFramebufferAttachmentParameteriv({:#X}, {:#X}, {:#X}, {:p});", target, attachment, pname, params);
}
let out = call_atomic_ptr_4arg(
"glGetFramebufferAttachmentParameteriv",
&self.glGetFramebufferAttachmentParameteriv_p,
target,
attachment,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetFramebufferAttachmentParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetFramebufferAttachmentParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetFramebufferAttachmentParameteriv\0",
&self.glGetFramebufferAttachmentParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetFramebufferAttachmentParameteriv_is_loaded(&self) -> bool {
!self.glGetFramebufferAttachmentParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetInteger64i_v(
&self,
target: GLenum,
index: GLuint,
data: *mut GLint64,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetInteger64i_v({:#X}, {:?}, {:p});",
target,
index,
data
);
}
let out = call_atomic_ptr_3arg(
"glGetInteger64i_v",
&self.glGetInteger64i_v_p,
target,
index,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetInteger64i_v", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetInteger64i_v_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetInteger64i_v\0",
&self.glGetInteger64i_v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetInteger64i_v_is_loaded(&self) -> bool {
!self.glGetInteger64i_v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetInteger64v(&self, pname: GLenum, data: *mut GLint64) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetInteger64v({:#X}, {:p});", pname, data);
}
let out = call_atomic_ptr_2arg(
"glGetInteger64v",
&self.glGetInteger64v_p,
pname,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetInteger64v", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetInteger64v_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetInteger64v\0",
&self.glGetInteger64v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetInteger64v_is_loaded(&self) -> bool {
!self.glGetInteger64v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetIntegeri_v(
&self,
target: GLenum,
index: GLuint,
data: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetIntegeri_v({:#X}, {:?}, {:p});",
target,
index,
data
);
}
let out = call_atomic_ptr_3arg(
"glGetIntegeri_v",
&self.glGetIntegeri_v_p,
target,
index,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetIntegeri_v", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetIntegeri_v_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetIntegeri_v\0",
&self.glGetIntegeri_v_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetIntegeri_v_is_loaded(&self) -> bool {
!self.glGetIntegeri_v_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetIntegerv(&self, pname: GLenum, data: *mut GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetIntegerv({:#X}, {:p});", pname, data);
}
let out = call_atomic_ptr_2arg(
"glGetIntegerv",
&self.glGetIntegerv_p,
pname,
data,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetIntegerv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetIntegerv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetIntegerv\0",
&self.glGetIntegerv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetIntegerv_is_loaded(&self) -> bool {
!self.glGetIntegerv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetInternalformativ(
&self,
target: GLenum,
internalformat: GLenum,
pname: GLenum,
count: GLsizei,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetInternalformativ({:#X}, {:#X}, {:#X}, {:?}, {:p});",
target,
internalformat,
pname,
count,
params
);
}
let out = call_atomic_ptr_5arg(
"glGetInternalformativ",
&self.glGetInternalformativ_p,
target,
internalformat,
pname,
count,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetInternalformativ", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetInternalformativ_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetInternalformativ\0",
&self.glGetInternalformativ_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetInternalformativ_is_loaded(&self) -> bool {
!self.glGetInternalformativ_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetProgramBinary(
&self,
program: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
binaryFormat: *mut GLenum,
binary: *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetProgramBinary({:?}, {:?}, {:p}, {:p}, {:p});",
program,
bufSize,
length,
binaryFormat,
binary
);
}
let out = call_atomic_ptr_5arg(
"glGetProgramBinary",
&self.glGetProgramBinary_p,
program,
bufSize,
length,
binaryFormat,
binary,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetProgramBinary", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetProgramBinary_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetProgramBinary\0",
&self.glGetProgramBinary_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetProgramBinary_is_loaded(&self) -> bool {
!self.glGetProgramBinary_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetProgramInfoLog(
&self,
program: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
infoLog: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetProgramInfoLog({:?}, {:?}, {:p}, {:p});",
program,
bufSize,
length,
infoLog
);
}
let out = call_atomic_ptr_4arg(
"glGetProgramInfoLog",
&self.glGetProgramInfoLog_p,
program,
bufSize,
length,
infoLog,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetProgramInfoLog", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetProgramInfoLog_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetProgramInfoLog\0",
&self.glGetProgramInfoLog_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetProgramInfoLog_is_loaded(&self) -> bool {
!self.glGetProgramInfoLog_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetProgramiv(
&self,
program: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetProgramiv({:?}, {:#X}, {:p});",
program,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetProgramiv",
&self.glGetProgramiv_p,
program,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetProgramiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetProgramiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetProgramiv\0",
&self.glGetProgramiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetProgramiv_is_loaded(&self) -> bool {
!self.glGetProgramiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetQueryObjectuiv(
&self,
id: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetQueryObjectuiv({:?}, {:#X}, {:p});",
id,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetQueryObjectuiv",
&self.glGetQueryObjectuiv_p,
id,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetQueryObjectuiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetQueryObjectuiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetQueryObjectuiv\0",
&self.glGetQueryObjectuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetQueryObjectuiv_is_loaded(&self) -> bool {
!self.glGetQueryObjectuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetQueryiv(
&self,
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetQueryiv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetQueryiv",
&self.glGetQueryiv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetQueryiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetQueryiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetQueryiv\0",
&self.glGetQueryiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetQueryiv_is_loaded(&self) -> bool {
!self.glGetQueryiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetRenderbufferParameteriv(
&self,
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetRenderbufferParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetRenderbufferParameteriv",
&self.glGetRenderbufferParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetRenderbufferParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetRenderbufferParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetRenderbufferParameteriv\0",
&self.glGetRenderbufferParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetRenderbufferParameteriv_is_loaded(&self) -> bool {
!self.glGetRenderbufferParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetSamplerParameterfv(
&self,
sampler: GLuint,
pname: GLenum,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetSamplerParameterfv({:?}, {:#X}, {:p});",
sampler,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetSamplerParameterfv",
&self.glGetSamplerParameterfv_p,
sampler,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetSamplerParameterfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetSamplerParameterfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetSamplerParameterfv\0",
&self.glGetSamplerParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetSamplerParameterfv_is_loaded(&self) -> bool {
!self.glGetSamplerParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetSamplerParameteriv(
&self,
sampler: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetSamplerParameteriv({:?}, {:#X}, {:p});",
sampler,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetSamplerParameteriv",
&self.glGetSamplerParameteriv_p,
sampler,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetSamplerParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetSamplerParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetSamplerParameteriv\0",
&self.glGetSamplerParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetSamplerParameteriv_is_loaded(&self) -> bool {
!self.glGetSamplerParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetShaderInfoLog(
&self,
shader: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
infoLog: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetShaderInfoLog({:?}, {:?}, {:p}, {:p});",
shader,
bufSize,
length,
infoLog
);
}
let out = call_atomic_ptr_4arg(
"glGetShaderInfoLog",
&self.glGetShaderInfoLog_p,
shader,
bufSize,
length,
infoLog,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderInfoLog", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetShaderInfoLog_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderInfoLog\0",
&self.glGetShaderInfoLog_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetShaderInfoLog_is_loaded(&self) -> bool {
!self.glGetShaderInfoLog_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetShaderPrecisionFormat(
&self,
shadertype: GLenum,
precisiontype: GLenum,
range: *mut GLint,
precision: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetShaderPrecisionFormat({:#X}, {:#X}, {:p}, {:p});",
shadertype,
precisiontype,
range,
precision
);
}
let out = call_atomic_ptr_4arg(
"glGetShaderPrecisionFormat",
&self.glGetShaderPrecisionFormat_p,
shadertype,
precisiontype,
range,
precision,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderPrecisionFormat", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetShaderPrecisionFormat_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderPrecisionFormat\0",
&self.glGetShaderPrecisionFormat_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetShaderPrecisionFormat_is_loaded(&self) -> bool {
!self.glGetShaderPrecisionFormat_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetShaderSource(
&self,
shader: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
source: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetShaderSource({:?}, {:?}, {:p}, {:p});",
shader,
bufSize,
length,
source
);
}
let out = call_atomic_ptr_4arg(
"glGetShaderSource",
&self.glGetShaderSource_p,
shader,
bufSize,
length,
source,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderSource", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetShaderSource_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderSource\0",
&self.glGetShaderSource_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetShaderSource_is_loaded(&self) -> bool {
!self.glGetShaderSource_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetShaderiv(
&self,
shader: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetShaderiv({:?}, {:#X}, {:p});",
shader,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetShaderiv",
&self.glGetShaderiv_p,
shader,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetShaderiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetShaderiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetShaderiv\0",
&self.glGetShaderiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetShaderiv_is_loaded(&self) -> bool {
!self.glGetShaderiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetString(&self, name: GLenum) -> *const GLubyte {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetString({:#X});", name);
}
let out = call_atomic_ptr_1arg("glGetString", &self.glGetString_p, name);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetString", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetString_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetString\0",
&self.glGetString_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetString_is_loaded(&self) -> bool {
!self.glGetString_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetStringi(
&self,
name: GLenum,
index: GLuint,
) -> *const GLubyte {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetStringi({:#X}, {:?});", name, index);
}
let out =
call_atomic_ptr_2arg("glGetStringi", &self.glGetStringi_p, name, index);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetStringi", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetStringi_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetStringi\0",
&self.glGetStringi_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetStringi_is_loaded(&self) -> bool {
!self.glGetStringi_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetSynciv(
&self,
sync: GLsync,
pname: GLenum,
count: GLsizei,
length: *mut GLsizei,
values: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetSynciv({:p}, {:#X}, {:?}, {:p}, {:p});",
sync,
pname,
count,
length,
values
);
}
let out = call_atomic_ptr_5arg(
"glGetSynciv",
&self.glGetSynciv_p,
sync,
pname,
count,
length,
values,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetSynciv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetSynciv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetSynciv\0",
&self.glGetSynciv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetSynciv_is_loaded(&self) -> bool {
!self.glGetSynciv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetTexParameterfv(
&self,
target: GLenum,
pname: GLenum,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetTexParameterfv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetTexParameterfv",
&self.glGetTexParameterfv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetTexParameterfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetTexParameterfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetTexParameterfv\0",
&self.glGetTexParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetTexParameterfv_is_loaded(&self) -> bool {
!self.glGetTexParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetTexParameteriv(
&self,
target: GLenum,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetTexParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetTexParameteriv",
&self.glGetTexParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetTexParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetTexParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetTexParameteriv\0",
&self.glGetTexParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetTexParameteriv_is_loaded(&self) -> bool {
!self.glGetTexParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetTransformFeedbackVarying(
&self,
program: GLuint,
index: GLuint,
bufSize: GLsizei,
length: *mut GLsizei,
size: *mut GLsizei,
type_: *mut GLenum,
name: *mut GLchar,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetTransformFeedbackVarying({:?}, {:?}, {:?}, {:p}, {:p}, {:p}, {:p});", program, index, bufSize, length, size, type_, name);
}
let out = call_atomic_ptr_7arg(
"glGetTransformFeedbackVarying",
&self.glGetTransformFeedbackVarying_p,
program,
index,
bufSize,
length,
size,
type_,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetTransformFeedbackVarying", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetTransformFeedbackVarying_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetTransformFeedbackVarying\0",
&self.glGetTransformFeedbackVarying_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetTransformFeedbackVarying_is_loaded(&self) -> bool {
!self.glGetTransformFeedbackVarying_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetUniformBlockIndex(
&self,
program: GLuint,
uniformBlockName: *const GLchar,
) -> GLuint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetUniformBlockIndex({:?}, {:p});",
program,
uniformBlockName
);
}
let out = call_atomic_ptr_2arg(
"glGetUniformBlockIndex",
&self.glGetUniformBlockIndex_p,
program,
uniformBlockName,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformBlockIndex", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetUniformBlockIndex_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformBlockIndex\0",
&self.glGetUniformBlockIndex_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetUniformBlockIndex_is_loaded(&self) -> bool {
!self.glGetUniformBlockIndex_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetUniformIndices(
&self,
program: GLuint,
uniformCount: GLsizei,
uniformNames: *const *const GLchar,
uniformIndices: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetUniformIndices({:?}, {:?}, {:p}, {:p});",
program,
uniformCount,
uniformNames,
uniformIndices
);
}
let out = call_atomic_ptr_4arg(
"glGetUniformIndices",
&self.glGetUniformIndices_p,
program,
uniformCount,
uniformNames,
uniformIndices,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformIndices", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetUniformIndices_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformIndices\0",
&self.glGetUniformIndices_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetUniformIndices_is_loaded(&self) -> bool {
!self.glGetUniformIndices_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetUniformLocation(
&self,
program: GLuint,
name: *const GLchar,
) -> GLint {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.GetUniformLocation({:?}, {:p});", program, name);
}
let out = call_atomic_ptr_2arg(
"glGetUniformLocation",
&self.glGetUniformLocation_p,
program,
name,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformLocation", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetUniformLocation_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformLocation\0",
&self.glGetUniformLocation_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetUniformLocation_is_loaded(&self) -> bool {
!self.glGetUniformLocation_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetUniformfv(
&self,
program: GLuint,
location: GLint,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetUniformfv({:?}, {:?}, {:p});",
program,
location,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetUniformfv",
&self.glGetUniformfv_p,
program,
location,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetUniformfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformfv\0",
&self.glGetUniformfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetUniformfv_is_loaded(&self) -> bool {
!self.glGetUniformfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetUniformiv(
&self,
program: GLuint,
location: GLint,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetUniformiv({:?}, {:?}, {:p});",
program,
location,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetUniformiv",
&self.glGetUniformiv_p,
program,
location,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetUniformiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformiv\0",
&self.glGetUniformiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetUniformiv_is_loaded(&self) -> bool {
!self.glGetUniformiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetUniformuiv(
&self,
program: GLuint,
location: GLint,
params: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetUniformuiv({:?}, {:?}, {:p});",
program,
location,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetUniformuiv",
&self.glGetUniformuiv_p,
program,
location,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetUniformuiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetUniformuiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetUniformuiv\0",
&self.glGetUniformuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetUniformuiv_is_loaded(&self) -> bool {
!self.glGetUniformuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetVertexAttribIiv(
&self,
index: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetVertexAttribIiv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribIiv",
&self.glGetVertexAttribIiv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribIiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetVertexAttribIiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribIiv\0",
&self.glGetVertexAttribIiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetVertexAttribIiv_is_loaded(&self) -> bool {
!self.glGetVertexAttribIiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetVertexAttribIuiv(
&self,
index: GLuint,
pname: GLenum,
params: *mut GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetVertexAttribIuiv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribIuiv",
&self.glGetVertexAttribIuiv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribIuiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetVertexAttribIuiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribIuiv\0",
&self.glGetVertexAttribIuiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetVertexAttribIuiv_is_loaded(&self) -> bool {
!self.glGetVertexAttribIuiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetVertexAttribPointerv(
&self,
index: GLuint,
pname: GLenum,
pointer: *mut *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetVertexAttribPointerv({:?}, {:#X}, {:p});",
index,
pname,
pointer
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribPointerv",
&self.glGetVertexAttribPointerv_p,
index,
pname,
pointer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribPointerv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetVertexAttribPointerv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribPointerv\0",
&self.glGetVertexAttribPointerv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetVertexAttribPointerv_is_loaded(&self) -> bool {
!self.glGetVertexAttribPointerv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetVertexAttribfv(
&self,
index: GLuint,
pname: GLenum,
params: *mut GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetVertexAttribfv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribfv",
&self.glGetVertexAttribfv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetVertexAttribfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribfv\0",
&self.glGetVertexAttribfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetVertexAttribfv_is_loaded(&self) -> bool {
!self.glGetVertexAttribfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn GetVertexAttribiv(
&self,
index: GLuint,
pname: GLenum,
params: *mut GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.GetVertexAttribiv({:?}, {:#X}, {:p});",
index,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glGetVertexAttribiv",
&self.glGetVertexAttribiv_p,
index,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glGetVertexAttribiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn GetVertexAttribiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glGetVertexAttribiv\0",
&self.glGetVertexAttribiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn GetVertexAttribiv_is_loaded(&self) -> bool {
!self.glGetVertexAttribiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Hint(&self, target: GLenum, mode: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Hint({:#X}, {:#X});", target, mode);
}
let out = call_atomic_ptr_2arg("glHint", &self.glHint_p, target, mode);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glHint", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Hint_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(get_proc_address, b"glHint\0", &self.glHint_p)
}
#[inline]
#[doc(hidden)]
pub fn Hint_is_loaded(&self) -> bool {
!self.glHint_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn InvalidateFramebuffer(
&self,
target: GLenum,
numAttachments: GLsizei,
attachments: *const GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.InvalidateFramebuffer({:#X}, {:?}, {:p});",
target,
numAttachments,
attachments
);
}
let out = call_atomic_ptr_3arg(
"glInvalidateFramebuffer",
&self.glInvalidateFramebuffer_p,
target,
numAttachments,
attachments,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glInvalidateFramebuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn InvalidateFramebuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glInvalidateFramebuffer\0",
&self.glInvalidateFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn InvalidateFramebuffer_is_loaded(&self) -> bool {
!self.glInvalidateFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn InvalidateSubFramebuffer(
&self,
target: GLenum,
numAttachments: GLsizei,
attachments: *const GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.InvalidateSubFramebuffer({:#X}, {:?}, {:p}, {:?}, {:?}, {:?}, {:?});", target, numAttachments, attachments, x, y, width, height);
}
let out = call_atomic_ptr_7arg(
"glInvalidateSubFramebuffer",
&self.glInvalidateSubFramebuffer_p,
target,
numAttachments,
attachments,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glInvalidateSubFramebuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn InvalidateSubFramebuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glInvalidateSubFramebuffer\0",
&self.glInvalidateSubFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn InvalidateSubFramebuffer_is_loaded(&self) -> bool {
!self.glInvalidateSubFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsBuffer(&self, buffer: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsBuffer({:?});", buffer);
}
let out = call_atomic_ptr_1arg("glIsBuffer", &self.glIsBuffer_p, buffer);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsBuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsBuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsBuffer\0",
&self.glIsBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsBuffer_is_loaded(&self) -> bool {
!self.glIsBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsEnabled(&self, cap: GLenum) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsEnabled({:#X});", cap);
}
let out = call_atomic_ptr_1arg("glIsEnabled", &self.glIsEnabled_p, cap);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsEnabled", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsEnabled_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsEnabled\0",
&self.glIsEnabled_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsEnabled_is_loaded(&self) -> bool {
!self.glIsEnabled_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsFramebuffer(&self, framebuffer: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsFramebuffer({:?});", framebuffer);
}
let out = call_atomic_ptr_1arg(
"glIsFramebuffer",
&self.glIsFramebuffer_p,
framebuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsFramebuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsFramebuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsFramebuffer\0",
&self.glIsFramebuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsFramebuffer_is_loaded(&self) -> bool {
!self.glIsFramebuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsProgram(&self, program: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsProgram({:?});", program);
}
let out =
call_atomic_ptr_1arg("glIsProgram", &self.glIsProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsProgram", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsProgram_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsProgram\0",
&self.glIsProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsProgram_is_loaded(&self) -> bool {
!self.glIsProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsQuery(&self, id: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsQuery({:?});", id);
}
let out = call_atomic_ptr_1arg("glIsQuery", &self.glIsQuery_p, id);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsQuery", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsQuery_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsQuery\0",
&self.glIsQuery_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsQuery_is_loaded(&self) -> bool {
!self.glIsQuery_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsRenderbuffer(&self, renderbuffer: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsRenderbuffer({:?});", renderbuffer);
}
let out = call_atomic_ptr_1arg(
"glIsRenderbuffer",
&self.glIsRenderbuffer_p,
renderbuffer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsRenderbuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsRenderbuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsRenderbuffer\0",
&self.glIsRenderbuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsRenderbuffer_is_loaded(&self) -> bool {
!self.glIsRenderbuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsSampler(&self, sampler: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsSampler({:?});", sampler);
}
let out =
call_atomic_ptr_1arg("glIsSampler", &self.glIsSampler_p, sampler);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsSampler", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsSampler_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsSampler\0",
&self.glIsSampler_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsSampler_is_loaded(&self) -> bool {
!self.glIsSampler_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsShader(&self, shader: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsShader({:?});", shader);
}
let out = call_atomic_ptr_1arg("glIsShader", &self.glIsShader_p, shader);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsShader", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsShader_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsShader\0",
&self.glIsShader_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsShader_is_loaded(&self) -> bool {
!self.glIsShader_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsSync(&self, sync: GLsync) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsSync({:p});", sync);
}
let out = call_atomic_ptr_1arg("glIsSync", &self.glIsSync_p, sync);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsSync", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsSync_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsSync\0",
&self.glIsSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsSync_is_loaded(&self) -> bool {
!self.glIsSync_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsTexture(&self, texture: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsTexture({:?});", texture);
}
let out =
call_atomic_ptr_1arg("glIsTexture", &self.glIsTexture_p, texture);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsTexture", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsTexture_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsTexture\0",
&self.glIsTexture_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsTexture_is_loaded(&self) -> bool {
!self.glIsTexture_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsTransformFeedback(&self, id: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsTransformFeedback({:?});", id);
}
let out = call_atomic_ptr_1arg(
"glIsTransformFeedback",
&self.glIsTransformFeedback_p,
id,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsTransformFeedback", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsTransformFeedback_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsTransformFeedback\0",
&self.glIsTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsTransformFeedback_is_loaded(&self) -> bool {
!self.glIsTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn IsVertexArray(&self, array: GLuint) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.IsVertexArray({:?});", array);
}
let out =
call_atomic_ptr_1arg("glIsVertexArray", &self.glIsVertexArray_p, array);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glIsVertexArray", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn IsVertexArray_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glIsVertexArray\0",
&self.glIsVertexArray_p,
)
}
#[inline]
#[doc(hidden)]
pub fn IsVertexArray_is_loaded(&self) -> bool {
!self.glIsVertexArray_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn LineWidth(&self, width: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.LineWidth({:?});", width);
}
let out = call_atomic_ptr_1arg("glLineWidth", &self.glLineWidth_p, width);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glLineWidth", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn LineWidth_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glLineWidth\0",
&self.glLineWidth_p,
)
}
#[inline]
#[doc(hidden)]
pub fn LineWidth_is_loaded(&self) -> bool {
!self.glLineWidth_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn LinkProgram(&self, program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.LinkProgram({:?});", program);
}
let out =
call_atomic_ptr_1arg("glLinkProgram", &self.glLinkProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glLinkProgram", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn LinkProgram_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glLinkProgram\0",
&self.glLinkProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn LinkProgram_is_loaded(&self) -> bool {
!self.glLinkProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn MapBufferRange(
&self,
target: GLenum,
offset: GLintptr,
length: GLsizeiptr,
access: GLbitfield,
) -> *mut c_void {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.MapBufferRange({:#X}, {:?}, {:?}, {:?});",
target,
offset,
length,
access
);
}
let out = call_atomic_ptr_4arg(
"glMapBufferRange",
&self.glMapBufferRange_p,
target,
offset,
length,
access,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glMapBufferRange", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn MapBufferRange_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glMapBufferRange\0",
&self.glMapBufferRange_p,
)
}
#[inline]
#[doc(hidden)]
pub fn MapBufferRange_is_loaded(&self) -> bool {
!self.glMapBufferRange_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn PauseTransformFeedback(&self) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.PauseTransformFeedback();",);
}
let out = call_atomic_ptr_0arg(
"glPauseTransformFeedback",
&self.glPauseTransformFeedback_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glPauseTransformFeedback", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn PauseTransformFeedback_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glPauseTransformFeedback\0",
&self.glPauseTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn PauseTransformFeedback_is_loaded(&self) -> bool {
!self.glPauseTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn PixelStorei(&self, pname: GLenum, param: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.PixelStorei({:#X}, {:?});", pname, param);
}
let out = call_atomic_ptr_2arg(
"glPixelStorei",
&self.glPixelStorei_p,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glPixelStorei", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn PixelStorei_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glPixelStorei\0",
&self.glPixelStorei_p,
)
}
#[inline]
#[doc(hidden)]
pub fn PixelStorei_is_loaded(&self) -> bool {
!self.glPixelStorei_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn PolygonOffset(&self, factor: GLfloat, units: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.PolygonOffset({:?}, {:?});", factor, units);
}
let out = call_atomic_ptr_2arg(
"glPolygonOffset",
&self.glPolygonOffset_p,
factor,
units,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glPolygonOffset", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn PolygonOffset_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glPolygonOffset\0",
&self.glPolygonOffset_p,
)
}
#[inline]
#[doc(hidden)]
pub fn PolygonOffset_is_loaded(&self) -> bool {
!self.glPolygonOffset_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ProgramBinary(
&self,
program: GLuint,
binaryFormat: GLenum,
binary: *const c_void,
length: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ProgramBinary({:?}, {:#X}, {:p}, {:?});",
program,
binaryFormat,
binary,
length
);
}
let out = call_atomic_ptr_4arg(
"glProgramBinary",
&self.glProgramBinary_p,
program,
binaryFormat,
binary,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glProgramBinary", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ProgramBinary_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glProgramBinary\0",
&self.glProgramBinary_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ProgramBinary_is_loaded(&self) -> bool {
!self.glProgramBinary_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ProgramParameteri(
&self,
program: GLuint,
pname: GLenum,
value: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ProgramParameteri({:?}, {:#X}, {:?});",
program,
pname,
value
);
}
let out = call_atomic_ptr_3arg(
"glProgramParameteri",
&self.glProgramParameteri_p,
program,
pname,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glProgramParameteri", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ProgramParameteri_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glProgramParameteri\0",
&self.glProgramParameteri_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ProgramParameteri_is_loaded(&self) -> bool {
!self.glProgramParameteri_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ReadBuffer(&self, src: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ReadBuffer({:#X});", src);
}
let out = call_atomic_ptr_1arg("glReadBuffer", &self.glReadBuffer_p, src);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glReadBuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ReadBuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glReadBuffer\0",
&self.glReadBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ReadBuffer_is_loaded(&self) -> bool {
!self.glReadBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ReadPixels(
&self,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *mut c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ReadPixels({:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});",
x,
y,
width,
height,
format,
type_,
pixels
);
}
let out = call_atomic_ptr_7arg(
"glReadPixels",
&self.glReadPixels_p,
x,
y,
width,
height,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glReadPixels", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ReadPixels_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glReadPixels\0",
&self.glReadPixels_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ReadPixels_is_loaded(&self) -> bool {
!self.glReadPixels_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ReleaseShaderCompiler(&self) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ReleaseShaderCompiler();",);
}
let out = call_atomic_ptr_0arg(
"glReleaseShaderCompiler",
&self.glReleaseShaderCompiler_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glReleaseShaderCompiler", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ReleaseShaderCompiler_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glReleaseShaderCompiler\0",
&self.glReleaseShaderCompiler_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ReleaseShaderCompiler_is_loaded(&self) -> bool {
!self.glReleaseShaderCompiler_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn RenderbufferStorage(
&self,
target: GLenum,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.RenderbufferStorage({:#X}, {:#X}, {:?}, {:?});",
target,
internalformat,
width,
height
);
}
let out = call_atomic_ptr_4arg(
"glRenderbufferStorage",
&self.glRenderbufferStorage_p,
target,
internalformat,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glRenderbufferStorage", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn RenderbufferStorage_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glRenderbufferStorage\0",
&self.glRenderbufferStorage_p,
)
}
#[inline]
#[doc(hidden)]
pub fn RenderbufferStorage_is_loaded(&self) -> bool {
!self.glRenderbufferStorage_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn RenderbufferStorageMultisample(
&self,
target: GLenum,
samples: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.RenderbufferStorageMultisample({:#X}, {:?}, {:#X}, {:?}, {:?});", target, samples, internalformat, width, height);
}
let out = call_atomic_ptr_5arg(
"glRenderbufferStorageMultisample",
&self.glRenderbufferStorageMultisample_p,
target,
samples,
internalformat,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glRenderbufferStorageMultisample", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn RenderbufferStorageMultisample_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glRenderbufferStorageMultisample\0",
&self.glRenderbufferStorageMultisample_p,
)
}
#[inline]
#[doc(hidden)]
pub fn RenderbufferStorageMultisample_is_loaded(&self) -> bool {
!self.glRenderbufferStorageMultisample_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ResumeTransformFeedback(&self) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ResumeTransformFeedback();",);
}
let out = call_atomic_ptr_0arg(
"glResumeTransformFeedback",
&self.glResumeTransformFeedback_p,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glResumeTransformFeedback", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ResumeTransformFeedback_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glResumeTransformFeedback\0",
&self.glResumeTransformFeedback_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ResumeTransformFeedback_is_loaded(&self) -> bool {
!self.glResumeTransformFeedback_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn SampleCoverage(&self, value: GLfloat, invert: GLboolean) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.SampleCoverage({:?}, {:?});", value, invert);
}
let out = call_atomic_ptr_2arg(
"glSampleCoverage",
&self.glSampleCoverage_p,
value,
invert,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glSampleCoverage", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn SampleCoverage_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSampleCoverage\0",
&self.glSampleCoverage_p,
)
}
#[inline]
#[doc(hidden)]
pub fn SampleCoverage_is_loaded(&self) -> bool {
!self.glSampleCoverage_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn SamplerParameterf(
&self,
sampler: GLuint,
pname: GLenum,
param: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.SamplerParameterf({:?}, {:#X}, {:?});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameterf",
&self.glSamplerParameterf_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameterf", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn SamplerParameterf_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameterf\0",
&self.glSamplerParameterf_p,
)
}
#[inline]
#[doc(hidden)]
pub fn SamplerParameterf_is_loaded(&self) -> bool {
!self.glSamplerParameterf_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn SamplerParameterfv(
&self,
sampler: GLuint,
pname: GLenum,
param: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.SamplerParameterfv({:?}, {:#X}, {:p});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameterfv",
&self.glSamplerParameterfv_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameterfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn SamplerParameterfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameterfv\0",
&self.glSamplerParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn SamplerParameterfv_is_loaded(&self) -> bool {
!self.glSamplerParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn SamplerParameteri(
&self,
sampler: GLuint,
pname: GLenum,
param: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.SamplerParameteri({:?}, {:#X}, {:?});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameteri",
&self.glSamplerParameteri_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameteri", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn SamplerParameteri_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameteri\0",
&self.glSamplerParameteri_p,
)
}
#[inline]
#[doc(hidden)]
pub fn SamplerParameteri_is_loaded(&self) -> bool {
!self.glSamplerParameteri_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn SamplerParameteriv(
&self,
sampler: GLuint,
pname: GLenum,
param: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.SamplerParameteriv({:?}, {:#X}, {:p});",
sampler,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glSamplerParameteriv",
&self.glSamplerParameteriv_p,
sampler,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glSamplerParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn SamplerParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glSamplerParameteriv\0",
&self.glSamplerParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn SamplerParameteriv_is_loaded(&self) -> bool {
!self.glSamplerParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Scissor(
&self,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Scissor({:?}, {:?}, {:?}, {:?});",
x,
y,
width,
height
);
}
let out = call_atomic_ptr_4arg(
"glScissor",
&self.glScissor_p,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glScissor", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Scissor_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glScissor\0",
&self.glScissor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Scissor_is_loaded(&self) -> bool {
!self.glScissor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ShaderBinary(
&self,
count: GLsizei,
shaders: *const GLuint,
binaryformat: GLenum,
binary: *const c_void,
length: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ShaderBinary({:?}, {:p}, {:#X}, {:p}, {:?});",
count,
shaders,
binaryformat,
binary,
length
);
}
let out = call_atomic_ptr_5arg(
"glShaderBinary",
&self.glShaderBinary_p,
count,
shaders,
binaryformat,
binary,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glShaderBinary", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ShaderBinary_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glShaderBinary\0",
&self.glShaderBinary_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ShaderBinary_is_loaded(&self) -> bool {
!self.glShaderBinary_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ShaderSource(
&self,
shader: GLuint,
count: GLsizei,
string: *const *const GLchar,
length: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.ShaderSource({:?}, {:?}, {:p}, {:p});",
shader,
count,
string,
length
);
}
let out = call_atomic_ptr_4arg(
"glShaderSource",
&self.glShaderSource_p,
shader,
count,
string,
length,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glShaderSource", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ShaderSource_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glShaderSource\0",
&self.glShaderSource_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ShaderSource_is_loaded(&self) -> bool {
!self.glShaderSource_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn StencilFunc(&self, func: GLenum, ref_: GLint, mask: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.StencilFunc({:#X}, {:?}, {:?});", func, ref_, mask);
}
let out = call_atomic_ptr_3arg(
"glStencilFunc",
&self.glStencilFunc_p,
func,
ref_,
mask,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilFunc", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn StencilFunc_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilFunc\0",
&self.glStencilFunc_p,
)
}
#[inline]
#[doc(hidden)]
pub fn StencilFunc_is_loaded(&self) -> bool {
!self.glStencilFunc_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn StencilFuncSeparate(
&self,
face: GLenum,
func: GLenum,
ref_: GLint,
mask: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.StencilFuncSeparate({:#X}, {:#X}, {:?}, {:?});",
face,
func,
ref_,
mask
);
}
let out = call_atomic_ptr_4arg(
"glStencilFuncSeparate",
&self.glStencilFuncSeparate_p,
face,
func,
ref_,
mask,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilFuncSeparate", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn StencilFuncSeparate_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilFuncSeparate\0",
&self.glStencilFuncSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn StencilFuncSeparate_is_loaded(&self) -> bool {
!self.glStencilFuncSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn StencilMask(&self, mask: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.StencilMask({:?});", mask);
}
let out =
call_atomic_ptr_1arg("glStencilMask", &self.glStencilMask_p, mask);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilMask", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn StencilMask_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilMask\0",
&self.glStencilMask_p,
)
}
#[inline]
#[doc(hidden)]
pub fn StencilMask_is_loaded(&self) -> bool {
!self.glStencilMask_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn StencilMaskSeparate(&self, face: GLenum, mask: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.StencilMaskSeparate({:#X}, {:?});", face, mask);
}
let out = call_atomic_ptr_2arg(
"glStencilMaskSeparate",
&self.glStencilMaskSeparate_p,
face,
mask,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilMaskSeparate", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn StencilMaskSeparate_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilMaskSeparate\0",
&self.glStencilMaskSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn StencilMaskSeparate_is_loaded(&self) -> bool {
!self.glStencilMaskSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn StencilOp(&self, fail: GLenum, zfail: GLenum, zpass: GLenum) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.StencilOp({:#X}, {:#X}, {:#X});",
fail,
zfail,
zpass
);
}
let out = call_atomic_ptr_3arg(
"glStencilOp",
&self.glStencilOp_p,
fail,
zfail,
zpass,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilOp", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn StencilOp_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilOp\0",
&self.glStencilOp_p,
)
}
#[inline]
#[doc(hidden)]
pub fn StencilOp_is_loaded(&self) -> bool {
!self.glStencilOp_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn StencilOpSeparate(
&self,
face: GLenum,
sfail: GLenum,
dpfail: GLenum,
dppass: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.StencilOpSeparate({:#X}, {:#X}, {:#X}, {:#X});",
face,
sfail,
dpfail,
dppass
);
}
let out = call_atomic_ptr_4arg(
"glStencilOpSeparate",
&self.glStencilOpSeparate_p,
face,
sfail,
dpfail,
dppass,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glStencilOpSeparate", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn StencilOpSeparate_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glStencilOpSeparate\0",
&self.glStencilOpSeparate_p,
)
}
#[inline]
#[doc(hidden)]
pub fn StencilOpSeparate_is_loaded(&self) -> bool {
!self.glStencilOpSeparate_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexImage2D(
&self,
target: GLenum,
level: GLint,
internalformat: GLint,
width: GLsizei,
height: GLsizei,
border: GLint,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.TexImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, internalformat, width, height, border, format, type_, pixels);
}
let out = call_atomic_ptr_9arg(
"glTexImage2D",
&self.glTexImage2D_p,
target,
level,
internalformat,
width,
height,
border,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexImage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexImage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexImage2D\0",
&self.glTexImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexImage2D_is_loaded(&self) -> bool {
!self.glTexImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexImage3D(
&self,
target: GLenum,
level: GLint,
internalformat: GLint,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
border: GLint,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.TexImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, internalformat, width, height, depth, border, format, type_, pixels);
}
let out = call_atomic_ptr_10arg(
"glTexImage3D",
&self.glTexImage3D_p,
target,
level,
internalformat,
width,
height,
depth,
border,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexImage3D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexImage3D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexImage3D\0",
&self.glTexImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexImage3D_is_loaded(&self) -> bool {
!self.glTexImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexParameterf(
&self,
target: GLenum,
pname: GLenum,
param: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TexParameterf({:#X}, {:#X}, {:?});",
target,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glTexParameterf",
&self.glTexParameterf_p,
target,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameterf", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexParameterf_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameterf\0",
&self.glTexParameterf_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexParameterf_is_loaded(&self) -> bool {
!self.glTexParameterf_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexParameterfv(
&self,
target: GLenum,
pname: GLenum,
params: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TexParameterfv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glTexParameterfv",
&self.glTexParameterfv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameterfv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexParameterfv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameterfv\0",
&self.glTexParameterfv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexParameterfv_is_loaded(&self) -> bool {
!self.glTexParameterfv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexParameteri(
&self,
target: GLenum,
pname: GLenum,
param: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TexParameteri({:#X}, {:#X}, {:?});",
target,
pname,
param
);
}
let out = call_atomic_ptr_3arg(
"glTexParameteri",
&self.glTexParameteri_p,
target,
pname,
param,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameteri", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexParameteri_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameteri\0",
&self.glTexParameteri_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexParameteri_is_loaded(&self) -> bool {
!self.glTexParameteri_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexParameteriv(
&self,
target: GLenum,
pname: GLenum,
params: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TexParameteriv({:#X}, {:#X}, {:p});",
target,
pname,
params
);
}
let out = call_atomic_ptr_3arg(
"glTexParameteriv",
&self.glTexParameteriv_p,
target,
pname,
params,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexParameteriv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexParameteriv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexParameteriv\0",
&self.glTexParameteriv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexParameteriv_is_loaded(&self) -> bool {
!self.glTexParameteriv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexStorage2D(
&self,
target: GLenum,
levels: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TexStorage2D({:#X}, {:?}, {:#X}, {:?}, {:?});",
target,
levels,
internalformat,
width,
height
);
}
let out = call_atomic_ptr_5arg(
"glTexStorage2D",
&self.glTexStorage2D_p,
target,
levels,
internalformat,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexStorage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexStorage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexStorage2D\0",
&self.glTexStorage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexStorage2D_is_loaded(&self) -> bool {
!self.glTexStorage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexStorage3D(
&self,
target: GLenum,
levels: GLsizei,
internalformat: GLenum,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TexStorage3D({:#X}, {:?}, {:#X}, {:?}, {:?}, {:?});",
target,
levels,
internalformat,
width,
height,
depth
);
}
let out = call_atomic_ptr_6arg(
"glTexStorage3D",
&self.glTexStorage3D_p,
target,
levels,
internalformat,
width,
height,
depth,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexStorage3D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexStorage3D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexStorage3D\0",
&self.glTexStorage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexStorage3D_is_loaded(&self) -> bool {
!self.glTexStorage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexSubImage2D(
&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.TexSubImage2D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, xoffset, yoffset, width, height, format, type_, pixels);
}
let out = call_atomic_ptr_9arg(
"glTexSubImage2D",
&self.glTexSubImage2D_p,
target,
level,
xoffset,
yoffset,
width,
height,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexSubImage2D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexSubImage2D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexSubImage2D\0",
&self.glTexSubImage2D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexSubImage2D_is_loaded(&self) -> bool {
!self.glTexSubImage2D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TexSubImage3D(
&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
width: GLsizei,
height: GLsizei,
depth: GLsizei,
format: GLenum,
type_: GLenum,
pixels: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.TexSubImage3D({:#X}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:#X}, {:#X}, {:p});", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, pixels);
}
let out = call_atomic_ptr_11arg(
"glTexSubImage3D",
&self.glTexSubImage3D_p,
target,
level,
xoffset,
yoffset,
zoffset,
width,
height,
depth,
format,
type_,
pixels,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTexSubImage3D", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TexSubImage3D_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTexSubImage3D\0",
&self.glTexSubImage3D_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TexSubImage3D_is_loaded(&self) -> bool {
!self.glTexSubImage3D_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn TransformFeedbackVaryings(
&self,
program: GLuint,
count: GLsizei,
varyings: *const *const GLchar,
bufferMode: GLenum,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.TransformFeedbackVaryings({:?}, {:?}, {:p}, {:#X});",
program,
count,
varyings,
bufferMode
);
}
let out = call_atomic_ptr_4arg(
"glTransformFeedbackVaryings",
&self.glTransformFeedbackVaryings_p,
program,
count,
varyings,
bufferMode,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glTransformFeedbackVaryings", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn TransformFeedbackVaryings_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glTransformFeedbackVaryings\0",
&self.glTransformFeedbackVaryings_p,
)
}
#[inline]
#[doc(hidden)]
pub fn TransformFeedbackVaryings_is_loaded(&self) -> bool {
!self.glTransformFeedbackVaryings_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform1f(&self, location: GLint, v0: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Uniform1f({:?}, {:?});", location, v0);
}
let out =
call_atomic_ptr_2arg("glUniform1f", &self.glUniform1f_p, location, v0);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform1f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1f\0",
&self.glUniform1f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform1f_is_loaded(&self) -> bool {
!self.glUniform1f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform1fv(
&self,
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform1fv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform1fv",
&self.glUniform1fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform1fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1fv\0",
&self.glUniform1fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform1fv_is_loaded(&self) -> bool {
!self.glUniform1fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform1i(&self, location: GLint, v0: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Uniform1i({:?}, {:?});", location, v0);
}
let out =
call_atomic_ptr_2arg("glUniform1i", &self.glUniform1i_p, location, v0);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1i", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform1i_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1i\0",
&self.glUniform1i_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform1i_is_loaded(&self) -> bool {
!self.glUniform1i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform1iv(
&self,
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform1iv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform1iv",
&self.glUniform1iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1iv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform1iv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1iv\0",
&self.glUniform1iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform1iv_is_loaded(&self) -> bool {
!self.glUniform1iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform1ui(&self, location: GLint, v0: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Uniform1ui({:?}, {:?});", location, v0);
}
let out = call_atomic_ptr_2arg(
"glUniform1ui",
&self.glUniform1ui_p,
location,
v0,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1ui", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform1ui_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1ui\0",
&self.glUniform1ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform1ui_is_loaded(&self) -> bool {
!self.glUniform1ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform1uiv(
&self,
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform1uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform1uiv",
&self.glUniform1uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform1uiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform1uiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform1uiv\0",
&self.glUniform1uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform1uiv_is_loaded(&self) -> bool {
!self.glUniform1uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform2f(&self, location: GLint, v0: GLfloat, v1: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Uniform2f({:?}, {:?}, {:?});", location, v0, v1);
}
let out = call_atomic_ptr_3arg(
"glUniform2f",
&self.glUniform2f_p,
location,
v0,
v1,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform2f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2f\0",
&self.glUniform2f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform2f_is_loaded(&self) -> bool {
!self.glUniform2f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform2fv(
&self,
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform2fv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform2fv",
&self.glUniform2fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform2fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2fv\0",
&self.glUniform2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform2fv_is_loaded(&self) -> bool {
!self.glUniform2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform2i(&self, location: GLint, v0: GLint, v1: GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Uniform2i({:?}, {:?}, {:?});", location, v0, v1);
}
let out = call_atomic_ptr_3arg(
"glUniform2i",
&self.glUniform2i_p,
location,
v0,
v1,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2i", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform2i_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2i\0",
&self.glUniform2i_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform2i_is_loaded(&self) -> bool {
!self.glUniform2i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform2iv(
&self,
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform2iv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform2iv",
&self.glUniform2iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2iv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform2iv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2iv\0",
&self.glUniform2iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform2iv_is_loaded(&self) -> bool {
!self.glUniform2iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform2ui(&self, location: GLint, v0: GLuint, v1: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.Uniform2ui({:?}, {:?}, {:?});", location, v0, v1);
}
let out = call_atomic_ptr_3arg(
"glUniform2ui",
&self.glUniform2ui_p,
location,
v0,
v1,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2ui", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform2ui_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2ui\0",
&self.glUniform2ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform2ui_is_loaded(&self) -> bool {
!self.glUniform2ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform2uiv(
&self,
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform2uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform2uiv",
&self.glUniform2uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform2uiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform2uiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform2uiv\0",
&self.glUniform2uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform2uiv_is_loaded(&self) -> bool {
!self.glUniform2uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform3f(
&self,
location: GLint,
v0: GLfloat,
v1: GLfloat,
v2: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform3f({:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2
);
}
let out = call_atomic_ptr_4arg(
"glUniform3f",
&self.glUniform3f_p,
location,
v0,
v1,
v2,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform3f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3f\0",
&self.glUniform3f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform3f_is_loaded(&self) -> bool {
!self.glUniform3f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform3fv(
&self,
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform3fv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform3fv",
&self.glUniform3fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform3fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3fv\0",
&self.glUniform3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform3fv_is_loaded(&self) -> bool {
!self.glUniform3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform3i(
&self,
location: GLint,
v0: GLint,
v1: GLint,
v2: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform3i({:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2
);
}
let out = call_atomic_ptr_4arg(
"glUniform3i",
&self.glUniform3i_p,
location,
v0,
v1,
v2,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3i", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform3i_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3i\0",
&self.glUniform3i_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform3i_is_loaded(&self) -> bool {
!self.glUniform3i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform3iv(
&self,
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform3iv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform3iv",
&self.glUniform3iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3iv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform3iv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3iv\0",
&self.glUniform3iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform3iv_is_loaded(&self) -> bool {
!self.glUniform3iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform3ui(
&self,
location: GLint,
v0: GLuint,
v1: GLuint,
v2: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform3ui({:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2
);
}
let out = call_atomic_ptr_4arg(
"glUniform3ui",
&self.glUniform3ui_p,
location,
v0,
v1,
v2,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3ui", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform3ui_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3ui\0",
&self.glUniform3ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform3ui_is_loaded(&self) -> bool {
!self.glUniform3ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform3uiv(
&self,
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform3uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform3uiv",
&self.glUniform3uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform3uiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform3uiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform3uiv\0",
&self.glUniform3uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform3uiv_is_loaded(&self) -> bool {
!self.glUniform3uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform4f(
&self,
location: GLint,
v0: GLfloat,
v1: GLfloat,
v2: GLfloat,
v3: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform4f({:?}, {:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2,
v3
);
}
let out = call_atomic_ptr_5arg(
"glUniform4f",
&self.glUniform4f_p,
location,
v0,
v1,
v2,
v3,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform4f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4f\0",
&self.glUniform4f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform4f_is_loaded(&self) -> bool {
!self.glUniform4f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform4fv(
&self,
location: GLint,
count: GLsizei,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform4fv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform4fv",
&self.glUniform4fv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform4fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4fv\0",
&self.glUniform4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform4fv_is_loaded(&self) -> bool {
!self.glUniform4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform4i(
&self,
location: GLint,
v0: GLint,
v1: GLint,
v2: GLint,
v3: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform4i({:?}, {:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2,
v3
);
}
let out = call_atomic_ptr_5arg(
"glUniform4i",
&self.glUniform4i_p,
location,
v0,
v1,
v2,
v3,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4i", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform4i_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4i\0",
&self.glUniform4i_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform4i_is_loaded(&self) -> bool {
!self.glUniform4i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform4iv(
&self,
location: GLint,
count: GLsizei,
value: *const GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform4iv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform4iv",
&self.glUniform4iv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4iv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform4iv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4iv\0",
&self.glUniform4iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform4iv_is_loaded(&self) -> bool {
!self.glUniform4iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform4ui(
&self,
location: GLint,
v0: GLuint,
v1: GLuint,
v2: GLuint,
v3: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform4ui({:?}, {:?}, {:?}, {:?}, {:?});",
location,
v0,
v1,
v2,
v3
);
}
let out = call_atomic_ptr_5arg(
"glUniform4ui",
&self.glUniform4ui_p,
location,
v0,
v1,
v2,
v3,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4ui", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform4ui_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4ui\0",
&self.glUniform4ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform4ui_is_loaded(&self) -> bool {
!self.glUniform4ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Uniform4uiv(
&self,
location: GLint,
count: GLsizei,
value: *const GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Uniform4uiv({:?}, {:?}, {:p});",
location,
count,
value
);
}
let out = call_atomic_ptr_3arg(
"glUniform4uiv",
&self.glUniform4uiv_p,
location,
count,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniform4uiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Uniform4uiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniform4uiv\0",
&self.glUniform4uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Uniform4uiv_is_loaded(&self) -> bool {
!self.glUniform4uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformBlockBinding(
&self,
program: GLuint,
uniformBlockIndex: GLuint,
uniformBlockBinding: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformBlockBinding({:?}, {:?}, {:?});",
program,
uniformBlockIndex,
uniformBlockBinding
);
}
let out = call_atomic_ptr_3arg(
"glUniformBlockBinding",
&self.glUniformBlockBinding_p,
program,
uniformBlockIndex,
uniformBlockBinding,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformBlockBinding", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformBlockBinding_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformBlockBinding\0",
&self.glUniformBlockBinding_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformBlockBinding_is_loaded(&self) -> bool {
!self.glUniformBlockBinding_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix2fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix2fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix2fv",
&self.glUniformMatrix2fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix2fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix2fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix2fv\0",
&self.glUniformMatrix2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix2fv_is_loaded(&self) -> bool {
!self.glUniformMatrix2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix2x3fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix2x3fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix2x3fv",
&self.glUniformMatrix2x3fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix2x3fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix2x3fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix2x3fv\0",
&self.glUniformMatrix2x3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix2x3fv_is_loaded(&self) -> bool {
!self.glUniformMatrix2x3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix2x4fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix2x4fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix2x4fv",
&self.glUniformMatrix2x4fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix2x4fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix2x4fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix2x4fv\0",
&self.glUniformMatrix2x4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix2x4fv_is_loaded(&self) -> bool {
!self.glUniformMatrix2x4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix3fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix3fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix3fv",
&self.glUniformMatrix3fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix3fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix3fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix3fv\0",
&self.glUniformMatrix3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix3fv_is_loaded(&self) -> bool {
!self.glUniformMatrix3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix3x2fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix3x2fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix3x2fv",
&self.glUniformMatrix3x2fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix3x2fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix3x2fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix3x2fv\0",
&self.glUniformMatrix3x2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix3x2fv_is_loaded(&self) -> bool {
!self.glUniformMatrix3x2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix3x4fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix3x4fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix3x4fv",
&self.glUniformMatrix3x4fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix3x4fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix3x4fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix3x4fv\0",
&self.glUniformMatrix3x4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix3x4fv_is_loaded(&self) -> bool {
!self.glUniformMatrix3x4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix4fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix4fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix4fv",
&self.glUniformMatrix4fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix4fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix4fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix4fv\0",
&self.glUniformMatrix4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix4fv_is_loaded(&self) -> bool {
!self.glUniformMatrix4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix4x2fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix4x2fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix4x2fv",
&self.glUniformMatrix4x2fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix4x2fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix4x2fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix4x2fv\0",
&self.glUniformMatrix4x2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix4x2fv_is_loaded(&self) -> bool {
!self.glUniformMatrix4x2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UniformMatrix4x3fv(
&self,
location: GLint,
count: GLsizei,
transpose: GLboolean,
value: *const GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.UniformMatrix4x3fv({:?}, {:?}, {:?}, {:p});",
location,
count,
transpose,
value
);
}
let out = call_atomic_ptr_4arg(
"glUniformMatrix4x3fv",
&self.glUniformMatrix4x3fv_p,
location,
count,
transpose,
value,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUniformMatrix4x3fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UniformMatrix4x3fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUniformMatrix4x3fv\0",
&self.glUniformMatrix4x3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UniformMatrix4x3fv_is_loaded(&self) -> bool {
!self.glUniformMatrix4x3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UnmapBuffer(&self, target: GLenum) -> GLboolean {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.UnmapBuffer({:#X});", target);
}
let out =
call_atomic_ptr_1arg("glUnmapBuffer", &self.glUnmapBuffer_p, target);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUnmapBuffer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UnmapBuffer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUnmapBuffer\0",
&self.glUnmapBuffer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UnmapBuffer_is_loaded(&self) -> bool {
!self.glUnmapBuffer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn UseProgram(&self, program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.UseProgram({:?});", program);
}
let out =
call_atomic_ptr_1arg("glUseProgram", &self.glUseProgram_p, program);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glUseProgram", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn UseProgram_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glUseProgram\0",
&self.glUseProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn UseProgram_is_loaded(&self) -> bool {
!self.glUseProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn ValidateProgram(&self, program: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.ValidateProgram({:?});", program);
}
let out = call_atomic_ptr_1arg(
"glValidateProgram",
&self.glValidateProgram_p,
program,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glValidateProgram", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn ValidateProgram_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glValidateProgram\0",
&self.glValidateProgram_p,
)
}
#[inline]
#[doc(hidden)]
pub fn ValidateProgram_is_loaded(&self) -> bool {
!self.glValidateProgram_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib1f(&self, index: GLuint, x: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttrib1f({:?}, {:?});", index, x);
}
let out = call_atomic_ptr_2arg(
"glVertexAttrib1f",
&self.glVertexAttrib1f_p,
index,
x,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib1f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib1f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib1f\0",
&self.glVertexAttrib1f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib1f_is_loaded(&self) -> bool {
!self.glVertexAttrib1f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib1fv(&self, index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttrib1fv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttrib1fv",
&self.glVertexAttrib1fv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib1fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib1fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib1fv\0",
&self.glVertexAttrib1fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib1fv_is_loaded(&self) -> bool {
!self.glVertexAttrib1fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib2f(&self, index: GLuint, x: GLfloat, y: GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttrib2f({:?}, {:?}, {:?});", index, x, y);
}
let out = call_atomic_ptr_3arg(
"glVertexAttrib2f",
&self.glVertexAttrib2f_p,
index,
x,
y,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib2f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib2f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib2f\0",
&self.glVertexAttrib2f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib2f_is_loaded(&self) -> bool {
!self.glVertexAttrib2f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib2fv(&self, index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttrib2fv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttrib2fv",
&self.glVertexAttrib2fv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib2fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib2fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib2fv\0",
&self.glVertexAttrib2fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib2fv_is_loaded(&self) -> bool {
!self.glVertexAttrib2fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib3f(
&self,
index: GLuint,
x: GLfloat,
y: GLfloat,
z: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.VertexAttrib3f({:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z
);
}
let out = call_atomic_ptr_4arg(
"glVertexAttrib3f",
&self.glVertexAttrib3f_p,
index,
x,
y,
z,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib3f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib3f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib3f\0",
&self.glVertexAttrib3f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib3f_is_loaded(&self) -> bool {
!self.glVertexAttrib3f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib3fv(&self, index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttrib3fv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttrib3fv",
&self.glVertexAttrib3fv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib3fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib3fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib3fv\0",
&self.glVertexAttrib3fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib3fv_is_loaded(&self) -> bool {
!self.glVertexAttrib3fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib4f(
&self,
index: GLuint,
x: GLfloat,
y: GLfloat,
z: GLfloat,
w: GLfloat,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.VertexAttrib4f({:?}, {:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z,
w
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttrib4f",
&self.glVertexAttrib4f_p,
index,
x,
y,
z,
w,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib4f", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib4f_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib4f\0",
&self.glVertexAttrib4f_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib4f_is_loaded(&self) -> bool {
!self.glVertexAttrib4f_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttrib4fv(&self, index: GLuint, v: *const GLfloat) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttrib4fv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttrib4fv",
&self.glVertexAttrib4fv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttrib4fv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttrib4fv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttrib4fv\0",
&self.glVertexAttrib4fv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttrib4fv_is_loaded(&self) -> bool {
!self.glVertexAttrib4fv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribDivisor(&self, index: GLuint, divisor: GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttribDivisor({:?}, {:?});", index, divisor);
}
let out = call_atomic_ptr_2arg(
"glVertexAttribDivisor",
&self.glVertexAttribDivisor_p,
index,
divisor,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribDivisor", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribDivisor_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribDivisor\0",
&self.glVertexAttribDivisor_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribDivisor_is_loaded(&self) -> bool {
!self.glVertexAttribDivisor_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribI4i(
&self,
index: GLuint,
x: GLint,
y: GLint,
z: GLint,
w: GLint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.VertexAttribI4i({:?}, {:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z,
w
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttribI4i",
&self.glVertexAttribI4i_p,
index,
x,
y,
z,
w,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4i", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribI4i_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4i\0",
&self.glVertexAttribI4i_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribI4i_is_loaded(&self) -> bool {
!self.glVertexAttribI4i_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribI4iv(&self, index: GLuint, v: *const GLint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttribI4iv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttribI4iv",
&self.glVertexAttribI4iv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4iv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribI4iv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4iv\0",
&self.glVertexAttribI4iv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribI4iv_is_loaded(&self) -> bool {
!self.glVertexAttribI4iv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribI4ui(
&self,
index: GLuint,
x: GLuint,
y: GLuint,
z: GLuint,
w: GLuint,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.VertexAttribI4ui({:?}, {:?}, {:?}, {:?}, {:?});",
index,
x,
y,
z,
w
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttribI4ui",
&self.glVertexAttribI4ui_p,
index,
x,
y,
z,
w,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4ui", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribI4ui_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4ui\0",
&self.glVertexAttribI4ui_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribI4ui_is_loaded(&self) -> bool {
!self.glVertexAttribI4ui_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribI4uiv(&self, index: GLuint, v: *const GLuint) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttribI4uiv({:?}, {:p});", index, v);
}
let out = call_atomic_ptr_2arg(
"glVertexAttribI4uiv",
&self.glVertexAttribI4uiv_p,
index,
v,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribI4uiv", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribI4uiv_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribI4uiv\0",
&self.glVertexAttribI4uiv_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribI4uiv_is_loaded(&self) -> bool {
!self.glVertexAttribI4uiv_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribIPointer(
&self,
index: GLuint,
size: GLint,
type_: GLenum,
stride: GLsizei,
pointer: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.VertexAttribIPointer({:?}, {:?}, {:#X}, {:?}, {:p});",
index,
size,
type_,
stride,
pointer
);
}
let out = call_atomic_ptr_5arg(
"glVertexAttribIPointer",
&self.glVertexAttribIPointer_p,
index,
size,
type_,
stride,
pointer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribIPointer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribIPointer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribIPointer\0",
&self.glVertexAttribIPointer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribIPointer_is_loaded(&self) -> bool {
!self.glVertexAttribIPointer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn VertexAttribPointer(
&self,
index: GLuint,
size: GLint,
type_: GLenum,
normalized: GLboolean,
stride: GLsizei,
pointer: *const c_void,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.VertexAttribPointer({:?}, {:?}, {:#X}, {:?}, {:?}, {:p});", index, size, type_, normalized, stride, pointer);
}
let out = call_atomic_ptr_6arg(
"glVertexAttribPointer",
&self.glVertexAttribPointer_p,
index,
size,
type_,
normalized,
stride,
pointer,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glVertexAttribPointer", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn VertexAttribPointer_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glVertexAttribPointer\0",
&self.glVertexAttribPointer_p,
)
}
#[inline]
#[doc(hidden)]
pub fn VertexAttribPointer_is_loaded(&self) -> bool {
!self.glVertexAttribPointer_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn Viewport(
&self,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!(
"calling gl.Viewport({:?}, {:?}, {:?}, {:?});",
x,
y,
width,
height
);
}
let out = call_atomic_ptr_4arg(
"glViewport",
&self.glViewport_p,
x,
y,
width,
height,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glViewport", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn Viewport_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glViewport\0",
&self.glViewport_p,
)
}
#[inline]
#[doc(hidden)]
pub fn Viewport_is_loaded(&self) -> bool {
!self.glViewport_p.load(RELAX).is_null()
}
#[cfg_attr(feature = "inline", inline)]
#[cfg_attr(feature = "inline_always", inline(always))]
pub unsafe fn WaitSync(
&self,
sync: GLsync,
flags: GLbitfield,
timeout: GLuint64,
) {
#[cfg(all(debug_assertions, feature = "debug_trace_calls"))]
{
trace!("calling gl.WaitSync({:p}, {:?}, {:?});", sync, flags, timeout);
}
let out = call_atomic_ptr_3arg(
"glWaitSync",
&self.glWaitSync_p,
sync,
flags,
timeout,
);
#[cfg(all(debug_assertions, feature = "debug_automatic_glGetError"))]
{
let mut err = self.GetError();
while err != GL_NO_ERROR {
report_error_code_from("glWaitSync", err);
err = self.GetError();
}
}
out
}
#[doc(hidden)]
pub unsafe fn WaitSync_load_with_dyn(
&self,
get_proc_address: &mut dyn FnMut(*const c_char) -> *mut c_void,
) -> bool {
load_dyn_name_atomic_ptr(
get_proc_address,
b"glWaitSync\0",
&self.glWaitSync_p,
)
}
#[inline]
#[doc(hidden)]
pub fn WaitSync_is_loaded(&self) -> bool {
!self.glWaitSync_p.load(RELAX).is_null()
}
}
#[repr(C)]
pub struct GlFns {
glActiveTexture_p: APcv,
glAttachShader_p: APcv,
glBeginQuery_p: APcv,
glBeginTransformFeedback_p: APcv,
glBindAttribLocation_p: APcv,
glBindBuffer_p: APcv,
glBindBufferBase_p: APcv,
glBindBufferRange_p: APcv,
glBindFramebuffer_p: APcv,
glBindRenderbuffer_p: APcv,
glBindSampler_p: APcv,
glBindTexture_p: APcv,
glBindTransformFeedback_p: APcv,
glBindVertexArray_p: APcv,
glBlendColor_p: APcv,
glBlendEquation_p: APcv,
glBlendEquationSeparate_p: APcv,
glBlendFunc_p: APcv,
glBlendFuncSeparate_p: APcv,
glBlitFramebuffer_p: APcv,
glBufferData_p: APcv,
glBufferSubData_p: APcv,
glCheckFramebufferStatus_p: APcv,
glClear_p: APcv,
glClearBufferfi_p: APcv,
glClearBufferfv_p: APcv,
glClearBufferiv_p: APcv,
glClearBufferuiv_p: APcv,
glClearColor_p: APcv,
glClearDepthf_p: APcv,
glClearStencil_p: APcv,
glClientWaitSync_p: APcv,
glColorMask_p: APcv,
glCompileShader_p: APcv,
glCompressedTexImage2D_p: APcv,
glCompressedTexImage3D_p: APcv,
glCompressedTexSubImage2D_p: APcv,
glCompressedTexSubImage3D_p: APcv,
glCopyBufferSubData_p: APcv,
glCopyTexImage2D_p: APcv,
glCopyTexSubImage2D_p: APcv,
glCopyTexSubImage3D_p: APcv,
glCreateProgram_p: APcv,
glCreateShader_p: APcv,
glCullFace_p: APcv,
glDeleteBuffers_p: APcv,
glDeleteFramebuffers_p: APcv,
glDeleteProgram_p: APcv,
glDeleteQueries_p: APcv,
glDeleteRenderbuffers_p: APcv,
glDeleteSamplers_p: APcv,
glDeleteShader_p: APcv,
glDeleteSync_p: APcv,
glDeleteTextures_p: APcv,
glDeleteTransformFeedbacks_p: APcv,
glDeleteVertexArrays_p: APcv,
glDepthFunc_p: APcv,
glDepthMask_p: APcv,
glDepthRangef_p: APcv,
glDetachShader_p: APcv,
glDisable_p: APcv,
glDisableVertexAttribArray_p: APcv,
glDrawArrays_p: APcv,
glDrawArraysInstanced_p: APcv,
glDrawBuffers_p: APcv,
glDrawElements_p: APcv,
glDrawElementsInstanced_p: APcv,
glDrawRangeElements_p: APcv,
glEnable_p: APcv,
glEnableVertexAttribArray_p: APcv,
glEndQuery_p: APcv,
glEndTransformFeedback_p: APcv,
glFenceSync_p: APcv,
glFinish_p: APcv,
glFlush_p: APcv,
glFlushMappedBufferRange_p: APcv,
glFramebufferRenderbuffer_p: APcv,
glFramebufferTexture2D_p: APcv,
glFramebufferTextureLayer_p: APcv,
glFrontFace_p: APcv,
glGenBuffers_p: APcv,
glGenFramebuffers_p: APcv,
glGenQueries_p: APcv,
glGenRenderbuffers_p: APcv,
glGenSamplers_p: APcv,
glGenTextures_p: APcv,
glGenTransformFeedbacks_p: APcv,
glGenVertexArrays_p: APcv,
glGenerateMipmap_p: APcv,
glGetActiveAttrib_p: APcv,
glGetActiveUniform_p: APcv,
glGetActiveUniformBlockName_p: APcv,
glGetActiveUniformBlockiv_p: APcv,
glGetActiveUniformsiv_p: APcv,
glGetAttachedShaders_p: APcv,
glGetAttribLocation_p: APcv,
glGetBooleanv_p: APcv,
glGetBufferParameteri64v_p: APcv,
glGetBufferParameteriv_p: APcv,
glGetBufferPointerv_p: APcv,
glGetError_p: APcv,
glGetFloatv_p: APcv,
glGetFragDataLocation_p: APcv,
glGetFramebufferAttachmentParameteriv_p: APcv,
glGetInteger64i_v_p: APcv,
glGetInteger64v_p: APcv,
glGetIntegeri_v_p: APcv,
glGetIntegerv_p: APcv,
glGetInternalformativ_p: APcv,
glGetProgramBinary_p: APcv,
glGetProgramInfoLog_p: APcv,
glGetProgramiv_p: APcv,
glGetQueryObjectuiv_p: APcv,
glGetQueryiv_p: APcv,
glGetRenderbufferParameteriv_p: APcv,
glGetSamplerParameterfv_p: APcv,
glGetSamplerParameteriv_p: APcv,
glGetShaderInfoLog_p: APcv,
glGetShaderPrecisionFormat_p: APcv,
glGetShaderSource_p: APcv,
glGetShaderiv_p: APcv,
glGetString_p: APcv,
glGetStringi_p: APcv,
glGetSynciv_p: APcv,
glGetTexParameterfv_p: APcv,
glGetTexParameteriv_p: APcv,
glGetTransformFeedbackVarying_p: APcv,
glGetUniformBlockIndex_p: APcv,
glGetUniformIndices_p: APcv,
glGetUniformLocation_p: APcv,
glGetUniformfv_p: APcv,
glGetUniformiv_p: APcv,
glGetUniformuiv_p: APcv,
glGetVertexAttribIiv_p: APcv,
glGetVertexAttribIuiv_p: APcv,
glGetVertexAttribPointerv_p: APcv,
glGetVertexAttribfv_p: APcv,
glGetVertexAttribiv_p: APcv,
glHint_p: APcv,
glInvalidateFramebuffer_p: APcv,
glInvalidateSubFramebuffer_p: APcv,
glIsBuffer_p: APcv,
glIsEnabled_p: APcv,
glIsFramebuffer_p: APcv,
glIsProgram_p: APcv,
glIsQuery_p: APcv,
glIsRenderbuffer_p: APcv,
glIsSampler_p: APcv,
glIsShader_p: APcv,
glIsSync_p: APcv,
glIsTexture_p: APcv,
glIsTransformFeedback_p: APcv,
glIsVertexArray_p: APcv,
glLineWidth_p: APcv,
glLinkProgram_p: APcv,
glMapBufferRange_p: APcv,
glPauseTransformFeedback_p: APcv,
glPixelStorei_p: APcv,
glPolygonOffset_p: APcv,
glProgramBinary_p: APcv,
glProgramParameteri_p: APcv,
glReadBuffer_p: APcv,
glReadPixels_p: APcv,
glReleaseShaderCompiler_p: APcv,
glRenderbufferStorage_p: APcv,
glRenderbufferStorageMultisample_p: APcv,
glResumeTransformFeedback_p: APcv,
glSampleCoverage_p: APcv,
glSamplerParameterf_p: APcv,
glSamplerParameterfv_p: APcv,
glSamplerParameteri_p: APcv,
glSamplerParameteriv_p: APcv,
glScissor_p: APcv,
glShaderBinary_p: APcv,
glShaderSource_p: APcv,
glStencilFunc_p: APcv,
glStencilFuncSeparate_p: APcv,
glStencilMask_p: APcv,
glStencilMaskSeparate_p: APcv,
glStencilOp_p: APcv,
glStencilOpSeparate_p: APcv,
glTexImage2D_p: APcv,
glTexImage3D_p: APcv,
glTexParameterf_p: APcv,
glTexParameterfv_p: APcv,
glTexParameteri_p: APcv,
glTexParameteriv_p: APcv,
glTexStorage2D_p: APcv,
glTexStorage3D_p: APcv,
glTexSubImage2D_p: APcv,
glTexSubImage3D_p: APcv,
glTransformFeedbackVaryings_p: APcv,
glUniform1f_p: APcv,
glUniform1fv_p: APcv,
glUniform1i_p: APcv,
glUniform1iv_p: APcv,
glUniform1ui_p: APcv,
glUniform1uiv_p: APcv,
glUniform2f_p: APcv,
glUniform2fv_p: APcv,
glUniform2i_p: APcv,
glUniform2iv_p: APcv,
glUniform2ui_p: APcv,
glUniform2uiv_p: APcv,
glUniform3f_p: APcv,
glUniform3fv_p: APcv,
glUniform3i_p: APcv,
glUniform3iv_p: APcv,
glUniform3ui_p: APcv,
glUniform3uiv_p: APcv,
glUniform4f_p: APcv,
glUniform4fv_p: APcv,
glUniform4i_p: APcv,
glUniform4iv_p: APcv,
glUniform4ui_p: APcv,
glUniform4uiv_p: APcv,
glUniformBlockBinding_p: APcv,
glUniformMatrix2fv_p: APcv,
glUniformMatrix2x3fv_p: APcv,
glUniformMatrix2x4fv_p: APcv,
glUniformMatrix3fv_p: APcv,
glUniformMatrix3x2fv_p: APcv,
glUniformMatrix3x4fv_p: APcv,
glUniformMatrix4fv_p: APcv,
glUniformMatrix4x2fv_p: APcv,
glUniformMatrix4x3fv_p: APcv,
glUnmapBuffer_p: APcv,
glUseProgram_p: APcv,
glValidateProgram_p: APcv,
glVertexAttrib1f_p: APcv,
glVertexAttrib1fv_p: APcv,
glVertexAttrib2f_p: APcv,
glVertexAttrib2fv_p: APcv,
glVertexAttrib3f_p: APcv,
glVertexAttrib3fv_p: APcv,
glVertexAttrib4f_p: APcv,
glVertexAttrib4fv_p: APcv,
glVertexAttribDivisor_p: APcv,
glVertexAttribI4i_p: APcv,
glVertexAttribI4iv_p: APcv,
glVertexAttribI4ui_p: APcv,
glVertexAttribI4uiv_p: APcv,
glVertexAttribIPointer_p: APcv,
glVertexAttribPointer_p: APcv,
glViewport_p: APcv,
glWaitSync_p: APcv,
}
#[cfg(feature = "bytemuck")]
unsafe impl bytemuck::Zeroable for GlFns {}
impl core::fmt::Debug for GlFns {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "GlFns")
}
}
}