From 163b963b1d6c1d0d288e27aeb978ff521a241917 Mon Sep 17 00:00:00 2001 From: Kyle K Date: Sun, 3 Oct 2010 18:30:04 -0500 Subject: Initial commit --- Makefile | 37 + lib/GLee.c | 18170 +++++++++++++++++++++++++++++++++++++++++++++++++ lib/GLee.h | 17647 +++++++++++++++++++++++++++++++++++++++++++++++ lib/TriangleMesh.cpp | 154 + lib/TriangleMesh.h | 63 + lib/VBOMesh.cpp | 208 + lib/VBOMesh.h | 64 + lib/glframe.h | 412 ++ lib/glfrustum.h | 217 + lib/gltools.cpp | 651 ++ lib/gltools.h | 162 + lib/glut.h | 22 + lib/math3d.cpp | 1062 +++ lib/math3d.h | 610 ++ lib/stopwatch.h | 77 + pyramid.cpp | 372 + stone.tga | Bin 0 -> 196652 bytes todo.txt | 2 + 18 files changed, 39930 insertions(+) create mode 100644 Makefile create mode 100755 lib/GLee.c create mode 100755 lib/GLee.h create mode 100644 lib/TriangleMesh.cpp create mode 100644 lib/TriangleMesh.h create mode 100644 lib/VBOMesh.cpp create mode 100644 lib/VBOMesh.h create mode 100644 lib/glframe.h create mode 100644 lib/glfrustum.h create mode 100644 lib/gltools.cpp create mode 100644 lib/gltools.h create mode 100644 lib/glut.h create mode 100644 lib/math3d.cpp create mode 100644 lib/math3d.h create mode 100644 lib/stopwatch.h create mode 100644 pyramid.cpp create mode 100644 stone.tga create mode 100644 todo.txt diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5da8212 --- /dev/null +++ b/Makefile @@ -0,0 +1,37 @@ +PROG = pyramid +OBJS = $(PROG).o ./lib/math3d.o ./lib/gltools.o ./lib/TriangleMesh.o ./lib/VBOMesh.o +CC = g++ +DBGFLAGS = -g -O0 +ifdef DEBUG + CFLAGS = $(DBGFLAGS) -Wall +else + CFLAGS = -Wall -O2 -march=native -mtune=native +endif +LDFLAGS = -lGLEW -lGL -lGLU -lm -lglut +SDL_CFLAGS := $(shell sdl-config --cflags) +SDL_LDFLAGS := $(shell sdl-config --libs) +SDL_image_CFLAGS := $(shell pkg-config --cflags SDL_image) +SDL_image_LDFLAGS := $(shell pkg-config --libs SDL_image) + +$(PROG): $(OBJS) + $(CC) $(LDFLAGS) $(SDL_LDFLAGS) $(SDL_image_LDFLAGS) $(OBJS) -o $(PROG) + +$(PROG).o: $(PROG).cpp + $(CC) -c $(CFLAGS) $(SDL_CFLAGS) $(SDL_image_CFLAGS) $(PROG).cpp + +math3d.o: math3d.cpp + $(CC) -c $(CFLAGS) math3d.cpp + +gltools.o: gltools.cpp + $(CC) -c $(CFLAGS) ./lib/gltools.cpp + +TriangleMesh.o: TriangleMesh.cpp + $(CC) -c $(CFLAGS) ./lib/TriangleMesh.cpp + +VBOMesh.o: VBOMesh.cpp + $(CC) -c $(CFLAGS) ./lib/VBOMesh.cpp + +.PHONY: clean + +clean: + rm -f *.o ./$(PROG) ./lib/*.o diff --git a/lib/GLee.c b/lib/GLee.c new file mode 100755 index 0000000..b89fae6 --- /dev/null +++ b/lib/GLee.c @@ -0,0 +1,18170 @@ +/*************************************************************************** +* +* GLee.c +* GLee (OpenGL Easy Extension library) +* Version : 5.4 +* +* Copyright (c)2009 Ben Woodhouse All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are +* met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer as +* the first lines of this file unmodified. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY BEN WOODHOUSE ``AS IS'' AND ANY EXPRESS OR +* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL BEN WOODHOUSE BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +* Web: http://elf-stone.com/glee.php +* +* [This file was automatically generated by GLeeGen 7.0 +* +***************************************************************************/ + +#ifdef _MSC_VER + #pragma optimize( "g", off ) +#endif + +#include +#include +#include +#include "GLee.h" + +#if defined(__APPLE__) || defined(__APPLE_CC__) + #include +#endif + +typedef GLuint(*GLEE_LINK_FUNCTION)(void); + +GLboolean __GLeeInited=GL_FALSE; + +#ifndef _WIN32 + #define __stdcall /* nothing */ +#endif + +void * __GLeeGetProcAddress(const char *extname) +{ +#ifdef WIN32 + return (void*)wglGetProcAddress(extname); +#elif defined(__APPLE__) || defined(__APPLE_CC__) + CFBundleRef bundle; + CFURLRef bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, true); + + CFStringRef functionName = CFStringCreateWithCString(kCFAllocatorDefault, extname, kCFStringEncodingASCII); + + void *function; + + bundle = CFBundleCreate(kCFAllocatorDefault, bundleURL); + assert(bundle != NULL); + + function = CFBundleGetFunctionPointerForName(bundle, functionName); + + CFRelease(bundleURL); + CFRelease(functionName); + CFRelease(bundle); + + return function; +#else + return (void*)glXGetProcAddressARB((const GLubyte *)extname); +#endif +} + + + + +/* Extension querying variables */ + +GLboolean _GLEE_VERSION_1_2 = GL_FALSE; +GLboolean _GLEE_ARB_imaging = GL_FALSE; +GLboolean _GLEE_VERSION_1_3 = GL_FALSE; +GLboolean _GLEE_VERSION_1_4 = GL_FALSE; +GLboolean _GLEE_VERSION_1_5 = GL_FALSE; +GLboolean _GLEE_VERSION_2_0 = GL_FALSE; +GLboolean _GLEE_VERSION_2_1 = GL_FALSE; +GLboolean _GLEE_VERSION_3_0 = GL_FALSE; +GLboolean _GLEE_ARB_multitexture = GL_FALSE; +GLboolean _GLEE_ARB_transpose_matrix = GL_FALSE; +GLboolean _GLEE_ARB_multisample = GL_FALSE; +GLboolean _GLEE_ARB_texture_env_add = GL_FALSE; +GLboolean _GLEE_ARB_texture_cube_map = GL_FALSE; +GLboolean _GLEE_ARB_texture_compression = GL_FALSE; +GLboolean _GLEE_ARB_texture_border_clamp = GL_FALSE; +GLboolean _GLEE_ARB_point_parameters = GL_FALSE; +GLboolean _GLEE_ARB_vertex_blend = GL_FALSE; +GLboolean _GLEE_ARB_matrix_palette = GL_FALSE; +GLboolean _GLEE_ARB_texture_env_combine = GL_FALSE; +GLboolean _GLEE_ARB_texture_env_crossbar = GL_FALSE; +GLboolean _GLEE_ARB_texture_env_dot3 = GL_FALSE; +GLboolean _GLEE_ARB_texture_mirrored_repeat = GL_FALSE; +GLboolean _GLEE_ARB_depth_texture = GL_FALSE; +GLboolean _GLEE_ARB_shadow = GL_FALSE; +GLboolean _GLEE_ARB_shadow_ambient = GL_FALSE; +GLboolean _GLEE_ARB_window_pos = GL_FALSE; +GLboolean _GLEE_ARB_vertex_program = GL_FALSE; +GLboolean _GLEE_ARB_fragment_program = GL_FALSE; +GLboolean _GLEE_ARB_vertex_buffer_object = GL_FALSE; +GLboolean _GLEE_ARB_occlusion_query = GL_FALSE; +GLboolean _GLEE_ARB_shader_objects = GL_FALSE; +GLboolean _GLEE_ARB_vertex_shader = GL_FALSE; +GLboolean _GLEE_ARB_fragment_shader = GL_FALSE; +GLboolean _GLEE_ARB_shading_language_100 = GL_FALSE; +GLboolean _GLEE_ARB_texture_non_power_of_two = GL_FALSE; +GLboolean _GLEE_ARB_point_sprite = GL_FALSE; +GLboolean _GLEE_ARB_fragment_program_shadow = GL_FALSE; +GLboolean _GLEE_ARB_draw_buffers = GL_FALSE; +GLboolean _GLEE_ARB_texture_rectangle = GL_FALSE; +GLboolean _GLEE_ARB_color_buffer_float = GL_FALSE; +GLboolean _GLEE_ARB_half_float_pixel = GL_FALSE; +GLboolean _GLEE_ARB_texture_float = GL_FALSE; +GLboolean _GLEE_ARB_pixel_buffer_object = GL_FALSE; +GLboolean _GLEE_ARB_depth_buffer_float = GL_FALSE; +GLboolean _GLEE_ARB_draw_instanced = GL_FALSE; +GLboolean _GLEE_ARB_framebuffer_object = GL_FALSE; +GLboolean _GLEE_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean _GLEE_ARB_geometry_shader4 = GL_FALSE; +GLboolean _GLEE_ARB_half_float_vertex = GL_FALSE; +GLboolean _GLEE_ARB_instanced_arrays = GL_FALSE; +GLboolean _GLEE_ARB_map_buffer_range = GL_FALSE; +GLboolean _GLEE_ARB_texture_buffer_object = GL_FALSE; +GLboolean _GLEE_ARB_texture_compression_rgtc = GL_FALSE; +GLboolean _GLEE_ARB_texture_rg = GL_FALSE; +GLboolean _GLEE_ARB_vertex_array_object = GL_FALSE; +GLboolean _GLEE_EXT_abgr = GL_FALSE; +GLboolean _GLEE_EXT_blend_color = GL_FALSE; +GLboolean _GLEE_EXT_polygon_offset = GL_FALSE; +GLboolean _GLEE_EXT_texture = GL_FALSE; +GLboolean _GLEE_EXT_texture3D = GL_FALSE; +GLboolean _GLEE_SGIS_texture_filter4 = GL_FALSE; +GLboolean _GLEE_EXT_subtexture = GL_FALSE; +GLboolean _GLEE_EXT_copy_texture = GL_FALSE; +GLboolean _GLEE_EXT_histogram = GL_FALSE; +GLboolean _GLEE_EXT_convolution = GL_FALSE; +GLboolean _GLEE_SGI_color_matrix = GL_FALSE; +GLboolean _GLEE_SGI_color_table = GL_FALSE; +GLboolean _GLEE_SGIS_pixel_texture = GL_FALSE; +GLboolean _GLEE_SGIX_pixel_texture = GL_FALSE; +GLboolean _GLEE_SGIS_texture4D = GL_FALSE; +GLboolean _GLEE_SGI_texture_color_table = GL_FALSE; +GLboolean _GLEE_EXT_cmyka = GL_FALSE; +GLboolean _GLEE_EXT_texture_object = GL_FALSE; +GLboolean _GLEE_SGIS_detail_texture = GL_FALSE; +GLboolean _GLEE_SGIS_sharpen_texture = GL_FALSE; +GLboolean _GLEE_EXT_packed_pixels = GL_FALSE; +GLboolean _GLEE_SGIS_texture_lod = GL_FALSE; +GLboolean _GLEE_SGIS_multisample = GL_FALSE; +GLboolean _GLEE_EXT_rescale_normal = GL_FALSE; +GLboolean _GLEE_EXT_vertex_array = GL_FALSE; +GLboolean _GLEE_EXT_misc_attribute = GL_FALSE; +GLboolean _GLEE_SGIS_generate_mipmap = GL_FALSE; +GLboolean _GLEE_SGIX_clipmap = GL_FALSE; +GLboolean _GLEE_SGIX_shadow = GL_FALSE; +GLboolean _GLEE_SGIS_texture_edge_clamp = GL_FALSE; +GLboolean _GLEE_SGIS_texture_border_clamp = GL_FALSE; +GLboolean _GLEE_EXT_blend_minmax = GL_FALSE; +GLboolean _GLEE_EXT_blend_subtract = GL_FALSE; +GLboolean _GLEE_EXT_blend_logic_op = GL_FALSE; +GLboolean _GLEE_SGIX_interlace = GL_FALSE; +GLboolean _GLEE_SGIX_pixel_tiles = GL_FALSE; +GLboolean _GLEE_SGIS_texture_select = GL_FALSE; +GLboolean _GLEE_SGIX_sprite = GL_FALSE; +GLboolean _GLEE_SGIX_texture_multi_buffer = GL_FALSE; +GLboolean _GLEE_EXT_point_parameters = GL_FALSE; +GLboolean _GLEE_SGIS_point_parameters = GL_FALSE; +GLboolean _GLEE_SGIX_instruments = GL_FALSE; +GLboolean _GLEE_SGIX_texture_scale_bias = GL_FALSE; +GLboolean _GLEE_SGIX_framezoom = GL_FALSE; +GLboolean _GLEE_SGIX_tag_sample_buffer = GL_FALSE; +GLboolean _GLEE_FfdMaskSGIX = GL_FALSE; +GLboolean _GLEE_SGIX_polynomial_ffd = GL_FALSE; +GLboolean _GLEE_SGIX_reference_plane = GL_FALSE; +GLboolean _GLEE_SGIX_flush_raster = GL_FALSE; +GLboolean _GLEE_SGIX_depth_texture = GL_FALSE; +GLboolean _GLEE_SGIS_fog_function = GL_FALSE; +GLboolean _GLEE_SGIX_fog_offset = GL_FALSE; +GLboolean _GLEE_HP_image_transform = GL_FALSE; +GLboolean _GLEE_HP_convolution_border_modes = GL_FALSE; +GLboolean _GLEE_INGR_palette_buffer = GL_FALSE; +GLboolean _GLEE_SGIX_texture_add_env = GL_FALSE; +GLboolean _GLEE_EXT_color_subtable = GL_FALSE; +GLboolean _GLEE_PGI_vertex_hints = GL_FALSE; +GLboolean _GLEE_PGI_misc_hints = GL_FALSE; +GLboolean _GLEE_EXT_paletted_texture = GL_FALSE; +GLboolean _GLEE_EXT_clip_volume_hint = GL_FALSE; +GLboolean _GLEE_SGIX_list_priority = GL_FALSE; +GLboolean _GLEE_SGIX_ir_instrument1 = GL_FALSE; +GLboolean _GLEE_SGIX_calligraphic_fragment = GL_FALSE; +GLboolean _GLEE_SGIX_texture_lod_bias = GL_FALSE; +GLboolean _GLEE_SGIX_shadow_ambient = GL_FALSE; +GLboolean _GLEE_EXT_index_texture = GL_FALSE; +GLboolean _GLEE_EXT_index_material = GL_FALSE; +GLboolean _GLEE_EXT_index_func = GL_FALSE; +GLboolean _GLEE_EXT_index_array_formats = GL_FALSE; +GLboolean _GLEE_EXT_compiled_vertex_array = GL_FALSE; +GLboolean _GLEE_EXT_cull_vertex = GL_FALSE; +GLboolean _GLEE_SGIX_ycrcb = GL_FALSE; +GLboolean _GLEE_SGIX_fragment_lighting = GL_FALSE; +GLboolean _GLEE_IBM_rasterpos_clip = GL_FALSE; +GLboolean _GLEE_HP_texture_lighting = GL_FALSE; +GLboolean _GLEE_EXT_draw_range_elements = GL_FALSE; +GLboolean _GLEE_WIN_phong_shading = GL_FALSE; +GLboolean _GLEE_WIN_specular_fog = GL_FALSE; +GLboolean _GLEE_EXT_light_texture = GL_FALSE; +GLboolean _GLEE_SGIX_blend_alpha_minmax = GL_FALSE; +GLboolean _GLEE_SGIX_impact_pixel_texture = GL_FALSE; +GLboolean _GLEE_EXT_bgra = GL_FALSE; +GLboolean _GLEE_SGIX_async = GL_FALSE; +GLboolean _GLEE_SGIX_async_pixel = GL_FALSE; +GLboolean _GLEE_SGIX_async_histogram = GL_FALSE; +GLboolean _GLEE_INTEL_texture_scissor = GL_FALSE; +GLboolean _GLEE_INTEL_parallel_arrays = GL_FALSE; +GLboolean _GLEE_HP_occlusion_test = GL_FALSE; +GLboolean _GLEE_EXT_pixel_transform = GL_FALSE; +GLboolean _GLEE_EXT_pixel_transform_color_table = GL_FALSE; +GLboolean _GLEE_EXT_shared_texture_palette = GL_FALSE; +GLboolean _GLEE_EXT_separate_specular_color = GL_FALSE; +GLboolean _GLEE_EXT_secondary_color = GL_FALSE; +GLboolean _GLEE_EXT_texture_perturb_normal = GL_FALSE; +GLboolean _GLEE_EXT_multi_draw_arrays = GL_FALSE; +GLboolean _GLEE_EXT_fog_coord = GL_FALSE; +GLboolean _GLEE_REND_screen_coordinates = GL_FALSE; +GLboolean _GLEE_EXT_coordinate_frame = GL_FALSE; +GLboolean _GLEE_EXT_texture_env_combine = GL_FALSE; +GLboolean _GLEE_APPLE_specular_vector = GL_FALSE; +GLboolean _GLEE_APPLE_transform_hint = GL_FALSE; +GLboolean _GLEE_SGIX_fog_scale = GL_FALSE; +GLboolean _GLEE_SUNX_constant_data = GL_FALSE; +GLboolean _GLEE_SUN_global_alpha = GL_FALSE; +GLboolean _GLEE_SUN_triangle_list = GL_FALSE; +GLboolean _GLEE_SUN_vertex = GL_FALSE; +GLboolean _GLEE_EXT_blend_func_separate = GL_FALSE; +GLboolean _GLEE_INGR_color_clamp = GL_FALSE; +GLboolean _GLEE_INGR_interlace_read = GL_FALSE; +GLboolean _GLEE_EXT_stencil_wrap = GL_FALSE; +GLboolean _GLEE_EXT_422_pixels = GL_FALSE; +GLboolean _GLEE_NV_texgen_reflection = GL_FALSE; +GLboolean _GLEE_EXT_texture_cube_map = GL_FALSE; +GLboolean _GLEE_SUN_convolution_border_modes = GL_FALSE; +GLboolean _GLEE_EXT_texture_env_add = GL_FALSE; +GLboolean _GLEE_EXT_texture_lod_bias = GL_FALSE; +GLboolean _GLEE_EXT_texture_filter_anisotropic = GL_FALSE; +GLboolean _GLEE_EXT_vertex_weighting = GL_FALSE; +GLboolean _GLEE_NV_light_max_exponent = GL_FALSE; +GLboolean _GLEE_NV_vertex_array_range = GL_FALSE; +GLboolean _GLEE_NV_register_combiners = GL_FALSE; +GLboolean _GLEE_NV_fog_distance = GL_FALSE; +GLboolean _GLEE_NV_texgen_emboss = GL_FALSE; +GLboolean _GLEE_NV_blend_square = GL_FALSE; +GLboolean _GLEE_NV_texture_env_combine4 = GL_FALSE; +GLboolean _GLEE_MESA_resize_buffers = GL_FALSE; +GLboolean _GLEE_MESA_window_pos = GL_FALSE; +GLboolean _GLEE_EXT_texture_compression_s3tc = GL_FALSE; +GLboolean _GLEE_IBM_cull_vertex = GL_FALSE; +GLboolean _GLEE_IBM_multimode_draw_arrays = GL_FALSE; +GLboolean _GLEE_IBM_vertex_array_lists = GL_FALSE; +GLboolean _GLEE_SGIX_subsample = GL_FALSE; +GLboolean _GLEE_SGIX_ycrcb_subsample = GL_FALSE; +GLboolean _GLEE_SGIX_ycrcba = GL_FALSE; +GLboolean _GLEE_SGI_depth_pass_instrument = GL_FALSE; +GLboolean _GLEE_3DFX_texture_compression_FXT1 = GL_FALSE; +GLboolean _GLEE_3DFX_multisample = GL_FALSE; +GLboolean _GLEE_3DFX_tbuffer = GL_FALSE; +GLboolean _GLEE_EXT_multisample = GL_FALSE; +GLboolean _GLEE_SGIX_vertex_preclip = GL_FALSE; +GLboolean _GLEE_SGIX_convolution_accuracy = GL_FALSE; +GLboolean _GLEE_SGIX_resample = GL_FALSE; +GLboolean _GLEE_SGIS_point_line_texgen = GL_FALSE; +GLboolean _GLEE_SGIS_texture_color_mask = GL_FALSE; +GLboolean _GLEE_EXT_texture_env_dot3 = GL_FALSE; +GLboolean _GLEE_ATI_texture_mirror_once = GL_FALSE; +GLboolean _GLEE_NV_fence = GL_FALSE; +GLboolean _GLEE_IBM_texture_mirrored_repeat = GL_FALSE; +GLboolean _GLEE_NV_evaluators = GL_FALSE; +GLboolean _GLEE_NV_packed_depth_stencil = GL_FALSE; +GLboolean _GLEE_NV_register_combiners2 = GL_FALSE; +GLboolean _GLEE_NV_texture_compression_vtc = GL_FALSE; +GLboolean _GLEE_NV_texture_rectangle = GL_FALSE; +GLboolean _GLEE_NV_texture_shader = GL_FALSE; +GLboolean _GLEE_NV_texture_shader2 = GL_FALSE; +GLboolean _GLEE_NV_vertex_array_range2 = GL_FALSE; +GLboolean _GLEE_NV_vertex_program = GL_FALSE; +GLboolean _GLEE_SGIX_texture_coordinate_clamp = GL_FALSE; +GLboolean _GLEE_SGIX_scalebias_hint = GL_FALSE; +GLboolean _GLEE_OML_interlace = GL_FALSE; +GLboolean _GLEE_OML_subsample = GL_FALSE; +GLboolean _GLEE_OML_resample = GL_FALSE; +GLboolean _GLEE_NV_copy_depth_to_color = GL_FALSE; +GLboolean _GLEE_ATI_envmap_bumpmap = GL_FALSE; +GLboolean _GLEE_ATI_fragment_shader = GL_FALSE; +GLboolean _GLEE_ATI_pn_triangles = GL_FALSE; +GLboolean _GLEE_ATI_vertex_array_object = GL_FALSE; +GLboolean _GLEE_EXT_vertex_shader = GL_FALSE; +GLboolean _GLEE_ATI_vertex_streams = GL_FALSE; +GLboolean _GLEE_ATI_element_array = GL_FALSE; +GLboolean _GLEE_SUN_mesh_array = GL_FALSE; +GLboolean _GLEE_SUN_slice_accum = GL_FALSE; +GLboolean _GLEE_NV_multisample_filter_hint = GL_FALSE; +GLboolean _GLEE_NV_depth_clamp = GL_FALSE; +GLboolean _GLEE_NV_occlusion_query = GL_FALSE; +GLboolean _GLEE_NV_point_sprite = GL_FALSE; +GLboolean _GLEE_NV_texture_shader3 = GL_FALSE; +GLboolean _GLEE_NV_vertex_program1_1 = GL_FALSE; +GLboolean _GLEE_EXT_shadow_funcs = GL_FALSE; +GLboolean _GLEE_EXT_stencil_two_side = GL_FALSE; +GLboolean _GLEE_ATI_text_fragment_shader = GL_FALSE; +GLboolean _GLEE_APPLE_client_storage = GL_FALSE; +GLboolean _GLEE_APPLE_element_array = GL_FALSE; +GLboolean _GLEE_APPLE_fence = GL_FALSE; +GLboolean _GLEE_APPLE_vertex_array_object = GL_FALSE; +GLboolean _GLEE_APPLE_vertex_array_range = GL_FALSE; +GLboolean _GLEE_APPLE_ycbcr_422 = GL_FALSE; +GLboolean _GLEE_S3_s3tc = GL_FALSE; +GLboolean _GLEE_ATI_draw_buffers = GL_FALSE; +GLboolean _GLEE_ATI_pixel_format_float = GL_FALSE; +GLboolean _GLEE_ATI_texture_env_combine3 = GL_FALSE; +GLboolean _GLEE_ATI_texture_float = GL_FALSE; +GLboolean _GLEE_NV_float_buffer = GL_FALSE; +GLboolean _GLEE_NV_fragment_program = GL_FALSE; +GLboolean _GLEE_NV_half_float = GL_FALSE; +GLboolean _GLEE_NV_pixel_data_range = GL_FALSE; +GLboolean _GLEE_NV_primitive_restart = GL_FALSE; +GLboolean _GLEE_NV_texture_expand_normal = GL_FALSE; +GLboolean _GLEE_NV_vertex_program2 = GL_FALSE; +GLboolean _GLEE_ATI_map_object_buffer = GL_FALSE; +GLboolean _GLEE_ATI_separate_stencil = GL_FALSE; +GLboolean _GLEE_ATI_vertex_attrib_array_object = GL_FALSE; +GLboolean _GLEE_OES_read_format = GL_FALSE; +GLboolean _GLEE_EXT_depth_bounds_test = GL_FALSE; +GLboolean _GLEE_EXT_texture_mirror_clamp = GL_FALSE; +GLboolean _GLEE_EXT_blend_equation_separate = GL_FALSE; +GLboolean _GLEE_MESA_pack_invert = GL_FALSE; +GLboolean _GLEE_MESA_ycbcr_texture = GL_FALSE; +GLboolean _GLEE_EXT_pixel_buffer_object = GL_FALSE; +GLboolean _GLEE_NV_fragment_program_option = GL_FALSE; +GLboolean _GLEE_NV_fragment_program2 = GL_FALSE; +GLboolean _GLEE_NV_vertex_program2_option = GL_FALSE; +GLboolean _GLEE_NV_vertex_program3 = GL_FALSE; +GLboolean _GLEE_EXT_framebuffer_object = GL_FALSE; +GLboolean _GLEE_GREMEDY_string_marker = GL_FALSE; +GLboolean _GLEE_EXT_packed_depth_stencil = GL_FALSE; +GLboolean _GLEE_EXT_stencil_clear_tag = GL_FALSE; +GLboolean _GLEE_EXT_texture_sRGB = GL_FALSE; +GLboolean _GLEE_EXT_framebuffer_blit = GL_FALSE; +GLboolean _GLEE_EXT_framebuffer_multisample = GL_FALSE; +GLboolean _GLEE_MESAX_texture_stack = GL_FALSE; +GLboolean _GLEE_EXT_timer_query = GL_FALSE; +GLboolean _GLEE_EXT_gpu_program_parameters = GL_FALSE; +GLboolean _GLEE_APPLE_flush_buffer_range = GL_FALSE; +GLboolean _GLEE_EXT_gpu_shader4 = GL_FALSE; +GLboolean _GLEE_EXT_draw_instanced = GL_FALSE; +GLboolean _GLEE_EXT_packed_float = GL_FALSE; +GLboolean _GLEE_EXT_texture_array = GL_FALSE; +GLboolean _GLEE_EXT_texture_buffer_object = GL_FALSE; +GLboolean _GLEE_EXT_texture_compression_latc = GL_FALSE; +GLboolean _GLEE_EXT_texture_compression_rgtc = GL_FALSE; +GLboolean _GLEE_EXT_texture_shared_exponent = GL_FALSE; +GLboolean _GLEE_NV_depth_buffer_float = GL_FALSE; +GLboolean _GLEE_NV_framebuffer_multisample_coverage = GL_FALSE; +GLboolean _GLEE_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean _GLEE_NV_geometry_shader4 = GL_FALSE; +GLboolean _GLEE_NV_parameter_buffer_object = GL_FALSE; +GLboolean _GLEE_EXT_draw_buffers2 = GL_FALSE; +GLboolean _GLEE_NV_transform_feedback = GL_FALSE; +GLboolean _GLEE_EXT_bindable_uniform = GL_FALSE; +GLboolean _GLEE_EXT_texture_integer = GL_FALSE; +GLboolean _GLEE_GREMEDY_frame_terminator = GL_FALSE; +GLboolean _GLEE_NV_conditional_render = GL_FALSE; +GLboolean _GLEE_NV_present_video = GL_FALSE; +GLboolean _GLEE_EXT_transform_feedback = GL_FALSE; +GLboolean _GLEE_EXT_direct_state_access = 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_INGR_blend_func_separate = GL_FALSE; +GLboolean _GLEE_SGIX_depth_pass_instrument = GL_FALSE; +GLboolean _GLEE_SGIX_igloo_interface = 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_texture_compression_dxt1 = GL_FALSE; +GLboolean _GLEE_EXT_texture_env = 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_compressed_paletted_texture = GL_FALSE; +GLboolean _GLEE_OES_single_precision = GL_FALSE; +GLboolean _GLEE_SGIX_pixel_texture_bits = GL_FALSE; +GLboolean _GLEE_SGIX_texture_range = GL_FALSE; + +/* GL Extension names */ + +char __GLeeGLExtensionNames[322][39]={ + "GL_VERSION_1_2", + "GL_ARB_imaging", + "GL_VERSION_1_3", + "GL_VERSION_1_4", + "GL_VERSION_1_5", + "GL_VERSION_2_0", + "GL_VERSION_2_1", + "GL_VERSION_3_0", + "GL_ARB_multitexture", + "GL_ARB_transpose_matrix", + "GL_ARB_multisample", + "GL_ARB_texture_env_add", + "GL_ARB_texture_cube_map", + "GL_ARB_texture_compression", + "GL_ARB_texture_border_clamp", + "GL_ARB_point_parameters", + "GL_ARB_vertex_blend", + "GL_ARB_matrix_palette", + "GL_ARB_texture_env_combine", + "GL_ARB_texture_env_crossbar", + "GL_ARB_texture_env_dot3", + "GL_ARB_texture_mirrored_repeat", + "GL_ARB_depth_texture", + "GL_ARB_shadow", + "GL_ARB_shadow_ambient", + "GL_ARB_window_pos", + "GL_ARB_vertex_program", + "GL_ARB_fragment_program", + "GL_ARB_vertex_buffer_object", + "GL_ARB_occlusion_query", + "GL_ARB_shader_objects", + "GL_ARB_vertex_shader", + "GL_ARB_fragment_shader", + "GL_ARB_shading_language_100", + "GL_ARB_texture_non_power_of_two", + "GL_ARB_point_sprite", + "GL_ARB_fragment_program_shadow", + "GL_ARB_draw_buffers", + "GL_ARB_texture_rectangle", + "GL_ARB_color_buffer_float", + "GL_ARB_half_float_pixel", + "GL_ARB_texture_float", + "GL_ARB_pixel_buffer_object", + "GL_ARB_depth_buffer_float", + "GL_ARB_draw_instanced", + "GL_ARB_framebuffer_object", + "GL_ARB_framebuffer_sRGB", + "GL_ARB_geometry_shader4", + "GL_ARB_half_float_vertex", + "GL_ARB_instanced_arrays", + "GL_ARB_map_buffer_range", + "GL_ARB_texture_buffer_object", + "GL_ARB_texture_compression_rgtc", + "GL_ARB_texture_rg", + "GL_ARB_vertex_array_object", + "GL_EXT_abgr", + "GL_EXT_blend_color", + "GL_EXT_polygon_offset", + "GL_EXT_texture", + "GL_EXT_texture3D", + "GL_SGIS_texture_filter4", + "GL_EXT_subtexture", + "GL_EXT_copy_texture", + "GL_EXT_histogram", + "GL_EXT_convolution", + "GL_SGI_color_matrix", + "GL_SGI_color_table", + "GL_SGIS_pixel_texture", + "GL_SGIX_pixel_texture", + "GL_SGIS_texture4D", + "GL_SGI_texture_color_table", + "GL_EXT_cmyka", + "GL_EXT_texture_object", + "GL_SGIS_detail_texture", + "GL_SGIS_sharpen_texture", + "GL_EXT_packed_pixels", + "GL_SGIS_texture_lod", + "GL_SGIS_multisample", + "GL_EXT_rescale_normal", + "GL_EXT_vertex_array", + "GL_EXT_misc_attribute", + "GL_SGIS_generate_mipmap", + "GL_SGIX_clipmap", + "GL_SGIX_shadow", + "GL_SGIS_texture_edge_clamp", + "GL_SGIS_texture_border_clamp", + "GL_EXT_blend_minmax", + "GL_EXT_blend_subtract", + "GL_EXT_blend_logic_op", + "GL_SGIX_interlace", + "GL_SGIX_pixel_tiles", + "GL_SGIS_texture_select", + "GL_SGIX_sprite", + "GL_SGIX_texture_multi_buffer", + "GL_EXT_point_parameters", + "GL_SGIS_point_parameters", + "GL_SGIX_instruments", + "GL_SGIX_texture_scale_bias", + "GL_SGIX_framezoom", + "GL_SGIX_tag_sample_buffer", + "GL_FfdMaskSGIX", + "GL_SGIX_polynomial_ffd", + "GL_SGIX_reference_plane", + "GL_SGIX_flush_raster", + "GL_SGIX_depth_texture", + "GL_SGIS_fog_function", + "GL_SGIX_fog_offset", + "GL_HP_image_transform", + "GL_HP_convolution_border_modes", + "GL_INGR_palette_buffer", + "GL_SGIX_texture_add_env", + "GL_EXT_color_subtable", + "GL_PGI_vertex_hints", + "GL_PGI_misc_hints", + "GL_EXT_paletted_texture", + "GL_EXT_clip_volume_hint", + "GL_SGIX_list_priority", + "GL_SGIX_ir_instrument1", + "GL_SGIX_calligraphic_fragment", + "GL_SGIX_texture_lod_bias", + "GL_SGIX_shadow_ambient", + "GL_EXT_index_texture", + "GL_EXT_index_material", + "GL_EXT_index_func", + "GL_EXT_index_array_formats", + "GL_EXT_compiled_vertex_array", + "GL_EXT_cull_vertex", + "GL_SGIX_ycrcb", + "GL_SGIX_fragment_lighting", + "GL_IBM_rasterpos_clip", + "GL_HP_texture_lighting", + "GL_EXT_draw_range_elements", + "GL_WIN_phong_shading", + "GL_WIN_specular_fog", + "GL_EXT_light_texture", + "GL_SGIX_blend_alpha_minmax", + "GL_SGIX_impact_pixel_texture", + "GL_EXT_bgra", + "GL_SGIX_async", + "GL_SGIX_async_pixel", + "GL_SGIX_async_histogram", + "GL_INTEL_texture_scissor", + "GL_INTEL_parallel_arrays", + "GL_HP_occlusion_test", + "GL_EXT_pixel_transform", + "GL_EXT_pixel_transform_color_table", + "GL_EXT_shared_texture_palette", + "GL_EXT_separate_specular_color", + "GL_EXT_secondary_color", + "GL_EXT_texture_perturb_normal", + "GL_EXT_multi_draw_arrays", + "GL_EXT_fog_coord", + "GL_REND_screen_coordinates", + "GL_EXT_coordinate_frame", + "GL_EXT_texture_env_combine", + "GL_APPLE_specular_vector", + "GL_APPLE_transform_hint", + "GL_SGIX_fog_scale", + "GL_SUNX_constant_data", + "GL_SUN_global_alpha", + "GL_SUN_triangle_list", + "GL_SUN_vertex", + "GL_EXT_blend_func_separate", + "GL_INGR_color_clamp", + "GL_INGR_interlace_read", + "GL_EXT_stencil_wrap", + "GL_EXT_422_pixels", + "GL_NV_texgen_reflection", + "GL_EXT_texture_cube_map", + "GL_SUN_convolution_border_modes", + "GL_EXT_texture_env_add", + "GL_EXT_texture_lod_bias", + "GL_EXT_texture_filter_anisotropic", + "GL_EXT_vertex_weighting", + "GL_NV_light_max_exponent", + "GL_NV_vertex_array_range", + "GL_NV_register_combiners", + "GL_NV_fog_distance", + "GL_NV_texgen_emboss", + "GL_NV_blend_square", + "GL_NV_texture_env_combine4", + "GL_MESA_resize_buffers", + "GL_MESA_window_pos", + "GL_EXT_texture_compression_s3tc", + "GL_IBM_cull_vertex", + "GL_IBM_multimode_draw_arrays", + "GL_IBM_vertex_array_lists", + "GL_SGIX_subsample", + "GL_SGIX_ycrcb_subsample", + "GL_SGIX_ycrcba", + "GL_SGI_depth_pass_instrument", + "GL_3DFX_texture_compression_FXT1", + "GL_3DFX_multisample", + "GL_3DFX_tbuffer", + "GL_EXT_multisample", + "GL_SGIX_vertex_preclip", + "GL_SGIX_convolution_accuracy", + "GL_SGIX_resample", + "GL_SGIS_point_line_texgen", + "GL_SGIS_texture_color_mask", + "GL_EXT_texture_env_dot3", + "GL_ATI_texture_mirror_once", + "GL_NV_fence", + "GL_IBM_texture_mirrored_repeat", + "GL_NV_evaluators", + "GL_NV_packed_depth_stencil", + "GL_NV_register_combiners2", + "GL_NV_texture_compression_vtc", + "GL_NV_texture_rectangle", + "GL_NV_texture_shader", + "GL_NV_texture_shader2", + "GL_NV_vertex_array_range2", + "GL_NV_vertex_program", + "GL_SGIX_texture_coordinate_clamp", + "GL_SGIX_scalebias_hint", + "GL_OML_interlace", + "GL_OML_subsample", + "GL_OML_resample", + "GL_NV_copy_depth_to_color", + "GL_ATI_envmap_bumpmap", + "GL_ATI_fragment_shader", + "GL_ATI_pn_triangles", + "GL_ATI_vertex_array_object", + "GL_EXT_vertex_shader", + "GL_ATI_vertex_streams", + "GL_ATI_element_array", + "GL_SUN_mesh_array", + "GL_SUN_slice_accum", + "GL_NV_multisample_filter_hint", + "GL_NV_depth_clamp", + "GL_NV_occlusion_query", + "GL_NV_point_sprite", + "GL_NV_texture_shader3", + "GL_NV_vertex_program1_1", + "GL_EXT_shadow_funcs", + "GL_EXT_stencil_two_side", + "GL_ATI_text_fragment_shader", + "GL_APPLE_client_storage", + "GL_APPLE_element_array", + "GL_APPLE_fence", + "GL_APPLE_vertex_array_object", + "GL_APPLE_vertex_array_range", + "GL_APPLE_ycbcr_422", + "GL_S3_s3tc", + "GL_ATI_draw_buffers", + "GL_ATI_pixel_format_float", + "GL_ATI_texture_env_combine3", + "GL_ATI_texture_float", + "GL_NV_float_buffer", + "GL_NV_fragment_program", + "GL_NV_half_float", + "GL_NV_pixel_data_range", + "GL_NV_primitive_restart", + "GL_NV_texture_expand_normal", + "GL_NV_vertex_program2", + "GL_ATI_map_object_buffer", + "GL_ATI_separate_stencil", + "GL_ATI_vertex_attrib_array_object", + "GL_OES_read_format", + "GL_EXT_depth_bounds_test", + "GL_EXT_texture_mirror_clamp", + "GL_EXT_blend_equation_separate", + "GL_MESA_pack_invert", + "GL_MESA_ycbcr_texture", + "GL_EXT_pixel_buffer_object", + "GL_NV_fragment_program_option", + "GL_NV_fragment_program2", + "GL_NV_vertex_program2_option", + "GL_NV_vertex_program3", + "GL_EXT_framebuffer_object", + "GL_GREMEDY_string_marker", + "GL_EXT_packed_depth_stencil", + "GL_EXT_stencil_clear_tag", + "GL_EXT_texture_sRGB", + "GL_EXT_framebuffer_blit", + "GL_EXT_framebuffer_multisample", + "GL_MESAX_texture_stack", + "GL_EXT_timer_query", + "GL_EXT_gpu_program_parameters", + "GL_APPLE_flush_buffer_range", + "GL_EXT_gpu_shader4", + "GL_EXT_draw_instanced", + "GL_EXT_packed_float", + "GL_EXT_texture_array", + "GL_EXT_texture_buffer_object", + "GL_EXT_texture_compression_latc", + "GL_EXT_texture_compression_rgtc", + "GL_EXT_texture_shared_exponent", + "GL_NV_depth_buffer_float", + "GL_NV_framebuffer_multisample_coverage", + "GL_EXT_framebuffer_sRGB", + "GL_NV_geometry_shader4", + "GL_NV_parameter_buffer_object", + "GL_EXT_draw_buffers2", + "GL_NV_transform_feedback", + "GL_EXT_bindable_uniform", + "GL_EXT_texture_integer", + "GL_GREMEDY_frame_terminator", + "GL_NV_conditional_render", + "GL_NV_present_video", + "GL_EXT_transform_feedback", + "GL_EXT_direct_state_access", + "GL_EXT_vertex_array_bgra", + "GL_EXT_texture_swizzle", + "GL_NV_explicit_multisample", + "GL_NV_transform_feedback2", + "GL_SGIX_texture_select", + "GL_INGR_blend_func_separate", + "GL_SGIX_depth_pass_instrument", + "GL_SGIX_igloo_interface", + "GL_EXT_fragment_lighting", + "GL_EXT_geometry_shader4", + "GL_EXT_scene_marker", + "GL_EXT_texture_compression_dxt1", + "GL_EXT_texture_env", + "GL_IBM_static_data", + "GL_NV_gpu_program4", + "GL_OES_byte_coordinates", + "GL_OES_compressed_paletted_texture", + "GL_OES_single_precision", + "GL_SGIX_pixel_texture_bits", + "GL_SGIX_texture_range" +}; +int __GLeeGLNumExtensions=322; + +/* GL_VERSION_1_2 */ + +#ifdef __GLEE_GL_VERSION_1_2 +#ifndef GLEE_C_DEFINED_glBlendColor +#define GLEE_C_DEFINED_glBlendColor + void __stdcall GLee_Lazy_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {if (GLeeInit()) glBlendColor(red, green, blue, alpha);} + GLEEPFNGLBLENDCOLORPROC GLeeFuncPtr_glBlendColor=GLee_Lazy_glBlendColor; +#endif +#ifndef GLEE_C_DEFINED_glBlendEquation +#define GLEE_C_DEFINED_glBlendEquation + void __stdcall GLee_Lazy_glBlendEquation(GLenum mode) {if (GLeeInit()) glBlendEquation(mode);} + GLEEPFNGLBLENDEQUATIONPROC GLeeFuncPtr_glBlendEquation=GLee_Lazy_glBlendEquation; +#endif +#ifndef GLEE_C_DEFINED_glDrawRangeElements +#define GLEE_C_DEFINED_glDrawRangeElements + void __stdcall GLee_Lazy_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) {if (GLeeInit()) glDrawRangeElements(mode, start, end, count, type, indices);} + GLEEPFNGLDRAWRANGEELEMENTSPROC GLeeFuncPtr_glDrawRangeElements=GLee_Lazy_glDrawRangeElements; +#endif +#ifndef GLEE_C_DEFINED_glColorTable +#define GLEE_C_DEFINED_glColorTable + void __stdcall GLee_Lazy_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) {if (GLeeInit()) glColorTable(target, internalformat, width, format, type, table);} + GLEEPFNGLCOLORTABLEPROC GLeeFuncPtr_glColorTable=GLee_Lazy_glColorTable; +#endif +#ifndef GLEE_C_DEFINED_glColorTableParameterfv +#define GLEE_C_DEFINED_glColorTableParameterfv + void __stdcall GLee_Lazy_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glColorTableParameterfv(target, pname, params);} + GLEEPFNGLCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glColorTableParameterfv=GLee_Lazy_glColorTableParameterfv; +#endif +#ifndef GLEE_C_DEFINED_glColorTableParameteriv +#define GLEE_C_DEFINED_glColorTableParameteriv + void __stdcall GLee_Lazy_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glColorTableParameteriv(target, pname, params);} + GLEEPFNGLCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glColorTableParameteriv=GLee_Lazy_glColorTableParameteriv; +#endif +#ifndef GLEE_C_DEFINED_glCopyColorTable +#define GLEE_C_DEFINED_glCopyColorTable + void __stdcall GLee_Lazy_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorTable(target, internalformat, x, y, width);} + GLEEPFNGLCOPYCOLORTABLEPROC GLeeFuncPtr_glCopyColorTable=GLee_Lazy_glCopyColorTable; +#endif +#ifndef GLEE_C_DEFINED_glGetColorTable +#define GLEE_C_DEFINED_glGetColorTable + void __stdcall GLee_Lazy_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table) {if (GLeeInit()) glGetColorTable(target, format, type, table);} + GLEEPFNGLGETCOLORTABLEPROC GLeeFuncPtr_glGetColorTable=GLee_Lazy_glGetColorTable; +#endif +#ifndef GLEE_C_DEFINED_glGetColorTableParameterfv +#define GLEE_C_DEFINED_glGetColorTableParameterfv + void __stdcall GLee_Lazy_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetColorTableParameterfv(target, pname, params);} + GLEEPFNGLGETCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glGetColorTableParameterfv=GLee_Lazy_glGetColorTableParameterfv; +#endif +#ifndef GLEE_C_DEFINED_glGetColorTableParameteriv +#define GLEE_C_DEFINED_glGetColorTableParameteriv + void __stdcall GLee_Lazy_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetColorTableParameteriv(target, pname, params);} + GLEEPFNGLGETCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glGetColorTableParameteriv=GLee_Lazy_glGetColorTableParameteriv; +#endif +#ifndef GLEE_C_DEFINED_glColorSubTable +#define GLEE_C_DEFINED_glColorSubTable + void __stdcall GLee_Lazy_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) {if (GLeeInit()) glColorSubTable(target, start, count, format, type, data);} + GLEEPFNGLCOLORSUBTABLEPROC GLeeFuncPtr_glColorSubTable=GLee_Lazy_glColorSubTable; +#endif +#ifndef GLEE_C_DEFINED_glCopyColorSubTable +#define GLEE_C_DEFINED_glCopyColorSubTable + void __stdcall GLee_Lazy_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorSubTable(target, start, x, y, width);} + GLEEPFNGLCOPYCOLORSUBTABLEPROC GLeeFuncPtr_glCopyColorSubTable=GLee_Lazy_glCopyColorSubTable; +#endif +#ifndef GLEE_C_DEFINED_glConvolutionFilter1D +#define GLEE_C_DEFINED_glConvolutionFilter1D + void __stdcall GLee_Lazy_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) {if (GLeeInit()) glConvolutionFilter1D(target, internalformat, width, format, type, image);} + GLEEPFNGLCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glConvolutionFilter1D=GLee_Lazy_glConvolutionFilter1D; +#endif +#ifndef GLEE_C_DEFINED_glConvolutionFilter2D +#define GLEE_C_DEFINED_glConvolutionFilter2D + void __stdcall GLee_Lazy_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) {if (GLeeInit()) glConvolutionFilter2D(target, internalformat, width, height, format, type, image);} + GLEEPFNGLCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glConvolutionFilter2D=GLee_Lazy_glConvolutionFilter2D; +#endif +#ifndef GLEE_C_DEFINED_glConvolutionParameterf +#define GLEE_C_DEFINED_glConvolutionParameterf + void __stdcall GLee_Lazy_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) {if (GLeeInit()) glConvolutionParameterf(target, pname, params);} + GLEEPFNGLCONVOLUTIONPARAMETERFPROC GLeeFuncPtr_glConvolutionParameterf=GLee_Lazy_glConvolutionParameterf; +#endif +#ifndef GLEE_C_DEFINED_glConvolutionParameterfv +#define GLEE_C_DEFINED_glConvolutionParameterfv + void __stdcall GLee_Lazy_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glConvolutionParameterfv(target, pname, params);} + GLEEPFNGLCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glConvolutionParameterfv=GLee_Lazy_glConvolutionParameterfv; +#endif +#ifndef GLEE_C_DEFINED_glConvolutionParameteri +#define GLEE_C_DEFINED_glConvolutionParameteri + void __stdcall GLee_Lazy_glConvolutionParameteri(GLenum target, GLenum pname, GLint params) {if (GLeeInit()) glConvolutionParameteri(target, pname, params);} + GLEEPFNGLCONVOLUTIONPARAMETERIPROC GLeeFuncPtr_glConvolutionParameteri=GLee_Lazy_glConvolutionParameteri; +#endif +#ifndef GLEE_C_DEFINED_glConvolutionParameteriv +#define GLEE_C_DEFINED_glConvolutionParameteriv + void __stdcall GLee_Lazy_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glConvolutionParameteriv(target, pname, params);} + GLEEPFNGLCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glConvolutionParameteriv=GLee_Lazy_glConvolutionParameteriv; +#endif +#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter1D +#define GLEE_C_DEFINED_glCopyConvolutionFilter1D + void __stdcall GLee_Lazy_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyConvolutionFilter1D(target, internalformat, x, y, width);} + GLEEPFNGLCOPYCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glCopyConvolutionFilter1D=GLee_Lazy_glCopyConvolutionFilter1D; +#endif +#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter2D +#define GLEE_C_DEFINED_glCopyConvolutionFilter2D + void __stdcall GLee_Lazy_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);} + GLEEPFNGLCOPYCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glCopyConvolutionFilter2D=GLee_Lazy_glCopyConvolutionFilter2D; +#endif +#ifndef GLEE_C_DEFINED_glGetConvolutionFilter +#define GLEE_C_DEFINED_glGetConvolutionFilter + void __stdcall GLee_Lazy_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image) {if (GLeeInit()) glGetConvolutionFilter(target, format, type, image);} + GLEEPFNGLGETCONVOLUTIONFILTERPROC GLeeFuncPtr_glGetConvolutionFilter=GLee_Lazy_glGetConvolutionFilter; +#endif +#ifndef GLEE_C_DEFINED_glGetConvolutionParameterfv +#define GLEE_C_DEFINED_glGetConvolutionParameterfv + void __stdcall GLee_Lazy_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetConvolutionParameterfv(target, pname, params);} + GLEEPFNGLGETCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glGetConvolutionParameterfv=GLee_Lazy_glGetConvolutionParameterfv; +#endif +#ifndef GLEE_C_DEFINED_glGetConvolutionParameteriv +#define GLEE_C_DEFINED_glGetConvolutionParameteriv + void __stdcall GLee_Lazy_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetConvolutionParameteriv(target, pname, params);} + GLEEPFNGLGETCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glGetConvolutionParameteriv=GLee_Lazy_glGetConvolutionParameteriv; +#endif +#ifndef GLEE_C_DEFINED_glGetSeparableFilter +#define GLEE_C_DEFINED_glGetSeparableFilter + void __stdcall GLee_Lazy_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) {if (GLeeInit()) glGetSeparableFilter(target, format, type, row, column, span);} + GLEEPFNGLGETSEPARABLEFILTERPROC GLeeFuncPtr_glGetSeparableFilter=GLee_Lazy_glGetSeparableFilter; +#endif +#ifndef GLEE_C_DEFINED_glSeparableFilter2D +#define GLEE_C_DEFINED_glSeparableFilter2D + void __stdcall GLee_Lazy_glSeparableFilter2D(GLenum target, GLenum internalformat, 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, GLenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetHistogram(target, reset, format, type, values);} + GLEEPFNGLGETHISTOGRAMPROC GLeeFuncPtr_glGetHistogram=GLee_Lazy_glGetHistogram; +#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_glGetHistogramParameterfv=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_glGetHistogramParameteriv=GLee_Lazy_glGetHistogramParameteriv; +#endif +#ifndef GLEE_C_DEFINED_glGetMinmax +#define GLEE_C_DEFINED_glGetMinmax + void __stdcall GLee_Lazy_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetMinmax(target, 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 pname, GLfloat * params) {if (GLeeInit()) glGetMinmaxParameterfv(target, pname, 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 pname, 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, width, 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, GLboolean 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_glResetHistogram; +#endif +#ifndef GLEE_C_DEFINED_glResetMinmax +#define GLEE_C_DEFINED_glResetMinmax + void __stdcall GLee_Lazy_glResetMinmax(GLenum target) {if (GLeeInit()) glResetMinmax(target);} + GLEEPFNGLRESETMINMAXPROC GLeeFuncPtr_glResetMinmax=GLee_Lazy_glResetMinmax; +#endif +#ifndef GLEE_C_DEFINED_glTexImage3D +#define GLEE_C_DEFINED_glTexImage3D + void __stdcall GLee_Lazy_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexImage3D(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, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);} + GLEEPFNGLTEXSUBIMAGE3DPROC GLeeFuncPtr_glTexSubImage3D=GLee_Lazy_glTexSubImage3D; +#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 width, GLsizei height) {if (GLeeInit()) glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);} + GLEEPFNGLCOPYTEXSUBIMAGE3DPROC GLeeFuncPtr_glCopyTexSubImage3D=GLee_Lazy_glCopyTexSubImage3D; +#endif +#endif + +/* GL_ARB_imaging */ + +#ifdef __GLEE_GL_ARB_imaging +#endif + +/* GL_VERSION_1_3 */ + +#ifdef __GLEE_GL_VERSION_1_3 +#ifndef GLEE_C_DEFINED_glActiveTexture +#define GLEE_C_DEFINED_glActiveTexture + void __stdcall GLee_Lazy_glActiveTexture(GLenum texture) {if (GLeeInit()) glActiveTexture(texture);} + GLEEPFNGLACTIVETEXTUREPROC GLeeFuncPtr_glActiveTexture=GLee_Lazy_glActiveTexture; +#endif +#ifndef GLEE_C_DEFINED_glClientActiveTexture +#define GLEE_C_DEFINED_glClientActiveTexture + void __stdcall GLee_Lazy_glClientActiveTexture(GLenum texture) {if (GLeeInit()) glClientActiveTexture(texture);} + GLEEPFNGLCLIENTACTIVETEXTUREPROC GLeeFuncPtr_glClientActiveTexture=GLee_Lazy_glClientActiveTexture; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1d +#define GLEE_C_DEFINED_glMultiTexCoord1d + void __stdcall GLee_Lazy_glMultiTexCoord1d(GLenum target, GLdouble s) {if (GLeeInit()) glMultiTexCoord1d(target, s);} + GLEEPFNGLMULTITEXCOORD1DPROC GLeeFuncPtr_glMultiTexCoord1d=GLee_Lazy_glMultiTexCoord1d; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1dv +#define GLEE_C_DEFINED_glMultiTexCoord1dv + void __stdcall GLee_Lazy_glMultiTexCoord1dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord1dv(target, v);} + GLEEPFNGLMULTITEXCOORD1DVPROC GLeeFuncPtr_glMultiTexCoord1dv=GLee_Lazy_glMultiTexCoord1dv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1f +#define GLEE_C_DEFINED_glMultiTexCoord1f + void __stdcall GLee_Lazy_glMultiTexCoord1f(GLenum target, GLfloat s) {if (GLeeInit()) glMultiTexCoord1f(target, s);} + GLEEPFNGLMULTITEXCOORD1FPROC GLeeFuncPtr_glMultiTexCoord1f=GLee_Lazy_glMultiTexCoord1f; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1fv +#define GLEE_C_DEFINED_glMultiTexCoord1fv + void __stdcall GLee_Lazy_glMultiTexCoord1fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord1fv(target, v);} + GLEEPFNGLMULTITEXCOORD1FVPROC GLeeFuncPtr_glMultiTexCoord1fv=GLee_Lazy_glMultiTexCoord1fv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1i +#define GLEE_C_DEFINED_glMultiTexCoord1i + void __stdcall GLee_Lazy_glMultiTexCoord1i(GLenum target, GLint s) {if (GLeeInit()) glMultiTexCoord1i(target, s);} + GLEEPFNGLMULTITEXCOORD1IPROC GLeeFuncPtr_glMultiTexCoord1i=GLee_Lazy_glMultiTexCoord1i; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1iv +#define GLEE_C_DEFINED_glMultiTexCoord1iv + void __stdcall GLee_Lazy_glMultiTexCoord1iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord1iv(target, v);} + GLEEPFNGLMULTITEXCOORD1IVPROC GLeeFuncPtr_glMultiTexCoord1iv=GLee_Lazy_glMultiTexCoord1iv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1s +#define GLEE_C_DEFINED_glMultiTexCoord1s + void __stdcall GLee_Lazy_glMultiTexCoord1s(GLenum target, GLshort s) {if (GLeeInit()) glMultiTexCoord1s(target, s);} + GLEEPFNGLMULTITEXCOORD1SPROC GLeeFuncPtr_glMultiTexCoord1s=GLee_Lazy_glMultiTexCoord1s; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord1sv +#define GLEE_C_DEFINED_glMultiTexCoord1sv + void __stdcall GLee_Lazy_glMultiTexCoord1sv(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord1sv(target, v);} + GLEEPFNGLMULTITEXCOORD1SVPROC GLeeFuncPtr_glMultiTexCoord1sv=GLee_Lazy_glMultiTexCoord1sv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2d +#define GLEE_C_DEFINED_glMultiTexCoord2d + void __stdcall GLee_Lazy_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) {if (GLeeInit()) glMultiTexCoord2d(target, s, t);} + GLEEPFNGLMULTITEXCOORD2DPROC GLeeFuncPtr_glMultiTexCoord2d=GLee_Lazy_glMultiTexCoord2d; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2dv +#define GLEE_C_DEFINED_glMultiTexCoord2dv + void __stdcall GLee_Lazy_glMultiTexCoord2dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord2dv(target, v);} + GLEEPFNGLMULTITEXCOORD2DVPROC GLeeFuncPtr_glMultiTexCoord2dv=GLee_Lazy_glMultiTexCoord2dv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2f +#define GLEE_C_DEFINED_glMultiTexCoord2f + void __stdcall GLee_Lazy_glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {if (GLeeInit()) glMultiTexCoord2f(target, s, t);} + GLEEPFNGLMULTITEXCOORD2FPROC GLeeFuncPtr_glMultiTexCoord2f=GLee_Lazy_glMultiTexCoord2f; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2fv +#define GLEE_C_DEFINED_glMultiTexCoord2fv + void __stdcall GLee_Lazy_glMultiTexCoord2fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord2fv(target, v);} + GLEEPFNGLMULTITEXCOORD2FVPROC GLeeFuncPtr_glMultiTexCoord2fv=GLee_Lazy_glMultiTexCoord2fv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2i +#define GLEE_C_DEFINED_glMultiTexCoord2i + void __stdcall GLee_Lazy_glMultiTexCoord2i(GLenum target, GLint s, GLint t) {if (GLeeInit()) glMultiTexCoord2i(target, s, t);} + GLEEPFNGLMULTITEXCOORD2IPROC GLeeFuncPtr_glMultiTexCoord2i=GLee_Lazy_glMultiTexCoord2i; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2iv +#define GLEE_C_DEFINED_glMultiTexCoord2iv + void __stdcall GLee_Lazy_glMultiTexCoord2iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord2iv(target, v);} + GLEEPFNGLMULTITEXCOORD2IVPROC GLeeFuncPtr_glMultiTexCoord2iv=GLee_Lazy_glMultiTexCoord2iv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2s +#define GLEE_C_DEFINED_glMultiTexCoord2s + void __stdcall GLee_Lazy_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) {if (GLeeInit()) glMultiTexCoord2s(target, s, t);} + GLEEPFNGLMULTITEXCOORD2SPROC GLeeFuncPtr_glMultiTexCoord2s=GLee_Lazy_glMultiTexCoord2s; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord2sv +#define GLEE_C_DEFINED_glMultiTexCoord2sv + void __stdcall GLee_Lazy_glMultiTexCoord2sv(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord2sv(target, v);} + GLEEPFNGLMULTITEXCOORD2SVPROC GLeeFuncPtr_glMultiTexCoord2sv=GLee_Lazy_glMultiTexCoord2sv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3d +#define GLEE_C_DEFINED_glMultiTexCoord3d + void __stdcall GLee_Lazy_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3d(target, s, t, r);} + GLEEPFNGLMULTITEXCOORD3DPROC GLeeFuncPtr_glMultiTexCoord3d=GLee_Lazy_glMultiTexCoord3d; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3dv +#define GLEE_C_DEFINED_glMultiTexCoord3dv + void __stdcall GLee_Lazy_glMultiTexCoord3dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord3dv(target, v);} + GLEEPFNGLMULTITEXCOORD3DVPROC GLeeFuncPtr_glMultiTexCoord3dv=GLee_Lazy_glMultiTexCoord3dv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3f +#define GLEE_C_DEFINED_glMultiTexCoord3f + void __stdcall GLee_Lazy_glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {if (GLeeInit()) glMultiTexCoord3f(target, s, t, r);} + GLEEPFNGLMULTITEXCOORD3FPROC GLeeFuncPtr_glMultiTexCoord3f=GLee_Lazy_glMultiTexCoord3f; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3fv +#define GLEE_C_DEFINED_glMultiTexCoord3fv + void __stdcall GLee_Lazy_glMultiTexCoord3fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord3fv(target, v);} + GLEEPFNGLMULTITEXCOORD3FVPROC GLeeFuncPtr_glMultiTexCoord3fv=GLee_Lazy_glMultiTexCoord3fv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3i +#define GLEE_C_DEFINED_glMultiTexCoord3i + void __stdcall GLee_Lazy_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) {if (GLeeInit()) glMultiTexCoord3i(target, s, t, r);} + GLEEPFNGLMULTITEXCOORD3IPROC GLeeFuncPtr_glMultiTexCoord3i=GLee_Lazy_glMultiTexCoord3i; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3iv +#define GLEE_C_DEFINED_glMultiTexCoord3iv + void __stdcall GLee_Lazy_glMultiTexCoord3iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord3iv(target, v);} + GLEEPFNGLMULTITEXCOORD3IVPROC GLeeFuncPtr_glMultiTexCoord3iv=GLee_Lazy_glMultiTexCoord3iv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord3s +#define GLEE_C_DEFINED_glMultiTexCoord3s + void __stdcall GLee_Lazy_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) {if (GLeeInit()) glMultiTexCoord3s(target, s, t, r);} + GLEEPFNGLMULTITEXCOORD3SPROC GLeeFuncPtr_glMultiTexCoord3s=GLee_Lazy_glMultiTexCoord3s; +#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_glMultiTexCoord3sv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord4d +#define GLEE_C_DEFINED_glMultiTexCoord4d + void __stdcall GLee_Lazy_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4d(target, s, t, r, q);} + GLEEPFNGLMULTITEXCOORD4DPROC GLeeFuncPtr_glMultiTexCoord4d=GLee_Lazy_glMultiTexCoord4d; +#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_glMultiTexCoord4dv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord4f +#define GLEE_C_DEFINED_glMultiTexCoord4f + void __stdcall GLee_Lazy_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4f(target, s, t, r, q);} + GLEEPFNGLMULTITEXCOORD4FPROC GLeeFuncPtr_glMultiTexCoord4f=GLee_Lazy_glMultiTexCoord4f; +#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_glMultiTexCoord4fv; +#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_glMultiTexCoord4i; +#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_glMultiTexCoord4iv; +#endif +#ifndef GLEE_C_DEFINED_glMultiTexCoord4s +#define GLEE_C_DEFINED_glMultiTexCoord4s + void __stdcall GLee_Lazy_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4s(target, s, t, r, q);} + GLEEPFNGLMULTITEXCOORD4SPROC GLeeFuncPtr_glMultiTexCoord4s=GLee_Lazy_glMultiTexCoord4s; +#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_glMultiTexCoord4sv; +#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 invert) {if (GLeeInit()) glSampleCoverage(value, invert);} + GLEEPFNGLSAMPLECOVERAGEPROC GLeeFuncPtr_glSampleCoverage=GLee_Lazy_glSampleCoverage; +#endif +#ifndef GLEE_C_DEFINED_glCompressedTexImage3D +#define GLEE_C_DEFINED_glCompressedTexImage3D + void __stdcall GLee_Lazy_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, 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 level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage2D(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 level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const 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 level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);} + GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC GLeeFuncPtr_glCompressedTexSubImage3D=GLee_Lazy_glCompressedTexSubImage3D; +#endif +#ifndef GLEE_C_DEFINED_glCompressedTexSubImage2D +#define GLEE_C_DEFINED_glCompressedTexSubImage2D + void __stdcall GLee_Lazy_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);} + GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC GLeeFuncPtr_glCompressedTexSubImage2D=GLee_Lazy_glCompressedTexSubImage2D; +#endif +#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1D +#define GLEE_C_DEFINED_glCompressedTexSubImage1D + void __stdcall GLee_Lazy_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);} + GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC GLeeFuncPtr_glCompressedTexSubImage1D=GLee_Lazy_glCompressedTexSubImage1D; +#endif +#ifndef GLEE_C_DEFINED_glGetCompressedTexImage +#define GLEE_C_DEFINED_glGetCompressedTexImage + void __stdcall GLee_Lazy_glGetCompressedTexImage(GLenum target, GLint level, GLvoid * img) {if (GLeeInit()) glGetCompressedTexImage(target, level, img);} + GLEEPFNGLGETCOMPRESSEDTEXIMAGEPROC GLeeFuncPtr_glGetCompressedTexImage=GLee_Lazy_glGetCompressedTexImage; +#endif +#endif + +/* GL_VERSION_1_4 */ + +#ifdef __GLEE_GL_VERSION_1_4 +#ifndef GLEE_C_DEFINED_glBlendFuncSeparate +#define GLEE_C_DEFINED_glBlendFuncSeparate + void __stdcall GLee_Lazy_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);} + GLEEPFNGLBLENDFUNCSEPARATEPROC GLeeFuncPtr_glBlendFuncSeparate=GLee_Lazy_glBlendFuncSeparate; +#endif +#ifndef GLEE_C_DEFINED_glFogCoordf +#define GLEE_C_DEFINED_glFogCoordf + void __stdcall GLee_Lazy_glFogCoordf(GLfloat coord) {if (GLeeInit()) glFogCoordf(coord);} + GLEEPFNGLFOGCOORDFPROC GLeeFuncPtr_glFogCoordf=GLee_Lazy_glFogCoordf; +#endif +#ifndef GLEE_C_DEFINED_glFogCoordfv +#define GLEE_C_DEFINED_glFogCoordfv + void __stdcall GLee_Lazy_glFogCoordfv(const GLfloat * coord) {if (GLeeInit()) glFogCoordfv(coord);} + GLEEPFNGLFOGCOORDFVPROC GLeeFuncPtr_glFogCoordfv=GLee_Lazy_glFogCoordfv; +#endif +#ifndef GLEE_C_DEFINED_glFogCoordd +#define GLEE_C_DEFINED_glFogCoordd + void __stdcall GLee_Lazy_glFogCoordd(GLdouble coord) {if (GLeeInit()) glFogCoordd(coord);} + GLEEPFNGLFOGCOORDDPROC GLeeFuncPtr_glFogCoordd=GLee_Lazy_glFogCoordd; +#endif +#ifndef GLEE_C_DEFINED_glFogCoorddv +#define GLEE_C_DEFINED_glFogCoorddv + void __stdcall GLee_Lazy_glFogCoorddv(const GLdouble * coord) {if (GLeeInit()) glFogCoorddv(coord);} + GLEEPFNGLFOGCOORDDVPROC GLeeFuncPtr_glFogCoorddv=GLee_Lazy