GLee.c   GLee.c 
/************************************************************************** * /************************************************************************** *
* *
* GLee.c * GLee.c
* GLee (OpenGL Easy Extension library) * GLee (OpenGL Easy Extension library)
* Version : 5.33 * Version : 5.4
* *
* Copyright (c)2008 Ben Woodhouse All rights reserved. * Copyright (c)2009 Ben Woodhouse All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are * modification, are permitted provided that the following conditions are
* met: * met:
* 1. Redistributions of source code must retain the above copyright * 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer as * notice, this list of conditions and the following disclaimer as
* the first lines of this file unmodified. * the first lines of this file unmodified.
* 2. Redistributions in binary form must reproduce the above copyright * 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
skipping to change at line 32 skipping to change at line 32
* IN NO EVENT SHALL BEN WOODHOUSE BE LIABLE FOR ANY DIRECT, INDIRECT, * IN NO EVENT SHALL BEN WOODHOUSE BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Web: http://elf-stone.com/glee.php * Web: http://elf-stone.com/glee.php
* *
* [This file was automatically generated by GLeeGen 6.0 * [This file was automatically generated by GLeeGen 7.0
* *
*************************************************************************** / *************************************************************************** /
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma optimize( "g", off ) #pragma optimize( "g", off )
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
skipping to change at line 366 skipping to change at line 366
GLboolean _GLEE_GREMEDY_string_marker = GL_FALSE; GLboolean _GLEE_GREMEDY_string_marker = GL_FALSE;
GLboolean _GLEE_EXT_packed_depth_stencil = GL_FALSE; GLboolean _GLEE_EXT_packed_depth_stencil = GL_FALSE;
GLboolean _GLEE_EXT_stencil_clear_tag = GL_FALSE; GLboolean _GLEE_EXT_stencil_clear_tag = GL_FALSE;
GLboolean _GLEE_EXT_texture_sRGB = GL_FALSE; GLboolean _GLEE_EXT_texture_sRGB = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_blit = GL_FALSE; GLboolean _GLEE_EXT_framebuffer_blit = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_multisample = GL_FALSE; GLboolean _GLEE_EXT_framebuffer_multisample = GL_FALSE;
GLboolean _GLEE_MESAX_texture_stack = GL_FALSE; GLboolean _GLEE_MESAX_texture_stack = GL_FALSE;
GLboolean _GLEE_EXT_timer_query = GL_FALSE; GLboolean _GLEE_EXT_timer_query = GL_FALSE;
GLboolean _GLEE_EXT_gpu_program_parameters = GL_FALSE; GLboolean _GLEE_EXT_gpu_program_parameters = GL_FALSE;
GLboolean _GLEE_APPLE_flush_buffer_range = GL_FALSE; GLboolean _GLEE_APPLE_flush_buffer_range = GL_FALSE;
GLboolean _GLEE_NV_gpu_program4 = GL_FALSE;
GLboolean _GLEE_NV_geometry_program4 = GL_FALSE;
GLboolean _GLEE_EXT_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program4 = GL_FALSE;
GLboolean _GLEE_EXT_gpu_shader4 = GL_FALSE; GLboolean _GLEE_EXT_gpu_shader4 = GL_FALSE;
GLboolean _GLEE_EXT_draw_instanced = GL_FALSE; GLboolean _GLEE_EXT_draw_instanced = GL_FALSE;
GLboolean _GLEE_EXT_packed_float = GL_FALSE; GLboolean _GLEE_EXT_packed_float = GL_FALSE;
GLboolean _GLEE_EXT_texture_array = GL_FALSE; GLboolean _GLEE_EXT_texture_array = GL_FALSE;
GLboolean _GLEE_EXT_texture_buffer_object = GL_FALSE; GLboolean _GLEE_EXT_texture_buffer_object = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_latc = GL_FALSE; GLboolean _GLEE_EXT_texture_compression_latc = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_rgtc = GL_FALSE; GLboolean _GLEE_EXT_texture_compression_rgtc = GL_FALSE;
GLboolean _GLEE_EXT_texture_shared_exponent = GL_FALSE; GLboolean _GLEE_EXT_texture_shared_exponent = GL_FALSE;
GLboolean _GLEE_NV_depth_buffer_float = GL_FALSE; GLboolean _GLEE_NV_depth_buffer_float = GL_FALSE;
GLboolean _GLEE_NV_fragment_program4 = GL_FALSE;
GLboolean _GLEE_NV_framebuffer_multisample_coverage = GL_FALSE; GLboolean _GLEE_NV_framebuffer_multisample_coverage = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_sRGB = GL_FALSE; GLboolean _GLEE_EXT_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_NV_geometry_shader4 = GL_FALSE; GLboolean _GLEE_NV_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_NV_parameter_buffer_object = GL_FALSE; GLboolean _GLEE_NV_parameter_buffer_object = GL_FALSE;
GLboolean _GLEE_EXT_draw_buffers2 = GL_FALSE; GLboolean _GLEE_EXT_draw_buffers2 = GL_FALSE;
GLboolean _GLEE_NV_transform_feedback = GL_FALSE; GLboolean _GLEE_NV_transform_feedback = GL_FALSE;
GLboolean _GLEE_EXT_bindable_uniform = GL_FALSE; GLboolean _GLEE_EXT_bindable_uniform = GL_FALSE;
GLboolean _GLEE_EXT_texture_integer = GL_FALSE; GLboolean _GLEE_EXT_texture_integer = GL_FALSE;
GLboolean _GLEE_GREMEDY_frame_terminator = GL_FALSE; GLboolean _GLEE_GREMEDY_frame_terminator = GL_FALSE;
GLboolean _GLEE_NV_conditional_render = GL_FALSE; GLboolean _GLEE_NV_conditional_render = GL_FALSE;
GLboolean _GLEE_NV_present_video = GL_FALSE; GLboolean _GLEE_NV_present_video = GL_FALSE;
GLboolean _GLEE_EXT_transform_feedback = GL_FALSE; GLboolean _GLEE_EXT_transform_feedback = GL_FALSE;
GLboolean _GLEE_EXT_direct_state_access = GL_FALSE; GLboolean _GLEE_EXT_direct_state_access = GL_FALSE;
GLboolean _GLEE_EXT_vertex_array_bgra = GL_FALSE; GLboolean _GLEE_EXT_vertex_array_bgra = GL_FALSE;
GLboolean _GLEE_EXT_texture_swizzle = GL_FALSE;
GLboolean _GLEE_NV_explicit_multisample = GL_FALSE;
GLboolean _GLEE_NV_transform_feedback2 = GL_FALSE;
GLboolean _GLEE_SGIX_texture_select = GL_FALSE; GLboolean _GLEE_SGIX_texture_select = GL_FALSE;
GLboolean _GLEE_INGR_blend_func_separate = GL_FALSE; GLboolean _GLEE_INGR_blend_func_separate = GL_FALSE;
GLboolean _GLEE_SGIX_depth_pass_instrument = GL_FALSE; GLboolean _GLEE_SGIX_depth_pass_instrument = GL_FALSE;
GLboolean _GLEE_SGIX_igloo_interface = GL_FALSE; GLboolean _GLEE_SGIX_igloo_interface = GL_FALSE;
GLboolean _GLEE_EXT_fragment_lighting = GL_FALSE; GLboolean _GLEE_EXT_fragment_lighting = GL_FALSE;
GLboolean _GLEE_EXT_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_EXT_scene_marker = GL_FALSE; GLboolean _GLEE_EXT_scene_marker = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_dxt1 = GL_FALSE; GLboolean _GLEE_EXT_texture_compression_dxt1 = GL_FALSE;
GLboolean _GLEE_EXT_texture_env = GL_FALSE; GLboolean _GLEE_EXT_texture_env = GL_FALSE;
GLboolean _GLEE_IBM_static_data = GL_FALSE; GLboolean _GLEE_IBM_static_data = GL_FALSE;
GLboolean _GLEE_NV_gpu_program4 = GL_FALSE;
GLboolean _GLEE_OES_byte_coordinates = GL_FALSE; GLboolean _GLEE_OES_byte_coordinates = GL_FALSE;
GLboolean _GLEE_OES_compressed_paletted_texture = GL_FALSE; GLboolean _GLEE_OES_compressed_paletted_texture = GL_FALSE;
GLboolean _GLEE_OES_single_precision = GL_FALSE; GLboolean _GLEE_OES_single_precision = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_texture_bits = GL_FALSE; GLboolean _GLEE_SGIX_pixel_texture_bits = GL_FALSE;
GLboolean _GLEE_SGIX_texture_range = GL_FALSE; GLboolean _GLEE_SGIX_texture_range = GL_FALSE;
/* GL Extension names */ /* GL Extension names */
char __GLeeGLExtensionNames[322][39]={ char __GLeeGLExtensionNames[322][39]={
"GL_VERSION_1_2", "GL_VERSION_1_2",
skipping to change at line 692 skipping to change at line 692
"GL_GREMEDY_string_marker", "GL_GREMEDY_string_marker",
"GL_EXT_packed_depth_stencil", "GL_EXT_packed_depth_stencil",
"GL_EXT_stencil_clear_tag", "GL_EXT_stencil_clear_tag",
"GL_EXT_texture_sRGB", "GL_EXT_texture_sRGB",
"GL_EXT_framebuffer_blit", "GL_EXT_framebuffer_blit",
"GL_EXT_framebuffer_multisample", "GL_EXT_framebuffer_multisample",
"GL_MESAX_texture_stack", "GL_MESAX_texture_stack",
"GL_EXT_timer_query", "GL_EXT_timer_query",
"GL_EXT_gpu_program_parameters", "GL_EXT_gpu_program_parameters",
"GL_APPLE_flush_buffer_range", "GL_APPLE_flush_buffer_range",
"GL_NV_gpu_program4",
"GL_NV_geometry_program4",
"GL_EXT_geometry_shader4",
"GL_NV_vertex_program4",
"GL_EXT_gpu_shader4", "GL_EXT_gpu_shader4",
"GL_EXT_draw_instanced", "GL_EXT_draw_instanced",
"GL_EXT_packed_float", "GL_EXT_packed_float",
"GL_EXT_texture_array", "GL_EXT_texture_array",
"GL_EXT_texture_buffer_object", "GL_EXT_texture_buffer_object",
"GL_EXT_texture_compression_latc", "GL_EXT_texture_compression_latc",
"GL_EXT_texture_compression_rgtc", "GL_EXT_texture_compression_rgtc",
"GL_EXT_texture_shared_exponent", "GL_EXT_texture_shared_exponent",
"GL_NV_depth_buffer_float", "GL_NV_depth_buffer_float",
"GL_NV_fragment_program4",
"GL_NV_framebuffer_multisample_coverage", "GL_NV_framebuffer_multisample_coverage",
"GL_EXT_framebuffer_sRGB", "GL_EXT_framebuffer_sRGB",
"GL_NV_geometry_shader4", "GL_NV_geometry_shader4",
"GL_NV_parameter_buffer_object", "GL_NV_parameter_buffer_object",
"GL_EXT_draw_buffers2", "GL_EXT_draw_buffers2",
"GL_NV_transform_feedback", "GL_NV_transform_feedback",
"GL_EXT_bindable_uniform", "GL_EXT_bindable_uniform",
"GL_EXT_texture_integer", "GL_EXT_texture_integer",
"GL_GREMEDY_frame_terminator", "GL_GREMEDY_frame_terminator",
"GL_NV_conditional_render", "GL_NV_conditional_render",
"GL_NV_present_video", "GL_NV_present_video",
"GL_EXT_transform_feedback", "GL_EXT_transform_feedback",
"GL_EXT_direct_state_access", "GL_EXT_direct_state_access",
"GL_EXT_vertex_array_bgra", "GL_EXT_vertex_array_bgra",
"GL_EXT_texture_swizzle",
"GL_NV_explicit_multisample",
"GL_NV_transform_feedback2",
"GL_SGIX_texture_select", "GL_SGIX_texture_select",
"GL_INGR_blend_func_separate", "GL_INGR_blend_func_separate",
"GL_SGIX_depth_pass_instrument", "GL_SGIX_depth_pass_instrument",
"GL_SGIX_igloo_interface", "GL_SGIX_igloo_interface",
"GL_EXT_fragment_lighting", "GL_EXT_fragment_lighting",
"GL_EXT_geometry_shader4",
"GL_EXT_scene_marker", "GL_EXT_scene_marker",
"GL_EXT_texture_compression_dxt1", "GL_EXT_texture_compression_dxt1",
"GL_EXT_texture_env", "GL_EXT_texture_env",
"GL_IBM_static_data", "GL_IBM_static_data",
"GL_NV_gpu_program4",
"GL_OES_byte_coordinates", "GL_OES_byte_coordinates",
"GL_OES_compressed_paletted_texture", "GL_OES_compressed_paletted_texture",
"GL_OES_single_precision", "GL_OES_single_precision",
"GL_SGIX_pixel_texture_bits", "GL_SGIX_pixel_texture_bits",
"GL_SGIX_texture_range" "GL_SGIX_texture_range"
}; };
int __GLeeGLNumExtensions=322; int __GLeeGLNumExtensions=322;
/* GL_VERSION_1_2 */ /* GL_VERSION_1_2 */
#ifdef __GLEE_GL_VERSION_1_2 #ifdef __GLEE_GL_VERSION_1_2
void __stdcall _Lazy_glBlendColor(GLclampf red, GLclampf green, GLclampf bl #ifndef GLEE_C_DEFINED_glBlendColor
ue, GLclampf alpha) {if (GLeeInit()) glBlendColor(red, green, blue, alpha) #define GLEE_C_DEFINED_glBlendColor
;} void __stdcall GLee_Lazy_glBlendColor(GLclampf red, GLclampf green, GLcla
void __stdcall _Lazy_glBlendEquation(GLenum mode) mpf blue, GLclampf alpha) {if (GLeeInit()) glBlendColor(red, green, blue,
{if (GLeeInit()) glBlendEquation(mode);} alpha);}
void __stdcall _Lazy_glDrawRangeElements(GLenum mode, GLuint start, GLuint GLEEPFNGLBLENDCOLORPROC GLeeFuncPtr_glBlendColor=GLee_Lazy_glBlendColor;
end, GLsizei count, GLenum type, const GLvoid * indices) {if (GLeeInit()) #endif
glDrawRangeElements(mode, start, end, count, type, indices);} #ifndef GLEE_C_DEFINED_glBlendEquation
void __stdcall _Lazy_glColorTable(GLenum target, GLenum internalformat, GLs #define GLEE_C_DEFINED_glBlendEquation
izei width, GLenum format, GLenum type, const GLvoid * table) {if (GLeeIni void __stdcall GLee_Lazy_glBlendEquation(GLenum mode) {if (GLeeInit()) g
t()) glColorTable(target, internalformat, width, format, type, table);} lBlendEquation(mode);}
void __stdcall _Lazy_glColorTableParameterfv(GLenum target, GLenum pname, c GLEEPFNGLBLENDEQUATIONPROC GLeeFuncPtr_glBlendEquation=GLee_Lazy_glBlendE
onst GLfloat * params) {if (GLeeInit()) glColorTableParameterfv(target, pn quation;
ame, params);} #endif
void __stdcall _Lazy_glColorTableParameteriv(GLenum target, GLenum pname, c #ifndef GLEE_C_DEFINED_glDrawRangeElements
onst GLint * params) {if (GLeeInit()) glColorTableParameteriv(target, pnam #define GLEE_C_DEFINED_glDrawRangeElements
e, params);} void __stdcall GLee_Lazy_glDrawRangeElements(GLenum mode, GLuint start, G
void __stdcall _Lazy_glCopyColorTable(GLenum target, GLenum internalformat, Luint end, GLsizei count, GLenum type, const GLvoid * indices) {if (GLeeIn
GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorTable(target it()) glDrawRangeElements(mode, start, end, count, type, indices);}
, internalformat, x, y, width);} GLEEPFNGLDRAWRANGEELEMENTSPROC GLeeFuncPtr_glDrawRangeElements=GLee_Lazy_
void __stdcall _Lazy_glGetColorTable(GLenum target, GLenum format, GLenum t glDrawRangeElements;
ype, GLvoid * table) {if (GLeeInit()) glGetColorTable(target, format, type #endif
, table);} #ifndef GLEE_C_DEFINED_glColorTable
void __stdcall _Lazy_glGetColorTableParameterfv(GLenum target, GLenum pname #define GLEE_C_DEFINED_glColorTable
, GLfloat * params) {if (GLeeInit()) glGetColorTableParameterfv(target, pn void __stdcall GLee_Lazy_glColorTable(GLenum target, GLenum internalforma
ame, params);} t, GLsizei width, GLenum format, GLenum type, const GLvoid * table) {if (G
void __stdcall _Lazy_glGetColorTableParameteriv(GLenum target, GLenum pname LeeInit()) glColorTable(target, internalformat, width, format, type, table)
, GLint * params) {if (GLeeInit()) glGetColorTableParameteriv(target, pnam ;}
e, params);} GLEEPFNGLCOLORTABLEPROC GLeeFuncPtr_glColorTable=GLee_Lazy_glColorTable;
void __stdcall _Lazy_glColorSubTable(GLenum target, GLsizei start, GLsizei #endif
count, GLenum format, GLenum type, const GLvoid * data) {if (GLeeInit()) g #ifndef GLEE_C_DEFINED_glColorTableParameterfv
lColorSubTable(target, start, count, format, type, data);} #define GLEE_C_DEFINED_glColorTableParameterfv
void __stdcall _Lazy_glCopyColorSubTable(GLenum target, GLsizei start, GLin void __stdcall GLee_Lazy_glColorTableParameterfv(GLenum target, GLenum pn
t x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorSubTable(target, ame, const GLfloat * params) {if (GLeeInit()) glColorTableParameterfv(targ
start, x, y, width);} et, pname, params);}
void __stdcall _Lazy_glConvolutionFilter1D(GLenum target, GLenum internalfo GLEEPFNGLCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glColorTableParameterfv=GL
rmat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) {if ee_Lazy_glColorTableParameterfv;
(GLeeInit()) glConvolutionFilter1D(target, internalformat, width, format, #endif
type, image);} #ifndef GLEE_C_DEFINED_glColorTableParameteriv
void __stdcall _Lazy_glConvolutionFilter2D(GLenum target, GLenum internalfo #define GLEE_C_DEFINED_glColorTableParameteriv
rmat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvo void __stdcall GLee_Lazy_glColorTableParameteriv(GLenum target, GLenum pn
id * image) {if (GLeeInit()) glConvolutionFilter2D(target, internalformat, ame, const GLint * params) {if (GLeeInit()) glColorTableParameteriv(target
width, height, format, type, image);} , pname, params);}
void __stdcall _Lazy_glConvolutionParameterf(GLenum target, GLenum pname, G GLEEPFNGLCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glColorTableParameteriv=GL
Lfloat params) {if (GLeeInit()) glConvolutionParameterf(target, pname, par ee_Lazy_glColorTableParameteriv;
ams);} #endif
void __stdcall _Lazy_glConvolutionParameterfv(GLenum target, GLenum pname, #ifndef GLEE_C_DEFINED_glCopyColorTable
const GLfloat * params) {if (GLeeInit()) glConvolutionParameterfv(target, #define GLEE_C_DEFINED_glCopyColorTable
pname, params);} void __stdcall GLee_Lazy_glCopyColorTable(GLenum target, GLenum internalf
void __stdcall _Lazy_glConvolutionParameteri(GLenum target, GLenum pname, G ormat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorTable(
Lint params) {if (GLeeInit()) glConvolutionParameteri(target, pname, para target, internalformat, x, y, width);}
ms);} GLEEPFNGLCOPYCOLORTABLEPROC GLeeFuncPtr_glCopyColorTable=GLee_Lazy_glCopy
void __stdcall _Lazy_glConvolutionParameteriv(GLenum target, GLenum pname, ColorTable;
const GLint * params) {if (GLeeInit()) glConvolutionParameteriv(target, pn #endif
ame, params);} #ifndef GLEE_C_DEFINED_glGetColorTable
void __stdcall _Lazy_glCopyConvolutionFilter1D(GLenum target, GLenum intern #define GLEE_C_DEFINED_glGetColorTable
alformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyConvolut void __stdcall GLee_Lazy_glGetColorTable(GLenum target, GLenum format, GL
ionFilter1D(target, internalformat, x, y, width);} enum type, GLvoid * table) {if (GLeeInit()) glGetColorTable(target, format
void __stdcall _Lazy_glCopyConvolutionFilter2D(GLenum target, GLenum intern , type, table);}
alformat, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit() GLEEPFNGLGETCOLORTABLEPROC GLeeFuncPtr_glGetColorTable=GLee_Lazy_glGetCol
) glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);} orTable;
void __stdcall _Lazy_glGetConvolutionFilter(GLenum target, GLenum format, G #endif
Lenum type, GLvoid * image) {if (GLeeInit()) glGetConvolutionFilter(target #ifndef GLEE_C_DEFINED_glGetColorTableParameterfv
, format, type, image);} #define GLEE_C_DEFINED_glGetColorTableParameterfv
void __stdcall _Lazy_glGetConvolutionParameterfv(GLenum target, GLenum pnam void __stdcall GLee_Lazy_glGetColorTableParameterfv(GLenum target, GLenum
e, GLfloat * params) {if (GLeeInit()) glGetConvolutionParameterfv(target, pname, GLfloat * params) {if (GLeeInit()) glGetColorTableParameterfv(targ
pname, params);} et, pname, params);}
void __stdcall _Lazy_glGetConvolutionParameteriv(GLenum target, GLenum pnam GLEEPFNGLGETCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glGetColorTableParamete
e, GLint * params) {if (GLeeInit()) glGetConvolutionParameteriv(target, pn rfv=GLee_Lazy_glGetColorTableParameterfv;
ame, params);} #endif
void __stdcall _Lazy_glGetSeparableFilter(GLenum target, GLenum format, GLe #ifndef GLEE_C_DEFINED_glGetColorTableParameteriv
num type, GLvoid * row, GLvoid * column, GLvoid * span) {if (GLeeInit()) g #define GLEE_C_DEFINED_glGetColorTableParameteriv
lGetSeparableFilter(target, format, type, row, column, span);} void __stdcall GLee_Lazy_glGetColorTableParameteriv(GLenum target, GLenum
void __stdcall _Lazy_glSeparableFilter2D(GLenum target, GLenum internalform pname, GLint * params) {if (GLeeInit()) glGetColorTableParameteriv(target
at, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid , pname, params);}
* row, const GLvoid * column) {if (GLeeInit()) glSeparableFilter2D(target GLEEPFNGLGETCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glGetColorTableParamete
, internalformat, width, height, format, type, row, column);} riv=GLee_Lazy_glGetColorTableParameteriv;
void __stdcall _Lazy_glGetHistogram(GLenum target, GLboolean reset, GLenum #endif
format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetHistogram(targ #ifndef GLEE_C_DEFINED_glColorSubTable
et, reset, format, type, values);} #define GLEE_C_DEFINED_glColorSubTable
void __stdcall _Lazy_glGetHistogramParameterfv(GLenum target, GLenum pname, void __stdcall GLee_Lazy_glColorSubTable(GLenum target, GLsizei start, GL
GLfloat * params) {if (GLeeInit()) glGetHistogramParameterfv(target, pnam sizei count, GLenum format, GLenum type, const GLvoid * data) {if (GLeeIni
e, params);} t()) glColorSubTable(target, start, count, format, type, data);}
void __stdcall _Lazy_glGetHistogramParameteriv(GLenum target, GLenum pname, GLEEPFNGLCOLORSUBTABLEPROC GLeeFuncPtr_glColorSubTable=GLee_Lazy_glColorS
GLint * params) {if (GLeeInit()) glGetHistogramParameteriv(target, pname, ubTable;
params);} #endif
void __stdcall _Lazy_glGetMinmax(GLenum target, GLboolean reset, GLenum for #ifndef GLEE_C_DEFINED_glCopyColorSubTable
mat, GLenum type, GLvoid * values) {if (GLeeInit()) glGetMinmax(target, re #define GLEE_C_DEFINED_glCopyColorSubTable
set, format, type, values);} void __stdcall GLee_Lazy_glCopyColorSubTable(GLenum target, GLsizei start
void __stdcall _Lazy_glGetMinmaxParameterfv(GLenum target, GLenum pname, GL , GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorSubTable(ta
float * params) {if (GLeeInit()) glGetMinmaxParameterfv(target, pname, par rget, start, x, y, width);}
ams);} GLEEPFNGLCOPYCOLORSUBTABLEPROC GLeeFuncPtr_glCopyColorSubTable=GLee_Lazy_
void __stdcall _Lazy_glGetMinmaxParameteriv(GLenum target, GLenum pname, GL glCopyColorSubTable;
int * params) {if (GLeeInit()) glGetMinmaxParameteriv(target, pname, param #endif
s);} #ifndef GLEE_C_DEFINED_glConvolutionFilter1D
void __stdcall _Lazy_glHistogram(GLenum target, GLsizei width, GLenum inter #define GLEE_C_DEFINED_glConvolutionFilter1D
nalformat, GLboolean sink) {if (GLeeInit()) glHistogram(target, width, int void __stdcall GLee_Lazy_glConvolutionFilter1D(GLenum target, GLenum inte
ernalformat, sink);} rnalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image
void __stdcall _Lazy_glMinmax(GLenum target, GLenum internalformat, GLboole ) {if (GLeeInit()) glConvolutionFilter1D(target, internalformat, width, fo
an sink) {if (GLeeInit()) glMinmax(target, internalformat, sink);} rmat, type, image);}
void __stdcall _Lazy_glResetHistogram(GLenum target) GLEEPFNGLCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glConvolutionFilter1D=GLee_L
{if (GLeeInit()) glResetHistogram(target);} azy_glConvolutionFilter1D;
void __stdcall _Lazy_glResetMinmax(GLenum target) #endif
{if (GLeeInit()) glResetMinmax(target);} #ifndef GLEE_C_DEFINED_glConvolutionFilter2D
void __stdcall _Lazy_glTexImage3D(GLenum target, GLint level, GLint interna #define GLEE_C_DEFINED_glConvolutionFilter2D
lformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum void __stdcall GLee_Lazy_glConvolutionFilter2D(GLenum target, GLenum inte
format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexImage3D rnalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, cons
(target, level, internalformat, width, height, depth, border, format, type, t GLvoid * image) {if (GLeeInit()) glConvolutionFilter2D(target, internalf
pixels);} ormat, width, height, format, type, image);}
void __stdcall _Lazy_glTexSubImage3D(GLenum target, GLint level, GLint xoff GLEEPFNGLCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glConvolutionFilter2D=GLee_L
set, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei d azy_glConvolutionFilter2D;
epth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) #endif
glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, de #ifndef GLEE_C_DEFINED_glConvolutionParameterf
pth, format, type, pixels);} #define GLEE_C_DEFINED_glConvolutionParameterf
void __stdcall _Lazy_glCopyTexSubImage3D(GLenum target, GLint level, GLint void __stdcall GLee_Lazy_glConvolutionParameterf(GLenum target, GLenum pn
xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLs ame, GLfloat params) {if (GLeeInit()) glConvolutionParameterf(target, pnam
izei height) {if (GLeeInit()) glCopyTexSubImage3D(target, level, xoffset, e, params);}
yoffset, zoffset, x, y, width, height);} GLEEPFNGLCONVOLUTIONPARAMETERFPROC GLeeFuncPtr_glConvolutionParameterf=GL
PFNGLBLENDCOLORPROC pglBlendColor=_Lazy_glBlendColor; ee_Lazy_glConvolutionParameterf;
PFNGLBLENDEQUATIONPROC pglBlendEquation=_Lazy_glBlendEquation; #endif
PFNGLDRAWRANGEELEMENTSPROC pglDrawRangeElements=_Lazy_glDrawRangeElements; #ifndef GLEE_C_DEFINED_glConvolutionParameterfv
PFNGLCOLORTABLEPROC pglColorTable=_Lazy_glColorTable; #define GLEE_C_DEFINED_glConvolutionParameterfv
PFNGLCOLORTABLEPARAMETERFVPROC pglColorTableParameterfv=_Lazy_glColorTableP void __stdcall GLee_Lazy_glConvolutionParameterfv(GLenum target, GLenum p
arameterfv; name, const GLfloat * params) {if (GLeeInit()) glConvolutionParameterfv(ta
PFNGLCOLORTABLEPARAMETERIVPROC pglColorTableParameteriv=_Lazy_glColorTableP rget, pname, params);}
arameteriv; GLEEPFNGLCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glConvolutionParameterfv=
PFNGLCOPYCOLORTABLEPROC pglCopyColorTable=_Lazy_glCopyColorTable; GLee_Lazy_glConvolutionParameterfv;
PFNGLGETCOLORTABLEPROC pglGetColorTable=_Lazy_glGetColorTable; #endif
PFNGLGETCOLORTABLEPARAMETERFVPROC pglGetColorTableParameterfv=_Lazy_glGetCo #ifndef GLEE_C_DEFINED_glConvolutionParameteri
lorTableParameterfv; #define GLEE_C_DEFINED_glConvolutionParameteri
PFNGLGETCOLORTABLEPARAMETERIVPROC pglGetColorTableParameteriv=_Lazy_glGetCo void __stdcall GLee_Lazy_glConvolutionParameteri(GLenum target, GLenum pn
lorTableParameteriv; ame, GLint params) {if (GLeeInit()) glConvolutionParameteri(target, pname,
PFNGLCOLORSUBTABLEPROC pglColorSubTable=_Lazy_glColorSubTable; params);}
PFNGLCOPYCOLORSUBTABLEPROC pglCopyColorSubTable=_Lazy_glCopyColorSubTable; GLEEPFNGLCONVOLUTIONPARAMETERIPROC GLeeFuncPtr_glConvolutionParameteri=GL
PFNGLCONVOLUTIONFILTER1DPROC pglConvolutionFilter1D=_Lazy_glConvolutionFilt ee_Lazy_glConvolutionParameteri;
er1D; #endif
PFNGLCONVOLUTIONFILTER2DPROC pglConvolutionFilter2D=_Lazy_glConvolutionFilt #ifndef GLEE_C_DEFINED_glConvolutionParameteriv
er2D; #define GLEE_C_DEFINED_glConvolutionParameteriv
PFNGLCONVOLUTIONPARAMETERFPROC pglConvolutionParameterf=_Lazy_glConvolution void __stdcall GLee_Lazy_glConvolutionParameteriv(GLenum target, GLenum p
Parameterf; name, const GLint * params) {if (GLeeInit()) glConvolutionParameteriv(targ
PFNGLCONVOLUTIONPARAMETERFVPROC pglConvolutionParameterfv=_Lazy_glConvoluti et, pname, params);}
onParameterfv; GLEEPFNGLCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glConvolutionParameteriv=
PFNGLCONVOLUTIONPARAMETERIPROC pglConvolutionParameteri=_Lazy_glConvolution GLee_Lazy_glConvolutionParameteriv;
Parameteri; #endif
PFNGLCONVOLUTIONPARAMETERIVPROC pglConvolutionParameteriv=_Lazy_glConvoluti #ifndef GLEE_C_DEFINED_glCopyConvolutionFilter1D
onParameteriv; #define GLEE_C_DEFINED_glCopyConvolutionFilter1D
PFNGLCOPYCONVOLUTIONFILTER1DPROC pglCopyConvolutionFilter1D=_Lazy_glCopyCon void __stdcall GLee_Lazy_glCopyConvolutionFilter1D(GLenum target, GLenum
volutionFilter1D; internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyCo
PFNGLCOPYCONVOLUTIONFILTER2DPROC pglCopyConvolutionFilter2D=_Lazy_glCopyCon nvolutionFilter1D(target, internalformat, x, y, width);}
volutionFilter2D; GLEEPFNGLCOPYCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glCopyConvolutionFilter1
PFNGLGETCONVOLUTIONFILTERPROC pglGetConvolutionFilter=_Lazy_glGetConvolutio D=GLee_Lazy_glCopyConvolutionFilter1D;
nFilter; #endif
PFNGLGETCONVOLUTIONPARAMETERFVPROC pglGetConvolutionParameterfv=_Lazy_glGet #ifndef GLEE_C_DEFINED_glCopyConvolutionFilter2D
ConvolutionParameterfv; #define GLEE_C_DEFINED_glCopyConvolutionFilter2D
PFNGLGETCONVOLUTIONPARAMETERIVPROC pglGetConvolutionParameteriv=_Lazy_glGet void __stdcall GLee_Lazy_glCopyConvolutionFilter2D(GLenum target, GLenum
ConvolutionParameteriv; internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLee
PFNGLGETSEPARABLEFILTERPROC pglGetSeparableFilter=_Lazy_glGetSeparableFilte Init()) glCopyConvolutionFilter2D(target, internalformat, x, y, width, heig
r; ht);}
PFNGLSEPARABLEFILTER2DPROC pglSeparableFilter2D=_Lazy_glSeparableFilter2D; GLEEPFNGLCOPYCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glCopyConvolutionFilter2
PFNGLGETHISTOGRAMPROC pglGetHistogram=_Lazy_glGetHistogram; D=GLee_Lazy_glCopyConvolutionFilter2D;
PFNGLGETHISTOGRAMPARAMETERFVPROC pglGetHistogramParameterfv=_Lazy_glGetHist #endif
ogramParameterfv; #ifndef GLEE_C_DEFINED_glGetConvolutionFilter
PFNGLGETHISTOGRAMPARAMETERIVPROC pglGetHistogramParameteriv=_Lazy_glGetHist #define GLEE_C_DEFINED_glGetConvolutionFilter
ogramParameteriv; void __stdcall GLee_Lazy_glGetConvolutionFilter(GLenum target, GLenum for
PFNGLGETMINMAXPROC pglGetMinmax=_Lazy_glGetMinmax; mat, GLenum type, GLvoid * image) {if (GLeeInit()) glGetConvolutionFilter(
PFNGLGETMINMAXPARAMETERFVPROC pglGetMinmaxParameterfv=_Lazy_glGetMinmaxPara target, format, type, image);}
meterfv; GLEEPFNGLGETCONVOLUTIONFILTERPROC GLeeFuncPtr_glGetConvolutionFilter=GLee
PFNGLGETMINMAXPARAMETERIVPROC pglGetMinmaxParameteriv=_Lazy_glGetMinmaxPara _Lazy_glGetConvolutionFilter;
meteriv; #endif
PFNGLHISTOGRAMPROC pglHistogram=_Lazy_glHistogram; #ifndef GLEE_C_DEFINED_glGetConvolutionParameterfv
PFNGLMINMAXPROC pglMinmax=_Lazy_glMinmax; #define GLEE_C_DEFINED_glGetConvolutionParameterfv
PFNGLRESETHISTOGRAMPROC pglResetHistogram=_Lazy_glResetHistogram; void __stdcall GLee_Lazy_glGetConvolutionParameterfv(GLenum target, GLenu
PFNGLRESETMINMAXPROC pglResetMinmax=_Lazy_glResetMinmax; m pname, GLfloat * params) {if (GLeeInit()) glGetConvolutionParameterfv(ta
PFNGLTEXIMAGE3DPROC pglTexImage3D=_Lazy_glTexImage3D; rget, pname, params);}
PFNGLTEXSUBIMAGE3DPROC pglTexSubImage3D=_Lazy_glTexSubImage3D; GLEEPFNGLGETCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glGetConvolutionParame
PFNGLCOPYTEXSUBIMAGE3DPROC pglCopyTexSubImage3D=_Lazy_glCopyTexSubImage3D; terfv=GLee_Lazy_glGetConvolutionParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameteriv
#define GLEE_C_DEFINED_glGetConvolutionParameteriv
void __stdcall GLee_Lazy_glGetConvolutionParameteriv(GLenum target, GLenu
m pname, GLint * params) {if (GLeeInit()) glGetConvolutionParameteriv(targ
et, pname, params);}
GLEEPFNGLGETCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glGetConvolutionParame
teriv=GLee_Lazy_glGetConvolutionParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetSeparableFilter
#define GLEE_C_DEFINED_glGetSeparableFilter
void __stdcall GLee_Lazy_glGetSeparableFilter(GLenum target, GLenum forma
t, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) {if (GLeeIni
t()) glGetSeparableFilter(target, format, type, row, column, span);}
GLEEPFNGLGETSEPARABLEFILTERPROC GLeeFuncPtr_glGetSeparableFilter=GLee_Laz
y_glGetSeparableFilter;
#endif
#ifndef GLEE_C_DEFINED_glSeparableFilter2D
#define GLEE_C_DEFINED_glSeparableFilter2D
void __stdcall GLee_Lazy_glSeparableFilter2D(GLenum target, GLenum intern
alformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const
GLvoid * row, const GLvoid * column) {if (GLeeInit()) glSeparableFilter2D(
target, internalformat, width, height, format, type, row, column);}
GLEEPFNGLSEPARABLEFILTER2DPROC GLeeFuncPtr_glSeparableFilter2D=GLee_Lazy_
glSeparableFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogram
#define GLEE_C_DEFINED_glGetHistogram
void __stdcall GLee_Lazy_glGetHistogram(GLenum target, GLboolean reset, G
Lenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetHistogra
m(target, reset, format, type, values);}
GLEEPFNGLGETHISTOGRAMPROC GLeeFuncPtr_glGetHistogram=GLee_Lazy_glGetHisto
gram;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterfv
#define GLEE_C_DEFINED_glGetHistogramParameterfv
void __stdcall GLee_Lazy_glGetHistogramParameterfv(GLenum target, GLenum
pname, GLfloat * params) {if (GLeeInit()) glGetHistogramParameterfv(target
, pname, params);}
GLEEPFNGLGETHISTOGRAMPARAMETERFVPROC GLeeFuncPtr_glGetHistogramParameterf
v=GLee_Lazy_glGetHistogramParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameteriv
#define GLEE_C_DEFINED_glGetHistogramParameteriv
void __stdcall GLee_Lazy_glGetHistogramParameteriv(GLenum target, GLenum
pname, GLint * params) {if (GLeeInit()) glGetHistogramParameteriv(target,
pname, params);}
GLEEPFNGLGETHISTOGRAMPARAMETERIVPROC GLeeFuncPtr_glGetHistogramParameteri
v=GLee_Lazy_glGetHistogramParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmax
#define GLEE_C_DEFINED_glGetMinmax
void __stdcall GLee_Lazy_glGetMinmax(GLenum target, GLboolean reset, GLen
um format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetMinmax(targ
et, reset, format, type, values);}
GLEEPFNGLGETMINMAXPROC GLeeFuncPtr_glGetMinmax=GLee_Lazy_glGetMinmax;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterfv
#define GLEE_C_DEFINED_glGetMinmaxParameterfv
void __stdcall GLee_Lazy_glGetMinmaxParameterfv(GLenum target, GLenum pna
me, GLfloat * params) {if (GLeeInit()) glGetMinmaxParameterfv(target, pnam
e, params);}
GLEEPFNGLGETMINMAXPARAMETERFVPROC GLeeFuncPtr_glGetMinmaxParameterfv=GLee
_Lazy_glGetMinmaxParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameteriv
#define GLEE_C_DEFINED_glGetMinmaxParameteriv
void __stdcall GLee_Lazy_glGetMinmaxParameteriv(GLenum target, GLenum pna
me, GLint * params) {if (GLeeInit()) glGetMinmaxParameteriv(target, pname,
params);}
GLEEPFNGLGETMINMAXPARAMETERIVPROC GLeeFuncPtr_glGetMinmaxParameteriv=GLee
_Lazy_glGetMinmaxParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glHistogram
#define GLEE_C_DEFINED_glHistogram
void __stdcall GLee_Lazy_glHistogram(GLenum target, GLsizei width, GLenum
internalformat, GLboolean sink) {if (GLeeInit()) glHistogram(target, widt
h, internalformat, sink);}
GLEEPFNGLHISTOGRAMPROC GLeeFuncPtr_glHistogram=GLee_Lazy_glHistogram;
#endif
#ifndef GLEE_C_DEFINED_glMinmax
#define GLEE_C_DEFINED_glMinmax
void __stdcall GLee_Lazy_glMinmax(GLenum target, GLenum internalformat, G
Lboolean sink) {if (GLeeInit()) glMinmax(target, internalformat, sink);}
GLEEPFNGLMINMAXPROC GLeeFuncPtr_glMinmax=GLee_Lazy_glMinmax;
#endif
#ifndef GLEE_C_DEFINED_glResetHistogram
#define GLEE_C_DEFINED_glResetHistogram
void __stdcall GLee_Lazy_glResetHistogram(GLenum target) {if (GLeeInit()
) glResetHistogram(target);}
GLEEPFNGLRESETHISTOGRAMPROC GLeeFuncPtr_glResetHistogram=GLee_Lazy_glRese
tHistogram;
#endif
#ifndef GLEE_C_DEFINED_glResetMinmax
#define GLEE_C_DEFINED_glResetMinmax
void __stdcall GLee_Lazy_glResetMinmax(GLenum target) {if (GLeeInit()) g
lResetMinmax(target);}
GLEEPFNGLRESETMINMAXPROC GLeeFuncPtr_glResetMinmax=GLee_Lazy_glResetMinma
x;
#endif
#ifndef GLEE_C_DEFINED_glTexImage3D
#define GLEE_C_DEFINED_glTexImage3D
void __stdcall GLee_Lazy_glTexImage3D(GLenum target, GLint level, GLint i
nternalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border,
GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexI
mage3D(target, level, internalformat, width, height, depth, border, format,
type, pixels);}
GLEEPFNGLTEXIMAGE3DPROC GLeeFuncPtr_glTexImage3D=GLee_Lazy_glTexImage3D;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage3D
#define GLEE_C_DEFINED_glTexSubImage3D
void __stdcall GLee_Lazy_glTexSubImage3D(GLenum target, GLint level, GLin
t xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLs
izei depth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeIn
it()) glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, heig
ht, depth, format, type, pixels);}
GLEEPFNGLTEXSUBIMAGE3DPROC GLeeFuncPtr_glTexSubImage3D=GLee_Lazy_glTexSub
Image3D;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage3D
#define GLEE_C_DEFINED_glCopyTexSubImage3D
void __stdcall GLee_Lazy_glCopyTexSubImage3D(GLenum target, GLint level,
GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei widt
h, GLsizei height) {if (GLeeInit()) glCopyTexSubImage3D(target, level, xof
fset, yoffset, zoffset, x, y, width, height);}
GLEEPFNGLCOPYTEXSUBIMAGE3DPROC GLeeFuncPtr_glCopyTexSubImage3D=GLee_Lazy_
glCopyTexSubImage3D;
#endif
#endif #endif
/* GL_ARB_imaging */ /* GL_ARB_imaging */
#ifdef __GLEE_GL_ARB_imaging #ifdef __GLEE_GL_ARB_imaging
#endif #endif
/* GL_VERSION_1_3 */ /* GL_VERSION_1_3 */
#ifdef __GLEE_GL_VERSION_1_3 #ifdef __GLEE_GL_VERSION_1_3
void __stdcall _Lazy_glActiveTexture(GLenum texture) #ifndef GLEE_C_DEFINED_glActiveTexture
{if (GLeeInit()) glActiveTexture(texture);} #define GLEE_C_DEFINED_glActiveTexture
void __stdcall _Lazy_glClientActiveTexture(GLenum texture) void __stdcall GLee_Lazy_glActiveTexture(GLenum texture) {if (GLeeInit()
{if (GLeeInit()) glClientActiveTexture(texture);} ) glActiveTexture(texture);}
void __stdcall _Lazy_glMultiTexCoord1d(GLenum target, GLdouble s) GLEEPFNGLACTIVETEXTUREPROC GLeeFuncPtr_glActiveTexture=GLee_Lazy_glActive
{if (GLeeInit()) glMultiTexCoord1d(target, s);} Texture;
void __stdcall _Lazy_glMultiTexCoord1dv(GLenum target, const GLdouble * v) #endif
{if (GLeeInit()) glMultiTexCoord1dv(target, v);} #ifndef GLEE_C_DEFINED_glClientActiveTexture
void __stdcall _Lazy_glMultiTexCoord1f(GLenum target, GLfloat s) #define GLEE_C_DEFINED_glClientActiveTexture
{if (GLeeInit()) glMultiTexCoord1f(target, s);} void __stdcall GLee_Lazy_glClientActiveTexture(GLenum texture) {if (GLee
void __stdcall _Lazy_glMultiTexCoord1fv(GLenum target, const GLfloat * v) Init()) glClientActiveTexture(texture);}
{if (GLeeInit()) glMultiTexCoord1fv(target, v);} GLEEPFNGLCLIENTACTIVETEXTUREPROC GLeeFuncPtr_glClientActiveTexture=GLee_L
void __stdcall _Lazy_glMultiTexCoord1i(GLenum target, GLint s) azy_glClientActiveTexture;
{if (GLeeInit()) glMultiTexCoord1i(target, s);} #endif
void __stdcall _Lazy_glMultiTexCoord1iv(GLenum target, const GLint * v) #ifndef GLEE_C_DEFINED_glMultiTexCoord1d
{if (GLeeInit()) glMultiTexCoord1iv(target, v);} #define GLEE_C_DEFINED_glMultiTexCoord1d
void __stdcall _Lazy_glMultiTexCoord1s(GLenum target, GLshort s) void __stdcall GLee_Lazy_glMultiTexCoord1d(GLenum target, GLdouble s) {i
{if (GLeeInit()) glMultiTexCoord1s(target, s);} f (GLeeInit()) glMultiTexCoord1d(target, s);}
void __stdcall _Lazy_glMultiTexCoord1sv(GLenum target, const GLshort * v) GLEEPFNGLMULTITEXCOORD1DPROC GLeeFuncPtr_glMultiTexCoord1d=GLee_Lazy_glMu
{if (GLeeInit()) glMultiTexCoord1sv(target, v);} ltiTexCoord1d;
void __stdcall _Lazy_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble #endif
t) {if (GLeeInit()) glMultiTexCoord2d(target, s, t);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1dv
void __stdcall _Lazy_glMultiTexCoord2dv(GLenum target, const GLdouble * v) #define GLEE_C_DEFINED_glMultiTexCoord1dv
{if (GLeeInit()) glMultiTexCoord2dv(target, v);} void __stdcall GLee_Lazy_glMultiTexCoord1dv(GLenum target, const GLdouble
void __stdcall _Lazy_glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) * v) {if (GLeeInit()) glMultiTexCoord1dv(target, v);}
{if (GLeeInit()) glMultiTexCoord2f(target, s, t);} GLEEPFNGLMULTITEXCOORD1DVPROC GLeeFuncPtr_glMultiTexCoord1dv=GLee_Lazy_gl
void __stdcall _Lazy_glMultiTexCoord2fv(GLenum target, const GLfloat * v) MultiTexCoord1dv;
{if (GLeeInit()) glMultiTexCoord2fv(target, v);} #endif
void __stdcall _Lazy_glMultiTexCoord2i(GLenum target, GLint s, GLint t) #ifndef GLEE_C_DEFINED_glMultiTexCoord1f
{if (GLeeInit()) glMultiTexCoord2i(target, s, t);} #define GLEE_C_DEFINED_glMultiTexCoord1f
void __stdcall _Lazy_glMultiTexCoord2iv(GLenum target, const GLint * v) void __stdcall GLee_Lazy_glMultiTexCoord1f(GLenum target, GLfloat s) {if
{if (GLeeInit()) glMultiTexCoord2iv(target, v);} (GLeeInit()) glMultiTexCoord1f(target, s);}
void __stdcall _Lazy_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) GLEEPFNGLMULTITEXCOORD1FPROC GLeeFuncPtr_glMultiTexCoord1f=GLee_Lazy_glMu
{if (GLeeInit()) glMultiTexCoord2s(target, s, t);} ltiTexCoord1f;
void __stdcall _Lazy_glMultiTexCoord2sv(GLenum target, const GLshort * v) #endif
{if (GLeeInit()) glMultiTexCoord2sv(target, v);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1fv
void __stdcall _Lazy_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble #define GLEE_C_DEFINED_glMultiTexCoord1fv
t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3d(target, s, t, r);} void __stdcall GLee_Lazy_glMultiTexCoord1fv(GLenum target, const GLfloat
void __stdcall _Lazy_glMultiTexCoord3dv(GLenum target, const GLdouble * v) * v) {if (GLeeInit()) glMultiTexCoord1fv(target, v);}
{if (GLeeInit()) glMultiTexCoord3dv(target, v);} GLEEPFNGLMULTITEXCOORD1FVPROC GLeeFuncPtr_glMultiTexCoord1fv=GLee_Lazy_gl
void __stdcall _Lazy_glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, MultiTexCoord1fv;
GLfloat r) {if (GLeeInit()) glMultiTexCoord3f(target, s, t, r);} #endif
void __stdcall _Lazy_glMultiTexCoord3fv(GLenum target, const GLfloat * v) #ifndef GLEE_C_DEFINED_glMultiTexCoord1i
{if (GLeeInit()) glMultiTexCoord3fv(target, v);} #define GLEE_C_DEFINED_glMultiTexCoord1i
void __stdcall _Lazy_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLi void __stdcall GLee_Lazy_glMultiTexCoord1i(GLenum target, GLint s) {if (
nt r) {if (GLeeInit()) glMultiTexCoord3i(target, s, t, r);} GLeeInit()) glMultiTexCoord1i(target, s);}
void __stdcall _Lazy_glMultiTexCoord3iv(GLenum target, const GLint * v) GLEEPFNGLMULTITEXCOORD1IPROC GLeeFuncPtr_glMultiTexCoord1i=GLee_Lazy_glMu
{if (GLeeInit()) glMultiTexCoord3iv(target, v);} ltiTexCoord1i;
void __stdcall _Lazy_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, #endif
GLshort r) {if (GLeeInit()) glMultiTexCoord3s(target, s, t, r);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1iv
void __stdcall _Lazy_glMultiTexCoord3sv(GLenum target, const GLshort * v) #define GLEE_C_DEFINED_glMultiTexCoord1iv
{if (GLeeInit()) glMultiTexCoord3sv(target, v);} void __stdcall GLee_Lazy_glMultiTexCoord1iv(GLenum target, const GLint *
void __stdcall _Lazy_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble v) {if (GLeeInit()) glMultiTexCoord1iv(target, v);}
t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4d(target, s, t GLEEPFNGLMULTITEXCOORD1IVPROC GLeeFuncPtr_glMultiTexCoord1iv=GLee_Lazy_gl
, r, q);} MultiTexCoord1iv;
void __stdcall _Lazy_glMultiTexCoord4dv(GLenum target, const GLdouble * v) #endif
{if (GLeeInit()) glMultiTexCoord4dv(target, v);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1s
void __stdcall _Lazy_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, #define GLEE_C_DEFINED_glMultiTexCoord1s
GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4f(target, s, t, r, void __stdcall GLee_Lazy_glMultiTexCoord1s(GLenum target, GLshort s) {if
q);} (GLeeInit()) glMultiTexCoord1s(target, s);}
void __stdcall _Lazy_glMultiTexCoord4fv(GLenum target, const GLfloat * v) GLEEPFNGLMULTITEXCOORD1SPROC GLeeFuncPtr_glMultiTexCoord1s=GLee_Lazy_glMu
{if (GLeeInit()) glMultiTexCoord4fv(target, v);} ltiTexCoord1s;
void __stdcall _Lazy_glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLi #endif
nt r, GLint q) {if (GLeeInit()) glMultiTexCoord4i(target, s, t, r, q);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1sv
void __stdcall _Lazy_glMultiTexCoord4iv(GLenum target, const GLint * v) #define GLEE_C_DEFINED_glMultiTexCoord1sv
{if (GLeeInit()) glMultiTexCoord4iv(target, v);} void __stdcall GLee_Lazy_glMultiTexCoord1sv(GLenum target, const GLshort
void __stdcall _Lazy_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, * v) {if (GLeeInit()) glMultiTexCoord1sv(target, v);}
GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4s(target, s, t, r, GLEEPFNGLMULTITEXCOORD1SVPROC GLeeFuncPtr_glMultiTexCoord1sv=GLee_Lazy_gl
q);} MultiTexCoord1sv;
void __stdcall _Lazy_glMultiTexCoord4sv(GLenum target, const GLshort * v) #endif
{if (GLeeInit()) glMultiTexCoord4sv(target, v);} #ifndef GLEE_C_DEFINED_glMultiTexCoord2d
void __stdcall _Lazy_glLoadTransposeMatrixf(const GLfloat * m) #define GLEE_C_DEFINED_glMultiTexCoord2d
{if (GLeeInit()) glLoadTransposeMatrixf(m);} void __stdcall GLee_Lazy_glMultiTexCoord2d(GLenum target, GLdouble s, GLd
void __stdcall _Lazy_glLoadTransposeMatrixd(const GLdouble * m) ouble t) {if (GLeeInit()) glMultiTexCoord2d(target, s, t);}
{if (GLeeInit()) glLoadTransposeMatrixd(m);} GLEEPFNGLMULTITEXCOORD2DPROC GLeeFuncPtr_glMultiTexCoord2d=GLee_Lazy_glMu
void __stdcall _Lazy_glMultTransposeMatrixf(const GLfloat * m) ltiTexCoord2d;
{if (GLeeInit()) glMultTransposeMatrixf(m);} #endif
void __stdcall _Lazy_glMultTransposeMatrixd(const GLdouble * m) #ifndef GLEE_C_DEFINED_glMultiTexCoord2dv
{if (GLeeInit()) glMultTransposeMatrixd(m);} #define GLEE_C_DEFINED_glMultiTexCoord2dv
void __stdcall _Lazy_glSampleCoverage(GLclampf value, GLboolean invert) void __stdcall GLee_Lazy_glMultiTexCoord2dv(GLenum target, const GLdouble
{if (GLeeInit()) glSampleCoverage(value, invert);} * v) {if (GLeeInit()) glMultiTexCoord2dv(target, v);}
void __stdcall _Lazy_glCompressedTexImage3D(GLenum target, GLint level, GLe GLEEPFNGLMULTITEXCOORD2DVPROC GLeeFuncPtr_glMultiTexCoord2dv=GLee_Lazy_gl
num internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint bor MultiTexCoord2dv;
der, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressed #endif
TexImage3D(target, level, internalformat, width, height, depth, border, ima #ifndef GLEE_C_DEFINED_glMultiTexCoord2f
geSize, data);} #define GLEE_C_DEFINED_glMultiTexCoord2f
void __stdcall _Lazy_glCompressedTexImage2D(GLenum target, GLint level, GLe void __stdcall GLee_Lazy_glMultiTexCoord2f(GLenum target, GLfloat s, GLfl
num internalformat, GLsizei width, GLsizei height, GLint border, GLsizei im oat t) {if (GLeeInit()) glMultiTexCoord2f(target, s, t);}
ageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage2D(targ GLEEPFNGLMULTITEXCOORD2FPROC GLeeFuncPtr_glMultiTexCoord2f=GLee_Lazy_glMu
et, level, internalformat, width, height, border, imageSize, data);} ltiTexCoord2f;
void __stdcall _Lazy_glCompressedTexImage1D(GLenum target, GLint level, GLe #endif
num internalformat, GLsizei width, GLint border, GLsizei imageSize, const G #ifndef GLEE_C_DEFINED_glMultiTexCoord2fv
Lvoid * data) {if (GLeeInit()) glCompressedTexImage1D(target, level, inter #define GLEE_C_DEFINED_glMultiTexCoord2fv
nalformat, width, border, imageSize, data);} void __stdcall GLee_Lazy_glMultiTexCoord2fv(GLenum target, const GLfloat
void __stdcall _Lazy_glCompressedTexSubImage3D(GLenum target, GLint level, * v) {if (GLeeInit()) glMultiTexCoord2fv(target, v);}
GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLEEPFNGLMULTITEXCOORD2FVPROC GLeeFuncPtr_glMultiTexCoord2fv=GLee_Lazy_gl
GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) {if MultiTexCoord2fv;
(GLeeInit()) glCompressedTexSubImage3D(target, level, xoffset, yoffset, zo #endif
ffset, width, height, depth, format, imageSize, data);} #ifndef GLEE_C_DEFINED_glMultiTexCoord2i
void __stdcall _Lazy_glCompressedTexSubImage2D(GLenum target, GLint level, #define GLEE_C_DEFINED_glMultiTexCoord2i
GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, void __stdcall GLee_Lazy_glMultiTexCoord2i(GLenum target, GLint s, GLint
GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexS t) {if (GLeeInit()) glMultiTexCoord2i(target, s, t);}
ubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize GLEEPFNGLMULTITEXCOORD2IPROC GLeeFuncPtr_glMultiTexCoord2i=GLee_Lazy_glMu
, data);} ltiTexCoord2i;
void __stdcall _Lazy_glCompressedTexSubImage1D(GLenum target, GLint level, #endif
GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoi #ifndef GLEE_C_DEFINED_glMultiTexCoord2iv
d * data) {if (GLeeInit()) glCompressedTexSubImage1D(target, level, xoffse #define GLEE_C_DEFINED_glMultiTexCoord2iv
t, width, format, imageSize, data);} void __stdcall GLee_Lazy_glMultiTexCoord2iv(GLenum target, const GLint *
void __stdcall _Lazy_glGetCompressedTexImage(GLenum target, GLint level, GL v) {if (GLeeInit()) glMultiTexCoord2iv(target, v);}
void * img) {if (GLeeInit()) glGetCompressedTexImage(target, level, img) GLEEPFNGLMULTITEXCOORD2IVPROC GLeeFuncPtr_glMultiTexCoord2iv=GLee_Lazy_gl
;} MultiTexCoord2iv;
PFNGLACTIVETEXTUREPROC pglActiveTexture=_Lazy_glActiveTexture; #endif
PFNGLCLIENTACTIVETEXTUREPROC pglClientActiveTexture=_Lazy_glClientActiveTex #ifndef GLEE_C_DEFINED_glMultiTexCoord2s
ture; #define GLEE_C_DEFINED_glMultiTexCoord2s
PFNGLMULTITEXCOORD1DPROC pglMultiTexCoord1d=_Lazy_glMultiTexCoord1d; void __stdcall GLee_Lazy_glMultiTexCoord2s(GLenum target, GLshort s, GLsh
PFNGLMULTITEXCOORD1DVPROC pglMultiTexCoord1dv=_Lazy_glMultiTexCoord1dv; ort t) {if (GLeeInit()) glMultiTexCoord2s(target, s, t);}
PFNGLMULTITEXCOORD1FPROC pglMultiTexCoord1f=_Lazy_glMultiTexCoord1f; GLEEPFNGLMULTITEXCOORD2SPROC GLeeFuncPtr_glMultiTexCoord2s=GLee_Lazy_glMu
PFNGLMULTITEXCOORD1FVPROC pglMultiTexCoord1fv=_Lazy_glMultiTexCoord1fv; ltiTexCoord2s;
PFNGLMULTITEXCOORD1IPROC pglMultiTexCoord1i=_Lazy_glMultiTexCoord1i; #endif
PFNGLMULTITEXCOORD1IVPROC pglMultiTexCoord1iv=_Lazy_glMultiTexCoord1iv; #ifndef GLEE_C_DEFINED_glMultiTexCoord2sv
PFNGLMULTITEXCOORD1SPROC pglMultiTexCoord1s=_Lazy_glMultiTexCoord1s; #define GLEE_C_DEFINED_glMultiTexCoord2sv
PFNGLMULTITEXCOORD1SVPROC pglMultiTexCoord1sv=_Lazy_glMultiTexCoord1sv; void __stdcall GLee_Lazy_glMultiTexCoord2sv(GLenum target, const GLshort
PFNGLMULTITEXCOORD2DPROC pglMultiTexCoord2d=_Lazy_glMultiTexCoord2d; * v) {if (GLeeInit()) glMultiTexCoord2sv(target, v);}
PFNGLMULTITEXCOORD2DVPROC pglMultiTexCoord2dv=_Lazy_glMultiTexCoord2dv; GLEEPFNGLMULTITEXCOORD2SVPROC GLeeFuncPtr_glMultiTexCoord2sv=GLee_Lazy_gl
PFNGLMULTITEXCOORD2FPROC pglMultiTexCoord2f=_Lazy_glMultiTexCoord2f; MultiTexCoord2sv;
PFNGLMULTITEXCOORD2FVPROC pglMultiTexCoord2fv=_Lazy_glMultiTexCoord2fv; #endif
PFNGLMULTITEXCOORD2IPROC pglMultiTexCoord2i=_Lazy_glMultiTexCoord2i; #ifndef GLEE_C_DEFINED_glMultiTexCoord3d
PFNGLMULTITEXCOORD2IVPROC pglMultiTexCoord2iv=_Lazy_glMultiTexCoord2iv; #define GLEE_C_DEFINED_glMultiTexCoord3d
PFNGLMULTITEXCOORD2SPROC pglMultiTexCoord2s=_Lazy_glMultiTexCoord2s; void __stdcall GLee_Lazy_glMultiTexCoord3d(GLenum target, GLdouble s, GLd
PFNGLMULTITEXCOORD2SVPROC pglMultiTexCoord2sv=_Lazy_glMultiTexCoord2sv; ouble t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3d(target, s, t, r);}
PFNGLMULTITEXCOORD3DPROC pglMultiTexCoord3d=_Lazy_glMultiTexCoord3d; GLEEPFNGLMULTITEXCOORD3DPROC GLeeFuncPtr_glMultiTexCoord3d=GLee_Lazy_glMu
PFNGLMULTITEXCOORD3DVPROC pglMultiTexCoord3dv=_Lazy_glMultiTexCoord3dv; ltiTexCoord3d;
PFNGLMULTITEXCOORD3FPROC pglMultiTexCoord3f=_Lazy_glMultiTexCoord3f; #endif
PFNGLMULTITEXCOORD3FVPROC pglMultiTexCoord3fv=_Lazy_glMultiTexCoord3fv; #ifndef GLEE_C_DEFINED_glMultiTexCoord3dv
PFNGLMULTITEXCOORD3IPROC pglMultiTexCoord3i=_Lazy_glMultiTexCoord3i; #define GLEE_C_DEFINED_glMultiTexCoord3dv
PFNGLMULTITEXCOORD3IVPROC pglMultiTexCoord3iv=_Lazy_glMultiTexCoord3iv; void __stdcall GLee_Lazy_glMultiTexCoord3dv(GLenum target, const GLdouble
PFNGLMULTITEXCOORD3SPROC pglMultiTexCoord3s=_Lazy_glMultiTexCoord3s; * v) {if (GLeeInit()) glMultiTexCoord3dv(target, v);}
PFNGLMULTITEXCOORD3SVPROC pglMultiTexCoord3sv=_Lazy_glMultiTexCoord3sv; GLEEPFNGLMULTITEXCOORD3DVPROC GLeeFuncPtr_glMultiTexCoord3dv=GLee_Lazy_gl
PFNGLMULTITEXCOORD4DPROC pglMultiTexCoord4d=_Lazy_glMultiTexCoord4d; MultiTexCoord3dv;
PFNGLMULTITEXCOORD4DVPROC pglMultiTexCoord4dv=_Lazy_glMultiTexCoord4dv; #endif
PFNGLMULTITEXCOORD4FPROC pglMultiTexCoord4f=_Lazy_glMultiTexCoord4f; #ifndef GLEE_C_DEFINED_glMultiTexCoord3f
PFNGLMULTITEXCOORD4FVPROC pglMultiTexCoord4fv=_Lazy_glMultiTexCoord4fv; #define GLEE_C_DEFINED_glMultiTexCoord3f
PFNGLMULTITEXCOORD4IPROC pglMultiTexCoord4i=_Lazy_glMultiTexCoord4i; void __stdcall GLee_Lazy_glMultiTexCoord3f(GLenum target, GLfloat s, GLfl
PFNGLMULTITEXCOORD4IVPROC pglMultiTexCoord4iv=_Lazy_glMultiTexCoord4iv; oat t, GLfloat r) {if (GLeeInit()) glMultiTexCoord3f(target, s, t, r);}
PFNGLMULTITEXCOORD4SPROC pglMultiTexCoord4s=_Lazy_glMultiTexCoord4s; GLEEPFNGLMULTITEXCOORD3FPROC GLeeFuncPtr_glMultiTexCoord3f=GLee_Lazy_glMu
PFNGLMULTITEXCOORD4SVPROC pglMultiTexCoord4sv=_Lazy_glMultiTexCoord4sv; ltiTexCoord3f;
PFNGLLOADTRANSPOSEMATRIXFPROC pglLoadTransposeMatrixf=_Lazy_glLoadTranspose #endif
Matrixf; #ifndef GLEE_C_DEFINED_glMultiTexCoord3fv
PFNGLLOADTRANSPOSEMATRIXDPROC pglLoadTransposeMatrixd=_Lazy_glLoadTranspose #define GLEE_C_DEFINED_glMultiTexCoord3fv
Matrixd; void __stdcall GLee_Lazy_glMultiTexCoord3fv(GLenum target, const GLfloat
PFNGLMULTTRANSPOSEMATRIXFPROC pglMultTransposeMatrixf=_Lazy_glMultTranspose * v) {if (GLeeInit()) glMultiTexCoord3fv(target, v);}
Matrixf; GLEEPFNGLMULTITEXCOORD3FVPROC GLeeFuncPtr_glMultiTexCoord3fv=GLee_Lazy_gl
PFNGLMULTTRANSPOSEMATRIXDPROC pglMultTransposeMatrixd=_Lazy_glMultTranspose MultiTexCoord3fv;
Matrixd; #endif
PFNGLSAMPLECOVERAGEPROC pglSampleCoverage=_Lazy_glSampleCoverage; #ifndef GLEE_C_DEFINED_glMultiTexCoord3i
PFNGLCOMPRESSEDTEXIMAGE3DPROC pglCompressedTexImage3D=_Lazy_glCompressedTex #define GLEE_C_DEFINED_glMultiTexCoord3i
Image3D; void __stdcall GLee_Lazy_glMultiTexCoord3i(GLenum target, GLint s, GLint
PFNGLCOMPRESSEDTEXIMAGE2DPROC pglCompressedTexImage2D=_Lazy_glCompressedTex t, GLint r) {if (GLeeInit()) glMultiTexCoord3i(target, s, t, r);}
Image2D; GLEEPFNGLMULTITEXCOORD3IPROC GLeeFuncPtr_glMultiTexCoord3i=GLee_Lazy_glMu
PFNGLCOMPRESSEDTEXIMAGE1DPROC pglCompressedTexImage1D=_Lazy_glCompressedTex ltiTexCoord3i;
Image1D; #endif
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC pglCompressedTexSubImage3D=_Lazy_glCompres #ifndef GLEE_C_DEFINED_glMultiTexCoord3iv
sedTexSubImage3D; #define GLEE_C_DEFINED_glMultiTexCoord3iv
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC pglCompressedTexSubImage2D=_Lazy_glCompres void __stdcall GLee_Lazy_glMultiTexCoord3iv(GLenum target, const GLint *
sedTexSubImage2D; v) {if (GLeeInit()) glMultiTexCoord3iv(target, v);}
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC pglCompressedTexSubImage1D=_Lazy_glCompres GLEEPFNGLMULTITEXCOORD3IVPROC GLeeFuncPtr_glMultiTexCoord3iv=GLee_Lazy_gl
sedTexSubImage1D; MultiTexCoord3iv;
PFNGLGETCOMPRESSEDTEXIMAGEPROC pglGetCompressedTexImage=_Lazy_glGetCompress #endif
edTexImage; #ifndef GLEE_C_DEFINED_glMultiTexCoord3s
#define GLEE_C_DEFINED_glMultiTexCoord3s
void __stdcall GLee_Lazy_glMultiTexCoord3s(GLenum target, GLshort s, GLsh
ort t, GLshort r) {if (GLeeInit()) glMultiTexCoord3s(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3SPROC GLeeFuncPtr_glMultiTexCoord3s=GLee_Lazy_glMu
ltiTexCoord3s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3sv
#define GLEE_C_DEFINED_glMultiTexCoord3sv
void __stdcall GLee_Lazy_glMultiTexCoord3sv(GLenum target, const GLshort
* v) {if (GLeeInit()) glMultiTexCoord3sv(target, v);}
GLEEPFNGLMULTITEXCOORD3SVPROC GLeeFuncPtr_glMultiTexCoord3sv=GLee_Lazy_gl
MultiTexCoord3sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4d
#define GLEE_C_DEFINED_glMultiTexCoord4d
void __stdcall GLee_Lazy_glMultiTexCoord4d(GLenum target, GLdouble s, GLd
ouble t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4d(target
, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4DPROC GLeeFuncPtr_glMultiTexCoord4d=GLee_Lazy_glMu
ltiTexCoord4d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dv
#define GLEE_C_DEFINED_glMultiTexCoord4dv
void __stdcall GLee_Lazy_glMultiTexCoord4dv(GLenum target, const GLdouble
* v) {if (GLeeInit()) glMultiTexCoord4dv(target, v);}
GLEEPFNGLMULTITEXCOORD4DVPROC GLeeFuncPtr_glMultiTexCoord4dv=GLee_Lazy_gl
MultiTexCoord4dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4f
#define GLEE_C_DEFINED_glMultiTexCoord4f
void __stdcall GLee_Lazy_glMultiTexCoord4f(GLenum target, GLfloat s, GLfl
oat t, GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4f(target, s,
t, r, q);}
GLEEPFNGLMULTITEXCOORD4FPROC GLeeFuncPtr_glMultiTexCoord4f=GLee_Lazy_glMu
ltiTexCoord4f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fv
#define GLEE_C_DEFINED_glMultiTexCoord4fv
void __stdcall GLee_Lazy_glMultiTexCoord4fv(GLenum target, const GLfloat
* v) {if (GLeeInit()) glMultiTexCoord4fv(target, v);}
GLEEPFNGLMULTITEXCOORD4FVPROC GLeeFuncPtr_glMultiTexCoord4fv=GLee_Lazy_gl
MultiTexCoord4fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4i
#define GLEE_C_DEFINED_glMultiTexCoord4i
void __stdcall GLee_Lazy_glMultiTexCoord4i(GLenum target, GLint s, GLint
t, GLint r, GLint q) {if (GLeeInit()) glMultiTexCoord4i(target, s, t, r, q
);}
GLEEPFNGLMULTITEXCOORD4IPROC GLeeFuncPtr_glMultiTexCoord4i=GLee_Lazy_glMu
ltiTexCoord4i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4iv
#define GLEE_C_DEFINED_glMultiTexCoord4iv
void __stdcall GLee_Lazy_glMultiTexCoord4iv(GLenum target, const GLint *
v) {if (GLeeInit()) glMultiTexCoord4iv(target, v);}
GLEEPFNGLMULTITEXCOORD4IVPROC GLeeFuncPtr_glMultiTexCoord4iv=GLee_Lazy_gl
MultiTexCoord4iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4s
#define GLEE_C_DEFINED_glMultiTexCoord4s
void __stdcall GLee_Lazy_glMultiTexCoord4s(GLenum target, GLshort s, GLsh
ort t, GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4s(target, s,
t, r, q);}
GLEEPFNGLMULTITEXCOORD4SPROC GLeeFuncPtr_glMultiTexCoord4s=GLee_Lazy_glMu
ltiTexCoord4s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4sv
#define GLEE_C_DEFINED_glMultiTexCoord4sv
void __stdcall GLee_Lazy_glMultiTexCoord4sv(GLenum target, const GLshort
* v) {if (GLeeInit()) glMultiTexCoord4sv(target, v);}
GLEEPFNGLMULTITEXCOORD4SVPROC GLeeFuncPtr_glMultiTexCoord4sv=GLee_Lazy_gl
MultiTexCoord4sv;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixf
#define GLEE_C_DEFINED_glLoadTransposeMatrixf
void __stdcall GLee_Lazy_glLoadTransposeMatrixf(const GLfloat * m) {if (
GLeeInit()) glLoadTransposeMatrixf(m);}
GLEEPFNGLLOADTRANSPOSEMATRIXFPROC GLeeFuncPtr_glLoadTransposeMatrixf=GLee
_Lazy_glLoadTransposeMatrixf;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixd
#define GLEE_C_DEFINED_glLoadTransposeMatrixd
void __stdcall GLee_Lazy_glLoadTransposeMatrixd(const GLdouble * m) {if
(GLeeInit()) glLoadTransposeMatrixd(m);}
GLEEPFNGLLOADTRANSPOSEMATRIXDPROC GLeeFuncPtr_glLoadTransposeMatrixd=GLee
_Lazy_glLoadTransposeMatrixd;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixf
#define GLEE_C_DEFINED_glMultTransposeMatrixf
void __stdcall GLee_Lazy_glMultTransposeMatrixf(const GLfloat * m) {if (
GLeeInit()) glMultTransposeMatrixf(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXFPROC GLeeFuncPtr_glMultTransposeMatrixf=GLee
_Lazy_glMultTransposeMatrixf;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixd
#define GLEE_C_DEFINED_glMultTransposeMatrixd
void __stdcall GLee_Lazy_glMultTransposeMatrixd(const GLdouble * m) {if
(GLeeInit()) glMultTransposeMatrixd(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXDPROC GLeeFuncPtr_glMultTransposeMatrixd=GLee
_Lazy_glMultTransposeMatrixd;
#endif
#ifndef GLEE_C_DEFINED_glSampleCoverage
#define GLEE_C_DEFINED_glSampleCoverage
void __stdcall GLee_Lazy_glSampleCoverage(GLclampf value, GLboolean inver
t) {if (GLeeInit()) glSampleCoverage(value, invert);}
GLEEPFNGLSAMPLECOVERAGEPROC GLeeFuncPtr_glSampleCoverage=GLee_Lazy_glSamp
leCoverage;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage3D
#define GLEE_C_DEFINED_glCompressedTexImage3D
void __stdcall GLee_Lazy_glCompressedTexImage3D(GLenum target, GLint leve
l, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLi
nt border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glComp
ressedTexImage3D(target, level, internalformat, width, height, depth, borde
r, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE3DPROC GLeeFuncPtr_glCompressedTexImage3D=GLee
_Lazy_glCompressedTexImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage2D
#define GLEE_C_DEFINED_glCompressedTexImage2D
void __stdcall GLee_Lazy_glCompressedTexImage2D(GLenum target, GLint leve
l, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsi
zei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage2
D(target, level, internalformat, width, height, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE2DPROC GLeeFuncPtr_glCompressedTexImage2D=GLee
_Lazy_glCompressedTexImage2D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage1D
#define GLEE_C_DEFINED_glCompressedTexImage1D
void __stdcall GLee_Lazy_glCompressedTexImage1D(GLenum target, GLint leve
l, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, c
onst GLvoid * data) {if (GLeeInit()) glCompressedTexImage1D(target, level,
internalformat, width, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE1DPROC GLeeFuncPtr_glCompressedTexImage1D=GLee
_Lazy_glCompressedTexImage1D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage3D
#define GLEE_C_DEFINED_glCompressedTexSubImage3D
void __stdcall GLee_Lazy_glCompressedTexSubImage3D(GLenum target, GLint l
evel, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei h
eight, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data
) {if (GLeeInit()) glCompressedTexSubImage3D(target, level, xoffset, yoffs
et, zoffset, width, height, depth, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC GLeeFuncPtr_glCompressedTexSubImage3
D=GLee_Lazy_glCompressedTexSubImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage2D
#define GLEE_C_DEFINED_glCompressedTexSubImage2D
void __stdcall GLee_Lazy_glCompressedTexSubImage2D(GLenum target, GLint l
evel, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum f
ormat, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompress
edTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ima
geSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC GLeeFuncPtr_glCompressedTexSubImage2
D=GLee_Lazy_glCompressedTexSubImage2D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1D
#define GLEE_C_DEFINED_glCompressedTexSubImage1D
void __stdcall GLee_Lazy_glCompressedTexSubImage1D(GLenum target, GLint l
evel, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const
GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage1D(target, level,
xoffset, width, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC GLeeFuncPtr_glCompressedTexSubImage1
D=GLee_Lazy_glCompressedTexSubImage1D;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTexImage
#define GLEE_C_DEFINED_glGetCompressedTexImage
void __stdcall GLee_Lazy_glGetCompressedTexImage(GLenum target, GLint lev
el, GLvoid * img) {if (GLeeInit()) glGetCompressedTexImage(target, level,
img);}
GLEEPFNGLGETCOMPRESSEDTEXIMAGEPROC GLeeFuncPtr_glGetCompressedTexImage=GL
ee_Lazy_glGetCompressedTexImage;
#endif
#endif #endif
/* GL_VERSION_1_4 */ /* GL_VERSION_1_4 */
#ifdef __GLEE_GL_VERSION_1_4 #ifdef __GLEE_GL_VERSION_1_4
void __stdcall _Lazy_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorR #ifndef GLEE_C_DEFINED_glBlendFuncSeparate
GB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBlendFunc #define GLEE_C_DEFINED_glBlendFuncSeparate
Separate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);} void __stdcall GLee_Lazy_glBlendFuncSeparate(GLenum sfactorRGB, GLenum df
void __stdcall _Lazy_glFogCoordf(GLfloat coord) actorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBle
{if (GLeeInit()) glFogCoordf(coord);} ndFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
void __stdcall _Lazy_glFogCoordfv(const GLfloat * coord) GLEEPFNGLBLENDFUNCSEPARATEPROC GLeeFuncPtr_glBlendFuncSeparate=GLee_Lazy_
{if (GLeeInit()) glFogCoordfv(coord);} glBlendFuncSeparate;
void __stdcall _Lazy_glFogCoordd(GLdouble coord) #endif
{if (GLeeInit()) glFogCoordd(coord);} #ifndef GLEE_C_DEFINED_glFogCoordf
void __stdcall _Lazy_glFogCoorddv(const GLdouble * coord) #define GLEE_C_DEFINED_glFogCoordf
{if (GLeeInit()) glFogCoorddv(coord);} void __stdcall GLee_Lazy_glFogCoordf(GLfloat coord) {if (GLeeInit()) glF
void __stdcall _Lazy_glFogCoordPointer(GLenum type, GLsizei stride, const G ogCoordf(coord);}
Lvoid * pointer) {if (GLeeInit()) glFogCoordPointer(type, stride, pointer) GLEEPFNGLFOGCOORDFPROC GLeeFuncPtr_glFogCoordf=GLee_Lazy_glFogCoordf;
;} #endif
void __stdcall _Lazy_glMultiDrawArrays(GLenum mode, GLint * first, GLsizei #ifndef GLEE_C_DEFINED_glFogCoordfv
* count, GLsizei primcount) {if (GLeeInit()) glMultiDrawArrays(mode, first #define GLEE_C_DEFINED_glFogCoordfv
, count, primcount);} void __stdcall GLee_Lazy_glFogCoordfv(const GLfloat * coord) {if (GLeeIn
void __stdcall _Lazy_glMultiDrawElements(GLenum mode, const GLsizei * count it()) glFogCoordfv(coord);}
, GLenum type, const GLvoid* * indices, GLsizei primcount) {if (GLeeInit() GLEEPFNGLFOGCOORDFVPROC GLeeFuncPtr_glFogCoordfv=GLee_Lazy_glFogCoordfv;
) glMultiDrawElements(mode, count, type, indices, primcount);} #endif
void __stdcall _Lazy_glPointParameterf(GLenum pname, GLfloat param) #ifndef GLEE_C_DEFINED_glFogCoordd
{if (GLeeInit()) glPointParameterf(pname, param);} #define GLEE_C_DEFINED_glFogCoordd
void __stdcall _Lazy_glPointParameterfv(GLenum pname, const GLfloat * param void __stdcall GLee_Lazy_glFogCoordd(GLdouble coord) {if (GLeeInit()) gl
s) {if (GLeeInit()) glPointParameterfv(pname, params);} FogCoordd(coord);}
void __stdcall _Lazy_glPointParameteri(GLenum pname, GLint param) GLEEPFNGLFOGCOORDDPROC GLeeFuncPtr_glFogCoordd=GLee_Lazy_glFogCoordd;
{if (GLeeInit()) glPointParameteri(pname, param);} #endif
void __stdcall _Lazy_glPointParameteriv(GLenum pname, const GLint * params) #ifndef GLEE_C_DEFINED_glFogCoorddv
{if (GLeeInit()) glPointParameteriv(pname, params);} #define GLEE_C_DEFINED_glFogCoorddv
void __stdcall _Lazy_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte bl void __stdcall GLee_Lazy_glFogCoorddv(const GLdouble * coord) {if (GLeeI
ue) {if (GLeeInit()) glSecondaryColor3b(red, green, blue);} nit()) glFogCoorddv(coord);}
void __stdcall _Lazy_glSecondaryColor3bv(const GLbyte * v) GLEEPFNGLFOGCOORDDVPROC GLeeFuncPtr_glFogCoorddv=GLee_Lazy_glFogCoorddv;
{if (GLeeInit()) glSecondaryColor3bv(v);} #endif
void __stdcall _Lazy_glSecondaryColor3d(GLdouble red, GLdouble green, GLdou #ifndef GLEE_C_DEFINED_glFogCoordPointer
ble blue) {if (GLeeInit()) glSecondaryColor3d(red, green, blue);} #define GLEE_C_DEFINED_glFogCoordPointer
void __stdcall _Lazy_glSecondaryColor3dv(const GLdouble * v) void __stdcall GLee_Lazy_glFogCoordPointer(GLenum type, GLsizei stride, c
{if (GLeeInit()) glSecondaryColor3dv(v);} onst GLvoid * pointer) {if (GLeeInit()) glFogCoordPointer(type, stride, po
void __stdcall _Lazy_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat inter);}
blue) {if (GLeeInit()) glSecondaryColor3f(red, green, blue);} GLEEPFNGLFOGCOORDPOINTERPROC GLeeFuncPtr_glFogCoordPointer=GLee_Lazy_glFo
void __stdcall _Lazy_glSecondaryColor3fv(const GLfloat * v) gCoordPointer;
{if (GLeeInit()) glSecondaryColor3fv(v);} #endif
void __stdcall _Lazy_glSecondaryColor3i(GLint red, GLint green, GLint blue) #ifndef GLEE_C_DEFINED_glMultiDrawArrays
{if (GLeeInit()) glSecondaryColor3i(red, green, blue);} #define GLEE_C_DEFINED_glMultiDrawArrays
void __stdcall _Lazy_glSecondaryColor3iv(const GLint * v) void __stdcall GLee_Lazy_glMultiDrawArrays(GLenum mode, GLint * first, GL
{if (GLeeInit()) glSecondaryColor3iv(v);} sizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawArrays(mode,
void __stdcall _Lazy_glSecondaryColor3s(GLshort red, GLshort green, GLshort first, count, primcount);}
blue) {if (GLeeInit()) glSecondaryColor3s(red, green, blue);} GLEEPFNGLMULTIDRAWARRAYSPROC GLeeFuncPtr_glMultiDrawArrays=GLee_Lazy_glMu
void __stdcall _Lazy_glSecondaryColor3sv(const GLshort * v) ltiDrawArrays;
{if (GLeeInit()) glSecondaryColor3sv(v);} #endif
void __stdcall _Lazy_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyt #ifndef GLEE_C_DEFINED_glMultiDrawElements
e blue) {if (GLeeInit()) glSecondaryColor3ub(red, green, blue);} #define GLEE_C_DEFINED_glMultiDrawElements
void __stdcall _Lazy_glSecondaryColor3ubv(const GLubyte * v) void __stdcall GLee_Lazy_glMultiDrawElements(GLenum mode, const GLsizei *
{if (GLeeInit()) glSecondaryColor3ubv(v);} count, GLenum type, const GLvoid* * indices, GLsizei primcount) {if (GLee
void __stdcall _Lazy_glSecondaryColor3ui(GLuint red, GLuint green, GLuint b Init()) glMultiDrawElements(mode, count, type, indices, primcount);}
lue) {if (GLeeInit()) glSecondaryColor3ui(red, green, blue);} GLEEPFNGLMULTIDRAWELEMENTSPROC GLeeFuncPtr_glMultiDrawElements=GLee_Lazy_
void __stdcall _Lazy_glSecondaryColor3uiv(const GLuint * v) glMultiDrawElements;
{if (GLeeInit()) glSecondaryColor3uiv(v);} #endif
void __stdcall _Lazy_glSecondaryColor3us(GLushort red, GLushort green, GLus #ifndef GLEE_C_DEFINED_glPointParameterf
hort blue) {if (GLeeInit()) glSecondaryColor3us(red, green, blue);} #define GLEE_C_DEFINED_glPointParameterf
void __stdcall _Lazy_glSecondaryColor3usv(const GLushort * v) void __stdcall GLee_Lazy_glPointParameterf(GLenum pname, GLfloat param)
{if (GLeeInit()) glSecondaryColor3usv(v);} {if (GLeeInit()) glPointParameterf(pname, param);}
void __stdcall _Lazy_glSecondaryColorPointer(GLint size, GLenum type, GLsiz GLEEPFNGLPOINTPARAMETERFPROC GLeeFuncPtr_glPointParameterf=GLee_Lazy_glPo
ei stride, const GLvoid * pointer) {if (GLeeInit()) glSecondaryColorPointe intParameterf;
r(size, type, stride, pointer);} #endif
void __stdcall _Lazy_glWindowPos2d(GLdouble x, GLdouble y) #ifndef GLEE_C_DEFINED_glPointParameterfv
{if (GLeeInit()) glWindowPos2d(x, y);} #define GLEE_C_DEFINED_glPointParameterfv
void __stdcall _Lazy_glWindowPos2dv(const GLdouble * v) void __stdcall GLee_Lazy_glPointParameterfv(GLenum pname, const GLfloat *
{if (GLeeInit()) glWindowPos2dv(v);} params) {if (GLeeInit()) glPointParameterfv(pname, params);}
void __stdcall _Lazy_glWindowPos2f(GLfloat x, GLfloat y) GLEEPFNGLPOINTPARAMETERFVPROC GLeeFuncPtr_glPointParameterfv=GLee_Lazy_gl
{if (GLeeInit()) glWindowPos2f(x, y);} PointParameterfv;
void __stdcall _Lazy_glWindowPos2fv(const GLfloat * v) #endif
{if (GLeeInit()) glWindowPos2fv(v);} #ifndef GLEE_C_DEFINED_glPointParameteri
void __stdcall _Lazy_glWindowPos2i(GLint x, GLint y) #define GLEE_C_DEFINED_glPointParameteri
{if (GLeeInit()) glWindowPos2i(x, y);} void __stdcall GLee_Lazy_glPointParameteri(GLenum pname, GLint param) {i
void __stdcall _Lazy_glWindowPos2iv(const GLint * v) f (GLeeInit()) glPointParameteri(pname, param);}
{if (GLeeInit()) glWindowPos2iv(v);} GLEEPFNGLPOINTPARAMETERIPROC GLeeFuncPtr_glPointParameteri=GLee_Lazy_glPo
void __stdcall _Lazy_glWindowPos2s(GLshort x, GLshort y) intParameteri;
{if (GLeeInit()) glWindowPos2s(x, y);} #endif
void __stdcall _Lazy_glWindowPos2sv(const GLshort * v) #ifndef GLEE_C_DEFINED_glPointParameteriv
{if (GLeeInit()) glWindowPos2sv(v);} #define GLEE_C_DEFINED_glPointParameteriv
void __stdcall _Lazy_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) void __stdcall GLee_Lazy_glPointParameteriv(GLenum pname, const GLint * p
{if (GLeeInit()) glWindowPos3d(x, y, z);} arams) {if (GLeeInit()) glPointParameteriv(pname, params);}
void __stdcall _Lazy_glWindowPos3dv(const GLdouble * v) GLEEPFNGLPOINTPARAMETERIVPROC GLeeFuncPtr_glPointParameteriv=GLee_Lazy_gl
{if (GLeeInit()) glWindowPos3dv(v);} PointParameteriv;
void __stdcall _Lazy_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) #endif
{if (GLeeInit()) glWindowPos3f(x, y, z);} #ifndef GLEE_C_DEFINED_glSecondaryColor3b
void __stdcall _Lazy_glWindowPos3fv(const GLfloat * v) #define GLEE_C_DEFINED_glSecondaryColor3b
{if (GLeeInit()) glWindowPos3fv(v);} void __stdcall GLee_Lazy_glSecondaryColor3b(GLbyte red, GLbyte green, GLb
void __stdcall _Lazy_glWindowPos3i(GLint x, GLint y, GLint z) yte blue) {if (GLeeInit()) glSecondaryColor3b(red, green, blue);}
{if (GLeeInit()) glWindowPos3i(x, y, z);} GLEEPFNGLSECONDARYCOLOR3BPROC GLeeFuncPtr_glSecondaryColor3b=GLee_Lazy_gl
void __stdcall _Lazy_glWindowPos3iv(const GLint * v) SecondaryColor3b;
{if (GLeeInit()) glWindowPos3iv(v);} #endif
void __stdcall _Lazy_glWindowPos3s(GLshort x, GLshort y, GLshort z) #ifndef GLEE_C_DEFINED_glSecondaryColor3bv
{if (GLeeInit()) glWindowPos3s(x, y, z);} #define GLEE_C_DEFINED_glSecondaryColor3bv
void __stdcall _Lazy_glWindowPos3sv(const GLshort * v) void __stdcall GLee_Lazy_glSecondaryColor3bv(const GLbyte * v) {if (GLee
{if (GLeeInit()) glWindowPos3sv(v);} Init()) glSecondaryColor3bv(v);}
PFNGLBLENDFUNCSEPARATEPROC pglBlendFuncSeparate=_Lazy_glBlendFuncSeparate; GLEEPFNGLSECONDARYCOLOR3BVPROC GLeeFuncPtr_glSecondaryColor3bv=GLee_Lazy_
PFNGLFOGCOORDFPROC pglFogCoordf=_Lazy_glFogCoordf; glSecondaryColor3bv;
PFNGLFOGCOORDFVPROC pglFogCoordfv=_Lazy_glFogCoordfv; #endif
PFNGLFOGCOORDDPROC pglFogCoordd=_Lazy_glFogCoordd; #ifndef GLEE_C_DEFINED_glSecondaryColor3d
PFNGLFOGCOORDDVPROC pglFogCoorddv=_Lazy_glFogCoorddv; #define GLEE_C_DEFINED_glSecondaryColor3d
PFNGLFOGCOORDPOINTERPROC pglFogCoordPointer=_Lazy_glFogCoordPointer; void __stdcall GLee_Lazy_glSecondaryColor3d(GLdouble red, GLdouble green,
PFNGLMULTIDRAWARRAYSPROC pglMultiDrawArrays=_Lazy_glMultiDrawArrays; GLdouble blue) {if (GLeeInit()) glSecondaryColor3d(red, green, blue);}
PFNGLMULTIDRAWELEMENTSPROC pglMultiDrawElements=_Lazy_glMultiDrawElements; GLEEPFNGLSECONDARYCOLOR3DPROC GLeeFuncPtr_glSecondaryColor3d=GLee_Lazy_gl
PFNGLPOINTPARAMETERFPROC pglPointParameterf=_Lazy_glPointParameterf; SecondaryColor3d;
PFNGLPOINTPARAMETERFVPROC pglPointParameterfv=_Lazy_glPointParameterfv; #endif
PFNGLPOINTPARAMETERIPROC pglPointParameteri=_Lazy_glPointParameteri; #ifndef GLEE_C_DEFINED_glSecondaryColor3dv
PFNGLPOINTPARAMETERIVPROC pglPointParameteriv=_Lazy_glPointParameteriv; #define GLEE_C_DEFINED_glSecondaryColor3dv
PFNGLSECONDARYCOLOR3BPROC pglSecondaryColor3b=_Lazy_glSecondaryColor3b; void __stdcall GLee_Lazy_glSecondaryColor3dv(const GLdouble * v) {if (GL
PFNGLSECONDARYCOLOR3BVPROC pglSecondaryColor3bv=_Lazy_glSecondaryColor3bv; eeInit()) glSecondaryColor3dv(v);}
PFNGLSECONDARYCOLOR3DPROC pglSecondaryColor3d=_Lazy_glSecondaryColor3d; GLEEPFNGLSECONDARYCOLOR3DVPROC GLeeFuncPtr_glSecondaryColor3dv=GLee_Lazy_
PFNGLSECONDARYCOLOR3DVPROC pglSecondaryColor3dv=_Lazy_glSecondaryColor3dv; glSecondaryColor3dv;
PFNGLSECONDARYCOLOR3FPROC pglSecondaryColor3f=_Lazy_glSecondaryColor3f; #endif
PFNGLSECONDARYCOLOR3FVPROC pglSecondaryColor3fv=_Lazy_glSecondaryColor3fv; #ifndef GLEE_C_DEFINED_glSecondaryColor3f
PFNGLSECONDARYCOLOR3IPROC pglSecondaryColor3i=_Lazy_glSecondaryColor3i; #define GLEE_C_DEFINED_glSecondaryColor3f
PFNGLSECONDARYCOLOR3IVPROC pglSecondaryColor3iv=_Lazy_glSecondaryColor3iv; void __stdcall GLee_Lazy_glSecondaryColor3f(GLfloat red, GLfloat green, G
PFNGLSECONDARYCOLOR3SPROC pglSecondaryColor3s=_Lazy_glSecondaryColor3s; Lfloat blue) {if (GLeeInit()) glSecondaryColor3f(red, green, blue);}
PFNGLSECONDARYCOLOR3SVPROC pglSecondaryColor3sv=_Lazy_glSecondaryColor3sv; GLEEPFNGLSECONDARYCOLOR3FPROC GLeeFuncPtr_glSecondaryColor3f=GLee_Lazy_gl
PFNGLSECONDARYCOLOR3UBPROC pglSecondaryColor3ub=_Lazy_glSecondaryColor3ub; SecondaryColor3f;
PFNGLSECONDARYCOLOR3UBVPROC pglSecondaryColor3ubv=_Lazy_glSecondaryColor3ub #endif
v; #ifndef GLEE_C_DEFINED_glSecondaryColor3fv
PFNGLSECONDARYCOLOR3UIPROC pglSecondaryColor3ui=_Lazy_glSecondaryColor3ui; #define GLEE_C_DEFINED_glSecondaryColor3fv
PFNGLSECONDARYCOLOR3UIVPROC pglSecondaryColor3uiv=_Lazy_glSecondaryColor3ui void __stdcall GLee_Lazy_glSecondaryColor3fv(const GLfloat * v) {if (GLe
v; eInit()) glSecondaryColor3fv(v);}
PFNGLSECONDARYCOLOR3USPROC pglSecondaryColor3us=_Lazy_glSecondaryColor3us; GLEEPFNGLSECONDARYCOLOR3FVPROC GLeeFuncPtr_glSecondaryColor3fv=GLee_Lazy_
PFNGLSECONDARYCOLOR3USVPROC pglSecondaryColor3usv=_Lazy_glSecondaryColor3us glSecondaryColor3fv;
v; #endif
PFNGLSECONDARYCOLORPOINTERPROC pglSecondaryColorPointer=_Lazy_glSecondaryCo #ifndef GLEE_C_DEFINED_glSecondaryColor3i
lorPointer; #define GLEE_C_DEFINED_glSecondaryColor3i
PFNGLWINDOWPOS2DPROC pglWindowPos2d=_Lazy_glWindowPos2d; void __stdcall GLee_Lazy_glSecondaryColor3i(GLint red, GLint green, GLint
PFNGLWINDOWPOS2DVPROC pglWindowPos2dv=_Lazy_glWindowPos2dv; blue) {if (GLeeInit()) glSecondaryColor3i(red, green, blue);}
PFNGLWINDOWPOS2FPROC pglWindowPos2f=_Lazy_glWindowPos2f; GLEEPFNGLSECONDARYCOLOR3IPROC GLeeFuncPtr_glSecondaryColor3i=GLee_Lazy_gl
PFNGLWINDOWPOS2FVPROC pglWindowPos2fv=_Lazy_glWindowPos2fv; SecondaryColor3i;
PFNGLWINDOWPOS2IPROC pglWindowPos2i=_Lazy_glWindowPos2i; #endif
PFNGLWINDOWPOS2IVPROC pglWindowPos2iv=_Lazy_glWindowPos2iv; #ifndef GLEE_C_DEFINED_glSecondaryColor3iv
PFNGLWINDOWPOS2SPROC pglWindowPos2s=_Lazy_glWindowPos2s; #define GLEE_C_DEFINED_glSecondaryColor3iv
PFNGLWINDOWPOS2SVPROC pglWindowPos2sv=_Lazy_glWindowPos2sv; void __stdcall GLee_Lazy_glSecondaryColor3iv(const GLint * v) {if (GLeeI
PFNGLWINDOWPOS3DPROC pglWindowPos3d=_Lazy_glWindowPos3d; nit()) glSecondaryColor3iv(v);}
PFNGLWINDOWPOS3DVPROC pglWindowPos3dv=_Lazy_glWindowPos3dv; GLEEPFNGLSECONDARYCOLOR3IVPROC GLeeFuncPtr_glSecondaryColor3iv=GLee_Lazy_
PFNGLWINDOWPOS3FPROC pglWindowPos3f=_Lazy_glWindowPos3f; glSecondaryColor3iv;
PFNGLWINDOWPOS3FVPROC pglWindowPos3fv=_Lazy_glWindowPos3fv; #endif
PFNGLWINDOWPOS3IPROC pglWindowPos3i=_Lazy_glWindowPos3i; #ifndef GLEE_C_DEFINED_glSecondaryColor3s
PFNGLWINDOWPOS3IVPROC pglWindowPos3iv=_Lazy_glWindowPos3iv; #define GLEE_C_DEFINED_glSecondaryColor3s
PFNGLWINDOWPOS3SPROC pglWindowPos3s=_Lazy_glWindowPos3s; void __stdcall GLee_Lazy_glSecondaryColor3s(GLshort red, GLshort green, G
PFNGLWINDOWPOS3SVPROC pglWindowPos3sv=_Lazy_glWindowPos3sv; Lshort blue) {if (GLeeInit()) glSecondaryColor3s(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3SPROC GLeeFuncPtr_glSecondaryColor3s=GLee_Lazy_gl
SecondaryColor3s;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3sv
#define GLEE_C_DEFINED_glSecondaryColor3sv
void __stdcall GLee_Lazy_glSecondaryColor3sv(const GLshort * v) {if (GLe
eInit()) glSecondaryColor3sv(v);}
GLEEPFNGLSECONDARYCOLOR3SVPROC GLeeFuncPtr_glSecondaryColor3sv=GLee_Lazy_
glSecondaryColor3sv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ub
#define GLEE_C_DEFINED_glSecondaryColor3ub
void __stdcall GLee_Lazy_glSecondaryColor3ub(GLubyte red, GLubyte green,
GLubyte blue) {if (GLeeInit()) glSecondaryColor3ub(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3UBPROC GLeeFuncPtr_glSecondaryColor3ub=GLee_Lazy_
glSecondaryColor3ub;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ubv
#define GLEE_C_DEFINED_glSecondaryColor3ubv
void __stdcall GLee_Lazy_glSecondaryColor3ubv(const GLubyte * v) {if (GL
eeInit()) glSecondaryColor3ubv(v);}
GLEEPFNGLSECONDARYCOLOR3UBVPROC GLeeFuncPtr_glSecondaryColor3ubv=GLee_Laz
y_glSecondaryColor3ubv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ui
#define GLEE_C_DEFINED_glSecondaryColor3ui
void __stdcall GLee_Lazy_glSecondaryColor3ui(GLuint red, GLuint green, GL
uint blue) {if (GLeeInit()) glSecondaryColor3ui(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3UIPROC GLeeFuncPtr_glSecondaryColor3ui=GLee_Lazy_
glSecondaryColor3ui;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3uiv
#define GLEE_C_DEFINED_glSecondaryColor3uiv
void __stdcall GLee_Lazy_glSecondaryColor3uiv(const GLuint * v) {if (GLe
eInit()) glSecondaryColor3uiv(v);}
GLEEPFNGLSECONDARYCOLOR3UIVPROC GLeeFuncPtr_glSecondaryColor3uiv=GLee_Laz
y_glSecondaryColor3uiv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3us
#define GLEE_C_DEFINED_glSecondaryColor3us
void __stdcall GLee_Lazy_glSecondaryColor3us(GLushort red, GLushort green
, GLushort blue) {if (GLeeInit()) glSecondaryColor3us(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3USPROC GLeeFuncPtr_glSecondaryColor3us=GLee_Lazy_
glSecondaryColor3us;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3usv
#define GLEE_C_DEFINED_glSecondaryColor3usv
void __stdcall GLee_Lazy_glSecondaryColor3usv(const GLushort * v) {if (G
LeeInit()) glSecondaryColor3usv(v);}
GLEEPFNGLSECONDARYCOLOR3USVPROC GLeeFuncPtr_glSecondaryColor3usv=GLee_Laz
y_glSecondaryColor3usv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColorPointer
#define GLEE_C_DEFINED_glSecondaryColorPointer
void __stdcall GLee_Lazy_glSecondaryColorPointer(GLint size, GLenum type,
GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glSecondaryColor
Pointer(size, type, stride, pointer);}
GLEEPFNGLSECONDARYCOLORPOINTERPROC GLeeFuncPtr_glSecondaryColorPointer=GL
ee_Lazy_glSecondaryColorPointer;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2d
#define GLEE_C_DEFINED_glWindowPos2d
void __stdcall GLee_Lazy_glWindowPos2d(GLdouble x, GLdouble y) {if (GLee
Init()) glWindowPos2d(x, y);}
GLEEPFNGLWINDOWPOS2DPROC GLeeFuncPtr_glWindowPos2d=GLee_Lazy_glWindowPos2
d;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2dv
#define GLEE_C_DEFINED_glWindowPos2dv
void __stdcall GLee_Lazy_glWindowPos2dv(const GLdouble * v) {if (GLeeIni
t()) glWindowPos2dv(v);}
GLEEPFNGLWINDOWPOS2DVPROC GLeeFuncPtr_glWindowPos2dv=GLee_Lazy_glWindowPo
s2dv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2f
#define GLEE_C_DEFINED_glWindowPos2f
void __stdcall GLee_Lazy_glWindowPos2f(GLfloat x, GLfloat y) {if (GLeeIn
it()) glWindowPos2f(x, y);}
GLEEPFNGLWINDOWPOS2FPROC GLeeFuncPtr_glWindowPos2f=GLee_Lazy_glWindowPos2
f;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fv
#define GLEE_C_DEFINED_glWindowPos2fv
void __stdcall GLee_Lazy_glWindowPos2fv(const GLfloat * v) {if (GLeeInit
()) glWindowPos2fv(v);}
GLEEPFNGLWINDOWPOS2FVPROC GLeeFuncPtr_glWindowPos2fv=GLee_Lazy_glWindowPo
s2fv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2i
#define GLEE_C_DEFINED_glWindowPos2i
void __stdcall GLee_Lazy_glWindowPos2i(GLint x, GLint y) {if (GLeeInit()
) glWindowPos2i(x, y);}
GLEEPFNGLWINDOWPOS2IPROC GLeeFuncPtr_glWindowPos2i=GLee_Lazy_glWindowPos2
i;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2iv
#define GLEE_C_DEFINED_glWindowPos2iv
void __stdcall GLee_Lazy_glWindowPos2iv(const GLint * v) {if (GLeeInit()
) glWindowPos2iv(v);}
GLEEPFNGLWINDOWPOS2IVPROC GLeeFuncPtr_glWindowPos2iv=GLee_Lazy_glWindowPo
s2iv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2s
#define GLEE_C_DEFINED_glWindowPos2s
void __stdcall GLee_Lazy_glWindowPos2s(GLshort x, GLshort y) {if (GLeeIn
it()) glWindowPos2s(x, y);}
GLEEPFNGLWINDOWPOS2SPROC GLeeFuncPtr_glWindowPos2s=GLee_Lazy_glWindowPos2
s;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2sv
#define GLEE_C_DEFINED_glWindowPos2sv
void __stdcall GLee_Lazy_glWindowPos2sv(const GLshort * v) {if (GLeeInit
()) glWindowPos2sv(v);}
GLEEPFNGLWINDOWPOS2SVPROC GLeeFuncPtr_glWindowPos2sv=GLee_Lazy_glWindowPo
s2sv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3d
#define GLEE_C_DEFINED_glWindowPos3d
void __stdcall GLee_Lazy_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z
) {if (GLeeInit()) glWindowPos3d(x, y, z);}
GLEEPFNGLWINDOWPOS3DPROC GLeeFuncPtr_glWindowPos3d=GLee_Lazy_glWindowPos3
d;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dv
#define GLEE_C_DEFINED_glWindowPos3dv
void __stdcall GLee_Lazy_glWindowPos3dv(const GLdouble * v) {if (GLeeIni
t()) glWindowPos3dv(v);}
GLEEPFNGLWINDOWPOS3DVPROC GLeeFuncPtr_glWindowPos3dv=GLee_Lazy_glWindowPo
s3dv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3f
#define GLEE_C_DEFINED_glWindowPos3f
void __stdcall GLee_Lazy_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
{if (GLeeInit()) glWindowPos3f(x, y, z);}
GLEEPFNGLWINDOWPOS3FPROC GLeeFuncPtr_glWindowPos3f=GLee_Lazy_glWindowPos3
f;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fv
#define GLEE_C_DEFINED_glWindowPos3fv
void __stdcall GLee_Lazy_glWindowPos3fv(const GLfloat * v) {if (GLeeInit
()) glWindowPos3fv(v);}
GLEEPFNGLWINDOWPOS3FVPROC GLeeFuncPtr_glWindowPos3fv=GLee_Lazy_glWindowPo
s3fv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3i
#define GLEE_C_DEFINED_glWindowPos3i
void __stdcall GLee_Lazy_glWindowPos3i(GLint x, GLint y, GLint z) {if (G
LeeInit()) glWindowPos3i(x, y, z);}
GLEEPFNGLWINDOWPOS3IPROC GLeeFuncPtr_glWindowPos3i=GLee_Lazy_glWindowPos3
i;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iv
#define GLEE_C_DEFINED_glWindowPos3iv
void __stdcall GLee_Lazy_glWindowPos3iv(const GLint * v) {if (GLeeInit()
) glWindowPos3iv(v);}
GLEEPFNGLWINDOWPOS3IVPROC GLeeFuncPtr_glWindowPos3iv=GLee_Lazy_glWindowPo
s3iv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3s
#define GLEE_C_DEFINED_glWindowPos3s
void __stdcall GLee_Lazy_glWindowPos3s(GLshort x, GLshort y, GLshort z)
{if (GLeeInit()) glWindowPos3s(x, y, z);}
GLEEPFNGLWINDOWPOS3SPROC GLeeFuncPtr_glWindowPos3s=GLee_Lazy_glWindowPos3
s;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sv
#define GLEE_C_DEFINED_glWindowPos3sv
void __stdcall GLee_Lazy_glWindowPos3sv(const GLshort * v) {if (GLeeInit
()) glWindowPos3sv(v);}
GLEEPFNGLWINDOWPOS3SVPROC GLeeFuncPtr_glWindowPos3sv=GLee_Lazy_glWindowPo
s3sv;
#endif
#endif #endif
/* GL_VERSION_1_5 */ /* GL_VERSION_1_5 */
#ifdef __GLEE_GL_VERSION_1_5 #ifdef __GLEE_GL_VERSION_1_5
void __stdcall _Lazy_glGenQueries(GLsizei n, GLuint * ids) #ifndef GLEE_C_DEFINED_glGenQueries
{if (GLeeInit()) glGenQueries(n, ids);} #define GLEE_C_DEFINED_glGenQueries
void __stdcall _Lazy_glDeleteQueries(GLsizei n, const GLuint * ids) void __stdcall GLee_Lazy_glGenQueries(GLsizei n, GLuint * ids) {if (GLee
{if (GLeeInit()) glDeleteQueries(n, ids);} Init()) glGenQueries(n, ids);}
GLboolean __stdcall _Lazy_glIsQuery(GLuint id) GLEEPFNGLGENQUERIESPROC GLeeFuncPtr_glGenQueries=GLee_Lazy_glGenQueries;
{if (GLeeInit()) return glIsQuery(id); return (GLboolean)0;} #endif
void __stdcall _Lazy_glBeginQuery(GLenum target, GLuint id) #ifndef GLEE_C_DEFINED_glDeleteQueries
{if (GLeeInit()) glBeginQuery(target, id);} #define GLEE_C_DEFINED_glDeleteQueries
void __stdcall _Lazy_glEndQuery(GLenum target) void __stdcall GLee_Lazy_glDeleteQueries(GLsizei n, const GLuint * ids)
{if (GLeeInit()) glEndQuery(target);} {if (GLeeInit()) glDeleteQueries(n, ids);}
void __stdcall _Lazy_glGetQueryiv(GLenum target, GLenum pname, GLint * para GLEEPFNGLDELETEQUERIESPROC GLeeFuncPtr_glDeleteQueries=GLee_Lazy_glDelete
ms) {if (GLeeInit()) glGetQueryiv(target, pname, params);} Queries;
void __stdcall _Lazy_glGetQueryObjectiv(GLuint id, GLenum pname, GLint * pa #endif
rams) {if (GLeeInit()) glGetQueryObjectiv(id, pname, params);} #ifndef GLEE_C_DEFINED_glIsQuery
void __stdcall _Lazy_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * #define GLEE_C_DEFINED_glIsQuery
params) {if (GLeeInit()) glGetQueryObjectuiv(id, pname, params);} GLboolean __stdcall GLee_Lazy_glIsQuery(GLuint id) {if (GLeeInit()) retu
void __stdcall _Lazy_glBindBuffer(GLenum target, GLuint buffer) rn glIsQuery(id); return (GLboolean)0;}
{if (GLeeInit()) glBindBuffer(target, buffer);} GLEEPFNGLISQUERYPROC GLeeFuncPtr_glIsQuery=GLee_Lazy_glIsQuery;
void __stdcall _Lazy_glDeleteBuffers(GLsizei n, const GLuint * buffers) #endif
{if (GLeeInit()) glDeleteBuffers(n, buffers);} #ifndef GLEE_C_DEFINED_glBeginQuery
void __stdcall _Lazy_glGenBuffers(GLsizei n, GLuint * buffers) #define GLEE_C_DEFINED_glBeginQuery
{if (GLeeInit()) glGenBuffers(n, buffers);} void __stdcall GLee_Lazy_glBeginQuery(GLenum target, GLuint id) {if (GLe
GLboolean __stdcall _Lazy_glIsBuffer(GLuint buffer) eInit()) glBeginQuery(target, id);}
{if (GLeeInit()) return glIsBuffer(buffer); return (GLboolea GLEEPFNGLBEGINQUERYPROC GLeeFuncPtr_glBeginQuery=GLee_Lazy_glBeginQuery;
n)0;} #endif
void __stdcall _Lazy_glBufferData(GLenum target, GLsizeiptr size, const GLv #ifndef GLEE_C_DEFINED_glEndQuery
oid * data, GLenum usage) {if (GLeeInit()) glBufferData(target, size, data #define GLEE_C_DEFINED_glEndQuery
, usage);} void __stdcall GLee_Lazy_glEndQuery(GLenum target) {if (GLeeInit()) glEn
void __stdcall _Lazy_glBufferSubData(GLenum target, GLintptr offset, GLsize dQuery(target);}
iptr size, const GLvoid * data) {if (GLeeInit()) glBufferSubData(target, o GLEEPFNGLENDQUERYPROC GLeeFuncPtr_glEndQuery=GLee_Lazy_glEndQuery;
ffset, size, data);} #endif
void __stdcall _Lazy_glGetBufferSubData(GLenum target, GLintptr offset, GLs #ifndef GLEE_C_DEFINED_glGetQueryiv
izeiptr size, GLvoid * data) {if (GLeeInit()) glGetBufferSubData(target, o #define GLEE_C_DEFINED_glGetQueryiv
ffset, size, data);} void __stdcall GLee_Lazy_glGetQueryiv(GLenum target, GLenum pname, GLint
GLvoid* __stdcall _Lazy_glMapBuffer(GLenum target, GLenum access) * params) {if (GLeeInit()) glGetQueryiv(target, pname, params);}
{if (GLeeInit()) return glMapBuffer(target, access); return GLEEPFNGLGETQUERYIVPROC GLeeFuncPtr_glGetQueryiv=GLee_Lazy_glGetQueryiv;
(GLvoid*)0;} #endif
GLboolean __stdcall _Lazy_glUnmapBuffer(GLenum target) #ifndef GLEE_C_DEFINED_glGetQueryObjectiv
{if (GLeeInit()) return glUnmapBuffer(target); return (GLboo #define GLEE_C_DEFINED_glGetQueryObjectiv
lean)0;} void __stdcall GLee_Lazy_glGetQueryObjectiv(GLuint id, GLenum pname, GLin
void __stdcall _Lazy_glGetBufferParameteriv(GLenum target, GLenum pname, GL t * params) {if (GLeeInit()) glGetQueryObjectiv(id, pname, params);}
int * params) {if (GLeeInit()) glGetBufferParameteriv(target, pname, param GLEEPFNGLGETQUERYOBJECTIVPROC GLeeFuncPtr_glGetQueryObjectiv=GLee_Lazy_gl
s);} GetQueryObjectiv;
void __stdcall _Lazy_glGetBufferPointerv(GLenum target, GLenum pname, GLvoi #endif
d* * params) {if (GLeeInit()) glGetBufferPointerv(target, pname, params); #ifndef GLEE_C_DEFINED_glGetQueryObjectuiv
} #define GLEE_C_DEFINED_glGetQueryObjectuiv
PFNGLGENQUERIESPROC pglGenQueries=_Lazy_glGenQueries; void __stdcall GLee_Lazy_glGetQueryObjectuiv(GLuint id, GLenum pname, GLu
PFNGLDELETEQUERIESPROC pglDeleteQueries=_Lazy_glDeleteQueries; int * params) {if (GLeeInit()) glGetQueryObjectuiv(id, pname, params);}
PFNGLISQUERYPROC pglIsQuery=_Lazy_glIsQuery; GLEEPFNGLGETQUERYOBJECTUIVPROC GLeeFuncPtr_glGetQueryObjectuiv=GLee_Lazy_
PFNGLBEGINQUERYPROC pglBeginQuery=_Lazy_glBeginQuery; glGetQueryObjectuiv;
PFNGLENDQUERYPROC pglEndQuery=_Lazy_glEndQuery; #endif
PFNGLGETQUERYIVPROC pglGetQueryiv=_Lazy_glGetQueryiv; #ifndef GLEE_C_DEFINED_glBindBuffer
PFNGLGETQUERYOBJECTIVPROC pglGetQueryObjectiv=_Lazy_glGetQueryObjectiv; #define GLEE_C_DEFINED_glBindBuffer
PFNGLGETQUERYOBJECTUIVPROC pglGetQueryObjectuiv=_Lazy_glGetQueryObjectuiv; void __stdcall GLee_Lazy_glBindBuffer(GLenum target, GLuint buffer) {if
PFNGLBINDBUFFERPROC pglBindBuffer=_Lazy_glBindBuffer; (GLeeInit()) glBindBuffer(target, buffer);}
PFNGLDELETEBUFFERSPROC pglDeleteBuffers=_Lazy_glDeleteBuffers; GLEEPFNGLBINDBUFFERPROC GLeeFuncPtr_glBindBuffer=GLee_Lazy_glBindBuffer;
PFNGLGENBUFFERSPROC pglGenBuffers=_Lazy_glGenBuffers; #endif
PFNGLISBUFFERPROC pglIsBuffer=_Lazy_glIsBuffer; #ifndef GLEE_C_DEFINED_glDeleteBuffers
PFNGLBUFFERDATAPROC pglBufferData=_Lazy_glBufferData; #define GLEE_C_DEFINED_glDeleteBuffers
PFNGLBUFFERSUBDATAPROC pglBufferSubData=_Lazy_glBufferSubData; void __stdcall GLee_Lazy_glDeleteBuffers(GLsizei n, const GLuint * buffer
PFNGLGETBUFFERSUBDATAPROC pglGetBufferSubData=_Lazy_glGetBufferSubData; s) {if (GLeeInit()) glDeleteBuffers(n, buffers);}
PFNGLMAPBUFFERPROC pglMapBuffer=_Lazy_glMapBuffer; GLEEPFNGLDELETEBUFFERSPROC GLeeFuncPtr_glDeleteBuffers=GLee_Lazy_glDelete
PFNGLUNMAPBUFFERPROC pglUnmapBuffer=_Lazy_glUnmapBuffer; Buffers;
PFNGLGETBUFFERPARAMETERIVPROC pglGetBufferParameteriv=_Lazy_glGetBufferPara #endif
meteriv; #ifndef GLEE_C_DEFINED_glGenBuffers
PFNGLGETBUFFERPOINTERVPROC pglGetBufferPointerv=_Lazy_glGetBufferPointerv; #define GLEE_C_DEFINED_glGenBuffers
void __stdcall GLee_Lazy_glGenBuffers(GLsizei n, GLuint * buffers) {if (
GLeeInit()) glGenBuffers(n, buffers);}
GLEEPFNGLGENBUFFERSPROC GLeeFuncPtr_glGenBuffers=GLee_Lazy_glGenBuffers;
#endif
#ifndef GLEE_C_DEFINED_glIsBuffer
#define GLEE_C_DEFINED_glIsBuffer
GLboolean __stdcall GLee_Lazy_glIsBuffer(GLuint buffer) {if (GLeeInit())
return glIsBuffer(buffer); return (GLboolean)0;}
GLEEPFNGLISBUFFERPROC GLeeFuncPtr_glIsBuffer=GLee_Lazy_glIsBuffer;
#endif
#ifndef GLEE_C_DEFINED_glBufferData
#define GLEE_C_DEFINED_glBufferData
void __stdcall GLee_Lazy_glBufferData(GLenum target, GLsizeiptr size, con
st GLvoid * data, GLenum usage) {if (GLeeInit()) glBufferData(target, size
, data, usage);}
GLEEPFNGLBUFFERDATAPROC GLeeFuncPtr_glBufferData=GLee_Lazy_glBufferData;
#endif
#ifndef GLEE_C_DEFINED_glBufferSubData
#define GLEE_C_DEFINED_glBufferSubData
void __stdcall GLee_Lazy_glBufferSubData(GLenum target, GLintptr offset,
GLsizeiptr size, const GLvoid * data) {if (GLeeInit()) glBufferSubData(tar
get, offset, size, data);}
GLEEPFNGLBUFFERSUBDATAPROC GLeeFuncPtr_glBufferSubData=GLee_Lazy_glBuffer
SubData;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferSubData
#define GLEE_C_DEFINED_glGetBufferSubData
void __stdcall GLee_Lazy_glGetBufferSubData(GLenum target, GLintptr offse
t, GLsizeiptr size, GLvoid * data) {if (GLeeInit()) glGetBufferSubData(tar
get, offset, size, data);}
GLEEPFNGLGETBUFFERSUBDATAPROC GLeeFuncPtr_glGetBufferSubData=GLee_Lazy_gl
GetBufferSubData;
#endif
#ifndef GLEE_C_DEFINED_glMapBuffer
#define GLEE_C_DEFINED_glMapBuffer
GLvoid* __stdcall GLee_Lazy_glMapBuffer(GLenum target, GLenum access) {i
f (GLeeInit()) return glMapBuffer(target, access); return (GLvoid*)0;}
GLEEPFNGLMAPBUFFERPROC GLeeFuncPtr_glMapBuffer=GLee_Lazy_glMapBuffer;
#endif
#ifndef GLEE_C_DEFINED_glUnmapBuffer
#define GLEE_C_DEFINED_glUnmapBuffer
GLboolean __stdcall GLee_Lazy_glUnmapBuffer(GLenum target) {if (GLeeInit
()) return glUnmapBuffer(target); return (GLboolean)0;}
GLEEPFNGLUNMAPBUFFERPROC GLeeFuncPtr_glUnmapBuffer=GLee_Lazy_glUnmapBuffe
r;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferParameteriv
#define GLEE_C_DEFINED_glGetBufferParameteriv
void __stdcall GLee_Lazy_glGetBufferParameteriv(GLenum target, GLenum pna
me, GLint * params) {if (GLeeInit()) glGetBufferParameteriv(target, pname,
params);}
GLEEPFNGLGETBUFFERPARAMETERIVPROC GLeeFuncPtr_glGetBufferParameteriv=GLee
_Lazy_glGetBufferParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferPointerv
#define GLEE_C_DEFINED_glGetBufferPointerv
void __stdcall GLee_Lazy_glGetBufferPointerv(GLenum target, GLenum pname,
GLvoid* * params) {if (GLeeInit()) glGetBufferPointerv(target, pname, par
ams);}
GLEEPFNGLGETBUFFERPOINTERVPROC GLeeFuncPtr_glGetBufferPointerv=GLee_Lazy_
glGetBufferPointerv;
#endif
#endif #endif
/* GL_VERSION_2_0 */ /* GL_VERSION_2_0 */
#ifdef __GLEE_GL_VERSION_2_0 #ifdef __GLEE_GL_VERSION_2_0
void __stdcall _Lazy_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlp #ifndef GLEE_C_DEFINED_glBlendEquationSeparate
ha) {if (GLeeInit()) glBlendEquationSeparate(modeRGB, modeAlpha) #define GLEE_C_DEFINED_glBlendEquationSeparate
;} void __stdcall GLee_Lazy_glBlendEquationSeparate(GLenum modeRGB, GLenum m
void __stdcall _Lazy_glDrawBuffers(GLsizei n, const GLenum * bufs) odeAlpha) {if (GLeeInit()) glBlendEquationSeparate(modeRGB, modeAlpha);}
{if (GLeeInit()) glDrawBuffers(n, bufs);} GLEEPFNGLBLENDEQUATIONSEPARATEPROC GLeeFuncPtr_glBlendEquationSeparate=GL
void __stdcall _Lazy_glStencilOpSeparate(GLenum face, GLenum sfail, GLenum ee_Lazy_glBlendEquationSeparate;
dpfail, GLenum dppass) {if (GLeeInit()) glStencilOpSeparate(face, sfail, d #endif
pfail, dppass);} #ifndef GLEE_C_DEFINED_glDrawBuffers
void __stdcall _Lazy_glStencilFuncSeparate(GLenum frontfunc, GLenum backfun #define GLEE_C_DEFINED_glDrawBuffers
c, GLint ref, GLuint mask) {if (GLeeInit()) glStencilFuncSeparate(frontfun void __stdcall GLee_Lazy_glDrawBuffers(GLsizei n, const GLenum * bufs) {
c, backfunc, ref, mask);} if (GLeeInit()) glDrawBuffers(n, bufs);}
void __stdcall _Lazy_glStencilMaskSeparate(GLenum face, GLuint mask) GLEEPFNGLDRAWBUFFERSPROC GLeeFuncPtr_glDrawBuffers=GLee_Lazy_glDrawBuffer
{if (GLeeInit()) glStencilMaskSeparate(face, mask);} s;
void __stdcall _Lazy_glAttachShader(GLuint program, GLuint shader) #endif
{if (GLeeInit()) glAttachShader(program, shader);} #ifndef GLEE_C_DEFINED_glStencilOpSeparate
void __stdcall _Lazy_glBindAttribLocation(GLuint program, GLuint index, con #define GLEE_C_DEFINED_glStencilOpSeparate
st GLchar * name) {if (GLeeInit()) glBindAttribLocation(program, index, na void __stdcall GLee_Lazy_glStencilOpSeparate(GLenum face, GLenum sfail, G
me);} Lenum dpfail, GLenum dppass) {if (GLeeInit()) glStencilOpSeparate(face, sf
void __stdcall _Lazy_glCompileShader(GLuint shader) ail, dpfail, dppass);}
{if (GLeeInit()) glCompileShader(shader);} GLEEPFNGLSTENCILOPSEPARATEPROC GLeeFuncPtr_glStencilOpSeparate=GLee_Lazy_
GLuint __stdcall _Lazy_glCreateProgram(void) glStencilOpSeparate;
{if (GLeeInit()) return glCreateProgram(); return (GLuint)0; #endif
} #ifndef GLEE_C_DEFINED_glStencilFuncSeparate
GLuint __stdcall _Lazy_glCreateShader(GLenum type) #define GLEE_C_DEFINED_glStencilFuncSeparate
{if (GLeeInit()) return glCreateShader(type); return (GLuint void __stdcall GLee_Lazy_glStencilFuncSeparate(GLenum frontfunc, GLenum b
)0;} ackfunc, GLint ref, GLuint mask) {if (GLeeInit()) glStencilFuncSeparate(fr
void __stdcall _Lazy_glDeleteProgram(GLuint program) ontfunc, backfunc, ref, mask);}
{if (GLeeInit()) glDeleteProgram(program);} GLEEPFNGLSTENCILFUNCSEPARATEPROC GLeeFuncPtr_glStencilFuncSeparate=GLee_L
void __stdcall _Lazy_glDeleteShader(GLuint shader) azy_glStencilFuncSeparate;
{if (GLeeInit()) glDeleteShader(shader);} #endif
void __stdcall _Lazy_glDetachShader(GLuint program, GLuint shader) #ifndef GLEE_C_DEFINED_glStencilMaskSeparate
{if (GLeeInit()) glDetachShader(program, shader);} #define GLEE_C_DEFINED_glStencilMaskSeparate
void __stdcall _Lazy_glDisableVertexAttribArray(GLuint index) void __stdcall GLee_Lazy_glStencilMaskSeparate(GLenum face, GLuint mask)
{if (GLeeInit()) glDisableVertexAttribArray(index);} {if (GLeeInit()) glStencilMaskSeparate(face, mask);}
void __stdcall _Lazy_glEnableVertexAttribArray(GLuint index) GLEEPFNGLSTENCILMASKSEPARATEPROC GLeeFuncPtr_glStencilMaskSeparate=GLee_L
{if (GLeeInit()) glEnableVertexAttribArray(index);} azy_glStencilMaskSeparate;
void __stdcall _Lazy_glGetActiveAttrib(GLuint program, GLuint index, GLsize #endif
i bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) { #ifndef GLEE_C_DEFINED_glAttachShader
if (GLeeInit()) glGetActiveAttrib(program, index, bufSize, length, size, ty #define GLEE_C_DEFINED_glAttachShader
pe, name);} void __stdcall GLee_Lazy_glAttachShader(GLuint program, GLuint shader) {
void __stdcall _Lazy_glGetActiveUniform(GLuint program, GLuint index, GLsiz if (GLeeInit()) glAttachShader(program, shader);}
ei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) GLEEPFNGLATTACHSHADERPROC GLeeFuncPtr_glAttachShader=GLee_Lazy_glAttachSh
{if (GLeeInit()) glGetActiveUniform(program, index, bufSize, length, size, ader;
type, name);} #endif
void __stdcall _Lazy_glGetAttachedShaders(GLuint program, GLsizei maxCount, #ifndef GLEE_C_DEFINED_glBindAttribLocation
GLsizei * count, GLuint * obj) {if (GLeeInit()) glGetAttachedShaders(prog #define GLEE_C_DEFINED_glBindAttribLocation
ram, maxCount, count, obj);} void __stdcall GLee_Lazy_glBindAttribLocation(GLuint program, GLuint inde
GLint __stdcall _Lazy_glGetAttribLocation(GLuint program, const GLchar * na x, const GLchar * name) {if (GLeeInit()) glBindAttribLocation(program, ind
me) {if (GLeeInit()) return glGetAttribLocation(program, name); ex, name);}
return (GLint)0;} GLEEPFNGLBINDATTRIBLOCATIONPROC GLeeFuncPtr_glBindAttribLocation=GLee_Laz
void __stdcall _Lazy_glGetProgramiv(GLuint program, GLenum pname, GLint * p y_glBindAttribLocation;
arams) {if (GLeeInit()) glGetProgramiv(program, pname, params);} #endif
void __stdcall _Lazy_glGetProgramInfoLog(GLuint program, GLsizei bufSize, G #ifndef GLEE_C_DEFINED_glCompileShader
Lsizei * length, GLchar * infoLog) {if (GLeeInit()) glGetProgramInfoLog(pr #define GLEE_C_DEFINED_glCompileShader
ogram, bufSize, length, infoLog);} void __stdcall GLee_Lazy_glCompileShader(GLuint shader) {if (GLeeInit())
void __stdcall _Lazy_glGetShaderiv(GLuint shader, GLenum pname, GLint * par glCompileShader(shader);}
ams) {if (GLeeInit()) glGetShaderiv(shader, pname, params);} GLEEPFNGLCOMPILESHADERPROC GLeeFuncPtr_glCompileShader=GLee_Lazy_glCompil
void __stdcall _Lazy_glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLs eShader;
izei * length, GLchar * infoLog) {if (GLeeInit()) glGetShaderInfoLog(shade #endif
r, bufSize, length, infoLog);} #ifndef GLEE_C_DEFINED_glCreateProgram
void __stdcall _Lazy_glGetShaderSource(GLuint shader, GLsizei bufSize, GLsi #define GLEE_C_DEFINED_glCreateProgram
zei * length, GLchar * source) {if (GLeeInit()) glGetShaderSource(shader, GLuint __stdcall GLee_Lazy_glCreateProgram(void) {if (GLeeInit()) return
bufSize, length, source);} glCreateProgram(); return (GLuint)0;}
GLint __stdcall _Lazy_glGetUniformLocation(GLuint program, const GLchar * n GLEEPFNGLCREATEPROGRAMPROC GLeeFuncPtr_glCreateProgram=GLee_Lazy_glCreate
ame) {if (GLeeInit()) return glGetUniformLocation(program, name); Program;
return (GLint)0;} #endif
void __stdcall _Lazy_glGetUniformfv(GLuint program, GLint location, GLfloat #ifndef GLEE_C_DEFINED_glCreateShader
* params) {if (GLeeInit()) glGetUniformfv(program, location, params);} #define GLEE_C_DEFINED_glCreateShader
void __stdcall _Lazy_glGetUniformiv(GLuint program, GLint location, GLint * GLuint __stdcall GLee_Lazy_glCreateShader(GLenum type) {if (GLeeInit())
params) {if (GLeeInit()) glGetUniformiv(program, location, params);} return glCreateShader(type); return (GLuint)0;}
void __stdcall _Lazy_glGetVertexAttribdv(GLuint index, GLenum pname, GLdoub GLEEPFNGLCREATESHADERPROC GLeeFuncPtr_glCreateShader=GLee_Lazy_glCreateSh
le * params) {if (GLeeInit()) glGetVertexAttribdv(index, pname, params);} ader;
void __stdcall _Lazy_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloa #endif
t * params) {if (GLeeInit()) glGetVertexAttribfv(index, pname, params);} #ifndef GLEE_C_DEFINED_glDeleteProgram
void __stdcall _Lazy_glGetVertexAttribiv(GLuint index, GLenum pname, GLint #define GLEE_C_DEFINED_glDeleteProgram
* params) {if (GLeeInit()) glGetVertexAttribiv(index, pname, params);} void __stdcall GLee_Lazy_glDeleteProgram(GLuint program) {if (GLeeInit()
void __stdcall _Lazy_glGetVertexAttribPointerv(GLuint index, GLenum pname, ) glDeleteProgram(program);}
GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointerv(index, pname GLEEPFNGLDELETEPROGRAMPROC GLeeFuncPtr_glDeleteProgram=GLee_Lazy_glDelete
, pointer);} Program;
GLboolean __stdcall _Lazy_glIsProgram(GLuint program) #endif
{if (GLeeInit()) return glIsProgram(program); return (GLbool #ifndef GLEE_C_DEFINED_glDeleteShader
ean)0;} #define GLEE_C_DEFINED_glDeleteShader
GLboolean __stdcall _Lazy_glIsShader(GLuint shader) void __stdcall GLee_Lazy_glDeleteShader(GLuint shader) {if (GLeeInit())
{if (GLeeInit()) return glIsShader(shader); return (GLboolea glDeleteShader(shader);}
n)0;} GLEEPFNGLDELETESHADERPROC GLeeFuncPtr_glDeleteShader=GLee_Lazy_glDeleteSh
void __stdcall _Lazy_glLinkProgram(GLuint program) ader;
{if (GLeeInit()) glLinkProgram(program);} #endif
void __stdcall _Lazy_glShaderSource(GLuint shader, GLsizei count, const GLc #ifndef GLEE_C_DEFINED_glDetachShader
har* * string, const GLint * length) {if (GLeeInit()) glShaderSource(shade #define GLEE_C_DEFINED_glDetachShader
r, count, string, length);} void __stdcall GLee_Lazy_glDetachShader(GLuint program, GLuint shader) {
void __stdcall _Lazy_glUseProgram(GLuint program) if (GLeeInit()) glDetachShader(program, shader);}
{if (GLeeInit()) glUseProgram(program);} GLEEPFNGLDETACHSHADERPROC GLeeFuncPtr_glDetachShader=GLee_Lazy_glDetachSh
void __stdcall _Lazy_glUniform1f(GLint location, GLfloat v0) ader;
{if (GLeeInit()) glUniform1f(location, v0);} #endif
void __stdcall _Lazy_glUniform2f(GLint location, GLfloat v0, GLfloat v1) #ifndef GLEE_C_DEFINED_glDisableVertexAttribArray
{if (GLeeInit()) glUniform2f(location, v0, v1);} #define GLEE_C_DEFINED_glDisableVertexAttribArray
void __stdcall _Lazy_glUniform3f(GLint location, GLfloat v0, GLfloat v1, GL void __stdcall GLee_Lazy_glDisableVertexAttribArray(GLuint index) {if (G
float v2) {if (GLeeInit()) glUniform3f(location, v0, v1, v2);} LeeInit()) glDisableVertexAttribArray(index);}
void __stdcall _Lazy_glUniform4f(GLint location, GLfloat v0, GLfloat v1, GL GLEEPFNGLDISABLEVERTEXATTRIBARRAYPROC GLeeFuncPtr_glDisableVertexAttribAr
float v2, GLfloat v3) {if (GLeeInit()) glUniform4f(location, v0, v1, v2, v ray=GLee_Lazy_glDisableVertexAttribArray;
3);} #endif
void __stdcall _Lazy_glUniform1i(GLint location, GLint v0) #ifndef GLEE_C_DEFINED_glEnableVertexAttribArray
{if (GLeeInit()) glUniform1i(location, v0);} #define GLEE_C_DEFINED_glEnableVertexAttribArray
void __stdcall _Lazy_glUniform2i(GLint location, GLint v0, GLint v1) void __stdcall GLee_Lazy_glEnableVertexAttribArray(GLuint index) {if (GL
{if (GLeeInit()) glUniform2i(location, v0, v1);} eeInit()) glEnableVertexAttribArray(index);}
void __stdcall _Lazy_glUniform3i(GLint location, GLint v0, GLint v1, GLint GLEEPFNGLENABLEVERTEXATTRIBARRAYPROC GLeeFuncPtr_glEnableVertexAttribArra
v2) {if (GLeeInit()) glUniform3i(location, v0, v1, v2);} y=GLee_Lazy_glEnableVertexAttribArray;
void __stdcall _Lazy_glUniform4i(GLint location, GLint v0, GLint v1, GLint #endif
v2, GLint v3) {if (GLeeInit()) glUniform4i(location, v0, v1, v2, v3);} #ifndef GLEE_C_DEFINED_glGetActiveAttrib
void __stdcall _Lazy_glUniform1fv(GLint location, GLsizei count, const GLfl #define GLEE_C_DEFINED_glGetActiveAttrib
oat * value) {if (GLeeInit()) glUniform1fv(location, count, value);} void __stdcall GLee_Lazy_glGetActiveAttrib(GLuint program, GLuint index,
void __stdcall _Lazy_glUniform2fv(GLint location, GLsizei count, const GLfl GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * na
oat * value) {if (GLeeInit()) glUniform2fv(location, count, value);} me) {if (GLeeInit()) glGetActiveAttrib(program, index, bufSize, length, si
void __stdcall _Lazy_glUniform3fv(GLint location, GLsizei count, const GLfl ze, type, name);}
oat * value) {if (GLeeInit()) glUniform3fv(location, count, value);} GLEEPFNGLGETACTIVEATTRIBPROC GLeeFuncPtr_glGetActiveAttrib=GLee_Lazy_glGe
void __stdcall _Lazy_glUniform4fv(GLint location, GLsizei count, const GLfl tActiveAttrib;
oat * value) {if (GLeeInit()) glUniform4fv(location, count, value);} #endif
void __stdcall _Lazy_glUniform1iv(GLint location, GLsizei count, const GLin #ifndef GLEE_C_DEFINED_glGetActiveUniform
t * value) {if (GLeeInit()) glUniform1iv(location, count, value);} #define GLEE_C_DEFINED_glGetActiveUniform
void __stdcall _Lazy_glUniform2iv(GLint location, GLsizei count, const GLin void __stdcall GLee_Lazy_glGetActiveUniform(GLuint program, GLuint index,
t * value) {if (GLeeInit()) glUniform2iv(location, count, value);} GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * n
void __stdcall _Lazy_glUniform3iv(GLint location, GLsizei count, const GLin ame) {if (GLeeInit()) glGetActiveUniform(program, index, bufSize, length,
t * value) {if (GLeeInit()) glUniform3iv(location, count, value);} size, type, name);}
void __stdcall _Lazy_glUniform4iv(GLint location, GLsizei count, const GLin GLEEPFNGLGETACTIVEUNIFORMPROC GLeeFuncPtr_glGetActiveUniform=GLee_Lazy_gl
t * value) {if (GLeeInit()) glUniform4iv(location, count, value);} GetActiveUniform;
void __stdcall _Lazy_glUniformMatrix2fv(GLint location, GLsizei count, GLbo #endif
olean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix2f #ifndef GLEE_C_DEFINED_glGetAttachedShaders
v(location, count, transpose, value);} #define GLEE_C_DEFINED_glGetAttachedShaders
void __stdcall _Lazy_glUniformMatrix3fv(GLint location, GLsizei count, GLbo void __stdcall GLee_Lazy_glGetAttachedShaders(GLuint program, GLsizei max
olean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix3f Count, GLsizei * count, GLuint * obj) {if (GLeeInit()) glGetAttachedShader
v(location, count, transpose, value);} s(program, maxCount, count, obj);}
void __stdcall _Lazy_glUniformMatrix4fv(GLint location, GLsizei count, GLbo GLEEPFNGLGETATTACHEDSHADERSPROC GLeeFuncPtr_glGetAttachedShaders=GLee_Laz
olean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix4f y_glGetAttachedShaders;
v(location, count, transpose, value);} #endif
void __stdcall _Lazy_glValidateProgram(GLuint program) #ifndef GLEE_C_DEFINED_glGetAttribLocation
{if (GLeeInit()) glValidateProgram(program);} #define GLEE_C_DEFINED_glGetAttribLocation
void __stdcall _Lazy_glVertexAttrib1d(GLuint index, GLdouble x) GLint __stdcall GLee_Lazy_glGetAttribLocation(GLuint program, const GLcha
{if (GLeeInit()) glVertexAttrib1d(index, x);} r * name) {if (GLeeInit()) return glGetAttribLocation(program, name); retu
void __stdcall _Lazy_glVertexAttrib1dv(GLuint index, const GLdouble * v) rn (GLint)0;}
{if (GLeeInit()) glVertexAttrib1dv(index, v);} GLEEPFNGLGETATTRIBLOCATIONPROC GLeeFuncPtr_glGetAttribLocation=GLee_Lazy_
void __stdcall _Lazy_glVertexAttrib1f(GLuint index, GLfloat x) glGetAttribLocation;
{if (GLeeInit()) glVertexAttrib1f(index, x);} #endif
void __stdcall _Lazy_glVertexAttrib1fv(GLuint index, const GLfloat * v) #ifndef GLEE_C_DEFINED_glGetProgramiv
{if (GLeeInit()) glVertexAttrib1fv(index, v);} #define GLEE_C_DEFINED_glGetProgramiv
void __stdcall _Lazy_glVertexAttrib1s(GLuint index, GLshort x) void __stdcall GLee_Lazy_glGetProgramiv(GLuint program, GLenum pname, GLi
{if (GLeeInit()) glVertexAttrib1s(index, x);} nt * params) {if (GLeeInit()) glGetProgramiv(program, pname, params);}
void __stdcall _Lazy_glVertexAttrib1sv(GLuint index, const GLshort * v) GLEEPFNGLGETPROGRAMIVPROC GLeeFuncPtr_glGetProgramiv=GLee_Lazy_glGetProgr
{if (GLeeInit()) glVertexAttrib1sv(index, v);} amiv;
void __stdcall _Lazy_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) #endif
{if (GLeeInit()) glVertexAttrib2d(index, x, y);} #ifndef GLEE_C_DEFINED_glGetProgramInfoLog
void __stdcall _Lazy_glVertexAttrib2dv(GLuint index, const GLdouble * v) #define GLEE_C_DEFINED_glGetProgramInfoLog
{if (GLeeInit()) glVertexAttrib2dv(index, v);} void __stdcall GLee_Lazy_glGetProgramInfoLog(GLuint program, GLsizei bufS
void __stdcall _Lazy_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) ize, GLsizei * length, GLchar * infoLog) {if (GLeeInit()) glGetProgramInfo
{if (GLeeInit()) glVertexAttrib2f(index, x, y);} Log(program, bufSize, length, infoLog);}
void __stdcall _Lazy_glVertexAttrib2fv(GLuint index, const GLfloat * v) GLEEPFNGLGETPROGRAMINFOLOGPROC GLeeFuncPtr_glGetProgramInfoLog=GLee_Lazy_
{if (GLeeInit()) glVertexAttrib2fv(index, v);} glGetProgramInfoLog;
void __stdcall _Lazy_glVertexAttrib2s(GLuint index, GLshort x, GLshort y) #endif
{if (GLeeInit()) glVertexAttrib2s(index, x, y);} #ifndef GLEE_C_DEFINED_glGetShaderiv
void __stdcall _Lazy_glVertexAttrib2sv(GLuint index, const GLshort * v) #define GLEE_C_DEFINED_glGetShaderiv
{if (GLeeInit()) glVertexAttrib2sv(index, v);} void __stdcall GLee_Lazy_glGetShaderiv(GLuint shader, GLenum pname, GLint
void __stdcall _Lazy_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, * params) {if (GLeeInit()) glGetShaderiv(shader, pname, params);}
GLdouble z) {if (GLeeInit()) glVertexAttrib3d(index, x, y, z);} GLEEPFNGLGETSHADERIVPROC GLeeFuncPtr_glGetShaderiv=GLee_Lazy_glGetShaderi
void __stdcall _Lazy_glVertexAttrib3dv(GLuint index, const GLdouble * v) v;
{if (GLeeInit()) glVertexAttrib3dv(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, G #ifndef GLEE_C_DEFINED_glGetShaderInfoLog
Lfloat z) {if (GLeeInit()) glVertexAttrib3f(index, x, y, z);} #define GLEE_C_DEFINED_glGetShaderInfoLog
void __stdcall _Lazy_glVertexAttrib3fv(GLuint index, const GLfloat * v) void __stdcall GLee_Lazy_glGetShaderInfoLog(GLuint shader, GLsizei bufSiz
{if (GLeeInit()) glVertexAttrib3fv(index, v);} e, GLsizei * length, GLchar * infoLog) {if (GLeeInit()) glGetShaderInfoLog
void __stdcall _Lazy_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, G (shader, bufSize, length, infoLog);}
Lshort z) {if (GLeeInit()) glVertexAttrib3s(index, x, y, z);} GLEEPFNGLGETSHADERINFOLOGPROC GLeeFuncPtr_glGetShaderInfoLog=GLee_Lazy_gl
void __stdcall _Lazy_glVertexAttrib3sv(GLuint index, const GLshort * v) GetShaderInfoLog;
{if (GLeeInit()) glVertexAttrib3sv(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib4Nbv(GLuint index, const GLbyte * v) #ifndef GLEE_C_DEFINED_glGetShaderSource
{if (GLeeInit()) glVertexAttrib4Nbv(index, v);} #define GLEE_C_DEFINED_glGetShaderSource
void __stdcall _Lazy_glVertexAttrib4Niv(GLuint index, const GLint * v) void __stdcall GLee_Lazy_glGetShaderSource(GLuint shader, GLsizei bufSize
{if (GLeeInit()) glVertexAttrib4Niv(index, v);} , GLsizei * length, GLchar * source) {if (GLeeInit()) glGetShaderSource(sh
void __stdcall _Lazy_glVertexAttrib4Nsv(GLuint index, const GLshort * v) ader, bufSize, length, source);}
{if (GLeeInit()) glVertexAttrib4Nsv(index, v);} GLEEPFNGLGETSHADERSOURCEPROC GLeeFuncPtr_glGetShaderSource=GLee_Lazy_glGe
void __stdcall _Lazy_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, tShaderSource;
GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4Nub(index, x, y, z, #endif
w);} #ifndef GLEE_C_DEFINED_glGetUniformLocation
void __stdcall _Lazy_glVertexAttrib4Nubv(GLuint index, const GLubyte * v) #define GLEE_C_DEFINED_glGetUniformLocation
{if (GLeeInit()) glVertexAttrib4Nubv(index, v);} GLint __stdcall GLee_Lazy_glGetUniformLocation(GLuint program, const GLch
void __stdcall _Lazy_glVertexAttrib4Nuiv(GLuint index, const GLuint * v) ar * name) {if (GLeeInit()) return glGetUniformLocation(program, name); re
{if (GLeeInit()) glVertexAttrib4Nuiv(index, v);} turn (GLint)0;}
void __stdcall _Lazy_glVertexAttrib4Nusv(GLuint index, const GLushort * v) GLEEPFNGLGETUNIFORMLOCATIONPROC GLeeFuncPtr_glGetUniformLocation=GLee_Laz
{if (GLeeInit()) glVertexAttrib4Nusv(index, v);} y_glGetUniformLocation;
void __stdcall _Lazy_glVertexAttrib4bv(GLuint index, const GLbyte * v) #endif
{if (GLeeInit()) glVertexAttrib4bv(index, v);} #ifndef GLEE_C_DEFINED_glGetUniformfv
void __stdcall _Lazy_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, #define GLEE_C_DEFINED_glGetUniformfv
GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4d(index, x, y, z, void __stdcall GLee_Lazy_glGetUniformfv(GLuint program, GLint location, G
w);} Lfloat * params) {if (GLeeInit()) glGetUniformfv(program, location, params
void __stdcall _Lazy_glVertexAttrib4dv(GLuint index, const GLdouble * v) );}
{if (GLeeInit()) glVertexAttrib4dv(index, v);} GLEEPFNGLGETUNIFORMFVPROC GLeeFuncPtr_glGetUniformfv=GLee_Lazy_glGetUnifo
void __stdcall _Lazy_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, G rmfv;
Lfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4f(index, x, y, z, w); #endif
} #ifndef GLEE_C_DEFINED_glGetUniformiv
void __stdcall _Lazy_glVertexAttrib4fv(GLuint index, const GLfloat * v) #define GLEE_C_DEFINED_glGetUniformiv
{if (GLeeInit()) glVertexAttrib4fv(index, v);} void __stdcall GLee_Lazy_glGetUniformiv(GLuint program, GLint location, G
void __stdcall _Lazy_glVertexAttrib4iv(GLuint index, const GLint * v) Lint * params) {if (GLeeInit()) glGetUniformiv(program, location, params);
{if (GLeeInit()) glVertexAttrib4iv(index, v);} }
void __stdcall _Lazy_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, G GLEEPFNGLGETUNIFORMIVPROC GLeeFuncPtr_glGetUniformiv=GLee_Lazy_glGetUnifo
Lshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4s(index, x, y, z, w); rmiv;
} #endif
void __stdcall _Lazy_glVertexAttrib4sv(GLuint index, const GLshort * v) #ifndef GLEE_C_DEFINED_glGetVertexAttribdv
{if (GLeeInit()) glVertexAttrib4sv(index, v);} #define GLEE_C_DEFINED_glGetVertexAttribdv
void __stdcall _Lazy_glVertexAttrib4ubv(GLuint index, const GLubyte * v) void __stdcall GLee_Lazy_glGetVertexAttribdv(GLuint index, GLenum pname,
{if (GLeeInit()) glVertexAttrib4ubv(index, v);} GLdouble * params) {if (GLeeInit()) glGetVertexAttribdv(index, pname, para
void __stdcall _Lazy_glVertexAttrib4uiv(GLuint index, const GLuint * v) ms);}
{if (GLeeInit()) glVertexAttrib4uiv(index, v);} GLEEPFNGLGETVERTEXATTRIBDVPROC GLeeFuncPtr_glGetVertexAttribdv=GLee_Lazy_
void __stdcall _Lazy_glVertexAttrib4usv(GLuint index, const GLushort * v) glGetVertexAttribdv;
{if (GLeeInit()) glVertexAttrib4usv(index, v);} #endif
void __stdcall _Lazy_glVertexAttribPointer(GLuint index, GLint size, GLenum #ifndef GLEE_C_DEFINED_glGetVertexAttribfv
type, GLboolean normalized, GLsizei stride, const GLvoid * pointer) {if ( #define GLEE_C_DEFINED_glGetVertexAttribfv
GLeeInit()) glVertexAttribPointer(index, size, type, normalized, stride, po void __stdcall GLee_Lazy_glGetVertexAttribfv(GLuint index, GLenum pname,
inter);} GLfloat * params) {if (GLeeInit()) glGetVertexAttribfv(index, pname, param
PFNGLBLENDEQUATIONSEPARATEPROC pglBlendEquationSeparate=_Lazy_glBlendEquati s);}
onSeparate; GLEEPFNGLGETVERTEXATTRIBFVPROC GLeeFuncPtr_glGetVertexAttribfv=GLee_Lazy_
PFNGLDRAWBUFFERSPROC pglDrawBuffers=_Lazy_glDrawBuffers; glGetVertexAttribfv;
PFNGLSTENCILOPSEPARATEPROC pglStencilOpSeparate=_Lazy_glStencilOpSeparate; #endif
PFNGLSTENCILFUNCSEPARATEPROC pglStencilFuncSeparate=_Lazy_glStencilFuncSepa #ifndef GLEE_C_DEFINED_glGetVertexAttribiv
rate; #define GLEE_C_DEFINED_glGetVertexAttribiv
PFNGLSTENCILMASKSEPARATEPROC pglStencilMaskSeparate=_Lazy_glStencilMaskSepa void __stdcall GLee_Lazy_glGetVertexAttribiv(GLuint index, GLenum pname,
rate; GLint * params) {if (GLeeInit()) glGetVertexAttribiv(index, pname, params)
PFNGLATTACHSHADERPROC pglAttachShader=_Lazy_glAttachShader; ;}
PFNGLBINDATTRIBLOCATIONPROC pglBindAttribLocation=_Lazy_glBindAttribLocatio GLEEPFNGLGETVERTEXATTRIBIVPROC GLeeFuncPtr_glGetVertexAttribiv=GLee_Lazy_
n; glGetVertexAttribiv;
PFNGLCOMPILESHADERPROC pglCompileShader=_Lazy_glCompileShader; #endif
PFNGLCREATEPROGRAMPROC pglCreateProgram=_Lazy_glCreateProgram; #ifndef GLEE_C_DEFINED_glGetVertexAttribPointerv
PFNGLCREATESHADERPROC pglCreateShader=_Lazy_glCreateShader; #define GLEE_C_DEFINED_glGetVertexAttribPointerv
PFNGLDELETEPROGRAMPROC pglDeleteProgram=_Lazy_glDeleteProgram; void __stdcall GLee_Lazy_glGetVertexAttribPointerv(GLuint index, GLenum p
PFNGLDELETESHADERPROC pglDeleteShader=_Lazy_glDeleteShader; name, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointerv(index,
PFNGLDETACHSHADERPROC pglDetachShader=_Lazy_glDetachShader; pname, pointer);}
PFNGLDISABLEVERTEXATTRIBARRAYPROC pglDisableVertexAttribArray=_Lazy_glDisab GLEEPFNGLGETVERTEXATTRIBPOINTERVPROC GLeeFuncPtr_glGetVertexAttribPointer
leVertexAttribArray; v=GLee_Lazy_glGetVertexAttribPointerv;
PFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray=_Lazy_glEnableV #endif
ertexAttribArray; #ifndef GLEE_C_DEFINED_glIsProgram
PFNGLGETACTIVEATTRIBPROC pglGetActiveAttrib=_Lazy_glGetActiveAttrib; #define GLEE_C_DEFINED_glIsProgram
PFNGLGETACTIVEUNIFORMPROC pglGetActiveUniform=_Lazy_glGetActiveUniform; GLboolean __stdcall GLee_Lazy_glIsProgram(GLuint program) {if (GLeeInit(
PFNGLGETATTACHEDSHADERSPROC pglGetAttachedShaders=_Lazy_glGetAttachedShader )) return glIsProgram(program); return (GLboolean)0;}
s; GLEEPFNGLISPROGRAMPROC GLeeFuncPtr_glIsProgram=GLee_Lazy_glIsProgram;
PFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation=_Lazy_glGetAttribLocation; #endif
PFNGLGETPROGRAMIVPROC pglGetProgramiv=_Lazy_glGetProgramiv; #ifndef GLEE_C_DEFINED_glIsShader
PFNGLGETPROGRAMINFOLOGPROC pglGetProgramInfoLog=_Lazy_glGetProgramInfoLog; #define GLEE_C_DEFINED_glIsShader
PFNGLGETSHADERIVPROC pglGetShaderiv=_Lazy_glGetShaderiv; GLboolean __stdcall GLee_Lazy_glIsShader(GLuint shader) {if (GLeeInit())
PFNGLGETSHADERINFOLOGPROC pglGetShaderInfoLog=_Lazy_glGetShaderInfoLog; return glIsShader(shader); return (GLboolean)0;}
PFNGLGETSHADERSOURCEPROC pglGetShaderSource=_Lazy_glGetShaderSource; GLEEPFNGLISSHADERPROC GLeeFuncPtr_glIsShader=GLee_Lazy_glIsShader;
PFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation=_Lazy_glGetUniformLocatio #endif
n; #ifndef GLEE_C_DEFINED_glLinkProgram
PFNGLGETUNIFORMFVPROC pglGetUniformfv=_Lazy_glGetUniformfv; #define GLEE_C_DEFINED_glLinkProgram
PFNGLGETUNIFORMIVPROC pglGetUniformiv=_Lazy_glGetUniformiv; void __stdcall GLee_Lazy_glLinkProgram(GLuint program) {if (GLeeInit())
PFNGLGETVERTEXATTRIBDVPROC pglGetVertexAttribdv=_Lazy_glGetVertexAttribdv; glLinkProgram(program);}
PFNGLGETVERTEXATTRIBFVPROC pglGetVertexAttribfv=_Lazy_glGetVertexAttribfv; GLEEPFNGLLINKPROGRAMPROC GLeeFuncPtr_glLinkProgram=GLee_Lazy_glLinkProgra
PFNGLGETVERTEXATTRIBIVPROC pglGetVertexAttribiv=_Lazy_glGetVertexAttribiv; m;
PFNGLGETVERTEXATTRIBPOINTERVPROC pglGetVertexAttribPointerv=_Lazy_glGetVert #endif
exAttribPointerv; #ifndef GLEE_C_DEFINED_glShaderSource
PFNGLISPROGRAMPROC pglIsProgram=_Lazy_glIsProgram; #define GLEE_C_DEFINED_glShaderSource
PFNGLISSHADERPROC pglIsShader=_Lazy_glIsShader; void __stdcall GLee_Lazy_glShaderSource(GLuint shader, GLsizei count, con
PFNGLLINKPROGRAMPROC pglLinkProgram=_Lazy_glLinkProgram; st GLchar* * string, const GLint * length) {if (GLeeInit()) glShaderSource
PFNGLSHADERSOURCEPROC pglShaderSource=_Lazy_glShaderSource; (shader, count, string, length);}
PFNGLUSEPROGRAMPROC pglUseProgram=_Lazy_glUseProgram; GLEEPFNGLSHADERSOURCEPROC GLeeFuncPtr_glShaderSource=GLee_Lazy_glShaderSo
PFNGLUNIFORM1FPROC pglUniform1f=_Lazy_glUniform1f; urce;
PFNGLUNIFORM2FPROC pglUniform2f=_Lazy_glUniform2f; #endif
PFNGLUNIFORM3FPROC pglUniform3f=_Lazy_glUniform3f; #ifndef GLEE_C_DEFINED_glUseProgram
PFNGLUNIFORM4FPROC pglUniform4f=_Lazy_glUniform4f; #define GLEE_C_DEFINED_glUseProgram
PFNGLUNIFORM1IPROC pglUniform1i=_Lazy_glUniform1i; void __stdcall GLee_Lazy_glUseProgram(GLuint program) {if (GLeeInit()) g
PFNGLUNIFORM2IPROC pglUniform2i=_Lazy_glUniform2i; lUseProgram(program);}
PFNGLUNIFORM3IPROC pglUniform3i=_Lazy_glUniform3i; GLEEPFNGLUSEPROGRAMPROC GLeeFuncPtr_glUseProgram=GLee_Lazy_glUseProgram;
PFNGLUNIFORM4IPROC pglUniform4i=_Lazy_glUniform4i; #endif
PFNGLUNIFORM1FVPROC pglUniform1fv=_Lazy_glUniform1fv; #ifndef GLEE_C_DEFINED_glUniform1f
PFNGLUNIFORM2FVPROC pglUniform2fv=_Lazy_glUniform2fv; #define GLEE_C_DEFINED_glUniform1f
PFNGLUNIFORM3FVPROC pglUniform3fv=_Lazy_glUniform3fv; void __stdcall GLee_Lazy_glUniform1f(GLint location, GLfloat v0) {if (GL
PFNGLUNIFORM4FVPROC pglUniform4fv=_Lazy_glUniform4fv; eeInit()) glUniform1f(location, v0);}
PFNGLUNIFORM1IVPROC pglUniform1iv=_Lazy_glUniform1iv; GLEEPFNGLUNIFORM1FPROC GLeeFuncPtr_glUniform1f=GLee_Lazy_glUniform1f;
PFNGLUNIFORM2IVPROC pglUniform2iv=_Lazy_glUniform2iv; #endif
PFNGLUNIFORM3IVPROC pglUniform3iv=_Lazy_glUniform3iv; #ifndef GLEE_C_DEFINED_glUniform2f
PFNGLUNIFORM4IVPROC pglUniform4iv=_Lazy_glUniform4iv; #define GLEE_C_DEFINED_glUniform2f
PFNGLUNIFORMMATRIX2FVPROC pglUniformMatrix2fv=_Lazy_glUniformMatrix2fv; void __stdcall GLee_Lazy_glUniform2f(GLint location, GLfloat v0, GLfloat
PFNGLUNIFORMMATRIX3FVPROC pglUniformMatrix3fv=_Lazy_glUniformMatrix3fv; v1) {if (GLeeInit()) glUniform2f(location, v0, v1);}
PFNGLUNIFORMMATRIX4FVPROC pglUniformMatrix4fv=_Lazy_glUniformMatrix4fv; GLEEPFNGLUNIFORM2FPROC GLeeFuncPtr_glUniform2f=GLee_Lazy_glUniform2f;
PFNGLVALIDATEPROGRAMPROC pglValidateProgram=_Lazy_glValidateProgram; #endif
PFNGLVERTEXATTRIB1DPROC pglVertexAttrib1d=_Lazy_glVertexAttrib1d; #ifndef GLEE_C_DEFINED_glUniform3f
PFNGLVERTEXATTRIB1DVPROC pglVertexAttrib1dv=_Lazy_glVertexAttrib1dv; #define GLEE_C_DEFINED_glUniform3f
PFNGLVERTEXATTRIB1FPROC pglVertexAttrib1f=_Lazy_glVertexAttrib1f; void __stdcall GLee_Lazy_glUniform3f(GLint location, GLfloat v0, GLfloat
PFNGLVERTEXATTRIB1FVPROC pglVertexAttrib1fv=_Lazy_glVertexAttrib1fv; v1, GLfloat v2) {if (GLeeInit()) glUniform3f(location, v0, v1, v2);}
PFNGLVERTEXATTRIB1SPROC pglVertexAttrib1s=_Lazy_glVertexAttrib1s; GLEEPFNGLUNIFORM3FPROC GLeeFuncPtr_glUniform3f=GLee_Lazy_glUniform3f;
PFNGLVERTEXATTRIB1SVPROC pglVertexAttrib1sv=_Lazy_glVertexAttrib1sv; #endif
PFNGLVERTEXATTRIB2DPROC pglVertexAttrib2d=_Lazy_glVertexAttrib2d; #ifndef GLEE_C_DEFINED_glUniform4f
PFNGLVERTEXATTRIB2DVPROC pglVertexAttrib2dv=_Lazy_glVertexAttrib2dv; #define GLEE_C_DEFINED_glUniform4f
PFNGLVERTEXATTRIB2FPROC pglVertexAttrib2f=_Lazy_glVertexAttrib2f; void __stdcall GLee_Lazy_glUniform4f(GLint location, GLfloat v0, GLfloat
PFNGLVERTEXATTRIB2FVPROC pglVertexAttrib2fv=_Lazy_glVertexAttrib2fv; v1, GLfloat v2, GLfloat v3) {if (GLeeInit()) glUniform4f(location, v0, v1,
PFNGLVERTEXATTRIB2SPROC pglVertexAttrib2s=_Lazy_glVertexAttrib2s; v2, v3);}
PFNGLVERTEXATTRIB2SVPROC pglVertexAttrib2sv=_Lazy_glVertexAttrib2sv; GLEEPFNGLUNIFORM4FPROC GLeeFuncPtr_glUniform4f=GLee_Lazy_glUniform4f;
PFNGLVERTEXATTRIB3DPROC pglVertexAttrib3d=_Lazy_glVertexAttrib3d; #endif
PFNGLVERTEXATTRIB3DVPROC pglVertexAttrib3dv=_Lazy_glVertexAttrib3dv; #ifndef GLEE_C_DEFINED_glUniform1i
PFNGLVERTEXATTRIB3FPROC pglVertexAttrib3f=_Lazy_glVertexAttrib3f; #define GLEE_C_DEFINED_glUniform1i
PFNGLVERTEXATTRIB3FVPROC pglVertexAttrib3fv=_Lazy_glVertexAttrib3fv; void __stdcall GLee_Lazy_glUniform1i(GLint location, GLint v0) {if (GLee
PFNGLVERTEXATTRIB3SPROC pglVertexAttrib3s=_Lazy_glVertexAttrib3s; Init()) glUniform1i(location, v0);}
PFNGLVERTEXATTRIB3SVPROC pglVertexAttrib3sv=_Lazy_glVertexAttrib3sv; GLEEPFNGLUNIFORM1IPROC GLeeFuncPtr_glUniform1i=GLee_Lazy_glUniform1i;
PFNGLVERTEXATTRIB4NBVPROC pglVertexAttrib4Nbv=_Lazy_glVertexAttrib4Nbv; #endif
PFNGLVERTEXATTRIB4NIVPROC pglVertexAttrib4Niv=_Lazy_glVertexAttrib4Niv; #ifndef GLEE_C_DEFINED_glUniform2i
PFNGLVERTEXATTRIB4NSVPROC pglVertexAttrib4Nsv=_Lazy_glVertexAttrib4Nsv; #define GLEE_C_DEFINED_glUniform2i
PFNGLVERTEXATTRIB4NUBPROC pglVertexAttrib4Nub=_Lazy_glVertexAttrib4Nub; void __stdcall GLee_Lazy_glUniform2i(GLint location, GLint v0, GLint v1)
PFNGLVERTEXATTRIB4NUBVPROC pglVertexAttrib4Nubv=_Lazy_glVertexAttrib4Nubv; {if (GLeeInit()) glUniform2i(location, v0, v1);}
PFNGLVERTEXATTRIB4NUIVPROC pglVertexAttrib4Nuiv=_Lazy_glVertexAttrib4Nuiv; GLEEPFNGLUNIFORM2IPROC GLeeFuncPtr_glUniform2i=GLee_Lazy_glUniform2i;
PFNGLVERTEXATTRIB4NUSVPROC pglVertexAttrib4Nusv=_Lazy_glVertexAttrib4Nusv; #endif
PFNGLVERTEXATTRIB4BVPROC pglVertexAttrib4bv=_Lazy_glVertexAttrib4bv; #ifndef GLEE_C_DEFINED_glUniform3i
PFNGLVERTEXATTRIB4DPROC pglVertexAttrib4d=_Lazy_glVertexAttrib4d; #define GLEE_C_DEFINED_glUniform3i
PFNGLVERTEXATTRIB4DVPROC pglVertexAttrib4dv=_Lazy_glVertexAttrib4dv; void __stdcall GLee_Lazy_glUniform3i(GLint location, GLint v0, GLint v1,
PFNGLVERTEXATTRIB4FPROC pglVertexAttrib4f=_Lazy_glVertexAttrib4f; GLint v2) {if (GLeeInit()) glUniform3i(location, v0, v1, v2);}
PFNGLVERTEXATTRIB4FVPROC pglVertexAttrib4fv=_Lazy_glVertexAttrib4fv; GLEEPFNGLUNIFORM3IPROC GLeeFuncPtr_glUniform3i=GLee_Lazy_glUniform3i;
PFNGLVERTEXATTRIB4IVPROC pglVertexAttrib4iv=_Lazy_glVertexAttrib4iv; #endif
PFNGLVERTEXATTRIB4SPROC pglVertexAttrib4s=_Lazy_glVertexAttrib4s; #ifndef GLEE_C_DEFINED_glUniform4i
PFNGLVERTEXATTRIB4SVPROC pglVertexAttrib4sv=_Lazy_glVertexAttrib4sv; #define GLEE_C_DEFINED_glUniform4i
PFNGLVERTEXATTRIB4UBVPROC pglVertexAttrib4ubv=_Lazy_glVertexAttrib4ubv; void __stdcall GLee_Lazy_glUniform4i(GLint location, GLint v0, GLint v1,
PFNGLVERTEXATTRIB4UIVPROC pglVertexAttrib4uiv=_Lazy_glVertexAttrib4uiv; GLint v2, GLint v3) {if (GLeeInit()) glUniform4i(location, v0, v1, v2, v3)
PFNGLVERTEXATTRIB4USVPROC pglVertexAttrib4usv=_Lazy_glVertexAttrib4usv; ;}
PFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer=_Lazy_glVertexAttribPoi GLEEPFNGLUNIFORM4IPROC GLeeFuncPtr_glUniform4i=GLee_Lazy_glUniform4i;
nter; #endif
#ifndef GLEE_C_DEFINED_glUniform1fv
#define GLEE_C_DEFINED_glUniform1fv
void __stdcall GLee_Lazy_glUniform1fv(GLint location, GLsizei count, cons
t GLfloat * value) {if (GLeeInit()) glUniform1fv(location, count, value);}
GLEEPFNGLUNIFORM1FVPROC GLeeFuncPtr_glUniform1fv=GLee_Lazy_glUniform1fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fv
#define GLEE_C_DEFINED_glUniform2fv
void __stdcall GLee_Lazy_glUniform2fv(GLint location, GLsizei count, cons
t GLfloat * value) {if (GLeeInit()) glUniform2fv(location, count, value);}
GLEEPFNGLUNIFORM2FVPROC GLeeFuncPtr_glUniform2fv=GLee_Lazy_glUniform2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fv
#define GLEE_C_DEFINED_glUniform3fv
void __stdcall GLee_Lazy_glUniform3fv(GLint location, GLsizei count, cons
t GLfloat * value) {if (GLeeInit()) glUniform3fv(location, count, value);}
GLEEPFNGLUNIFORM3FVPROC GLeeFuncPtr_glUniform3fv=GLee_Lazy_glUniform3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fv
#define GLEE_C_DEFINED_glUniform4fv
void __stdcall GLee_Lazy_glUniform4fv(GLint location, GLsizei count, cons
t GLfloat * value) {if (GLeeInit()) glUniform4fv(location, count, value);}
GLEEPFNGLUNIFORM4FVPROC GLeeFuncPtr_glUniform4fv=GLee_Lazy_glUniform4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform1iv
#define GLEE_C_DEFINED_glUniform1iv
void __stdcall GLee_Lazy_glUniform1iv(GLint location, GLsizei count, cons
t GLint * value) {if (GLeeInit()) glUniform1iv(location, count, value);}
GLEEPFNGLUNIFORM1IVPROC GLeeFuncPtr_glUniform1iv=GLee_Lazy_glUniform1iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2iv
#define GLEE_C_DEFINED_glUniform2iv
void __stdcall GLee_Lazy_glUniform2iv(GLint location, GLsizei count, cons
t GLint * value) {if (GLeeInit()) glUniform2iv(location, count, value);}
GLEEPFNGLUNIFORM2IVPROC GLeeFuncPtr_glUniform2iv=GLee_Lazy_glUniform2iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3iv
#define GLEE_C_DEFINED_glUniform3iv
void __stdcall GLee_Lazy_glUniform3iv(GLint location, GLsizei count, cons
t GLint * value) {if (GLeeInit()) glUniform3iv(location, count, value);}
GLEEPFNGLUNIFORM3IVPROC GLeeFuncPtr_glUniform3iv=GLee_Lazy_glUniform3iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4iv
#define GLEE_C_DEFINED_glUniform4iv
void __stdcall GLee_Lazy_glUniform4iv(GLint location, GLsizei count, cons
t GLint * value) {if (GLeeInit()) glUniform4iv(location, count, value);}
GLEEPFNGLUNIFORM4IVPROC GLeeFuncPtr_glUniform4iv=GLee_Lazy_glUniform4iv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2fv
#define GLEE_C_DEFINED_glUniformMatrix2fv
void __stdcall GLee_Lazy_glUniformMatrix2fv(GLint location, GLsizei count
, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMa
trix2fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX2FVPROC GLeeFuncPtr_glUniformMatrix2fv=GLee_Lazy_gl
UniformMatrix2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3fv
#define GLEE_C_DEFINED_glUniformMatrix3fv
void __stdcall GLee_Lazy_glUniformMatrix3fv(GLint location, GLsizei count
, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMa
trix3fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3FVPROC GLeeFuncPtr_glUniformMatrix3fv=GLee_Lazy_gl
UniformMatrix3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4fv
#define GLEE_C_DEFINED_glUniformMatrix4fv
void __stdcall GLee_Lazy_glUniformMatrix4fv(GLint location, GLsizei count
, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMa
trix4fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX4FVPROC GLeeFuncPtr_glUniformMatrix4fv=GLee_Lazy_gl
UniformMatrix4fv;
#endif
#ifndef GLEE_C_DEFINED_glValidateProgram
#define GLEE_C_DEFINED_glValidateProgram
void __stdcall GLee_Lazy_glValidateProgram(GLuint program) {if (GLeeInit
()) glValidateProgram(program);}
GLEEPFNGLVALIDATEPROGRAMPROC GLeeFuncPtr_glValidateProgram=GLee_Lazy_glVa
lidateProgram;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1d
#define GLEE_C_DEFINED_glVertexAttrib1d
void __stdcall GLee_Lazy_glVertexAttrib1d(GLuint index, GLdouble x) {if
(GLeeInit()) glVertexAttrib1d(index, x);}
GLEEPFNGLVERTEXATTRIB1DPROC GLeeFuncPtr_glVertexAttrib1d=GLee_Lazy_glVert
exAttrib1d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dv
#define GLEE_C_DEFINED_glVertexAttrib1dv
void __stdcall GLee_Lazy_glVertexAttrib1dv(GLuint index, const GLdouble *
v) {if (GLeeInit()) glVertexAttrib1dv(index, v);}
GLEEPFNGLVERTEXATTRIB1DVPROC GLeeFuncPtr_glVertexAttrib1dv=GLee_Lazy_glVe
rtexAttrib1dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1f
#define GLEE_C_DEFINED_glVertexAttrib1f
void __stdcall GLee_Lazy_glVertexAttrib1f(GLuint index, GLfloat x) {if (
GLeeInit()) glVertexAttrib1f(index, x);}
GLEEPFNGLVERTEXATTRIB1FPROC GLeeFuncPtr_glVertexAttrib1f=GLee_Lazy_glVert
exAttrib1f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fv
#define GLEE_C_DEFINED_glVertexAttrib1fv
void __stdcall GLee_Lazy_glVertexAttrib1fv(GLuint index, const GLfloat *
v) {if (GLeeInit()) glVertexAttrib1fv(index, v);}
GLEEPFNGLVERTEXATTRIB1FVPROC GLeeFuncPtr_glVertexAttrib1fv=GLee_Lazy_glVe
rtexAttrib1fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1s
#define GLEE_C_DEFINED_glVertexAttrib1s
void __stdcall GLee_Lazy_glVertexAttrib1s(GLuint index, GLshort x) {if (
GLeeInit()) glVertexAttrib1s(index, x);}
GLEEPFNGLVERTEXATTRIB1SPROC GLeeFuncPtr_glVertexAttrib1s=GLee_Lazy_glVert
exAttrib1s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1sv
#define GLEE_C_DEFINED_glVertexAttrib1sv
void __stdcall GLee_Lazy_glVertexAttrib1sv(GLuint index, const GLshort *
v) {if (GLeeInit()) glVertexAttrib1sv(index, v);}
GLEEPFNGLVERTEXATTRIB1SVPROC GLeeFuncPtr_glVertexAttrib1sv=GLee_Lazy_glVe
rtexAttrib1sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2d
#define GLEE_C_DEFINED_glVertexAttrib2d
void __stdcall GLee_Lazy_glVertexAttrib2d(GLuint index, GLdouble x, GLdou
ble y) {if (GLeeInit()) glVertexAttrib2d(index, x, y);}
GLEEPFNGLVERTEXATTRIB2DPROC GLeeFuncPtr_glVertexAttrib2d=GLee_Lazy_glVert
exAttrib2d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dv
#define GLEE_C_DEFINED_glVertexAttrib2dv
void __stdcall GLee_Lazy_glVertexAttrib2dv(GLuint index, const GLdouble *
v) {if (GLeeInit()) glVertexAttrib2dv(index, v);}
GLEEPFNGLVERTEXATTRIB2DVPROC GLeeFuncPtr_glVertexAttrib2dv=GLee_Lazy_glVe
rtexAttrib2dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2f
#define GLEE_C_DEFINED_glVertexAttrib2f
void __stdcall GLee_Lazy_glVertexAttrib2f(GLuint index, GLfloat x, GLfloa
t y) {if (GLeeInit()) glVertexAttrib2f(index, x, y);}
GLEEPFNGLVERTEXATTRIB2FPROC GLeeFuncPtr_glVertexAttrib2f=GLee_Lazy_glVert
exAttrib2f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fv
#define GLEE_C_DEFINED_glVertexAttrib2fv
void __stdcall GLee_Lazy_glVertexAttrib2fv(GLuint index, const GLfloat *
v) {if (GLeeInit()) glVertexAttrib2fv(index, v);}
GLEEPFNGLVERTEXATTRIB2FVPROC GLeeFuncPtr_glVertexAttrib2fv=GLee_Lazy_glVe
rtexAttrib2fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2s
#define GLEE_C_DEFINED_glVertexAttrib2s
void __stdcall GLee_Lazy_glVertexAttrib2s(GLuint index, GLshort x, GLshor
t y) {if (GLeeInit()) glVertexAttrib2s(index, x, y);}
GLEEPFNGLVERTEXATTRIB2SPROC GLeeFuncPtr_glVertexAttrib2s=GLee_Lazy_glVert
exAttrib2s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2sv
#define GLEE_C_DEFINED_glVertexAttrib2sv
void __stdcall GLee_Lazy_glVertexAttrib2sv(GLuint index, const GLshort *
v) {if (GLeeInit()) glVertexAttrib2sv(index, v);}
GLEEPFNGLVERTEXATTRIB2SVPROC GLeeFuncPtr_glVertexAttrib2sv=GLee_Lazy_glVe
rtexAttrib2sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3d
#define GLEE_C_DEFINED_glVertexAttrib3d
void __stdcall GLee_Lazy_glVertexAttrib3d(GLuint index, GLdouble x, GLdou
ble y, GLdouble z) {if (GLeeInit()) glVertexAttrib3d(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3DPROC GLeeFuncPtr_glVertexAttrib3d=GLee_Lazy_glVert
exAttrib3d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dv
#define GLEE_C_DEFINED_glVertexAttrib3dv
void __stdcall GLee_Lazy_glVertexAttrib3dv(GLuint index, const GLdouble *
v) {if (GLeeInit()) glVertexAttrib3dv(index, v);}
GLEEPFNGLVERTEXATTRIB3DVPROC GLeeFuncPtr_glVertexAttrib3dv=GLee_Lazy_glVe
rtexAttrib3dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3f
#define GLEE_C_DEFINED_glVertexAttrib3f
void __stdcall GLee_Lazy_glVertexAttrib3f(GLuint index, GLfloat x, GLfloa
t y, GLfloat z) {if (GLeeInit()) glVertexAttrib3f(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3FPROC GLeeFuncPtr_glVertexAttrib3f=GLee_Lazy_glVert
exAttrib3f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fv
#define GLEE_C_DEFINED_glVertexAttrib3fv
void __stdcall GLee_Lazy_glVertexAttrib3fv(GLuint index, const GLfloat *
v) {if (GLeeInit()) glVertexAttrib3fv(index, v);}
GLEEPFNGLVERTEXATTRIB3FVPROC GLeeFuncPtr_glVertexAttrib3fv=GLee_Lazy_glVe
rtexAttrib3fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3s
#define GLEE_C_DEFINED_glVertexAttrib3s
void __stdcall GLee_Lazy_glVertexAttrib3s(GLuint index, GLshort x, GLshor
t y, GLshort z) {if (GLeeInit()) glVertexAttrib3s(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3SPROC GLeeFuncPtr_glVertexAttrib3s=GLee_Lazy_glVert
exAttrib3s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3sv
#define GLEE_C_DEFINED_glVertexAttrib3sv
void __stdcall GLee_Lazy_glVertexAttrib3sv(GLuint index, const GLshort *
v) {if (GLeeInit()) glVertexAttrib3sv(index, v);}
GLEEPFNGLVERTEXATTRIB3SVPROC GLeeFuncPtr_glVertexAttrib3sv=GLee_Lazy_glVe
rtexAttrib3sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nbv
#define GLEE_C_DEFINED_glVertexAttrib4Nbv
void __stdcall GLee_Lazy_glVertexAttrib4Nbv(GLuint index, const GLbyte *
v) {if (GLeeInit()) glVertexAttrib4Nbv(index, v);}
GLEEPFNGLVERTEXATTRIB4NBVPROC GLeeFuncPtr_glVertexAttrib4Nbv=GLee_Lazy_gl
VertexAttrib4Nbv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Niv
#define GLEE_C_DEFINED_glVertexAttrib4Niv
void __stdcall GLee_Lazy_glVertexAttrib4Niv(GLuint index, const GLint * v
) {if (GLeeInit()) glVertexAttrib4Niv(index, v);}
GLEEPFNGLVERTEXATTRIB4NIVPROC GLeeFuncPtr_glVertexAttrib4Niv=GLee_Lazy_gl
VertexAttrib4Niv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nsv
#define GLEE_C_DEFINED_glVertexAttrib4Nsv
void __stdcall GLee_Lazy_glVertexAttrib4Nsv(GLuint index, const GLshort *
v) {if (GLeeInit()) glVertexAttrib4Nsv(index, v);}
GLEEPFNGLVERTEXATTRIB4NSVPROC GLeeFuncPtr_glVertexAttrib4Nsv=GLee_Lazy_gl
VertexAttrib4Nsv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nub
#define GLEE_C_DEFINED_glVertexAttrib4Nub
void __stdcall GLee_Lazy_glVertexAttrib4Nub(GLuint index, GLubyte x, GLub
yte y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4Nub(index, x,
y, z, w);}
GLEEPFNGLVERTEXATTRIB4NUBPROC GLeeFuncPtr_glVertexAttrib4Nub=GLee_Lazy_gl
VertexAttrib4Nub;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nubv
#define GLEE_C_DEFINED_glVertexAttrib4Nubv
void __stdcall GLee_Lazy_glVertexAttrib4Nubv(GLuint index, const GLubyte
* v) {if (GLeeInit()) glVertexAttrib4Nubv(index, v);}
GLEEPFNGLVERTEXATTRIB4NUBVPROC GLeeFuncPtr_glVertexAttrib4Nubv=GLee_Lazy_
glVertexAttrib4Nubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nuiv
#define GLEE_C_DEFINED_glVertexAttrib4Nuiv
void __stdcall GLee_Lazy_glVertexAttrib4Nuiv(GLuint index, const GLuint *
v) {if (GLeeInit()) glVertexAttrib4Nuiv(index, v);}
GLEEPFNGLVERTEXATTRIB4NUIVPROC GLeeFuncPtr_glVertexAttrib4Nuiv=GLee_Lazy_
glVertexAttrib4Nuiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nusv
#define GLEE_C_DEFINED_glVertexAttrib4Nusv
void __stdcall GLee_Lazy_glVertexAttrib4Nusv(GLuint index, const GLushort
* v) {if (GLeeInit()) glVertexAttrib4Nusv(index, v);}
GLEEPFNGLVERTEXATTRIB4NUSVPROC GLeeFuncPtr_glVertexAttrib4Nusv=GLee_Lazy_
glVertexAttrib4Nusv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4bv
#define GLEE_C_DEFINED_glVertexAttrib4bv
void __stdcall GLee_Lazy_glVertexAttrib4bv(GLuint index, const GLbyte * v
) {if (GLeeInit()) glVertexAttrib4bv(index, v);}
GLEEPFNGLVERTEXATTRIB4BVPROC GLeeFuncPtr_glVertexAttrib4bv=GLee_Lazy_glVe
rtexAttrib4bv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4d
#define GLEE_C_DEFINED_glVertexAttrib4d
void __stdcall GLee_Lazy_glVertexAttrib4d(GLuint index, GLdouble x, GLdou
ble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4d(index, x,
y, z, w);}
GLEEPFNGLVERTEXATTRIB4DPROC GLeeFuncPtr_glVertexAttrib4d=GLee_Lazy_glVert
exAttrib4d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dv
#define GLEE_C_DEFINED_glVertexAttrib4dv
void __stdcall GLee_Lazy_glVertexAttrib4dv(GLuint index, const GLdouble *
v) {if (GLeeInit()) glVertexAttrib4dv(index, v);}
GLEEPFNGLVERTEXATTRIB4DVPROC GLeeFuncPtr_glVertexAttrib4dv=GLee_Lazy_glVe
rtexAttrib4dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4f
#define GLEE_C_DEFINED_glVertexAttrib4f
void __stdcall GLee_Lazy_glVertexAttrib4f(GLuint index, GLfloat x, GLfloa
t y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4f(index, x, y,
z, w);}
GLEEPFNGLVERTEXATTRIB4FPROC GLeeFuncPtr_glVertexAttrib4f=GLee_Lazy_glVert
exAttrib4f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fv
#define GLEE_C_DEFINED_glVertexAttrib4fv
void __stdcall GLee_Lazy_glVertexAttrib4fv(GLuint index, const GLfloat *
v) {if (GLeeInit()) glVertexAttrib4fv(index, v);}
GLEEPFNGLVERTEXATTRIB4FVPROC GLeeFuncPtr_glVertexAttrib4fv=GLee_Lazy_glVe
rtexAttrib4fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4iv
#define GLEE_C_DEFINED_glVertexAttrib4iv
void __stdcall GLee_Lazy_glVertexAttrib4iv(GLuint index, const GLint * v)
{if (GLeeInit()) glVertexAttrib4iv(index, v);}
GLEEPFNGLVERTEXATTRIB4IVPROC GLeeFuncPtr_glVertexAttrib4iv=GLee_Lazy_glVe
rtexAttrib4iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4s
#define GLEE_C_DEFINED_glVertexAttrib4s
void __stdcall GLee_Lazy_glVertexAttrib4s(GLuint index, GLshort x, GLshor
t y, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4s(index, x, y,
z, w);}
GLEEPFNGLVERTEXATTRIB4SPROC GLeeFuncPtr_glVertexAttrib4s=GLee_Lazy_glVert
exAttrib4s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4sv
#define GLEE_C_DEFINED_glVertexAttrib4sv
void __stdcall GLee_Lazy_glVertexAttrib4sv(GLuint index, const GLshort *
v) {if (GLeeInit()) glVertexAttrib4sv(index, v);}
GLEEPFNGLVERTEXATTRIB4SVPROC GLeeFuncPtr_glVertexAttrib4sv=GLee_Lazy_glVe
rtexAttrib4sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubv
#define GLEE_C_DEFINED_glVertexAttrib4ubv
void __stdcall GLee_Lazy_glVertexAttrib4ubv(GLuint index, const GLubyte *
v) {if (GLeeInit()) glVertexAttrib4ubv(index, v);}
GLEEPFNGLVERTEXATTRIB4UBVPROC GLeeFuncPtr_glVertexAttrib4ubv=GLee_Lazy_gl
VertexAttrib4ubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4uiv
#define GLEE_C_DEFINED_glVertexAttrib4uiv
void __stdcall GLee_Lazy_glVertexAttrib4uiv(GLuint index, const GLuint *
v) {if (GLeeInit()) glVertexAttrib4uiv(index, v);}
GLEEPFNGLVERTEXATTRIB4UIVPROC GLeeFuncPtr_glVertexAttrib4uiv=GLee_Lazy_gl
VertexAttrib4uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4usv
#define GLEE_C_DEFINED_glVertexAttrib4usv
void __stdcall GLee_Lazy_glVertexAttrib4usv(GLuint index, const GLushort
* v) {if (GLeeInit()) glVertexAttrib4usv(index, v);}
GLEEPFNGLVERTEXATTRIB4USVPROC GLeeFuncPtr_glVertexAttrib4usv=GLee_Lazy_gl
VertexAttrib4usv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointer
#define GLEE_C_DEFINED_glVertexAttribPointer
void __stdcall GLee_Lazy_glVertexAttribPointer(GLuint index, GLint size,
GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)
{if (GLeeInit()) glVertexAttribPointer(index, size, type, normalized, stri
de, pointer);}
GLEEPFNGLVERTEXATTRIBPOINTERPROC GLeeFuncPtr_glVertexAttribPointer=GLee_L
azy_glVertexAttribPointer;
#endif
#endif #endif
/* GL_VERSION_2_1 */ /* GL_VERSION_2_1 */
#ifdef __GLEE_GL_VERSION_2_1 #ifdef __GLEE_GL_VERSION_2_1
void __stdcall _Lazy_glUniformMatrix2x3fv(GLint location, GLsizei count, GL #ifndef GLEE_C_DEFINED_glUniformMatrix2x3fv
boolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix #define GLEE_C_DEFINED_glUniformMatrix2x3fv
2x3fv(location, count, transpose, value);} void __stdcall GLee_Lazy_glUniformMatrix2x3fv(GLint location, GLsizei cou
void __stdcall _Lazy_glUniformMatrix3x2fv(GLint location, GLsizei count, GL nt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniform
boolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix Matrix2x3fv(location, count, transpose, value);}
3x2fv(location, count, transpose, value);} GLEEPFNGLUNIFORMMATRIX2X3FVPROC GLeeFuncPtr_glUniformMatrix2x3fv=GLee_Laz
void __stdcall _Lazy_glUniformMatrix2x4fv(GLint location, GLsizei count, GL y_glUniformMatrix2x3fv;
boolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix #endif
2x4fv(location, count, transpose, value);} #ifndef GLEE_C_DEFINED_glUniformMatrix3x2fv
void __stdcall _Lazy_glUniformMatrix4x2fv(GLint location, GLsizei count, GL #define GLEE_C_DEFINED_glUniformMatrix3x2fv
boolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix void __stdcall GLee_Lazy_glUniformMatrix3x2fv(GLint location, GLsizei cou
4x2fv(location, count, transpose, value);} nt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniform
void __stdcall _Lazy_glUniformMatrix3x4fv(GLint location, GLsizei count, GL Matrix3x2fv(location, count, transpose, value);}
boolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix GLEEPFNGLUNIFORMMATRIX3X2FVPROC GLeeFuncPtr_glUniformMatrix3x2fv=GLee_Laz
3x4fv(location, count, transpose, value);} y_glUniformMatrix3x2fv;
void __stdcall _Lazy_glUniformMatrix4x3fv(GLint location, GLsizei count, GL #endif
boolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix #ifndef GLEE_C_DEFINED_glUniformMatrix2x4fv
4x3fv(location, count, transpose, value);} #define GLEE_C_DEFINED_glUniformMatrix2x4fv
PFNGLUNIFORMMATRIX2X3FVPROC pglUniformMatrix2x3fv=_Lazy_glUniformMatrix2x3f void __stdcall GLee_Lazy_glUniformMatrix2x4fv(GLint location, GLsizei cou
v; nt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniform
PFNGLUNIFORMMATRIX3X2FVPROC pglUniformMatrix3x2fv=_Lazy_glUniformMatrix3x2f Matrix2x4fv(location, count, transpose, value);}
v; GLEEPFNGLUNIFORMMATRIX2X4FVPROC GLeeFuncPtr_glUniformMatrix2x4fv=GLee_Laz
PFNGLUNIFORMMATRIX2X4FVPROC pglUniformMatrix2x4fv=_Lazy_glUniformMatrix2x4f y_glUniformMatrix2x4fv;
v; #endif
PFNGLUNIFORMMATRIX4X2FVPROC pglUniformMatrix4x2fv=_Lazy_glUniformMatrix4x2f #ifndef GLEE_C_DEFINED_glUniformMatrix4x2fv
v; #define GLEE_C_DEFINED_glUniformMatrix4x2fv
PFNGLUNIFORMMATRIX3X4FVPROC pglUniformMatrix3x4fv=_Lazy_glUniformMatrix3x4f void __stdcall GLee_Lazy_glUniformMatrix4x2fv(GLint location, GLsizei cou
v; nt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniform
PFNGLUNIFORMMATRIX4X3FVPROC pglUniformMatrix4x3fv=_Lazy_glUniformMatrix4x3f Matrix4x2fv(location, count, transpose, value);}
v; GLEEPFNGLUNIFORMMATRIX4X2FVPROC GLeeFuncPtr_glUniformMatrix4x2fv=GLee_Laz
y_glUniformMatrix4x2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3x4fv
#define GLEE_C_DEFINED_glUniformMatrix3x4fv
void __stdcall GLee_Lazy_glUniformMatrix3x4fv(GLint location, GLsizei cou
nt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniform
Matrix3x4fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3X4FVPROC GLeeFuncPtr_glUniformMatrix3x4fv=GLee_Laz
y_glUniformMatrix3x4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4x3fv
#define GLEE_C_DEFINED_glUniformMatrix4x3fv
void __stdcall GLee_Lazy_glUniformMatrix4x3fv(GLint location, GLsizei cou
nt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniform
Matrix4x3fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX4X3FVPROC GLeeFuncPtr_glUniformMatrix4x3fv=GLee_Laz
y_glUniformMatrix4x3fv;
#endif
#endif #endif
/* GL_VERSION_3_0 */ /* GL_VERSION_3_0 */
#ifdef __GLEE_GL_VERSION_3_0 #ifdef __GLEE_GL_VERSION_3_0
void __stdcall _Lazy_glColorMaski(GLuint index, GLboolean r, GLboolean g, G #ifndef GLEE_C_DEFINED_glColorMaski
Lboolean b, GLboolean a) {if (GLeeInit()) glColorMaski(index, r, g, b, a); #define GLEE_C_DEFINED_glColorMaski
} void __stdcall GLee_Lazy_glColorMaski(GLuint index, GLboolean r, GLboolea
void __stdcall _Lazy_glGetBooleani_v(GLenum target, GLuint index, GLboolean n g, GLboolean b, GLboolean a) {if (GLeeInit()) glColorMaski(index, r, g,
* data) {if (GLeeInit()) glGetBooleani_v(target, index, data);} b, a);}
void __stdcall _Lazy_glGetIntegeri_v(GLenum target, GLuint index, GLint * d GLEEPFNGLCOLORMASKIPROC GLeeFuncPtr_glColorMaski=GLee_Lazy_glColorMaski;
ata) {if (GLeeInit()) glGetIntegeri_v(target, index, data);} #endif
void __stdcall _Lazy_glEnablei(GLenum target, GLuint index) #ifndef GLEE_C_DEFINED_glGetBooleani_v
{if (GLeeInit()) glEnablei(target, index);} #define GLEE_C_DEFINED_glGetBooleani_v
void __stdcall _Lazy_glDisablei(GLenum target, GLuint index) void __stdcall GLee_Lazy_glGetBooleani_v(GLenum target, GLuint index, GLb
{if (GLeeInit()) glDisablei(target, index);} oolean * data) {if (GLeeInit()) glGetBooleani_v(target, index, data);}
GLboolean __stdcall _Lazy_glIsEnabledi(GLenum target, GLuint index) GLEEPFNGLGETBOOLEANI_VPROC GLeeFuncPtr_glGetBooleani_v=GLee_Lazy_glGetBoo
{if (GLeeInit()) return glIsEnabledi(target, index); return leani_v;
(GLboolean)0;} #endif
void __stdcall _Lazy_glBeginTransformFeedback(GLenum primitiveMode) #ifndef GLEE_C_DEFINED_glGetIntegeri_v
{if (GLeeInit()) glBeginTransformFeedback(primitiveMode);} #define GLEE_C_DEFINED_glGetIntegeri_v
void __stdcall _Lazy_glEndTransformFeedback(void) void __stdcall GLee_Lazy_glGetIntegeri_v(GLenum target, GLuint index, GLi
{if (GLeeInit()) glEndTransformFeedback();} nt * data) {if (GLeeInit()) glGetIntegeri_v(target, index, data);}
void __stdcall _Lazy_glBindBufferRange(GLenum target, GLuint index, GLuint GLEEPFNGLGETINTEGERI_VPROC GLeeFuncPtr_glGetIntegeri_v=GLee_Lazy_glGetInt
buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBufferRan egeri_v;
ge(target, index, buffer, offset, size);} #endif
void __stdcall _Lazy_glBindBufferBase(GLenum target, GLuint index, GLuint b #ifndef GLEE_C_DEFINED_glEnablei
uffer) {if (GLeeInit()) glBindBufferBase(target, index, buffer);} #define GLEE_C_DEFINED_glEnablei
void __stdcall _Lazy_glTransformFeedbackVaryings(GLuint program, GLsizei co void __stdcall GLee_Lazy_glEnablei(GLenum target, GLuint index) {if (GLe
unt, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) glTransf eInit()) glEnablei(target, index);}
ormFeedbackVaryings(program, count, locations, bufferMode);} GLEEPFNGLENABLEIPROC GLeeFuncPtr_glEnablei=GLee_Lazy_glEnablei;
void __stdcall _Lazy_glGetTransformFeedbackVarying(GLuint program, GLuint i #endif
ndex, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVarying(pro #ifndef GLEE_C_DEFINED_glDisablei
gram, index, location);} #define GLEE_C_DEFINED_glDisablei
void __stdcall _Lazy_glClampColor(GLenum target, GLenum clamp) void __stdcall GLee_Lazy_glDisablei(GLenum target, GLuint index) {if (GL
{if (GLeeInit()) glClampColor(target, clamp);} eeInit()) glDisablei(target, index);}
void __stdcall _Lazy_glBeginConditionalRender(GLuint id, GLenum mode) GLEEPFNGLDISABLEIPROC GLeeFuncPtr_glDisablei=GLee_Lazy_glDisablei;
{if (GLeeInit()) glBeginConditionalRender(id, mode);} #endif
void __stdcall _Lazy_glEndConditionalRender(void) #ifndef GLEE_C_DEFINED_glIsEnabledi
{if (GLeeInit()) glEndConditionalRender();} #define GLEE_C_DEFINED_glIsEnabledi
void __stdcall _Lazy_glVertexAttribI1i(GLuint index, GLint x) GLboolean __stdcall GLee_Lazy_glIsEnabledi(GLenum target, GLuint index)
{if (GLeeInit()) glVertexAttribI1i(index, x);} {if (GLeeInit()) return glIsEnabledi(target, index); return (GLboolean)0;}
void __stdcall _Lazy_glVertexAttribI2i(GLuint index, GLint x, GLint y) GLEEPFNGLISENABLEDIPROC GLeeFuncPtr_glIsEnabledi=GLee_Lazy_glIsEnabledi;
{if (GLeeInit()) glVertexAttribI2i(index, x, y);} #endif
void __stdcall _Lazy_glVertexAttribI3i(GLuint index, GLint x, GLint y, GLin #ifndef GLEE_C_DEFINED_glBeginTransformFeedback
t z) {if (GLeeInit()) glVertexAttribI3i(index, x, y, z);} #define GLEE_C_DEFINED_glBeginTransformFeedback
void __stdcall _Lazy_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLin void __stdcall GLee_Lazy_glBeginTransformFeedback(GLenum primitiveMode)
t z, GLint w) {if (GLeeInit()) glVertexAttribI4i(index, x, y, z, w);} {if (GLeeInit()) glBeginTransformFeedback(primitiveMode);}
void __stdcall _Lazy_glVertexAttribI1ui(GLuint index, GLuint x) GLEEPFNGLBEGINTRANSFORMFEEDBACKPROC GLeeFuncPtr_glBeginTransformFeedback=
{if (GLeeInit()) glVertexAttribI1ui(index, x);} GLee_Lazy_glBeginTransformFeedback;
void __stdcall _Lazy_glVertexAttribI2ui(GLuint index, GLuint x, GLuint y) #endif
{if (GLeeInit()) glVertexAttribI2ui(index, x, y);} #ifndef GLEE_C_DEFINED_glEndTransformFeedback
void __stdcall _Lazy_glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, G #define GLEE_C_DEFINED_glEndTransformFeedback
Luint z) {if (GLeeInit()) glVertexAttribI3ui(index, x, y, z);} void __stdcall GLee_Lazy_glEndTransformFeedback(void) {if (GLeeInit()) g
void __stdcall _Lazy_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, G lEndTransformFeedback();}
Luint z, GLuint w) {if (GLeeInit()) glVertexAttribI4ui(index, x, y, z, w); GLEEPFNGLENDTRANSFORMFEEDBACKPROC GLeeFuncPtr_glEndTransformFeedback=GLee
} _Lazy_glEndTransformFeedback;
void __stdcall _Lazy_glVertexAttribI1iv(GLuint index, const GLint * v) #endif
{if (GLeeInit()) glVertexAttribI1iv(index, v);} #ifndef GLEE_C_DEFINED_glBindBufferRange
void __stdcall _Lazy_glVertexAttribI2iv(GLuint index, const GLint * v) #define GLEE_C_DEFINED_glBindBufferRange
{if (GLeeInit()) glVertexAttribI2iv(index, v);} void __stdcall GLee_Lazy_glBindBufferRange(GLenum target, GLuint index, G
void __stdcall _Lazy_glVertexAttribI3iv(GLuint index, const GLint * v) Luint buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBuf
{if (GLeeInit()) glVertexAttribI3iv(index, v);} ferRange(target, index, buffer, offset, size);}
void __stdcall _Lazy_glVertexAttribI4iv(GLuint index, const GLint * v) GLEEPFNGLBINDBUFFERRANGEPROC GLeeFuncPtr_glBindBufferRange=GLee_Lazy_glBi
{if (GLeeInit()) glVertexAttribI4iv(index, v);} ndBufferRange;
void __stdcall _Lazy_glVertexAttribI1uiv(GLuint index, const GLuint * v) #endif
{if (GLeeInit()) glVertexAttribI1uiv(index, v);} #ifndef GLEE_C_DEFINED_glBindBufferBase
void __stdcall _Lazy_glVertexAttribI2uiv(GLuint index, const GLuint * v) #define GLEE_C_DEFINED_glBindBufferBase
{if (GLeeInit()) glVertexAttribI2uiv(index, v);} void __stdcall GLee_Lazy_glBindBufferBase(GLenum target, GLuint index, GL
void __stdcall _Lazy_glVertexAttribI3uiv(GLuint index, const GLuint * v) uint buffer) {if (GLeeInit()) glBindBufferBase(target, index, buffer);}
{if (GLeeInit()) glVertexAttribI3uiv(index, v);} GLEEPFNGLBINDBUFFERBASEPROC GLeeFuncPtr_glBindBufferBase=GLee_Lazy_glBind
void __stdcall _Lazy_glVertexAttribI4uiv(GLuint index, const GLuint * v) BufferBase;
{if (GLeeInit()) glVertexAttribI4uiv(index, v);} #endif
void __stdcall _Lazy_glVertexAttribI4bv(GLuint index, const GLbyte * v) #ifndef GLEE_C_DEFINED_glTransformFeedbackVaryings
{if (GLeeInit()) glVertexAttribI4bv(index, v);} #define GLEE_C_DEFINED_glTransformFeedbackVaryings
void __stdcall _Lazy_glVertexAttribI4sv(GLuint index, const GLshort * v) void __stdcall GLee_Lazy_glTransformFeedbackVaryings(GLuint program, GLsi
{if (GLeeInit()) glVertexAttribI4sv(index, v);} zei count, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) gl
void __stdcall _Lazy_glVertexAttribI4ubv(GLuint index, const GLubyte * v) TransformFeedbackVaryings(program, count, locations, bufferMode);}
{if (GLeeInit()) glVertexAttribI4ubv(index, v);} GLEEPFNGLTRANSFORMFEEDBACKVARYINGSPROC GLeeFuncPtr_glTransformFeedbackVar
void __stdcall _Lazy_glVertexAttribI4usv(GLuint index, const GLushort * v) yings=GLee_Lazy_glTransformFeedbackVaryings;
{if (GLeeInit()) glVertexAttribI4usv(index, v);} #endif
void __stdcall _Lazy_glVertexAttribIPointer(GLuint index, GLint size, GLenu #ifndef GLEE_C_DEFINED_glGetTransformFeedbackVarying
m type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexA #define GLEE_C_DEFINED_glGetTransformFeedbackVarying
ttribIPointer(index, size, type, stride, pointer);} void __stdcall GLee_Lazy_glGetTransformFeedbackVarying(GLuint program, GL
void __stdcall _Lazy_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint uint index, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVaryi
* params) {if (GLeeInit()) glGetVertexAttribIiv(index, pname, params); ng(program, index, location);}
} GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGPROC GLeeFuncPtr_glGetTransformFeedba
void __stdcall _Lazy_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLui ckVarying=GLee_Lazy_glGetTransformFeedbackVarying;
nt * params) {if (GLeeInit()) glGetVertexAttribIuiv(index, pname, params) #endif
;} #ifndef GLEE_C_DEFINED_glClampColor
void __stdcall _Lazy_glGetUniformuiv(GLuint program, GLint location, GLuint #define GLEE_C_DEFINED_glClampColor
* params) {if (GLeeInit()) glGetUniformuiv(program, location, params); void __stdcall GLee_Lazy_glClampColor(GLenum target, GLenum clamp) {if (
} GLeeInit()) glClampColor(target, clamp);}
void __stdcall _Lazy_glBindFragDataLocation(GLuint program, GLuint color, c GLEEPFNGLCLAMPCOLORPROC GLeeFuncPtr_glClampColor=GLee_Lazy_glClampColor;
onst GLchar * name) {if (GLeeInit()) glBindFragDataLocation(program, color #endif
, name);} #ifndef GLEE_C_DEFINED_glBeginConditionalRender
GLint __stdcall _Lazy_glGetFragDataLocation(GLuint program, const GLchar * #define GLEE_C_DEFINED_glBeginConditionalRender
name) {if (GLeeInit()) return glGetFragDataLocation(program, name) void __stdcall GLee_Lazy_glBeginConditionalRender(GLuint id, GLenum mode)
; return (GLint)0;} {if (GLeeInit()) glBeginConditionalRender(id, mode);}
void __stdcall _Lazy_glUniform1ui(GLint location, GLuint v0) GLEEPFNGLBEGINCONDITIONALRENDERPROC GLeeFuncPtr_glBeginConditionalRender=
{if (GLeeInit()) glUniform1ui(location, v0);} GLee_Lazy_glBeginConditionalRender;
void __stdcall _Lazy_glUniform2ui(GLint location, GLuint v0, GLuint v1) #endif
{if (GLeeInit()) glUniform2ui(location, v0, v1);} #ifndef GLEE_C_DEFINED_glEndConditionalRender
void __stdcall _Lazy_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLu #define GLEE_C_DEFINED_glEndConditionalRender
int v2) {if (GLeeInit()) glUniform3ui(location, v0, v1, v2);} void __stdcall GLee_Lazy_glEndConditionalRender(void) {if (GLeeInit()) g
void __stdcall _Lazy_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLu lEndConditionalRender();}
int v2, GLuint v3) {if (GLeeInit()) glUniform4ui(location, v0, v1, v2, v3) GLEEPFNGLENDCONDITIONALRENDERPROC GLeeFuncPtr_glEndConditionalRender=GLee
;} _Lazy_glEndConditionalRender;
void __stdcall _Lazy_glUniform1uiv(GLint location, GLsizei count, const GLu #endif
int * value) {if (GLeeInit()) glUniform1uiv(location, count, value);} #ifndef GLEE_C_DEFINED_glVertexAttribI1i
void __stdcall _Lazy_glUniform2uiv(GLint location, GLsizei count, const GLu #define GLEE_C_DEFINED_glVertexAttribI1i
int * value) {if (GLeeInit()) glUniform2uiv(location, count, value);} void __stdcall GLee_Lazy_glVertexAttribI1i(GLuint index, GLint x) {if (G
void __stdcall _Lazy_glUniform3uiv(GLint location, GLsizei count, const GLu LeeInit()) glVertexAttribI1i(index, x);}
int * value) {if (GLeeInit()) glUniform3uiv(location, count, value);} GLEEPFNGLVERTEXATTRIBI1IPROC GLeeFuncPtr_glVertexAttribI1i=GLee_Lazy_glVe
void __stdcall _Lazy_glUniform4uiv(GLint location, GLsizei count, const GLu rtexAttribI1i;
int * value) {if (GLeeInit()) glUniform4uiv(location, count, value);} #endif
void __stdcall _Lazy_glTexParameterIiv(GLenum target, GLenum pname, const G #ifndef GLEE_C_DEFINED_glVertexAttribI2i
Lint * params) {if (GLeeInit()) glTexParameterIiv(target, pname, params);} #define GLEE_C_DEFINED_glVertexAttribI2i
void __stdcall _Lazy_glTexParameterIuiv(GLenum target, GLenum pname, const void __stdcall GLee_Lazy_glVertexAttribI2i(GLuint index, GLint x, GLint y
GLuint * params) {if (GLeeInit()) glTexParameterIuiv(target, pname, params ) {if (GLeeInit()) glVertexAttribI2i(index, x, y);}
);} GLEEPFNGLVERTEXATTRIBI2IPROC GLeeFuncPtr_glVertexAttribI2i=GLee_Lazy_glVe
void __stdcall _Lazy_glGetTexParameterIiv(GLenum target, GLenum pname, GLin rtexAttribI2i;
t * params) {if (GLeeInit()) glGetTexParameterIiv(target, pname, params) #endif
;} #ifndef GLEE_C_DEFINED_glVertexAttribI3i
void __stdcall _Lazy_glGetTexParameterIuiv(GLenum target, GLenum pname, GLu #define GLEE_C_DEFINED_glVertexAttribI3i
int * params) {if (GLeeInit()) glGetTexParameterIuiv(target, pname, params void __stdcall GLee_Lazy_glVertexAttribI3i(GLuint index, GLint x, GLint y
);} , GLint z) {if (GLeeInit()) glVertexAttribI3i(index, x, y, z);}
void __stdcall _Lazy_glClearBufferiv(GLenum buffer, const GLint * value) GLEEPFNGLVERTEXATTRIBI3IPROC GLeeFuncPtr_glVertexAttribI3i=GLee_Lazy_glVe
{if (GLeeInit()) glClearBufferiv(buffer, value);} rtexAttribI3i;
void __stdcall _Lazy_glClearBufferuiv(GLenum buffer, const GLuint * value) #endif
{if (GLeeInit()) glClearBufferuiv(buffer, value);} #ifndef GLEE_C_DEFINED_glVertexAttribI4i
void __stdcall _Lazy_glClearBufferfv(GLenum buffer, const GLfloat * value) #define GLEE_C_DEFINED_glVertexAttribI4i
{if (GLeeInit()) glClearBufferfv(buffer, value);} void __stdcall GLee_Lazy_glVertexAttribI4i(GLuint index, GLint x, GLint y
void __stdcall _Lazy_glClearBufferfi(GLenum buffer, GLfloat depth, GLint st , GLint z, GLint w) {if (GLeeInit()) glVertexAttribI4i(index, x, y, z, w);
encil) {if (GLeeInit()) glClearBufferfi(buffer, depth, stencil);} }
const GLubyte * __stdcall _Lazy_glGetStringi(GLenum name, GLuint index) GLEEPFNGLVERTEXATTRIBI4IPROC GLeeFuncPtr_glVertexAttribI4i=GLee_Lazy_glVe
{if (GLeeInit()) return glGetStringi(name, index); return (c rtexAttribI4i;
onst GLubyte *)0;} #endif
PFNGLCOLORMASKIPROC pglColorMaski=_Lazy_glColorMaski; #ifndef GLEE_C_DEFINED_glVertexAttribI1ui
PFNGLGETBOOLEANI_VPROC pglGetBooleani_v=_Lazy_glGetBooleani_v; #define GLEE_C_DEFINED_glVertexAttribI1ui
PFNGLGETINTEGERI_VPROC pglGetIntegeri_v=_Lazy_glGetIntegeri_v; void __stdcall GLee_Lazy_glVertexAttribI1ui(GLuint index, GLuint x) {if
PFNGLENABLEIPROC pglEnablei=_Lazy_glEnablei; (GLeeInit()) glVertexAttribI1ui(index, x);}
PFNGLDISABLEIPROC pglDisablei=_Lazy_glDisablei; GLEEPFNGLVERTEXATTRIBI1UIPROC GLeeFuncPtr_glVertexAttribI1ui=GLee_Lazy_gl
PFNGLISENABLEDIPROC pglIsEnabledi=_Lazy_glIsEnabledi; VertexAttribI1ui;
PFNGLBEGINTRANSFORMFEEDBACKPROC pglBeginTransformFeedback=_Lazy_glBeginTran #endif
sformFeedback; #ifndef GLEE_C_DEFINED_glVertexAttribI2ui
PFNGLENDTRANSFORMFEEDBACKPROC pglEndTransformFeedback=_Lazy_glEndTransformF #define GLEE_C_DEFINED_glVertexAttribI2ui
eedback; void __stdcall GLee_Lazy_glVertexAttribI2ui(GLuint index, GLuint x, GLuin
PFNGLBINDBUFFERRANGEPROC pglBindBufferRange=_Lazy_glBindBufferRange; t y) {if (GLeeInit()) glVertexAttribI2ui(index, x, y);}
PFNGLBINDBUFFERBASEPROC pglBindBufferBase=_Lazy_glBindBufferBase; GLEEPFNGLVERTEXATTRIBI2UIPROC GLeeFuncPtr_glVertexAttribI2ui=GLee_Lazy_gl
PFNGLTRANSFORMFEEDBACKVARYINGSPROC pglTransformFeedbackVaryings=_Lazy_glTra VertexAttribI2ui;
nsformFeedbackVaryings; #endif
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC pglGetTransformFeedbackVarying=_Lazy_g #ifndef GLEE_C_DEFINED_glVertexAttribI3ui
lGetTransformFeedbackVarying; #define GLEE_C_DEFINED_glVertexAttribI3ui
PFNGLCLAMPCOLORPROC pglClampColor=_Lazy_glClampColor; void __stdcall GLee_Lazy_glVertexAttribI3ui(GLuint index, GLuint x, GLuin
PFNGLBEGINCONDITIONALRENDERPROC pglBeginConditionalRender=_Lazy_glBeginCond t y, GLuint z) {if (GLeeInit()) glVertexAttribI3ui(index, x, y, z);}
itionalRender; GLEEPFNGLVERTEXATTRIBI3UIPROC GLeeFuncPtr_glVertexAttribI3ui=GLee_Lazy_gl
PFNGLENDCONDITIONALRENDERPROC pglEndConditionalRender=_Lazy_glEndConditiona VertexAttribI3ui;
lRender; #endif
PFNGLVERTEXATTRIBI1IPROC pglVertexAttribI1i=_Lazy_glVertexAttribI1i; #ifndef GLEE_C_DEFINED_glVertexAttribI4ui
PFNGLVERTEXATTRIBI2IPROC pglVertexAttribI2i=_Lazy_glVertexAttribI2i; #define GLEE_C_DEFINED_glVertexAttribI4ui
PFNGLVERTEXATTRIBI3IPROC pglVertexAttribI3i=_Lazy_glVertexAttribI3i; void __stdcall GLee_Lazy_glVertexAttribI4ui(GLuint index, GLuint x, GLuin
PFNGLVERTEXATTRIBI4IPROC pglVertexAttribI4i=_Lazy_glVertexAttribI4i; t y, GLuint z, GLuint w) {if (GLeeInit()) glVertexAttribI4ui(index, x, y,
PFNGLVERTEXATTRIBI1UIPROC pglVertexAttribI1ui=_Lazy_glVertexAttribI1ui; z, w);}
PFNGLVERTEXATTRIBI2UIPROC pglVertexAttribI2ui=_Lazy_glVertexAttribI2ui; GLEEPFNGLVERTEXATTRIBI4UIPROC GLeeFuncPtr_glVertexAttribI4ui=GLee_Lazy_gl
PFNGLVERTEXATTRIBI3UIPROC pglVertexAttribI3ui=_Lazy_glVertexAttribI3ui; VertexAttribI4ui;
PFNGLVERTEXATTRIBI4UIPROC pglVertexAttribI4ui=_Lazy_glVertexAttribI4ui; #endif
PFNGLVERTEXATTRIBI1IVPROC pglVertexAttribI1iv=_Lazy_glVertexAttribI1iv; #ifndef GLEE_C_DEFINED_glVertexAttribI1iv
PFNGLVERTEXATTRIBI2IVPROC pglVertexAttribI2iv=_Lazy_glVertexAttribI2iv; #define GLEE_C_DEFINED_glVertexAttribI1iv
PFNGLVERTEXATTRIBI3IVPROC pglVertexAttribI3iv=_Lazy_glVertexAttribI3iv; void __stdcall GLee_Lazy_glVertexAttribI1iv(GLuint index, const GLint * v
PFNGLVERTEXATTRIBI4IVPROC pglVertexAttribI4iv=_Lazy_glVertexAttribI4iv; ) {if (GLeeInit()) glVertexAttribI1iv(index, v);}
PFNGLVERTEXATTRIBI1UIVPROC pglVertexAttribI1uiv=_Lazy_glVertexAttribI1uiv; GLEEPFNGLVERTEXATTRIBI1IVPROC GLeeFuncPtr_glVertexAttribI1iv=GLee_Lazy_gl
PFNGLVERTEXATTRIBI2UIVPROC pglVertexAttribI2uiv=_Lazy_glVertexAttribI2uiv; VertexAttribI1iv;
PFNGLVERTEXATTRIBI3UIVPROC pglVertexAttribI3uiv=_Lazy_glVertexAttribI3uiv; #endif
PFNGLVERTEXATTRIBI4UIVPROC pglVertexAttribI4uiv=_Lazy_glVertexAttribI4uiv; #ifndef GLEE_C_DEFINED_glVertexAttribI2iv
PFNGLVERTEXATTRIBI4BVPROC pglVertexAttribI4bv=_Lazy_glVertexAttribI4bv; #define GLEE_C_DEFINED_glVertexAttribI2iv
PFNGLVERTEXATTRIBI4SVPROC pglVertexAttribI4sv=_Lazy_glVertexAttribI4sv; void __stdcall GLee_Lazy_glVertexAttribI2iv(GLuint index, const GLint * v
PFNGLVERTEXATTRIBI4UBVPROC pglVertexAttribI4ubv=_Lazy_glVertexAttribI4ubv; ) {if (GLeeInit()) glVertexAttribI2iv(index, v);}
PFNGLVERTEXATTRIBI4USVPROC pglVertexAttribI4usv=_Lazy_glVertexAttribI4usv; GLEEPFNGLVERTEXATTRIBI2IVPROC GLeeFuncPtr_glVertexAttribI2iv=GLee_Lazy_gl
PFNGLVERTEXATTRIBIPOINTERPROC pglVertexAttribIPointer=_Lazy_glVertexAttribI VertexAttribI2iv;
Pointer; #endif
PFNGLGETVERTEXATTRIBIIVPROC pglGetVertexAttribIiv=_Lazy_glGetVertexAttribIi #ifndef GLEE_C_DEFINED_glVertexAttribI3iv
v; #define GLEE_C_DEFINED_glVertexAttribI3iv
PFNGLGETVERTEXATTRIBIUIVPROC pglGetVertexAttribIuiv=_Lazy_glGetVertexAttrib void __stdcall GLee_Lazy_glVertexAttribI3iv(GLuint index, const GLint * v
Iuiv; ) {if (GLeeInit()) glVertexAttribI3iv(index, v);}
PFNGLGETUNIFORMUIVPROC pglGetUniformuiv=_Lazy_glGetUniformuiv; GLEEPFNGLVERTEXATTRIBI3IVPROC GLeeFuncPtr_glVertexAttribI3iv=GLee_Lazy_gl
PFNGLBINDFRAGDATALOCATIONPROC pglBindFragDataLocation=_Lazy_glBindFragDataL VertexAttribI3iv;
ocation; #endif
PFNGLGETFRAGDATALOCATIONPROC pglGetFragDataLocation=_Lazy_glGetFragDataLoca #ifndef GLEE_C_DEFINED_glVertexAttribI4iv
tion; #define GLEE_C_DEFINED_glVertexAttribI4iv
PFNGLUNIFORM1UIPROC pglUniform1ui=_Lazy_glUniform1ui; void __stdcall GLee_Lazy_glVertexAttribI4iv(GLuint index, const GLint * v
PFNGLUNIFORM2UIPROC pglUniform2ui=_Lazy_glUniform2ui; ) {if (GLeeInit()) glVertexAttribI4iv(index, v);}
PFNGLUNIFORM3UIPROC pglUniform3ui=_Lazy_glUniform3ui; GLEEPFNGLVERTEXATTRIBI4IVPROC GLeeFuncPtr_glVertexAttribI4iv=GLee_Lazy_gl
PFNGLUNIFORM4UIPROC pglUniform4ui=_Lazy_glUniform4ui; VertexAttribI4iv;
PFNGLUNIFORM1UIVPROC pglUniform1uiv=_Lazy_glUniform1uiv; #endif
PFNGLUNIFORM2UIVPROC pglUniform2uiv=_Lazy_glUniform2uiv; #ifndef GLEE_C_DEFINED_glVertexAttribI1uiv
PFNGLUNIFORM3UIVPROC pglUniform3uiv=_Lazy_glUniform3uiv; #define GLEE_C_DEFINED_glVertexAttribI1uiv
PFNGLUNIFORM4UIVPROC pglUniform4uiv=_Lazy_glUniform4uiv; void __stdcall GLee_Lazy_glVertexAttribI1uiv(GLuint index, const GLuint *
PFNGLTEXPARAMETERIIVPROC pglTexParameterIiv=_Lazy_glTexParameterIiv; v) {if (GLeeInit()) glVertexAttribI1uiv(index, v);}
PFNGLTEXPARAMETERIUIVPROC pglTexParameterIuiv=_Lazy_glTexParameterIuiv; GLEEPFNGLVERTEXATTRIBI1UIVPROC GLeeFuncPtr_glVertexAttribI1uiv=GLee_Lazy_
PFNGLGETTEXPARAMETERIIVPROC pglGetTexParameterIiv=_Lazy_glGetTexParameterIi glVertexAttribI1uiv;
v; #endif
PFNGLGETTEXPARAMETERIUIVPROC pglGetTexParameterIuiv=_Lazy_glGetTexParameter #ifndef GLEE_C_DEFINED_glVertexAttribI2uiv
Iuiv; #define GLEE_C_DEFINED_glVertexAttribI2uiv
PFNGLCLEARBUFFERIVPROC pglClearBufferiv=_Lazy_glClearBufferiv; void __stdcall GLee_Lazy_glVertexAttribI2uiv(GLuint index, const GLuint *
PFNGLCLEARBUFFERUIVPROC pglClearBufferuiv=_Lazy_glClearBufferuiv; v) {if (GLeeInit()) glVertexAttribI2uiv(index, v);}
PFNGLCLEARBUFFERFVPROC pglClearBufferfv=_Lazy_glClearBufferfv; GLEEPFNGLVERTEXATTRIBI2UIVPROC GLeeFuncPtr_glVertexAttribI2uiv=GLee_Lazy_
PFNGLCLEARBUFFERFIPROC pglClearBufferfi=_Lazy_glClearBufferfi; glVertexAttribI2uiv;
PFNGLGETSTRINGIPROC pglGetStringi=_Lazy_glGetStringi; #endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3uiv
#define GLEE_C_DEFINED_glVertexAttribI3uiv
void __stdcall GLee_Lazy_glVertexAttribI3uiv(GLuint index, const GLuint *
v) {if (GLeeInit()) glVertexAttribI3uiv(index, v);}
GLEEPFNGLVERTEXATTRIBI3UIVPROC GLeeFuncPtr_glVertexAttribI3uiv=GLee_Lazy_
glVertexAttribI3uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4uiv
#define GLEE_C_DEFINED_glVertexAttribI4uiv
void __stdcall GLee_Lazy_glVertexAttribI4uiv(GLuint index, const GLuint *
v) {if (GLeeInit()) glVertexAttribI4uiv(index, v);}
GLEEPFNGLVERTEXATTRIBI4UIVPROC GLeeFuncPtr_glVertexAttribI4uiv=GLee_Lazy_
glVertexAttribI4uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4bv
#define GLEE_C_DEFINED_glVertexAttribI4bv
void __stdcall GLee_Lazy_glVertexAttribI4bv(GLuint index, const GLbyte *
v) {if (GLeeInit()) glVertexAttribI4bv(index, v);}
GLEEPFNGLVERTEXATTRIBI4BVPROC GLeeFuncPtr_glVertexAttribI4bv=GLee_Lazy_gl
VertexAttribI4bv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4sv
#define GLEE_C_DEFINED_glVertexAttribI4sv
void __stdcall GLee_Lazy_glVertexAttribI4sv(GLuint index, const GLshort *
v) {if (GLeeInit()) glVertexAttribI4sv(index, v);}
GLEEPFNGLVERTEXATTRIBI4SVPROC GLeeFuncPtr_glVertexAttribI4sv=GLee_Lazy_gl
VertexAttribI4sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ubv
#define GLEE_C_DEFINED_glVertexAttribI4ubv
void __stdcall GLee_Lazy_glVertexAttribI4ubv(GLuint index, const GLubyte
* v) {if (GLeeInit()) glVertexAttribI4ubv(index, v);}
GLEEPFNGLVERTEXATTRIBI4UBVPROC GLeeFuncPtr_glVertexAttribI4ubv=GLee_Lazy_
glVertexAttribI4ubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4usv
#define GLEE_C_DEFINED_glVertexAttribI4usv
void __stdcall GLee_Lazy_glVertexAttribI4usv(GLuint index, const GLushort
* v) {if (GLeeInit()) glVertexAttribI4usv(index, v);}
GLEEPFNGLVERTEXATTRIBI4USVPROC GLeeFuncPtr_glVertexAttribI4usv=GLee_Lazy_
glVertexAttribI4usv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribIPointer
#define GLEE_C_DEFINED_glVertexAttribIPointer
void __stdcall GLee_Lazy_glVertexAttribIPointer(GLuint index, GLint size,
GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glV
ertexAttribIPointer(index, size, type, stride, pointer);}
GLEEPFNGLVERTEXATTRIBIPOINTERPROC GLeeFuncPtr_glVertexAttribIPointer=GLee
_Lazy_glVertexAttribIPointer;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIiv
#define GLEE_C_DEFINED_glGetVertexAttribIiv
void __stdcall GLee_Lazy_glGetVertexAttribIiv(GLuint index, GLenum pname,
GLint * params) {if (GLeeInit()) glGetVertexAttribIiv(index, pname, param
s);}
GLEEPFNGLGETVERTEXATTRIBIIVPROC GLeeFuncPtr_glGetVertexAttribIiv=GLee_Laz
y_glGetVertexAttribIiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIuiv
#define GLEE_C_DEFINED_glGetVertexAttribIuiv
void __stdcall GLee_Lazy_glGetVertexAttribIuiv(GLuint index, GLenum pname
, GLuint * params) {if (GLeeInit()) glGetVertexAttribIuiv(index, pname, pa
rams);}
GLEEPFNGLGETVERTEXATTRIBIUIVPROC GLeeFuncPtr_glGetVertexAttribIuiv=GLee_L
azy_glGetVertexAttribIuiv;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformuiv
#define GLEE_C_DEFINED_glGetUniformuiv
void __stdcall GLee_Lazy_glGetUniformuiv(GLuint program, GLint location,
GLuint * params) {if (GLeeInit()) glGetUniformuiv(program, location, param
s);}
GLEEPFNGLGETUNIFORMUIVPROC GLeeFuncPtr_glGetUniformuiv=GLee_Lazy_glGetUni
formuiv;
#endif
#ifndef GLEE_C_DEFINED_glBindFragDataLocation
#define GLEE_C_DEFINED_glBindFragDataLocation
void __stdcall GLee_Lazy_glBindFragDataLocation(GLuint program, GLuint co
lor, const GLchar * name) {if (GLeeInit()) glBindFragDataLocation(program,
color, name);}
GLEEPFNGLBINDFRAGDATALOCATIONPROC GLeeFuncPtr_glBindFragDataLocation=GLee
_Lazy_glBindFragDataLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetFragDataLocation
#define GLEE_C_DEFINED_glGetFragDataLocation
GLint __stdcall GLee_Lazy_glGetFragDataLocation(GLuint program, const GLc
har * name) {if (GLeeInit()) return glGetFragDataLocation(program, name);
return (GLint)0;}
GLEEPFNGLGETFRAGDATALOCATIONPROC GLeeFuncPtr_glGetFragDataLocation=GLee_L
azy_glGetFragDataLocation;
#endif
#ifndef GLEE_C_DEFINED_glUniform1ui
#define GLEE_C_DEFINED_glUniform1ui
void __stdcall GLee_Lazy_glUniform1ui(GLint location, GLuint v0) {if (GL
eeInit()) glUniform1ui(location, v0);}
GLEEPFNGLUNIFORM1UIPROC GLeeFuncPtr_glUniform1ui=GLee_Lazy_glUniform1ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform2ui
#define GLEE_C_DEFINED_glUniform2ui
void __stdcall GLee_Lazy_glUniform2ui(GLint location, GLuint v0, GLuint v
1) {if (GLeeInit()) glUniform2ui(location, v0, v1);}
GLEEPFNGLUNIFORM2UIPROC GLeeFuncPtr_glUniform2ui=GLee_Lazy_glUniform2ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform3ui
#define GLEE_C_DEFINED_glUniform3ui
void __stdcall GLee_Lazy_glUniform3ui(GLint location, GLuint v0, GLuint v
1, GLuint v2) {if (GLeeInit()) glUniform3ui(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3UIPROC GLeeFuncPtr_glUniform3ui=GLee_Lazy_glUniform3ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform4ui
#define GLEE_C_DEFINED_glUniform4ui
void __stdcall GLee_Lazy_glUniform4ui(GLint location, GLuint v0, GLuint v
1, GLuint v2, GLuint v3) {if (GLeeInit()) glUniform4ui(location, v0, v1, v
2, v3);}
GLEEPFNGLUNIFORM4UIPROC GLeeFuncPtr_glUniform4ui=GLee_Lazy_glUniform4ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform1uiv
#define GLEE_C_DEFINED_glUniform1uiv
void __stdcall GLee_Lazy_glUniform1uiv(GLint location, GLsizei count, con
st GLuint * value) {if (GLeeInit()) glUniform1uiv(location, count, value);
}
GLEEPFNGLUNIFORM1UIVPROC GLeeFuncPtr_glUniform1uiv=GLee_Lazy_glUniform1ui
v;
#endif
#ifndef GLEE_C_DEFINED_glUniform2uiv
#define GLEE_C_DEFINED_glUniform2uiv
void __stdcall GLee_Lazy_glUniform2uiv(GLint location, GLsizei count, con
st GLuint * value) {if (GLeeInit()) glUniform2uiv(location, count, value);
}
GLEEPFNGLUNIFORM2UIVPROC GLeeFuncPtr_glUniform2uiv=GLee_Lazy_glUniform2ui
v;
#endif
#ifndef GLEE_C_DEFINED_glUniform3uiv
#define GLEE_C_DEFINED_glUniform3uiv
void __stdcall GLee_Lazy_glUniform3uiv(GLint location, GLsizei count, con
st GLuint * value) {if (GLeeInit()) glUniform3uiv(location, count, value);
}
GLEEPFNGLUNIFORM3UIVPROC GLeeFuncPtr_glUniform3uiv=GLee_Lazy_glUniform3ui
v;
#endif
#ifndef GLEE_C_DEFINED_glUniform4uiv
#define GLEE_C_DEFINED_glUniform4uiv
void __stdcall GLee_Lazy_glUniform4uiv(GLint location, GLsizei count, con
st GLuint * value) {if (GLeeInit()) glUniform4uiv(location, count, value);
}
GLEEPFNGLUNIFORM4UIVPROC GLeeFuncPtr_glUniform4uiv=GLee_Lazy_glUniform4ui
v;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIiv
#define GLEE_C_DEFINED_glTexParameterIiv
void __stdcall GLee_Lazy_glTexParameterIiv(GLenum target, GLenum pname, c
onst GLint * params) {if (GLeeInit()) glTexParameterIiv(target, pname, par
ams);}
GLEEPFNGLTEXPARAMETERIIVPROC GLeeFuncPtr_glTexParameterIiv=GLee_Lazy_glTe
xParameterIiv;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIuiv
#define GLEE_C_DEFINED_glTexParameterIuiv
void __stdcall GLee_Lazy_glTexParameterIuiv(GLenum target, GLenum pname,
const GLuint * params) {if (GLeeInit()) glTexParameterIuiv(target, pname,
params);}
GLEEPFNGLTEXPARAMETERIUIVPROC GLeeFuncPtr_glTexParameterIuiv=GLee_Lazy_gl
TexParameterIuiv;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIiv
#define GLEE_C_DEFINED_glGetTexParameterIiv
void __stdcall GLee_Lazy_glGetTexParameterIiv(GLenum target, GLenum pname
, GLint * params) {if (GLeeInit()) glGetTexParameterIiv(target, pname, par
ams);}
GLEEPFNGLGETTEXPARAMETERIIVPROC GLeeFuncPtr_glGetTexParameterIiv=GLee_Laz
y_glGetTexParameterIiv;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIuiv
#define GLEE_C_DEFINED_glGetTexParameterIuiv
void __stdcall GLee_Lazy_glGetTexParameterIuiv(GLenum target, GLenum pnam
e, GLuint * params) {if (GLeeInit()) glGetTexParameterIuiv(target, pname,
params);}
GLEEPFNGLGETTEXPARAMETERIUIVPROC GLeeFuncPtr_glGetTexParameterIuiv=GLee_L
azy_glGetTexParameterIuiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferiv
#define GLEE_C_DEFINED_glClearBufferiv
void __stdcall GLee_Lazy_glClearBufferiv(GLenum buffer, GLint drawbuffer,
const GLint * value) {if (GLeeInit()) glClearBufferiv(buffer, drawbuffer,
value);}
GLEEPFNGLCLEARBUFFERIVPROC GLeeFuncPtr_glClearBufferiv=GLee_Lazy_glClearB
ufferiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferuiv
#define GLEE_C_DEFINED_glClearBufferuiv
void __stdcall GLee_Lazy_glClearBufferuiv(GLenum buffer, GLint drawbuffer
, const GLuint * value) {if (GLeeInit()) glClearBufferuiv(buffer, drawbuff
er, value);}
GLEEPFNGLCLEARBUFFERUIVPROC GLeeFuncPtr_glClearBufferuiv=GLee_Lazy_glClea
rBufferuiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferfv
#define GLEE_C_DEFINED_glClearBufferfv
void __stdcall GLee_Lazy_glClearBufferfv(GLenum buffer, GLint drawbuffer,
const GLfloat * value) {if (GLeeInit()) glClearBufferfv(buffer, drawbuffe
r, value);}
GLEEPFNGLCLEARBUFFERFVPROC GLeeFuncPtr_glClearBufferfv=GLee_Lazy_glClearB
ufferfv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferfi
#define GLEE_C_DEFINED_glClearBufferfi
void __stdcall GLee_Lazy_glClearBufferfi(GLenum buffer, GLint drawbuffer,
GLfloat depth, GLint stencil) {if (GLeeInit()) glClearBufferfi(buffer, dr
awbuffer, depth, stencil);}
GLEEPFNGLCLEARBUFFERFIPROC GLeeFuncPtr_glClearBufferfi=GLee_Lazy_glClearB
ufferfi;
#endif
#ifndef GLEE_C_DEFINED_glGetStringi
#define GLEE_C_DEFINED_glGetStringi
const GLubyte * __stdcall GLee_Lazy_glGetStringi(GLenum name, GLuint inde
x) {if (GLeeInit()) return glGetStringi(name, index); return (const GLubyt
e *)0;}
GLEEPFNGLGETSTRINGIPROC GLeeFuncPtr_glGetStringi=GLee_Lazy_glGetStringi;
#endif
#endif #endif
/* GL_ARB_multitexture */ /* GL_ARB_multitexture */
#ifdef __GLEE_GL_ARB_multitexture #ifdef __GLEE_GL_ARB_multitexture
void __stdcall _Lazy_glActiveTextureARB(GLenum texture) #ifndef GLEE_C_DEFINED_glActiveTextureARB
{if (GLeeInit()) glActiveTextureARB(texture);} #define GLEE_C_DEFINED_glActiveTextureARB
void __stdcall _Lazy_glClientActiveTextureARB(GLenum texture) void __stdcall GLee_Lazy_glActiveTextureARB(GLenum texture) {if (GLeeIni
{if (GLeeInit()) glClientActiveTextureARB(texture);} t()) glActiveTextureARB(texture);}
void __stdcall _Lazy_glMultiTexCoord1dARB(GLenum target, GLdouble s) GLEEPFNGLACTIVETEXTUREARBPROC GLeeFuncPtr_glActiveTextureARB=GLee_Lazy_gl
{if (GLeeInit()) glMultiTexCoord1dARB(target, s);} ActiveTextureARB;
void __stdcall _Lazy_glMultiTexCoord1dvARB(GLenum target, const GLdouble * #endif
v) {if (GLeeInit()) glMultiTexCoord1dvARB(target, v);} #ifndef GLEE_C_DEFINED_glClientActiveTextureARB
void __stdcall _Lazy_glMultiTexCoord1fARB(GLenum target, GLfloat s) #define GLEE_C_DEFINED_glClientActiveTextureARB
{if (GLeeInit()) glMultiTexCoord1fARB(target, s);} void __stdcall GLee_Lazy_glClientActiveTextureARB(GLenum texture) {if (G
void __stdcall _Lazy_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v LeeInit()) glClientActiveTextureARB(texture);}
) {if (GLeeInit()) glMultiTexCoord1fvARB(target, v);} GLEEPFNGLCLIENTACTIVETEXTUREARBPROC GLeeFuncPtr_glClientActiveTextureARB=
void __stdcall _Lazy_glMultiTexCoord1iARB(GLenum target, GLint s) GLee_Lazy_glClientActiveTextureARB;
{if (GLeeInit()) glMultiTexCoord1iARB(target, s);} #endif
void __stdcall _Lazy_glMultiTexCoord1ivARB(GLenum target, const GLint * v) #ifndef GLEE_C_DEFINED_glMultiTexCoord1dARB
{if (GLeeInit()) glMultiTexCoord1ivARB(target, v);} #define GLEE_C_DEFINED_glMultiTexCoord1dARB
void __stdcall _Lazy_glMultiTexCoord1sARB(GLenum target, GLshort s) void __stdcall GLee_Lazy_glMultiTexCoord1dARB(GLenum target, GLdouble s)
{if (GLeeInit()) glMultiTexCoord1sARB(target, s);} {if (GLeeInit()) glMultiTexCoord1dARB(target, s);}
void __stdcall _Lazy_glMultiTexCoord1svARB(GLenum target, const GLshort * v GLEEPFNGLMULTITEXCOORD1DARBPROC GLeeFuncPtr_glMultiTexCoord1dARB=GLee_Laz
) {if (GLeeInit()) glMultiTexCoord1svARB(target, v);} y_glMultiTexCoord1dARB;
void __stdcall _Lazy_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdoub #endif
le t) {if (GLeeInit()) glMultiTexCoord2dARB(target, s, t);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1dvARB
void __stdcall _Lazy_glMultiTexCoord2dvARB(GLenum target, const GLdouble * #define GLEE_C_DEFINED_glMultiTexCoord1dvARB
v) {if (GLeeInit()) glMultiTexCoord2dvARB(target, v);} void __stdcall GLee_Lazy_glMultiTexCoord1dvARB(GLenum target, const GLdou
void __stdcall _Lazy_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat ble * v) {if (GLeeInit()) glMultiTexCoord1dvARB(target, v);}
t) {if (GLeeInit()) glMultiTexCoord2fARB(target, s, t);} GLEEPFNGLMULTITEXCOORD1DVARBPROC GLeeFuncPtr_glMultiTexCoord1dvARB=GLee_L
void __stdcall _Lazy_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v azy_glMultiTexCoord1dvARB;
) {if (GLeeInit()) glMultiTexCoord2fvARB(target, v);} #endif
void __stdcall _Lazy_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t) #ifndef GLEE_C_DEFINED_glMultiTexCoord1fARB
{if (GLeeInit()) glMultiTexCoord2iARB(target, s, t);} #define GLEE_C_DEFINED_glMultiTexCoord1fARB
void __stdcall _Lazy_glMultiTexCoord2ivARB(GLenum target, const GLint * v) void __stdcall GLee_Lazy_glMultiTexCoord1fARB(GLenum target, GLfloat s)
{if (GLeeInit()) glMultiTexCoord2ivARB(target, v);} {if (GLeeInit()) glMultiTexCoord1fARB(target, s);}
void __stdcall _Lazy_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort GLEEPFNGLMULTITEXCOORD1FARBPROC GLeeFuncPtr_glMultiTexCoord1fARB=GLee_Laz
t) {if (GLeeInit()) glMultiTexCoord2sARB(target, s, t);} y_glMultiTexCoord1fARB;
void __stdcall _Lazy_glMultiTexCoord2svARB(GLenum target, const GLshort * v #endif
) {if (GLeeInit()) glMultiTexCoord2svARB(target, v);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1fvARB
void __stdcall _Lazy_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdoub #define GLEE_C_DEFINED_glMultiTexCoord1fvARB
le t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3dARB(target, s, t, r);} void __stdcall GLee_Lazy_glMultiTexCoord1fvARB(GLenum target, const GLflo
void __stdcall _Lazy_glMultiTexCoord3dvARB(GLenum target, const GLdouble * at * v) {if (GLeeInit()) glMultiTexCoord1fvARB(target, v);}
v) {if (GLeeInit()) glMultiTexCoord3dvARB(target, v);} GLEEPFNGLMULTITEXCOORD1FVARBPROC GLeeFuncPtr_glMultiTexCoord1fvARB=GLee_L
void __stdcall _Lazy_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat azy_glMultiTexCoord1fvARB;
t, GLfloat r) {if (GLeeInit()) glMultiTexCoord3fARB(target, s, t, r);} #endif
void __stdcall _Lazy_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v #ifndef GLEE_C_DEFINED_glMultiTexCoord1iARB
) {if (GLeeInit()) glMultiTexCoord3fvARB(target, v);} #define GLEE_C_DEFINED_glMultiTexCoord1iARB
void __stdcall _Lazy_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, void __stdcall GLee_Lazy_glMultiTexCoord1iARB(GLenum target, GLint s) {i
GLint r) {if (GLeeInit()) glMultiTexCoord3iARB(target, s, t, r);} f (GLeeInit()) glMultiTexCoord1iARB(target, s);}
void __stdcall _Lazy_glMultiTexCoord3ivARB(GLenum target, const GLint * v) GLEEPFNGLMULTITEXCOORD1IARBPROC GLeeFuncPtr_glMultiTexCoord1iARB=GLee_Laz
{if (GLeeInit()) glMultiTexCoord3ivARB(target, v);} y_glMultiTexCoord1iARB;
void __stdcall _Lazy_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort #endif
t, GLshort r) {if (GLeeInit()) glMultiTexCoord3sARB(target, s, t, r);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1ivARB
void __stdcall _Lazy_glMultiTexCoord3svARB(GLenum target, const GLshort * v #define GLEE_C_DEFINED_glMultiTexCoord1ivARB
) {if (GLeeInit()) glMultiTexCoord3svARB(target, v);} void __stdcall GLee_Lazy_glMultiTexCoord1ivARB(GLenum target, const GLint
void __stdcall _Lazy_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdoub * v) {if (GLeeInit()) glMultiTexCoord1ivARB(target, v);}
le t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4dARB(target GLEEPFNGLMULTITEXCOORD1IVARBPROC GLeeFuncPtr_glMultiTexCoord1ivARB=GLee_L
, s, t, r, q);} azy_glMultiTexCoord1ivARB;
void __stdcall _Lazy_glMultiTexCoord4dvARB(GLenum target, const GLdouble * #endif
v) {if (GLeeInit()) glMultiTexCoord4dvARB(target, v);} #ifndef GLEE_C_DEFINED_glMultiTexCoord1sARB
void __stdcall _Lazy_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat #define GLEE_C_DEFINED_glMultiTexCoord1sARB
t, GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4fARB(target, s, void __stdcall GLee_Lazy_glMultiTexCoord1sARB(GLenum target, GLshort s)
t, r, q);} {if (GLeeInit()) glMultiTexCoord1sARB(target, s);}
void __stdcall _Lazy_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v GLEEPFNGLMULTITEXCOORD1SARBPROC GLeeFuncPtr_glMultiTexCoord1sARB=GLee_Laz
) {if (GLeeInit()) glMultiTexCoord4fvARB(target, v);} y_glMultiTexCoord1sARB;
void __stdcall _Lazy_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, #endif
GLint r, GLint q) {if (GLeeInit()) glMultiTexCoord4iARB(target, s, t, r, q #ifndef GLEE_C_DEFINED_glMultiTexCoord1svARB
);} #define GLEE_C_DEFINED_glMultiTexCoord1svARB
void __stdcall _Lazy_glMultiTexCoord4ivARB(GLenum target, const GLint * v) void __stdcall GLee_Lazy_glMultiTexCoord1svARB(GLenum target, const GLsho
{if (GLeeInit()) glMultiTexCoord4ivARB(target, v);} rt * v) {if (GLeeInit()) glMultiTexCoord1svARB(target, v);}
void __stdcall _Lazy_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort GLEEPFNGLMULTITEXCOORD1SVARBPROC GLeeFuncPtr_glMultiTexCoord1svARB=GLee_L
t, GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4sARB(target, s, azy_glMultiTexCoord1svARB;
t, r, q);} #endif
void __stdcall _Lazy_glMultiTexCoord4svARB(GLenum target, const GLshort * v #ifndef GLEE_C_DEFINED_glMultiTexCoord2dARB
) {if (GLeeInit()) glMultiTexCoord4svARB(target, v);} #define GLEE_C_DEFINED_glMultiTexCoord2dARB
PFNGLACTIVETEXTUREARBPROC pglActiveTextureARB=_Lazy_glActiveTextureARB; void __stdcall GLee_Lazy_glMultiTexCoord2dARB(GLenum target, GLdouble s,
PFNGLCLIENTACTIVETEXTUREARBPROC pglClientActiveTextureARB=_Lazy_glClientAct GLdouble t) {if (GLeeInit()) glMultiTexCoord2dARB(target, s, t);}
iveTextureARB; GLEEPFNGLMULTITEXCOORD2DARBPROC GLeeFuncPtr_glMultiTexCoord2dARB=GLee_Laz
PFNGLMULTITEXCOORD1DARBPROC pglMultiTexCoord1dARB=_Lazy_glMultiTexCoord1dAR y_glMultiTexCoord2dARB;
B; #endif
PFNGLMULTITEXCOORD1DVARBPROC pglMultiTexCoord1dvARB=_Lazy_glMultiTexCoord1d #ifndef GLEE_C_DEFINED_glMultiTexCoord2dvARB
vARB; #define GLEE_C_DEFINED_glMultiTexCoord2dvARB
PFNGLMULTITEXCOORD1FARBPROC pglMultiTexCoord1fARB=_Lazy_glMultiTexCoord1fAR void __stdcall GLee_Lazy_glMultiTexCoord2dvARB(GLenum target, const GLdou
B; ble * v) {if (GLeeInit()) glMultiTexCoord2dvARB(target, v);}
PFNGLMULTITEXCOORD1FVARBPROC pglMultiTexCoord1fvARB=_Lazy_glMultiTexCoord1f GLEEPFNGLMULTITEXCOORD2DVARBPROC GLeeFuncPtr_glMultiTexCoord2dvARB=GLee_L
vARB; azy_glMultiTexCoord2dvARB;
PFNGLMULTITEXCOORD1IARBPROC pglMultiTexCoord1iARB=_Lazy_glMultiTexCoord1iAR #endif
B; #ifndef GLEE_C_DEFINED_glMultiTexCoord2fARB
PFNGLMULTITEXCOORD1IVARBPROC pglMultiTexCoord1ivARB=_Lazy_glMultiTexCoord1i #define GLEE_C_DEFINED_glMultiTexCoord2fARB
vARB; void __stdcall GLee_Lazy_glMultiTexCoord2fARB(GLenum target, GLfloat s, G
PFNGLMULTITEXCOORD1SARBPROC pglMultiTexCoord1sARB=_Lazy_glMultiTexCoord1sAR Lfloat t) {if (GLeeInit()) glMultiTexCoord2fARB(target, s, t);}
B; GLEEPFNGLMULTITEXCOORD2FARBPROC GLeeFuncPtr_glMultiTexCoord2fARB=GLee_Laz
PFNGLMULTITEXCOORD1SVARBPROC pglMultiTexCoord1svARB=_Lazy_glMultiTexCoord1s y_glMultiTexCoord2fARB;
vARB; #endif
PFNGLMULTITEXCOORD2DARBPROC pglMultiTexCoord2dARB=_Lazy_glMultiTexCoord2dAR #ifndef GLEE_C_DEFINED_glMultiTexCoord2fvARB
B; #define GLEE_C_DEFINED_glMultiTexCoord2fvARB
PFNGLMULTITEXCOORD2DVARBPROC pglMultiTexCoord2dvARB=_Lazy_glMultiTexCoord2d void __stdcall GLee_Lazy_glMultiTexCoord2fvARB(GLenum target, const GLflo
vARB; at * v) {if (GLeeInit()) glMultiTexCoord2fvARB(target, v);}
PFNGLMULTITEXCOORD2FARBPROC pglMultiTexCoord2fARB=_Lazy_glMultiTexCoord2fAR GLEEPFNGLMULTITEXCOORD2FVARBPROC GLeeFuncPtr_glMultiTexCoord2fvARB=GLee_L
B; azy_glMultiTexCoord2fvARB;
PFNGLMULTITEXCOORD2FVARBPROC pglMultiTexCoord2fvARB=_Lazy_glMultiTexCoord2f #endif
vARB; #ifndef GLEE_C_DEFINED_glMultiTexCoord2iARB
PFNGLMULTITEXCOORD2IARBPROC pglMultiTexCoord2iARB=_Lazy_glMultiTexCoord2iAR #define GLEE_C_DEFINED_glMultiTexCoord2iARB
B; void __stdcall GLee_Lazy_glMultiTexCoord2iARB(GLenum target, GLint s, GLi
PFNGLMULTITEXCOORD2IVARBPROC pglMultiTexCoord2ivARB=_Lazy_glMultiTexCoord2i nt t) {if (GLeeInit()) glMultiTexCoord2iARB(target, s, t);}
vARB; GLEEPFNGLMULTITEXCOORD2IARBPROC GLeeFuncPtr_glMultiTexCoord2iARB=GLee_Laz
PFNGLMULTITEXCOORD2SARBPROC pglMultiTexCoord2sARB=_Lazy_glMultiTexCoord2sAR y_glMultiTexCoord2iARB;
B; #endif
PFNGLMULTITEXCOORD2SVARBPROC pglMultiTexCoord2svARB=_Lazy_glMultiTexCoord2s #ifndef GLEE_C_DEFINED_glMultiTexCoord2ivARB
vARB; #define GLEE_C_DEFINED_glMultiTexCoord2ivARB
PFNGLMULTITEXCOORD3DARBPROC pglMultiTexCoord3dARB=_Lazy_glMultiTexCoord3dAR void __stdcall GLee_Lazy_glMultiTexCoord2ivARB(GLenum target, const GLint
B; * v) {if (GLeeInit()) glMultiTexCoord2ivARB(target, v);}
PFNGLMULTITEXCOORD3DVARBPROC pglMultiTexCoord3dvARB=_Lazy_glMultiTexCoord3d GLEEPFNGLMULTITEXCOORD2IVARBPROC GLeeFuncPtr_glMultiTexCoord2ivARB=GLee_L
vARB; azy_glMultiTexCoord2ivARB;
PFNGLMULTITEXCOORD3FARBPROC pglMultiTexCoord3fARB=_Lazy_glMultiTexCoord3fAR #endif
B; #ifndef GLEE_C_DEFINED_glMultiTexCoord2sARB
PFNGLMULTITEXCOORD3FVARBPROC pglMultiTexCoord3fvARB=_Lazy_glMultiTexCoord3f #define GLEE_C_DEFINED_glMultiTexCoord2sARB
vARB; void __stdcall GLee_Lazy_glMultiTexCoord2sARB(GLenum target, GLshort s, G
PFNGLMULTITEXCOORD3IARBPROC pglMultiTexCoord3iARB=_Lazy_glMultiTexCoord3iAR Lshort t) {if (GLeeInit()) glMultiTexCoord2sARB(target, s, t);}
B; GLEEPFNGLMULTITEXCOORD2SARBPROC GLeeFuncPtr_glMultiTexCoord2sARB=GLee_Laz
PFNGLMULTITEXCOORD3IVARBPROC pglMultiTexCoord3ivARB=_Lazy_glMultiTexCoord3i y_glMultiTexCoord2sARB;
vARB; #endif
PFNGLMULTITEXCOORD3SARBPROC pglMultiTexCoord3sARB=_Lazy_glMultiTexCoord3sAR #ifndef GLEE_C_DEFINED_glMultiTexCoord2svARB
B; #define GLEE_C_DEFINED_glMultiTexCoord2svARB
PFNGLMULTITEXCOORD3SVARBPROC pglMultiTexCoord3svARB=_Lazy_glMultiTexCoord3s void __stdcall GLee_Lazy_glMultiTexCoord2svARB(GLenum target, const GLsho
vARB; rt * v) {if (GLeeInit()) glMultiTexCoord2svARB(target, v);}
PFNGLMULTITEXCOORD4DARBPROC pglMultiTexCoord4dARB=_Lazy_glMultiTexCoord4dAR GLEEPFNGLMULTITEXCOORD2SVARBPROC GLeeFuncPtr_glMultiTexCoord2svARB=GLee_L
B; azy_glMultiTexCoord2svARB;
PFNGLMULTITEXCOORD4DVARBPROC pglMultiTexCoord4dvARB=_Lazy_glMultiTexCoord4d #endif
vARB; #ifndef GLEE_C_DEFINED_glMultiTexCoord3dARB
PFNGLMULTITEXCOORD4FARBPROC pglMultiTexCoord4fARB=_Lazy_glMultiTexCoord4fAR #define GLEE_C_DEFINED_glMultiTexCoord3dARB
B; void __stdcall GLee_Lazy_glMultiTexCoord3dARB(GLenum target, GLdouble s,
PFNGLMULTITEXCOORD4FVARBPROC pglMultiTexCoord4fvARB=_Lazy_glMultiTexCoord4f GLdouble t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3dARB(target, s, t
vARB; , r);}
PFNGLMULTITEXCOORD4IARBPROC pglMultiTexCoord4iARB=_Lazy_glMultiTexCoord4iAR GLEEPFNGLMULTITEXCOORD3DARBPROC GLeeFuncPtr_glMultiTexCoord3dARB=GLee_Laz
B; y_glMultiTexCoord3dARB;
PFNGLMULTITEXCOORD4IVARBPROC pglMultiTexCoord4ivARB=_Lazy_glMultiTexCoord4i #endif
vARB; #ifndef GLEE_C_DEFINED_glMultiTexCoord3dvARB
PFNGLMULTITEXCOORD4SARBPROC pglMultiTexCoord4sARB=_Lazy_glMultiTexCoord4sAR #define GLEE_C_DEFINED_glMultiTexCoord3dvARB
B; void __stdcall GLee_Lazy_glMultiTexCoord3dvARB(GLenum target, const GLdou
PFNGLMULTITEXCOORD4SVARBPROC pglMultiTexCoord4svARB=_Lazy_glMultiTexCoord4s ble * v) {if (GLeeInit()) glMultiTexCoord3dvARB(target, v);}
vARB; GLEEPFNGLMULTITEXCOORD3DVARBPROC GLeeFuncPtr_glMultiTexCoord3dvARB=GLee_L
azy_glMultiTexCoord3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fARB
#define GLEE_C_DEFINED_glMultiTexCoord3fARB
void __stdcall GLee_Lazy_glMultiTexCoord3fARB(GLenum target, GLfloat s, G
Lfloat t, GLfloat r) {if (GLeeInit()) glMultiTexCoord3fARB(target, s, t, r
);}
GLEEPFNGLMULTITEXCOORD3FARBPROC GLeeFuncPtr_glMultiTexCoord3fARB=GLee_Laz
y_glMultiTexCoord3fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fvARB
#define GLEE_C_DEFINED_glMultiTexCoord3fvARB
void __stdcall GLee_Lazy_glMultiTexCoord3fvARB(GLenum target, const GLflo
at * v) {if (GLeeInit()) glMultiTexCoord3fvARB(target, v);}
GLEEPFNGLMULTITEXCOORD3FVARBPROC GLeeFuncPtr_glMultiTexCoord3fvARB=GLee_L
azy_glMultiTexCoord3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3iARB
#define GLEE_C_DEFINED_glMultiTexCoord3iARB
void __stdcall GLee_Lazy_glMultiTexCoord3iARB(GLenum target, GLint s, GLi
nt t, GLint r) {if (GLeeInit()) glMultiTexCoord3iARB(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3IARBPROC GLeeFuncPtr_glMultiTexCoord3iARB=GLee_Laz
y_glMultiTexCoord3iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3ivARB
#define GLEE_C_DEFINED_glMultiTexCoord3ivARB
void __stdcall GLee_Lazy_glMultiTexCoord3ivARB(GLenum target, const GLint
* v) {if (GLeeInit()) glMultiTexCoord3ivARB(target, v);}
GLEEPFNGLMULTITEXCOORD3IVARBPROC GLeeFuncPtr_glMultiTexCoord3ivARB=GLee_L
azy_glMultiTexCoord3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3sARB
#define GLEE_C_DEFINED_glMultiTexCoord3sARB
void __stdcall GLee_Lazy_glMultiTexCoord3sARB(GLenum target, GLshort s, G
Lshort t, GLshort r) {if (GLeeInit()) glMultiTexCoord3sARB(target, s, t, r
);}
GLEEPFNGLMULTITEXCOORD3SARBPROC GLeeFuncPtr_glMultiTexCoord3sARB=GLee_Laz
y_glMultiTexCoord3sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3svARB
#define GLEE_C_DEFINED_glMultiTexCoord3svARB
void __stdcall GLee_Lazy_glMultiTexCoord3svARB(GLenum target, const GLsho
rt * v) {if (GLeeInit()) glMultiTexCoord3svARB(target, v);}
GLEEPFNGLMULTITEXCOORD3SVARBPROC GLeeFuncPtr_glMultiTexCoord3svARB=GLee_L
azy_glMultiTexCoord3svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dARB
#define GLEE_C_DEFINED_glMultiTexCoord4dARB
void __stdcall GLee_Lazy_glMultiTexCoord4dARB(GLenum target, GLdouble s,
GLdouble t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4dARB(
target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4DARBPROC GLeeFuncPtr_glMultiTexCoord4dARB=GLee_Laz
y_glMultiTexCoord4dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dvARB
#define GLEE_C_DEFINED_glMultiTexCoord4dvARB
void __stdcall GLee_Lazy_glMultiTexCoord4dvARB(GLenum target, const GLdou
ble * v) {if (GLeeInit()) glMultiTexCoord4dvARB(target, v);}
GLEEPFNGLMULTITEXCOORD4DVARBPROC GLeeFuncPtr_glMultiTexCoord4dvARB=GLee_L
azy_glMultiTexCoord4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fARB
#define GLEE_C_DEFINED_glMultiTexCoord4fARB
void __stdcall GLee_Lazy_glMultiTexCoord4fARB(GLenum target, GLfloat s, G
Lfloat t, GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4fARB(targ
et, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4FARBPROC GLeeFuncPtr_glMultiTexCoord4fARB=GLee_Laz
y_glMultiTexCoord4fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fvARB
#define GLEE_C_DEFINED_glMultiTexCoord4fvARB
void __stdcall GLee_Lazy_glMultiTexCoord4fvARB(GLenum target, const GLflo
at * v) {if (GLeeInit()) glMultiTexCoord4fvARB(target, v);}
GLEEPFNGLMULTITEXCOORD4FVARBPROC GLeeFuncPtr_glMultiTexCoord4fvARB=GLee_L
azy_glMultiTexCoord4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4iARB
#define GLEE_C_DEFINED_glMultiTexCoord4iARB
void __stdcall GLee_Lazy_glMultiTexCoord4iARB(GLenum target, GLint s, GLi
nt t, GLint r, GLint q) {if (GLeeInit()) glMultiTexCoord4iARB(target, s, t
, r, q);}
GLEEPFNGLMULTITEXCOORD4IARBPROC GLeeFuncPtr_glMultiTexCoord4iARB=GLee_Laz
y_glMultiTexCoord4iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4ivARB
#define GLEE_C_DEFINED_glMultiTexCoord4ivARB
void __stdcall GLee_Lazy_glMultiTexCoord4ivARB(GLenum target, const GLint
* v) {if (GLeeInit()) glMultiTexCoord4ivARB(target, v);}
GLEEPFNGLMULTITEXCOORD4IVARBPROC GLeeFuncPtr_glMultiTexCoord4ivARB=GLee_L
azy_glMultiTexCoord4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4sARB
#define GLEE_C_DEFINED_glMultiTexCoord4sARB
void __stdcall GLee_Lazy_glMultiTexCoord4sARB(GLenum target, GLshort s, G
Lshort t, GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4sARB(targ
et, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4SARBPROC GLeeFuncPtr_glMultiTexCoord4sARB=GLee_Laz
y_glMultiTexCoord4sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4svARB
#define GLEE_C_DEFINED_glMultiTexCoord4svARB
void __stdcall GLee_Lazy_glMultiTexCoord4svARB(GLenum target, const GLsho
rt * v) {if (GLeeInit()) glMultiTexCoord4svARB(target, v);}
GLEEPFNGLMULTITEXCOORD4SVARBPROC GLeeFuncPtr_glMultiTexCoord4svARB=GLee_L
azy_glMultiTexCoord4svARB;
#endif
#endif #endif
/* GL_ARB_transpose_matrix */ /* GL_ARB_transpose_matrix */
#ifdef __GLEE_GL_ARB_transpose_matrix #ifdef __GLEE_GL_ARB_transpose_matrix
void __stdcall _Lazy_glLoadTransposeMatrixfARB(const GLfloat * m) #ifndef GLEE_C_DEFINED_glLoadTransposeMatrixfARB
{if (GLeeInit()) glLoadTransposeMatrixfARB(m);} #define GLEE_C_DEFINED_glLoadTransposeMatrixfARB
void __stdcall _Lazy_glLoadTransposeMatrixdARB(const GLdouble * m) void __stdcall GLee_Lazy_glLoadTransposeMatrixfARB(const GLfloat * m) {i
{if (GLeeInit()) glLoadTransposeMatrixdARB(m);} f (GLeeInit()) glLoadTransposeMatrixfARB(m);}
void __stdcall _Lazy_glMultTransposeMatrixfARB(const GLfloat * m) GLEEPFNGLLOADTRANSPOSEMATRIXFARBPROC GLeeFuncPtr_glLoadTransposeMatrixfAR
{if (GLeeInit()) glMultTransposeMatrixfARB(m);} B=GLee_Lazy_glLoadTransposeMatrixfARB;
void __stdcall _Lazy_glMultTransposeMatrixdARB(const GLdouble * m) #endif
{if (GLeeInit()) glMultTransposeMatrixdARB(m);} #ifndef GLEE_C_DEFINED_glLoadTransposeMatrixdARB
PFNGLLOADTRANSPOSEMATRIXFARBPROC pglLoadTransposeMatrixfARB=_Lazy_glLoadTra #define GLEE_C_DEFINED_glLoadTransposeMatrixdARB
nsposeMatrixfARB; void __stdcall GLee_Lazy_glLoadTransposeMatrixdARB(const GLdouble * m) {
PFNGLLOADTRANSPOSEMATRIXDARBPROC pglLoadTransposeMatrixdARB=_Lazy_glLoadTra if (GLeeInit()) glLoadTransposeMatrixdARB(m);}
nsposeMatrixdARB; GLEEPFNGLLOADTRANSPOSEMATRIXDARBPROC GLeeFuncPtr_glLoadTransposeMatrixdAR
PFNGLMULTTRANSPOSEMATRIXFARBPROC pglMultTransposeMatrixfARB=_Lazy_glMultTra B=GLee_Lazy_glLoadTransposeMatrixdARB;
nsposeMatrixfARB; #endif
PFNGLMULTTRANSPOSEMATRIXDARBPROC pglMultTransposeMatrixdARB=_Lazy_glMultTra #ifndef GLEE_C_DEFINED_glMultTransposeMatrixfARB
nsposeMatrixdARB; #define GLEE_C_DEFINED_glMultTransposeMatrixfARB
void __stdcall GLee_Lazy_glMultTransposeMatrixfARB(const GLfloat * m) {i
f (GLeeInit()) glMultTransposeMatrixfARB(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXFARBPROC GLeeFuncPtr_glMultTransposeMatrixfAR
B=GLee_Lazy_glMultTransposeMatrixfARB;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixdARB
#define GLEE_C_DEFINED_glMultTransposeMatrixdARB
void __stdcall GLee_Lazy_glMultTransposeMatrixdARB(const GLdouble * m) {
if (GLeeInit()) glMultTransposeMatrixdARB(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXDARBPROC GLeeFuncPtr_glMultTransposeMatrixdAR
B=GLee_Lazy_glMultTransposeMatrixdARB;
#endif
#endif #endif
/* GL_ARB_multisample */ /* GL_ARB_multisample */
#ifdef __GLEE_GL_ARB_multisample #ifdef __GLEE_GL_ARB_multisample
void __stdcall _Lazy_glSampleCoverageARB(GLclampf value, GLboolean invert) #ifndef GLEE_C_DEFINED_glSampleCoverageARB
{if (GLeeInit()) glSampleCoverageARB(value, invert);} #define GLEE_C_DEFINED_glSampleCoverageARB
PFNGLSAMPLECOVERAGEARBPROC pglSampleCoverageARB=_Lazy_glSampleCoverageARB; void __stdcall GLee_Lazy_glSampleCoverageARB(GLclampf value, GLboolean in
vert) {if (GLeeInit()) glSampleCoverageARB(value, invert);}
GLEEPFNGLSAMPLECOVERAGEARBPROC GLeeFuncPtr_glSampleCoverageARB=GLee_Lazy_
glSampleCoverageARB;
#endif
#endif #endif
/* GL_ARB_texture_env_add */ /* GL_ARB_texture_env_add */
#ifdef __GLEE_GL_ARB_texture_env_add #ifdef __GLEE_GL_ARB_texture_env_add
#endif #endif
/* GL_ARB_texture_cube_map */ /* GL_ARB_texture_cube_map */
#ifdef __GLEE_GL_ARB_texture_cube_map #ifdef __GLEE_GL_ARB_texture_cube_map
#endif #endif
/* GL_ARB_texture_compression */ /* GL_ARB_texture_compression */
#ifdef __GLEE_GL_ARB_texture_compression #ifdef __GLEE_GL_ARB_texture_compression
void __stdcall _Lazy_glCompressedTexImage3DARB(GLenum target, GLint level, #ifndef GLEE_C_DEFINED_glCompressedTexImage3DARB
GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint #define GLEE_C_DEFINED_glCompressedTexImage3DARB
border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompres void __stdcall GLee_Lazy_glCompressedTexImage3DARB(GLenum target, GLint l
sedTexImage3DARB(target, level, internalformat, width, height, depth, borde evel, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
r, imageSize, data);} GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glC
void __stdcall _Lazy_glCompressedTexImage2DARB(GLenum target, GLint level, ompressedTexImage3DARB(target, level, internalformat, width, height, depth,
GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei border, imageSize, data);}
imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage2DAR GLEEPFNGLCOMPRESSEDTEXIMAGE3DARBPROC GLeeFuncPtr_glCompressedTexImage3DAR
B(target, level, internalformat, width, height, border, imageSize, data);} B=GLee_Lazy_glCompressedTexImage3DARB;
void __stdcall _Lazy_glCompressedTexImage1DARB(GLenum target, GLint level, #endif
GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, cons #ifndef GLEE_C_DEFINED_glCompressedTexImage2DARB
t GLvoid * data) {if (GLeeInit()) glCompressedTexImage1DARB(target, level, #define GLEE_C_DEFINED_glCompressedTexImage2DARB
internalformat, width, border, imageSize, data);} void __stdcall GLee_Lazy_glCompressedTexImage2DARB(GLenum target, GLint l
void __stdcall _Lazy_glCompressedTexSubImage3DARB(GLenum target, GLint leve evel, GLenum internalformat, GLsizei width, GLsizei height, GLint border, G
l, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei heig Lsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexIma
ht, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) ge2DARB(target, level, internalformat, width, height, border, imageSize, da
{if (GLeeInit()) glCompressedTexSubImage3DARB(target, level, xoffset, yoffs ta);}
et, zoffset, width, height, depth, format, imageSize, data);} GLEEPFNGLCOMPRESSEDTEXIMAGE2DARBPROC GLeeFuncPtr_glCompressedTexImage2DAR
void __stdcall _Lazy_glCompressedTexSubImage2DARB(GLenum target, GLint leve B=GLee_Lazy_glCompressedTexImage2DARB;
l, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum form #endif
at, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedT #ifndef GLEE_C_DEFINED_glCompressedTexImage1DARB
exSubImage2DARB(target, level, xoffset, yoffset, width, height, format, ima #define GLEE_C_DEFINED_glCompressedTexImage1DARB
geSize, data);} void __stdcall GLee_Lazy_glCompressedTexImage1DARB(GLenum target, GLint l
void __stdcall _Lazy_glCompressedTexSubImage1DARB(GLenum target, GLint leve evel, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize
l, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GL , const GLvoid * data) {if (GLeeInit()) glCompressedTexImage1DARB(target,
void * data) {if (GLeeInit()) glCompressedTexSubImage1DARB(target, level, level, internalformat, width, border, imageSize, data);}
xoffset, width, format, imageSize, data);} GLEEPFNGLCOMPRESSEDTEXIMAGE1DARBPROC GLeeFuncPtr_glCompressedTexImage1DAR
void __stdcall _Lazy_glGetCompressedTexImageARB(GLenum target, GLint level, B=GLee_Lazy_glCompressedTexImage1DARB;
GLvoid * img) {if (GLeeInit()) glGetCompressedTexImageARB(target, level, #endif
img);} #ifndef GLEE_C_DEFINED_glCompressedTexSubImage3DARB
PFNGLCOMPRESSEDTEXIMAGE3DARBPROC pglCompressedTexImage3DARB=_Lazy_glCompres #define GLEE_C_DEFINED_glCompressedTexSubImage3DARB
sedTexImage3DARB; void __stdcall GLee_Lazy_glCompressedTexSubImage3DARB(GLenum target, GLin
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC pglCompressedTexImage2DARB=_Lazy_glCompres t level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsize
sedTexImage2DARB; i height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * d
PFNGLCOMPRESSEDTEXIMAGE1DARBPROC pglCompressedTexImage1DARB=_Lazy_glCompres ata) {if (GLeeInit()) glCompressedTexSubImage3DARB(target, level, xoffset,
sedTexImage1DARB; yoffset, zoffset, width, height, depth, format, imageSize, data);}
PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC pglCompressedTexSubImage3DARB=_Lazy_glC GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC GLeeFuncPtr_glCompressedTexSubIma
ompressedTexSubImage3DARB; ge3DARB=GLee_Lazy_glCompressedTexSubImage3DARB;
PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC pglCompressedTexSubImage2DARB=_Lazy_glC #endif
ompressedTexSubImage2DARB; #ifndef GLEE_C_DEFINED_glCompressedTexSubImage2DARB
PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC pglCompressedTexSubImage1DARB=_Lazy_glC #define GLEE_C_DEFINED_glCompressedTexSubImage2DARB
ompressedTexSubImage1DARB; void __stdcall GLee_Lazy_glCompressedTexSubImage2DARB(GLenum target, GLin
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC pglGetCompressedTexImageARB=_Lazy_glGetCo t level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenu
mpressedTexImageARB; m format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompr
essedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, forma
t, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC GLeeFuncPtr_glCompressedTexSubIma
ge2DARB=GLee_Lazy_glCompressedTexSubImage2DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage1DARB
void __stdcall GLee_Lazy_glCompressedTexSubImage1DARB(GLenum target, GLin
t level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, co
nst GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage1DARB(target, l
evel, xoffset, width, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC GLeeFuncPtr_glCompressedTexSubIma
ge1DARB=GLee_Lazy_glCompressedTexSubImage1DARB;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTexImageARB
#define GLEE_C_DEFINED_glGetCompressedTexImageARB
void __stdcall GLee_Lazy_glGetCompressedTexImageARB(GLenum target, GLint
level, GLvoid * img) {if (GLeeInit()) glGetCompressedTexImageARB(target, l
evel, img);}
GLEEPFNGLGETCOMPRESSEDTEXIMAGEARBPROC GLeeFuncPtr_glGetCompressedTexImage
ARB=GLee_Lazy_glGetCompressedTexImageARB;
#endif
#endif #endif
/* GL_ARB_texture_border_clamp */ /* GL_ARB_texture_border_clamp */
#ifdef __GLEE_GL_ARB_texture_border_clamp #ifdef __GLEE_GL_ARB_texture_border_clamp
#endif #endif
/* GL_ARB_point_parameters */ /* GL_ARB_point_parameters */
#ifdef __GLEE_GL_ARB_point_parameters #ifdef __GLEE_GL_ARB_point_parameters
void __stdcall _Lazy_glPointParameterfARB(GLenum pname, GLfloat param) #ifndef GLEE_C_DEFINED_glPointParameterfARB
{if (GLeeInit()) glPointParameterfARB(pname, param);} #define GLEE_C_DEFINED_glPointParameterfARB
void __stdcall _Lazy_glPointParameterfvARB(GLenum pname, const GLfloat * pa void __stdcall GLee_Lazy_glPointParameterfARB(GLenum pname, GLfloat param
rams) {if (GLeeInit()) glPointParameterfvARB(pname, params);} ) {if (GLeeInit()) glPointParameterfARB(pname, param);}
PFNGLPOINTPARAMETERFARBPROC pglPointParameterfARB=_Lazy_glPointParameterfAR GLEEPFNGLPOINTPARAMETERFARBPROC GLeeFuncPtr_glPointParameterfARB=GLee_Laz
B; y_glPointParameterfARB;
PFNGLPOINTPARAMETERFVARBPROC pglPointParameterfvARB=_Lazy_glPointParameterf #endif
vARB; #ifndef GLEE_C_DEFINED_glPointParameterfvARB
#define GLEE_C_DEFINED_glPointParameterfvARB
void __stdcall GLee_Lazy_glPointParameterfvARB(GLenum pname, const GLfloa
t * params) {if (GLeeInit()) glPointParameterfvARB(pname, params);}
GLEEPFNGLPOINTPARAMETERFVARBPROC GLeeFuncPtr_glPointParameterfvARB=GLee_L
azy_glPointParameterfvARB;
#endif
#endif #endif
/* GL_ARB_vertex_blend */ /* GL_ARB_vertex_blend */
#ifdef __GLEE_GL_ARB_vertex_blend #ifdef __GLEE_GL_ARB_vertex_blend
void __stdcall _Lazy_glWeightbvARB(GLint size, const GLbyte * weights) #ifndef GLEE_C_DEFINED_glWeightbvARB
{if (GLeeInit()) glWeightbvARB(size, weights);} #define GLEE_C_DEFINED_glWeightbvARB
void __stdcall _Lazy_glWeightsvARB(GLint size, const GLshort * weights) void __stdcall GLee_Lazy_glWeightbvARB(GLint size, const GLbyte * weights
{if (GLeeInit()) glWeightsvARB(size, weights);} ) {if (GLeeInit()) glWeightbvARB(size, weights);}
void __stdcall _Lazy_glWeightivARB(GLint size, const GLint * weights) GLEEPFNGLWEIGHTBVARBPROC GLeeFuncPtr_glWeightbvARB=GLee_Lazy_glWeightbvAR
{if (GLeeInit()) glWeightivARB(size, weights);} B;
void __stdcall _Lazy_glWeightfvARB(GLint size, const GLfloat * weights) #endif
{if (GLeeInit()) glWeightfvARB(size, weights);} #ifndef GLEE_C_DEFINED_glWeightsvARB
void __stdcall _Lazy_glWeightdvARB(GLint size, const GLdouble * weights) #define GLEE_C_DEFINED_glWeightsvARB
{if (GLeeInit()) glWeightdvARB(size, weights);} void __stdcall GLee_Lazy_glWeightsvARB(GLint size, const GLshort * weight
void __stdcall _Lazy_glWeightubvARB(GLint size, const GLubyte * weights) s) {if (GLeeInit()) glWeightsvARB(size, weights);}
{if (GLeeInit()) glWeightubvARB(size, weights);} GLEEPFNGLWEIGHTSVARBPROC GLeeFuncPtr_glWeightsvARB=GLee_Lazy_glWeightsvAR
void __stdcall _Lazy_glWeightusvARB(GLint size, const GLushort * weights) B;
{if (GLeeInit()) glWeightusvARB(size, weights);} #endif
void __stdcall _Lazy_glWeightuivARB(GLint size, const GLuint * weights) #ifndef GLEE_C_DEFINED_glWeightivARB
{if (GLeeInit()) glWeightuivARB(size, weights);} #define GLEE_C_DEFINED_glWeightivARB
void __stdcall _Lazy_glWeightPointerARB(GLint size, GLenum type, GLsizei st void __stdcall GLee_Lazy_glWeightivARB(GLint size, const GLint * weights)
ride, const GLvoid * pointer) {if (GLeeInit()) glWeightPointerARB(size, ty {if (GLeeInit()) glWeightivARB(size, weights);}
pe, stride, pointer);} GLEEPFNGLWEIGHTIVARBPROC GLeeFuncPtr_glWeightivARB=GLee_Lazy_glWeightivAR
void __stdcall _Lazy_glVertexBlendARB(GLint count) B;
{if (GLeeInit()) glVertexBlendARB(count);} #endif
PFNGLWEIGHTBVARBPROC pglWeightbvARB=_Lazy_glWeightbvARB; #ifndef GLEE_C_DEFINED_glWeightfvARB
PFNGLWEIGHTSVARBPROC pglWeightsvARB=_Lazy_glWeightsvARB; #define GLEE_C_DEFINED_glWeightfvARB
PFNGLWEIGHTIVARBPROC pglWeightivARB=_Lazy_glWeightivARB; void __stdcall GLee_Lazy_glWeightfvARB(GLint size, const GLfloat * weight
PFNGLWEIGHTFVARBPROC pglWeightfvARB=_Lazy_glWeightfvARB; s) {if (GLeeInit()) glWeightfvARB(size, weights);}
PFNGLWEIGHTDVARBPROC pglWeightdvARB=_Lazy_glWeightdvARB; GLEEPFNGLWEIGHTFVARBPROC GLeeFuncPtr_glWeightfvARB=GLee_Lazy_glWeightfvAR
PFNGLWEIGHTUBVARBPROC pglWeightubvARB=_Lazy_glWeightubvARB; B;
PFNGLWEIGHTUSVARBPROC pglWeightusvARB=_Lazy_glWeightusvARB; #endif
PFNGLWEIGHTUIVARBPROC pglWeightuivARB=_Lazy_glWeightuivARB; #ifndef GLEE_C_DEFINED_glWeightdvARB
PFNGLWEIGHTPOINTERARBPROC pglWeightPointerARB=_Lazy_glWeightPointerARB; #define GLEE_C_DEFINED_glWeightdvARB
PFNGLVERTEXBLENDARBPROC pglVertexBlendARB=_Lazy_glVertexBlendARB; void __stdcall GLee_Lazy_glWeightdvARB(GLint size, const GLdouble * weigh
ts) {if (GLeeInit()) glWeightdvARB(size, weights);}
GLEEPFNGLWEIGHTDVARBPROC GLeeFuncPtr_glWeightdvARB=GLee_Lazy_glWeightdvAR
B;
#endif
#ifndef GLEE_C_DEFINED_glWeightubvARB
#define GLEE_C_DEFINED_glWeightubvARB
void __stdcall GLee_Lazy_glWeightubvARB(GLint size, const GLubyte * weigh
ts) {if (GLeeInit()) glWeightubvARB(size, weights);}
GLEEPFNGLWEIGHTUBVARBPROC GLeeFuncPtr_glWeightubvARB=GLee_Lazy_glWeightub
vARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightusvARB
#define GLEE_C_DEFINED_glWeightusvARB
void __stdcall GLee_Lazy_glWeightusvARB(GLint size, const GLushort * weig
hts) {if (GLeeInit()) glWeightusvARB(size, weights);}
GLEEPFNGLWEIGHTUSVARBPROC GLeeFuncPtr_glWeightusvARB=GLee_Lazy_glWeightus
vARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightuivARB
#define GLEE_C_DEFINED_glWeightuivARB
void __stdcall GLee_Lazy_glWeightuivARB(GLint size, const GLuint * weight
s) {if (GLeeInit()) glWeightuivARB(size, weights);}
GLEEPFNGLWEIGHTUIVARBPROC GLeeFuncPtr_glWeightuivARB=GLee_Lazy_glWeightui
vARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightPointerARB
#define GLEE_C_DEFINED_glWeightPointerARB
void __stdcall GLee_Lazy_glWeightPointerARB(GLint size, GLenum type, GLsi
zei stride, const GLvoid * pointer) {if (GLeeInit()) glWeightPointerARB(si
ze, type, stride, pointer);}
GLEEPFNGLWEIGHTPOINTERARBPROC GLeeFuncPtr_glWeightPointerARB=GLee_Lazy_gl
WeightPointerARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexBlendARB
#define GLEE_C_DEFINED_glVertexBlendARB
void __stdcall GLee_Lazy_glVertexBlendARB(GLint count) {if (GLeeInit())
glVertexBlendARB(count);}
GLEEPFNGLVERTEXBLENDARBPROC GLeeFuncPtr_glVertexBlendARB=GLee_Lazy_glVert
exBlendARB;
#endif
#endif #endif
/* GL_ARB_matrix_palette */ /* GL_ARB_matrix_palette */
#ifdef __GLEE_GL_ARB_matrix_palette #ifdef __GLEE_GL_ARB_matrix_palette
void __stdcall _Lazy_glCurrentPaletteMatrixARB(GLint index) #ifndef GLEE_C_DEFINED_glCurrentPaletteMatrixARB
{if (GLeeInit()) glCurrentPaletteMatrixARB(index);} #define GLEE_C_DEFINED_glCurrentPaletteMatrixARB
void __stdcall _Lazy_glMatrixIndexubvARB(GLint size, const GLubyte * indice void __stdcall GLee_Lazy_glCurrentPaletteMatrixARB(GLint index) {if (GLe
s) {if (GLeeInit()) glMatrixIndexubvARB(size, indices);} eInit()) glCurrentPaletteMatrixARB(index);}
void __stdcall _Lazy_glMatrixIndexusvARB(GLint size, const GLushort * indic GLEEPFNGLCURRENTPALETTEMATRIXARBPROC GLeeFuncPtr_glCurrentPaletteMatrixAR
es) {if (GLeeInit()) glMatrixIndexusvARB(size, indices);} B=GLee_Lazy_glCurrentPaletteMatrixARB;
void __stdcall _Lazy_glMatrixIndexuivARB(GLint size, const GLuint * indices #endif
) {if (GLeeInit()) glMatrixIndexuivARB(size, indices);} #ifndef GLEE_C_DEFINED_glMatrixIndexubvARB
void __stdcall _Lazy_glMatrixIndexPointerARB(GLint size, GLenum type, GLsiz #define GLEE_C_DEFINED_glMatrixIndexubvARB
ei stride, const GLvoid * pointer) {if (GLeeInit()) glMatrixIndexPointerAR void __stdcall GLee_Lazy_glMatrixIndexubvARB(GLint size, const GLubyte *
B(size, type, stride, pointer);} indices) {if (GLeeInit()) glMatrixIndexubvARB(size, indices);}
PFNGLCURRENTPALETTEMATRIXARBPROC pglCurrentPaletteMatrixARB=_Lazy_glCurrent GLEEPFNGLMATRIXINDEXUBVARBPROC GLeeFuncPtr_glMatrixIndexubvARB=GLee_Lazy_
PaletteMatrixARB; glMatrixIndexubvARB;
PFNGLMATRIXINDEXUBVARBPROC pglMatrixIndexubvARB=_Lazy_glMatrixIndexubvARB; #endif
PFNGLMATRIXINDEXUSVARBPROC pglMatrixIndexusvARB=_Lazy_glMatrixIndexusvARB; #ifndef GLEE_C_DEFINED_glMatrixIndexusvARB
PFNGLMATRIXINDEXUIVARBPROC pglMatrixIndexuivARB=_Lazy_glMatrixIndexuivARB; #define GLEE_C_DEFINED_glMatrixIndexusvARB
PFNGLMATRIXINDEXPOINTERARBPROC pglMatrixIndexPointerARB=_Lazy_glMatrixIndex void __stdcall GLee_Lazy_glMatrixIndexusvARB(GLint size, const GLushort *
PointerARB; indices) {if (GLeeInit()) glMatrixIndexusvARB(size, indices);}
GLEEPFNGLMATRIXINDEXUSVARBPROC GLeeFuncPtr_glMatrixIndexusvARB=GLee_Lazy_
glMatrixIndexusvARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexuivARB
#define GLEE_C_DEFINED_glMatrixIndexuivARB
void __stdcall GLee_Lazy_glMatrixIndexuivARB(GLint size, const GLuint * i
ndices) {if (GLeeInit()) glMatrixIndexuivARB(size, indices);}
GLEEPFNGLMATRIXINDEXUIVARBPROC GLeeFuncPtr_glMatrixIndexuivARB=GLee_Lazy_
glMatrixIndexuivARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexPointerARB
#define GLEE_C_DEFINED_glMatrixIndexPointerARB
void __stdcall GLee_Lazy_glMatrixIndexPointerARB(GLint size, GLenum type,
GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glMatrixIndexPoi
nterARB(size, type, stride, pointer);}
GLEEPFNGLMATRIXINDEXPOINTERARBPROC GLeeFuncPtr_glMatrixIndexPointerARB=GL
ee_Lazy_glMatrixIndexPointerARB;
#endif
#endif #endif
/* GL_ARB_texture_env_combine */ /* GL_ARB_texture_env_combine */
#ifdef __GLEE_GL_ARB_texture_env_combine #ifdef __GLEE_GL_ARB_texture_env_combine
#endif #endif
/* GL_ARB_texture_env_crossbar */ /* GL_ARB_texture_env_crossbar */
#ifdef __GLEE_GL_ARB_texture_env_crossbar #ifdef __GLEE_GL_ARB_texture_env_crossbar
skipping to change at line 1601 skipping to change at line 2705
#endif #endif
/* GL_ARB_shadow_ambient */ /* GL_ARB_shadow_ambient */
#ifdef __GLEE_GL_ARB_shadow_ambient #ifdef __GLEE_GL_ARB_shadow_ambient
#endif #endif
/* GL_ARB_window_pos */ /* GL_ARB_window_pos */
#ifdef __GLEE_GL_ARB_window_pos #ifdef __GLEE_GL_ARB_window_pos
void __stdcall _Lazy_glWindowPos2dARB(GLdouble x, GLdouble y) #ifndef GLEE_C_DEFINED_glWindowPos2dARB
{if (GLeeInit()) glWindowPos2dARB(x, y);} #define GLEE_C_DEFINED_glWindowPos2dARB
void __stdcall _Lazy_glWindowPos2dvARB(const GLdouble * v) void __stdcall GLee_Lazy_glWindowPos2dARB(GLdouble x, GLdouble y) {if (G
{if (GLeeInit()) glWindowPos2dvARB(v);} LeeInit()) glWindowPos2dARB(x, y);}
void __stdcall _Lazy_glWindowPos2fARB(GLfloat x, GLfloat y) GLEEPFNGLWINDOWPOS2DARBPROC GLeeFuncPtr_glWindowPos2dARB=GLee_Lazy_glWind
{if (GLeeInit()) glWindowPos2fARB(x, y);} owPos2dARB;
void __stdcall _Lazy_glWindowPos2fvARB(const GLfloat * v) #endif
{if (GLeeInit()) glWindowPos2fvARB(v);} #ifndef GLEE_C_DEFINED_glWindowPos2dvARB
void __stdcall _Lazy_glWindowPos2iARB(GLint x, GLint y) #define GLEE_C_DEFINED_glWindowPos2dvARB
{if (GLeeInit()) glWindowPos2iARB(x, y);} void __stdcall GLee_Lazy_glWindowPos2dvARB(const GLdouble * v) {if (GLee
void __stdcall _Lazy_glWindowPos2ivARB(const GLint * v) Init()) glWindowPos2dvARB(v);}
{if (GLeeInit()) glWindowPos2ivARB(v);} GLEEPFNGLWINDOWPOS2DVARBPROC GLeeFuncPtr_glWindowPos2dvARB=GLee_Lazy_glWi
void __stdcall _Lazy_glWindowPos2sARB(GLshort x, GLshort y) ndowPos2dvARB;
{if (GLeeInit()) glWindowPos2sARB(x, y);} #endif
void __stdcall _Lazy_glWindowPos2svARB(const GLshort * v) #ifndef GLEE_C_DEFINED_glWindowPos2fARB
{if (GLeeInit()) glWindowPos2svARB(v);} #define GLEE_C_DEFINED_glWindowPos2fARB
void __stdcall _Lazy_glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z) void __stdcall GLee_Lazy_glWindowPos2fARB(GLfloat x, GLfloat y) {if (GLe
{if (GLeeInit()) glWindowPos3dARB(x, y, z);} eInit()) glWindowPos2fARB(x, y);}
void __stdcall _Lazy_glWindowPos3dvARB(const GLdouble * v) GLEEPFNGLWINDOWPOS2FARBPROC GLeeFuncPtr_glWindowPos2fARB=GLee_Lazy_glWind
{if (GLeeInit()) glWindowPos3dvARB(v);} owPos2fARB;
void __stdcall _Lazy_glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z) #endif
{if (GLeeInit()) glWindowPos3fARB(x, y, z);} #ifndef GLEE_C_DEFINED_glWindowPos2fvARB
void __stdcall _Lazy_glWindowPos3fvARB(const GLfloat * v) #define GLEE_C_DEFINED_glWindowPos2fvARB
{if (GLeeInit()) glWindowPos3fvARB(v);} void __stdcall GLee_Lazy_glWindowPos2fvARB(const GLfloat * v) {if (GLeeI
void __stdcall _Lazy_glWindowPos3iARB(GLint x, GLint y, GLint z) nit()) glWindowPos2fvARB(v);}
{if (GLeeInit()) glWindowPos3iARB(x, y, z);} GLEEPFNGLWINDOWPOS2FVARBPROC GLeeFuncPtr_glWindowPos2fvARB=GLee_Lazy_glWi
void __stdcall _Lazy_glWindowPos3ivARB(const GLint * v) ndowPos2fvARB;
{if (GLeeInit()) glWindowPos3ivARB(v);} #endif
void __stdcall _Lazy_glWindowPos3sARB(GLshort x, GLshort y, GLshort z) #ifndef GLEE_C_DEFINED_glWindowPos2iARB
{if (GLeeInit()) glWindowPos3sARB(x, y, z);} #define GLEE_C_DEFINED_glWindowPos2iARB
void __stdcall _Lazy_glWindowPos3svARB(const GLshort * v) void __stdcall GLee_Lazy_glWindowPos2iARB(GLint x, GLint y) {if (GLeeIni
{if (GLeeInit()) glWindowPos3svARB(v);} t()) glWindowPos2iARB(x, y);}
PFNGLWINDOWPOS2DARBPROC pglWindowPos2dARB=_Lazy_glWindowPos2dARB; GLEEPFNGLWINDOWPOS2IARBPROC GLeeFuncPtr_glWindowPos2iARB=GLee_Lazy_glWind
PFNGLWINDOWPOS2DVARBPROC pglWindowPos2dvARB=_Lazy_glWindowPos2dvARB; owPos2iARB;
PFNGLWINDOWPOS2FARBPROC pglWindowPos2fARB=_Lazy_glWindowPos2fARB; #endif
PFNGLWINDOWPOS2FVARBPROC pglWindowPos2fvARB=_Lazy_glWindowPos2fvARB; #ifndef GLEE_C_DEFINED_glWindowPos2ivARB
PFNGLWINDOWPOS2IARBPROC pglWindowPos2iARB=_Lazy_glWindowPos2iARB; #define GLEE_C_DEFINED_glWindowPos2ivARB
PFNGLWINDOWPOS2IVARBPROC pglWindowPos2ivARB=_Lazy_glWindowPos2ivARB; void __stdcall GLee_Lazy_glWindowPos2ivARB(const GLint * v) {if (GLeeIni
PFNGLWINDOWPOS2SARBPROC pglWindowPos2sARB=_Lazy_glWindowPos2sARB; t()) glWindowPos2ivARB(v);}
PFNGLWINDOWPOS2SVARBPROC pglWindowPos2svARB=_Lazy_glWindowPos2svARB; GLEEPFNGLWINDOWPOS2IVARBPROC GLeeFuncPtr_glWindowPos2ivARB=GLee_Lazy_glWi
PFNGLWINDOWPOS3DARBPROC pglWindowPos3dARB=_Lazy_glWindowPos3dARB; ndowPos2ivARB;
PFNGLWINDOWPOS3DVARBPROC pglWindowPos3dvARB=_Lazy_glWindowPos3dvARB; #endif
PFNGLWINDOWPOS3FARBPROC pglWindowPos3fARB=_Lazy_glWindowPos3fARB; #ifndef GLEE_C_DEFINED_glWindowPos2sARB
PFNGLWINDOWPOS3FVARBPROC pglWindowPos3fvARB=_Lazy_glWindowPos3fvARB; #define GLEE_C_DEFINED_glWindowPos2sARB
PFNGLWINDOWPOS3IARBPROC pglWindowPos3iARB=_Lazy_glWindowPos3iARB; void __stdcall GLee_Lazy_glWindowPos2sARB(GLshort x, GLshort y) {if (GLe
PFNGLWINDOWPOS3IVARBPROC pglWindowPos3ivARB=_Lazy_glWindowPos3ivARB; eInit()) glWindowPos2sARB(x, y);}
PFNGLWINDOWPOS3SARBPROC pglWindowPos3sARB=_Lazy_glWindowPos3sARB; GLEEPFNGLWINDOWPOS2SARBPROC GLeeFuncPtr_glWindowPos2sARB=GLee_Lazy_glWind
PFNGLWINDOWPOS3SVARBPROC pglWindowPos3svARB=_Lazy_glWindowPos3svARB; owPos2sARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2svARB
#define GLEE_C_DEFINED_glWindowPos2svARB
void __stdcall GLee_Lazy_glWindowPos2svARB(const GLshort * v) {if (GLeeI
nit()) glWindowPos2svARB(v);}
GLEEPFNGLWINDOWPOS2SVARBPROC GLeeFuncPtr_glWindowPos2svARB=GLee_Lazy_glWi
ndowPos2svARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dARB
#define GLEE_C_DEFINED_glWindowPos3dARB
void __stdcall GLee_Lazy_glWindowPos3dARB(GLdouble x, GLdouble y, GLdoubl
e z) {if (GLeeInit()) glWindowPos3dARB(x, y, z);}
GLEEPFNGLWINDOWPOS3DARBPROC GLeeFuncPtr_glWindowPos3dARB=GLee_Lazy_glWind
owPos3dARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dvARB
#define GLEE_C_DEFINED_glWindowPos3dvARB
void __stdcall GLee_Lazy_glWindowPos3dvARB(const GLdouble * v) {if (GLee
Init()) glWindowPos3dvARB(v);}
GLEEPFNGLWINDOWPOS3DVARBPROC GLeeFuncPtr_glWindowPos3dvARB=GLee_Lazy_glWi
ndowPos3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fARB
#define GLEE_C_DEFINED_glWindowPos3fARB
void __stdcall GLee_Lazy_glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z
) {if (GLeeInit()) glWindowPos3fARB(x, y, z);}
GLEEPFNGLWINDOWPOS3FARBPROC GLeeFuncPtr_glWindowPos3fARB=GLee_Lazy_glWind
owPos3fARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fvARB
#define GLEE_C_DEFINED_glWindowPos3fvARB
void __stdcall GLee_Lazy_glWindowPos3fvARB(const GLfloat * v) {if (GLeeI
nit()) glWindowPos3fvARB(v);}
GLEEPFNGLWINDOWPOS3FVARBPROC GLeeFuncPtr_glWindowPos3fvARB=GLee_Lazy_glWi
ndowPos3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iARB
#define GLEE_C_DEFINED_glWindowPos3iARB
void __stdcall GLee_Lazy_glWindowPos3iARB(GLint x, GLint y, GLint z) {if
(GLeeInit()) glWindowPos3iARB(x, y, z);}
GLEEPFNGLWINDOWPOS3IARBPROC GLeeFuncPtr_glWindowPos3iARB=GLee_Lazy_glWind
owPos3iARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3ivARB
#define GLEE_C_DEFINED_glWindowPos3ivARB
void __stdcall GLee_Lazy_glWindowPos3ivARB(const GLint * v) {if (GLeeIni
t()) glWindowPos3ivARB(v);}
GLEEPFNGLWINDOWPOS3IVARBPROC GLeeFuncPtr_glWindowPos3ivARB=GLee_Lazy_glWi
ndowPos3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sARB
#define GLEE_C_DEFINED_glWindowPos3sARB
void __stdcall GLee_Lazy_glWindowPos3sARB(GLshort x, GLshort y, GLshort z
) {if (GLeeInit()) glWindowPos3sARB(x, y, z);}
GLEEPFNGLWINDOWPOS3SARBPROC GLeeFuncPtr_glWindowPos3sARB=GLee_Lazy_glWind
owPos3sARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3svARB
#define GLEE_C_DEFINED_glWindowPos3svARB
void __stdcall GLee_Lazy_glWindowPos3svARB(const GLshort * v) {if (GLeeI
nit()) glWindowPos3svARB(v);}
GLEEPFNGLWINDOWPOS3SVARBPROC GLeeFuncPtr_glWindowPos3svARB=GLee_Lazy_glWi
ndowPos3svARB;
#endif
#endif #endif
/* GL_ARB_vertex_program */ /* GL_ARB_vertex_program */
#ifdef __GLEE_GL_ARB_vertex_program #ifdef __GLEE_GL_ARB_vertex_program
void __stdcall _Lazy_glVertexAttrib1dARB(GLuint index, GLdouble x) #ifndef GLEE_C_DEFINED_glVertexAttrib1dARB
{if (GLeeInit()) glVertexAttrib1dARB(index, x);} #define GLEE_C_DEFINED_glVertexAttrib1dARB
void __stdcall _Lazy_glVertexAttrib1dvARB(GLuint index, const GLdouble * v) void __stdcall GLee_Lazy_glVertexAttrib1dARB(GLuint index, GLdouble x) {
{if (GLeeInit()) glVertexAttrib1dvARB(index, v);} if (GLeeInit()) glVertexAttrib1dARB(index, x);}
void __stdcall _Lazy_glVertexAttrib1fARB(GLuint index, GLfloat x) GLEEPFNGLVERTEXATTRIB1DARBPROC GLeeFuncPtr_glVertexAttrib1dARB=GLee_Lazy_
{if (GLeeInit()) glVertexAttrib1fARB(index, x);} glVertexAttrib1dARB;
void __stdcall _Lazy_glVertexAttrib1fvARB(GLuint index, const GLfloat * v) #endif
{if (GLeeInit()) glVertexAttrib1fvARB(index, v);} #ifndef GLEE_C_DEFINED_glVertexAttrib1dvARB
void __stdcall _Lazy_glVertexAttrib1sARB(GLuint index, GLshort x) #define GLEE_C_DEFINED_glVertexAttrib1dvARB
{if (GLeeInit()) glVertexAttrib1sARB(index, x);} void __stdcall GLee_Lazy_glVertexAttrib1dvARB(GLuint index, const GLdoubl
void __stdcall _Lazy_glVertexAttrib1svARB(GLuint index, const GLshort * v) e * v) {if (GLeeInit()) glVertexAttrib1dvARB(index, v);}
{if (GLeeInit()) glVertexAttrib1svARB(index, v);} GLEEPFNGLVERTEXATTRIB1DVARBPROC GLeeFuncPtr_glVertexAttrib1dvARB=GLee_Laz
void __stdcall _Lazy_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y_glVertexAttrib1dvARB;
y) {if (GLeeInit()) glVertexAttrib2dARB(index, x, y);} #endif
void __stdcall _Lazy_glVertexAttrib2dvARB(GLuint index, const GLdouble * v) #ifndef GLEE_C_DEFINED_glVertexAttrib1fARB
{if (GLeeInit()) glVertexAttrib2dvARB(index, v);} #define GLEE_C_DEFINED_glVertexAttrib1fARB
void __stdcall _Lazy_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y void __stdcall GLee_Lazy_glVertexAttrib1fARB(GLuint index, GLfloat x) {i
) {if (GLeeInit()) glVertexAttrib2fARB(index, x, y);} f (GLeeInit()) glVertexAttrib1fARB(index, x);}
void __stdcall _Lazy_glVertexAttrib2fvARB(GLuint index, const GLfloat * v) GLEEPFNGLVERTEXATTRIB1FARBPROC GLeeFuncPtr_glVertexAttrib1fARB=GLee_Lazy_
{if (GLeeInit()) glVertexAttrib2fvARB(index, v);} glVertexAttrib1fARB;
void __stdcall _Lazy_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y #endif
) {if (GLeeInit()) glVertexAttrib2sARB(index, x, y);} #ifndef GLEE_C_DEFINED_glVertexAttrib1fvARB
void __stdcall _Lazy_glVertexAttrib2svARB(GLuint index, const GLshort * v) #define GLEE_C_DEFINED_glVertexAttrib1fvARB
{if (GLeeInit()) glVertexAttrib2svARB(index, v);} void __stdcall GLee_Lazy_glVertexAttrib1fvARB(GLuint index, const GLfloat
void __stdcall _Lazy_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble * v) {if (GLeeInit()) glVertexAttrib1fvARB(index, v);}
y, GLdouble z) {if (GLeeInit()) glVertexAttrib3dARB(index, x, y, z);} GLEEPFNGLVERTEXATTRIB1FVARBPROC GLeeFuncPtr_glVertexAttrib1fvARB=GLee_Laz
void __stdcall _Lazy_glVertexAttrib3dvARB(GLuint index, const GLdouble * v) y_glVertexAttrib1fvARB;
{if (GLeeInit()) glVertexAttrib3dvARB(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y #ifndef GLEE_C_DEFINED_glVertexAttrib1sARB
, GLfloat z) {if (GLeeInit()) glVertexAttrib3fARB(index, x, y, z);} #define GLEE_C_DEFINED_glVertexAttrib1sARB
void __stdcall _Lazy_glVertexAttrib3fvARB(GLuint index, const GLfloat * v) void __stdcall GLee_Lazy_glVertexAttrib1sARB(GLuint index, GLshort x) {i
{if (GLeeInit()) glVertexAttrib3fvARB(index, v);} f (GLeeInit()) glVertexAttrib1sARB(index, x);}
void __stdcall _Lazy_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y GLEEPFNGLVERTEXATTRIB1SARBPROC GLeeFuncPtr_glVertexAttrib1sARB=GLee_Lazy_
, GLshort z) {if (GLeeInit()) glVertexAttrib3sARB(index, x, y, z);} glVertexAttrib1sARB;
void __stdcall _Lazy_glVertexAttrib3svARB(GLuint index, const GLshort * v) #endif
{if (GLeeInit()) glVertexAttrib3svARB(index, v);} #ifndef GLEE_C_DEFINED_glVertexAttrib1svARB
void __stdcall _Lazy_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v) #define GLEE_C_DEFINED_glVertexAttrib1svARB
{if (GLeeInit()) glVertexAttrib4NbvARB(index, v);} void __stdcall GLee_Lazy_glVertexAttrib1svARB(GLuint index, const GLshort
void __stdcall _Lazy_glVertexAttrib4NivARB(GLuint index, const GLint * v) * v) {if (GLeeInit()) glVertexAttrib1svARB(index, v);}
{if (GLeeInit()) glVertexAttrib4NivARB(index, v);} GLEEPFNGLVERTEXATTRIB1SVARBPROC GLeeFuncPtr_glVertexAttrib1svARB=GLee_Laz
void __stdcall _Lazy_glVertexAttrib4NsvARB(GLuint index, const GLshort * v) y_glVertexAttrib1svARB;
{if (GLeeInit()) glVertexAttrib4NsvARB(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte #ifndef GLEE_C_DEFINED_glVertexAttrib2dARB
y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4NubARB(index, x, #define GLEE_C_DEFINED_glVertexAttrib2dARB
y, z, w);} void __stdcall GLee_Lazy_glVertexAttrib2dARB(GLuint index, GLdouble x, GL
void __stdcall _Lazy_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v double y) {if (GLeeInit()) glVertexAttrib2dARB(index, x, y);}
) {if (GLeeInit()) glVertexAttrib4NubvARB(index, v);} GLEEPFNGLVERTEXATTRIB2DARBPROC GLeeFuncPtr_glVertexAttrib2dARB=GLee_Lazy_
void __stdcall _Lazy_glVertexAttrib4NuivARB(GLuint index, const GLuint * v) glVertexAttrib2dARB;
{if (GLeeInit()) glVertexAttrib4NuivARB(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib4NusvARB(GLuint index, const GLushort * #ifndef GLEE_C_DEFINED_glVertexAttrib2dvARB
v) {if (GLeeInit()) glVertexAttrib4NusvARB(index, v);} #define GLEE_C_DEFINED_glVertexAttrib2dvARB
void __stdcall _Lazy_glVertexAttrib4bvARB(GLuint index, const GLbyte * v) void __stdcall GLee_Lazy_glVertexAttrib2dvARB(GLuint index, const GLdoubl
{if (GLeeInit()) glVertexAttrib4bvARB(index, v);} e * v) {if (GLeeInit()) glVertexAttrib2dvARB(index, v);}
void __stdcall _Lazy_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble GLEEPFNGLVERTEXATTRIB2DVARBPROC GLeeFuncPtr_glVertexAttrib2dvARB=GLee_Laz
y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4dARB(index, x, y_glVertexAttrib2dvARB;
y, z, w);} #endif
void __stdcall _Lazy_glVertexAttrib4dvARB(GLuint index, const GLdouble * v) #ifndef GLEE_C_DEFINED_glVertexAttrib2fARB
{if (GLeeInit()) glVertexAttrib4dvARB(index, v);} #define GLEE_C_DEFINED_glVertexAttrib2fARB
void __stdcall _Lazy_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y void __stdcall GLee_Lazy_glVertexAttrib2fARB(GLuint index, GLfloat x, GLf
, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4fARB(index, x, y, loat y) {if (GLeeInit()) glVertexAttrib2fARB(index, x, y);}
z, w);} GLEEPFNGLVERTEXATTRIB2FARBPROC GLeeFuncPtr_glVertexAttrib2fARB=GLee_Lazy_
void __stdcall _Lazy_glVertexAttrib4fvARB(GLuint index, const GLfloat * v) glVertexAttrib2fARB;
{if (GLeeInit()) glVertexAttrib4fvARB(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib4ivARB(GLuint index, const GLint * v) #ifndef GLEE_C_DEFINED_glVertexAttrib2fvARB
{if (GLeeInit()) glVertexAttrib4ivARB(index, v);} #define GLEE_C_DEFINED_glVertexAttrib2fvARB
void __stdcall _Lazy_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y void __stdcall GLee_Lazy_glVertexAttrib2fvARB(GLuint index, const GLfloat
, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4sARB(index, x, y, * v) {if (GLeeInit()) glVertexAttrib2fvARB(index, v);}
z, w);} GLEEPFNGLVERTEXATTRIB2FVARBPROC GLeeFuncPtr_glVertexAttrib2fvARB=GLee_Laz
void __stdcall _Lazy_glVertexAttrib4svARB(GLuint index, const GLshort * v) y_glVertexAttrib2fvARB;
{if (GLeeInit()) glVertexAttrib4svARB(index, v);} #endif
void __stdcall _Lazy_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v) #ifndef GLEE_C_DEFINED_glVertexAttrib2sARB
{if (GLeeInit()) glVertexAttrib4ubvARB(index, v);} #define GLEE_C_DEFINED_glVertexAttrib2sARB
void __stdcall _Lazy_glVertexAttrib4uivARB(GLuint index, const GLuint * v) void __stdcall GLee_Lazy_glVertexAttrib2sARB(GLuint index, GLshort x, GLs
{if (GLeeInit()) glVertexAttrib4uivARB(index, v);} hort y) {if (GLeeInit()) glVertexAttrib2sARB(index, x, y);}
void __stdcall _Lazy_glVertexAttrib4usvARB(GLuint index, const GLushort * v GLEEPFNGLVERTEXATTRIB2SARBPROC GLeeFuncPtr_glVertexAttrib2sARB=GLee_Lazy_
) {if (GLeeInit()) glVertexAttrib4usvARB(index, v);} glVertexAttrib2sARB;
void __stdcall _Lazy_glVertexAttribPointerARB(GLuint index, GLint size, GLe #endif
num type, GLboolean normalized, GLsizei stride, const GLvoid * pointer) {i #ifndef GLEE_C_DEFINED_glVertexAttrib2svARB
f (GLeeInit()) glVertexAttribPointerARB(index, size, type, normalized, stri #define GLEE_C_DEFINED_glVertexAttrib2svARB
de, pointer);} void __stdcall GLee_Lazy_glVertexAttrib2svARB(GLuint index, const GLshort
void __stdcall _Lazy_glEnableVertexAttribArrayARB(GLuint index) * v) {if (GLeeInit()) glVertexAttrib2svARB(index, v);}
{if (GLeeInit()) glEnableVertexAttribArrayARB(index);} GLEEPFNGLVERTEXATTRIB2SVARBPROC GLeeFuncPtr_glVertexAttrib2svARB=GLee_Laz
void __stdcall _Lazy_glDisableVertexAttribArrayARB(GLuint index) y_glVertexAttrib2svARB;
{if (GLeeInit()) glDisableVertexAttribArrayARB(index);} #endif
void __stdcall _Lazy_glProgramStringARB(GLenum target, GLenum format, GLsiz #ifndef GLEE_C_DEFINED_glVertexAttrib3dARB
ei len, const GLvoid * string) {if (GLeeInit()) glProgramStringARB(target, #define GLEE_C_DEFINED_glVertexAttrib3dARB
format, len, string);} void __stdcall GLee_Lazy_glVertexAttrib3dARB(GLuint index, GLdouble x, GL
void __stdcall _Lazy_glBindProgramARB(GLenum target, GLuint program) double y, GLdouble z) {if (GLeeInit()) glVertexAttrib3dARB(index, x, y, z)
{if (GLeeInit()) glBindProgramARB(target, program);} ;}
void __stdcall _Lazy_glDeleteProgramsARB(GLsizei n, const GLuint * programs GLEEPFNGLVERTEXATTRIB3DARBPROC GLeeFuncPtr_glVertexAttrib3dARB=GLee_Lazy_
) {if (GLeeInit()) glDeleteProgramsARB(n, programs);} glVertexAttrib3dARB;
void __stdcall _Lazy_glGenProgramsARB(GLsizei n, GLuint * programs) #endif
{if (GLeeInit()) glGenProgramsARB(n, programs);} #ifndef GLEE_C_DEFINED_glVertexAttrib3dvARB
void __stdcall _Lazy_glProgramEnvParameter4dARB(GLenum target, GLuint index #define GLEE_C_DEFINED_glVertexAttrib3dvARB
, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgr void __stdcall GLee_Lazy_glVertexAttrib3dvARB(GLuint index, const GLdoubl
amEnvParameter4dARB(target, index, x, y, z, w);} e * v) {if (GLeeInit()) glVertexAttrib3dvARB(index, v);}
void __stdcall _Lazy_glProgramEnvParameter4dvARB(GLenum target, GLuint inde GLEEPFNGLVERTEXATTRIB3DVARBPROC GLeeFuncPtr_glVertexAttrib3dvARB=GLee_Laz
x, const GLdouble * params) {if (GLeeInit()) glProgramEnvParameter4dvARB(t y_glVertexAttrib3dvARB;
arget, index, params);} #endif
void __stdcall _Lazy_glProgramEnvParameter4fARB(GLenum target, GLuint index #ifndef GLEE_C_DEFINED_glVertexAttrib3fARB
, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramEn #define GLEE_C_DEFINED_glVertexAttrib3fARB
vParameter4fARB(target, index, x, y, z, w);} void __stdcall GLee_Lazy_glVertexAttrib3fARB(GLuint index, GLfloat x, GLf
void __stdcall _Lazy_glProgramEnvParameter4fvARB(GLenum target, GLuint inde loat y, GLfloat z) {if (GLeeInit()) glVertexAttrib3fARB(index, x, y, z);}
x, const GLfloat * params) {if (GLeeInit()) glProgramEnvParameter4fvARB(ta GLEEPFNGLVERTEXATTRIB3FARBPROC GLeeFuncPtr_glVertexAttrib3fARB=GLee_Lazy_
rget, index, params);} glVertexAttrib3fARB;
void __stdcall _Lazy_glProgramLocalParameter4dARB(GLenum target, GLuint ind #endif
ex, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glPro #ifndef GLEE_C_DEFINED_glVertexAttrib3fvARB
gramLocalParameter4dARB(target, index, x, y, z, w);} #define GLEE_C_DEFINED_glVertexAttrib3fvARB
void __stdcall _Lazy_glProgramLocalParameter4dvARB(GLenum target, GLuint in void __stdcall GLee_Lazy_glVertexAttrib3fvARB(GLuint index, const GLfloat
dex, const GLdouble * params) {if (GLeeInit()) glProgramLocalParameter4dvA * v) {if (GLeeInit()) glVertexAttrib3fvARB(index, v);}
RB(target, index, params);} GLEEPFNGLVERTEXATTRIB3FVARBPROC GLeeFuncPtr_glVertexAttrib3fvARB=GLee_Laz
void __stdcall _Lazy_glProgramLocalParameter4fARB(GLenum target, GLuint ind y_glVertexAttrib3fvARB;
ex, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgram #endif
LocalParameter4fARB(target, index, x, y, z, w);} #ifndef GLEE_C_DEFINED_glVertexAttrib3sARB
void __stdcall _Lazy_glProgramLocalParameter4fvARB(GLenum target, GLuint in #define GLEE_C_DEFINED_glVertexAttrib3sARB
dex, const GLfloat * params) {if (GLeeInit()) glProgramLocalParameter4fvAR void __stdcall GLee_Lazy_glVertexAttrib3sARB(GLuint index, GLshort x, GLs
B(target, index, params);} hort y, GLshort z) {if (GLeeInit()) glVertexAttrib3sARB(index, x, y, z);}
void __stdcall _Lazy_glGetProgramEnvParameterdvARB(GLenum target, GLuint in GLEEPFNGLVERTEXATTRIB3SARBPROC GLeeFuncPtr_glVertexAttrib3sARB=GLee_Lazy_
dex, GLdouble * params) {if (GLeeInit()) glGetProgramEnvParameterdvARB(tar glVertexAttrib3sARB;
get, index, params);} #endif
void __stdcall _Lazy_glGetProgramEnvParameterfvARB(GLenum target, GLuint in #ifndef GLEE_C_DEFINED_glVertexAttrib3svARB
dex, GLfloat * params) {if (GLeeInit()) glGetProgramEnvParameterfvARB(targ #define GLEE_C_DEFINED_glVertexAttrib3svARB
et, index, params);} void __stdcall GLee_Lazy_glVertexAttrib3svARB(GLuint index, const GLshort
void __stdcall _Lazy_glGetProgramLocalParameterdvARB(GLenum target, GLuint * v) {if (GLeeInit()) glVertexAttrib3svARB(index, v);}
index, GLdouble * params) {if (GLeeInit()) glGetProgramLocalParameterdvARB GLEEPFNGLVERTEXATTRIB3SVARBPROC GLeeFuncPtr_glVertexAttrib3svARB=GLee_Laz
(target, index, params);} y_glVertexAttrib3svARB;
void __stdcall _Lazy_glGetProgramLocalParameterfvARB(GLenum target, GLuint #endif
index, GLfloat * params) {if (GLeeInit()) glGetProgramLocalParameterfvARB( #ifndef GLEE_C_DEFINED_glVertexAttrib4NbvARB
target, index, params);} #define GLEE_C_DEFINED_glVertexAttrib4NbvARB
void __stdcall _Lazy_glGetProgramivARB(GLenum target, GLenum pname, GLint * void __stdcall GLee_Lazy_glVertexAttrib4NbvARB(GLuint index, const GLbyte
params) {if (GLeeInit()) glGetProgramivARB(target, pname, params);} * v) {if (GLeeInit()) glVertexAttrib4NbvARB(index, v);}
void __stdcall _Lazy_glGetProgramStringARB(GLenum target, GLenum pname, GLv GLEEPFNGLVERTEXATTRIB4NBVARBPROC GLeeFuncPtr_glVertexAttrib4NbvARB=GLee_L
oid * string) {if (GLeeInit()) glGetProgramStringARB(target, pname, string azy_glVertexAttrib4NbvARB;
);} #endif
void __stdcall _Lazy_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLd #ifndef GLEE_C_DEFINED_glVertexAttrib4NivARB
ouble * params) {if (GLeeInit()) glGetVertexAttribdvARB(index, pname, para #define GLEE_C_DEFINED_glVertexAttrib4NivARB
ms);} void __stdcall GLee_Lazy_glVertexAttrib4NivARB(GLuint index, const GLint
void __stdcall _Lazy_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLf * v) {if (GLeeInit()) glVertexAttrib4NivARB(index, v);}
loat * params) {if (GLeeInit()) glGetVertexAttribfvARB(index, pname, param GLEEPFNGLVERTEXATTRIB4NIVARBPROC GLeeFuncPtr_glVertexAttrib4NivARB=GLee_L
s);} azy_glVertexAttrib4NivARB;
void __stdcall _Lazy_glGetVertexAttribivARB(GLuint index, GLenum pname, GLi #endif
nt * params) {if (GLeeInit()) glGetVertexAttribivARB(index, pname, params #ifndef GLEE_C_DEFINED_glVertexAttrib4NsvARB
);} #define GLEE_C_DEFINED_glVertexAttrib4NsvARB
void __stdcall _Lazy_glGetVertexAttribPointervARB(GLuint index, GLenum pnam void __stdcall GLee_Lazy_glVertexAttrib4NsvARB(GLuint index, const GLshor
e, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointervARB(index, t * v) {if (GLeeInit()) glVertexAttrib4NsvARB(index, v);}
pname, pointer);} GLEEPFNGLVERTEXATTRIB4NSVARBPROC GLeeFuncPtr_glVertexAttrib4NsvARB=GLee_L
GLboolean __stdcall _Lazy_glIsProgramARB(GLuint program) azy_glVertexAttrib4NsvARB;
{if (GLeeInit()) return glIsProgramARB(program); return (GLb #endif
oolean)0;} #ifndef GLEE_C_DEFINED_glVertexAttrib4NubARB
PFNGLVERTEXATTRIB1DARBPROC pglVertexAttrib1dARB=_Lazy_glVertexAttrib1dARB; #define GLEE_C_DEFINED_glVertexAttrib4NubARB
PFNGLVERTEXATTRIB1DVARBPROC pglVertexAttrib1dvARB=_Lazy_glVertexAttrib1dvAR void __stdcall GLee_Lazy_glVertexAttrib4NubARB(GLuint index, GLubyte x, G
B; Lubyte y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4NubARB(ind
PFNGLVERTEXATTRIB1FARBPROC pglVertexAttrib1fARB=_Lazy_glVertexAttrib1fARB; ex, x, y, z, w);}
PFNGLVERTEXATTRIB1FVARBPROC pglVertexAttrib1fvARB=_Lazy_glVertexAttrib1fvAR GLEEPFNGLVERTEXATTRIB4NUBARBPROC GLeeFuncPtr_glVertexAttrib4NubARB=GLee_L
B; azy_glVertexAttrib4NubARB;
PFNGLVERTEXATTRIB1SARBPROC pglVertexAttrib1sARB=_Lazy_glVertexAttrib1sARB; #endif
PFNGLVERTEXATTRIB1SVARBPROC pglVertexAttrib1svARB=_Lazy_glVertexAttrib1svAR #ifndef GLEE_C_DEFINED_glVertexAttrib4NubvARB
B; #define GLEE_C_DEFINED_glVertexAttrib4NubvARB
PFNGLVERTEXATTRIB2DARBPROC pglVertexAttrib2dARB=_Lazy_glVertexAttrib2dARB; void __stdcall GLee_Lazy_glVertexAttrib4NubvARB(GLuint index, const GLuby
PFNGLVERTEXATTRIB2DVARBPROC pglVertexAttrib2dvARB=_Lazy_glVertexAttrib2dvAR te * v) {if (GLeeInit()) glVertexAttrib4NubvARB(index, v);}
B; GLEEPFNGLVERTEXATTRIB4NUBVARBPROC GLeeFuncPtr_glVertexAttrib4NubvARB=GLee
PFNGLVERTEXATTRIB2FARBPROC pglVertexAttrib2fARB=_Lazy_glVertexAttrib2fARB; _Lazy_glVertexAttrib4NubvARB;
PFNGLVERTEXATTRIB2FVARBPROC pglVertexAttrib2fvARB=_Lazy_glVertexAttrib2fvAR #endif
B; #ifndef GLEE_C_DEFINED_glVertexAttrib4NuivARB
PFNGLVERTEXATTRIB2SARBPROC pglVertexAttrib2sARB=_Lazy_glVertexAttrib2sARB; #define GLEE_C_DEFINED_glVertexAttrib4NuivARB
PFNGLVERTEXATTRIB2SVARBPROC pglVertexAttrib2svARB=_Lazy_glVertexAttrib2svAR void __stdcall GLee_Lazy_glVertexAttrib4NuivARB(GLuint index, const GLuin
B; t * v) {if (GLeeInit()) glVertexAttrib4NuivARB(index, v);}
PFNGLVERTEXATTRIB3DARBPROC pglVertexAttrib3dARB=_Lazy_glVertexAttrib3dARB; GLEEPFNGLVERTEXATTRIB4NUIVARBPROC GLeeFuncPtr_glVertexAttrib4NuivARB=GLee
PFNGLVERTEXATTRIB3DVARBPROC pglVertexAttrib3dvARB=_Lazy_glVertexAttrib3dvAR _Lazy_glVertexAttrib4NuivARB;
B; #endif
PFNGLVERTEXATTRIB3FARBPROC pglVertexAttrib3fARB=_Lazy_glVertexAttrib3fARB; #ifndef GLEE_C_DEFINED_glVertexAttrib4NusvARB
PFNGLVERTEXATTRIB3FVARBPROC pglVertexAttrib3fvARB=_Lazy_glVertexAttrib3fvAR #define GLEE_C_DEFINED_glVertexAttrib4NusvARB
B; void __stdcall GLee_Lazy_glVertexAttrib4NusvARB(GLuint index, const GLush
PFNGLVERTEXATTRIB3SARBPROC pglVertexAttrib3sARB=_Lazy_glVertexAttrib3sARB; ort * v) {if (GLeeInit()) glVertexAttrib4NusvARB(index, v);}
PFNGLVERTEXATTRIB3SVARBPROC pglVertexAttrib3svARB=_Lazy_glVertexAttrib3svAR GLEEPFNGLVERTEXATTRIB4NUSVARBPROC GLeeFuncPtr_glVertexAttrib4NusvARB=GLee
B; _Lazy_glVertexAttrib4NusvARB;
PFNGLVERTEXATTRIB4NBVARBPROC pglVertexAttrib4NbvARB=_Lazy_glVertexAttrib4Nb #endif
vARB; #ifndef GLEE_C_DEFINED_glVertexAttrib4bvARB
PFNGLVERTEXATTRIB4NIVARBPROC pglVertexAttrib4NivARB=_Lazy_glVertexAttrib4Ni #define GLEE_C_DEFINED_glVertexAttrib4bvARB
vARB; void __stdcall GLee_Lazy_glVertexAttrib4bvARB(GLuint index, const GLbyte
PFNGLVERTEXATTRIB4NSVARBPROC pglVertexAttrib4NsvARB=_Lazy_glVertexAttrib4Ns * v) {if (GLeeInit()) glVertexAttrib4bvARB(index, v);}
vARB; GLEEPFNGLVERTEXATTRIB4BVARBPROC GLeeFuncPtr_glVertexAttrib4bvARB=GLee_Laz
PFNGLVERTEXATTRIB4NUBARBPROC pglVertexAttrib4NubARB=_Lazy_glVertexAttrib4Nu y_glVertexAttrib4bvARB;
bARB; #endif
PFNGLVERTEXATTRIB4NUBVARBPROC pglVertexAttrib4NubvARB=_Lazy_glVertexAttrib4 #ifndef GLEE_C_DEFINED_glVertexAttrib4dARB
NubvARB; #define GLEE_C_DEFINED_glVertexAttrib4dARB
PFNGLVERTEXATTRIB4NUIVARBPROC pglVertexAttrib4NuivARB=_Lazy_glVertexAttrib4 void __stdcall GLee_Lazy_glVertexAttrib4dARB(GLuint index, GLdouble x, GL
NuivARB; double y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4dARB(ind
PFNGLVERTEXATTRIB4NUSVARBPROC pglVertexAttrib4NusvARB=_Lazy_glVertexAttrib4 ex, x, y, z, w);}
NusvARB; GLEEPFNGLVERTEXATTRIB4DARBPROC GLeeFuncPtr_glVertexAttrib4dARB=GLee_Lazy_
PFNGLVERTEXATTRIB4BVARBPROC pglVertexAttrib4bvARB=_Lazy_glVertexAttrib4bvAR glVertexAttrib4dARB;
B; #endif
PFNGLVERTEXATTRIB4DARBPROC pglVertexAttrib4dARB=_Lazy_glVertexAttrib4dARB; #ifndef GLEE_C_DEFINED_glVertexAttrib4dvARB
PFNGLVERTEXATTRIB4DVARBPROC pglVertexAttrib4dvARB=_Lazy_glVertexAttrib4dvAR #define GLEE_C_DEFINED_glVertexAttrib4dvARB
B; void __stdcall GLee_Lazy_glVertexAttrib4dvARB(GLuint index, const GLdoubl
PFNGLVERTEXATTRIB4FARBPROC pglVertexAttrib4fARB=_Lazy_glVertexAttrib4fARB; e * v) {if (GLeeInit()) glVertexAttrib4dvARB(index, v);}
PFNGLVERTEXATTRIB4FVARBPROC pglVertexAttrib4fvARB=_Lazy_glVertexAttrib4fvAR GLEEPFNGLVERTEXATTRIB4DVARBPROC GLeeFuncPtr_glVertexAttrib4dvARB=GLee_Laz
B; y_glVertexAttrib4dvARB;
PFNGLVERTEXATTRIB4IVARBPROC pglVertexAttrib4ivARB=_Lazy_glVertexAttrib4ivAR #endif
B; #ifndef GLEE_C_DEFINED_glVertexAttrib4fARB
PFNGLVERTEXATTRIB4SARBPROC pglVertexAttrib4sARB=_Lazy_glVertexAttrib4sARB; #define GLEE_C_DEFINED_glVertexAttrib4fARB
PFNGLVERTEXATTRIB4SVARBPROC pglVertexAttrib4svARB=_Lazy_glVertexAttrib4svAR void __stdcall GLee_Lazy_glVertexAttrib4fARB(GLuint index, GLfloat x, GLf
B; loat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4fARB(index,
PFNGLVERTEXATTRIB4UBVARBPROC pglVertexAttrib4ubvARB=_Lazy_glVertexAttrib4ub x, y, z, w);}
vARB; GLEEPFNGLVERTEXATTRIB4FARBPROC GLeeFuncPtr_glVertexAttrib4fARB=GLee_Lazy_
PFNGLVERTEXATTRIB4UIVARBPROC pglVertexAttrib4uivARB=_Lazy_glVertexAttrib4ui glVertexAttrib4fARB;
vARB; #endif
PFNGLVERTEXATTRIB4USVARBPROC pglVertexAttrib4usvARB=_Lazy_glVertexAttrib4us #ifndef GLEE_C_DEFINED_glVertexAttrib4fvARB
vARB; #define GLEE_C_DEFINED_glVertexAttrib4fvARB
PFNGLVERTEXATTRIBPOINTERARBPROC pglVertexAttribPointerARB=_Lazy_glVertexAtt void __stdcall GLee_Lazy_glVertexAttrib4fvARB(GLuint index, const GLfloat
ribPointerARB; * v) {if (GLeeInit()) glVertexAttrib4fvARB(index, v);}
PFNGLENABLEVERTEXATTRIBARRAYARBPROC pglEnableVertexAttribArrayARB=_Lazy_glE GLEEPFNGLVERTEXATTRIB4FVARBPROC GLeeFuncPtr_glVertexAttrib4fvARB=GLee_Laz
nableVertexAttribArrayARB; y_glVertexAttrib4fvARB;
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC pglDisableVertexAttribArrayARB=_Lazy_g #endif
lDisableVertexAttribArrayARB; #ifndef GLEE_C_DEFINED_glVertexAttrib4ivARB
PFNGLPROGRAMSTRINGARBPROC pglProgramStringARB=_Lazy_glProgramStringARB; #define GLEE_C_DEFINED_glVertexAttrib4ivARB
PFNGLBINDPROGRAMARBPROC pglBindProgramARB=_Lazy_glBindProgramARB; void __stdcall GLee_Lazy_glVertexAttrib4ivARB(GLuint index, const GLint *
PFNGLDELETEPROGRAMSARBPROC pglDeleteProgramsARB=_Lazy_glDeleteProgramsARB; v) {if (GLeeInit()) glVertexAttrib4ivARB(index, v);}
PFNGLGENPROGRAMSARBPROC pglGenProgramsARB=_Lazy_glGenProgramsARB; GLEEPFNGLVERTEXATTRIB4IVARBPROC GLeeFuncPtr_glVertexAttrib4ivARB=GLee_Laz
PFNGLPROGRAMENVPARAMETER4DARBPROC pglProgramEnvParameter4dARB=_Lazy_glProgr y_glVertexAttrib4ivARB;
amEnvParameter4dARB; #endif
PFNGLPROGRAMENVPARAMETER4DVARBPROC pglProgramEnvParameter4dvARB=_Lazy_glPro #ifndef GLEE_C_DEFINED_glVertexAttrib4sARB
gramEnvParameter4dvARB; #define GLEE_C_DEFINED_glVertexAttrib4sARB
PFNGLPROGRAMENVPARAMETER4FARBPROC pglProgramEnvParameter4fARB=_Lazy_glProgr void __stdcall GLee_Lazy_glVertexAttrib4sARB(GLuint index, GLshort x, GLs
amEnvParameter4fARB; hort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4sARB(index,
PFNGLPROGRAMENVPARAMETER4FVARBPROC pglProgramEnvParameter4fvARB=_Lazy_glPro x, y, z, w);}
gramEnvParameter4fvARB; GLEEPFNGLVERTEXATTRIB4SARBPROC GLeeFuncPtr_glVertexAttrib4sARB=GLee_Lazy_
PFNGLPROGRAMLOCALPARAMETER4DARBPROC pglProgramLocalParameter4dARB=_Lazy_glP glVertexAttrib4sARB;
rogramLocalParameter4dARB; #endif
PFNGLPROGRAMLOCALPARAMETER4DVARBPROC pglProgramLocalParameter4dvARB=_Lazy_g #ifndef GLEE_C_DEFINED_glVertexAttrib4svARB
lProgramLocalParameter4dvARB; #define GLEE_C_DEFINED_glVertexAttrib4svARB
PFNGLPROGRAMLOCALPARAMETER4FARBPROC pglProgramLocalParameter4fARB=_Lazy_glP void __stdcall GLee_Lazy_glVertexAttrib4svARB(GLuint index, const GLshort
rogramLocalParameter4fARB; * v) {if (GLeeInit()) glVertexAttrib4svARB(index, v);}
PFNGLPROGRAMLOCALPARAMETER4FVARBPROC pglProgramLocalParameter4fvARB=_Lazy_g GLEEPFNGLVERTEXATTRIB4SVARBPROC GLeeFuncPtr_glVertexAttrib4svARB=GLee_Laz
lProgramLocalParameter4fvARB; y_glVertexAttrib4svARB;
PFNGLGETPROGRAMENVPARAMETERDVARBPROC pglGetProgramEnvParameterdvARB=_Lazy_g #endif
lGetProgramEnvParameterdvARB; #ifndef GLEE_C_DEFINED_glVertexAttrib4ubvARB
PFNGLGETPROGRAMENVPARAMETERFVARBPROC pglGetProgramEnvParameterfvARB=_Lazy_g #define GLEE_C_DEFINED_glVertexAttrib4ubvARB
lGetProgramEnvParameterfvARB; void __stdcall GLee_Lazy_glVertexAttrib4ubvARB(GLuint index, const GLubyt
PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC pglGetProgramLocalParameterdvARB=_La e * v) {if (GLeeInit()) glVertexAttrib4ubvARB(index, v);}
zy_glGetProgramLocalParameterdvARB; GLEEPFNGLVERTEXATTRIB4UBVARBPROC GLeeFuncPtr_glVertexAttrib4ubvARB=GLee_L
PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC pglGetProgramLocalParameterfvARB=_La azy_glVertexAttrib4ubvARB;
zy_glGetProgramLocalParameterfvARB; #endif
PFNGLGETPROGRAMIVARBPROC pglGetProgramivARB=_Lazy_glGetProgramivARB; #ifndef GLEE_C_DEFINED_glVertexAttrib4uivARB
PFNGLGETPROGRAMSTRINGARBPROC pglGetProgramStringARB=_Lazy_glGetProgramStrin #define GLEE_C_DEFINED_glVertexAttrib4uivARB
gARB; void __stdcall GLee_Lazy_glVertexAttrib4uivARB(GLuint index, const GLuint
PFNGLGETVERTEXATTRIBDVARBPROC pglGetVertexAttribdvARB=_Lazy_glGetVertexAttr * v) {if (GLeeInit()) glVertexAttrib4uivARB(index, v);}
ibdvARB; GLEEPFNGLVERTEXATTRIB4UIVARBPROC GLeeFuncPtr_glVertexAttrib4uivARB=GLee_L
PFNGLGETVERTEXATTRIBFVARBPROC pglGetVertexAttribfvARB=_Lazy_glGetVertexAttr azy_glVertexAttrib4uivARB;
ibfvARB; #endif
PFNGLGETVERTEXATTRIBIVARBPROC pglGetVertexAttribivARB=_Lazy_glGetVertexAttr #ifndef GLEE_C_DEFINED_glVertexAttrib4usvARB
ibivARB; #define GLEE_C_DEFINED_glVertexAttrib4usvARB
PFNGLGETVERTEXATTRIBPOINTERVARBPROC pglGetVertexAttribPointervARB=_Lazy_glG void __stdcall GLee_Lazy_glVertexAttrib4usvARB(GLuint index, const GLusho
etVertexAttribPointervARB; rt * v) {if (GLeeInit()) glVertexAttrib4usvARB(index, v);}
PFNGLISPROGRAMARBPROC pglIsProgramARB=_Lazy_glIsProgramARB; GLEEPFNGLVERTEXATTRIB4USVARBPROC GLeeFuncPtr_glVertexAttrib4usvARB=GLee_L
azy_glVertexAttrib4usvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointerARB
#define GLEE_C_DEFINED_glVertexAttribPointerARB
void __stdcall GLee_Lazy_glVertexAttribPointerARB(GLuint index, GLint siz
e, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointe
r) {if (GLeeInit()) glVertexAttribPointerARB(index, size, type, normalized
, stride, pointer);}
GLEEPFNGLVERTEXATTRIBPOINTERARBPROC GLeeFuncPtr_glVertexAttribPointerARB=
GLee_Lazy_glVertexAttribPointerARB;
#endif
#ifndef GLEE_C_DEFINED_glEnableVertexAttribArrayARB
#define GLEE_C_DEFINED_glEnableVertexAttribArrayARB
void __stdcall GLee_Lazy_glEnableVertexAttribArrayARB(GLuint index) {if
(GLeeInit()) glEnableVertexAttribArrayARB(index);}
GLEEPFNGLENABLEVERTEXATTRIBARRAYARBPROC GLeeFuncPtr_glEnableVertexAttribA
rrayARB=GLee_Lazy_glEnableVertexAttribArrayARB;
#endif
#ifndef GLEE_C_DEFINED_glDisableVertexAttribArrayARB
#define GLEE_C_DEFINED_glDisableVertexAttribArrayARB
void __stdcall GLee_Lazy_glDisableVertexAttribArrayARB(GLuint index) {if
(GLeeInit()) glDisableVertexAttribArrayARB(index);}
GLEEPFNGLDISABLEVERTEXATTRIBARRAYARBPROC GLeeFuncPtr_glDisableVertexAttri
bArrayARB=GLee_Lazy_glDisableVertexAttribArrayARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramStringARB
#define GLEE_C_DEFINED_glProgramStringARB
void __stdcall GLee_Lazy_glProgramStringARB(GLenum target, GLenum format,
GLsizei len, const GLvoid * string) {if (GLeeInit()) glProgramStringARB(t
arget, format, len, string);}
GLEEPFNGLPROGRAMSTRINGARBPROC GLeeFuncPtr_glProgramStringARB=GLee_Lazy_gl
ProgramStringARB;
#endif
#ifndef GLEE_C_DEFINED_glBindProgramARB
#define GLEE_C_DEFINED_glBindProgramARB
void __stdcall GLee_Lazy_glBindProgramARB(GLenum target, GLuint program)
{if (GLeeInit()) glBindProgramARB(target, program);}
GLEEPFNGLBINDPROGRAMARBPROC GLeeFuncPtr_glBindProgramARB=GLee_Lazy_glBind
ProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteProgramsARB
#define GLEE_C_DEFINED_glDeleteProgramsARB
void __stdcall GLee_Lazy_glDeleteProgramsARB(GLsizei n, const GLuint * pr
ograms) {if (GLeeInit()) glDeleteProgramsARB(n, programs);}
GLEEPFNGLDELETEPROGRAMSARBPROC GLeeFuncPtr_glDeleteProgramsARB=GLee_Lazy_
glDeleteProgramsARB;
#endif
#ifndef GLEE_C_DEFINED_glGenProgramsARB
#define GLEE_C_DEFINED_glGenProgramsARB
void __stdcall GLee_Lazy_glGenProgramsARB(GLsizei n, GLuint * programs)
{if (GLeeInit()) glGenProgramsARB(n, programs);}
GLEEPFNGLGENPROGRAMSARBPROC GLeeFuncPtr_glGenProgramsARB=GLee_Lazy_glGenP
rogramsARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4dARB
#define GLEE_C_DEFINED_glProgramEnvParameter4dARB
void __stdcall GLee_Lazy_glProgramEnvParameter4dARB(GLenum target, GLuint
index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) g
lProgramEnvParameter4dARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMENVPARAMETER4DARBPROC GLeeFuncPtr_glProgramEnvParameter4d
ARB=GLee_Lazy_glProgramEnvParameter4dARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4dvARB
#define GLEE_C_DEFINED_glProgramEnvParameter4dvARB
void __stdcall GLee_Lazy_glProgramEnvParameter4dvARB(GLenum target, GLuin
t index, const GLdouble * params) {if (GLeeInit()) glProgramEnvParameter4d
vARB(target, index, params);}
GLEEPFNGLPROGRAMENVPARAMETER4DVARBPROC GLeeFuncPtr_glProgramEnvParameter4
dvARB=GLee_Lazy_glProgramEnvParameter4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4fARB
#define GLEE_C_DEFINED_glProgramEnvParameter4fARB
void __stdcall GLee_Lazy_glProgramEnvParameter4fARB(GLenum target, GLuint
index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glPro
gramEnvParameter4fARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMENVPARAMETER4FARBPROC GLeeFuncPtr_glProgramEnvParameter4f
ARB=GLee_Lazy_glProgramEnvParameter4fARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4fvARB
#define GLEE_C_DEFINED_glProgramEnvParameter4fvARB
void __stdcall GLee_Lazy_glProgramEnvParameter4fvARB(GLenum target, GLuin
t index, const GLfloat * params) {if (GLeeInit()) glProgramEnvParameter4fv
ARB(target, index, params);}
GLEEPFNGLPROGRAMENVPARAMETER4FVARBPROC GLeeFuncPtr_glProgramEnvParameter4
fvARB=GLee_Lazy_glProgramEnvParameter4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4dARB
#define GLEE_C_DEFINED_glProgramLocalParameter4dARB
void __stdcall GLee_Lazy_glProgramLocalParameter4dARB(GLenum target, GLui
nt index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit())
glProgramLocalParameter4dARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMLOCALPARAMETER4DARBPROC GLeeFuncPtr_glProgramLocalParamet
er4dARB=GLee_Lazy_glProgramLocalParameter4dARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4dvARB
#define GLEE_C_DEFINED_glProgramLocalParameter4dvARB
void __stdcall GLee_Lazy_glProgramLocalParameter4dvARB(GLenum target, GLu
int index, const GLdouble * params) {if (GLeeInit()) glProgramLocalParamet
er4dvARB(target, index, params);}
GLEEPFNGLPROGRAMLOCALPARAMETER4DVARBPROC GLeeFuncPtr_glProgramLocalParame
ter4dvARB=GLee_Lazy_glProgramLocalParameter4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4fARB
#define GLEE_C_DEFINED_glProgramLocalParameter4fARB
void __stdcall GLee_Lazy_glProgramLocalParameter4fARB(GLenum target, GLui
nt index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glP
rogramLocalParameter4fARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMLOCALPARAMETER4FARBPROC GLeeFuncPtr_glProgramLocalParamet
er4fARB=GLee_Lazy_glProgramLocalParameter4fARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4fvARB
#define GLEE_C_DEFINED_glProgramLocalParameter4fvARB
void __stdcall GLee_Lazy_glProgramLocalParameter4fvARB(GLenum target, GLu
int index, const GLfloat * params) {if (GLeeInit()) glProgramLocalParamete
r4fvARB(target, index, params);}
GLEEPFNGLPROGRAMLOCALPARAMETER4FVARBPROC GLeeFuncPtr_glProgramLocalParame
ter4fvARB=GLee_Lazy_glProgramLocalParameter4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterdvARB
#define GLEE_C_DEFINED_glGetProgramEnvParameterdvARB
void __stdcall GLee_Lazy_glGetProgramEnvParameterdvARB(GLenum target, GLu
int index, GLdouble * params) {if (GLeeInit()) glGetProgramEnvParameterdvA
RB(target, index, params);}
GLEEPFNGLGETPROGRAMENVPARAMETERDVARBPROC GLeeFuncPtr_glGetProgramEnvParam
eterdvARB=GLee_Lazy_glGetProgramEnvParameterdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterfvARB
#define GLEE_C_DEFINED_glGetProgramEnvParameterfvARB
void __stdcall GLee_Lazy_glGetProgramEnvParameterfvARB(GLenum target, GLu
int index, GLfloat * params) {if (GLeeInit()) glGetProgramEnvParameterfvAR
B(target, index, params);}
GLEEPFNGLGETPROGRAMENVPARAMETERFVARBPROC GLeeFuncPtr_glGetProgramEnvParam
eterfvARB=GLee_Lazy_glGetProgramEnvParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterdvARB
#define GLEE_C_DEFINED_glGetProgramLocalParameterdvARB
void __stdcall GLee_Lazy_glGetProgramLocalParameterdvARB(GLenum target, G
Luint index, GLdouble * params) {if (GLeeInit()) glGetProgramLocalParamete
rdvARB(target, index, params);}
GLEEPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GLeeFuncPtr_glGetProgramLocalP
arameterdvARB=GLee_Lazy_glGetProgramLocalParameterdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterfvARB
#define GLEE_C_DEFINED_glGetProgramLocalParameterfvARB
void __stdcall GLee_Lazy_glGetProgramLocalParameterfvARB(GLenum target, G
Luint index, GLfloat * params) {if (GLeeInit()) glGetProgramLocalParameter
fvARB(target, index, params);}
GLEEPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GLeeFuncPtr_glGetProgramLocalP
arameterfvARB=GLee_Lazy_glGetProgramLocalParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramivARB
#define GLEE_C_DEFINED_glGetProgramivARB
void __stdcall GLee_Lazy_glGetProgramivARB(GLenum target, GLenum pname, G
Lint * params) {if (GLeeInit()) glGetProgramivARB(target, pname, params);}
GLEEPFNGLGETPROGRAMIVARBPROC GLeeFuncPtr_glGetProgramivARB=GLee_Lazy_glGe
tProgramivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramStringARB
#define GLEE_C_DEFINED_glGetProgramStringARB
void __stdcall GLee_Lazy_glGetProgramStringARB(GLenum target, GLenum pnam
e, GLvoid * string) {if (GLeeInit()) glGetProgramStringARB(target, pname,
string);}
GLEEPFNGLGETPROGRAMSTRINGARBPROC GLeeFuncPtr_glGetProgramStringARB=GLee_L
azy_glGetProgramStringARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribdvARB
#define GLEE_C_DEFINED_glGetVertexAttribdvARB
void __stdcall GLee_Lazy_glGetVertexAttribdvARB(GLuint index, GLenum pnam
e, GLdouble * params) {if (GLeeInit()) glGetVertexAttribdvARB(index, pname
, params);}
GLEEPFNGLGETVERTEXATTRIBDVARBPROC GLeeFuncPtr_glGetVertexAttribdvARB=GLee
_Lazy_glGetVertexAttribdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribfvARB
#define GLEE_C_DEFINED_glGetVertexAttribfvARB
void __stdcall GLee_Lazy_glGetVertexAttribfvARB(GLuint index, GLenum pnam
e, GLfloat * params) {if (GLeeInit()) glGetVertexAttribfvARB(index, pname,
params);}
GLEEPFNGLGETVERTEXATTRIBFVARBPROC GLeeFuncPtr_glGetVertexAttribfvARB=GLee
_Lazy_glGetVertexAttribfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribivARB
#define GLEE_C_DEFINED_glGetVertexAttribivARB
void __stdcall GLee_Lazy_glGetVertexAttribivARB(GLuint index, GLenum pnam
e, GLint * params) {if (GLeeInit()) glGetVertexAttribivARB(index, pname, p
arams);}
GLEEPFNGLGETVERTEXATTRIBIVARBPROC GLeeFuncPtr_glGetVertexAttribivARB=GLee
_Lazy_glGetVertexAttribivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribPointervARB
#define GLEE_C_DEFINED_glGetVertexAttribPointervARB
void __stdcall GLee_Lazy_glGetVertexAttribPointervARB(GLuint index, GLenu
m pname, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointervARB(
index, pname, pointer);}
GLEEPFNGLGETVERTEXATTRIBPOINTERVARBPROC GLeeFuncPtr_glGetVertexAttribPoin
tervARB=GLee_Lazy_glGetVertexAttribPointervARB;
#endif
#ifndef GLEE_C_DEFINED_glIsProgramARB
#define GLEE_C_DEFINED_glIsProgramARB
GLboolean __stdcall GLee_Lazy_glIsProgramARB(GLuint program) {if (GLeeIn
it()) return glIsProgramARB(program); return (GLboolean)0;}
GLEEPFNGLISPROGRAMARBPROC GLeeFuncPtr_glIsProgramARB=GLee_Lazy_glIsProgra
mARB;
#endif
#endif #endif
/* GL_ARB_fragment_program */ /* GL_ARB_fragment_program */
#ifdef __GLEE_GL_ARB_fragment_program #ifdef __GLEE_GL_ARB_fragment_program
#endif #endif
/* GL_ARB_vertex_buffer_object */ /* GL_ARB_vertex_buffer_object */
#ifdef __GLEE_GL_ARB_vertex_buffer_object #ifdef __GLEE_GL_ARB_vertex_buffer_object
void __stdcall _Lazy_glBindBufferARB(GLenum target, GLuint buffer) #ifndef GLEE_C_DEFINED_glBindBufferARB
{if (GLeeInit()) glBindBufferARB(target, buffer);} #define GLEE_C_DEFINED_glBindBufferARB
void __stdcall _Lazy_glDeleteBuffersARB(GLsizei n, const GLuint * buffers) void __stdcall GLee_Lazy_glBindBufferARB(GLenum target, GLuint buffer) {
{if (GLeeInit()) glDeleteBuffersARB(n, buffers);} if (GLeeInit()) glBindBufferARB(target, buffer);}
void __stdcall _Lazy_glGenBuffersARB(GLsizei n, GLuint * buffers) GLEEPFNGLBINDBUFFERARBPROC GLeeFuncPtr_glBindBufferARB=GLee_Lazy_glBindBu
{if (GLeeInit()) glGenBuffersARB(n, buffers);} fferARB;
GLboolean __stdcall _Lazy_glIsBufferARB(GLuint buffer) #endif
{if (GLeeInit()) return glIsBufferARB(buffer); return (GLboo #ifndef GLEE_C_DEFINED_glDeleteBuffersARB
lean)0;} #define GLEE_C_DEFINED_glDeleteBuffersARB
void __stdcall _Lazy_glBufferDataARB(GLenum target, GLsizeiptrARB size, con void __stdcall GLee_Lazy_glDeleteBuffersARB(GLsizei n, const GLuint * buf
st GLvoid * data, GLenum usage) {if (GLeeInit()) glBufferDataARB(target, s fers) {if (GLeeInit()) glDeleteBuffersARB(n, buffers);}
ize, data, usage);} GLEEPFNGLDELETEBUFFERSARBPROC GLeeFuncPtr_glDeleteBuffersARB=GLee_Lazy_gl
void __stdcall _Lazy_glBufferSubDataARB(GLenum target, GLintptrARB offset, DeleteBuffersARB;
GLsizeiptrARB size, const GLvoid * data) {if (GLeeInit()) glBufferSubDataA #endif
RB(target, offset, size, data);} #ifndef GLEE_C_DEFINED_glGenBuffersARB
void __stdcall _Lazy_glGetBufferSubDataARB(GLenum target, GLintptrARB offse #define GLEE_C_DEFINED_glGenBuffersARB
t, GLsizeiptrARB size, GLvoid * data) {if (GLeeInit()) glGetBufferSubDataA void __stdcall GLee_Lazy_glGenBuffersARB(GLsizei n, GLuint * buffers) {i
RB(target, offset, size, data);} f (GLeeInit()) glGenBuffersARB(n, buffers);}
GLvoid* __stdcall _Lazy_glMapBufferARB(GLenum target, GLenum access) GLEEPFNGLGENBUFFERSARBPROC GLeeFuncPtr_glGenBuffersARB=GLee_Lazy_glGenBuf
{if (GLeeInit()) return glMapBufferARB(target, access); retu fersARB;
rn (GLvoid*)0;} #endif
GLboolean __stdcall _Lazy_glUnmapBufferARB(GLenum target) #ifndef GLEE_C_DEFINED_glIsBufferARB
{if (GLeeInit()) return glUnmapBufferARB(target); return (GL #define GLEE_C_DEFINED_glIsBufferARB
boolean)0;} GLboolean __stdcall GLee_Lazy_glIsBufferARB(GLuint buffer) {if (GLeeInit
void __stdcall _Lazy_glGetBufferParameterivARB(GLenum target, GLenum pname, ()) return glIsBufferARB(buffer); return (GLboolean)0;}
GLint * params) {if (GLeeInit()) glGetBufferParameterivARB(target, pname, GLEEPFNGLISBUFFERARBPROC GLeeFuncPtr_glIsBufferARB=GLee_Lazy_glIsBufferAR
params);} B;
void __stdcall _Lazy_glGetBufferPointervARB(GLenum target, GLenum pname, GL #endif
void* * params) {if (GLeeInit()) glGetBufferPointervARB(target, pname, par #ifndef GLEE_C_DEFINED_glBufferDataARB
ams);} #define GLEE_C_DEFINED_glBufferDataARB
PFNGLBINDBUFFERARBPROC pglBindBufferARB=_Lazy_glBindBufferARB; void __stdcall GLee_Lazy_glBufferDataARB(GLenum target, GLsizeiptrARB siz
PFNGLDELETEBUFFERSARBPROC pglDeleteBuffersARB=_Lazy_glDeleteBuffersARB; e, const GLvoid * data, GLenum usage) {if (GLeeInit()) glBufferDataARB(tar
PFNGLGENBUFFERSARBPROC pglGenBuffersARB=_Lazy_glGenBuffersARB; get, size, data, usage);}
PFNGLISBUFFERARBPROC pglIsBufferARB=_Lazy_glIsBufferARB; GLEEPFNGLBUFFERDATAARBPROC GLeeFuncPtr_glBufferDataARB=GLee_Lazy_glBuffer
PFNGLBUFFERDATAARBPROC pglBufferDataARB=_Lazy_glBufferDataARB; DataARB;
PFNGLBUFFERSUBDATAARBPROC pglBufferSubDataARB=_Lazy_glBufferSubDataARB; #endif
PFNGLGETBUFFERSUBDATAARBPROC pglGetBufferSubDataARB=_Lazy_glGetBufferSubDat #ifndef GLEE_C_DEFINED_glBufferSubDataARB
aARB; #define GLEE_C_DEFINED_glBufferSubDataARB
PFNGLMAPBUFFERARBPROC pglMapBufferARB=_Lazy_glMapBufferARB; void __stdcall GLee_Lazy_glBufferSubDataARB(GLenum target, GLintptrARB of
PFNGLUNMAPBUFFERARBPROC pglUnmapBufferARB=_Lazy_glUnmapBufferARB; fset, GLsizeiptrARB size, const GLvoid * data) {if (GLeeInit()) glBufferSu
PFNGLGETBUFFERPARAMETERIVARBPROC pglGetBufferParameterivARB=_Lazy_glGetBuff bDataARB(target, offset, size, data);}
erParameterivARB; GLEEPFNGLBUFFERSUBDATAARBPROC GLeeFuncPtr_glBufferSubDataARB=GLee_Lazy_gl
PFNGLGETBUFFERPOINTERVARBPROC pglGetBufferPointervARB=_Lazy_glGetBufferPoin BufferSubDataARB;
tervARB; #endif
#ifndef GLEE_C_DEFINED_glGetBufferSubDataARB
#define GLEE_C_DEFINED_glGetBufferSubDataARB
void __stdcall GLee_Lazy_glGetBufferSubDataARB(GLenum target, GLintptrARB
offset, GLsizeiptrARB size, GLvoid * data) {if (GLeeInit()) glGetBufferSu
bDataARB(target, offset, size, data);}
GLEEPFNGLGETBUFFERSUBDATAARBPROC GLeeFuncPtr_glGetBufferSubDataARB=GLee_L
azy_glGetBufferSubDataARB;
#endif
#ifndef GLEE_C_DEFINED_glMapBufferARB
#define GLEE_C_DEFINED_glMapBufferARB
GLvoid* __stdcall GLee_Lazy_glMapBufferARB(GLenum target, GLenum access)
{if (GLeeInit()) return glMapBufferARB(target, access); return (GLvoid*)0;
}
GLEEPFNGLMAPBUFFERARBPROC GLeeFuncPtr_glMapBufferARB=GLee_Lazy_glMapBuffe
rARB;
#endif
#ifndef GLEE_C_DEFINED_glUnmapBufferARB
#define GLEE_C_DEFINED_glUnmapBufferARB
GLboolean __stdcall GLee_Lazy_glUnmapBufferARB(GLenum target) {if (GLeeI
nit()) return glUnmapBufferARB(target); return (GLboolean)0;}
GLEEPFNGLUNMAPBUFFERARBPROC GLeeFuncPtr_glUnmapBufferARB=GLee_Lazy_glUnma
pBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferParameterivARB
#define GLEE_C_DEFINED_glGetBufferParameterivARB
void __stdcall GLee_Lazy_glGetBufferParameterivARB(GLenum target, GLenum
pname, GLint * params) {if (GLeeInit()) glGetBufferParameterivARB(target,
pname, params);}
GLEEPFNGLGETBUFFERPARAMETERIVARBPROC GLeeFuncPtr_glGetBufferParameterivAR
B=GLee_Lazy_glGetBufferParameterivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferPointervARB
#define GLEE_C_DEFINED_glGetBufferPointervARB
void __stdcall GLee_Lazy_glGetBufferPointervARB(GLenum target, GLenum pna
me, GLvoid* * params) {if (GLeeInit()) glGetBufferPointervARB(target, pnam
e, params);}
GLEEPFNGLGETBUFFERPOINTERVARBPROC GLeeFuncPtr_glGetBufferPointervARB=GLee
_Lazy_glGetBufferPointervARB;
#endif
#endif #endif
/* GL_ARB_occlusion_query */ /* GL_ARB_occlusion_query */
#ifdef __GLEE_GL_ARB_occlusion_query #ifdef __GLEE_GL_ARB_occlusion_query
void __stdcall _Lazy_glGenQueriesARB(GLsizei n, GLuint * ids) #ifndef GLEE_C_DEFINED_glGenQueriesARB
{if (GLeeInit()) glGenQueriesARB(n, ids);} #define GLEE_C_DEFINED_glGenQueriesARB
void __stdcall _Lazy_glDeleteQueriesARB(GLsizei n, const GLuint * ids) void __stdcall GLee_Lazy_glGenQueriesARB(GLsizei n, GLuint * ids) {if (G
{if (GLeeInit()) glDeleteQueriesARB(n, ids);} LeeInit()) glGenQueriesARB(n, ids);}
GLboolean __stdcall _Lazy_glIsQueryARB(GLuint id) GLEEPFNGLGENQUERIESARBPROC GLeeFuncPtr_glGenQueriesARB=GLee_Lazy_glGenQue
{if (GLeeInit()) return glIsQueryARB(id); return (GLboolean) riesARB;
0;} #endif
void __stdcall _Lazy_glBeginQueryARB(GLenum target, GLuint id) #ifndef GLEE_C_DEFINED_glDeleteQueriesARB
{if (GLeeInit()) glBeginQueryARB(target, id);} #define GLEE_C_DEFINED_glDeleteQueriesARB
void __stdcall _Lazy_glEndQueryARB(GLenum target) void __stdcall GLee_Lazy_glDeleteQueriesARB(GLsizei n, const GLuint * ids
{if (GLeeInit()) glEndQueryARB(target);} ) {if (GLeeInit()) glDeleteQueriesARB(n, ids);}
void __stdcall _Lazy_glGetQueryivARB(GLenum target, GLenum pname, GLint * p GLEEPFNGLDELETEQUERIESARBPROC GLeeFuncPtr_glDeleteQueriesARB=GLee_Lazy_gl
arams) {if (GLeeInit()) glGetQueryivARB(target, pname, params);} DeleteQueriesARB;
void __stdcall _Lazy_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * #endif
params) {if (GLeeInit()) glGetQueryObjectivARB(id, pname, params);} #ifndef GLEE_C_DEFINED_glIsQueryARB
void __stdcall _Lazy_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint #define GLEE_C_DEFINED_glIsQueryARB
* params) {if (GLeeInit()) glGetQueryObjectuivARB(id, pname, params);} GLboolean __stdcall GLee_Lazy_glIsQueryARB(GLuint id) {if (GLeeInit()) r
PFNGLGENQUERIESARBPROC pglGenQueriesARB=_Lazy_glGenQueriesARB; eturn glIsQueryARB(id); return (GLboolean)0;}
PFNGLDELETEQUERIESARBPROC pglDeleteQueriesARB=_Lazy_glDeleteQueriesARB; GLEEPFNGLISQUERYARBPROC GLeeFuncPtr_glIsQueryARB=GLee_Lazy_glIsQueryARB;
PFNGLISQUERYARBPROC pglIsQueryARB=_Lazy_glIsQueryARB; #endif
PFNGLBEGINQUERYARBPROC pglBeginQueryARB=_Lazy_glBeginQueryARB; #ifndef GLEE_C_DEFINED_glBeginQueryARB
PFNGLENDQUERYARBPROC pglEndQueryARB=_Lazy_glEndQueryARB; #define GLEE_C_DEFINED_glBeginQueryARB
PFNGLGETQUERYIVARBPROC pglGetQueryivARB=_Lazy_glGetQueryivARB; void __stdcall GLee_Lazy_glBeginQueryARB(GLenum target, GLuint id) {if (
PFNGLGETQUERYOBJECTIVARBPROC pglGetQueryObjectivARB=_Lazy_glGetQueryObjecti GLeeInit()) glBeginQueryARB(target, id);}
vARB; GLEEPFNGLBEGINQUERYARBPROC GLeeFuncPtr_glBeginQueryARB=GLee_Lazy_glBeginQ
PFNGLGETQUERYOBJECTUIVARBPROC pglGetQueryObjectuivARB=_Lazy_glGetQueryObjec ueryARB;
tuivARB; #endif
#ifndef GLEE_C_DEFINED_glEndQueryARB
#define GLEE_C_DEFINED_glEndQueryARB
void __stdcall GLee_Lazy_glEndQueryARB(GLenum target) {if (GLeeInit()) g
lEndQueryARB(target);}
GLEEPFNGLENDQUERYARBPROC GLeeFuncPtr_glEndQueryARB=GLee_Lazy_glEndQueryAR
B;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryivARB
#define GLEE_C_DEFINED_glGetQueryivARB
void __stdcall GLee_Lazy_glGetQueryivARB(GLenum target, GLenum pname, GLi
nt * params) {if (GLeeInit()) glGetQueryivARB(target, pname, params);}
GLEEPFNGLGETQUERYIVARBPROC GLeeFuncPtr_glGetQueryivARB=GLee_Lazy_glGetQue
ryivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectivARB
#define GLEE_C_DEFINED_glGetQueryObjectivARB
void __stdcall GLee_Lazy_glGetQueryObjectivARB(GLuint id, GLenum pname, G
Lint * params) {if (GLeeInit()) glGetQueryObjectivARB(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTIVARBPROC GLeeFuncPtr_glGetQueryObjectivARB=GLee_L
azy_glGetQueryObjectivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectuivARB
#define GLEE_C_DEFINED_glGetQueryObjectuivARB
void __stdcall GLee_Lazy_glGetQueryObjectuivARB(GLuint id, GLenum pname,
GLuint * params) {if (GLeeInit()) glGetQueryObjectuivARB(id, pname, params
);}
GLEEPFNGLGETQUERYOBJECTUIVARBPROC GLeeFuncPtr_glGetQueryObjectuivARB=GLee
_Lazy_glGetQueryObjectuivARB;
#endif
#endif #endif
/* GL_ARB_shader_objects */ /* GL_ARB_shader_objects */
#ifdef __GLEE_GL_ARB_shader_objects #ifdef __GLEE_GL_ARB_shader_objects
void __stdcall _Lazy_glDeleteObjectARB(GLhandleARB obj) #ifndef GLEE_C_DEFINED_glDeleteObjectARB
{if (GLeeInit()) glDeleteObjectARB(obj);} #define GLEE_C_DEFINED_glDeleteObjectARB
GLhandleARB __stdcall _Lazy_glGetHandleARB(GLenum pname) void __stdcall GLee_Lazy_glDeleteObjectARB(GLhandleARB obj) {if (GLeeIni
{if (GLeeInit()) return glGetHandleARB(pname); return (GLhan t()) glDeleteObjectARB(obj);}
dleARB)0;} GLEEPFNGLDELETEOBJECTARBPROC GLeeFuncPtr_glDeleteObjectARB=GLee_Lazy_glDe
void __stdcall _Lazy_glDetachObjectARB(GLhandleARB containerObj, GLhandleAR leteObjectARB;
B attachedObj) {if (GLeeInit()) glDetachObjectARB(containerObj, attachedOb #endif
j);} #ifndef GLEE_C_DEFINED_glGetHandleARB
GLhandleARB __stdcall _Lazy_glCreateShaderObjectARB(GLenum shaderType) #define GLEE_C_DEFINED_glGetHandleARB
{if (GLeeInit()) return glCreateShaderObjectARB(shaderType); GLhandleARB __stdcall GLee_Lazy_glGetHandleARB(GLenum pname) {if (GLeeIn
return (GLhandleARB)0;} it()) return glGetHandleARB(pname); return (GLhandleARB)0;}
void __stdcall _Lazy_glShaderSourceARB(GLhandleARB shaderObj, GLsizei count GLEEPFNGLGETHANDLEARBPROC GLeeFuncPtr_glGetHandleARB=GLee_Lazy_glGetHandl
, const GLcharARB* * string, const GLint * length) {if (GLeeInit()) glShad eARB;
erSourceARB(shaderObj, count, string, length);} #endif
void __stdcall _Lazy_glCompileShaderARB(GLhandleARB shaderObj) #ifndef GLEE_C_DEFINED_glDetachObjectARB
{if (GLeeInit()) glCompileShaderARB(shaderObj);} #define GLEE_C_DEFINED_glDetachObjectARB
GLhandleARB __stdcall _Lazy_glCreateProgramObjectARB(void) void __stdcall GLee_Lazy_glDetachObjectARB(GLhandleARB containerObj, GLha
{if (GLeeInit()) return glCreateProgramObjectARB(); return ( ndleARB attachedObj) {if (GLeeInit()) glDetachObjectARB(containerObj, atta
GLhandleARB)0;} chedObj);}
void __stdcall _Lazy_glAttachObjectARB(GLhandleARB containerObj, GLhandleAR GLEEPFNGLDETACHOBJECTARBPROC GLeeFuncPtr_glDetachObjectARB=GLee_Lazy_glDe
B obj) {if (GLeeInit()) glAttachObjectARB(containerObj, obj);} tachObjectARB;
void __stdcall _Lazy_glLinkProgramARB(GLhandleARB programObj) #endif
{if (GLeeInit()) glLinkProgramARB(programObj);} #ifndef GLEE_C_DEFINED_glCreateShaderObjectARB
void __stdcall _Lazy_glUseProgramObjectARB(GLhandleARB programObj) #define GLEE_C_DEFINED_glCreateShaderObjectARB
{if (GLeeInit()) glUseProgramObjectARB(programObj);} GLhandleARB __stdcall GLee_Lazy_glCreateShaderObjectARB(GLenum shaderType
void __stdcall _Lazy_glValidateProgramARB(GLhandleARB programObj) ) {if (GLeeInit()) return glCreateShaderObjectARB(shaderType); return (GLh
{if (GLeeInit()) glValidateProgramARB(programObj);} andleARB)0;}
void __stdcall _Lazy_glUniform1fARB(GLint location, GLfloat v0) GLEEPFNGLCREATESHADEROBJECTARBPROC GLeeFuncPtr_glCreateShaderObjectARB=GL
{if (GLeeInit()) glUniform1fARB(location, v0);} ee_Lazy_glCreateShaderObjectARB;
void __stdcall _Lazy_glUniform2fARB(GLint location, GLfloat v0, GLfloat v1) #endif
{if (GLeeInit()) glUniform2fARB(location, v0, v1);} #ifndef GLEE_C_DEFINED_glShaderSourceARB
void __stdcall _Lazy_glUniform3fARB(GLint location, GLfloat v0, GLfloat v1, #define GLEE_C_DEFINED_glShaderSourceARB
GLfloat v2) {if (GLeeInit()) glUniform3fARB(location, v0, v1, v2);} void __stdcall GLee_Lazy_glShaderSourceARB(GLhandleARB shaderObj, GLsizei
void __stdcall _Lazy_glUniform4fARB(GLint location, GLfloat v0, GLfloat v1, count, const GLcharARB* * string, const GLint * length) {if (GLeeInit())
GLfloat v2, GLfloat v3) {if (GLeeInit()) glUniform4fARB(location, v0, v1, glShaderSourceARB(shaderObj, count, string, length);}
v2, v3);} GLEEPFNGLSHADERSOURCEARBPROC GLeeFuncPtr_glShaderSourceARB=GLee_Lazy_glSh
void __stdcall _Lazy_glUniform1iARB(GLint location, GLint v0) aderSourceARB;
{if (GLeeInit()) glUniform1iARB(location, v0);} #endif
void __stdcall _Lazy_glUniform2iARB(GLint location, GLint v0, GLint v1) #ifndef GLEE_C_DEFINED_glCompileShaderARB
{if (GLeeInit()) glUniform2iARB(location, v0, v1);} #define GLEE_C_DEFINED_glCompileShaderARB
void __stdcall _Lazy_glUniform3iARB(GLint location, GLint v0, GLint v1, GLi void __stdcall GLee_Lazy_glCompileShaderARB(GLhandleARB shaderObj) {if (
nt v2) {if (GLeeInit()) glUniform3iARB(location, v0, v1, v2);} GLeeInit()) glCompileShaderARB(shaderObj);}
void __stdcall _Lazy_glUniform4iARB(GLint location, GLint v0, GLint v1, GLi GLEEPFNGLCOMPILESHADERARBPROC GLeeFuncPtr_glCompileShaderARB=GLee_Lazy_gl
nt v2, GLint v3) {if (GLeeInit()) glUniform4iARB(location, v0, v1, v2, v3) CompileShaderARB;
;} #endif
void __stdcall _Lazy_glUniform1fvARB(GLint location, GLsizei count, const G #ifndef GLEE_C_DEFINED_glCreateProgramObjectARB
Lfloat * value) {if (GLeeInit()) glUniform1fvARB(location, count, value);} #define GLEE_C_DEFINED_glCreateProgramObjectARB
void __stdcall _Lazy_glUniform2fvARB(GLint location, GLsizei count, const G GLhandleARB __stdcall GLee_Lazy_glCreateProgramObjectARB(void) {if (GLee
Lfloat * value) {if (GLeeInit()) glUniform2fvARB(location, count, value);} Init()) return glCreateProgramObjectARB(); return (GLhandleARB)0;}
void __stdcall _Lazy_glUniform3fvARB(GLint location, GLsizei count, const G GLEEPFNGLCREATEPROGRAMOBJECTARBPROC GLeeFuncPtr_glCreateProgramObjectARB=
Lfloat * value) {if (GLeeInit()) glUniform3fvARB(location, count, value);} GLee_Lazy_glCreateProgramObjectARB;
void __stdcall _Lazy_glUniform4fvARB(GLint location, GLsizei count, const G #endif
Lfloat * value) {if (GLeeInit()) glUniform4fvARB(location, count, value);} #ifndef GLEE_C_DEFINED_glAttachObjectARB
void __stdcall _Lazy_glUniform1ivARB(GLint location, GLsizei count, const G #define GLEE_C_DEFINED_glAttachObjectARB
Lint * value) {if (GLeeInit()) glUniform1ivARB(location, count, value);} void __stdcall GLee_Lazy_glAttachObjectARB(GLhandleARB containerObj, GLha
void __stdcall _Lazy_glUniform2ivARB(GLint location, GLsizei count, const G ndleARB obj) {if (GLeeInit()) glAttachObjectARB(containerObj, obj);}
Lint * value) {if (GLeeInit()) glUniform2ivARB(location, count, value);} GLEEPFNGLATTACHOBJECTARBPROC GLeeFuncPtr_glAttachObjectARB=GLee_Lazy_glAt
void __stdcall _Lazy_glUniform3ivARB(GLint location, GLsizei count, const G tachObjectARB;
Lint * value) {if (GLeeInit()) glUniform3ivARB(location, count, value);} #endif
void __stdcall _Lazy_glUniform4ivARB(GLint location, GLsizei count, const G #ifndef GLEE_C_DEFINED_glLinkProgramARB
Lint * value) {if (GLeeInit()) glUniform4ivARB(location, count, value);} #define GLEE_C_DEFINED_glLinkProgramARB
void __stdcall _Lazy_glUniformMatrix2fvARB(GLint location, GLsizei count, G void __stdcall GLee_Lazy_glLinkProgramARB(GLhandleARB programObj) {if (G
Lboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatri LeeInit()) glLinkProgramARB(programObj);}
x2fvARB(location, count, transpose, value);} GLEEPFNGLLINKPROGRAMARBPROC GLeeFuncPtr_glLinkProgramARB=GLee_Lazy_glLink
void __stdcall _Lazy_glUniformMatrix3fvARB(GLint location, GLsizei count, G ProgramARB;
Lboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatri #endif
x3fvARB(location, count, transpose, value);} #ifndef GLEE_C_DEFINED_glUseProgramObjectARB
void __stdcall _Lazy_glUniformMatrix4fvARB(GLint location, GLsizei count, G #define GLEE_C_DEFINED_glUseProgramObjectARB
Lboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatri void __stdcall GLee_Lazy_glUseProgramObjectARB(GLhandleARB programObj) {
x4fvARB(location, count, transpose, value);} if (GLeeInit()) glUseProgramObjectARB(programObj);}
void __stdcall _Lazy_glGetObjectParameterfvARB(GLhandleARB obj, GLenum pnam GLEEPFNGLUSEPROGRAMOBJECTARBPROC GLeeFuncPtr_glUseProgramObjectARB=GLee_L
e, GLfloat * params) {if (GLeeInit()) glGetObjectParameterfvARB(obj, pname azy_glUseProgramObjectARB;
, params);} #endif
void __stdcall _Lazy_glGetObjectParameterivARB(GLhandleARB obj, GLenum pnam #ifndef GLEE_C_DEFINED_glValidateProgramARB
e, GLint * params) {if (GLeeInit()) glGetObjectParameterivARB(obj, pname, #define GLEE_C_DEFINED_glValidateProgramARB
params);} void __stdcall GLee_Lazy_glValidateProgramARB(GLhandleARB programObj) {i
void __stdcall _Lazy_glGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GL f (GLeeInit()) glValidateProgramARB(programObj);}
sizei * length, GLcharARB * infoLog) {if (GLeeInit()) glGetInfoLogARB(obj, GLEEPFNGLVALIDATEPROGRAMARBPROC GLeeFuncPtr_glValidateProgramARB=GLee_Laz
maxLength, length, infoLog);} y_glValidateProgramARB;
void __stdcall _Lazy_glGetAttachedObjectsARB(GLhandleARB containerObj, GLsi #endif
zei maxCount, GLsizei * count, GLhandleARB * obj) {if (GLeeInit()) glGetAt #ifndef GLEE_C_DEFINED_glUniform1fARB
tachedObjectsARB(containerObj, maxCount, count, obj);} #define GLEE_C_DEFINED_glUniform1fARB
GLint __stdcall _Lazy_glGetUniformLocationARB(GLhandleARB programObj, const void __stdcall GLee_Lazy_glUniform1fARB(GLint location, GLfloat v0) {if
GLcharARB * name) {if (GLeeInit()) return glGetUniformLocationARB(program (GLeeInit()) glUniform1fARB(location, v0);}
Obj, name); return (GLint)0;} GLEEPFNGLUNIFORM1FARBPROC GLeeFuncPtr_glUniform1fARB=GLee_Lazy_glUniform1
void __stdcall _Lazy_glGetActiveUniformARB(GLhandleARB programObj, GLuint i fARB;
ndex, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLc #endif
harARB * name) {if (GLeeInit()) glGetActiveUniformARB(programObj, index, m #ifndef GLEE_C_DEFINED_glUniform2fARB
axLength, length, size, type, name);} #define GLEE_C_DEFINED_glUniform2fARB
void __stdcall _Lazy_glGetUniformfvARB(GLhandleARB programObj, GLint locati void __stdcall GLee_Lazy_glUniform2fARB(GLint location, GLfloat v0, GLflo
on, GLfloat * params) {if (GLeeInit()) glGetUniformfvARB(programObj, locat at v1) {if (GLeeInit()) glUniform2fARB(location, v0, v1);}
ion, params);} GLEEPFNGLUNIFORM2FARBPROC GLeeFuncPtr_glUniform2fARB=GLee_Lazy_glUniform2
void __stdcall _Lazy_glGetUniformivARB(GLhandleARB programObj, GLint locati fARB;
on, GLint * params) {if (GLeeInit()) glGetUniformivARB(programObj, locatio #endif
n, params);} #ifndef GLEE_C_DEFINED_glUniform3fARB
void __stdcall _Lazy_glGetShaderSourceARB(GLhandleARB obj, GLsizei maxLengt #define GLEE_C_DEFINED_glUniform3fARB
h, GLsizei * length, GLcharARB * source) {if (GLeeInit()) glGetShaderSourc void __stdcall GLee_Lazy_glUniform3fARB(GLint location, GLfloat v0, GLflo
eARB(obj, maxLength, length, source);} at v1, GLfloat v2) {if (GLeeInit()) glUniform3fARB(location, v0, v1, v2);}
PFNGLDELETEOBJECTARBPROC pglDeleteObjectARB=_Lazy_glDeleteObjectARB; GLEEPFNGLUNIFORM3FARBPROC GLeeFuncPtr_glUniform3fARB=GLee_Lazy_glUniform3
PFNGLGETHANDLEARBPROC pglGetHandleARB=_Lazy_glGetHandleARB; fARB;
PFNGLDETACHOBJECTARBPROC pglDetachObjectARB=_Lazy_glDetachObjectARB; #endif
PFNGLCREATESHADEROBJECTARBPROC pglCreateShaderObjectARB=_Lazy_glCreateShade #ifndef GLEE_C_DEFINED_glUniform4fARB
rObjectARB; #define GLEE_C_DEFINED_glUniform4fARB
PFNGLSHADERSOURCEARBPROC pglShaderSourceARB=_Lazy_glShaderSourceARB; void __stdcall GLee_Lazy_glUniform4fARB(GLint location, GLfloat v0, GLflo
PFNGLCOMPILESHADERARBPROC pglCompileShaderARB=_Lazy_glCompileShaderARB; at v1, GLfloat v2, GLfloat v3) {if (GLeeInit()) glUniform4fARB(location, v
PFNGLCREATEPROGRAMOBJECTARBPROC pglCreateProgramObjectARB=_Lazy_glCreatePro 0, v1, v2, v3);}
gramObjectARB; GLEEPFNGLUNIFORM4FARBPROC GLeeFuncPtr_glUniform4fARB=GLee_Lazy_glUniform4
PFNGLATTACHOBJECTARBPROC pglAttachObjectARB=_Lazy_glAttachObjectARB; fARB;
PFNGLLINKPROGRAMARBPROC pglLinkProgramARB=_Lazy_glLinkProgramARB; #endif
PFNGLUSEPROGRAMOBJECTARBPROC pglUseProgramObjectARB=_Lazy_glUseProgramObjec #ifndef GLEE_C_DEFINED_glUniform1iARB
tARB; #define GLEE_C_DEFINED_glUniform1iARB
PFNGLVALIDATEPROGRAMARBPROC pglValidateProgramARB=_Lazy_glValidateProgramAR void __stdcall GLee_Lazy_glUniform1iARB(GLint location, GLint v0) {if (G
B; LeeInit()) glUniform1iARB(location, v0);}
PFNGLUNIFORM1FARBPROC pglUniform1fARB=_Lazy_glUniform1fARB; GLEEPFNGLUNIFORM1IARBPROC GLeeFuncPtr_glUniform1iARB=GLee_Lazy_glUniform1
PFNGLUNIFORM2FARBPROC pglUniform2fARB=_Lazy_glUniform2fARB; iARB;
PFNGLUNIFORM3FARBPROC pglUniform3fARB=_Lazy_glUniform3fARB; #endif
PFNGLUNIFORM4FARBPROC pglUniform4fARB=_Lazy_glUniform4fARB; #ifndef GLEE_C_DEFINED_glUniform2iARB
PFNGLUNIFORM1IARBPROC pglUniform1iARB=_Lazy_glUniform1iARB; #define GLEE_C_DEFINED_glUniform2iARB
PFNGLUNIFORM2IARBPROC pglUniform2iARB=_Lazy_glUniform2iARB; void __stdcall GLee_Lazy_glUniform2iARB(GLint location, GLint v0, GLint v
PFNGLUNIFORM3IARBPROC pglUniform3iARB=_Lazy_glUniform3iARB; 1) {if (GLeeInit()) glUniform2iARB(location, v0, v1);}
PFNGLUNIFORM4IARBPROC pglUniform4iARB=_Lazy_glUniform4iARB; GLEEPFNGLUNIFORM2IARBPROC GLeeFuncPtr_glUniform2iARB=GLee_Lazy_glUniform2
PFNGLUNIFORM1FVARBPROC pglUniform1fvARB=_Lazy_glUniform1fvARB; iARB;
PFNGLUNIFORM2FVARBPROC pglUniform2fvARB=_Lazy_glUniform2fvARB; #endif
PFNGLUNIFORM3FVARBPROC pglUniform3fvARB=_Lazy_glUniform3fvARB; #ifndef GLEE_C_DEFINED_glUniform3iARB
PFNGLUNIFORM4FVARBPROC pglUniform4fvARB=_Lazy_glUniform4fvARB; #define GLEE_C_DEFINED_glUniform3iARB
PFNGLUNIFORM1IVARBPROC pglUniform1ivARB=_Lazy_glUniform1ivARB; void __stdcall GLee_Lazy_glUniform3iARB(GLint location, GLint v0, GLint v
PFNGLUNIFORM2IVARBPROC pglUniform2ivARB=_Lazy_glUniform2ivARB; 1, GLint v2) {if (GLeeInit()) glUniform3iARB(location, v0, v1, v2);}
PFNGLUNIFORM3IVARBPROC pglUniform3ivARB=_Lazy_glUniform3ivARB; GLEEPFNGLUNIFORM3IARBPROC GLeeFuncPtr_glUniform3iARB=GLee_Lazy_glUniform3
PFNGLUNIFORM4IVARBPROC pglUniform4ivARB=_Lazy_glUniform4ivARB; iARB;
PFNGLUNIFORMMATRIX2FVARBPROC pglUniformMatrix2fvARB=_Lazy_glUniformMatrix2f #endif
vARB; #ifndef GLEE_C_DEFINED_glUniform4iARB
PFNGLUNIFORMMATRIX3FVARBPROC pglUniformMatrix3fvARB=_Lazy_glUniformMatrix3f #define GLEE_C_DEFINED_glUniform4iARB
vARB; void __stdcall GLee_Lazy_glUniform4iARB(GLint location, GLint v0, GLint v
PFNGLUNIFORMMATRIX4FVARBPROC pglUniformMatrix4fvARB=_Lazy_glUniformMatrix4f 1, GLint v2, GLint v3) {if (GLeeInit()) glUniform4iARB(location, v0, v1, v
vARB; 2, v3);}
PFNGLGETOBJECTPARAMETERFVARBPROC pglGetObjectParameterfvARB=_Lazy_glGetObje GLEEPFNGLUNIFORM4IARBPROC GLeeFuncPtr_glUniform4iARB=GLee_Lazy_glUniform4
ctParameterfvARB; iARB;
PFNGLGETOBJECTPARAMETERIVARBPROC pglGetObjectParameterivARB=_Lazy_glGetObje #endif
ctParameterivARB; #ifndef GLEE_C_DEFINED_glUniform1fvARB
PFNGLGETINFOLOGARBPROC pglGetInfoLogARB=_Lazy_glGetInfoLogARB; #define GLEE_C_DEFINED_glUniform1fvARB
PFNGLGETATTACHEDOBJECTSARBPROC pglGetAttachedObjectsARB=_Lazy_glGetAttached void __stdcall GLee_Lazy_glUniform1fvARB(GLint location, GLsizei count, c
ObjectsARB; onst GLfloat * value) {if (GLeeInit()) glUniform1fvARB(location, count, va
PFNGLGETUNIFORMLOCATIONARBPROC pglGetUniformLocationARB=_Lazy_glGetUniformL lue);}
ocationARB; GLEEPFNGLUNIFORM1FVARBPROC GLeeFuncPtr_glUniform1fvARB=GLee_Lazy_glUnifor
PFNGLGETACTIVEUNIFORMARBPROC pglGetActiveUniformARB=_Lazy_glGetActiveUnifor m1fvARB;
mARB; #endif
PFNGLGETUNIFORMFVARBPROC pglGetUniformfvARB=_Lazy_glGetUniformfvARB; #ifndef GLEE_C_DEFINED_glUniform2fvARB
PFNGLGETUNIFORMIVARBPROC pglGetUniformivARB=_Lazy_glGetUniformivARB; #define GLEE_C_DEFINED_glUniform2fvARB
PFNGLGETSHADERSOURCEARBPROC pglGetShaderSourceARB=_Lazy_glGetShaderSourceAR void __stdcall GLee_Lazy_glUniform2fvARB(GLint location, GLsizei count, c
B; onst GLfloat * value) {if (GLeeInit()) glUniform2fvARB(location, count, va
lue);}
GLEEPFNGLUNIFORM2FVARBPROC GLeeFuncPtr_glUniform2fvARB=GLee_Lazy_glUnifor
m2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fvARB
#define GLEE_C_DEFINED_glUniform3fvARB
void __stdcall GLee_Lazy_glUniform3fvARB(GLint location, GLsizei count, c
onst GLfloat * value) {if (GLeeInit()) glUniform3fvARB(location, count, va
lue);}
GLEEPFNGLUNIFORM3FVARBPROC GLeeFuncPtr_glUniform3fvARB=GLee_Lazy_glUnifor
m3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fvARB
#define GLEE_C_DEFINED_glUniform4fvARB
void __stdcall GLee_Lazy_glUniform4fvARB(GLint location, GLsizei count, c
onst GLfloat * value) {if (GLeeInit()) glUniform4fvARB(location, count, va
lue);}
GLEEPFNGLUNIFORM4FVARBPROC GLeeFuncPtr_glUniform4fvARB=GLee_Lazy_glUnifor
m4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1ivARB
#define GLEE_C_DEFINED_glUniform1ivARB
void __stdcall GLee_Lazy_glUniform1ivARB(GLint location, GLsizei count, c
onst GLint * value) {if (GLeeInit()) glUniform1ivARB(location, count, valu
e);}
GLEEPFNGLUNIFORM1IVARBPROC GLeeFuncPtr_glUniform1ivARB=GLee_Lazy_glUnifor
m1ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2ivARB
#define GLEE_C_DEFINED_glUniform2ivARB
void __stdcall GLee_Lazy_glUniform2ivARB(GLint location, GLsizei count, c
onst GLint * value) {if (GLeeInit()) glUniform2ivARB(location, count, valu
e);}
GLEEPFNGLUNIFORM2IVARBPROC GLeeFuncPtr_glUniform2ivARB=GLee_Lazy_glUnifor
m2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3ivARB
#define GLEE_C_DEFINED_glUniform3ivARB
void __stdcall GLee_Lazy_glUniform3ivARB(GLint location, GLsizei count, c
onst GLint * value) {if (GLeeInit()) glUniform3ivARB(location, count, valu
e);}
GLEEPFNGLUNIFORM3IVARBPROC GLeeFuncPtr_glUniform3ivARB=GLee_Lazy_glUnifor
m3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4ivARB
#define GLEE_C_DEFINED_glUniform4ivARB
void __stdcall GLee_Lazy_glUniform4ivARB(GLint location, GLsizei count, c
onst GLint * value) {if (GLeeInit()) glUniform4ivARB(location, count, valu
e);}
GLEEPFNGLUNIFORM4IVARBPROC GLeeFuncPtr_glUniform4ivARB=GLee_Lazy_glUnifor
m4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2fvARB
#define GLEE_C_DEFINED_glUniformMatrix2fvARB
void __stdcall GLee_Lazy_glUniformMatrix2fvARB(GLint location, GLsizei co
unt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUnifor
mMatrix2fvARB(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX2FVARBPROC GLeeFuncPtr_glUniformMatrix2fvARB=GLee_L
azy_glUniformMatrix2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3fvARB
#define GLEE_C_DEFINED_glUniformMatrix3fvARB
void __stdcall GLee_Lazy_glUniformMatrix3fvARB(GLint location, GLsizei co
unt, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUnifor
mMatrix3fvARB(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3FVARBPROC GLeeFuncPtr_glUniformMatrix3fvARB=GLee_L
azy_glUniformMatrix3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4fvARB
#define GLEE_C_DEFINED_glUniformMatrix4fvARB
void __stdcall GLee_Lazy_glUniformMatrix4