commit a636ae593240fae898986c09d627a9e6c5e7f743 Author: Robin Hübner Date: Fri Jun 22 21:51:16 2018 +0200 changes, put most of old emu code in, now lets make things werk yes diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..304e955 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +.dub +docs.json +__dummy.html +docs/ +*.exe +*.o +*.obj +*.lst diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..a175696 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,20 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "(Windows) Launch", + "type": "cppvsdbg", + "request": "launch", + "program": "${workspaceFolder}/chipd8.exe", + "preLaunchTask": "build", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "externalConsole": true + } + ] +} \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..4fb4a79 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,17 @@ +{ + // See https://go.microsoft.com/fwlink/?LinkId=733558 + // for the documentation about the tasks.json format + "version": "2.0.0", + "tasks": [ + { + "label": "build", + "type": "shell", + "command": "dub build --arch=x86_64", + "problemMatcher": "$msCompile", + "group": { + "kind": "build", + "isDefault": true + } + } + ] +} \ No newline at end of file diff --git a/SDL2.dll b/SDL2.dll new file mode 100644 index 0000000..6cf858c Binary files /dev/null and b/SDL2.dll differ diff --git a/dub.json b/dub.json new file mode 100644 index 0000000..bd949d9 --- /dev/null +++ b/dub.json @@ -0,0 +1,12 @@ +{ + "name": "chipd8", + "authors": [ + "profan" + ], + "dependencies": { + "derelict-sdl2": "~>3.1.0-alpha.4" + }, + "description": "A minimal D application.", + "copyright": "Copyright © 2018, profan", + "license": "MIT" +} \ No newline at end of file diff --git a/dub.selections.json b/dub.selections.json new file mode 100644 index 0000000..c4c9272 --- /dev/null +++ b/dub.selections.json @@ -0,0 +1,8 @@ +{ + "fileVersion": 1, + "versions": { + "derelict-gl3": "2.0.0-beta.6", + "derelict-sdl2": "3.1.0-alpha.4", + "derelict-util": "3.0.0-beta.2" + } +} diff --git a/source/app.d b/source/app.d new file mode 100644 index 0000000..b2e1735 --- /dev/null +++ b/source/app.d @@ -0,0 +1,591 @@ +import std.stdio; +import derelict.sdl2.sdl; +import glad.gl.all; + +string doCapture(string sym, uint start, uint end)(){ + + import std.string : format; + + enum bits = end - start; + static if (bits > 16) { + alias RT = uint; + } else static if (bits > 8) { + alias RT = ushort; + } else { + alias RT = ubyte; + } + + auto str = "0b"; + foreach (i; 0 .. end) { + if (i >= start) str ~= "1"; + else str ~= "0"; + } + + return format(q{ + %s result = ((%s & %s) >> %d); + return result; + }, RT.stringof, sym, str, start); + +} // doCapture + +auto capture(uint start, uint end)(ushort op) { + + enum str = doCapture!(op.stringof, start, end)(); + mixin(str); + +} // capture + +struct Chip8 { + + alias OpCode = ushort; + alias ProgramCounter = ushort; + alias Memory = ubyte[4096]; + alias Stack = ushort[16]; + + alias Register = ubyte; + alias Registers = Register[16]; + alias IndexRegister = ushort; + + alias KeyPad = ubyte[16]; + + struct CPU { + + OpCode opcode = 0; //current opcode + ProgramCounter pc = 0x200; + + Registers v; //16 general purpose registers + IndexRegister i; + + Register delay_timer; + Register sound_timer; + + } // CPU + + CPU cpu; + Memory ram; + + Stack stack; + ubyte sp; + + KeyPad kp; + + ubyte[64*32] screen_buf; + ubyte[3][64*32] screen_data; + + bool run_flag; + bool draw_flag; + + void load(size_t offset, in ubyte[] data) { + + assert(offset + data.length < ram.length); + + ram[offset .. offset + data.length] = data[]; + + } // load + + void step() { + + cpu.opcode = ram[cpu.pc] << 8 | ram[cpu.pc + 1]; + auto pc_target = cast(ProgramCounter)(cpu.pc + 2); + + writefln("opcode: 0x%X", cpu.opcode); + + switch (cpu.opcode & 0xF000) with (cpu) { + + case 0x0000: + + switch (cpu.opcode & 0x0FFF) { + + case 0x00E0: // 0x00E0 Clears the screen. + + screen_buf[0..$] = 0; + draw_flag = true; + + break; + + case 0x00EE: // 0x00EE Returns from a subroutine. + + pc_target = stack[--sp]; + + break; + + default: // 0x0NNN Calls RCA 1802 program at address NNN. Not necessary for most ROMs. + //assert(0, "0x0NNN RCA 1802 program opcode not implemented!"); + break; + + } + + break; + + case 0x1000: // 0x1NNN Jumps to address NNN. + + pc_target = cpu.opcode.capture!(0, 12); + + break; + + case 0x2000: // 0x2NNN Calls subroutine at NNN. + + stack[sp++] = cpu.pc; + pc_target = cpu.opcode.capture!(0, 12); + + break; + + case 0x3000: // 0x3XNN Skips the next instruction if VX equals NN. + + if (cpu.v[cpu.opcode.capture!(8, 12)] == cpu.opcode.capture!(0, 8)) { + pc_target += 2; + } + + break; + + case 0x4000: // 0x4XNN Skips the next instruction if VX doesn't equal NN. + + if (cpu.v[cpu.opcode.capture!(8, 12)] != cpu.opcode.capture!(0, 8)) { + pc_target += 2; + } + + break; + + case 0x5000: // 0x5XYO Skips the next instruction if VX equals VY. + + if (cpu.v[cpu.opcode.capture!(8, 12)] == cpu.v[cpu.opcode.capture!(4, 8)]) { + pc_target += 2; + } + + break; + + case 0x6000: // 0x6XNN Sets VX to NN. + + cpu.v[cpu.opcode.capture!(8, 12)] = cpu.opcode.capture!(0, 8); + + break; + + case 0x7000: // 0x7XNN Adds NN to VX. + + cpu.v[cpu.opcode.capture!(8, 12)] += cpu.opcode.capture!(0, 8); + + break; + + case 0x8000: + + auto x = cpu.opcode.capture!(8, 12); + auto y = cpu.opcode.capture!(4, 8); + + switch (cpu.opcode & 0x000F) { + + case 0x0000: // 0x8XY0 Sets VX to the value of VY. + + cpu.v[x] = cpu.v[y]; + + break; + + case 0x0001: // 0x8XY1 Sets VX to VX or VY. + + cpu.v[x] = cpu.v[x] | cpu.v[y]; + + break; + + case 0x0002: // 0x8XY2 Sets VX to VX and VY. + + cpu.v[x] = cpu.v[x] & cpu.v[y]; + + break; + + case 0x0003: // 0x8XY3 Sets VX to VX xor VY. + + cpu.v[x] = cpu.v[x] ^ cpu.v[y]; + + break; + + case 0x0004: // 0x8XY4 Adds VY to VX. VF is set to 1 when there's a carry, and to 0 when there isn't. + + cpu.v[x] += cpu.v[y]; //TODO carry flag + + break; + + case 0x0005: // 0x8XY5 VY is subtracted from VX. VF is set to 0 when there's a borrow, and 1 when there isn't. + + cpu.v[x] -= cpu.v[y]; //TODO borrow flag + + break; + + case 0x0006: // 0x8XY6 Shifts VX right by one. VF is set to the value of the least significant bit of VX before the shift. + + auto vx = cpu.v[x]; + cpu.v[0xF] = (vx & 0b10000000) >> 7; + cpu.v[x] >>= 1; + + break; + + case 0x0007: // 0x8XY7 Sets VX to VY minus VX. VF is set to 0 when there's a borrow, and 1 when there isn't. + + cpu.v[x] = cast(Register)(cpu.v[y] - cpu.v[x]); //TODO borrow flag + + break; + + case 0x000E: // 0x8XYE Shifts VX left by one. VF is set to the value of the most significant bit of VX before the shift. + + auto vx = cpu.v[x]; + cpu.v[0xF] = (vx & 0b10000000) >> 7; + cpu.v[x] <<= 1; + + break; + + default: //unhandled for some reason + writefln("unknown opcode: 0x%x", cpu.opcode); + break; + + } + + break; + + case 0x9000: // 0x9XYO Skips the next instruction if VX doesn't equal VY. + + if (cpu.v[cpu.opcode.capture!(8, 12)] != cpu.v[cpu.opcode.capture!(4, 8)]) { + pc_target += 2; //do skip yes + } + + break; + + case 0xA000: // 0xANNN Sets I to the address NNN. + + cpu.i = cpu.opcode.capture!(0, 12); + + break; + + case 0xB000: // 0xBNNN Jumps to the address NNN plus V0. + + pc_target = cast(ubyte)cpu.opcode.capture!(0, 12) + cpu.v[0x0]; + + break; + + case 0xC000: // 0xCXNN Sets VX to the result of a bitwise and operation on a random number and NN. + + import std.random : uniform; + auto x = cpu.opcode.capture!(8, 12); + cpu.v[x] = uniform(Register.min, Register.max) & cpu.opcode.capture!(0, 8); + + break; + + // 0xDXYN + // Sprites stored in memory at location in index register (I), 8bits wide. + // Wraps around the screen. If when drawn, clears a pixel, register VF is set to 1 otherwise it is zero. + // All drawing is XOR drawing (i.e. it toggles the screen pixels). + // Sprites are drawn starting at position VX, VY. N is the number of 8bit rows that need to be drawn. + // If N is greater than 1, second line continues at position VX, VY+1, and so on. + case 0xD000: + + auto spr_addr = cpu.i; + auto x = cpu.opcode.capture!(8, 12); + auto y = cpu.opcode.capture!(4, 8); + auto n = cpu.opcode.capture!(0, 4); + ushort pixel; + + foreach(int row; 0 .. n) { + + pixel = ram[spr_addr + row]; + + foreach (int col; 0 .. 8) { + if ((pixel & (0x80 >> col)) != 0) { + if (screen_buf[(x + col + ((y + row) * 64))] == 1) { + cpu.v[0xF] = 1; + } + screen_buf[x + row + ((y + col) * 64)] ^= 1; + } + } + + } + + draw_flag = true; + + break; + + case 0xE000: + + auto x = cpu.opcode.capture!(8, 12); + auto key = cpu.v[x]; + + switch (cpu.opcode & 0x000F) { + + case 0x000E: // 0xEX9E Skips the next instruction if the key stored in VX is pressed. + writefln("0xEXA1: skip instruction if VX not pressed: %x", key); + break; + + case 0x0001: // 0xEXA1 Skips the next instruction if the key stored in VX isn't pressed. + writefln("0xEXA1: skip instruction if VX not pressed: %x", key); + break; + + default: //unhandled for some reason + writefln("unknown opcode: 0x%x", cpu.opcode); + break; + + } + + break; + + case 0xF000: + + switch (cpu.opcode & 0x00FF) { + + case 0x0007: // 0xFX07 Sets VX to the value of the delay timer. + + cpu.v[cpu.opcode.capture!(8, 12)] = cpu.delay_timer; + + break; + + case 0x000A: // 0xFX0A A key press is awaited, and then stored in VX. + + break; + + case 0x0015: // 0xFX15 Sets the delay timer to VX. + + cpu.delay_timer = cpu.v[cpu.opcode.capture!(8, 12)]; + + break; + + case 0x0018: // 0xFX18 Sets the sound timer to VX. + + cpu.sound_timer = cpu.v[cpu.opcode.capture!(8, 12)]; + + break; + + case 0x001E: // 0xFX1E Adds VX to I. + + cpu.i += cpu.v[cpu.opcode.capture!(8, 12)]; + + break; + + case 0x0029: // 0xFX29 Sets I to the location of the sprite for the character in VX. + + auto vx = cpu.v[cpu.opcode.capture!(8, 12)]; + ushort char_addr = 0x200 + (vx * 40); // base of char sprites + value of vx * bits per character + cpu.i = char_addr; + + break; + + // 0xFX33 Stores the Binary-coded decimal representation of VX, + // with the most significant of three digits at the address in I, + // the middle digit at I plus 1, and the least significant digit at I plus 2. + case 0x0033: + + auto vx = cpu.v[cpu.opcode.capture!(8, 12)]; + ram[cpu.i] = vx / 100; + ram[cpu.i + 1] = (vx / 10) % 10; + ram[cpu.i + 2] = (vx % 100) % 10; + + break; + + case 0x0055: // 0xFX55 Stores V0 to VX in memory starting at address I. + + auto addr = cpu.i; + foreach (reg; cpu.v) { + ram[addr++] = reg; + } + + break; + + case 0x0065: // 0xFX65 Fills V0 to VX with values from memory starting at address I. + + auto addr = cpu.i; + foreach (ref reg; cpu.v) { + reg = ram[addr++]; + } + + break; + + default: //unhandled for some reason + writefln("unknown opcode: 0x%x", cpu.opcode); + break; + + } + + break; + + default: + writefln("unknown opcode: 0x%x", cpu.opcode); + + } + + /* now update pc and timer registers. */ + + cpu.pc = pc_target; + + if (cpu.delay_timer != 0u) { + --cpu.delay_timer; + } + + if (cpu.sound_timer != 0u) { + + if (cpu.sound_timer == 1) { + writefln("beep!"); + } + + --cpu.sound_timer; + + } + + } // step + + void tick() { + + if (run_flag) { + step(); + } + + } // tick + + void draw() { + + if (draw_flag) { + // update buffer with new pixel data + draw_flag = false; + } + + // glPixelZoom(rt.width / 64, rt.height / 32); + // glDrawPixels(64, 32, GL_RGB, GL_UNSIGNED_BYTE, screen_data.ptr); + + } // draw + +} // Emulator + +struct Window { + + import core.stdc.stdio; + import core.stdc.stdlib; + + SDL_Window* window; + SDL_GLContext context; + + void create_window(int w, int h, const char* title = "Chipd8 Emu") { + assert(w > 0, "window width must be > 0"); + assert(h > 0, "window height must be > 0"); + + // minimum OpenGL 3.3 + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); + + SDL_Window* new_win = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, SDL_WINDOW_OPENGL); + if (new_win == null) { + printf("SDL2 - Window could not be created: %s\n", SDL_GetError()); + return; + } + + SDL_GLContext new_con = SDL_GL_CreateContext(new_win); + if (new_con == null) { + printf("SDL2 - failed creating OpenGL 3.3 context: %s\n", SDL_GetError()); + return; + } + + // assign em yes + window = new_win; + context = new_con; + + atexit(SDL_Quit); + + } // create_window + +} // Window + +void load_libs() { + + import glad.gl.loader; + + DerelictSDL2.load(); + auto status = gladLoadGL(); + +} + +void init_libs() { + + SDL_Init(SDL_INIT_VIDEO); + +} + +void setup_imgui() { + +} + +void main() { + + load_libs(); + init_libs(); + + Emulator emu; + emu.create(); + emu.run(); + +} + +struct Emulator { + + bool running; + + Window window; + Chip8 chip8; + + void create() { + + // create window + window.create_window(640, 480); + + } + + void handle_events() { + + SDL_Event event; + while (SDL_PollEvent(&event)) { + switch (event.type) with (SDL_EventType) { + case SDL_TEXTINPUT: { + break; + } + case SDL_TEXTEDITING: { + break; + } + case SDL_MOUSEBUTTONDOWN: { + break; + } + case SDL_MOUSEBUTTONUP: { + break; + } + case SDL_MOUSEWHEEL: { + break; + } + case SDL_KEYDOWN: { + break; + } + case SDL_KEYUP: { + break; + } + case SDL_QUIT: { + running = false; + break; + } + default: { + break; + } + } + } + + } // handle_events + + void run() { + + running = true; + + while (running) { + handle_events(); + tick(); + draw(); + } + + } + + void tick() { + + } + + void draw() { + + } + +} \ No newline at end of file diff --git a/source/glad/gl/all.d b/source/glad/gl/all.d new file mode 100644 index 0000000..5781698 --- /dev/null +++ b/source/glad/gl/all.d @@ -0,0 +1,27 @@ +/* + + OpenGL loader generated by glad 0.1.24a0 on Wed Jun 20 01:57:03 2018. + + Language/Generator: D + Specification: gl + APIs: gl=3.3 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + + Commandline: + --profile="compatibility" --api="gl=3.3" --generator="d" --spec="gl" --extensions="" + Online: + http://glad.dav1d.de/#profile=compatibility&language=d&specification=gl&loader=on&api=gl%3D3.3 +*/ + +module glad.gl.all; + + +public import glad.gl.funcs; +public import glad.gl.ext; +public import glad.gl.enums; +public import glad.gl.types; diff --git a/source/glad/gl/enums.d b/source/glad/gl/enums.d new file mode 100644 index 0000000..261d2c6 --- /dev/null +++ b/source/glad/gl/enums.d @@ -0,0 +1,1259 @@ +module glad.gl.enums; + + +private import glad.gl.types; +enum ubyte GL_FALSE = 0; +enum ubyte GL_TRUE = 1; +enum uint GL_NO_ERROR = 0; +enum uint GL_NONE = 0; +enum uint GL_ZERO = 0; +enum uint GL_ONE = 1; +enum uint GL_NONE_OES = 0; +enum uint GL_INVALID_INDEX = 0xFFFFFFFF; +enum ulong GL_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; +enum ulong GL_TIMEOUT_IGNORED_APPLE = 0xFFFFFFFFFFFFFFFF; +enum uint GL_VERSION_ES_CL_1_0 = 1; +enum uint GL_VERSION_ES_CM_1_1 = 1; +enum uint GL_VERSION_ES_CL_1_1 = 1; +enum uint GL_DEPTH_BUFFER_BIT = 0x00000100; +enum uint GL_STENCIL_BUFFER_BIT = 0x00000400; +enum uint GL_COLOR_BUFFER_BIT = 0x00004000; +enum uint GL_POINTS = 0x0000; +enum uint GL_LINES = 0x0001; +enum uint GL_LINE_LOOP = 0x0002; +enum uint GL_LINE_STRIP = 0x0003; +enum uint GL_TRIANGLES = 0x0004; +enum uint GL_TRIANGLE_STRIP = 0x0005; +enum uint GL_TRIANGLE_FAN = 0x0006; +enum uint GL_QUADS = 0x0007; +enum uint GL_NEVER = 0x0200; +enum uint GL_LESS = 0x0201; +enum uint GL_EQUAL = 0x0202; +enum uint GL_LEQUAL = 0x0203; +enum uint GL_GREATER = 0x0204; +enum uint GL_NOTEQUAL = 0x0205; +enum uint GL_GEQUAL = 0x0206; +enum uint GL_ALWAYS = 0x0207; +enum uint GL_SRC_COLOR = 0x0300; +enum uint GL_ONE_MINUS_SRC_COLOR = 0x0301; +enum uint GL_SRC_ALPHA = 0x0302; +enum uint GL_ONE_MINUS_SRC_ALPHA = 0x0303; +enum uint GL_DST_ALPHA = 0x0304; +enum uint GL_ONE_MINUS_DST_ALPHA = 0x0305; +enum uint GL_DST_COLOR = 0x0306; +enum uint GL_ONE_MINUS_DST_COLOR = 0x0307; +enum uint GL_SRC_ALPHA_SATURATE = 0x0308; +enum uint GL_FRONT_LEFT = 0x0400; +enum uint GL_FRONT_RIGHT = 0x0401; +enum uint GL_BACK_LEFT = 0x0402; +enum uint GL_BACK_RIGHT = 0x0403; +enum uint GL_FRONT = 0x0404; +enum uint GL_BACK = 0x0405; +enum uint GL_LEFT = 0x0406; +enum uint GL_RIGHT = 0x0407; +enum uint GL_FRONT_AND_BACK = 0x0408; +enum uint GL_INVALID_ENUM = 0x0500; +enum uint GL_INVALID_VALUE = 0x0501; +enum uint GL_INVALID_OPERATION = 0x0502; +enum uint GL_OUT_OF_MEMORY = 0x0505; +enum uint GL_CW = 0x0900; +enum uint GL_CCW = 0x0901; +enum uint GL_POINT_SIZE = 0x0B11; +enum uint GL_POINT_SIZE_RANGE = 0x0B12; +enum uint GL_POINT_SIZE_GRANULARITY = 0x0B13; +enum uint GL_LINE_SMOOTH = 0x0B20; +enum uint GL_LINE_WIDTH = 0x0B21; +enum uint GL_LINE_WIDTH_RANGE = 0x0B22; +enum uint GL_LINE_WIDTH_GRANULARITY = 0x0B23; +enum uint GL_POLYGON_MODE = 0x0B40; +enum uint GL_POLYGON_SMOOTH = 0x0B41; +enum uint GL_CULL_FACE = 0x0B44; +enum uint GL_CULL_FACE_MODE = 0x0B45; +enum uint GL_FRONT_FACE = 0x0B46; +enum uint GL_DEPTH_RANGE = 0x0B70; +enum uint GL_DEPTH_TEST = 0x0B71; +enum uint GL_DEPTH_WRITEMASK = 0x0B72; +enum uint GL_DEPTH_CLEAR_VALUE = 0x0B73; +enum uint GL_DEPTH_FUNC = 0x0B74; +enum uint GL_STENCIL_TEST = 0x0B90; +enum uint GL_STENCIL_CLEAR_VALUE = 0x0B91; +enum uint GL_STENCIL_FUNC = 0x0B92; +enum uint GL_STENCIL_VALUE_MASK = 0x0B93; +enum uint GL_STENCIL_FAIL = 0x0B94; +enum uint GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95; +enum uint GL_STENCIL_PASS_DEPTH_PASS = 0x0B96; +enum uint GL_STENCIL_REF = 0x0B97; +enum uint GL_STENCIL_WRITEMASK = 0x0B98; +enum uint GL_VIEWPORT = 0x0BA2; +enum uint GL_DITHER = 0x0BD0; +enum uint GL_BLEND_DST = 0x0BE0; +enum uint GL_BLEND_SRC = 0x0BE1; +enum uint GL_BLEND = 0x0BE2; +enum uint GL_LOGIC_OP_MODE = 0x0BF0; +enum uint GL_DRAW_BUFFER = 0x0C01; +enum uint GL_READ_BUFFER = 0x0C02; +enum uint GL_SCISSOR_BOX = 0x0C10; +enum uint GL_SCISSOR_TEST = 0x0C11; +enum uint GL_COLOR_CLEAR_VALUE = 0x0C22; +enum uint GL_COLOR_WRITEMASK = 0x0C23; +enum uint GL_DOUBLEBUFFER = 0x0C32; +enum uint GL_STEREO = 0x0C33; +enum uint GL_LINE_SMOOTH_HINT = 0x0C52; +enum uint GL_POLYGON_SMOOTH_HINT = 0x0C53; +enum uint GL_UNPACK_SWAP_BYTES = 0x0CF0; +enum uint GL_UNPACK_LSB_FIRST = 0x0CF1; +enum uint GL_UNPACK_ROW_LENGTH = 0x0CF2; +enum uint GL_UNPACK_SKIP_ROWS = 0x0CF3; +enum uint GL_UNPACK_SKIP_PIXELS = 0x0CF4; +enum uint GL_UNPACK_ALIGNMENT = 0x0CF5; +enum uint GL_PACK_SWAP_BYTES = 0x0D00; +enum uint GL_PACK_LSB_FIRST = 0x0D01; +enum uint GL_PACK_ROW_LENGTH = 0x0D02; +enum uint GL_PACK_SKIP_ROWS = 0x0D03; +enum uint GL_PACK_SKIP_PIXELS = 0x0D04; +enum uint GL_PACK_ALIGNMENT = 0x0D05; +enum uint GL_MAX_TEXTURE_SIZE = 0x0D33; +enum uint GL_MAX_VIEWPORT_DIMS = 0x0D3A; +enum uint GL_SUBPIXEL_BITS = 0x0D50; +enum uint GL_TEXTURE_1D = 0x0DE0; +enum uint GL_TEXTURE_2D = 0x0DE1; +enum uint GL_TEXTURE_WIDTH = 0x1000; +enum uint GL_TEXTURE_HEIGHT = 0x1001; +enum uint GL_TEXTURE_BORDER_COLOR = 0x1004; +enum uint GL_DONT_CARE = 0x1100; +enum uint GL_FASTEST = 0x1101; +enum uint GL_NICEST = 0x1102; +enum uint GL_BYTE = 0x1400; +enum uint GL_UNSIGNED_BYTE = 0x1401; +enum uint GL_SHORT = 0x1402; +enum uint GL_UNSIGNED_SHORT = 0x1403; +enum uint GL_INT = 0x1404; +enum uint GL_UNSIGNED_INT = 0x1405; +enum uint GL_FLOAT = 0x1406; +enum uint GL_STACK_OVERFLOW = 0x0503; +enum uint GL_STACK_UNDERFLOW = 0x0504; +enum uint GL_CLEAR = 0x1500; +enum uint GL_AND = 0x1501; +enum uint GL_AND_REVERSE = 0x1502; +enum uint GL_COPY = 0x1503; +enum uint GL_AND_INVERTED = 0x1504; +enum uint GL_NOOP = 0x1505; +enum uint GL_XOR = 0x1506; +enum uint GL_OR = 0x1507; +enum uint GL_NOR = 0x1508; +enum uint GL_EQUIV = 0x1509; +enum uint GL_INVERT = 0x150A; +enum uint GL_OR_REVERSE = 0x150B; +enum uint GL_COPY_INVERTED = 0x150C; +enum uint GL_OR_INVERTED = 0x150D; +enum uint GL_NAND = 0x150E; +enum uint GL_SET = 0x150F; +enum uint GL_TEXTURE = 0x1702; +enum uint GL_COLOR = 0x1800; +enum uint GL_DEPTH = 0x1801; +enum uint GL_STENCIL = 0x1802; +enum uint GL_STENCIL_INDEX = 0x1901; +enum uint GL_DEPTH_COMPONENT = 0x1902; +enum uint GL_RED = 0x1903; +enum uint GL_GREEN = 0x1904; +enum uint GL_BLUE = 0x1905; +enum uint GL_ALPHA = 0x1906; +enum uint GL_RGB = 0x1907; +enum uint GL_RGBA = 0x1908; +enum uint GL_POINT = 0x1B00; +enum uint GL_LINE = 0x1B01; +enum uint GL_FILL = 0x1B02; +enum uint GL_KEEP = 0x1E00; +enum uint GL_REPLACE = 0x1E01; +enum uint GL_INCR = 0x1E02; +enum uint GL_DECR = 0x1E03; +enum uint GL_VENDOR = 0x1F00; +enum uint GL_RENDERER = 0x1F01; +enum uint GL_VERSION = 0x1F02; +enum uint GL_EXTENSIONS = 0x1F03; +enum uint GL_NEAREST = 0x2600; +enum uint GL_LINEAR = 0x2601; +enum uint GL_NEAREST_MIPMAP_NEAREST = 0x2700; +enum uint GL_LINEAR_MIPMAP_NEAREST = 0x2701; +enum uint GL_NEAREST_MIPMAP_LINEAR = 0x2702; +enum uint GL_LINEAR_MIPMAP_LINEAR = 0x2703; +enum uint GL_TEXTURE_MAG_FILTER = 0x2800; +enum uint GL_TEXTURE_MIN_FILTER = 0x2801; +enum uint GL_TEXTURE_WRAP_S = 0x2802; +enum uint GL_TEXTURE_WRAP_T = 0x2803; +enum uint GL_REPEAT = 0x2901; +enum uint GL_CURRENT_BIT = 0x00000001; +enum uint GL_POINT_BIT = 0x00000002; +enum uint GL_LINE_BIT = 0x00000004; +enum uint GL_POLYGON_BIT = 0x00000008; +enum uint GL_POLYGON_STIPPLE_BIT = 0x00000010; +enum uint GL_PIXEL_MODE_BIT = 0x00000020; +enum uint GL_LIGHTING_BIT = 0x00000040; +enum uint GL_FOG_BIT = 0x00000080; +enum uint GL_ACCUM_BUFFER_BIT = 0x00000200; +enum uint GL_VIEWPORT_BIT = 0x00000800; +enum uint GL_TRANSFORM_BIT = 0x00001000; +enum uint GL_ENABLE_BIT = 0x00002000; +enum uint GL_HINT_BIT = 0x00008000; +enum uint GL_EVAL_BIT = 0x00010000; +enum uint GL_LIST_BIT = 0x00020000; +enum uint GL_TEXTURE_BIT = 0x00040000; +enum uint GL_SCISSOR_BIT = 0x00080000; +enum uint GL_ALL_ATTRIB_BITS = 0xFFFFFFFF; +enum uint GL_QUAD_STRIP = 0x0008; +enum uint GL_POLYGON = 0x0009; +enum uint GL_ACCUM = 0x0100; +enum uint GL_LOAD = 0x0101; +enum uint GL_RETURN = 0x0102; +enum uint GL_MULT = 0x0103; +enum uint GL_ADD = 0x0104; +enum uint GL_AUX0 = 0x0409; +enum uint GL_AUX1 = 0x040A; +enum uint GL_AUX2 = 0x040B; +enum uint GL_AUX3 = 0x040C; +enum uint GL_2D = 0x0600; +enum uint GL_3D = 0x0601; +enum uint GL_3D_COLOR = 0x0602; +enum uint GL_3D_COLOR_TEXTURE = 0x0603; +enum uint GL_4D_COLOR_TEXTURE = 0x0604; +enum uint GL_PASS_THROUGH_TOKEN = 0x0700; +enum uint GL_POINT_TOKEN = 0x0701; +enum uint GL_LINE_TOKEN = 0x0702; +enum uint GL_POLYGON_TOKEN = 0x0703; +enum uint GL_BITMAP_TOKEN = 0x0704; +enum uint GL_DRAW_PIXEL_TOKEN = 0x0705; +enum uint GL_COPY_PIXEL_TOKEN = 0x0706; +enum uint GL_LINE_RESET_TOKEN = 0x0707; +enum uint GL_EXP = 0x0800; +enum uint GL_EXP2 = 0x0801; +enum uint GL_COEFF = 0x0A00; +enum uint GL_ORDER = 0x0A01; +enum uint GL_DOMAIN = 0x0A02; +enum uint GL_PIXEL_MAP_I_TO_I = 0x0C70; +enum uint GL_PIXEL_MAP_S_TO_S = 0x0C71; +enum uint GL_PIXEL_MAP_I_TO_R = 0x0C72; +enum uint GL_PIXEL_MAP_I_TO_G = 0x0C73; +enum uint GL_PIXEL_MAP_I_TO_B = 0x0C74; +enum uint GL_PIXEL_MAP_I_TO_A = 0x0C75; +enum uint GL_PIXEL_MAP_R_TO_R = 0x0C76; +enum uint GL_PIXEL_MAP_G_TO_G = 0x0C77; +enum uint GL_PIXEL_MAP_B_TO_B = 0x0C78; +enum uint GL_PIXEL_MAP_A_TO_A = 0x0C79; +enum uint GL_CURRENT_COLOR = 0x0B00; +enum uint GL_CURRENT_INDEX = 0x0B01; +enum uint GL_CURRENT_NORMAL = 0x0B02; +enum uint GL_CURRENT_TEXTURE_COORDS = 0x0B03; +enum uint GL_CURRENT_RASTER_COLOR = 0x0B04; +enum uint GL_CURRENT_RASTER_INDEX = 0x0B05; +enum uint GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06; +enum uint GL_CURRENT_RASTER_POSITION = 0x0B07; +enum uint GL_CURRENT_RASTER_POSITION_VALID = 0x0B08; +enum uint GL_CURRENT_RASTER_DISTANCE = 0x0B09; +enum uint GL_POINT_SMOOTH = 0x0B10; +enum uint GL_LINE_STIPPLE = 0x0B24; +enum uint GL_LINE_STIPPLE_PATTERN = 0x0B25; +enum uint GL_LINE_STIPPLE_REPEAT = 0x0B26; +enum uint GL_LIST_MODE = 0x0B30; +enum uint GL_MAX_LIST_NESTING = 0x0B31; +enum uint GL_LIST_BASE = 0x0B32; +enum uint GL_LIST_INDEX = 0x0B33; +enum uint GL_POLYGON_STIPPLE = 0x0B42; +enum uint GL_EDGE_FLAG = 0x0B43; +enum uint GL_LIGHTING = 0x0B50; +enum uint GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51; +enum uint GL_LIGHT_MODEL_TWO_SIDE = 0x0B52; +enum uint GL_LIGHT_MODEL_AMBIENT = 0x0B53; +enum uint GL_SHADE_MODEL = 0x0B54; +enum uint GL_COLOR_MATERIAL_FACE = 0x0B55; +enum uint GL_COLOR_MATERIAL_PARAMETER = 0x0B56; +enum uint GL_COLOR_MATERIAL = 0x0B57; +enum uint GL_FOG = 0x0B60; +enum uint GL_FOG_INDEX = 0x0B61; +enum uint GL_FOG_DENSITY = 0x0B62; +enum uint GL_FOG_START = 0x0B63; +enum uint GL_FOG_END = 0x0B64; +enum uint GL_FOG_MODE = 0x0B65; +enum uint GL_FOG_COLOR = 0x0B66; +enum uint GL_ACCUM_CLEAR_VALUE = 0x0B80; +enum uint GL_MATRIX_MODE = 0x0BA0; +enum uint GL_NORMALIZE = 0x0BA1; +enum uint GL_MODELVIEW_STACK_DEPTH = 0x0BA3; +enum uint GL_PROJECTION_STACK_DEPTH = 0x0BA4; +enum uint GL_TEXTURE_STACK_DEPTH = 0x0BA5; +enum uint GL_MODELVIEW_MATRIX = 0x0BA6; +enum uint GL_PROJECTION_MATRIX = 0x0BA7; +enum uint GL_TEXTURE_MATRIX = 0x0BA8; +enum uint GL_ATTRIB_STACK_DEPTH = 0x0BB0; +enum uint GL_ALPHA_TEST = 0x0BC0; +enum uint GL_ALPHA_TEST_FUNC = 0x0BC1; +enum uint GL_ALPHA_TEST_REF = 0x0BC2; +enum uint GL_LOGIC_OP = 0x0BF1; +enum uint GL_AUX_BUFFERS = 0x0C00; +enum uint GL_INDEX_CLEAR_VALUE = 0x0C20; +enum uint GL_INDEX_WRITEMASK = 0x0C21; +enum uint GL_INDEX_MODE = 0x0C30; +enum uint GL_RGBA_MODE = 0x0C31; +enum uint GL_RENDER_MODE = 0x0C40; +enum uint GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50; +enum uint GL_POINT_SMOOTH_HINT = 0x0C51; +enum uint GL_FOG_HINT = 0x0C54; +enum uint GL_TEXTURE_GEN_S = 0x0C60; +enum uint GL_TEXTURE_GEN_T = 0x0C61; +enum uint GL_TEXTURE_GEN_R = 0x0C62; +enum uint GL_TEXTURE_GEN_Q = 0x0C63; +enum uint GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0; +enum uint GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1; +enum uint GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2; +enum uint GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3; +enum uint GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4; +enum uint GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5; +enum uint GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6; +enum uint GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7; +enum uint GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8; +enum uint GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9; +enum uint GL_MAP_COLOR = 0x0D10; +enum uint GL_MAP_STENCIL = 0x0D11; +enum uint GL_INDEX_SHIFT = 0x0D12; +enum uint GL_INDEX_OFFSET = 0x0D13; +enum uint GL_RED_SCALE = 0x0D14; +enum uint GL_RED_BIAS = 0x0D15; +enum uint GL_ZOOM_X = 0x0D16; +enum uint GL_ZOOM_Y = 0x0D17; +enum uint GL_GREEN_SCALE = 0x0D18; +enum uint GL_GREEN_BIAS = 0x0D19; +enum uint GL_BLUE_SCALE = 0x0D1A; +enum uint GL_BLUE_BIAS = 0x0D1B; +enum uint GL_ALPHA_SCALE = 0x0D1C; +enum uint GL_ALPHA_BIAS = 0x0D1D; +enum uint GL_DEPTH_SCALE = 0x0D1E; +enum uint GL_DEPTH_BIAS = 0x0D1F; +enum uint GL_MAX_EVAL_ORDER = 0x0D30; +enum uint GL_MAX_LIGHTS = 0x0D31; +enum uint GL_MAX_CLIP_PLANES = 0x0D32; +enum uint GL_MAX_PIXEL_MAP_TABLE = 0x0D34; +enum uint GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35; +enum uint GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36; +enum uint GL_MAX_NAME_STACK_DEPTH = 0x0D37; +enum uint GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38; +enum uint GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39; +enum uint GL_INDEX_BITS = 0x0D51; +enum uint GL_RED_BITS = 0x0D52; +enum uint GL_GREEN_BITS = 0x0D53; +enum uint GL_BLUE_BITS = 0x0D54; +enum uint GL_ALPHA_BITS = 0x0D55; +enum uint GL_DEPTH_BITS = 0x0D56; +enum uint GL_STENCIL_BITS = 0x0D57; +enum uint GL_ACCUM_RED_BITS = 0x0D58; +enum uint GL_ACCUM_GREEN_BITS = 0x0D59; +enum uint GL_ACCUM_BLUE_BITS = 0x0D5A; +enum uint GL_ACCUM_ALPHA_BITS = 0x0D5B; +enum uint GL_NAME_STACK_DEPTH = 0x0D70; +enum uint GL_AUTO_NORMAL = 0x0D80; +enum uint GL_MAP1_COLOR_4 = 0x0D90; +enum uint GL_MAP1_INDEX = 0x0D91; +enum uint GL_MAP1_NORMAL = 0x0D92; +enum uint GL_MAP1_TEXTURE_COORD_1 = 0x0D93; +enum uint GL_MAP1_TEXTURE_COORD_2 = 0x0D94; +enum uint GL_MAP1_TEXTURE_COORD_3 = 0x0D95; +enum uint GL_MAP1_TEXTURE_COORD_4 = 0x0D96; +enum uint GL_MAP1_VERTEX_3 = 0x0D97; +enum uint GL_MAP1_VERTEX_4 = 0x0D98; +enum uint GL_MAP2_COLOR_4 = 0x0DB0; +enum uint GL_MAP2_INDEX = 0x0DB1; +enum uint GL_MAP2_NORMAL = 0x0DB2; +enum uint GL_MAP2_TEXTURE_COORD_1 = 0x0DB3; +enum uint GL_MAP2_TEXTURE_COORD_2 = 0x0DB4; +enum uint GL_MAP2_TEXTURE_COORD_3 = 0x0DB5; +enum uint GL_MAP2_TEXTURE_COORD_4 = 0x0DB6; +enum uint GL_MAP2_VERTEX_3 = 0x0DB7; +enum uint GL_MAP2_VERTEX_4 = 0x0DB8; +enum uint GL_MAP1_GRID_DOMAIN = 0x0DD0; +enum uint GL_MAP1_GRID_SEGMENTS = 0x0DD1; +enum uint GL_MAP2_GRID_DOMAIN = 0x0DD2; +enum uint GL_MAP2_GRID_SEGMENTS = 0x0DD3; +enum uint GL_TEXTURE_COMPONENTS = 0x1003; +enum uint GL_TEXTURE_BORDER = 0x1005; +enum uint GL_AMBIENT = 0x1200; +enum uint GL_DIFFUSE = 0x1201; +enum uint GL_SPECULAR = 0x1202; +enum uint GL_POSITION = 0x1203; +enum uint GL_SPOT_DIRECTION = 0x1204; +enum uint GL_SPOT_EXPONENT = 0x1205; +enum uint GL_SPOT_CUTOFF = 0x1206; +enum uint GL_CONSTANT_ATTENUATION = 0x1207; +enum uint GL_LINEAR_ATTENUATION = 0x1208; +enum uint GL_QUADRATIC_ATTENUATION = 0x1209; +enum uint GL_COMPILE = 0x1300; +enum uint GL_COMPILE_AND_EXECUTE = 0x1301; +enum uint GL_2_BYTES = 0x1407; +enum uint GL_3_BYTES = 0x1408; +enum uint GL_4_BYTES = 0x1409; +enum uint GL_EMISSION = 0x1600; +enum uint GL_SHININESS = 0x1601; +enum uint GL_AMBIENT_AND_DIFFUSE = 0x1602; +enum uint GL_COLOR_INDEXES = 0x1603; +enum uint GL_MODELVIEW = 0x1700; +enum uint GL_PROJECTION = 0x1701; +enum uint GL_COLOR_INDEX = 0x1900; +enum uint GL_LUMINANCE = 0x1909; +enum uint GL_LUMINANCE_ALPHA = 0x190A; +enum uint GL_BITMAP = 0x1A00; +enum uint GL_RENDER = 0x1C00; +enum uint GL_FEEDBACK = 0x1C01; +enum uint GL_SELECT = 0x1C02; +enum uint GL_FLAT = 0x1D00; +enum uint GL_SMOOTH = 0x1D01; +enum uint GL_S = 0x2000; +enum uint GL_T = 0x2001; +enum uint GL_R = 0x2002; +enum uint GL_Q = 0x2003; +enum uint GL_MODULATE = 0x2100; +enum uint GL_DECAL = 0x2101; +enum uint GL_TEXTURE_ENV_MODE = 0x2200; +enum uint GL_TEXTURE_ENV_COLOR = 0x2201; +enum uint GL_TEXTURE_ENV = 0x2300; +enum uint GL_EYE_LINEAR = 0x2400; +enum uint GL_OBJECT_LINEAR = 0x2401; +enum uint GL_SPHERE_MAP = 0x2402; +enum uint GL_TEXTURE_GEN_MODE = 0x2500; +enum uint GL_OBJECT_PLANE = 0x2501; +enum uint GL_EYE_PLANE = 0x2502; +enum uint GL_CLAMP = 0x2900; +enum uint GL_CLIP_PLANE0 = 0x3000; +enum uint GL_CLIP_PLANE1 = 0x3001; +enum uint GL_CLIP_PLANE2 = 0x3002; +enum uint GL_CLIP_PLANE3 = 0x3003; +enum uint GL_CLIP_PLANE4 = 0x3004; +enum uint GL_CLIP_PLANE5 = 0x3005; +enum uint GL_LIGHT0 = 0x4000; +enum uint GL_LIGHT1 = 0x4001; +enum uint GL_LIGHT2 = 0x4002; +enum uint GL_LIGHT3 = 0x4003; +enum uint GL_LIGHT4 = 0x4004; +enum uint GL_LIGHT5 = 0x4005; +enum uint GL_LIGHT6 = 0x4006; +enum uint GL_LIGHT7 = 0x4007; +enum uint GL_COLOR_LOGIC_OP = 0x0BF2; +enum uint GL_POLYGON_OFFSET_UNITS = 0x2A00; +enum uint GL_POLYGON_OFFSET_POINT = 0x2A01; +enum uint GL_POLYGON_OFFSET_LINE = 0x2A02; +enum uint GL_POLYGON_OFFSET_FILL = 0x8037; +enum uint GL_POLYGON_OFFSET_FACTOR = 0x8038; +enum uint GL_TEXTURE_BINDING_1D = 0x8068; +enum uint GL_TEXTURE_BINDING_2D = 0x8069; +enum uint GL_TEXTURE_INTERNAL_FORMAT = 0x1003; +enum uint GL_TEXTURE_RED_SIZE = 0x805C; +enum uint GL_TEXTURE_GREEN_SIZE = 0x805D; +enum uint GL_TEXTURE_BLUE_SIZE = 0x805E; +enum uint GL_TEXTURE_ALPHA_SIZE = 0x805F; +enum uint GL_DOUBLE = 0x140A; +enum uint GL_PROXY_TEXTURE_1D = 0x8063; +enum uint GL_PROXY_TEXTURE_2D = 0x8064; +enum uint GL_R3_G3_B2 = 0x2A10; +enum uint GL_RGB4 = 0x804F; +enum uint GL_RGB5 = 0x8050; +enum uint GL_RGB8 = 0x8051; +enum uint GL_RGB10 = 0x8052; +enum uint GL_RGB12 = 0x8053; +enum uint GL_RGB16 = 0x8054; +enum uint GL_RGBA2 = 0x8055; +enum uint GL_RGBA4 = 0x8056; +enum uint GL_RGB5_A1 = 0x8057; +enum uint GL_RGBA8 = 0x8058; +enum uint GL_RGB10_A2 = 0x8059; +enum uint GL_RGBA12 = 0x805A; +enum uint GL_RGBA16 = 0x805B; +enum uint GL_CLIENT_PIXEL_STORE_BIT = 0x00000001; +enum uint GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002; +enum uint GL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF; +enum uint GL_VERTEX_ARRAY_POINTER = 0x808E; +enum uint GL_NORMAL_ARRAY_POINTER = 0x808F; +enum uint GL_COLOR_ARRAY_POINTER = 0x8090; +enum uint GL_INDEX_ARRAY_POINTER = 0x8091; +enum uint GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092; +enum uint GL_EDGE_FLAG_ARRAY_POINTER = 0x8093; +enum uint GL_FEEDBACK_BUFFER_POINTER = 0x0DF0; +enum uint GL_SELECTION_BUFFER_POINTER = 0x0DF3; +enum uint GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1; +enum uint GL_INDEX_LOGIC_OP = 0x0BF1; +enum uint GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B; +enum uint GL_FEEDBACK_BUFFER_SIZE = 0x0DF1; +enum uint GL_FEEDBACK_BUFFER_TYPE = 0x0DF2; +enum uint GL_SELECTION_BUFFER_SIZE = 0x0DF4; +enum uint GL_VERTEX_ARRAY = 0x8074; +enum uint GL_NORMAL_ARRAY = 0x8075; +enum uint GL_COLOR_ARRAY = 0x8076; +enum uint GL_INDEX_ARRAY = 0x8077; +enum uint GL_TEXTURE_COORD_ARRAY = 0x8078; +enum uint GL_EDGE_FLAG_ARRAY = 0x8079; +enum uint GL_VERTEX_ARRAY_SIZE = 0x807A; +enum uint GL_VERTEX_ARRAY_TYPE = 0x807B; +enum uint GL_VERTEX_ARRAY_STRIDE = 0x807C; +enum uint GL_NORMAL_ARRAY_TYPE = 0x807E; +enum uint GL_NORMAL_ARRAY_STRIDE = 0x807F; +enum uint GL_COLOR_ARRAY_SIZE = 0x8081; +enum uint GL_COLOR_ARRAY_TYPE = 0x8082; +enum uint GL_COLOR_ARRAY_STRIDE = 0x8083; +enum uint GL_INDEX_ARRAY_TYPE = 0x8085; +enum uint GL_INDEX_ARRAY_STRIDE = 0x8086; +enum uint GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088; +enum uint GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089; +enum uint GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A; +enum uint GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C; +enum uint GL_TEXTURE_LUMINANCE_SIZE = 0x8060; +enum uint GL_TEXTURE_INTENSITY_SIZE = 0x8061; +enum uint GL_TEXTURE_PRIORITY = 0x8066; +enum uint GL_TEXTURE_RESIDENT = 0x8067; +enum uint GL_ALPHA4 = 0x803B; +enum uint GL_ALPHA8 = 0x803C; +enum uint GL_ALPHA12 = 0x803D; +enum uint GL_ALPHA16 = 0x803E; +enum uint GL_LUMINANCE4 = 0x803F; +enum uint GL_LUMINANCE8 = 0x8040; +enum uint GL_LUMINANCE12 = 0x8041; +enum uint GL_LUMINANCE16 = 0x8042; +enum uint GL_LUMINANCE4_ALPHA4 = 0x8043; +enum uint GL_LUMINANCE6_ALPHA2 = 0x8044; +enum uint GL_LUMINANCE8_ALPHA8 = 0x8045; +enum uint GL_LUMINANCE12_ALPHA4 = 0x8046; +enum uint GL_LUMINANCE12_ALPHA12 = 0x8047; +enum uint GL_LUMINANCE16_ALPHA16 = 0x8048; +enum uint GL_INTENSITY = 0x8049; +enum uint GL_INTENSITY4 = 0x804A; +enum uint GL_INTENSITY8 = 0x804B; +enum uint GL_INTENSITY12 = 0x804C; +enum uint GL_INTENSITY16 = 0x804D; +enum uint GL_V2F = 0x2A20; +enum uint GL_V3F = 0x2A21; +enum uint GL_C4UB_V2F = 0x2A22; +enum uint GL_C4UB_V3F = 0x2A23; +enum uint GL_C3F_V3F = 0x2A24; +enum uint GL_N3F_V3F = 0x2A25; +enum uint GL_C4F_N3F_V3F = 0x2A26; +enum uint GL_T2F_V3F = 0x2A27; +enum uint GL_T4F_V4F = 0x2A28; +enum uint GL_T2F_C4UB_V3F = 0x2A29; +enum uint GL_T2F_C3F_V3F = 0x2A2A; +enum uint GL_T2F_N3F_V3F = 0x2A2B; +enum uint GL_T2F_C4F_N3F_V3F = 0x2A2C; +enum uint GL_T4F_C4F_N3F_V4F = 0x2A2D; +enum uint GL_UNSIGNED_BYTE_3_3_2 = 0x8032; +enum uint GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033; +enum uint GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034; +enum uint GL_UNSIGNED_INT_8_8_8_8 = 0x8035; +enum uint GL_UNSIGNED_INT_10_10_10_2 = 0x8036; +enum uint GL_TEXTURE_BINDING_3D = 0x806A; +enum uint GL_PACK_SKIP_IMAGES = 0x806B; +enum uint GL_PACK_IMAGE_HEIGHT = 0x806C; +enum uint GL_UNPACK_SKIP_IMAGES = 0x806D; +enum uint GL_UNPACK_IMAGE_HEIGHT = 0x806E; +enum uint GL_TEXTURE_3D = 0x806F; +enum uint GL_PROXY_TEXTURE_3D = 0x8070; +enum uint GL_TEXTURE_DEPTH = 0x8071; +enum uint GL_TEXTURE_WRAP_R = 0x8072; +enum uint GL_MAX_3D_TEXTURE_SIZE = 0x8073; +enum uint GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362; +enum uint GL_UNSIGNED_SHORT_5_6_5 = 0x8363; +enum uint GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364; +enum uint GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; +enum uint GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; +enum uint GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367; +enum uint GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368; +enum uint GL_BGR = 0x80E0; +enum uint GL_BGRA = 0x80E1; +enum uint GL_MAX_ELEMENTS_VERTICES = 0x80E8; +enum uint GL_MAX_ELEMENTS_INDICES = 0x80E9; +enum uint GL_CLAMP_TO_EDGE = 0x812F; +enum uint GL_TEXTURE_MIN_LOD = 0x813A; +enum uint GL_TEXTURE_MAX_LOD = 0x813B; +enum uint GL_TEXTURE_BASE_LEVEL = 0x813C; +enum uint GL_TEXTURE_MAX_LEVEL = 0x813D; +enum uint GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12; +enum uint GL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; +enum uint GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22; +enum uint GL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; +enum uint GL_ALIASED_LINE_WIDTH_RANGE = 0x846E; +enum uint GL_RESCALE_NORMAL = 0x803A; +enum uint GL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8; +enum uint GL_SINGLE_COLOR = 0x81F9; +enum uint GL_SEPARATE_SPECULAR_COLOR = 0x81FA; +enum uint GL_ALIASED_POINT_SIZE_RANGE = 0x846D; +enum uint GL_TEXTURE0 = 0x84C0; +enum uint GL_TEXTURE1 = 0x84C1; +enum uint GL_TEXTURE2 = 0x84C2; +enum uint GL_TEXTURE3 = 0x84C3; +enum uint GL_TEXTURE4 = 0x84C4; +enum uint GL_TEXTURE5 = 0x84C5; +enum uint GL_TEXTURE6 = 0x84C6; +enum uint GL_TEXTURE7 = 0x84C7; +enum uint GL_TEXTURE8 = 0x84C8; +enum uint GL_TEXTURE9 = 0x84C9; +enum uint GL_TEXTURE10 = 0x84CA; +enum uint GL_TEXTURE11 = 0x84CB; +enum uint GL_TEXTURE12 = 0x84CC; +enum uint GL_TEXTURE13 = 0x84CD; +enum uint GL_TEXTURE14 = 0x84CE; +enum uint GL_TEXTURE15 = 0x84CF; +enum uint GL_TEXTURE16 = 0x84D0; +enum uint GL_TEXTURE17 = 0x84D1; +enum uint GL_TEXTURE18 = 0x84D2; +enum uint GL_TEXTURE19 = 0x84D3; +enum uint GL_TEXTURE20 = 0x84D4; +enum uint GL_TEXTURE21 = 0x84D5; +enum uint GL_TEXTURE22 = 0x84D6; +enum uint GL_TEXTURE23 = 0x84D7; +enum uint GL_TEXTURE24 = 0x84D8; +enum uint GL_TEXTURE25 = 0x84D9; +enum uint GL_TEXTURE26 = 0x84DA; +enum uint GL_TEXTURE27 = 0x84DB; +enum uint GL_TEXTURE28 = 0x84DC; +enum uint GL_TEXTURE29 = 0x84DD; +enum uint GL_TEXTURE30 = 0x84DE; +enum uint GL_TEXTURE31 = 0x84DF; +enum uint GL_ACTIVE_TEXTURE = 0x84E0; +enum uint GL_MULTISAMPLE = 0x809D; +enum uint GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E; +enum uint GL_SAMPLE_ALPHA_TO_ONE = 0x809F; +enum uint GL_SAMPLE_COVERAGE = 0x80A0; +enum uint GL_SAMPLE_BUFFERS = 0x80A8; +enum uint GL_SAMPLES = 0x80A9; +enum uint GL_SAMPLE_COVERAGE_VALUE = 0x80AA; +enum uint GL_SAMPLE_COVERAGE_INVERT = 0x80AB; +enum uint GL_TEXTURE_CUBE_MAP = 0x8513; +enum uint GL_TEXTURE_BINDING_CUBE_MAP = 0x8514; +enum uint GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; +enum uint GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; +enum uint GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; +enum uint GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; +enum uint GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; +enum uint GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; +enum uint GL_PROXY_TEXTURE_CUBE_MAP = 0x851B; +enum uint GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; +enum uint GL_COMPRESSED_RGB = 0x84ED; +enum uint GL_COMPRESSED_RGBA = 0x84EE; +enum uint GL_TEXTURE_COMPRESSION_HINT = 0x84EF; +enum uint GL_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0; +enum uint GL_TEXTURE_COMPRESSED = 0x86A1; +enum uint GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; +enum uint GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3; +enum uint GL_CLAMP_TO_BORDER = 0x812D; +enum uint GL_CLIENT_ACTIVE_TEXTURE = 0x84E1; +enum uint GL_MAX_TEXTURE_UNITS = 0x84E2; +enum uint GL_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3; +enum uint GL_TRANSPOSE_PROJECTION_MATRIX = 0x84E4; +enum uint GL_TRANSPOSE_TEXTURE_MATRIX = 0x84E5; +enum uint GL_TRANSPOSE_COLOR_MATRIX = 0x84E6; +enum uint GL_MULTISAMPLE_BIT = 0x20000000; +enum uint GL_NORMAL_MAP = 0x8511; +enum uint GL_REFLECTION_MAP = 0x8512; +enum uint GL_COMPRESSED_ALPHA = 0x84E9; +enum uint GL_COMPRESSED_LUMINANCE = 0x84EA; +enum uint GL_COMPRESSED_LUMINANCE_ALPHA = 0x84EB; +enum uint GL_COMPRESSED_INTENSITY = 0x84EC; +enum uint GL_COMBINE = 0x8570; +enum uint GL_COMBINE_RGB = 0x8571; +enum uint GL_COMBINE_ALPHA = 0x8572; +enum uint GL_SOURCE0_RGB = 0x8580; +enum uint GL_SOURCE1_RGB = 0x8581; +enum uint GL_SOURCE2_RGB = 0x8582; +enum uint GL_SOURCE0_ALPHA = 0x8588; +enum uint GL_SOURCE1_ALPHA = 0x8589; +enum uint GL_SOURCE2_ALPHA = 0x858A; +enum uint GL_OPERAND0_RGB = 0x8590; +enum uint GL_OPERAND1_RGB = 0x8591; +enum uint GL_OPERAND2_RGB = 0x8592; +enum uint GL_OPERAND0_ALPHA = 0x8598; +enum uint GL_OPERAND1_ALPHA = 0x8599; +enum uint GL_OPERAND2_ALPHA = 0x859A; +enum uint GL_RGB_SCALE = 0x8573; +enum uint GL_ADD_SIGNED = 0x8574; +enum uint GL_INTERPOLATE = 0x8575; +enum uint GL_SUBTRACT = 0x84E7; +enum uint GL_CONSTANT = 0x8576; +enum uint GL_PRIMARY_COLOR = 0x8577; +enum uint GL_PREVIOUS = 0x8578; +enum uint GL_DOT3_RGB = 0x86AE; +enum uint GL_DOT3_RGBA = 0x86AF; +enum uint GL_BLEND_DST_RGB = 0x80C8; +enum uint GL_BLEND_SRC_RGB = 0x80C9; +enum uint GL_BLEND_DST_ALPHA = 0x80CA; +enum uint GL_BLEND_SRC_ALPHA = 0x80CB; +enum uint GL_POINT_FADE_THRESHOLD_SIZE = 0x8128; +enum uint GL_DEPTH_COMPONENT16 = 0x81A5; +enum uint GL_DEPTH_COMPONENT24 = 0x81A6; +enum uint GL_DEPTH_COMPONENT32 = 0x81A7; +enum uint GL_MIRRORED_REPEAT = 0x8370; +enum uint GL_MAX_TEXTURE_LOD_BIAS = 0x84FD; +enum uint GL_TEXTURE_LOD_BIAS = 0x8501; +enum uint GL_INCR_WRAP = 0x8507; +enum uint GL_DECR_WRAP = 0x8508; +enum uint GL_TEXTURE_DEPTH_SIZE = 0x884A; +enum uint GL_TEXTURE_COMPARE_MODE = 0x884C; +enum uint GL_TEXTURE_COMPARE_FUNC = 0x884D; +enum uint GL_POINT_SIZE_MIN = 0x8126; +enum uint GL_POINT_SIZE_MAX = 0x8127; +enum uint GL_POINT_DISTANCE_ATTENUATION = 0x8129; +enum uint GL_GENERATE_MIPMAP = 0x8191; +enum uint GL_GENERATE_MIPMAP_HINT = 0x8192; +enum uint GL_FOG_COORDINATE_SOURCE = 0x8450; +enum uint GL_FOG_COORDINATE = 0x8451; +enum uint GL_FRAGMENT_DEPTH = 0x8452; +enum uint GL_CURRENT_FOG_COORDINATE = 0x8453; +enum uint GL_FOG_COORDINATE_ARRAY_TYPE = 0x8454; +enum uint GL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455; +enum uint GL_FOG_COORDINATE_ARRAY_POINTER = 0x8456; +enum uint GL_FOG_COORDINATE_ARRAY = 0x8457; +enum uint GL_COLOR_SUM = 0x8458; +enum uint GL_CURRENT_SECONDARY_COLOR = 0x8459; +enum uint GL_SECONDARY_COLOR_ARRAY_SIZE = 0x845A; +enum uint GL_SECONDARY_COLOR_ARRAY_TYPE = 0x845B; +enum uint GL_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C; +enum uint GL_SECONDARY_COLOR_ARRAY_POINTER = 0x845D; +enum uint GL_SECONDARY_COLOR_ARRAY = 0x845E; +enum uint GL_TEXTURE_FILTER_CONTROL = 0x8500; +enum uint GL_DEPTH_TEXTURE_MODE = 0x884B; +enum uint GL_COMPARE_R_TO_TEXTURE = 0x884E; +enum uint GL_BLEND_COLOR = 0x8005; +enum uint GL_BLEND_EQUATION = 0x8009; +enum uint GL_CONSTANT_COLOR = 0x8001; +enum uint GL_ONE_MINUS_CONSTANT_COLOR = 0x8002; +enum uint GL_CONSTANT_ALPHA = 0x8003; +enum uint GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004; +enum uint GL_FUNC_ADD = 0x8006; +enum uint GL_FUNC_REVERSE_SUBTRACT = 0x800B; +enum uint GL_FUNC_SUBTRACT = 0x800A; +enum uint GL_MIN = 0x8007; +enum uint GL_MAX = 0x8008; +enum uint GL_BUFFER_SIZE = 0x8764; +enum uint GL_BUFFER_USAGE = 0x8765; +enum uint GL_QUERY_COUNTER_BITS = 0x8864; +enum uint GL_CURRENT_QUERY = 0x8865; +enum uint GL_QUERY_RESULT = 0x8866; +enum uint GL_QUERY_RESULT_AVAILABLE = 0x8867; +enum uint GL_ARRAY_BUFFER = 0x8892; +enum uint GL_ELEMENT_ARRAY_BUFFER = 0x8893; +enum uint GL_ARRAY_BUFFER_BINDING = 0x8894; +enum uint GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; +enum uint GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; +enum uint GL_READ_ONLY = 0x88B8; +enum uint GL_WRITE_ONLY = 0x88B9; +enum uint GL_READ_WRITE = 0x88BA; +enum uint GL_BUFFER_ACCESS = 0x88BB; +enum uint GL_BUFFER_MAPPED = 0x88BC; +enum uint GL_BUFFER_MAP_POINTER = 0x88BD; +enum uint GL_STREAM_DRAW = 0x88E0; +enum uint GL_STREAM_READ = 0x88E1; +enum uint GL_STREAM_COPY = 0x88E2; +enum uint GL_STATIC_DRAW = 0x88E4; +enum uint GL_STATIC_READ = 0x88E5; +enum uint GL_STATIC_COPY = 0x88E6; +enum uint GL_DYNAMIC_DRAW = 0x88E8; +enum uint GL_DYNAMIC_READ = 0x88E9; +enum uint GL_DYNAMIC_COPY = 0x88EA; +enum uint GL_SAMPLES_PASSED = 0x8914; +enum uint GL_SRC1_ALPHA = 0x8589; +enum uint GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896; +enum uint GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897; +enum uint GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898; +enum uint GL_INDEX_ARRAY_BUFFER_BINDING = 0x8899; +enum uint GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A; +enum uint GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B; +enum uint GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C; +enum uint GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D; +enum uint GL_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E; +enum uint GL_FOG_COORD_SRC = 0x8450; +enum uint GL_FOG_COORD = 0x8451; +enum uint GL_CURRENT_FOG_COORD = 0x8453; +enum uint GL_FOG_COORD_ARRAY_TYPE = 0x8454; +enum uint GL_FOG_COORD_ARRAY_STRIDE = 0x8455; +enum uint GL_FOG_COORD_ARRAY_POINTER = 0x8456; +enum uint GL_FOG_COORD_ARRAY = 0x8457; +enum uint GL_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D; +enum uint GL_SRC0_RGB = 0x8580; +enum uint GL_SRC1_RGB = 0x8581; +enum uint GL_SRC2_RGB = 0x8582; +enum uint GL_SRC0_ALPHA = 0x8588; +enum uint GL_SRC2_ALPHA = 0x858A; +enum uint GL_BLEND_EQUATION_RGB = 0x8009; +enum uint GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; +enum uint GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; +enum uint GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; +enum uint GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; +enum uint GL_CURRENT_VERTEX_ATTRIB = 0x8626; +enum uint GL_VERTEX_PROGRAM_POINT_SIZE = 0x8642; +enum uint GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; +enum uint GL_STENCIL_BACK_FUNC = 0x8800; +enum uint GL_STENCIL_BACK_FAIL = 0x8801; +enum uint GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; +enum uint GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; +enum uint GL_MAX_DRAW_BUFFERS = 0x8824; +enum uint GL_DRAW_BUFFER0 = 0x8825; +enum uint GL_DRAW_BUFFER1 = 0x8826; +enum uint GL_DRAW_BUFFER2 = 0x8827; +enum uint GL_DRAW_BUFFER3 = 0x8828; +enum uint GL_DRAW_BUFFER4 = 0x8829; +enum uint GL_DRAW_BUFFER5 = 0x882A; +enum uint GL_DRAW_BUFFER6 = 0x882B; +enum uint GL_DRAW_BUFFER7 = 0x882C; +enum uint GL_DRAW_BUFFER8 = 0x882D; +enum uint GL_DRAW_BUFFER9 = 0x882E; +enum uint GL_DRAW_BUFFER10 = 0x882F; +enum uint GL_DRAW_BUFFER11 = 0x8830; +enum uint GL_DRAW_BUFFER12 = 0x8831; +enum uint GL_DRAW_BUFFER13 = 0x8832; +enum uint GL_DRAW_BUFFER14 = 0x8833; +enum uint GL_DRAW_BUFFER15 = 0x8834; +enum uint GL_BLEND_EQUATION_ALPHA = 0x883D; +enum uint GL_MAX_VERTEX_ATTRIBS = 0x8869; +enum uint GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; +enum uint GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872; +enum uint GL_FRAGMENT_SHADER = 0x8B30; +enum uint GL_VERTEX_SHADER = 0x8B31; +enum uint GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; +enum uint GL_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; +enum uint GL_MAX_VARYING_FLOATS = 0x8B4B; +enum uint GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; +enum uint GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; +enum uint GL_SHADER_TYPE = 0x8B4F; +enum uint GL_FLOAT_VEC2 = 0x8B50; +enum uint GL_FLOAT_VEC3 = 0x8B51; +enum uint GL_FLOAT_VEC4 = 0x8B52; +enum uint GL_INT_VEC2 = 0x8B53; +enum uint GL_INT_VEC3 = 0x8B54; +enum uint GL_INT_VEC4 = 0x8B55; +enum uint GL_BOOL = 0x8B56; +enum uint GL_BOOL_VEC2 = 0x8B57; +enum uint GL_BOOL_VEC3 = 0x8B58; +enum uint GL_BOOL_VEC4 = 0x8B59; +enum uint GL_FLOAT_MAT2 = 0x8B5A; +enum uint GL_FLOAT_MAT3 = 0x8B5B; +enum uint GL_FLOAT_MAT4 = 0x8B5C; +enum uint GL_SAMPLER_1D = 0x8B5D; +enum uint GL_SAMPLER_2D = 0x8B5E; +enum uint GL_SAMPLER_3D = 0x8B5F; +enum uint GL_SAMPLER_CUBE = 0x8B60; +enum uint GL_SAMPLER_1D_SHADOW = 0x8B61; +enum uint GL_SAMPLER_2D_SHADOW = 0x8B62; +enum uint GL_DELETE_STATUS = 0x8B80; +enum uint GL_COMPILE_STATUS = 0x8B81; +enum uint GL_LINK_STATUS = 0x8B82; +enum uint GL_VALIDATE_STATUS = 0x8B83; +enum uint GL_INFO_LOG_LENGTH = 0x8B84; +enum uint GL_ATTACHED_SHADERS = 0x8B85; +enum uint GL_ACTIVE_UNIFORMS = 0x8B86; +enum uint GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; +enum uint GL_SHADER_SOURCE_LENGTH = 0x8B88; +enum uint GL_ACTIVE_ATTRIBUTES = 0x8B89; +enum uint GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; +enum uint GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; +enum uint GL_SHADING_LANGUAGE_VERSION = 0x8B8C; +enum uint GL_CURRENT_PROGRAM = 0x8B8D; +enum uint GL_POINT_SPRITE_COORD_ORIGIN = 0x8CA0; +enum uint GL_LOWER_LEFT = 0x8CA1; +enum uint GL_UPPER_LEFT = 0x8CA2; +enum uint GL_STENCIL_BACK_REF = 0x8CA3; +enum uint GL_STENCIL_BACK_VALUE_MASK = 0x8CA4; +enum uint GL_STENCIL_BACK_WRITEMASK = 0x8CA5; +enum uint GL_VERTEX_PROGRAM_TWO_SIDE = 0x8643; +enum uint GL_POINT_SPRITE = 0x8861; +enum uint GL_COORD_REPLACE = 0x8862; +enum uint GL_MAX_TEXTURE_COORDS = 0x8871; +enum uint GL_PIXEL_PACK_BUFFER = 0x88EB; +enum uint GL_PIXEL_UNPACK_BUFFER = 0x88EC; +enum uint GL_PIXEL_PACK_BUFFER_BINDING = 0x88ED; +enum uint GL_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; +enum uint GL_FLOAT_MAT2x3 = 0x8B65; +enum uint GL_FLOAT_MAT2x4 = 0x8B66; +enum uint GL_FLOAT_MAT3x2 = 0x8B67; +enum uint GL_FLOAT_MAT3x4 = 0x8B68; +enum uint GL_FLOAT_MAT4x2 = 0x8B69; +enum uint GL_FLOAT_MAT4x3 = 0x8B6A; +enum uint GL_SRGB = 0x8C40; +enum uint GL_SRGB8 = 0x8C41; +enum uint GL_SRGB_ALPHA = 0x8C42; +enum uint GL_SRGB8_ALPHA8 = 0x8C43; +enum uint GL_COMPRESSED_SRGB = 0x8C48; +enum uint GL_COMPRESSED_SRGB_ALPHA = 0x8C49; +enum uint GL_CURRENT_RASTER_SECONDARY_COLOR = 0x845F; +enum uint GL_SLUMINANCE_ALPHA = 0x8C44; +enum uint GL_SLUMINANCE8_ALPHA8 = 0x8C45; +enum uint GL_SLUMINANCE = 0x8C46; +enum uint GL_SLUMINANCE8 = 0x8C47; +enum uint GL_COMPRESSED_SLUMINANCE = 0x8C4A; +enum uint GL_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B; +enum uint GL_COMPARE_REF_TO_TEXTURE = 0x884E; +enum uint GL_CLIP_DISTANCE0 = 0x3000; +enum uint GL_CLIP_DISTANCE1 = 0x3001; +enum uint GL_CLIP_DISTANCE2 = 0x3002; +enum uint GL_CLIP_DISTANCE3 = 0x3003; +enum uint GL_CLIP_DISTANCE4 = 0x3004; +enum uint GL_CLIP_DISTANCE5 = 0x3005; +enum uint GL_CLIP_DISTANCE6 = 0x3006; +enum uint GL_CLIP_DISTANCE7 = 0x3007; +enum uint GL_MAX_CLIP_DISTANCES = 0x0D32; +enum uint GL_MAJOR_VERSION = 0x821B; +enum uint GL_MINOR_VERSION = 0x821C; +enum uint GL_NUM_EXTENSIONS = 0x821D; +enum uint GL_CONTEXT_FLAGS = 0x821E; +enum uint GL_COMPRESSED_RED = 0x8225; +enum uint GL_COMPRESSED_RG = 0x8226; +enum uint GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001; +enum uint GL_RGBA32F = 0x8814; +enum uint GL_RGB32F = 0x8815; +enum uint GL_RGBA16F = 0x881A; +enum uint GL_RGB16F = 0x881B; +enum uint GL_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; +enum uint GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; +enum uint GL_MIN_PROGRAM_TEXEL_OFFSET = 0x8904; +enum uint GL_MAX_PROGRAM_TEXEL_OFFSET = 0x8905; +enum uint GL_CLAMP_READ_COLOR = 0x891C; +enum uint GL_FIXED_ONLY = 0x891D; +enum uint GL_MAX_VARYING_COMPONENTS = 0x8B4B; +enum uint GL_TEXTURE_1D_ARRAY = 0x8C18; +enum uint GL_PROXY_TEXTURE_1D_ARRAY = 0x8C19; +enum uint GL_TEXTURE_2D_ARRAY = 0x8C1A; +enum uint GL_PROXY_TEXTURE_2D_ARRAY = 0x8C1B; +enum uint GL_TEXTURE_BINDING_1D_ARRAY = 0x8C1C; +enum uint GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D; +enum uint GL_R11F_G11F_B10F = 0x8C3A; +enum uint GL_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; +enum uint GL_RGB9_E5 = 0x8C3D; +enum uint GL_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; +enum uint GL_TEXTURE_SHARED_SIZE = 0x8C3F; +enum uint GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; +enum uint GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; +enum uint GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; +enum uint GL_PRIMITIVES_GENERATED = 0x8C87; +enum uint GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; +enum uint GL_RASTERIZER_DISCARD = 0x8C89; +enum uint GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; +enum uint GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; +enum uint GL_INTERLEAVED_ATTRIBS = 0x8C8C; +enum uint GL_SEPARATE_ATTRIBS = 0x8C8D; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; +enum uint GL_RGBA32UI = 0x8D70; +enum uint GL_RGB32UI = 0x8D71; +enum uint GL_RGBA16UI = 0x8D76; +enum uint GL_RGB16UI = 0x8D77; +enum uint GL_RGBA8UI = 0x8D7C; +enum uint GL_RGB8UI = 0x8D7D; +enum uint GL_RGBA32I = 0x8D82; +enum uint GL_RGB32I = 0x8D83; +enum uint GL_RGBA16I = 0x8D88; +enum uint GL_RGB16I = 0x8D89; +enum uint GL_RGBA8I = 0x8D8E; +enum uint GL_RGB8I = 0x8D8F; +enum uint GL_RED_INTEGER = 0x8D94; +enum uint GL_GREEN_INTEGER = 0x8D95; +enum uint GL_BLUE_INTEGER = 0x8D96; +enum uint GL_RGB_INTEGER = 0x8D98; +enum uint GL_RGBA_INTEGER = 0x8D99; +enum uint GL_BGR_INTEGER = 0x8D9A; +enum uint GL_BGRA_INTEGER = 0x8D9B; +enum uint GL_SAMPLER_1D_ARRAY = 0x8DC0; +enum uint GL_SAMPLER_2D_ARRAY = 0x8DC1; +enum uint GL_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3; +enum uint GL_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; +enum uint GL_SAMPLER_CUBE_SHADOW = 0x8DC5; +enum uint GL_UNSIGNED_INT_VEC2 = 0x8DC6; +enum uint GL_UNSIGNED_INT_VEC3 = 0x8DC7; +enum uint GL_UNSIGNED_INT_VEC4 = 0x8DC8; +enum uint GL_INT_SAMPLER_1D = 0x8DC9; +enum uint GL_INT_SAMPLER_2D = 0x8DCA; +enum uint GL_INT_SAMPLER_3D = 0x8DCB; +enum uint GL_INT_SAMPLER_CUBE = 0x8DCC; +enum uint GL_INT_SAMPLER_1D_ARRAY = 0x8DCE; +enum uint GL_INT_SAMPLER_2D_ARRAY = 0x8DCF; +enum uint GL_UNSIGNED_INT_SAMPLER_1D = 0x8DD1; +enum uint GL_UNSIGNED_INT_SAMPLER_2D = 0x8DD2; +enum uint GL_UNSIGNED_INT_SAMPLER_3D = 0x8DD3; +enum uint GL_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; +enum uint GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; +enum uint GL_QUERY_WAIT = 0x8E13; +enum uint GL_QUERY_NO_WAIT = 0x8E14; +enum uint GL_QUERY_BY_REGION_WAIT = 0x8E15; +enum uint GL_QUERY_BY_REGION_NO_WAIT = 0x8E16; +enum uint GL_BUFFER_ACCESS_FLAGS = 0x911F; +enum uint GL_BUFFER_MAP_LENGTH = 0x9120; +enum uint GL_BUFFER_MAP_OFFSET = 0x9121; +enum uint GL_DEPTH_COMPONENT32F = 0x8CAC; +enum uint GL_DEPTH32F_STENCIL8 = 0x8CAD; +enum uint GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; +enum uint GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506; +enum uint GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; +enum uint GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; +enum uint GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; +enum uint GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; +enum uint GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; +enum uint GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; +enum uint GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; +enum uint GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; +enum uint GL_FRAMEBUFFER_DEFAULT = 0x8218; +enum uint GL_FRAMEBUFFER_UNDEFINED = 0x8219; +enum uint GL_DEPTH_STENCIL_ATTACHMENT = 0x821A; +enum uint GL_MAX_RENDERBUFFER_SIZE = 0x84E8; +enum uint GL_DEPTH_STENCIL = 0x84F9; +enum uint GL_UNSIGNED_INT_24_8 = 0x84FA; +enum uint GL_DEPTH24_STENCIL8 = 0x88F0; +enum uint GL_TEXTURE_STENCIL_SIZE = 0x88F1; +enum uint GL_TEXTURE_RED_TYPE = 0x8C10; +enum uint GL_TEXTURE_GREEN_TYPE = 0x8C11; +enum uint GL_TEXTURE_BLUE_TYPE = 0x8C12; +enum uint GL_TEXTURE_ALPHA_TYPE = 0x8C13; +enum uint GL_TEXTURE_DEPTH_TYPE = 0x8C16; +enum uint GL_UNSIGNED_NORMALIZED = 0x8C17; +enum uint GL_FRAMEBUFFER_BINDING = 0x8CA6; +enum uint GL_DRAW_FRAMEBUFFER_BINDING = 0x8CA6; +enum uint GL_RENDERBUFFER_BINDING = 0x8CA7; +enum uint GL_READ_FRAMEBUFFER = 0x8CA8; +enum uint GL_DRAW_FRAMEBUFFER = 0x8CA9; +enum uint GL_READ_FRAMEBUFFER_BINDING = 0x8CAA; +enum uint GL_RENDERBUFFER_SAMPLES = 0x8CAB; +enum uint GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; +enum uint GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; +enum uint GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; +enum uint GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; +enum uint GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; +enum uint GL_FRAMEBUFFER_COMPLETE = 0x8CD5; +enum uint GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; +enum uint GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; +enum uint GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB; +enum uint GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC; +enum uint GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD; +enum uint GL_MAX_COLOR_ATTACHMENTS = 0x8CDF; +enum uint GL_COLOR_ATTACHMENT0 = 0x8CE0; +enum uint GL_COLOR_ATTACHMENT1 = 0x8CE1; +enum uint GL_COLOR_ATTACHMENT2 = 0x8CE2; +enum uint GL_COLOR_ATTACHMENT3 = 0x8CE3; +enum uint GL_COLOR_ATTACHMENT4 = 0x8CE4; +enum uint GL_COLOR_ATTACHMENT5 = 0x8CE5; +enum uint GL_COLOR_ATTACHMENT6 = 0x8CE6; +enum uint GL_COLOR_ATTACHMENT7 = 0x8CE7; +enum uint GL_COLOR_ATTACHMENT8 = 0x8CE8; +enum uint GL_COLOR_ATTACHMENT9 = 0x8CE9; +enum uint GL_COLOR_ATTACHMENT10 = 0x8CEA; +enum uint GL_COLOR_ATTACHMENT11 = 0x8CEB; +enum uint GL_COLOR_ATTACHMENT12 = 0x8CEC; +enum uint GL_COLOR_ATTACHMENT13 = 0x8CED; +enum uint GL_COLOR_ATTACHMENT14 = 0x8CEE; +enum uint GL_COLOR_ATTACHMENT15 = 0x8CEF; +enum uint GL_COLOR_ATTACHMENT16 = 0x8CF0; +enum uint GL_COLOR_ATTACHMENT17 = 0x8CF1; +enum uint GL_COLOR_ATTACHMENT18 = 0x8CF2; +enum uint GL_COLOR_ATTACHMENT19 = 0x8CF3; +enum uint GL_COLOR_ATTACHMENT20 = 0x8CF4; +enum uint GL_COLOR_ATTACHMENT21 = 0x8CF5; +enum uint GL_COLOR_ATTACHMENT22 = 0x8CF6; +enum uint GL_COLOR_ATTACHMENT23 = 0x8CF7; +enum uint GL_COLOR_ATTACHMENT24 = 0x8CF8; +enum uint GL_COLOR_ATTACHMENT25 = 0x8CF9; +enum uint GL_COLOR_ATTACHMENT26 = 0x8CFA; +enum uint GL_COLOR_ATTACHMENT27 = 0x8CFB; +enum uint GL_COLOR_ATTACHMENT28 = 0x8CFC; +enum uint GL_COLOR_ATTACHMENT29 = 0x8CFD; +enum uint GL_COLOR_ATTACHMENT30 = 0x8CFE; +enum uint GL_COLOR_ATTACHMENT31 = 0x8CFF; +enum uint GL_DEPTH_ATTACHMENT = 0x8D00; +enum uint GL_STENCIL_ATTACHMENT = 0x8D20; +enum uint GL_FRAMEBUFFER = 0x8D40; +enum uint GL_RENDERBUFFER = 0x8D41; +enum uint GL_RENDERBUFFER_WIDTH = 0x8D42; +enum uint GL_RENDERBUFFER_HEIGHT = 0x8D43; +enum uint GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; +enum uint GL_STENCIL_INDEX1 = 0x8D46; +enum uint GL_STENCIL_INDEX4 = 0x8D47; +enum uint GL_STENCIL_INDEX8 = 0x8D48; +enum uint GL_STENCIL_INDEX16 = 0x8D49; +enum uint GL_RENDERBUFFER_RED_SIZE = 0x8D50; +enum uint GL_RENDERBUFFER_GREEN_SIZE = 0x8D51; +enum uint GL_RENDERBUFFER_BLUE_SIZE = 0x8D52; +enum uint GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53; +enum uint GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54; +enum uint GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55; +enum uint GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; +enum uint GL_MAX_SAMPLES = 0x8D57; +enum uint GL_INDEX = 0x8222; +enum uint GL_TEXTURE_LUMINANCE_TYPE = 0x8C14; +enum uint GL_TEXTURE_INTENSITY_TYPE = 0x8C15; +enum uint GL_FRAMEBUFFER_SRGB = 0x8DB9; +enum uint GL_HALF_FLOAT = 0x140B; +enum uint GL_MAP_READ_BIT = 0x0001; +enum uint GL_MAP_WRITE_BIT = 0x0002; +enum uint GL_MAP_INVALIDATE_RANGE_BIT = 0x0004; +enum uint GL_MAP_INVALIDATE_BUFFER_BIT = 0x0008; +enum uint GL_MAP_FLUSH_EXPLICIT_BIT = 0x0010; +enum uint GL_MAP_UNSYNCHRONIZED_BIT = 0x0020; +enum uint GL_COMPRESSED_RED_RGTC1 = 0x8DBB; +enum uint GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC; +enum uint GL_COMPRESSED_RG_RGTC2 = 0x8DBD; +enum uint GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; +enum uint GL_RG = 0x8227; +enum uint GL_RG_INTEGER = 0x8228; +enum uint GL_R8 = 0x8229; +enum uint GL_R16 = 0x822A; +enum uint GL_RG8 = 0x822B; +enum uint GL_RG16 = 0x822C; +enum uint GL_R16F = 0x822D; +enum uint GL_R32F = 0x822E; +enum uint GL_RG16F = 0x822F; +enum uint GL_RG32F = 0x8230; +enum uint GL_R8I = 0x8231; +enum uint GL_R8UI = 0x8232; +enum uint GL_R16I = 0x8233; +enum uint GL_R16UI = 0x8234; +enum uint GL_R32I = 0x8235; +enum uint GL_R32UI = 0x8236; +enum uint GL_RG8I = 0x8237; +enum uint GL_RG8UI = 0x8238; +enum uint GL_RG16I = 0x8239; +enum uint GL_RG16UI = 0x823A; +enum uint GL_RG32I = 0x823B; +enum uint GL_RG32UI = 0x823C; +enum uint GL_VERTEX_ARRAY_BINDING = 0x85B5; +enum uint GL_CLAMP_VERTEX_COLOR = 0x891A; +enum uint GL_CLAMP_FRAGMENT_COLOR = 0x891B; +enum uint GL_ALPHA_INTEGER = 0x8D97; +enum uint GL_SAMPLER_2D_RECT = 0x8B63; +enum uint GL_SAMPLER_2D_RECT_SHADOW = 0x8B64; +enum uint GL_SAMPLER_BUFFER = 0x8DC2; +enum uint GL_INT_SAMPLER_2D_RECT = 0x8DCD; +enum uint GL_INT_SAMPLER_BUFFER = 0x8DD0; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5; +enum uint GL_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8; +enum uint GL_TEXTURE_BUFFER = 0x8C2A; +enum uint GL_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B; +enum uint GL_TEXTURE_BINDING_BUFFER = 0x8C2C; +enum uint GL_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D; +enum uint GL_TEXTURE_RECTANGLE = 0x84F5; +enum uint GL_TEXTURE_BINDING_RECTANGLE = 0x84F6; +enum uint GL_PROXY_TEXTURE_RECTANGLE = 0x84F7; +enum uint GL_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8; +enum uint GL_R8_SNORM = 0x8F94; +enum uint GL_RG8_SNORM = 0x8F95; +enum uint GL_RGB8_SNORM = 0x8F96; +enum uint GL_RGBA8_SNORM = 0x8F97; +enum uint GL_R16_SNORM = 0x8F98; +enum uint GL_RG16_SNORM = 0x8F99; +enum uint GL_RGB16_SNORM = 0x8F9A; +enum uint GL_RGBA16_SNORM = 0x8F9B; +enum uint GL_SIGNED_NORMALIZED = 0x8F9C; +enum uint GL_PRIMITIVE_RESTART = 0x8F9D; +enum uint GL_PRIMITIVE_RESTART_INDEX = 0x8F9E; +enum uint GL_COPY_READ_BUFFER = 0x8F36; +enum uint GL_COPY_WRITE_BUFFER = 0x8F37; +enum uint GL_UNIFORM_BUFFER = 0x8A11; +enum uint GL_UNIFORM_BUFFER_BINDING = 0x8A28; +enum uint GL_UNIFORM_BUFFER_START = 0x8A29; +enum uint GL_UNIFORM_BUFFER_SIZE = 0x8A2A; +enum uint GL_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; +enum uint GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C; +enum uint GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; +enum uint GL_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; +enum uint GL_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; +enum uint GL_MAX_UNIFORM_BLOCK_SIZE = 0x8A30; +enum uint GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; +enum uint GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32; +enum uint GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; +enum uint GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; +enum uint GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; +enum uint GL_ACTIVE_UNIFORM_BLOCKS = 0x8A36; +enum uint GL_UNIFORM_TYPE = 0x8A37; +enum uint GL_UNIFORM_SIZE = 0x8A38; +enum uint GL_UNIFORM_NAME_LENGTH = 0x8A39; +enum uint GL_UNIFORM_BLOCK_INDEX = 0x8A3A; +enum uint GL_UNIFORM_OFFSET = 0x8A3B; +enum uint GL_UNIFORM_ARRAY_STRIDE = 0x8A3C; +enum uint GL_UNIFORM_MATRIX_STRIDE = 0x8A3D; +enum uint GL_UNIFORM_IS_ROW_MAJOR = 0x8A3E; +enum uint GL_UNIFORM_BLOCK_BINDING = 0x8A3F; +enum uint GL_UNIFORM_BLOCK_DATA_SIZE = 0x8A40; +enum uint GL_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; +enum uint GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; +enum uint GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; +enum uint GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; +enum uint GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45; +enum uint GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; +enum uint GL_CONTEXT_CORE_PROFILE_BIT = 0x00000001; +enum uint GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002; +enum uint GL_LINES_ADJACENCY = 0x000A; +enum uint GL_LINE_STRIP_ADJACENCY = 0x000B; +enum uint GL_TRIANGLES_ADJACENCY = 0x000C; +enum uint GL_TRIANGLE_STRIP_ADJACENCY = 0x000D; +enum uint GL_PROGRAM_POINT_SIZE = 0x8642; +enum uint GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29; +enum uint GL_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7; +enum uint GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8; +enum uint GL_GEOMETRY_SHADER = 0x8DD9; +enum uint GL_GEOMETRY_VERTICES_OUT = 0x8916; +enum uint GL_GEOMETRY_INPUT_TYPE = 0x8917; +enum uint GL_GEOMETRY_OUTPUT_TYPE = 0x8918; +enum uint GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF; +enum uint GL_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0; +enum uint GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1; +enum uint GL_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; +enum uint GL_MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123; +enum uint GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124; +enum uint GL_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; +enum uint GL_CONTEXT_PROFILE_MASK = 0x9126; +enum uint GL_DEPTH_CLAMP = 0x864F; +enum uint GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; +enum uint GL_FIRST_VERTEX_CONVENTION = 0x8E4D; +enum uint GL_LAST_VERTEX_CONVENTION = 0x8E4E; +enum uint GL_PROVOKING_VERTEX = 0x8E4F; +enum uint GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; +enum uint GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111; +enum uint GL_OBJECT_TYPE = 0x9112; +enum uint GL_SYNC_CONDITION = 0x9113; +enum uint GL_SYNC_STATUS = 0x9114; +enum uint GL_SYNC_FLAGS = 0x9115; +enum uint GL_SYNC_FENCE = 0x9116; +enum uint GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117; +enum uint GL_UNSIGNALED = 0x9118; +enum uint GL_SIGNALED = 0x9119; +enum uint GL_ALREADY_SIGNALED = 0x911A; +enum uint GL_TIMEOUT_EXPIRED = 0x911B; +enum uint GL_CONDITION_SATISFIED = 0x911C; +enum uint GL_WAIT_FAILED = 0x911D; +enum uint GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001; +enum uint GL_SAMPLE_POSITION = 0x8E50; +enum uint GL_SAMPLE_MASK = 0x8E51; +enum uint GL_SAMPLE_MASK_VALUE = 0x8E52; +enum uint GL_MAX_SAMPLE_MASK_WORDS = 0x8E59; +enum uint GL_TEXTURE_2D_MULTISAMPLE = 0x9100; +enum uint GL_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; +enum uint GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; +enum uint GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; +enum uint GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; +enum uint GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; +enum uint GL_TEXTURE_SAMPLES = 0x9106; +enum uint GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; +enum uint GL_SAMPLER_2D_MULTISAMPLE = 0x9108; +enum uint GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; +enum uint GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B; +enum uint GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; +enum uint GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E; +enum uint GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; +enum uint GL_MAX_INTEGER_SAMPLES = 0x9110; +enum uint GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; +enum uint GL_SRC1_COLOR = 0x88F9; +enum uint GL_ONE_MINUS_SRC1_COLOR = 0x88FA; +enum uint GL_ONE_MINUS_SRC1_ALPHA = 0x88FB; +enum uint GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; +enum uint GL_ANY_SAMPLES_PASSED = 0x8C2F; +enum uint GL_SAMPLER_BINDING = 0x8919; +enum uint GL_RGB10_A2UI = 0x906F; +enum uint GL_TEXTURE_SWIZZLE_R = 0x8E42; +enum uint GL_TEXTURE_SWIZZLE_G = 0x8E43; +enum uint GL_TEXTURE_SWIZZLE_B = 0x8E44; +enum uint GL_TEXTURE_SWIZZLE_A = 0x8E45; +enum uint GL_TEXTURE_SWIZZLE_RGBA = 0x8E46; +enum uint GL_TIME_ELAPSED = 0x88BF; +enum uint GL_TIMESTAMP = 0x8E28; +enum uint GL_INT_2_10_10_10_REV = 0x8D9F; diff --git a/source/glad/gl/ext.d b/source/glad/gl/ext.d new file mode 100644 index 0000000..ad03be6 --- /dev/null +++ b/source/glad/gl/ext.d @@ -0,0 +1,10 @@ +module glad.gl.ext; + + +private import glad.gl.types; +private import glad.gl.enums; +private import glad.gl.funcs; +nothrow @nogc extern(System) { +} +__gshared { +} diff --git a/source/glad/gl/funcs.d b/source/glad/gl/funcs.d new file mode 100644 index 0000000..037ad38 --- /dev/null +++ b/source/glad/gl/funcs.d @@ -0,0 +1,1468 @@ +module glad.gl.funcs; + + +private import glad.gl.types; +bool GL_VERSION_1_0; +bool GL_VERSION_1_1; +bool GL_VERSION_1_2; +bool GL_VERSION_1_3; +bool GL_VERSION_1_4; +bool GL_VERSION_1_5; +bool GL_VERSION_2_0; +bool GL_VERSION_2_1; +bool GL_VERSION_3_0; +bool GL_VERSION_3_1; +bool GL_VERSION_3_2; +bool GL_VERSION_3_3; +nothrow @nogc extern(System) { +alias fp_glCullFace = void function(GLenum); +alias fp_glFrontFace = void function(GLenum); +alias fp_glHint = void function(GLenum, GLenum); +alias fp_glLineWidth = void function(GLfloat); +alias fp_glPointSize = void function(GLfloat); +alias fp_glPolygonMode = void function(GLenum, GLenum); +alias fp_glScissor = void function(GLint, GLint, GLsizei, GLsizei); +alias fp_glTexParameterf = void function(GLenum, GLenum, GLfloat); +alias fp_glTexParameterfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glTexParameteri = void function(GLenum, GLenum, GLint); +alias fp_glTexParameteriv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glTexImage1D = void function(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const(void)*); +alias fp_glTexImage2D = void function(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const(void)*); +alias fp_glDrawBuffer = void function(GLenum); +alias fp_glClear = void function(GLbitfield); +alias fp_glClearColor = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glClearStencil = void function(GLint); +alias fp_glClearDepth = void function(GLdouble); +alias fp_glStencilMask = void function(GLuint); +alias fp_glColorMask = void function(GLboolean, GLboolean, GLboolean, GLboolean); +alias fp_glDepthMask = void function(GLboolean); +alias fp_glDisable = void function(GLenum); +alias fp_glEnable = void function(GLenum); +alias fp_glFinish = void function(); +alias fp_glFlush = void function(); +alias fp_glBlendFunc = void function(GLenum, GLenum); +alias fp_glLogicOp = void function(GLenum); +alias fp_glStencilFunc = void function(GLenum, GLint, GLuint); +alias fp_glStencilOp = void function(GLenum, GLenum, GLenum); +alias fp_glDepthFunc = void function(GLenum); +alias fp_glPixelStoref = void function(GLenum, GLfloat); +alias fp_glPixelStorei = void function(GLenum, GLint); +alias fp_glReadBuffer = void function(GLenum); +alias fp_glReadPixels = void function(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, void*); +alias fp_glGetBooleanv = void function(GLenum, GLboolean*); +alias fp_glGetDoublev = void function(GLenum, GLdouble*); +alias fp_glGetError = GLenum function(); +alias fp_glGetFloatv = void function(GLenum, GLfloat*); +alias fp_glGetIntegerv = void function(GLenum, GLint*); +alias fp_glGetString = const(GLubyte)* function(GLenum); +alias fp_glGetTexImage = void function(GLenum, GLint, GLenum, GLenum, void*); +alias fp_glGetTexParameterfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetTexParameteriv = void function(GLenum, GLenum, GLint*); +alias fp_glGetTexLevelParameterfv = void function(GLenum, GLint, GLenum, GLfloat*); +alias fp_glGetTexLevelParameteriv = void function(GLenum, GLint, GLenum, GLint*); +alias fp_glIsEnabled = GLboolean function(GLenum); +alias fp_glDepthRange = void function(GLdouble, GLdouble); +alias fp_glViewport = void function(GLint, GLint, GLsizei, GLsizei); +alias fp_glNewList = void function(GLuint, GLenum); +alias fp_glEndList = void function(); +alias fp_glCallList = void function(GLuint); +alias fp_glCallLists = void function(GLsizei, GLenum, const(void)*); +alias fp_glDeleteLists = void function(GLuint, GLsizei); +alias fp_glGenLists = GLuint function(GLsizei); +alias fp_glListBase = void function(GLuint); +alias fp_glBegin = void function(GLenum); +alias fp_glBitmap = void function(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const(GLubyte)*); +alias fp_glColor3b = void function(GLbyte, GLbyte, GLbyte); +alias fp_glColor3bv = void function(const(GLbyte)*); +alias fp_glColor3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glColor3dv = void function(const(GLdouble)*); +alias fp_glColor3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glColor3fv = void function(const(GLfloat)*); +alias fp_glColor3i = void function(GLint, GLint, GLint); +alias fp_glColor3iv = void function(const(GLint)*); +alias fp_glColor3s = void function(GLshort, GLshort, GLshort); +alias fp_glColor3sv = void function(const(GLshort)*); +alias fp_glColor3ub = void function(GLubyte, GLubyte, GLubyte); +alias fp_glColor3ubv = void function(const(GLubyte)*); +alias fp_glColor3ui = void function(GLuint, GLuint, GLuint); +alias fp_glColor3uiv = void function(const(GLuint)*); +alias fp_glColor3us = void function(GLushort, GLushort, GLushort); +alias fp_glColor3usv = void function(const(GLushort)*); +alias fp_glColor4b = void function(GLbyte, GLbyte, GLbyte, GLbyte); +alias fp_glColor4bv = void function(const(GLbyte)*); +alias fp_glColor4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glColor4dv = void function(const(GLdouble)*); +alias fp_glColor4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glColor4fv = void function(const(GLfloat)*); +alias fp_glColor4i = void function(GLint, GLint, GLint, GLint); +alias fp_glColor4iv = void function(const(GLint)*); +alias fp_glColor4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glColor4sv = void function(const(GLshort)*); +alias fp_glColor4ub = void function(GLubyte, GLubyte, GLubyte, GLubyte); +alias fp_glColor4ubv = void function(const(GLubyte)*); +alias fp_glColor4ui = void function(GLuint, GLuint, GLuint, GLuint); +alias fp_glColor4uiv = void function(const(GLuint)*); +alias fp_glColor4us = void function(GLushort, GLushort, GLushort, GLushort); +alias fp_glColor4usv = void function(const(GLushort)*); +alias fp_glEdgeFlag = void function(GLboolean); +alias fp_glEdgeFlagv = void function(const(GLboolean)*); +alias fp_glEnd = void function(); +alias fp_glIndexd = void function(GLdouble); +alias fp_glIndexdv = void function(const(GLdouble)*); +alias fp_glIndexf = void function(GLfloat); +alias fp_glIndexfv = void function(const(GLfloat)*); +alias fp_glIndexi = void function(GLint); +alias fp_glIndexiv = void function(const(GLint)*); +alias fp_glIndexs = void function(GLshort); +alias fp_glIndexsv = void function(const(GLshort)*); +alias fp_glNormal3b = void function(GLbyte, GLbyte, GLbyte); +alias fp_glNormal3bv = void function(const(GLbyte)*); +alias fp_glNormal3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glNormal3dv = void function(const(GLdouble)*); +alias fp_glNormal3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glNormal3fv = void function(const(GLfloat)*); +alias fp_glNormal3i = void function(GLint, GLint, GLint); +alias fp_glNormal3iv = void function(const(GLint)*); +alias fp_glNormal3s = void function(GLshort, GLshort, GLshort); +alias fp_glNormal3sv = void function(const(GLshort)*); +alias fp_glRasterPos2d = void function(GLdouble, GLdouble); +alias fp_glRasterPos2dv = void function(const(GLdouble)*); +alias fp_glRasterPos2f = void function(GLfloat, GLfloat); +alias fp_glRasterPos2fv = void function(const(GLfloat)*); +alias fp_glRasterPos2i = void function(GLint, GLint); +alias fp_glRasterPos2iv = void function(const(GLint)*); +alias fp_glRasterPos2s = void function(GLshort, GLshort); +alias fp_glRasterPos2sv = void function(const(GLshort)*); +alias fp_glRasterPos3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glRasterPos3dv = void function(const(GLdouble)*); +alias fp_glRasterPos3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glRasterPos3fv = void function(const(GLfloat)*); +alias fp_glRasterPos3i = void function(GLint, GLint, GLint); +alias fp_glRasterPos3iv = void function(const(GLint)*); +alias fp_glRasterPos3s = void function(GLshort, GLshort, GLshort); +alias fp_glRasterPos3sv = void function(const(GLshort)*); +alias fp_glRasterPos4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glRasterPos4dv = void function(const(GLdouble)*); +alias fp_glRasterPos4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glRasterPos4fv = void function(const(GLfloat)*); +alias fp_glRasterPos4i = void function(GLint, GLint, GLint, GLint); +alias fp_glRasterPos4iv = void function(const(GLint)*); +alias fp_glRasterPos4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glRasterPos4sv = void function(const(GLshort)*); +alias fp_glRectd = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glRectdv = void function(const(GLdouble)*, const(GLdouble)*); +alias fp_glRectf = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glRectfv = void function(const(GLfloat)*, const(GLfloat)*); +alias fp_glRecti = void function(GLint, GLint, GLint, GLint); +alias fp_glRectiv = void function(const(GLint)*, const(GLint)*); +alias fp_glRects = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glRectsv = void function(const(GLshort)*, const(GLshort)*); +alias fp_glTexCoord1d = void function(GLdouble); +alias fp_glTexCoord1dv = void function(const(GLdouble)*); +alias fp_glTexCoord1f = void function(GLfloat); +alias fp_glTexCoord1fv = void function(const(GLfloat)*); +alias fp_glTexCoord1i = void function(GLint); +alias fp_glTexCoord1iv = void function(const(GLint)*); +alias fp_glTexCoord1s = void function(GLshort); +alias fp_glTexCoord1sv = void function(const(GLshort)*); +alias fp_glTexCoord2d = void function(GLdouble, GLdouble); +alias fp_glTexCoord2dv = void function(const(GLdouble)*); +alias fp_glTexCoord2f = void function(GLfloat, GLfloat); +alias fp_glTexCoord2fv = void function(const(GLfloat)*); +alias fp_glTexCoord2i = void function(GLint, GLint); +alias fp_glTexCoord2iv = void function(const(GLint)*); +alias fp_glTexCoord2s = void function(GLshort, GLshort); +alias fp_glTexCoord2sv = void function(const(GLshort)*); +alias fp_glTexCoord3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glTexCoord3dv = void function(const(GLdouble)*); +alias fp_glTexCoord3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glTexCoord3fv = void function(const(GLfloat)*); +alias fp_glTexCoord3i = void function(GLint, GLint, GLint); +alias fp_glTexCoord3iv = void function(const(GLint)*); +alias fp_glTexCoord3s = void function(GLshort, GLshort, GLshort); +alias fp_glTexCoord3sv = void function(const(GLshort)*); +alias fp_glTexCoord4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glTexCoord4dv = void function(const(GLdouble)*); +alias fp_glTexCoord4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glTexCoord4fv = void function(const(GLfloat)*); +alias fp_glTexCoord4i = void function(GLint, GLint, GLint, GLint); +alias fp_glTexCoord4iv = void function(const(GLint)*); +alias fp_glTexCoord4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glTexCoord4sv = void function(const(GLshort)*); +alias fp_glVertex2d = void function(GLdouble, GLdouble); +alias fp_glVertex2dv = void function(const(GLdouble)*); +alias fp_glVertex2f = void function(GLfloat, GLfloat); +alias fp_glVertex2fv = void function(const(GLfloat)*); +alias fp_glVertex2i = void function(GLint, GLint); +alias fp_glVertex2iv = void function(const(GLint)*); +alias fp_glVertex2s = void function(GLshort, GLshort); +alias fp_glVertex2sv = void function(const(GLshort)*); +alias fp_glVertex3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glVertex3dv = void function(const(GLdouble)*); +alias fp_glVertex3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glVertex3fv = void function(const(GLfloat)*); +alias fp_glVertex3i = void function(GLint, GLint, GLint); +alias fp_glVertex3iv = void function(const(GLint)*); +alias fp_glVertex3s = void function(GLshort, GLshort, GLshort); +alias fp_glVertex3sv = void function(const(GLshort)*); +alias fp_glVertex4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glVertex4dv = void function(const(GLdouble)*); +alias fp_glVertex4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glVertex4fv = void function(const(GLfloat)*); +alias fp_glVertex4i = void function(GLint, GLint, GLint, GLint); +alias fp_glVertex4iv = void function(const(GLint)*); +alias fp_glVertex4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glVertex4sv = void function(const(GLshort)*); +alias fp_glClipPlane = void function(GLenum, const(GLdouble)*); +alias fp_glColorMaterial = void function(GLenum, GLenum); +alias fp_glFogf = void function(GLenum, GLfloat); +alias fp_glFogfv = void function(GLenum, const(GLfloat)*); +alias fp_glFogi = void function(GLenum, GLint); +alias fp_glFogiv = void function(GLenum, const(GLint)*); +alias fp_glLightf = void function(GLenum, GLenum, GLfloat); +alias fp_glLightfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glLighti = void function(GLenum, GLenum, GLint); +alias fp_glLightiv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glLightModelf = void function(GLenum, GLfloat); +alias fp_glLightModelfv = void function(GLenum, const(GLfloat)*); +alias fp_glLightModeli = void function(GLenum, GLint); +alias fp_glLightModeliv = void function(GLenum, const(GLint)*); +alias fp_glLineStipple = void function(GLint, GLushort); +alias fp_glMaterialf = void function(GLenum, GLenum, GLfloat); +alias fp_glMaterialfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glMateriali = void function(GLenum, GLenum, GLint); +alias fp_glMaterialiv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glPolygonStipple = void function(const(GLubyte)*); +alias fp_glShadeModel = void function(GLenum); +alias fp_glTexEnvf = void function(GLenum, GLenum, GLfloat); +alias fp_glTexEnvfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glTexEnvi = void function(GLenum, GLenum, GLint); +alias fp_glTexEnviv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glTexGend = void function(GLenum, GLenum, GLdouble); +alias fp_glTexGendv = void function(GLenum, GLenum, const(GLdouble)*); +alias fp_glTexGenf = void function(GLenum, GLenum, GLfloat); +alias fp_glTexGenfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glTexGeni = void function(GLenum, GLenum, GLint); +alias fp_glTexGeniv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glFeedbackBuffer = void function(GLsizei, GLenum, GLfloat*); +alias fp_glSelectBuffer = void function(GLsizei, GLuint*); +alias fp_glRenderMode = GLint function(GLenum); +alias fp_glInitNames = void function(); +alias fp_glLoadName = void function(GLuint); +alias fp_glPassThrough = void function(GLfloat); +alias fp_glPopName = void function(); +alias fp_glPushName = void function(GLuint); +alias fp_glClearAccum = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glClearIndex = void function(GLfloat); +alias fp_glIndexMask = void function(GLuint); +alias fp_glAccum = void function(GLenum, GLfloat); +alias fp_glPopAttrib = void function(); +alias fp_glPushAttrib = void function(GLbitfield); +alias fp_glMap1d = void function(GLenum, GLdouble, GLdouble, GLint, GLint, const(GLdouble)*); +alias fp_glMap1f = void function(GLenum, GLfloat, GLfloat, GLint, GLint, const(GLfloat)*); +alias fp_glMap2d = void function(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const(GLdouble)*); +alias fp_glMap2f = void function(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const(GLfloat)*); +alias fp_glMapGrid1d = void function(GLint, GLdouble, GLdouble); +alias fp_glMapGrid1f = void function(GLint, GLfloat, GLfloat); +alias fp_glMapGrid2d = void function(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble); +alias fp_glMapGrid2f = void function(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat); +alias fp_glEvalCoord1d = void function(GLdouble); +alias fp_glEvalCoord1dv = void function(const(GLdouble)*); +alias fp_glEvalCoord1f = void function(GLfloat); +alias fp_glEvalCoord1fv = void function(const(GLfloat)*); +alias fp_glEvalCoord2d = void function(GLdouble, GLdouble); +alias fp_glEvalCoord2dv = void function(const(GLdouble)*); +alias fp_glEvalCoord2f = void function(GLfloat, GLfloat); +alias fp_glEvalCoord2fv = void function(const(GLfloat)*); +alias fp_glEvalMesh1 = void function(GLenum, GLint, GLint); +alias fp_glEvalPoint1 = void function(GLint); +alias fp_glEvalMesh2 = void function(GLenum, GLint, GLint, GLint, GLint); +alias fp_glEvalPoint2 = void function(GLint, GLint); +alias fp_glAlphaFunc = void function(GLenum, GLfloat); +alias fp_glPixelZoom = void function(GLfloat, GLfloat); +alias fp_glPixelTransferf = void function(GLenum, GLfloat); +alias fp_glPixelTransferi = void function(GLenum, GLint); +alias fp_glPixelMapfv = void function(GLenum, GLsizei, const(GLfloat)*); +alias fp_glPixelMapuiv = void function(GLenum, GLsizei, const(GLuint)*); +alias fp_glPixelMapusv = void function(GLenum, GLsizei, const(GLushort)*); +alias fp_glCopyPixels = void function(GLint, GLint, GLsizei, GLsizei, GLenum); +alias fp_glDrawPixels = void function(GLsizei, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glGetClipPlane = void function(GLenum, GLdouble*); +alias fp_glGetLightfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetLightiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetMapdv = void function(GLenum, GLenum, GLdouble*); +alias fp_glGetMapfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetMapiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetMaterialfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetMaterialiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetPixelMapfv = void function(GLenum, GLfloat*); +alias fp_glGetPixelMapuiv = void function(GLenum, GLuint*); +alias fp_glGetPixelMapusv = void function(GLenum, GLushort*); +alias fp_glGetPolygonStipple = void function(GLubyte*); +alias fp_glGetTexEnvfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetTexEnviv = void function(GLenum, GLenum, GLint*); +alias fp_glGetTexGendv = void function(GLenum, GLenum, GLdouble*); +alias fp_glGetTexGenfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetTexGeniv = void function(GLenum, GLenum, GLint*); +alias fp_glIsList = GLboolean function(GLuint); +alias fp_glFrustum = void function(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glLoadIdentity = void function(); +alias fp_glLoadMatrixf = void function(const(GLfloat)*); +alias fp_glLoadMatrixd = void function(const(GLdouble)*); +alias fp_glMatrixMode = void function(GLenum); +alias fp_glMultMatrixf = void function(const(GLfloat)*); +alias fp_glMultMatrixd = void function(const(GLdouble)*); +alias fp_glOrtho = void function(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glPopMatrix = void function(); +alias fp_glPushMatrix = void function(); +alias fp_glRotated = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glRotatef = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glScaled = void function(GLdouble, GLdouble, GLdouble); +alias fp_glScalef = void function(GLfloat, GLfloat, GLfloat); +alias fp_glTranslated = void function(GLdouble, GLdouble, GLdouble); +alias fp_glTranslatef = void function(GLfloat, GLfloat, GLfloat); +alias fp_glDrawArrays = void function(GLenum, GLint, GLsizei); +alias fp_glDrawElements = void function(GLenum, GLsizei, GLenum, const(void)*); +alias fp_glGetPointerv = void function(GLenum, void**); +alias fp_glPolygonOffset = void function(GLfloat, GLfloat); +alias fp_glCopyTexImage1D = void function(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint); +alias fp_glCopyTexImage2D = void function(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); +alias fp_glCopyTexSubImage1D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei); +alias fp_glCopyTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +alias fp_glTexSubImage1D = void function(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glBindTexture = void function(GLenum, GLuint); +alias fp_glDeleteTextures = void function(GLsizei, const(GLuint)*); +alias fp_glGenTextures = void function(GLsizei, GLuint*); +alias fp_glIsTexture = GLboolean function(GLuint); +alias fp_glArrayElement = void function(GLint); +alias fp_glColorPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glDisableClientState = void function(GLenum); +alias fp_glEdgeFlagPointer = void function(GLsizei, const(void)*); +alias fp_glEnableClientState = void function(GLenum); +alias fp_glIndexPointer = void function(GLenum, GLsizei, const(void)*); +alias fp_glInterleavedArrays = void function(GLenum, GLsizei, const(void)*); +alias fp_glNormalPointer = void function(GLenum, GLsizei, const(void)*); +alias fp_glTexCoordPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glVertexPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glAreTexturesResident = GLboolean function(GLsizei, const(GLuint)*, GLboolean*); +alias fp_glPrioritizeTextures = void function(GLsizei, const(GLuint)*, const(GLfloat)*); +alias fp_glIndexub = void function(GLubyte); +alias fp_glIndexubv = void function(const(GLubyte)*); +alias fp_glPopClientAttrib = void function(); +alias fp_glPushClientAttrib = void function(GLbitfield); +alias fp_glDrawRangeElements = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(void)*); +alias fp_glTexImage3D = void function(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const(void)*); +alias fp_glTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glCopyTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +alias fp_glActiveTexture = void function(GLenum); +alias fp_glSampleCoverage = void function(GLfloat, GLboolean); +alias fp_glCompressedTexImage3D = void function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const(void)*); +alias fp_glCompressedTexImage2D = void function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const(void)*); +alias fp_glCompressedTexImage1D = void function(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const(void)*); +alias fp_glCompressedTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const(void)*); +alias fp_glCompressedTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const(void)*); +alias fp_glCompressedTexSubImage1D = void function(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const(void)*); +alias fp_glGetCompressedTexImage = void function(GLenum, GLint, void*); +alias fp_glClientActiveTexture = void function(GLenum); +alias fp_glMultiTexCoord1d = void function(GLenum, GLdouble); +alias fp_glMultiTexCoord1dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord1f = void function(GLenum, GLfloat); +alias fp_glMultiTexCoord1fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord1i = void function(GLenum, GLint); +alias fp_glMultiTexCoord1iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord1s = void function(GLenum, GLshort); +alias fp_glMultiTexCoord1sv = void function(GLenum, const(GLshort)*); +alias fp_glMultiTexCoord2d = void function(GLenum, GLdouble, GLdouble); +alias fp_glMultiTexCoord2dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord2f = void function(GLenum, GLfloat, GLfloat); +alias fp_glMultiTexCoord2fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord2i = void function(GLenum, GLint, GLint); +alias fp_glMultiTexCoord2iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord2s = void function(GLenum, GLshort, GLshort); +alias fp_glMultiTexCoord2sv = void function(GLenum, const(GLshort)*); +alias fp_glMultiTexCoord3d = void function(GLenum, GLdouble, GLdouble, GLdouble); +alias fp_glMultiTexCoord3dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord3f = void function(GLenum, GLfloat, GLfloat, GLfloat); +alias fp_glMultiTexCoord3fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord3i = void function(GLenum, GLint, GLint, GLint); +alias fp_glMultiTexCoord3iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord3s = void function(GLenum, GLshort, GLshort, GLshort); +alias fp_glMultiTexCoord3sv = void function(GLenum, const(GLshort)*); +alias fp_glMultiTexCoord4d = void function(GLenum, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glMultiTexCoord4dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord4f = void function(GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glMultiTexCoord4fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord4i = void function(GLenum, GLint, GLint, GLint, GLint); +alias fp_glMultiTexCoord4iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord4s = void function(GLenum, GLshort, GLshort, GLshort, GLshort); +alias fp_glMultiTexCoord4sv = void function(GLenum, const(GLshort)*); +alias fp_glLoadTransposeMatrixf = void function(const(GLfloat)*); +alias fp_glLoadTransposeMatrixd = void function(const(GLdouble)*); +alias fp_glMultTransposeMatrixf = void function(const(GLfloat)*); +alias fp_glMultTransposeMatrixd = void function(const(GLdouble)*); +alias fp_glBlendFuncSeparate = void function(GLenum, GLenum, GLenum, GLenum); +alias fp_glMultiDrawArrays = void function(GLenum, const(GLint)*, const(GLsizei)*, GLsizei); +alias fp_glMultiDrawElements = void function(GLenum, const(GLsizei)*, GLenum, const(void*)*, GLsizei); +alias fp_glPointParameterf = void function(GLenum, GLfloat); +alias fp_glPointParameterfv = void function(GLenum, const(GLfloat)*); +alias fp_glPointParameteri = void function(GLenum, GLint); +alias fp_glPointParameteriv = void function(GLenum, const(GLint)*); +alias fp_glFogCoordf = void function(GLfloat); +alias fp_glFogCoordfv = void function(const(GLfloat)*); +alias fp_glFogCoordd = void function(GLdouble); +alias fp_glFogCoorddv = void function(const(GLdouble)*); +alias fp_glFogCoordPointer = void function(GLenum, GLsizei, const(void)*); +alias fp_glSecondaryColor3b = void function(GLbyte, GLbyte, GLbyte); +alias fp_glSecondaryColor3bv = void function(const(GLbyte)*); +alias fp_glSecondaryColor3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glSecondaryColor3dv = void function(const(GLdouble)*); +alias fp_glSecondaryColor3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glSecondaryColor3fv = void function(const(GLfloat)*); +alias fp_glSecondaryColor3i = void function(GLint, GLint, GLint); +alias fp_glSecondaryColor3iv = void function(const(GLint)*); +alias fp_glSecondaryColor3s = void function(GLshort, GLshort, GLshort); +alias fp_glSecondaryColor3sv = void function(const(GLshort)*); +alias fp_glSecondaryColor3ub = void function(GLubyte, GLubyte, GLubyte); +alias fp_glSecondaryColor3ubv = void function(const(GLubyte)*); +alias fp_glSecondaryColor3ui = void function(GLuint, GLuint, GLuint); +alias fp_glSecondaryColor3uiv = void function(const(GLuint)*); +alias fp_glSecondaryColor3us = void function(GLushort, GLushort, GLushort); +alias fp_glSecondaryColor3usv = void function(const(GLushort)*); +alias fp_glSecondaryColorPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glWindowPos2d = void function(GLdouble, GLdouble); +alias fp_glWindowPos2dv = void function(const(GLdouble)*); +alias fp_glWindowPos2f = void function(GLfloat, GLfloat); +alias fp_glWindowPos2fv = void function(const(GLfloat)*); +alias fp_glWindowPos2i = void function(GLint, GLint); +alias fp_glWindowPos2iv = void function(const(GLint)*); +alias fp_glWindowPos2s = void function(GLshort, GLshort); +alias fp_glWindowPos2sv = void function(const(GLshort)*); +alias fp_glWindowPos3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glWindowPos3dv = void function(const(GLdouble)*); +alias fp_glWindowPos3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glWindowPos3fv = void function(const(GLfloat)*); +alias fp_glWindowPos3i = void function(GLint, GLint, GLint); +alias fp_glWindowPos3iv = void function(const(GLint)*); +alias fp_glWindowPos3s = void function(GLshort, GLshort, GLshort); +alias fp_glWindowPos3sv = void function(const(GLshort)*); +alias fp_glBlendColor = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glBlendEquation = void function(GLenum); +alias fp_glGenQueries = void function(GLsizei, GLuint*); +alias fp_glDeleteQueries = void function(GLsizei, const(GLuint)*); +alias fp_glIsQuery = GLboolean function(GLuint); +alias fp_glBeginQuery = void function(GLenum, GLuint); +alias fp_glEndQuery = void function(GLenum); +alias fp_glGetQueryiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetQueryObjectiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetQueryObjectuiv = void function(GLuint, GLenum, GLuint*); +alias fp_glBindBuffer = void function(GLenum, GLuint); +alias fp_glDeleteBuffers = void function(GLsizei, const(GLuint)*); +alias fp_glGenBuffers = void function(GLsizei, GLuint*); +alias fp_glIsBuffer = GLboolean function(GLuint); +alias fp_glBufferData = void function(GLenum, GLsizeiptr, const(void)*, GLenum); +alias fp_glBufferSubData = void function(GLenum, GLintptr, GLsizeiptr, const(void)*); +alias fp_glGetBufferSubData = void function(GLenum, GLintptr, GLsizeiptr, void*); +alias fp_glMapBuffer = void* function(GLenum, GLenum); +alias fp_glUnmapBuffer = GLboolean function(GLenum); +alias fp_glGetBufferParameteriv = void function(GLenum, GLenum, GLint*); +alias fp_glGetBufferPointerv = void function(GLenum, GLenum, void**); +alias fp_glBlendEquationSeparate = void function(GLenum, GLenum); +alias fp_glDrawBuffers = void function(GLsizei, const(GLenum)*); +alias fp_glStencilOpSeparate = void function(GLenum, GLenum, GLenum, GLenum); +alias fp_glStencilFuncSeparate = void function(GLenum, GLenum, GLint, GLuint); +alias fp_glStencilMaskSeparate = void function(GLenum, GLuint); +alias fp_glAttachShader = void function(GLuint, GLuint); +alias fp_glBindAttribLocation = void function(GLuint, GLuint, const(GLchar)*); +alias fp_glCompileShader = void function(GLuint); +alias fp_glCreateProgram = GLuint function(); +alias fp_glCreateShader = GLuint function(GLenum); +alias fp_glDeleteProgram = void function(GLuint); +alias fp_glDeleteShader = void function(GLuint); +alias fp_glDetachShader = void function(GLuint, GLuint); +alias fp_glDisableVertexAttribArray = void function(GLuint); +alias fp_glEnableVertexAttribArray = void function(GLuint); +alias fp_glGetActiveAttrib = void function(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*); +alias fp_glGetActiveUniform = void function(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*); +alias fp_glGetAttachedShaders = void function(GLuint, GLsizei, GLsizei*, GLuint*); +alias fp_glGetAttribLocation = GLint function(GLuint, const(GLchar)*); +alias fp_glGetProgramiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetProgramInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetShaderiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetShaderInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetShaderSource = void function(GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetUniformLocation = GLint function(GLuint, const(GLchar)*); +alias fp_glGetUniformfv = void function(GLuint, GLint, GLfloat*); +alias fp_glGetUniformiv = void function(GLuint, GLint, GLint*); +alias fp_glGetVertexAttribdv = void function(GLuint, GLenum, GLdouble*); +alias fp_glGetVertexAttribfv = void function(GLuint, GLenum, GLfloat*); +alias fp_glGetVertexAttribiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetVertexAttribPointerv = void function(GLuint, GLenum, void**); +alias fp_glIsProgram = GLboolean function(GLuint); +alias fp_glIsShader = GLboolean function(GLuint); +alias fp_glLinkProgram = void function(GLuint); +alias fp_glShaderSource = void function(GLuint, GLsizei, const(GLchar*)*, const(GLint)*); +alias fp_glUseProgram = void function(GLuint); +alias fp_glUniform1f = void function(GLint, GLfloat); +alias fp_glUniform2f = void function(GLint, GLfloat, GLfloat); +alias fp_glUniform3f = void function(GLint, GLfloat, GLfloat, GLfloat); +alias fp_glUniform4f = void function(GLint, GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glUniform1i = void function(GLint, GLint); +alias fp_glUniform2i = void function(GLint, GLint, GLint); +alias fp_glUniform3i = void function(GLint, GLint, GLint, GLint); +alias fp_glUniform4i = void function(GLint, GLint, GLint, GLint, GLint); +alias fp_glUniform1fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform2fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform3fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform4fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform1iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniform2iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniform3iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniform4iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniformMatrix2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glValidateProgram = void function(GLuint); +alias fp_glVertexAttrib1d = void function(GLuint, GLdouble); +alias fp_glVertexAttrib1dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib1f = void function(GLuint, GLfloat); +alias fp_glVertexAttrib1fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib1s = void function(GLuint, GLshort); +alias fp_glVertexAttrib1sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib2d = void function(GLuint, GLdouble, GLdouble); +alias fp_glVertexAttrib2dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib2f = void function(GLuint, GLfloat, GLfloat); +alias fp_glVertexAttrib2fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib2s = void function(GLuint, GLshort, GLshort); +alias fp_glVertexAttrib2sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib3d = void function(GLuint, GLdouble, GLdouble, GLdouble); +alias fp_glVertexAttrib3dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib3f = void function(GLuint, GLfloat, GLfloat, GLfloat); +alias fp_glVertexAttrib3fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib3s = void function(GLuint, GLshort, GLshort, GLshort); +alias fp_glVertexAttrib3sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib4Nbv = void function(GLuint, const(GLbyte)*); +alias fp_glVertexAttrib4Niv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttrib4Nsv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib4Nub = void function(GLuint, GLubyte, GLubyte, GLubyte, GLubyte); +alias fp_glVertexAttrib4Nubv = void function(GLuint, const(GLubyte)*); +alias fp_glVertexAttrib4Nuiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttrib4Nusv = void function(GLuint, const(GLushort)*); +alias fp_glVertexAttrib4bv = void function(GLuint, const(GLbyte)*); +alias fp_glVertexAttrib4d = void function(GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glVertexAttrib4dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib4f = void function(GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glVertexAttrib4fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib4iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttrib4s = void function(GLuint, GLshort, GLshort, GLshort, GLshort); +alias fp_glVertexAttrib4sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib4ubv = void function(GLuint, const(GLubyte)*); +alias fp_glVertexAttrib4uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttrib4usv = void function(GLuint, const(GLushort)*); +alias fp_glVertexAttribPointer = void function(GLuint, GLint, GLenum, GLboolean, GLsizei, const(void)*); +alias fp_glUniformMatrix2x3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix3x2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix2x4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix4x2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix3x4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix4x3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glColorMaski = void function(GLuint, GLboolean, GLboolean, GLboolean, GLboolean); +alias fp_glGetBooleani_v = void function(GLenum, GLuint, GLboolean*); +alias fp_glGetIntegeri_v = void function(GLenum, GLuint, GLint*); +alias fp_glEnablei = void function(GLenum, GLuint); +alias fp_glDisablei = void function(GLenum, GLuint); +alias fp_glIsEnabledi = GLboolean function(GLenum, GLuint); +alias fp_glBeginTransformFeedback = void function(GLenum); +alias fp_glEndTransformFeedback = void function(); +alias fp_glBindBufferRange = void function(GLenum, GLuint, GLuint, GLintptr, GLsizeiptr); +alias fp_glBindBufferBase = void function(GLenum, GLuint, GLuint); +alias fp_glTransformFeedbackVaryings = void function(GLuint, GLsizei, const(GLchar*)*, GLenum); +alias fp_glGetTransformFeedbackVarying = void function(GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, GLchar*); +alias fp_glClampColor = void function(GLenum, GLenum); +alias fp_glBeginConditionalRender = void function(GLuint, GLenum); +alias fp_glEndConditionalRender = void function(); +alias fp_glVertexAttribIPointer = void function(GLuint, GLint, GLenum, GLsizei, const(void)*); +alias fp_glGetVertexAttribIiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetVertexAttribIuiv = void function(GLuint, GLenum, GLuint*); +alias fp_glVertexAttribI1i = void function(GLuint, GLint); +alias fp_glVertexAttribI2i = void function(GLuint, GLint, GLint); +alias fp_glVertexAttribI3i = void function(GLuint, GLint, GLint, GLint); +alias fp_glVertexAttribI4i = void function(GLuint, GLint, GLint, GLint, GLint); +alias fp_glVertexAttribI1ui = void function(GLuint, GLuint); +alias fp_glVertexAttribI2ui = void function(GLuint, GLuint, GLuint); +alias fp_glVertexAttribI3ui = void function(GLuint, GLuint, GLuint, GLuint); +alias fp_glVertexAttribI4ui = void function(GLuint, GLuint, GLuint, GLuint, GLuint); +alias fp_glVertexAttribI1iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI2iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI3iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI4iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI1uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI2uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI3uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI4uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI4bv = void function(GLuint, const(GLbyte)*); +alias fp_glVertexAttribI4sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttribI4ubv = void function(GLuint, const(GLubyte)*); +alias fp_glVertexAttribI4usv = void function(GLuint, const(GLushort)*); +alias fp_glGetUniformuiv = void function(GLuint, GLint, GLuint*); +alias fp_glBindFragDataLocation = void function(GLuint, GLuint, const(GLchar)*); +alias fp_glGetFragDataLocation = GLint function(GLuint, const(GLchar)*); +alias fp_glUniform1ui = void function(GLint, GLuint); +alias fp_glUniform2ui = void function(GLint, GLuint, GLuint); +alias fp_glUniform3ui = void function(GLint, GLuint, GLuint, GLuint); +alias fp_glUniform4ui = void function(GLint, GLuint, GLuint, GLuint, GLuint); +alias fp_glUniform1uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glUniform2uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glUniform3uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glUniform4uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glTexParameterIiv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glTexParameterIuiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glGetTexParameterIiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetTexParameterIuiv = void function(GLenum, GLenum, GLuint*); +alias fp_glClearBufferiv = void function(GLenum, GLint, const(GLint)*); +alias fp_glClearBufferuiv = void function(GLenum, GLint, const(GLuint)*); +alias fp_glClearBufferfv = void function(GLenum, GLint, const(GLfloat)*); +alias fp_glClearBufferfi = void function(GLenum, GLint, GLfloat, GLint); +alias fp_glGetStringi = const(GLubyte)* function(GLenum, GLuint); +alias fp_glIsRenderbuffer = GLboolean function(GLuint); +alias fp_glBindRenderbuffer = void function(GLenum, GLuint); +alias fp_glDeleteRenderbuffers = void function(GLsizei, const(GLuint)*); +alias fp_glGenRenderbuffers = void function(GLsizei, GLuint*); +alias fp_glRenderbufferStorage = void function(GLenum, GLenum, GLsizei, GLsizei); +alias fp_glGetRenderbufferParameteriv = void function(GLenum, GLenum, GLint*); +alias fp_glIsFramebuffer = GLboolean function(GLuint); +alias fp_glBindFramebuffer = void function(GLenum, GLuint); +alias fp_glDeleteFramebuffers = void function(GLsizei, const(GLuint)*); +alias fp_glGenFramebuffers = void function(GLsizei, GLuint*); +alias fp_glCheckFramebufferStatus = GLenum function(GLenum); +alias fp_glFramebufferTexture1D = void function(GLenum, GLenum, GLenum, GLuint, GLint); +alias fp_glFramebufferTexture2D = void function(GLenum, GLenum, GLenum, GLuint, GLint); +alias fp_glFramebufferTexture3D = void function(GLenum, GLenum, GLenum, GLuint, GLint, GLint); +alias fp_glFramebufferRenderbuffer = void function(GLenum, GLenum, GLenum, GLuint); +alias fp_glGetFramebufferAttachmentParameteriv = void function(GLenum, GLenum, GLenum, GLint*); +alias fp_glGenerateMipmap = void function(GLenum); +alias fp_glBlitFramebuffer = void function(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum); +alias fp_glRenderbufferStorageMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei); +alias fp_glFramebufferTextureLayer = void function(GLenum, GLenum, GLuint, GLint, GLint); +alias fp_glMapBufferRange = void* function(GLenum, GLintptr, GLsizeiptr, GLbitfield); +alias fp_glFlushMappedBufferRange = void function(GLenum, GLintptr, GLsizeiptr); +alias fp_glBindVertexArray = void function(GLuint); +alias fp_glDeleteVertexArrays = void function(GLsizei, const(GLuint)*); +alias fp_glGenVertexArrays = void function(GLsizei, GLuint*); +alias fp_glIsVertexArray = GLboolean function(GLuint); +alias fp_glDrawArraysInstanced = void function(GLenum, GLint, GLsizei, GLsizei); +alias fp_glDrawElementsInstanced = void function(GLenum, GLsizei, GLenum, const(void)*, GLsizei); +alias fp_glTexBuffer = void function(GLenum, GLenum, GLuint); +alias fp_glPrimitiveRestartIndex = void function(GLuint); +alias fp_glCopyBufferSubData = void function(GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr); +alias fp_glGetUniformIndices = void function(GLuint, GLsizei, const(GLchar*)*, GLuint*); +alias fp_glGetActiveUniformsiv = void function(GLuint, GLsizei, const(GLuint)*, GLenum, GLint*); +alias fp_glGetActiveUniformName = void function(GLuint, GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetUniformBlockIndex = GLuint function(GLuint, const(GLchar)*); +alias fp_glGetActiveUniformBlockiv = void function(GLuint, GLuint, GLenum, GLint*); +alias fp_glGetActiveUniformBlockName = void function(GLuint, GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glUniformBlockBinding = void function(GLuint, GLuint, GLuint); +alias fp_glDrawElementsBaseVertex = void function(GLenum, GLsizei, GLenum, const(void)*, GLint); +alias fp_glDrawRangeElementsBaseVertex = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(void)*, GLint); +alias fp_glDrawElementsInstancedBaseVertex = void function(GLenum, GLsizei, GLenum, const(void)*, GLsizei, GLint); +alias fp_glMultiDrawElementsBaseVertex = void function(GLenum, const(GLsizei)*, GLenum, const(void*)*, GLsizei, const(GLint)*); +alias fp_glProvokingVertex = void function(GLenum); +alias fp_glFenceSync = GLsync function(GLenum, GLbitfield); +alias fp_glIsSync = GLboolean function(GLsync); +alias fp_glDeleteSync = void function(GLsync); +alias fp_glClientWaitSync = GLenum function(GLsync, GLbitfield, GLuint64); +alias fp_glWaitSync = void function(GLsync, GLbitfield, GLuint64); +alias fp_glGetInteger64v = void function(GLenum, GLint64*); +alias fp_glGetSynciv = void function(GLsync, GLenum, GLsizei, GLsizei*, GLint*); +alias fp_glGetInteger64i_v = void function(GLenum, GLuint, GLint64*); +alias fp_glGetBufferParameteri64v = void function(GLenum, GLenum, GLint64*); +alias fp_glFramebufferTexture = void function(GLenum, GLenum, GLuint, GLint); +alias fp_glTexImage2DMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean); +alias fp_glTexImage3DMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean); +alias fp_glGetMultisamplefv = void function(GLenum, GLuint, GLfloat*); +alias fp_glSampleMaski = void function(GLuint, GLbitfield); +alias fp_glBindFragDataLocationIndexed = void function(GLuint, GLuint, GLuint, const(GLchar)*); +alias fp_glGetFragDataIndex = GLint function(GLuint, const(GLchar)*); +alias fp_glGenSamplers = void function(GLsizei, GLuint*); +alias fp_glDeleteSamplers = void function(GLsizei, const(GLuint)*); +alias fp_glIsSampler = GLboolean function(GLuint); +alias fp_glBindSampler = void function(GLuint, GLuint); +alias fp_glSamplerParameteri = void function(GLuint, GLenum, GLint); +alias fp_glSamplerParameteriv = void function(GLuint, GLenum, const(GLint)*); +alias fp_glSamplerParameterf = void function(GLuint, GLenum, GLfloat); +alias fp_glSamplerParameterfv = void function(GLuint, GLenum, const(GLfloat)*); +alias fp_glSamplerParameterIiv = void function(GLuint, GLenum, const(GLint)*); +alias fp_glSamplerParameterIuiv = void function(GLuint, GLenum, const(GLuint)*); +alias fp_glGetSamplerParameteriv = void function(GLuint, GLenum, GLint*); +alias fp_glGetSamplerParameterIiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetSamplerParameterfv = void function(GLuint, GLenum, GLfloat*); +alias fp_glGetSamplerParameterIuiv = void function(GLuint, GLenum, GLuint*); +alias fp_glQueryCounter = void function(GLuint, GLenum); +alias fp_glGetQueryObjecti64v = void function(GLuint, GLenum, GLint64*); +alias fp_glGetQueryObjectui64v = void function(GLuint, GLenum, GLuint64*); +alias fp_glVertexAttribDivisor = void function(GLuint, GLuint); +alias fp_glVertexAttribP1ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP1uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexAttribP2ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP2uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexAttribP3ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP3uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexAttribP4ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP4uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexP2ui = void function(GLenum, GLuint); +alias fp_glVertexP2uiv = void function(GLenum, const(GLuint)*); +alias fp_glVertexP3ui = void function(GLenum, GLuint); +alias fp_glVertexP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glVertexP4ui = void function(GLenum, GLuint); +alias fp_glVertexP4uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP1ui = void function(GLenum, GLuint); +alias fp_glTexCoordP1uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP2ui = void function(GLenum, GLuint); +alias fp_glTexCoordP2uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP3ui = void function(GLenum, GLuint); +alias fp_glTexCoordP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP4ui = void function(GLenum, GLuint); +alias fp_glTexCoordP4uiv = void function(GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP1ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP1uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP2ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP2uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP3ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP3uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP4ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP4uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glNormalP3ui = void function(GLenum, GLuint); +alias fp_glNormalP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glColorP3ui = void function(GLenum, GLuint); +alias fp_glColorP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glColorP4ui = void function(GLenum, GLuint); +alias fp_glColorP4uiv = void function(GLenum, const(GLuint)*); +alias fp_glSecondaryColorP3ui = void function(GLenum, GLuint); +alias fp_glSecondaryColorP3uiv = void function(GLenum, const(GLuint)*); +} +__gshared { +fp_glCopyTexImage1D glCopyTexImage1D; +fp_glVertexAttribI3ui glVertexAttribI3ui; +fp_glWindowPos2s glWindowPos2s; +fp_glWindowPos2i glWindowPos2i; +fp_glWindowPos2f glWindowPos2f; +fp_glWindowPos2d glWindowPos2d; +fp_glVertex2fv glVertex2fv; +fp_glIndexi glIndexi; +fp_glFramebufferRenderbuffer glFramebufferRenderbuffer; +fp_glRectdv glRectdv; +fp_glCompressedTexSubImage3D glCompressedTexSubImage3D; +fp_glEvalCoord2d glEvalCoord2d; +fp_glEvalCoord2f glEvalCoord2f; +fp_glIndexd glIndexd; +fp_glVertexAttrib1sv glVertexAttrib1sv; +fp_glIndexf glIndexf; +fp_glBindSampler glBindSampler; +fp_glLineWidth glLineWidth; +fp_glColorP3uiv glColorP3uiv; +fp_glGetIntegeri_v glGetIntegeri_v; +fp_glGetMapfv glGetMapfv; +fp_glIndexs glIndexs; +fp_glCompileShader glCompileShader; +fp_glGetTransformFeedbackVarying glGetTransformFeedbackVarying; +fp_glWindowPos2iv glWindowPos2iv; +fp_glIndexfv glIndexfv; +fp_glFogiv glFogiv; +fp_glStencilMaskSeparate glStencilMaskSeparate; +fp_glRasterPos2fv glRasterPos2fv; +fp_glLightModeliv glLightModeliv; +fp_glColor4ui glColor4ui; +fp_glSecondaryColor3fv glSecondaryColor3fv; +fp_glMultiTexCoordP3ui glMultiTexCoordP3ui; +fp_glFogfv glFogfv; +fp_glVertexP4ui glVertexP4ui; +fp_glEnablei glEnablei; +fp_glVertex4iv glVertex4iv; +fp_glEvalCoord1fv glEvalCoord1fv; +fp_glWindowPos2sv glWindowPos2sv; +fp_glVertexAttribP4ui glVertexAttribP4ui; +fp_glCreateShader glCreateShader; +fp_glIsBuffer glIsBuffer; +fp_glGetMultisamplefv glGetMultisamplefv; +fp_glGenRenderbuffers glGenRenderbuffers; +fp_glCopyTexSubImage2D glCopyTexSubImage2D; +fp_glCompressedTexImage2D glCompressedTexImage2D; +fp_glVertexAttrib1f glVertexAttrib1f; +fp_glBlendFuncSeparate glBlendFuncSeparate; +fp_glVertex4fv glVertex4fv; +fp_glBindTexture glBindTexture; +fp_glVertexAttrib1s glVertexAttrib1s; +fp_glTexCoord2fv glTexCoord2fv; +fp_glSampleMaski glSampleMaski; +fp_glVertexP2ui glVertexP2ui; +fp_glDrawRangeElementsBaseVertex glDrawRangeElementsBaseVertex; +fp_glTexCoord4fv glTexCoord4fv; +fp_glUniformMatrix3x2fv glUniformMatrix3x2fv; +fp_glPointSize glPointSize; +fp_glVertexAttrib2dv glVertexAttrib2dv; +fp_glDeleteProgram glDeleteProgram; +fp_glColor4bv glColor4bv; +fp_glRasterPos2f glRasterPos2f; +fp_glRasterPos2d glRasterPos2d; +fp_glLoadIdentity glLoadIdentity; +fp_glRasterPos2i glRasterPos2i; +fp_glRenderbufferStorage glRenderbufferStorage; +fp_glUniformMatrix4x3fv glUniformMatrix4x3fv; +fp_glColor3b glColor3b; +fp_glClearBufferfv glClearBufferfv; +fp_glEdgeFlag glEdgeFlag; +fp_glDeleteSamplers glDeleteSamplers; +fp_glVertex3d glVertex3d; +fp_glVertex3f glVertex3f; +fp_glVertex3i glVertex3i; +fp_glColor3i glColor3i; +fp_glUniform3f glUniform3f; +fp_glVertexAttrib4ubv glVertexAttrib4ubv; +fp_glColor3s glColor3s; +fp_glVertex3s glVertex3s; +fp_glTexCoordP2ui glTexCoordP2ui; +fp_glColorMaski glColorMaski; +fp_glClearBufferfi glClearBufferfi; +fp_glTexCoord1iv glTexCoord1iv; +fp_glBlitFramebuffer glBlitFramebuffer; +fp_glMultiTexCoordP2ui glMultiTexCoordP2ui; +fp_glGetSamplerParameterIiv glGetSamplerParameterIiv; +fp_glGetFragDataIndex glGetFragDataIndex; +fp_glVertexAttrib3f glVertexAttrib3f; +fp_glVertex2iv glVertex2iv; +fp_glColor3sv glColor3sv; +fp_glGetVertexAttribdv glGetVertexAttribdv; +fp_glUniformMatrix3x4fv glUniformMatrix3x4fv; +fp_glNormalPointer glNormalPointer; +fp_glTexCoordP3uiv glTexCoordP3uiv; +fp_glVertex4sv glVertex4sv; +fp_glPassThrough glPassThrough; +fp_glMultiTexCoordP4ui glMultiTexCoordP4ui; +fp_glFogi glFogi; +fp_glBegin glBegin; +fp_glEvalCoord2dv glEvalCoord2dv; +fp_glColor3ubv glColor3ubv; +fp_glVertexPointer glVertexPointer; +fp_glSecondaryColor3uiv glSecondaryColor3uiv; +fp_glDeleteFramebuffers glDeleteFramebuffers; +fp_glDrawArrays glDrawArrays; +fp_glUniform1ui glUniform1ui; +fp_glMultiTexCoord1d glMultiTexCoord1d; +fp_glMultiTexCoord1f glMultiTexCoord1f; +fp_glLightfv glLightfv; +fp_glTexCoordP3ui glTexCoordP3ui; +fp_glVertexAttrib3d glVertexAttrib3d; +fp_glClear glClear; +fp_glMultiTexCoord1i glMultiTexCoord1i; +fp_glGetActiveUniformName glGetActiveUniformName; +fp_glMultiTexCoord1s glMultiTexCoord1s; +fp_glIsEnabled glIsEnabled; +fp_glStencilOp glStencilOp; +fp_glGetQueryObjectuiv glGetQueryObjectuiv; +fp_glFramebufferTexture2D glFramebufferTexture2D; +fp_glGetFramebufferAttachmentParameteriv glGetFramebufferAttachmentParameteriv; +fp_glTranslatef glTranslatef; +fp_glVertexAttrib4Nub glVertexAttrib4Nub; +fp_glTranslated glTranslated; +fp_glTexCoord3sv glTexCoord3sv; +fp_glGetFragDataLocation glGetFragDataLocation; +fp_glTexImage1D glTexImage1D; +fp_glVertexP3uiv glVertexP3uiv; +fp_glTexParameteriv glTexParameteriv; +fp_glSecondaryColor3bv glSecondaryColor3bv; +fp_glGetMaterialfv glGetMaterialfv; +fp_glGetTexImage glGetTexImage; +fp_glFogCoordfv glFogCoordfv; +fp_glPixelMapuiv glPixelMapuiv; +fp_glGetShaderInfoLog glGetShaderInfoLog; +fp_glGetQueryObjecti64v glGetQueryObjecti64v; +fp_glGenFramebuffers glGenFramebuffers; +fp_glIndexsv glIndexsv; +fp_glGetAttachedShaders glGetAttachedShaders; +fp_glIsRenderbuffer glIsRenderbuffer; +fp_glVertex3iv glVertex3iv; +fp_glBitmap glBitmap; +fp_glMateriali glMateriali; +fp_glIsVertexArray glIsVertexArray; +fp_glDisableVertexAttribArray glDisableVertexAttribArray; +fp_glGetQueryiv glGetQueryiv; +fp_glTexCoord4f glTexCoord4f; +fp_glTexCoord4d glTexCoord4d; +fp_glGetSamplerParameterfv glGetSamplerParameterfv; +fp_glTexCoord4i glTexCoord4i; +fp_glMaterialf glMaterialf; +fp_glTexCoord4s glTexCoord4s; +fp_glGetUniformIndices glGetUniformIndices; +fp_glIsShader glIsShader; +fp_glMultiTexCoord2s glMultiTexCoord2s; +fp_glVertexAttribI4ubv glVertexAttribI4ubv; +fp_glVertex3dv glVertex3dv; +fp_glGetInteger64v glGetInteger64v; +fp_glPointParameteriv glPointParameteriv; +fp_glEnable glEnable; +fp_glGetActiveUniformsiv glGetActiveUniformsiv; +fp_glColor4fv glColor4fv; +fp_glTexCoord1fv glTexCoord1fv; +fp_glTexCoord2sv glTexCoord2sv; +fp_glVertexAttrib4dv glVertexAttrib4dv; +fp_glMultiTexCoord1dv glMultiTexCoord1dv; +fp_glMultiTexCoord2i glMultiTexCoord2i; +fp_glTexCoord3fv glTexCoord3fv; +fp_glSecondaryColor3usv glSecondaryColor3usv; +fp_glTexGenf glTexGenf; +fp_glMultiTexCoordP3uiv glMultiTexCoordP3uiv; +fp_glVertexAttribP3ui glVertexAttribP3ui; +fp_glMultiTexCoordP1ui glMultiTexCoordP1ui; +fp_glGetPointerv glGetPointerv; +fp_glPolygonOffset glPolygonOffset; +fp_glGetUniformuiv glGetUniformuiv; +fp_glNormal3fv glNormal3fv; +fp_glSecondaryColor3s glSecondaryColor3s; +fp_glDepthRange glDepthRange; +fp_glFrustum glFrustum; +fp_glMultiTexCoord4sv glMultiTexCoord4sv; +fp_glDrawBuffer glDrawBuffer; +fp_glPushMatrix glPushMatrix; +fp_glRasterPos3fv glRasterPos3fv; +fp_glOrtho glOrtho; +fp_glDrawElementsInstanced glDrawElementsInstanced; +fp_glWindowPos3sv glWindowPos3sv; +fp_glClearIndex glClearIndex; +fp_glMap1d glMap1d; +fp_glMap1f glMap1f; +fp_glFlush glFlush; +fp_glGetRenderbufferParameteriv glGetRenderbufferParameteriv; +fp_glIndexiv glIndexiv; +fp_glRasterPos3sv glRasterPos3sv; +fp_glGetVertexAttribPointerv glGetVertexAttribPointerv; +fp_glPixelZoom glPixelZoom; +fp_glFenceSync glFenceSync; +fp_glDeleteVertexArrays glDeleteVertexArrays; +fp_glColorP3ui glColorP3ui; +fp_glVertexAttrib3sv glVertexAttrib3sv; +fp_glBeginConditionalRender glBeginConditionalRender; +fp_glDrawElementsBaseVertex glDrawElementsBaseVertex; +fp_glGetTexLevelParameteriv glGetTexLevelParameteriv; +fp_glLighti glLighti; +fp_glMultiTexCoordP4uiv glMultiTexCoordP4uiv; +fp_glLightf glLightf; +fp_glGetAttribLocation glGetAttribLocation; +fp_glStencilFuncSeparate glStencilFuncSeparate; +fp_glGenSamplers glGenSamplers; +fp_glClampColor glClampColor; +fp_glUniform4iv glUniform4iv; +fp_glClearStencil glClearStencil; +fp_glTexCoordP1uiv glTexCoordP1uiv; +fp_glMultiTexCoord3fv glMultiTexCoord3fv; +fp_glGetPixelMapuiv glGetPixelMapuiv; +fp_glGenTextures glGenTextures; +fp_glTexCoord4iv glTexCoord4iv; +fp_glGetTexParameterIuiv glGetTexParameterIuiv; +fp_glIndexPointer glIndexPointer; +fp_glVertexAttrib4Nbv glVertexAttrib4Nbv; +fp_glIsSync glIsSync; +fp_glVertex2f glVertex2f; +fp_glVertex2d glVertex2d; +fp_glDeleteRenderbuffers glDeleteRenderbuffers; +fp_glUniform2i glUniform2i; +fp_glMapGrid2d glMapGrid2d; +fp_glMapGrid2f glMapGrid2f; +fp_glTexCoordP4ui glTexCoordP4ui; +fp_glVertex2i glVertex2i; +fp_glVertexAttribPointer glVertexAttribPointer; +fp_glFramebufferTextureLayer glFramebufferTextureLayer; +fp_glVertex2s glVertex2s; +fp_glNormal3bv glNormal3bv; +fp_glVertexAttrib4Nuiv glVertexAttrib4Nuiv; +fp_glFlushMappedBufferRange glFlushMappedBufferRange; +fp_glSecondaryColor3sv glSecondaryColor3sv; +fp_glVertex3sv glVertex3sv; +fp_glGenQueries glGenQueries; +fp_glGetPixelMapfv glGetPixelMapfv; +fp_glTexEnvf glTexEnvf; +fp_glVertexAttribP1ui glVertexAttribP1ui; +fp_glTexSubImage3D glTexSubImage3D; +fp_glGetInteger64i_v glGetInteger64i_v; +fp_glFogCoordd glFogCoordd; +fp_glFogCoordf glFogCoordf; +fp_glCopyTexImage2D glCopyTexImage2D; +fp_glTexEnvi glTexEnvi; +fp_glMultiTexCoord1iv glMultiTexCoord1iv; +fp_glIsEnabledi glIsEnabledi; +fp_glSecondaryColorP3ui glSecondaryColorP3ui; +fp_glVertexAttribI2i glVertexAttribI2i; +fp_glBindFragDataLocationIndexed glBindFragDataLocationIndexed; +fp_glMultiTexCoord2dv glMultiTexCoord2dv; +fp_glUniform2iv glUniform2iv; +fp_glVertexAttrib1fv glVertexAttrib1fv; +fp_glUniform4uiv glUniform4uiv; +fp_glMatrixMode glMatrixMode; +fp_glFeedbackBuffer glFeedbackBuffer; +fp_glGetMapiv glGetMapiv; +fp_glFramebufferTexture1D glFramebufferTexture1D; +fp_glGetShaderiv glGetShaderiv; +fp_glMultiTexCoord2d glMultiTexCoord2d; +fp_glMultiTexCoord2f glMultiTexCoord2f; +fp_glBindFragDataLocation glBindFragDataLocation; +fp_glPrioritizeTextures glPrioritizeTextures; +fp_glCallList glCallList; +fp_glSecondaryColor3ubv glSecondaryColor3ubv; +fp_glGetDoublev glGetDoublev; +fp_glMultiTexCoord3iv glMultiTexCoord3iv; +fp_glVertexAttrib1d glVertexAttrib1d; +fp_glLightModelf glLightModelf; +fp_glGetUniformiv glGetUniformiv; +fp_glVertex2sv glVertex2sv; +fp_glLightModeli glLightModeli; +fp_glWindowPos3iv glWindowPos3iv; +fp_glMultiTexCoordP1uiv glMultiTexCoordP1uiv; +fp_glUniform3fv glUniform3fv; +fp_glPixelStorei glPixelStorei; +fp_glCallLists glCallLists; +fp_glMapBuffer glMapBuffer; +fp_glSecondaryColor3d glSecondaryColor3d; +fp_glTexCoord3i glTexCoord3i; +fp_glMultiTexCoord4fv glMultiTexCoord4fv; +fp_glRasterPos3i glRasterPos3i; +fp_glSecondaryColor3b glSecondaryColor3b; +fp_glRasterPos3d glRasterPos3d; +fp_glRasterPos3f glRasterPos3f; +fp_glCompressedTexImage3D glCompressedTexImage3D; +fp_glTexCoord3f glTexCoord3f; +fp_glDeleteSync glDeleteSync; +fp_glTexCoord3d glTexCoord3d; +fp_glTexImage2DMultisample glTexImage2DMultisample; +fp_glGetVertexAttribiv glGetVertexAttribiv; +fp_glMultiDrawElements glMultiDrawElements; +fp_glVertexAttrib3fv glVertexAttrib3fv; +fp_glTexCoord3s glTexCoord3s; +fp_glUniform3iv glUniform3iv; +fp_glRasterPos3s glRasterPos3s; +fp_glPolygonMode glPolygonMode; +fp_glDrawBuffers glDrawBuffers; +fp_glGetActiveUniformBlockiv glGetActiveUniformBlockiv; +fp_glAreTexturesResident glAreTexturesResident; +fp_glIsList glIsList; +fp_glRasterPos2sv glRasterPos2sv; +fp_glRasterPos4sv glRasterPos4sv; +fp_glColor4s glColor4s; +fp_glUseProgram glUseProgram; +fp_glLineStipple glLineStipple; +fp_glMultiTexCoord1sv glMultiTexCoord1sv; +fp_glGetProgramInfoLog glGetProgramInfoLog; +fp_glGetBufferParameteriv glGetBufferParameteriv; +fp_glMultiTexCoord2iv glMultiTexCoord2iv; +fp_glUniformMatrix2x4fv glUniformMatrix2x4fv; +fp_glBindVertexArray glBindVertexArray; +fp_glColor4b glColor4b; +fp_glSecondaryColor3f glSecondaryColor3f; +fp_glColor4f glColor4f; +fp_glColor4d glColor4d; +fp_glColor4i glColor4i; +fp_glSamplerParameterIiv glSamplerParameterIiv; +fp_glMultiDrawElementsBaseVertex glMultiDrawElementsBaseVertex; +fp_glRasterPos3iv glRasterPos3iv; +fp_glVertex2dv glVertex2dv; +fp_glTexCoord4sv glTexCoord4sv; +fp_glUniform2uiv glUniform2uiv; +fp_glCompressedTexSubImage1D glCompressedTexSubImage1D; +fp_glFinish glFinish; +fp_glGetBooleanv glGetBooleanv; +fp_glDeleteShader glDeleteShader; +fp_glDrawElements glDrawElements; +fp_glRasterPos2s glRasterPos2s; +fp_glGetMapdv glGetMapdv; +fp_glVertexAttrib4Nsv glVertexAttrib4Nsv; +fp_glMaterialfv glMaterialfv; +fp_glViewport glViewport; +fp_glUniform1uiv glUniform1uiv; +fp_glTransformFeedbackVaryings glTransformFeedbackVaryings; +fp_glIndexdv glIndexdv; +fp_glCopyTexSubImage3D glCopyTexSubImage3D; +fp_glTexCoord3iv glTexCoord3iv; +fp_glVertexAttribI3i glVertexAttribI3i; +fp_glClearDepth glClearDepth; +fp_glVertexAttribI4usv glVertexAttribI4usv; +fp_glTexParameterf glTexParameterf; +fp_glTexParameteri glTexParameteri; +fp_glGetShaderSource glGetShaderSource; +fp_glTexBuffer glTexBuffer; +fp_glPopName glPopName; +fp_glValidateProgram glValidateProgram; +fp_glPixelStoref glPixelStoref; +fp_glUniform3uiv glUniform3uiv; +fp_glRasterPos4fv glRasterPos4fv; +fp_glEvalCoord1dv glEvalCoord1dv; +fp_glMultiTexCoordP2uiv glMultiTexCoordP2uiv; +fp_glRecti glRecti; +fp_glColor4ub glColor4ub; +fp_glMultTransposeMatrixf glMultTransposeMatrixf; +fp_glRectf glRectf; +fp_glRectd glRectd; +fp_glNormal3sv glNormal3sv; +fp_glNewList glNewList; +fp_glColor4us glColor4us; +fp_glVertexAttribP1uiv glVertexAttribP1uiv; +fp_glLinkProgram glLinkProgram; +fp_glHint glHint; +fp_glRects glRects; +fp_glTexCoord2dv glTexCoord2dv; +fp_glRasterPos4iv glRasterPos4iv; +fp_glGetString glGetString; +fp_glVertexAttribP2uiv glVertexAttribP2uiv; +fp_glEdgeFlagv glEdgeFlagv; +fp_glDetachShader glDetachShader; +fp_glScalef glScalef; +fp_glEndQuery glEndQuery; +fp_glScaled glScaled; +fp_glEdgeFlagPointer glEdgeFlagPointer; +fp_glCopyPixels glCopyPixels; +fp_glVertexAttribI2ui glVertexAttribI2ui; +fp_glPopAttrib glPopAttrib; +fp_glDeleteTextures glDeleteTextures; +fp_glStencilOpSeparate glStencilOpSeparate; +fp_glDeleteQueries glDeleteQueries; +fp_glNormalP3uiv glNormalP3uiv; +fp_glVertexAttrib4f glVertexAttrib4f; +fp_glVertexAttrib4d glVertexAttrib4d; +fp_glInitNames glInitNames; +fp_glGetBufferParameteri64v glGetBufferParameteri64v; +fp_glColor3dv glColor3dv; +fp_glVertexAttribI1i glVertexAttribI1i; +fp_glGetTexParameteriv glGetTexParameteriv; +fp_glWaitSync glWaitSync; +fp_glVertexAttrib4s glVertexAttrib4s; +fp_glColorMaterial glColorMaterial; +fp_glSampleCoverage glSampleCoverage; +fp_glSamplerParameteri glSamplerParameteri; +fp_glSamplerParameterf glSamplerParameterf; +fp_glUniform1f glUniform1f; +fp_glGetVertexAttribfv glGetVertexAttribfv; +fp_glRenderMode glRenderMode; +fp_glGetCompressedTexImage glGetCompressedTexImage; +fp_glWindowPos2dv glWindowPos2dv; +fp_glUniform1i glUniform1i; +fp_glGetActiveAttrib glGetActiveAttrib; +fp_glUniform3i glUniform3i; +fp_glPixelTransferi glPixelTransferi; +fp_glTexSubImage2D glTexSubImage2D; +fp_glDisable glDisable; +fp_glLogicOp glLogicOp; +fp_glEvalPoint2 glEvalPoint2; +fp_glPixelTransferf glPixelTransferf; +fp_glSecondaryColor3i glSecondaryColor3i; +fp_glUniform4ui glUniform4ui; +fp_glColor3f glColor3f; +fp_glBindFramebuffer glBindFramebuffer; +fp_glGetTexEnvfv glGetTexEnvfv; +fp_glRectfv glRectfv; +fp_glCullFace glCullFace; +fp_glGetLightfv glGetLightfv; +fp_glColor3d glColor3d; +fp_glTexGend glTexGend; +fp_glTexGeni glTexGeni; +fp_glMultiTexCoord3s glMultiTexCoord3s; +fp_glGetStringi glGetStringi; +fp_glMultiTexCoord3i glMultiTexCoord3i; +fp_glMultiTexCoord3f glMultiTexCoord3f; +fp_glMultiTexCoord3d glMultiTexCoord3d; +fp_glAttachShader glAttachShader; +fp_glFogCoorddv glFogCoorddv; +fp_glUniformMatrix2x3fv glUniformMatrix2x3fv; +fp_glGetTexGenfv glGetTexGenfv; +fp_glQueryCounter glQueryCounter; +fp_glFogCoordPointer glFogCoordPointer; +fp_glProvokingVertex glProvokingVertex; +fp_glFramebufferTexture3D glFramebufferTexture3D; +fp_glTexGeniv glTexGeniv; +fp_glRasterPos2dv glRasterPos2dv; +fp_glSecondaryColor3dv glSecondaryColor3dv; +fp_glClientActiveTexture glClientActiveTexture; +fp_glVertexAttribI4sv glVertexAttribI4sv; +fp_glSecondaryColor3us glSecondaryColor3us; +fp_glNormalP3ui glNormalP3ui; +fp_glTexEnvfv glTexEnvfv; +fp_glReadBuffer glReadBuffer; +fp_glTexParameterIuiv glTexParameterIuiv; +fp_glDrawArraysInstanced glDrawArraysInstanced; +fp_glGenerateMipmap glGenerateMipmap; +fp_glWindowPos3fv glWindowPos3fv; +fp_glLightModelfv glLightModelfv; +fp_glSamplerParameteriv glSamplerParameteriv; +fp_glDeleteLists glDeleteLists; +fp_glGetClipPlane glGetClipPlane; +fp_glVertex4dv glVertex4dv; +fp_glTexCoord2d glTexCoord2d; +fp_glPopMatrix glPopMatrix; +fp_glTexCoord2f glTexCoord2f; +fp_glColor4iv glColor4iv; +fp_glIndexubv glIndexubv; +fp_glUnmapBuffer glUnmapBuffer; +fp_glTexCoord2i glTexCoord2i; +fp_glRasterPos4d glRasterPos4d; +fp_glRasterPos4f glRasterPos4f; +fp_glVertexAttrib3s glVertexAttrib3s; +fp_glTexCoord2s glTexCoord2s; +fp_glBindRenderbuffer glBindRenderbuffer; +fp_glVertex3fv glVertex3fv; +fp_glTexCoord4dv glTexCoord4dv; +fp_glMaterialiv glMaterialiv; +fp_glVertexAttribP4uiv glVertexAttribP4uiv; +fp_glIsProgram glIsProgram; +fp_glVertexAttrib4bv glVertexAttrib4bv; +fp_glVertex4s glVertex4s; +fp_glVertexAttrib4fv glVertexAttrib4fv; +fp_glNormal3dv glNormal3dv; +fp_glUniform4i glUniform4i; +fp_glActiveTexture glActiveTexture; +fp_glEnableVertexAttribArray glEnableVertexAttribArray; +fp_glRotated glRotated; +fp_glRotatef glRotatef; +fp_glVertex4i glVertex4i; +fp_glReadPixels glReadPixels; +fp_glVertexAttribI3iv glVertexAttribI3iv; +fp_glLoadName glLoadName; +fp_glUniform4f glUniform4f; +fp_glRenderbufferStorageMultisample glRenderbufferStorageMultisample; +fp_glGenVertexArrays glGenVertexArrays; +fp_glShadeModel glShadeModel; +fp_glMapGrid1d glMapGrid1d; +fp_glGetUniformfv glGetUniformfv; +fp_glMapGrid1f glMapGrid1f; +fp_glSamplerParameterfv glSamplerParameterfv; +fp_glDisableClientState glDisableClientState; +fp_glMultiTexCoord3sv glMultiTexCoord3sv; +fp_glDrawElementsInstancedBaseVertex glDrawElementsInstancedBaseVertex; +fp_glSecondaryColorPointer glSecondaryColorPointer; +fp_glAlphaFunc glAlphaFunc; +fp_glUniform1iv glUniform1iv; +fp_glMultiTexCoord4iv glMultiTexCoord4iv; +fp_glGetQueryObjectiv glGetQueryObjectiv; +fp_glStencilFunc glStencilFunc; +fp_glMultiTexCoord1fv glMultiTexCoord1fv; +fp_glUniformBlockBinding glUniformBlockBinding; +fp_glColor4uiv glColor4uiv; +fp_glRectiv glRectiv; +fp_glColorP4ui glColorP4ui; +fp_glRasterPos3dv glRasterPos3dv; +fp_glEvalMesh2 glEvalMesh2; +fp_glEvalMesh1 glEvalMesh1; +fp_glTexCoordPointer glTexCoordPointer; +fp_glVertexAttrib4Nubv glVertexAttrib4Nubv; +fp_glVertexAttribI4iv glVertexAttribI4iv; +fp_glEvalCoord2fv glEvalCoord2fv; +fp_glColor4ubv glColor4ubv; +fp_glLoadTransposeMatrixd glLoadTransposeMatrixd; +fp_glLoadTransposeMatrixf glLoadTransposeMatrixf; +fp_glVertexAttribI4i glVertexAttribI4i; +fp_glRasterPos2iv glRasterPos2iv; +fp_glGetBufferSubData glGetBufferSubData; +fp_glTexEnviv glTexEnviv; +fp_glBlendEquationSeparate glBlendEquationSeparate; +fp_glVertexAttribI1ui glVertexAttribI1ui; +fp_glGenBuffers glGenBuffers; +fp_glSelectBuffer glSelectBuffer; +fp_glVertexAttrib2sv glVertexAttrib2sv; +fp_glPushAttrib glPushAttrib; +fp_glVertexAttribIPointer glVertexAttribIPointer; +fp_glBlendFunc glBlendFunc; +fp_glCreateProgram glCreateProgram; +fp_glTexImage3D glTexImage3D; +fp_glIsFramebuffer glIsFramebuffer; +fp_glLightiv glLightiv; +fp_glPrimitiveRestartIndex glPrimitiveRestartIndex; +fp_glTexGenfv glTexGenfv; +fp_glEnd glEnd; +fp_glDeleteBuffers glDeleteBuffers; +fp_glScissor glScissor; +fp_glTexCoordP4uiv glTexCoordP4uiv; +fp_glClipPlane glClipPlane; +fp_glPushName glPushName; +fp_glTexGendv glTexGendv; +fp_glIndexub glIndexub; +fp_glVertexP2uiv glVertexP2uiv; +fp_glSecondaryColor3iv glSecondaryColor3iv; +fp_glRasterPos4i glRasterPos4i; +fp_glMultTransposeMatrixd glMultTransposeMatrixd; +fp_glClearColor glClearColor; +fp_glVertexAttrib4uiv glVertexAttrib4uiv; +fp_glNormal3s glNormal3s; +fp_glVertexAttrib4Niv glVertexAttrib4Niv; +fp_glClearBufferiv glClearBufferiv; +fp_glPointParameteri glPointParameteri; +fp_glColorP4uiv glColorP4uiv; +fp_glBlendColor glBlendColor; +fp_glWindowPos3d glWindowPos3d; +fp_glVertexAttribI2uiv glVertexAttribI2uiv; +fp_glSamplerParameterIuiv glSamplerParameterIuiv; +fp_glUniform3ui glUniform3ui; +fp_glColor4dv glColor4dv; +fp_glVertexAttribI4uiv glVertexAttribI4uiv; +fp_glPointParameterfv glPointParameterfv; +fp_glUniform2fv glUniform2fv; +fp_glSecondaryColor3ub glSecondaryColor3ub; +fp_glSecondaryColor3ui glSecondaryColor3ui; +fp_glTexCoord3dv glTexCoord3dv; +fp_glGetSamplerParameterIuiv glGetSamplerParameterIuiv; +fp_glBindBufferRange glBindBufferRange; +fp_glNormal3iv glNormal3iv; +fp_glWindowPos3s glWindowPos3s; +fp_glPointParameterf glPointParameterf; +fp_glGetVertexAttribIuiv glGetVertexAttribIuiv; +fp_glWindowPos3i glWindowPos3i; +fp_glMultiTexCoord4s glMultiTexCoord4s; +fp_glWindowPos3f glWindowPos3f; +fp_glColor3us glColor3us; +fp_glColor3uiv glColor3uiv; +fp_glVertexAttrib4Nusv glVertexAttrib4Nusv; +fp_glGetLightiv glGetLightiv; +fp_glDepthFunc glDepthFunc; +fp_glCompressedTexSubImage2D glCompressedTexSubImage2D; +fp_glListBase glListBase; +fp_glMultiTexCoord4f glMultiTexCoord4f; +fp_glColor3ub glColor3ub; +fp_glMultiTexCoord4d glMultiTexCoord4d; +fp_glVertexAttribI4bv glVertexAttribI4bv; +fp_glGetTexParameterfv glGetTexParameterfv; +fp_glColor3ui glColor3ui; +fp_glMultiTexCoord4i glMultiTexCoord4i; +fp_glGetPolygonStipple glGetPolygonStipple; +fp_glClientWaitSync glClientWaitSync; +fp_glVertexAttribI4ui glVertexAttribI4ui; +fp_glMultiTexCoord4dv glMultiTexCoord4dv; +fp_glColorMask glColorMask; +fp_glTexParameterIiv glTexParameterIiv; +fp_glBlendEquation glBlendEquation; +fp_glGetUniformLocation glGetUniformLocation; +fp_glGetSamplerParameteriv glGetSamplerParameteriv; +fp_glRasterPos4s glRasterPos4s; +fp_glEndTransformFeedback glEndTransformFeedback; +fp_glVertexAttrib4usv glVertexAttrib4usv; +fp_glMultiTexCoord3dv glMultiTexCoord3dv; +fp_glColor4sv glColor4sv; +fp_glPopClientAttrib glPopClientAttrib; +fp_glBeginTransformFeedback glBeginTransformFeedback; +fp_glFogf glFogf; +fp_glVertexAttribI1iv glVertexAttribI1iv; +fp_glIsSampler glIsSampler; +fp_glVertexP3ui glVertexP3ui; +fp_glVertexAttribDivisor glVertexAttribDivisor; +fp_glColor3iv glColor3iv; +fp_glCompressedTexImage1D glCompressedTexImage1D; +fp_glCopyTexSubImage1D glCopyTexSubImage1D; +fp_glTexCoord1i glTexCoord1i; +fp_glCheckFramebufferStatus glCheckFramebufferStatus; +fp_glTexCoord1d glTexCoord1d; +fp_glTexCoord1f glTexCoord1f; +fp_glEndConditionalRender glEndConditionalRender; +fp_glEnableClientState glEnableClientState; +fp_glBindAttribLocation glBindAttribLocation; +fp_glUniformMatrix4x2fv glUniformMatrix4x2fv; +fp_glMultiTexCoord2sv glMultiTexCoord2sv; +fp_glVertexAttrib1dv glVertexAttrib1dv; +fp_glDrawRangeElements glDrawRangeElements; +fp_glTexCoord1s glTexCoord1s; +fp_glBindBufferBase glBindBufferBase; +fp_glBufferSubData glBufferSubData; +fp_glVertexAttrib4iv glVertexAttrib4iv; +fp_glGenLists glGenLists; +fp_glColor3bv glColor3bv; +fp_glMapBufferRange glMapBufferRange; +fp_glFramebufferTexture glFramebufferTexture; +fp_glGetTexGendv glGetTexGendv; +fp_glMultiDrawArrays glMultiDrawArrays; +fp_glEndList glEndList; +fp_glVertexP4uiv glVertexP4uiv; +fp_glUniform2ui glUniform2ui; +fp_glVertexAttribI2iv glVertexAttribI2iv; +fp_glColor3usv glColor3usv; +fp_glWindowPos2fv glWindowPos2fv; +fp_glDisablei glDisablei; +fp_glIndexMask glIndexMask; +fp_glPushClientAttrib glPushClientAttrib; +fp_glShaderSource glShaderSource; +fp_glGetActiveUniformBlockName glGetActiveUniformBlockName; +fp_glVertexAttribI3uiv glVertexAttribI3uiv; +fp_glClearAccum glClearAccum; +fp_glGetSynciv glGetSynciv; +fp_glTexCoordP2uiv glTexCoordP2uiv; +fp_glUniform2f glUniform2f; +fp_glBeginQuery glBeginQuery; +fp_glGetUniformBlockIndex glGetUniformBlockIndex; +fp_glBindBuffer glBindBuffer; +fp_glMap2d glMap2d; +fp_glMap2f glMap2f; +fp_glVertex4d glVertex4d; +fp_glUniformMatrix2fv glUniformMatrix2fv; +fp_glTexCoord1sv glTexCoord1sv; +fp_glBufferData glBufferData; +fp_glEvalPoint1 glEvalPoint1; +fp_glGetTexParameterIiv glGetTexParameterIiv; +fp_glTexCoord1dv glTexCoord1dv; +fp_glTexCoordP1ui glTexCoordP1ui; +fp_glGetError glGetError; +fp_glGetTexEnviv glGetTexEnviv; +fp_glGetProgramiv glGetProgramiv; +fp_glVertexAttribP2ui glVertexAttribP2ui; +fp_glGetFloatv glGetFloatv; +fp_glTexSubImage1D glTexSubImage1D; +fp_glMultiTexCoord2fv glMultiTexCoord2fv; +fp_glVertexAttrib2fv glVertexAttrib2fv; +fp_glEvalCoord1d glEvalCoord1d; +fp_glGetTexLevelParameterfv glGetTexLevelParameterfv; +fp_glEvalCoord1f glEvalCoord1f; +fp_glPixelMapfv glPixelMapfv; +fp_glVertexAttribP3uiv glVertexAttribP3uiv; +fp_glGetPixelMapusv glGetPixelMapusv; +fp_glSecondaryColorP3uiv glSecondaryColorP3uiv; +fp_glGetIntegerv glGetIntegerv; +fp_glAccum glAccum; +fp_glGetBufferPointerv glGetBufferPointerv; +fp_glGetVertexAttribIiv glGetVertexAttribIiv; +fp_glRasterPos4dv glRasterPos4dv; +fp_glTexCoord2iv glTexCoord2iv; +fp_glIsQuery glIsQuery; +fp_glVertexAttrib4sv glVertexAttrib4sv; +fp_glWindowPos3dv glWindowPos3dv; +fp_glTexImage2D glTexImage2D; +fp_glStencilMask glStencilMask; +fp_glDrawPixels glDrawPixels; +fp_glMultMatrixd glMultMatrixd; +fp_glMultMatrixf glMultMatrixf; +fp_glIsTexture glIsTexture; +fp_glGetMaterialiv glGetMaterialiv; +fp_glUniform1fv glUniform1fv; +fp_glLoadMatrixf glLoadMatrixf; +fp_glLoadMatrixd glLoadMatrixd; +fp_glTexParameterfv glTexParameterfv; +fp_glUniformMatrix3fv glUniformMatrix3fv; +fp_glVertex4f glVertex4f; +fp_glRectsv glRectsv; +fp_glColor4usv glColor4usv; +fp_glPolygonStipple glPolygonStipple; +fp_glInterleavedArrays glInterleavedArrays; +fp_glNormal3i glNormal3i; +fp_glNormal3f glNormal3f; +fp_glNormal3d glNormal3d; +fp_glNormal3b glNormal3b; +fp_glPixelMapusv glPixelMapusv; +fp_glGetTexGeniv glGetTexGeniv; +fp_glArrayElement glArrayElement; +fp_glCopyBufferSubData glCopyBufferSubData; +fp_glVertexAttribI1uiv glVertexAttribI1uiv; +fp_glVertexAttrib2d glVertexAttrib2d; +fp_glVertexAttrib2f glVertexAttrib2f; +fp_glVertexAttrib3dv glVertexAttrib3dv; +fp_glGetQueryObjectui64v glGetQueryObjectui64v; +fp_glDepthMask glDepthMask; +fp_glVertexAttrib2s glVertexAttrib2s; +fp_glColor3fv glColor3fv; +fp_glTexImage3DMultisample glTexImage3DMultisample; +fp_glUniformMatrix4fv glUniformMatrix4fv; +fp_glUniform4fv glUniform4fv; +fp_glGetActiveUniform glGetActiveUniform; +fp_glColorPointer glColorPointer; +fp_glFrontFace glFrontFace; +fp_glGetBooleani_v glGetBooleani_v; +fp_glClearBufferuiv glClearBufferuiv; +} diff --git a/source/glad/gl/gl.d b/source/glad/gl/gl.d new file mode 100644 index 0000000..2659e44 --- /dev/null +++ b/source/glad/gl/gl.d @@ -0,0 +1,404 @@ +module glad.gl.gl; + + +public import glad.gl.types; +public import glad.gl.funcs : +glCopyTexImage1D, glVertexAttribI3ui, glWindowPos2s, glWindowPos2i, glWindowPos2f, +glWindowPos2d, glVertex2fv, glColor4ub, glIndexi, glFramebufferRenderbuffer, +glRectdv, glCompressedTexSubImage3D, glEvalCoord2d, glEvalCoord2f, glIndexd, +glVertexAttrib1sv, glIndexf, glBindSampler, glLineWidth, glColorP3uiv, +glGetIntegeri_v, glGetMapfv, glIndexs, glCompileShader, glGetTransformFeedbackVarying, +glVertex3sv, glIndexfv, glFogiv, glStencilMaskSeparate, glRasterPos2fv, +glLightModeliv, glRectd, glSecondaryColor3fv, glMultiTexCoordP3ui, glFogfv, +glVertexP4ui, glEnablei, glVertex4iv, glEvalCoord1fv, glWindowPos2sv, +glVertexAttribP4ui, glCreateShader, glIsBuffer, glGetMultisamplefv, glGenRenderbuffers, +glCopyTexSubImage2D, glCompressedTexImage2D, glVertexAttrib1f, glBlendFuncSeparate, glVertex4fv, +glDrawBuffers, glVertexAttrib1s, glTexCoord2fv, glSampleMaski, glVertexP2ui, +glTexCoord1i, glTexCoord4fv, glUniformMatrix3x2fv, glPointSize, glVertexAttrib2dv, +glDeleteProgram, glColor4bv, glRasterPos2f, glRasterPos2d, glLoadIdentity, +glRasterPos2i, glUniformMatrix4x3fv, glColor3b, glClearBufferfv, glEdgeFlag, +glFogCoordf, glVertex3d, glVertex3f, glVertex3i, glColor3i, +glUniform3f, glVertexAttrib4ubv, glColor3s, glVertex3s, glTexCoordP2ui, +glColorMaski, glEnableClientState, glClearBufferfi, glTexCoord1iv, glMultiTexCoord1iv, +glMultiTexCoordP2ui, glGetSamplerParameterIiv, glGetFragDataIndex, glRasterPos4i, glVertex2iv, +glColor3sv, glGetVertexAttribdv, glUniformMatrix3x4fv, glNormalPointer, glTexCoordP3uiv, +glVertex4sv, glPassThrough, glMultiTexCoordP4ui, glFogi, glBegin, +glEvalCoord2dv, glColor3ubv, glVertexPointer, glScaled, glDeleteFramebuffers, +glDrawArrays, glUniform1ui, glMultiTexCoord1d, glMultiTexCoord1f, glLightfv, +glClear, glMultiTexCoord1i, glGetActiveUniformName, glMultiTexCoord1s, glStencilOp, +glTexCoord1s, glFramebufferTexture2D, glGetFramebufferAttachmentParameteriv, glTranslatef, glVertexAttrib4Nub, +glTranslated, glTexCoord3sv, glGetFragDataLocation, glTexImage1D, glTexParameteriv, +glCopyPixels, glSecondaryColor3bv, glGetMaterialfv, glGetTexImage, glFogCoordfv, +glVertexAttrib4iv, glPixelMapuiv, glColor4ubv, glGetQueryObjecti64v, glGenFramebuffers, +glIndexsv, glGetAttachedShaders, glIsRenderbuffer, glVertex3iv, glBitmap, +glMateriali, glIsVertexArray, glDisableVertexAttribArray, glGetQueryiv, glTexCoord4f, +glTexCoord4d, glGetSamplerParameterfv, glTexCoord4i, glMaterialf, glTexCoord4s, +glGetUniformIndices, glIsShader, glFeedbackBuffer, glVertexAttribI4ubv, glVertex3dv, +glPointParameteriv, glDisable, glEnable, glGetActiveUniformsiv, glColor4fv, +glTexCoord1fv, glTexCoord2sv, glVertexAttrib4dv, glMultiTexCoord1dv, glGetMapiv, +glTexCoord3fv, glSecondaryColor3usv, glMultiTexCoordP3uiv, glVertexAttribP3ui, glGetPointerv, +glPolygonOffset, glGetUniformuiv, glNormal3fv, glDepthRange, glFrustum, +glMultiTexCoord2f, glDrawBuffer, glPushMatrix, glRasterPos3fv, glOrtho, +glDrawElementsInstanced, glWindowPos3sv, glVertexAttrib4d, glClearIndex, glMap1d, +glMap1f, glFlush, glGetRenderbufferParameteriv, glIndexiv, glRasterPos3sv, +glGetVertexAttribPointerv, glPixelZoom, glDeleteBuffers, glFenceSync, glDeleteVertexArrays, +glColorP3ui, glVertexAttrib3sv, glVertexAttrib4s, glGetTexLevelParameteriv, glLighti, +glMultiTexCoordP4uiv, glLightf, glGetAttribLocation, glStencilFuncSeparate, glGenSamplers, +glClampColor, glUniform4iv, glClearStencil, glVertexAttrib2sv, glMultiTexCoord3fv, +glGetPixelMapuiv, glGenTextures, glTexCoord4iv, glGetTexParameterIuiv, glIndexPointer, +glVertexAttrib4Nbv, glGetQueryObjectiv, glIsSync, glVertex2f, glVertex2d, +glDeleteRenderbuffers, glUniform2i, glMapGrid2d, glMapGrid2f, glShaderSource, +glVertex2i, glVertexAttribPointer, glFramebufferTextureLayer, glVertex2s, glNormal3bv, +glFlushMappedBufferRange, glSecondaryColor3sv, glPointParameteri, glWindowPos2iv, glGenQueries, +glGetPixelMapfv, glTexEnvf, glVertexAttribP1ui, glTexSubImage3D, glGetInteger64i_v, +glFogCoordd, glDeleteSamplers, glCopyTexImage2D, glTexEnvi, glBlitFramebuffer, +glIsEnabledi, glSecondaryColorP3ui, glBindFragDataLocationIndexed, glMultiTexCoord2dv, glUniform2iv, +glUniform4uiv, glMatrixMode, glMultiTexCoord2s, glColor3uiv, glMultiTexCoord2i, +glFramebufferTexture1D, glGetShaderiv, glMultiTexCoord2d, glMultiTexCoord4sv, glBindFragDataLocation, +glPrioritizeTextures, glCallList, glSecondaryColor3ubv, glGetDoublev, glMultiTexCoord3iv, +glVertexAttrib1d, glLightModelf, glVertexAttrib1fv, glVertex2sv, glLightModeli, +glBindBufferRange, glWindowPos3iv, glMultiTexCoordP1uiv, glUniform3fv, glCallLists, +glMapBuffer, glSecondaryColor3d, glTexCoord3i, glMultiTexCoord4fv, glRasterPos3i, +glSecondaryColor3b, glRasterPos3d, glRasterPos3f, glCompressedTexImage3D, glTexCoord3f, +glDeleteSync, glMultiTexCoordP1ui, glGetVertexAttribiv, glSecondaryColor3s, glVertexAttrib3fv, +glTexCoord3s, glUniform3iv, glRasterPos3s, glPolygonMode, glGetActiveUniformBlockiv, +glAreTexturesResident, glIsList, glRasterPos4sv, glCopyTexSubImage3D, glColor4s, +glUseProgram, glLineStipple, glSamplerParameterIuiv, glMultiTexCoord1sv, glGetProgramInfoLog, +glMultiTexCoord2iv, glTexCoord1sv, glBindVertexArray, glColor4b, glSecondaryColor3f, +glColor4f, glColor4d, glColor4i, glMultiDrawElementsBaseVertex, glUniform4fv, +glRasterPos3iv, glVertex2dv, glTexCoord4sv, glUniform2uiv, glCompressedTexSubImage1D, +glFinish, glClipPlane, glDeleteShader, glRasterPos2s, glGetMapdv, +glVertexAttrib4Nsv, glTexGendv, glViewport, glBindBufferBase, glVertexP3uiv, +glTransformFeedbackVaryings, glIndexdv, glTexCoord3d, glTexCoord3iv, glVertexAttribI3i, +glClearDepth, glVertexAttribI4usv, glTexParameterf, glTexParameteri, glGetShaderSource, +glTexBuffer, glPixelStorei, glValidateProgram, glPixelStoref, glSecondaryColor3iv, +glRasterPos4fv, glEvalCoord1dv, glMultiTexCoordP2uiv, glRecti, glMultiDrawElements, +glRectf, glColor4ui, glNormal3sv, glGetFloatv, glColor4us, +glVertexAttribP1uiv, glLinkProgram, glTexSubImage1D, glBindTexture, glRects, +glTexCoord2dv, glRasterPos4iv, glGetString, glVertexAttribP2uiv, glEdgeFlagv, +glDetachShader, glScalef, glEndQuery, glSecondaryColor3uiv, glEdgeFlagPointer, +glVertexAttrib4Nuiv, glVertexAttribI2ui, glPopAttrib, glDeleteTextures, glStencilOpSeparate, +glDeleteQueries, glNormalP3uiv, glVertexAttrib4f, glRenderbufferStorage, glInitNames, +glColor3dv, glPixelMapfv, glGetTexParameteriv, glWaitSync, glBeginConditionalRender, +glDrawElementsBaseVertex, glSampleCoverage, glSamplerParameteri, glSamplerParameterf, glUniform1f, +glGetVertexAttribfv, glRenderMode, glGetCompressedTexImage, glWindowPos2dv, glUniform1i, +glGetActiveAttrib, glUniform3i, glPixelTransferi, glTexSubImage2D, glGetUniformiv, +glLogicOp, glEvalPoint2, glPixelTransferf, glUniform4ui, glColor3f, +glBindFramebuffer, glGetTexEnvfv, glRectfv, glCullFace, glGetLightfv, +glTexGenf, glTexGend, glTexGeni, glMultiTexCoord3s, glVertexAttribI2uiv, +glMultiTexCoord3i, glMultiTexCoord3f, glMultiTexCoord3d, glAttachShader, glFogCoorddv, +glGetTexGenfv, glQueryCounter, glFogCoordPointer, glProvokingVertex, glRasterPos4dv, +glTexGeniv, glDrawElements, glColorMaterial, glSecondaryColor3dv, glClientActiveTexture, +glVertexAttribI4sv, glTexCoord2iv, glUniform1iv, glGetBufferParameteriv, glReadBuffer, +glTexParameterIuiv, glDrawArraysInstanced, glGenerateMipmap, glWindowPos3fv, glLightModelfv, +glSamplerParameteriv, glDeleteLists, glGetClipPlane, glVertexAttrib3f, glTexCoord2d, +glVertexAttrib3d, glTexCoord2f, glRasterPos2dv, glIndexubv, glUnmapBuffer, +glTexCoord2i, glRasterPos4d, glRasterPos4f, glVertexAttrib3s, glTexCoord2s, +glBindRenderbuffer, glVertex3fv, glTexCoord4dv, glMaterialiv, glVertexAttribP4uiv, +glIsProgram, glPointParameterfv, glVertex4s, glPopMatrix, glVertexAttrib4fv, +glNormal3dv, glUniform4i, glActiveTexture, glEnableVertexAttribArray, glRotated, +glRotatef, glVertex4i, glArrayElement, glReadPixels, glVertexAttribI3iv, +glStencilMask, glUniform4f, glRenderbufferStorageMultisample, glColor3d, glGenVertexArrays, +glShadeModel, glMapGrid1d, glGetUniformfv, glMapGrid1f, glDrawPixels, +glDisableClientState, glMultiTexCoord3sv, glDrawElementsInstancedBaseVertex, glSecondaryColorPointer, glAlphaFunc, +glMultiTexCoord4iv, glTexEnvfv, glStencilFunc, glTexCoord3dv, glUniformBlockBinding, +glColor4uiv, glRectiv, glColorP4ui, glRasterPos3dv, glEvalMesh2, +glEvalMesh1, glTexCoordPointer, glLoadMatrixf, glVertexAttribI4iv, glEvalCoord2fv, +glGetShaderInfoLog, glLoadTransposeMatrixd, glLoadTransposeMatrixf, glVertexAttribI4i, glRasterPos2iv, +glGetBufferSubData, glTexEnviv, glBlendEquationSeparate, glVertexAttribI1ui, glGenBuffers, +glSelectBuffer, glTexCoordP1uiv, glPushAttrib, glVertexAttribIPointer, glBlendFunc, +glCreateProgram, glTexImage3D, glIsFramebuffer, glLightiv, glPrimitiveRestartIndex, +glTexGenfv, glTexCoord1dv, glEnd, glGetInteger64v, glScissor, +glTexCoordP4uiv, glGetBooleanv, glPushName, glMaterialfv, glIndexub, +glVertexP2uiv, glUniform3uiv, glMultTransposeMatrixf, glMultTransposeMatrixd, glClearColor, +glVertexAttrib4uiv, glPolygonStipple, glVertexAttrib4Niv, glClearBufferiv, glGetBufferParameteri64v, +glColorP4uiv, glBlendColor, glWindowPos3d, glGetStringi, glColor4iv, +glUniform3ui, glSecondaryColor3us, glVertexAttribI4uiv, glVertexAttrib4bv, glUniform2fv, +glSecondaryColor3ub, glSecondaryColor3ui, glMultiTexCoord1fv, glGetSamplerParameterIuiv, glNormal3i, +glTexCoordP3ui, glNormal3iv, glWindowPos3s, glPointParameterf, glColor3us, +glWindowPos3i, glUniformMatrix2x3fv, glWindowPos3f, glGetVertexAttribIuiv, glMultiTexCoord4s, +glVertexAttrib4Nusv, glGetLightiv, glDepthFunc, glCompressedTexSubImage2D, glListBase, +glMultiTexCoord4f, glColor3ub, glMultiTexCoord4d, glVertexAttribI4bv, glGetTexParameterfv, +glColor3ui, glMultiTexCoord4i, glGetPolygonStipple, glClientWaitSync, glVertexAttribI4ui, +glPixelMapusv, glColorMask, glTexParameterIiv, glBlendEquation, glGetUniformLocation, +glGetTexGeniv, glRasterPos4s, glEndTransformFeedback, glVertexAttrib4usv, glTexImage2DMultisample, +glColor4sv, glPopClientAttrib, glColor4dv, glBeginTransformFeedback, glFogf, +glVertexAttribI1iv, glIsSampler, glVertexP3ui, glVertexAttribDivisor, glColor3iv, +glCompressedTexImage1D, glCopyTexSubImage1D, glDrawRangeElementsBaseVertex, glCheckFramebufferStatus, glTexCoord1d, +glTexCoord1f, glEndConditionalRender, glUniform1uiv, glBindAttribLocation, glUniformMatrix4x2fv, +glMultiTexCoord2sv, glVertexAttrib1dv, glDrawRangeElements, glGetQueryObjectuiv, glSamplerParameterIiv, +glBufferSubData, glVertexAttribI2i, glGenLists, glColor3bv, glMapBufferRange, +glFramebufferTexture, glGetTexGendv, glMultiDrawArrays, glEndList, glVertexP4uiv, +glUniform2ui, glVertexAttribI2iv, glColor3usv, glWindowPos2fv, glDisablei, +glIndexMask, glPushClientAttrib, glVertex4dv, glTexCoordP4ui, glGetActiveUniformBlockName, +glVertexAttribI3uiv, glClearAccum, glGetSynciv, glTexCoordP2uiv, glUniform2f, +glBeginQuery, glUniformMatrix4fv, glBindBuffer, glMap2d, glMap2f, +glRasterPos2sv, glUniformMatrix2fv, glUniformMatrix2x4fv, glBufferData, glEvalPoint1, +glGetTexParameterIiv, glIsEnabled, glTexCoordP1ui, glGetError, glGetTexEnviv, +glGetProgramiv, glVertexAttribP2ui, glNewList, glSecondaryColor3i, glMultiTexCoord2fv, +glNormalP3ui, glEvalCoord1d, glGetTexLevelParameterfv, glEvalCoord1f, glVertexAttribI1i, +glVertex4d, glVertexAttribP3uiv, glGetPixelMapusv, glSecondaryColorP3uiv, glGetIntegerv, +glAccum, glGetBufferPointerv, glGetVertexAttribIiv, glFramebufferTexture3D, glVertexAttrib2fv, +glIsQuery, glVertexAttrib4sv, glWindowPos3dv, glTexImage2D, glLoadName, +glSamplerParameterfv, glMultMatrixd, glMultMatrixf, glIsTexture, glGetMaterialiv, +glUniform1fv, glVertexAttrib4Nubv, glLoadMatrixd, glTexParameterfv, glUniformMatrix3fv, +glVertex4f, glRectsv, glColor4usv, glNormal3s, glInterleavedArrays, +glHint, glNormal3f, glNormal3d, glNormal3b, glMultiTexCoord4dv, +glGetSamplerParameteriv, glPopName, glCopyBufferSubData, glVertexAttribI1uiv, glVertexAttrib2d, +glVertexAttrib2f, glVertexAttrib3dv, glGetQueryObjectui64v, glDepthMask, glVertexAttrib2s, +glColor3fv, glTexImage3DMultisample, glGetUniformBlockIndex, glMultiTexCoord3dv, glGetActiveUniform, +glColorPointer, glFrontFace, glGetBooleani_v, glClearBufferuiv; + +public import glad.gl.enums : +GL_INDEX_CLEAR_VALUE, GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GL_FOG_INDEX, GL_ALPHA_TEST_FUNC, +GL_SOURCE1_ALPHA, GL_NORMAL_MAP, GL_DITHER, GL_QUERY_RESULT, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, +GL_R16_SNORM, GL_FOG_COORD_ARRAY, GL_FLOAT, GL_PROXY_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, +GL_RGB16_SNORM, GL_SAMPLER_2D_RECT, GL_RGB9_E5, GL_MAX_VERTEX_UNIFORM_BLOCKS, GL_TEXTURE_COMPRESSED, +GL_T2F_C4UB_V3F, GL_EDGE_FLAG_ARRAY_POINTER, GL_PROXY_TEXTURE_3D, GL_MAX_LIST_NESTING, GL_COLOR_ATTACHMENT22, +GL_SOURCE0_ALPHA, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_BYTE, GL_TIMEOUT_IGNORED, +GL_COLOR_ARRAY, GL_ZOOM_Y, GL_ZOOM_X, GL_RENDERBUFFER_SAMPLES, GL_HINT_BIT, +GL_COLOR_CLEAR_VALUE, GL_LINEAR_MIPMAP_LINEAR, GL_DEPTH_WRITEMASK, GL_TEXTURE_GEN_MODE, GL_3D_COLOR_TEXTURE, +GL_COLOR_ARRAY_POINTER, GL_TEXTURE_DEPTH_SIZE, GL_FLOAT_MAT3x2, GL_PIXEL_MAP_G_TO_G, GL_RENDER, +GL_MAX_TEXTURE_COORDS, GL_FLOAT_MAT3x4, GL_COLOR_ATTACHMENT28, GL_TEXTURE_BINDING_2D_MULTISAMPLE, GL_COLOR_ATTACHMENT24, +GL_COLOR_ATTACHMENT25, GL_COLOR_ATTACHMENT26, GL_COLOR_ATTACHMENT27, GL_COLOR_ATTACHMENT20, GL_COLOR_ATTACHMENT21, +GL_COMPRESSED_RGBA, GL_COLOR_ATTACHMENT23, GL_CLIENT_ATTRIB_STACK_DEPTH, GL_UNSIGNED_SHORT_5_5_5_1, GL_TEXTURE_COMPONENTS, +GL_QUERY_NO_WAIT, GL_PROVOKING_VERTEX, GL_SIGNED_NORMALIZED, GL_CURRENT_RASTER_TEXTURE_COORDS, GL_EXP, +GL_LINE_STRIP_ADJACENCY, GL_POINT_SIZE, GL_TEXTURE_COMPARE_FUNC, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, GL_BITMAP_TOKEN, +GL_RGB10, GL_RGB16, GL_POLYGON_OFFSET_FILL, GL_LINE_TOKEN, GL_DOUBLEBUFFER, +GL_MAX_CLIP_PLANES, GL_FOG_COORDINATE_ARRAY_STRIDE, GL_RGB_INTEGER, GL_COMPILE_AND_EXECUTE, GL_MULT, +GL_STENCIL_CLEAR_VALUE, GL_GREEN_BITS, GL_SHADING_LANGUAGE_VERSION, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_SRC2_RGB, +GL_FRAGMENT_SHADER, GL_UNSIGNED_INT_2_10_10_10_REV, GL_INDEX_ARRAY_TYPE, GL_FRAGMENT_SHADER_DERIVATIVE_HINT, GL_TEXTURE_DEPTH, +GL_VIEWPORT, GL_DRAW_BUFFER6, GL_DRAW_BUFFER7, GL_DRAW_BUFFER4, GL_DRAW_BUFFER5, +GL_DRAW_BUFFER2, GL_DRAW_BUFFER3, GL_DRAW_BUFFER0, GL_DRAW_BUFFER1, GL_LIGHT1, +GL_LIGHT0, GL_LIGHT3, GL_LIGHT2, GL_COPY, GL_LIGHT4, +GL_BLEND_SRC, GL_LIGHT6, GL_MAP_STENCIL, GL_QUADRATIC_ATTENUATION, GL_TEXTURE_CUBE_MAP_SEAMLESS, +GL_TEXTURE_RECTANGLE, GL_FILL, GL_SRC_COLOR, GL_SAMPLER_BINDING, GL_DEPTH24_STENCIL8, +GL_SAMPLE_BUFFERS, GL_RGBA_INTEGER, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_COLOR_INDEX, GL_EXTENSIONS, +GL_MAP2_NORMAL, GL_BUFFER_SIZE, GL_PASS_THROUGH_TOKEN, GL_MAX_EVAL_ORDER, GL_UPPER_LEFT, +GL_TEXTURE_COMPARE_MODE, GL_ANY_SAMPLES_PASSED, GL_LAST_VERTEX_CONVENTION, GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GL_DEPTH_BUFFER_BIT, +GL_STENCIL_BACK_PASS_DEPTH_FAIL, GL_UNSIGNALED, GL_UNIFORM_BUFFER, GL_MAP_WRITE_BIT, GL_SHADE_MODEL, +GL_COMPRESSED_SLUMINANCE, GL_CCW, GL_RGB32I, GL_DEPTH_COMPONENT24, GL_INDEX_SHIFT, +GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_LIST_BIT, GL_ONE_MINUS_SRC1_COLOR, GL_STREAM_READ, GL_LINEAR, +GL_R32F, GL_VERTEX_ARRAY, GL_OR_REVERSE, GL_LUMINANCE12_ALPHA4, GL_LOGIC_OP, +GL_VERTEX_ARRAY_BUFFER_BINDING, GL_PIXEL_MAP_R_TO_R, GL_FOG_COORDINATE_SOURCE, GL_UNSIGNED_SHORT_5_6_5_REV, GL_TEXTURE_BORDER, +GL_GREATER, GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_MAX_TEXTURE_IMAGE_UNITS, GL_RGB32F, +GL_FLOAT_MAT2, GL_FLOAT_MAT3, GL_FRONT_FACE, GL_DEPTH, GL_REPLACE, +GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, GL_OPERAND1_RGB, GL_RGBA32UI, GL_RG8I, +GL_RGBA8I, GL_TEXTURE_FILTER_CONTROL, GL_ACCUM_CLEAR_VALUE, GL_SRC1_ALPHA, GL_RG32F, +GL_R3_G3_B2, GL_ALPHA_BIAS, GL_RENDERBUFFER_BINDING, GL_TEXTURE_STACK_DEPTH, GL_TEXTURE_LUMINANCE_SIZE, +GL_TEXTURE_MIN_LOD, GL_FOG_COORDINATE_ARRAY, GL_BLEND, GL_FEEDBACK_BUFFER_TYPE, GL_MAP1_TEXTURE_COORD_3, +GL_R16UI, GL_MAP1_TEXTURE_COORD_1, GL_UNSIGNED_SHORT, GL_MIN, GL_MAP1_TEXTURE_COORD_4, +GL_COMPRESSED_SRGB_ALPHA, GL_ONE_MINUS_SRC_COLOR, GL_TEXTURE, GL_INTENSITY12, GL_MAX_PROJECTION_STACK_DEPTH, +GL_RGB_SCALE, GL_MAX_CLIP_DISTANCES, GL_PERSPECTIVE_CORRECTION_HINT, GL_LIST_MODE, GL_TIMESTAMP, +GL_ACTIVE_UNIFORMS, GL_VERTEX_PROGRAM_POINT_SIZE, GL_MAX_COLOR_ATTACHMENTS, GL_TEXTURE_BINDING_CUBE_MAP, GL_OPERAND2_RGB, +GL_R, GL_SRGB_ALPHA, GL_S, GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_PACK_SKIP_ROWS, +GL_T, GL_MAX_TEXTURE_UNITS, GL_SLUMINANCE8, GL_MAX_TEXTURE_BUFFER_SIZE, GL_MAP1_COLOR_4, +GL_GEOMETRY_SHADER, GL_R8I, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_BLEND_COLOR, +GL_ALPHA_BITS, GL_LINE_STIPPLE, GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, GL_ONE_MINUS_CONSTANT_ALPHA, GL_NEAREST_MIPMAP_LINEAR, +GL_ALPHA8, GL_BLEND_EQUATION, GL_SRC2_ALPHA, GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER, GL_ALPHA4, +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, GL_FOG_END, GL_SAMPLER_1D, GL_LINE, GL_STENCIL_BITS, +GL_FOG_COORDINATE_ARRAY_TYPE, GL_SAMPLES_PASSED, GL_RENDERBUFFER_RED_SIZE, GL_COMPRESSED_SLUMINANCE_ALPHA, GL_BLUE_INTEGER, +GL_DYNAMIC_COPY, GL_CURRENT_FOG_COORD, GL_SYNC_FLAGS, GL_RG32I, GL_UNSIGNED_BYTE_2_3_3_REV, +GL_RENDERBUFFER_INTERNAL_FORMAT, GL_CLIENT_ACTIVE_TEXTURE, GL_TEXTURE_HEIGHT, GL_RGBA16I, GL_RGBA16F, +GL_OPERAND2_ALPHA, GL_SAMPLE_ALPHA_TO_COVERAGE, GL_FOG_DENSITY, GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, GL_CONSTANT_ATTENUATION, +GL_RED, GL_DEPTH_BIAS, GL_EQUIV, GL_POLYGON_OFFSET_LINE, GL_FUNC_REVERSE_SUBTRACT, +GL_GREEN, GL_INVALID_OPERATION, GL_CLAMP_READ_COLOR, GL_RED_INTEGER, GL_TEXTURE_BINDING_BUFFER, +GL_COLOR_ATTACHMENT5, GL_COLOR_ATTACHMENT4, GL_MAP2_TEXTURE_COORD_2, GL_COLOR_ATTACHMENT6, GL_MAP2_TEXTURE_COORD_4, +GL_COLOR_ATTACHMENT0, GL_4_BYTES, GL_COLOR_ATTACHMENT2, GL_MAX_MODELVIEW_STACK_DEPTH, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, +GL_COLOR_ATTACHMENT9, GL_COLOR_ATTACHMENT8, GL_PACK_IMAGE_HEIGHT, GL_PIXEL_MAP_B_TO_B_SIZE, GL_BUFFER_USAGE, +GL_CULL_FACE_MODE, GL_UNSIGNED_INT_8_8_8_8_REV, GL_BOOL, GL_MAX_COMBINED_UNIFORM_BLOCKS, GL_3D_COLOR, +GL_GREEN_INTEGER, GL_DST_COLOR, GL_T2F_V3F, GL_UNSIGNED_INT, GL_OPERAND0_ALPHA, +GL_ALWAYS, GL_NOOP, GL_V3F, GL_POINT_SPRITE_COORD_ORIGIN, GL_POINT_SIZE_RANGE, +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_LUMINANCE16, GL_GREEN_BIAS, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, GL_LUMINANCE12, +GL_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_SHADER_TYPE, GL_RG16_SNORM, GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, GL_COLOR_ARRAY_TYPE, +GL_QUERY_COUNTER_BITS, GL_MODULATE, GL_RG_INTEGER, GL_DRAW_BUFFER10, GL_FOG_COORD_ARRAY_BUFFER_BINDING, +GL_TEXTURE_LUMINANCE_TYPE, GL_RENDERBUFFER_HEIGHT, GL_RG16UI, GL_INTERLEAVED_ATTRIBS, GL_TEXTURE_ALPHA_TYPE, +GL_COLOR_ATTACHMENT29, GL_MAP2_TEXTURE_COORD_1, GL_DRAW_BUFFER14, GL_FOG_COORD_ARRAY_STRIDE, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, +GL_MAP2_TEXTURE_COORD_3, GL_TEXTURE_BLUE_TYPE, GL_COLOR_ATTACHMENT1, GL_C4F_N3F_V3F, GL_COMBINE_RGB, +GL_STEREO, GL_ALREADY_SIGNALED, GL_T4F_V4F, GL_STREAM_COPY, GL_LIGHT_MODEL_LOCAL_VIEWER, +GL_SOURCE0_RGB, GL_EYE_PLANE, GL_TEXTURE_CUBE_MAP, GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_2D_MULTISAMPLE_ARRAY, +GL_CLIP_PLANE1, GL_CLIP_PLANE0, GL_CLIP_PLANE3, GL_CLIP_PLANE2, GL_CLIP_PLANE5, +GL_CLIP_PLANE4, GL_ORDER, GL_NORMAL_ARRAY_TYPE, GL_TEXTURE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER, +GL_LINE_STIPPLE_REPEAT, GL_POINTS, GL_LIGHTING_BIT, GL_SYNC_STATUS, GL_RENDERBUFFER_BLUE_SIZE, +GL_UNIFORM_NAME_LENGTH, GL_FASTEST, GL_LUMINANCE8, GL_LUMINANCE4, GL_POLYGON, +GL_NAND, GL_MAP1_INDEX, GL_LINE_WIDTH_GRANULARITY, GL_ADD_SIGNED, GL_MAX_3D_TEXTURE_SIZE, +GL_CLIENT_PIXEL_STORE_BIT, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_DONT_CARE, +GL_POLYGON_BIT, GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING, GL_QUERY_WAIT, GL_MAP_FLUSH_EXPLICIT_BIT, GL_TEXTURE_COORD_ARRAY_SIZE, +GL_RED_SCALE, GL_SRGB8, GL_CURRENT_NORMAL, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_FRAGMENT_DEPTH, +GL_UNIFORM_BLOCK_BINDING, GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, GL_SRC0_ALPHA, GL_LEQUAL, GL_PIXEL_MAP_A_TO_A_SIZE, +GL_TEXTURE_WIDTH, GL_ONE_MINUS_SRC1_ALPHA, GL_MAP_COLOR, GL_UNIFORM_SIZE, GL_POINT_SPRITE, +GL_FLOAT_MAT4x2, GL_SHADER_SOURCE_LENGTH, GL_DOT3_RGBA, GL_COMPRESSED_RG, GL_UNPACK_SWAP_BYTES, +GL_CURRENT_VERTEX_ATTRIB, GL_POLYGON_OFFSET_UNITS, GL_LUMINANCE6_ALPHA2, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_COLOR_ATTACHMENT7, +GL_PRIMARY_COLOR, GL_C3F_V3F, GL_OUT_OF_MEMORY, GL_AUX_BUFFERS, GL_NORMAL_ARRAY_STRIDE, +GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_SMOOTH, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, GL_GEOMETRY_OUTPUT_TYPE, GL_RASTERIZER_DISCARD, +GL_MAX_TEXTURE_LOD_BIAS, GL_CURRENT_TEXTURE_COORDS, GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, GL_FRONT_RIGHT, +GL_EDGE_FLAG_ARRAY, GL_INT_SAMPLER_2D_MULTISAMPLE, GL_RETURN, GL_STENCIL_TEST, GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION, +GL_R11F_G11F_B10F, GL_LUMINANCE_ALPHA, GL_PIXEL_UNPACK_BUFFER_BINDING, GL_INVERT, GL_PROXY_TEXTURE_1D, +GL_COMPRESSED_INTENSITY, GL_TRANSFORM_FEEDBACK_VARYINGS, GL_DEPTH_COMPONENT32F, GL_TRIANGLE_FAN, GL_LIST_BASE, +GL_MAX_ELEMENTS_VERTICES, GL_CURRENT_COLOR, GL_INVALID_FRAMEBUFFER_OPERATION, GL_RGB12, GL_UNIFORM_BUFFER_SIZE, +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING, GL_DEPTH32F_STENCIL8, GL_MAX_ARRAY_TEXTURE_LAYERS, GL_RED_BITS, GL_MAX_SERVER_WAIT_TIMEOUT, +GL_NOR, GL_FLAT, GL_PACK_ALIGNMENT, GL_PIXEL_MAP_S_TO_S, GL_UNPACK_LSB_FIRST, +GL_BGRA, GL_ACTIVE_UNIFORM_BLOCKS, GL_SOURCE1_RGB, GL_UNPACK_SKIP_IMAGES, GL_RGB16I, +GL_ACTIVE_TEXTURE, GL_TEXTURE_BASE_LEVEL, GL_RGB16F, GL_SMOOTH_LINE_WIDTH_RANGE, GL_ALPHA_INTEGER, +GL_GREEN_SCALE, GL_CLIP_DISTANCE7, GL_FOG_BIT, GL_TRANSPOSE_TEXTURE_MATRIX, GL_UNSIGNED_INT_SAMPLER_3D, +GL_SAMPLE_MASK, GL_INT_VEC4, GL_INT_VEC3, GL_INT_VEC2, GL_STENCIL_FAIL, +GL_CURRENT_FOG_COORDINATE, GL_CONDITION_SATISFIED, GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT, GL_FRAMEBUFFER_UNSUPPORTED, GL_RED_BIAS, +GL_DST_ALPHA, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_R8, GL_RENDER_MODE, GL_EDGE_FLAG_ARRAY_BUFFER_BINDING, +GL_MAX_CUBE_MAP_TEXTURE_SIZE, GL_TEXTURE_1D_ARRAY, GL_RENDERBUFFER_WIDTH, GL_READ_FRAMEBUFFER_BINDING, GL_FRAMEBUFFER_ATTACHMENT_LAYERED, +GL_TEXTURE_BLUE_SIZE, GL_COORD_REPLACE, GL_RGBA2, GL_RGBA4, GL_MULTISAMPLE_BIT, +GL_FOG_COLOR, GL_DRAW_BUFFER11, GL_DRAW_BUFFER12, GL_DRAW_BUFFER13, GL_UNSIGNED_INT_10_10_10_2, +GL_DRAW_BUFFER15, GL_INFO_LOG_LENGTH, GL_R16F, GL_RENDERBUFFER_STENCIL_SIZE, GL_CONSTANT_ALPHA, +GL_RESCALE_NORMAL, GL_R16I, GL_POINT_SIZE_GRANULARITY, GL_STATIC_READ, GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, +GL_COMPARE_R_TO_TEXTURE, GL_PREVIOUS, GL_MAP_READ_BIT, GL_SPOT_DIRECTION, GL_DEPTH_SCALE, +GL_STENCIL, GL_SAMPLE_MASK_VALUE, GL_LINE_BIT, GL_DIFFUSE, GL_MAX_RENDERBUFFER_SIZE, +GL_T2F_N3F_V3F, GL_TRANSFORM_BIT, GL_COLOR_ATTACHMENT30, GL_STENCIL_PASS_DEPTH_PASS, GL_INCR_WRAP, +GL_SOURCE2_RGB, GL_TEXTURE_GEN_T, GL_TEXTURE_GEN_S, GL_TEXTURE_GEN_R, GL_TEXTURE_GEN_Q, +GL_RENDERBUFFER_ALPHA_SIZE, GL_ALPHA12, GL_LIGHT_MODEL_TWO_SIDE, GL_ALPHA16, GL_DECR_WRAP, +GL_POLYGON_SMOOTH, GL_COMPILE, GL_SAMPLE_POSITION, GL_TRANSPOSE_MODELVIEW_MATRIX, GL_INCR, +GL_POINT_SIZE_MIN, GL_MAX_RECTANGLE_TEXTURE_SIZE, GL_RGBA12, GL_GENERATE_MIPMAP_HINT, GL_ALPHA_TEST_REF, +GL_RGBA16, GL_UNPACK_SKIP_ROWS, GL_MAP1_NORMAL, GL_SOURCE2_ALPHA, GL_DEPTH_CLAMP, +GL_POLYGON_STIPPLE_BIT, GL_BLEND_DST_ALPHA, GL_INT_SAMPLER_CUBE, GL_CURRENT_QUERY, GL_RGB5_A1, +GL_EXP2, GL_UNPACK_SKIP_PIXELS, GL_RGB16UI, GL_COPY_INVERTED, GL_TEXTURE_PRIORITY, +GL_MAX_GEOMETRY_INPUT_COMPONENTS, GL_LOWER_LEFT, GL_FOG_HINT, GL_TEXTURE_BINDING_1D, GL_PROJECTION_MATRIX, +GL_AUX0, GL_PIXEL_UNPACK_BUFFER, GL_LINEAR_MIPMAP_NEAREST, GL_POINT_DISTANCE_ATTENUATION, GL_TEXTURE_BUFFER_DATA_STORE_BINDING, +GL_RGB10_A2, GL_AMBIENT_AND_DIFFUSE, GL_ZERO, GL_ELEMENT_ARRAY_BUFFER, GL_CONTEXT_CORE_PROFILE_BIT, +GL_SCISSOR_BIT, GL_READ_ONLY, GL_MAX_FRAGMENT_INPUT_COMPONENTS, GL_MAP1_GRID_DOMAIN, GL_PIXEL_MAP_I_TO_A_SIZE, +GL_UNSIGNED_NORMALIZED, GL_SMOOTH_POINT_SIZE_GRANULARITY, GL_CLAMP_VERTEX_COLOR, GL_MAP2_INDEX, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, +GL_PIXEL_MAP_I_TO_R_SIZE, GL_NOTEQUAL, GL_TEXTURE_COORD_ARRAY, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GL_MAP2_GRID_DOMAIN, +GL_COMPRESSED_RED, GL_INT_SAMPLER_1D_ARRAY, GL_DRAW_PIXEL_TOKEN, GL_MAX_LIGHTS, GL_RGBA16_SNORM, +GL_OBJECT_LINEAR, GL_LIST_INDEX, GL_TEXTURE_BORDER_COLOR, GL_LUMINANCE16_ALPHA16, GL_TEXTURE_SHARED_SIZE, +GL_COMPILE_STATUS, GL_LOGIC_OP_MODE, GL_LUMINANCE8_ALPHA8, GL_RENDERBUFFER_DEPTH_SIZE, GL_MAX_FRAGMENT_UNIFORM_BLOCKS, +GL_SLUMINANCE_ALPHA, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, GL_FEEDBACK_BUFFER_POINTER, GL_SPOT_EXPONENT, GL_SHORT, +GL_BLUE, GL_CW, GL_UNSIGNED_INT_24_8, GL_UNSIGNED_BYTE, GL_MAX_VERTEX_UNIFORM_COMPONENTS, +GL_QUADS, GL_DEPTH_TEXTURE_MODE, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_R16, GL_PIXEL_PACK_BUFFER, +GL_PACK_LSB_FIRST, GL_RENDERBUFFER, GL_UNSIGNED_BYTE_3_3_2, GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GL_RGB8I, +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, GL_DRAW_BUFFER, GL_STENCIL_INDEX1, GL_STENCIL_INDEX4, GL_SAMPLER_3D, +GL_TEXTURE_GREEN_TYPE, GL_STENCIL_INDEX8, GL_DEPTH_BITS, GL_OR_INVERTED, GL_RGB8UI, +GL_STENCIL_INDEX16, GL_STENCIL_BACK_REF, GL_SELECT, GL_INTENSITY4, GL_BLEND_DST_RGB, +GL_INTENSITY8, GL_LIGHT5, GL_LINE_RESET_TOKEN, GL_MAP1_VERTEX_3, GL_TEXTURE_BINDING_2D_ARRAY, +GL_VERTEX_ATTRIB_ARRAY_DIVISOR, GL_CLEAR, GL_DRAW_BUFFER8, GL_CURRENT_RASTER_POSITION_VALID, GL_FOG_COORD_SRC, +GL_DRAW_BUFFER9, GL_SRC0_RGB, GL_PIXEL_PACK_BUFFER_BINDING, GL_DECAL, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, +GL_2D, GL_SELECTION_BUFFER_POINTER, GL_SELECTION_BUFFER_SIZE, GL_SAMPLES, GL_UNSIGNED_INT_VEC2, +GL_UNSIGNED_INT_VEC3, GL_UNSIGNED_INT_VEC4, GL_UNSIGNED_SHORT_5_6_5, GL_CURRENT_RASTER_POSITION, GL_VERTEX_ATTRIB_ARRAY_SIZE, +GL_VERTEX_SHADER, GL_RGBA_MODE, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4, +GL_COEFF, GL_RGB32UI, GL_BUFFER_MAP_OFFSET, GL_MIN_PROGRAM_TEXEL_OFFSET, GL_PROXY_TEXTURE_RECTANGLE, +GL_UNSIGNED_INT_SAMPLER_BUFFER, GL_UNIFORM_BUFFER_START, GL_MAX_TEXTURE_STACK_DEPTH, GL_UNSIGNED_INT_SAMPLER_2D, GL_TEXTURE8, +GL_INT_SAMPLER_2D_RECT, GL_TEXTURE_COORD_ARRAY_STRIDE, GL_TEXTURE4, GL_TEXTURE5, GL_TEXTURE6, +GL_TEXTURE7, GL_TEXTURE0, GL_CONTEXT_PROFILE_MASK, GL_TEXTURE2, GL_TEXTURE3, +GL_BOOL_VEC4, GL_DOUBLE, GL_RG8_SNORM, GL_BOOL_VEC3, GL_BOOL_VEC2, +GL_COLOR_MATERIAL_PARAMETER, GL_DOT3_RGB, GL_ONE, GL_SRC_ALPHA_SATURATE, GL_MAX_SAMPLES, +GL_UNPACK_IMAGE_HEIGHT, GL_TRIANGLE_STRIP, GL_N3F_V3F, GL_CONTEXT_FLAGS, GL_FRONT_LEFT, +GL_CLAMP, GL_POINT_SMOOTH_HINT, GL_INDEX_OFFSET, GL_INTENSITY, GL_POINT_SIZE_MAX, +GL_MODELVIEW_MATRIX, GL_VERTEX_ARRAY_BINDING, GL_INDEX_BITS, GL_TIMEOUT_EXPIRED, GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, +GL_STENCIL_FUNC, GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING, GL_TEXTURE_ENV, GL_ALIASED_LINE_WIDTH_RANGE, GL_DECR, +GL_BACK, GL_VIEWPORT_BIT, GL_INT, GL_CLIP_DISTANCE1, GL_CLIP_DISTANCE0, +GL_CLIP_DISTANCE3, GL_CLIP_DISTANCE2, GL_CLIP_DISTANCE5, GL_CLIP_DISTANCE4, GL_MINOR_VERSION, +GL_PIXEL_MAP_G_TO_G_SIZE, GL_FRONT_AND_BACK, GL_POINT, GL_COMPRESSED_RG_RGTC2, GL_POLYGON_TOKEN, +GL_SMOOTH_LINE_WIDTH_GRANULARITY, GL_SRGB, GL_NORMAL_ARRAY_POINTER, GL_SYNC_FENCE, GL_ONE_MINUS_CONSTANT_COLOR, +GL_UNSIGNED_INT_8_8_8_8, GL_RGB8_SNORM, GL_TEXTURE_ALPHA_SIZE, GL_UNSIGNED_INT_SAMPLER_2D_RECT, GL_CONSTANT_COLOR, +GL_UNSIGNED_SHORT_4_4_4_4, GL_NO_ERROR, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GL_BLEND_SRC_ALPHA, GL_CURRENT_SECONDARY_COLOR, +GL_RGBA16UI, GL_AND_REVERSE, GL_MAX_INTEGER_SAMPLES, GL_CLAMP_FRAGMENT_COLOR, GL_QUERY_RESULT_AVAILABLE, +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, GL_MAX_DRAW_BUFFERS, GL_ONE_MINUS_DST_ALPHA, GL_FOG_MODE, GL_R32UI, +GL_RGBA8_SNORM, GL_C4UB_V2F, GL_INT_SAMPLER_3D, GL_CURRENT_INDEX, GL_AND, +GL_INDEX_MODE, GL_ACCUM_GREEN_BITS, GL_MAJOR_VERSION, GL_STATIC_COPY, GL_REFLECTION_MAP, +GL_BGR_INTEGER, GL_3_BYTES, GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_TYPE, GL_DELETE_STATUS, +GL_POINT_BIT, GL_SYNC_GPU_COMMANDS_COMPLETE, GL_SMOOTH_POINT_SIZE_RANGE, GL_ALIASED_POINT_SIZE_RANGE, GL_3D, +GL_MAP_INVALIDATE_BUFFER_BIT, GL_UNSIGNED_INT_5_9_9_9_REV, GL_DEPTH_TEST, GL_BUFFER_MAP_LENGTH, GL_VERTEX_ATTRIB_ARRAY_POINTER, +GL_MULTISAMPLE, GL_MAX_GEOMETRY_OUTPUT_VERTICES, GL_TEXTURE_RED_TYPE, GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_FUNC_SUBTRACT, +GL_VERTEX_PROGRAM_TWO_SIDE, GL_SAMPLER_BUFFER, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, GL_TEXTURE_COORD_ARRAY_TYPE, GL_CLAMP_TO_BORDER, +GL_COLOR_ATTACHMENT15, GL_COLOR_ATTACHMENT14, GL_COLOR_ATTACHMENT17, GL_DEPTH_RANGE, GL_COLOR_ATTACHMENT11, +GL_COLOR_ATTACHMENT10, GL_COLOR_ATTACHMENT13, GL_COLOR_ATTACHMENT12, GL_NEAREST, GL_COMPRESSED_TEXTURE_FORMATS, +GL_COLOR_ATTACHMENT19, GL_COLOR_ATTACHMENT18, GL_RENDERBUFFER_GREEN_SIZE, GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, GL_PIXEL_MAP_S_TO_S_SIZE, +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, GL_RGBA8, GL_T2F_C3F_V3F, GL_SAMPLER_2D_RECT_SHADOW, GL_ALL_ATTRIB_BITS, +GL_POINT_TOKEN, GL_T4F_C4F_N3F_V4F, GL_TEXTURE30, GL_TEXTURE31, GL_UNSIGNED_INT_SAMPLER_1D, +GL_POINT_SMOOTH, GL_DEPTH_CLEAR_VALUE, GL_GEOMETRY_INPUT_TYPE, GL_BACK_LEFT, GL_TEXTURE_ENV_COLOR, +GL_BUFFER_MAP_POINTER, GL_LINE_SMOOTH, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, GL_STENCIL_REF, GL_CURRENT_BIT, +GL_FOG_COORDINATE, GL_COPY_WRITE_BUFFER, GL_MAX_VARYING_FLOATS, GL_PRIMITIVE_RESTART_INDEX, GL_OPERAND0_RGB, +GL_LIGHT_MODEL_COLOR_CONTROL, GL_FEEDBACK, GL_ONE_MINUS_DST_COLOR, GL_MAX_ATTRIB_STACK_DEPTH, GL_FOG_COORD_ARRAY_TYPE, +GL_PROXY_TEXTURE_1D_ARRAY, GL_ACCUM_ALPHA_BITS, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, +GL_COLOR_BUFFER_BIT, GL_PIXEL_MAP_I_TO_I, GL_SPOT_CUTOFF, GL_PIXEL_MAP_I_TO_R, GL_LINEAR_ATTENUATION, +GL_SAMPLER_2D, GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, GL_NEAREST_MIPMAP_NEAREST, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER, GL_EDGE_FLAG_ARRAY_STRIDE, +GL_TEXTURE_MAG_FILTER, GL_COLOR_MATERIAL_FACE, GL_CONTEXT_COMPATIBILITY_PROFILE_BIT, GL_SINGLE_COLOR, GL_R32I, +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, GL_SAMPLER_CUBE, GL_INT_2_10_10_10_REV, GL_SAMPLER_CUBE_SHADOW, GL_LEFT, +GL_AND_INVERTED, GL_ACCUM_BLUE_BITS, GL_FRAMEBUFFER_SRGB, GL_SECONDARY_COLOR_ARRAY_TYPE, GL_POLYGON_OFFSET_POINT, +GL_BGR, GL_MAX_TEXTURE_SIZE, GL_COMBINE_ALPHA, GL_RIGHT, GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, +GL_ARRAY_BUFFER, GL_COMPRESSED_ALPHA, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT16, GL_MAX_SAMPLE_MASK_WORDS, +GL_TEXTURE_COMPRESSED_IMAGE_SIZE, GL_TEXTURE_RED_SIZE, GL_TEXTURE_1D, GL_MAX_VARYING_COMPONENTS, GL_NAME_STACK_DEPTH, +GL_BLEND_SRC_RGB, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, GL_BGRA_INTEGER, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, GL_FALSE, +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, GL_ONE_MINUS_SRC_ALPHA, GL_SAMPLE_ALPHA_TO_ONE, GL_WEIGHT_ARRAY_BUFFER_BINDING, GL_COLOR_ATTACHMENT3, +GL_PIXEL_MAP_I_TO_G_SIZE, GL_MAP2_GRID_SEGMENTS, GL_PROGRAM_POINT_SIZE, GL_COLOR_ATTACHMENT16, GL_MAX_VIEWPORT_DIMS, +GL_DEPTH_ATTACHMENT, GL_INT_SAMPLER_2D, GL_UNSIGNED_INT_SAMPLER_1D_ARRAY, GL_STENCIL_PASS_DEPTH_FAIL, GL_PIXEL_MAP_A_TO_A, +GL_TEXTURE_COORD_ARRAY_POINTER, GL_MAP1_GRID_SEGMENTS, GL_MAX_GEOMETRY_UNIFORM_BLOCKS, GL_ATTRIB_STACK_DEPTH, GL_LINE_WIDTH, +GL_FEEDBACK_BUFFER_SIZE, GL_BLUE_BIAS, GL_FIXED_ONLY, GL_NONE, GL_FRAMEBUFFER_DEFAULT, +GL_POLYGON_MODE, GL_HALF_FLOAT, GL_UNIFORM_BLOCK_NAME_LENGTH, GL_V2F, GL_TEXTURE_BINDING_RECTANGLE, +GL_LINE_SMOOTH_HINT, GL_CLAMP_TO_EDGE, GL_FRONT, GL_SCISSOR_BOX, GL_UNIFORM_BLOCK_DATA_SIZE, +GL_AMBIENT, GL_NUM_EXTENSIONS, GL_UNIFORM_IS_ROW_MAJOR, GL_MAX_UNIFORM_BLOCK_SIZE, GL_INDEX_ARRAY, +GL_FRAMEBUFFER_BINDING, GL_NORMAL_ARRAY_BUFFER_BINDING, GL_ALPHA, GL_SET, GL_COLOR_WRITEMASK, +GL_DEPTH_FUNC, GL_TEXTURE_WRAP_R, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE9, +GL_INVALID_ENUM, GL_EVAL_BIT, GL_INT_SAMPLER_2D_ARRAY, GL_COMPRESSED_RGB, GL_LIGHT_MODEL_AMBIENT, +GL_DEPTH_COMPONENT, GL_SRC1_COLOR, GL_FOG_START, GL_WAIT_FAILED, GL_COMPARE_REF_TO_TEXTURE, +GL_PROJECTION_STACK_DEPTH, GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, GL_TRUE, GL_TEXTURE_MIN_FILTER, GL_FLOAT_MAT4, +GL_BLUE_BITS, GL_STACK_UNDERFLOW, GL_AUX1, GL_TEXTURE_SWIZZLE_R, GL_AUX3, +GL_AUX2, GL_PACK_SWAP_BYTES, GL_FIRST_VERTEX_CONVENTION, GL_EQUAL, GL_TEXTURE_SWIZZLE_G, +GL_DEPTH_STENCIL_ATTACHMENT, GL_TRIANGLE_STRIP_ADJACENCY, GL_ADD, GL_TEXTURE_BINDING_1D_ARRAY, GL_TEXTURE_SWIZZLE_B, +GL_TEXTURE_SWIZZLE_A, GL_FUNC_ADD, GL_MODELVIEW_STACK_DEPTH, GL_FLOAT_MAT4x3, GL_POINT_FADE_THRESHOLD_SIZE, +GL_INT_SAMPLER_BUFFER, GL_UNPACK_ALIGNMENT, GL_LINE_STRIP, GL_PACK_ROW_LENGTH, GL_COLOR_MATERIAL, +GL_MAX_PIXEL_MAP_TABLE, GL_COLOR, GL_POLYGON_STIPPLE, GL_BITMAP, GL_DYNAMIC_READ, +GL_COMPRESSED_LUMINANCE, GL_LUMINANCE12_ALPHA12, GL_DEPTH_STENCIL, GL_RG8UI, GL_MAX_VERTEX_OUTPUT_COMPONENTS, +GL_KEEP, GL_TEXTURE_INTENSITY_SIZE, GL_PROXY_TEXTURE_2D, GL_SYNC_CONDITION, GL_ACTIVE_UNIFORM_MAX_LENGTH, +GL_OR, GL_MAP_INVALIDATE_RANGE_BIT, GL_TEXTURE23, GL_TEXTURE22, GL_TEXTURE21, +GL_TEXTURE20, GL_TEXTURE27, GL_TEXTURE26, GL_TEXTURE25, GL_TEXTURE24, +GL_R8_SNORM, GL_TEXTURE29, GL_TEXTURE28, GL_SAMPLER_1D_ARRAY, GL_ELEMENT_ARRAY_BUFFER_BINDING, +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER, GL_TRIANGLES_ADJACENCY, GL_PIXEL_MODE_BIT, GL_LINE_LOOP, GL_ALPHA_SCALE, +GL_READ_BUFFER, GL_PACK_SKIP_PIXELS, GL_BACK_RIGHT, GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, GL_SUBPIXEL_BITS, +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, GL_GEQUAL, GL_ALPHA_TEST, GL_SLUMINANCE8_ALPHA8, GL_SAMPLER_2D_MULTISAMPLE, +GL_LUMINANCE4_ALPHA4, GL_RGBA8UI, GL_UNIFORM_OFFSET, GL_TEXTURE1, GL_OBJECT_PLANE, +GL_UNSIGNED_INT_SAMPLER_CUBE, GL_SUBTRACT, GL_TIME_ELAPSED, GL_SECONDARY_COLOR_ARRAY_SIZE, GL_COMPRESSED_RED_RGTC1, +GL_READ_WRITE, GL_BUFFER_ACCESS, GL_LINES_ADJACENCY, GL_ARRAY_BUFFER_BINDING, GL_INDEX_WRITEMASK, +GL_TEXTURE_2D, GL_VERTEX_ARRAY_STRIDE, GL_DYNAMIC_DRAW, GL_4D_COLOR_TEXTURE, GL_NICEST, +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, GL_UNPACK_ROW_LENGTH, GL_CURRENT_PROGRAM, GL_BUFFER_MAPPED, GL_EYE_LINEAR, +GL_STREAM_DRAW, GL_POLYGON_SMOOTH_HINT, GL_INDEX, GL_MAX_UNIFORM_BUFFER_BINDINGS, GL_SIGNALED, +GL_FRAMEBUFFER, GL_SPECULAR, GL_TEXTURE_BINDING_2D, GL_GENERATE_MIPMAP, GL_DOMAIN, +GL_COLOR_ARRAY_SIZE, GL_STENCIL_BACK_FAIL, GL_POLYGON_OFFSET_FACTOR, GL_R8UI, GL_SYNC_FLUSH_COMMANDS_BIT, +GL_DRAW_FRAMEBUFFER_BINDING, GL_STATIC_DRAW, GL_MODELVIEW, GL_PIXEL_MAP_I_TO_B_SIZE, GL_TRIANGLES, +GL_SAMPLER_2D_ARRAY_SHADOW, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_UNIFORM_MATRIX_STRIDE, GL_MAX_DEPTH_TEXTURE_SAMPLES, GL_QUERY_BY_REGION_WAIT, +GL_TEXTURE_RESIDENT, GL_SLUMINANCE, GL_SRGB8_ALPHA8, GL_FOG, GL_FOG_COORD, +GL_SAMPLER_2D_ARRAY, GL_POSITION, GL_RENDERER, GL_MIRRORED_REPEAT, GL_RG, +GL_PIXEL_MAP_B_TO_B, GL_LINE_STIPPLE_PATTERN, GL_STENCIL_BACK_FUNC, GL_PIXEL_MAP_R_TO_R_SIZE, GL_MAP1_TEXTURE_COORD_2, +GL_TEXTURE_BINDING_3D, GL_COLOR_LOGIC_OP, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, GL_UNIFORM_BLOCK_INDEX, GL_ENABLE_BIT, +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, GL_MAX_VERTEX_ATTRIBS, GL_SPHERE_MAP, GL_CONSTANT, GL_LINE_WIDTH_RANGE, +GL_XOR, GL_PROJECTION, GL_LESS, GL_COPY_PIXEL_TOKEN, GL_FRAMEBUFFER_UNDEFINED, +GL_2_BYTES, GL_TEXTURE_STENCIL_SIZE, GL_CURRENT_RASTER_INDEX, GL_EMISSION, GL_COMPRESSED_SRGB, +GL_TEXTURE_DEPTH_TYPE, GL_TEXTURE_ENV_MODE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_INT_SAMPLER_1D, GL_CURRENT_RASTER_COLOR, +GL_PROXY_TEXTURE_2D_ARRAY, GL_QUAD_STRIP, GL_REPEAT, GL_ACCUM, GL_T2F_C4F_N3F_V3F, +GL_TEXTURE_INTENSITY_TYPE, GL_INTENSITY16, GL_VERTEX_ARRAY_TYPE, GL_VERTEX_ARRAY_SIZE, GL_TEXTURE_GREEN_SIZE, +GL_CLIENT_ALL_ATTRIB_BITS, GL_VALIDATE_STATUS, GL_RG16, GL_LIGHT7, GL_STENCIL_BACK_VALUE_MASK, +GL_SCISSOR_TEST, GL_STENCIL_BUFFER_BIT, GL_TEXTURE_2D_MULTISAMPLE, GL_SAMPLER_1D_ARRAY_SHADOW, GL_SRC1_RGB, +GL_BLEND_EQUATION_ALPHA, GL_ACTIVE_ATTRIBUTES, GL_COLOR_ATTACHMENT31, GL_LIGHTING, GL_CURRENT_RASTER_DISTANCE, +GL_VERTEX_ARRAY_POINTER, GL_ATTACHED_SHADERS, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_QUERY_BY_REGION_NO_WAIT, GL_SAMPLE_COVERAGE_INVERT, +GL_LINES, GL_TEXTURE18, GL_TEXTURE19, GL_TEXTURE16, GL_TEXTURE17, +GL_TEXTURE14, GL_TEXTURE15, GL_TEXTURE12, GL_TEXTURE13, GL_TEXTURE10, +GL_TEXTURE11, GL_RGB, GL_SEPARATE_SPECULAR_COLOR, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_TRANSFORM_FEEDBACK_BUFFER_START, +GL_MAX_PROGRAM_TEXEL_OFFSET, GL_STACK_OVERFLOW, GL_MAP1_VERTEX_4, GL_TEXTURE_COMPRESSION_HINT, GL_RGBA32F, +GL_RGBA32I, GL_COLOR_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_TRANSPOSE_COLOR_MATRIX, GL_STENCIL_WRITEMASK, +GL_RG8, GL_FOG_COORDINATE_ARRAY_POINTER, GL_STENCIL_BACK_PASS_DEPTH_PASS, GL_INVALID_VALUE, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, +GL_VERSION, GL_MAP_UNSYNCHRONIZED_BIT, GL_PRIMITIVE_RESTART, GL_COLOR_ARRAY_STRIDE, GL_MAX_ELEMENTS_INDICES, +GL_SRC_ALPHA, GL_TEXTURE_3D, GL_GEOMETRY_VERTICES_OUT, GL_RGB8, GL_INDEX_ARRAY_POINTER, +GL_MATRIX_MODE, GL_UNIFORM_ARRAY_STRIDE, GL_TEXTURE_SAMPLES, GL_RGB4, GL_RGB5, +GL_CULL_FACE, GL_PIXEL_MAP_I_TO_I_SIZE, GL_SAMPLE_COVERAGE_VALUE, GL_PROXY_TEXTURE_CUBE_MAP, GL_SECONDARY_COLOR_ARRAY_STRIDE, +GL_COMPRESSED_SIGNED_RG_RGTC2, GL_COLOR_INDEXES, GL_RG32UI, GL_OPERAND1_ALPHA, GL_NORMALIZE, +GL_NEVER, GL_STENCIL_VALUE_MASK, GL_BLEND_DST, GL_STENCIL_BACK_WRITEMASK, GL_BLUE_SCALE, +GL_TEXTURE_INTERNAL_FORMAT, GL_LOAD, GL_FRAMEBUFFER_COMPLETE, GL_COPY_READ_BUFFER, GL_INDEX_ARRAY_STRIDE, +GL_FOG_COORD_ARRAY_POINTER, GL_MAP2_VERTEX_3, GL_TEXTURE_SWIZZLE_RGBA, GL_DEPTH_COMPONENT32, GL_RGBA, +GL_READ_FRAMEBUFFER, GL_NORMAL_ARRAY, GL_COLOR_SUM, GL_BLEND_EQUATION_RGB, GL_MAP2_COLOR_4, +GL_VENDOR, GL_TEXTURE_2D_ARRAY, GL_ACCUM_BUFFER_BIT, GL_EDGE_FLAG, GL_OBJECT_TYPE, +GL_C4UB_V3F, GL_INTERPOLATE, GL_BUFFER_ACCESS_FLAGS, GL_LINK_STATUS, GL_PACK_SKIP_IMAGES, +GL_FLOAT_MAT2x3, GL_COMBINE, GL_FLOAT_MAT2x4, GL_Q, GL_SECONDARY_COLOR_ARRAY, +GL_INDEX_LOGIC_OP, GL_SEPARATE_ATTRIBS, GL_PRIMITIVES_GENERATED, GL_MAX, GL_LUMINANCE, +GL_INVALID_INDEX, GL_MAP2_VERTEX_4, GL_AUTO_NORMAL, GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, GL_CURRENT_RASTER_SECONDARY_COLOR, +GL_SAMPLER_1D_SHADOW, GL_ACCUM_RED_BITS, GL_SAMPLER_2D_SHADOW, GL_TEXTURE_MATRIX, GL_TRANSPOSE_PROJECTION_MATRIX, +GL_CLIP_DISTANCE6, GL_RG16F, GL_MAX_NAME_STACK_DEPTH, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, GL_TEXTURE_BIT, +GL_RG16I, GL_WRITE_ONLY, GL_STENCIL_ATTACHMENT, GL_CLIENT_VERTEX_ARRAY_BIT, GL_SAMPLE_COVERAGE, +GL_INDEX_ARRAY_BUFFER_BINDING, GL_SHININESS, GL_DRAW_FRAMEBUFFER, GL_TEXTURE_LOD_BIAS, GL_RGB10_A2UI +; + diff --git a/source/glad/gl/loader.d b/source/glad/gl/loader.d new file mode 100644 index 0000000..91fef93 --- /dev/null +++ b/source/glad/gl/loader.d @@ -0,0 +1,1010 @@ +module glad.gl.loader; + + +private import glad.gl.funcs; +private import glad.gl.ext; +private import glad.gl.enums; +private import glad.gl.types; +alias Loader = void* delegate(const(char)*); + +version(Windows) { + private import core.sys.windows.windows; +} else { + private import core.sys.posix.dlfcn; +} + +version(Windows) { + private __gshared HMODULE libGL; +} else { + private __gshared void* libGL; +} +extern(System) private @nogc alias gladGetProcAddressPtrType = void* function(const(char)*); +private __gshared gladGetProcAddressPtrType gladGetProcAddressPtr; + +private +bool open_gl() @nogc { + version(Windows) { + libGL = LoadLibraryA("opengl32.dll"); + if(libGL !is null) { + gladGetProcAddressPtr = cast(typeof(gladGetProcAddressPtr))GetProcAddress( + libGL, "wglGetProcAddress"); + return gladGetProcAddressPtr !is null; + } + + return false; + } else { + version(OSX) { + enum const(char)*[] NAMES = [ + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + ]; + } else { + enum const(char)*[] NAMES = ["libGL.so.1", "libGL.so"]; + } + + foreach(name; NAMES) { + libGL = dlopen(name, RTLD_NOW | RTLD_GLOBAL); + if(libGL !is null) { + version(OSX) { + return true; + } else { + gladGetProcAddressPtr = cast(typeof(gladGetProcAddressPtr))dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr !is null; + } + } + } + + return false; + } +} + +private +void* get_proc(const(char)* namez) @nogc { + if(libGL is null) return null; + void* result; + + if(gladGetProcAddressPtr !is null) { + result = gladGetProcAddressPtr(namez); + } + if(result is null) { + version(Windows) { + result = GetProcAddress(libGL, namez); + } else { + result = dlsym(libGL, namez); + } + } + + return result; +} + +private +void close_gl() @nogc { + version(Windows) { + if(libGL !is null) { + FreeLibrary(libGL); + libGL = null; + } + } else { + if(libGL !is null) { + dlclose(libGL); + libGL = null; + } + } +} + +bool gladLoadGL() { + bool status = false; + + if(open_gl()) { + status = gladLoadGL(x => get_proc(x)); + close_gl(); + } + + return status; +} + +static struct GLVersion { static int major = 0; static int minor = 0; } +private extern(C) char* strstr(const(char)*, const(char)*) @nogc; +private extern(C) int strcmp(const(char)*, const(char)*) @nogc; +private extern(C) int strncmp(const(char)*, const(char)*, size_t) @nogc; +private extern(C) size_t strlen(const(char)*) @nogc; +private bool has_ext(const(char)* ext) @nogc { + if(GLVersion.major < 3) { + const(char)* extensions = cast(const(char)*)glGetString(GL_EXTENSIONS); + const(char)* loc; + const(char)* terminator; + + if(extensions is null || ext is null) { + return false; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc is null) { + return false; + } + + terminator = loc + strlen(ext); + if((loc is extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return true; + } + extensions = terminator; + } + } else { + int num; + glGetIntegerv(GL_NUM_EXTENSIONS, &num); + + for(uint i=0; i < cast(uint)num; i++) { + if(strcmp(cast(const(char)*)glGetStringi(GL_EXTENSIONS, i), ext) == 0) { + return true; + } + } + } + + return false; +} +bool gladLoadGL(Loader load) { + glGetString = cast(typeof(glGetString))load("glGetString"); + if(glGetString is null) { return false; } + if(glGetString(GL_VERSION) is null) { return false; } + + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + find_extensionsGL(); + return GLVersion.major != 0 || GLVersion.minor != 0; +} + +private { + +void find_coreGL() { + + // Thank you @elmindreda + // https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + // https://github.com/glfw/glfw/blob/master/src/context.c#L36 + int i; + const(char)* glversion; + const(char)*[] prefixes = [ + "OpenGL ES-CM ".ptr, + "OpenGL ES-CL ".ptr, + "OpenGL ES ".ptr, + ]; + + glversion = cast(const(char)*)glGetString(GL_VERSION); + if (glversion is null) return; + + foreach(prefix; prefixes) { + size_t length = strlen(prefix); + if (strncmp(glversion, prefix, length) == 0) { + glversion += length; + break; + } + } + + int major = glversion[0] - '0'; + int minor = glversion[2] - '0'; + GLVersion.major = major; GLVersion.minor = minor; + GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + return; +} + +void find_extensionsGL() { + return; +} + +void load_GL_VERSION_1_0(Loader load) { + if(!GL_VERSION_1_0) return; + glCullFace = cast(typeof(glCullFace))load("glCullFace"); + glFrontFace = cast(typeof(glFrontFace))load("glFrontFace"); + glHint = cast(typeof(glHint))load("glHint"); + glLineWidth = cast(typeof(glLineWidth))load("glLineWidth"); + glPointSize = cast(typeof(glPointSize))load("glPointSize"); + glPolygonMode = cast(typeof(glPolygonMode))load("glPolygonMode"); + glScissor = cast(typeof(glScissor))load("glScissor"); + glTexParameterf = cast(typeof(glTexParameterf))load("glTexParameterf"); + glTexParameterfv = cast(typeof(glTexParameterfv))load("glTexParameterfv"); + glTexParameteri = cast(typeof(glTexParameteri))load("glTexParameteri"); + glTexParameteriv = cast(typeof(glTexParameteriv))load("glTexParameteriv"); + glTexImage1D = cast(typeof(glTexImage1D))load("glTexImage1D"); + glTexImage2D = cast(typeof(glTexImage2D))load("glTexImage2D"); + glDrawBuffer = cast(typeof(glDrawBuffer))load("glDrawBuffer"); + glClear = cast(typeof(glClear))load("glClear"); + glClearColor = cast(typeof(glClearColor))load("glClearColor"); + glClearStencil = cast(typeof(glClearStencil))load("glClearStencil"); + glClearDepth = cast(typeof(glClearDepth))load("glClearDepth"); + glStencilMask = cast(typeof(glStencilMask))load("glStencilMask"); + glColorMask = cast(typeof(glColorMask))load("glColorMask"); + glDepthMask = cast(typeof(glDepthMask))load("glDepthMask"); + glDisable = cast(typeof(glDisable))load("glDisable"); + glEnable = cast(typeof(glEnable))load("glEnable"); + glFinish = cast(typeof(glFinish))load("glFinish"); + glFlush = cast(typeof(glFlush))load("glFlush"); + glBlendFunc = cast(typeof(glBlendFunc))load("glBlendFunc"); + glLogicOp = cast(typeof(glLogicOp))load("glLogicOp"); + glStencilFunc = cast(typeof(glStencilFunc))load("glStencilFunc"); + glStencilOp = cast(typeof(glStencilOp))load("glStencilOp"); + glDepthFunc = cast(typeof(glDepthFunc))load("glDepthFunc"); + glPixelStoref = cast(typeof(glPixelStoref))load("glPixelStoref"); + glPixelStorei = cast(typeof(glPixelStorei))load("glPixelStorei"); + glReadBuffer = cast(typeof(glReadBuffer))load("glReadBuffer"); + glReadPixels = cast(typeof(glReadPixels))load("glReadPixels"); + glGetBooleanv = cast(typeof(glGetBooleanv))load("glGetBooleanv"); + glGetDoublev = cast(typeof(glGetDoublev))load("glGetDoublev"); + glGetError = cast(typeof(glGetError))load("glGetError"); + glGetFloatv = cast(typeof(glGetFloatv))load("glGetFloatv"); + glGetIntegerv = cast(typeof(glGetIntegerv))load("glGetIntegerv"); + glGetString = cast(typeof(glGetString))load("glGetString"); + glGetTexImage = cast(typeof(glGetTexImage))load("glGetTexImage"); + glGetTexParameterfv = cast(typeof(glGetTexParameterfv))load("glGetTexParameterfv"); + glGetTexParameteriv = cast(typeof(glGetTexParameteriv))load("glGetTexParameteriv"); + glGetTexLevelParameterfv = cast(typeof(glGetTexLevelParameterfv))load("glGetTexLevelParameterfv"); + glGetTexLevelParameteriv = cast(typeof(glGetTexLevelParameteriv))load("glGetTexLevelParameteriv"); + glIsEnabled = cast(typeof(glIsEnabled))load("glIsEnabled"); + glDepthRange = cast(typeof(glDepthRange))load("glDepthRange"); + glViewport = cast(typeof(glViewport))load("glViewport"); + glNewList = cast(typeof(glNewList))load("glNewList"); + glEndList = cast(typeof(glEndList))load("glEndList"); + glCallList = cast(typeof(glCallList))load("glCallList"); + glCallLists = cast(typeof(glCallLists))load("glCallLists"); + glDeleteLists = cast(typeof(glDeleteLists))load("glDeleteLists"); + glGenLists = cast(typeof(glGenLists))load("glGenLists"); + glListBase = cast(typeof(glListBase))load("glListBase"); + glBegin = cast(typeof(glBegin))load("glBegin"); + glBitmap = cast(typeof(glBitmap))load("glBitmap"); + glColor3b = cast(typeof(glColor3b))load("glColor3b"); + glColor3bv = cast(typeof(glColor3bv))load("glColor3bv"); + glColor3d = cast(typeof(glColor3d))load("glColor3d"); + glColor3dv = cast(typeof(glColor3dv))load("glColor3dv"); + glColor3f = cast(typeof(glColor3f))load("glColor3f"); + glColor3fv = cast(typeof(glColor3fv))load("glColor3fv"); + glColor3i = cast(typeof(glColor3i))load("glColor3i"); + glColor3iv = cast(typeof(glColor3iv))load("glColor3iv"); + glColor3s = cast(typeof(glColor3s))load("glColor3s"); + glColor3sv = cast(typeof(glColor3sv))load("glColor3sv"); + glColor3ub = cast(typeof(glColor3ub))load("glColor3ub"); + glColor3ubv = cast(typeof(glColor3ubv))load("glColor3ubv"); + glColor3ui = cast(typeof(glColor3ui))load("glColor3ui"); + glColor3uiv = cast(typeof(glColor3uiv))load("glColor3uiv"); + glColor3us = cast(typeof(glColor3us))load("glColor3us"); + glColor3usv = cast(typeof(glColor3usv))load("glColor3usv"); + glColor4b = cast(typeof(glColor4b))load("glColor4b"); + glColor4bv = cast(typeof(glColor4bv))load("glColor4bv"); + glColor4d = cast(typeof(glColor4d))load("glColor4d"); + glColor4dv = cast(typeof(glColor4dv))load("glColor4dv"); + glColor4f = cast(typeof(glColor4f))load("glColor4f"); + glColor4fv = cast(typeof(glColor4fv))load("glColor4fv"); + glColor4i = cast(typeof(glColor4i))load("glColor4i"); + glColor4iv = cast(typeof(glColor4iv))load("glColor4iv"); + glColor4s = cast(typeof(glColor4s))load("glColor4s"); + glColor4sv = cast(typeof(glColor4sv))load("glColor4sv"); + glColor4ub = cast(typeof(glColor4ub))load("glColor4ub"); + glColor4ubv = cast(typeof(glColor4ubv))load("glColor4ubv"); + glColor4ui = cast(typeof(glColor4ui))load("glColor4ui"); + glColor4uiv = cast(typeof(glColor4uiv))load("glColor4uiv"); + glColor4us = cast(typeof(glColor4us))load("glColor4us"); + glColor4usv = cast(typeof(glColor4usv))load("glColor4usv"); + glEdgeFlag = cast(typeof(glEdgeFlag))load("glEdgeFlag"); + glEdgeFlagv = cast(typeof(glEdgeFlagv))load("glEdgeFlagv"); + glEnd = cast(typeof(glEnd))load("glEnd"); + glIndexd = cast(typeof(glIndexd))load("glIndexd"); + glIndexdv = cast(typeof(glIndexdv))load("glIndexdv"); + glIndexf = cast(typeof(glIndexf))load("glIndexf"); + glIndexfv = cast(typeof(glIndexfv))load("glIndexfv"); + glIndexi = cast(typeof(glIndexi))load("glIndexi"); + glIndexiv = cast(typeof(glIndexiv))load("glIndexiv"); + glIndexs = cast(typeof(glIndexs))load("glIndexs"); + glIndexsv = cast(typeof(glIndexsv))load("glIndexsv"); + glNormal3b = cast(typeof(glNormal3b))load("glNormal3b"); + glNormal3bv = cast(typeof(glNormal3bv))load("glNormal3bv"); + glNormal3d = cast(typeof(glNormal3d))load("glNormal3d"); + glNormal3dv = cast(typeof(glNormal3dv))load("glNormal3dv"); + glNormal3f = cast(typeof(glNormal3f))load("glNormal3f"); + glNormal3fv = cast(typeof(glNormal3fv))load("glNormal3fv"); + glNormal3i = cast(typeof(glNormal3i))load("glNormal3i"); + glNormal3iv = cast(typeof(glNormal3iv))load("glNormal3iv"); + glNormal3s = cast(typeof(glNormal3s))load("glNormal3s"); + glNormal3sv = cast(typeof(glNormal3sv))load("glNormal3sv"); + glRasterPos2d = cast(typeof(glRasterPos2d))load("glRasterPos2d"); + glRasterPos2dv = cast(typeof(glRasterPos2dv))load("glRasterPos2dv"); + glRasterPos2f = cast(typeof(glRasterPos2f))load("glRasterPos2f"); + glRasterPos2fv = cast(typeof(glRasterPos2fv))load("glRasterPos2fv"); + glRasterPos2i = cast(typeof(glRasterPos2i))load("glRasterPos2i"); + glRasterPos2iv = cast(typeof(glRasterPos2iv))load("glRasterPos2iv"); + glRasterPos2s = cast(typeof(glRasterPos2s))load("glRasterPos2s"); + glRasterPos2sv = cast(typeof(glRasterPos2sv))load("glRasterPos2sv"); + glRasterPos3d = cast(typeof(glRasterPos3d))load("glRasterPos3d"); + glRasterPos3dv = cast(typeof(glRasterPos3dv))load("glRasterPos3dv"); + glRasterPos3f = cast(typeof(glRasterPos3f))load("glRasterPos3f"); + glRasterPos3fv = cast(typeof(glRasterPos3fv))load("glRasterPos3fv"); + glRasterPos3i = cast(typeof(glRasterPos3i))load("glRasterPos3i"); + glRasterPos3iv = cast(typeof(glRasterPos3iv))load("glRasterPos3iv"); + glRasterPos3s = cast(typeof(glRasterPos3s))load("glRasterPos3s"); + glRasterPos3sv = cast(typeof(glRasterPos3sv))load("glRasterPos3sv"); + glRasterPos4d = cast(typeof(glRasterPos4d))load("glRasterPos4d"); + glRasterPos4dv = cast(typeof(glRasterPos4dv))load("glRasterPos4dv"); + glRasterPos4f = cast(typeof(glRasterPos4f))load("glRasterPos4f"); + glRasterPos4fv = cast(typeof(glRasterPos4fv))load("glRasterPos4fv"); + glRasterPos4i = cast(typeof(glRasterPos4i))load("glRasterPos4i"); + glRasterPos4iv = cast(typeof(glRasterPos4iv))load("glRasterPos4iv"); + glRasterPos4s = cast(typeof(glRasterPos4s))load("glRasterPos4s"); + glRasterPos4sv = cast(typeof(glRasterPos4sv))load("glRasterPos4sv"); + glRectd = cast(typeof(glRectd))load("glRectd"); + glRectdv = cast(typeof(glRectdv))load("glRectdv"); + glRectf = cast(typeof(glRectf))load("glRectf"); + glRectfv = cast(typeof(glRectfv))load("glRectfv"); + glRecti = cast(typeof(glRecti))load("glRecti"); + glRectiv = cast(typeof(glRectiv))load("glRectiv"); + glRects = cast(typeof(glRects))load("glRects"); + glRectsv = cast(typeof(glRectsv))load("glRectsv"); + glTexCoord1d = cast(typeof(glTexCoord1d))load("glTexCoord1d"); + glTexCoord1dv = cast(typeof(glTexCoord1dv))load("glTexCoord1dv"); + glTexCoord1f = cast(typeof(glTexCoord1f))load("glTexCoord1f"); + glTexCoord1fv = cast(typeof(glTexCoord1fv))load("glTexCoord1fv"); + glTexCoord1i = cast(typeof(glTexCoord1i))load("glTexCoord1i"); + glTexCoord1iv = cast(typeof(glTexCoord1iv))load("glTexCoord1iv"); + glTexCoord1s = cast(typeof(glTexCoord1s))load("glTexCoord1s"); + glTexCoord1sv = cast(typeof(glTexCoord1sv))load("glTexCoord1sv"); + glTexCoord2d = cast(typeof(glTexCoord2d))load("glTexCoord2d"); + glTexCoord2dv = cast(typeof(glTexCoord2dv))load("glTexCoord2dv"); + glTexCoord2f = cast(typeof(glTexCoord2f))load("glTexCoord2f"); + glTexCoord2fv = cast(typeof(glTexCoord2fv))load("glTexCoord2fv"); + glTexCoord2i = cast(typeof(glTexCoord2i))load("glTexCoord2i"); + glTexCoord2iv = cast(typeof(glTexCoord2iv))load("glTexCoord2iv"); + glTexCoord2s = cast(typeof(glTexCoord2s))load("glTexCoord2s"); + glTexCoord2sv = cast(typeof(glTexCoord2sv))load("glTexCoord2sv"); + glTexCoord3d = cast(typeof(glTexCoord3d))load("glTexCoord3d"); + glTexCoord3dv = cast(typeof(glTexCoord3dv))load("glTexCoord3dv"); + glTexCoord3f = cast(typeof(glTexCoord3f))load("glTexCoord3f"); + glTexCoord3fv = cast(typeof(glTexCoord3fv))load("glTexCoord3fv"); + glTexCoord3i = cast(typeof(glTexCoord3i))load("glTexCoord3i"); + glTexCoord3iv = cast(typeof(glTexCoord3iv))load("glTexCoord3iv"); + glTexCoord3s = cast(typeof(glTexCoord3s))load("glTexCoord3s"); + glTexCoord3sv = cast(typeof(glTexCoord3sv))load("glTexCoord3sv"); + glTexCoord4d = cast(typeof(glTexCoord4d))load("glTexCoord4d"); + glTexCoord4dv = cast(typeof(glTexCoord4dv))load("glTexCoord4dv"); + glTexCoord4f = cast(typeof(glTexCoord4f))load("glTexCoord4f"); + glTexCoord4fv = cast(typeof(glTexCoord4fv))load("glTexCoord4fv"); + glTexCoord4i = cast(typeof(glTexCoord4i))load("glTexCoord4i"); + glTexCoord4iv = cast(typeof(glTexCoord4iv))load("glTexCoord4iv"); + glTexCoord4s = cast(typeof(glTexCoord4s))load("glTexCoord4s"); + glTexCoord4sv = cast(typeof(glTexCoord4sv))load("glTexCoord4sv"); + glVertex2d = cast(typeof(glVertex2d))load("glVertex2d"); + glVertex2dv = cast(typeof(glVertex2dv))load("glVertex2dv"); + glVertex2f = cast(typeof(glVertex2f))load("glVertex2f"); + glVertex2fv = cast(typeof(glVertex2fv))load("glVertex2fv"); + glVertex2i = cast(typeof(glVertex2i))load("glVertex2i"); + glVertex2iv = cast(typeof(glVertex2iv))load("glVertex2iv"); + glVertex2s = cast(typeof(glVertex2s))load("glVertex2s"); + glVertex2sv = cast(typeof(glVertex2sv))load("glVertex2sv"); + glVertex3d = cast(typeof(glVertex3d))load("glVertex3d"); + glVertex3dv = cast(typeof(glVertex3dv))load("glVertex3dv"); + glVertex3f = cast(typeof(glVertex3f))load("glVertex3f"); + glVertex3fv = cast(typeof(glVertex3fv))load("glVertex3fv"); + glVertex3i = cast(typeof(glVertex3i))load("glVertex3i"); + glVertex3iv = cast(typeof(glVertex3iv))load("glVertex3iv"); + glVertex3s = cast(typeof(glVertex3s))load("glVertex3s"); + glVertex3sv = cast(typeof(glVertex3sv))load("glVertex3sv"); + glVertex4d = cast(typeof(glVertex4d))load("glVertex4d"); + glVertex4dv = cast(typeof(glVertex4dv))load("glVertex4dv"); + glVertex4f = cast(typeof(glVertex4f))load("glVertex4f"); + glVertex4fv = cast(typeof(glVertex4fv))load("glVertex4fv"); + glVertex4i = cast(typeof(glVertex4i))load("glVertex4i"); + glVertex4iv = cast(typeof(glVertex4iv))load("glVertex4iv"); + glVertex4s = cast(typeof(glVertex4s))load("glVertex4s"); + glVertex4sv = cast(typeof(glVertex4sv))load("glVertex4sv"); + glClipPlane = cast(typeof(glClipPlane))load("glClipPlane"); + glColorMaterial = cast(typeof(glColorMaterial))load("glColorMaterial"); + glFogf = cast(typeof(glFogf))load("glFogf"); + glFogfv = cast(typeof(glFogfv))load("glFogfv"); + glFogi = cast(typeof(glFogi))load("glFogi"); + glFogiv = cast(typeof(glFogiv))load("glFogiv"); + glLightf = cast(typeof(glLightf))load("glLightf"); + glLightfv = cast(typeof(glLightfv))load("glLightfv"); + glLighti = cast(typeof(glLighti))load("glLighti"); + glLightiv = cast(typeof(glLightiv))load("glLightiv"); + glLightModelf = cast(typeof(glLightModelf))load("glLightModelf"); + glLightModelfv = cast(typeof(glLightModelfv))load("glLightModelfv"); + glLightModeli = cast(typeof(glLightModeli))load("glLightModeli"); + glLightModeliv = cast(typeof(glLightModeliv))load("glLightModeliv"); + glLineStipple = cast(typeof(glLineStipple))load("glLineStipple"); + glMaterialf = cast(typeof(glMaterialf))load("glMaterialf"); + glMaterialfv = cast(typeof(glMaterialfv))load("glMaterialfv"); + glMateriali = cast(typeof(glMateriali))load("glMateriali"); + glMaterialiv = cast(typeof(glMaterialiv))load("glMaterialiv"); + glPolygonStipple = cast(typeof(glPolygonStipple))load("glPolygonStipple"); + glShadeModel = cast(typeof(glShadeModel))load("glShadeModel"); + glTexEnvf = cast(typeof(glTexEnvf))load("glTexEnvf"); + glTexEnvfv = cast(typeof(glTexEnvfv))load("glTexEnvfv"); + glTexEnvi = cast(typeof(glTexEnvi))load("glTexEnvi"); + glTexEnviv = cast(typeof(glTexEnviv))load("glTexEnviv"); + glTexGend = cast(typeof(glTexGend))load("glTexGend"); + glTexGendv = cast(typeof(glTexGendv))load("glTexGendv"); + glTexGenf = cast(typeof(glTexGenf))load("glTexGenf"); + glTexGenfv = cast(typeof(glTexGenfv))load("glTexGenfv"); + glTexGeni = cast(typeof(glTexGeni))load("glTexGeni"); + glTexGeniv = cast(typeof(glTexGeniv))load("glTexGeniv"); + glFeedbackBuffer = cast(typeof(glFeedbackBuffer))load("glFeedbackBuffer"); + glSelectBuffer = cast(typeof(glSelectBuffer))load("glSelectBuffer"); + glRenderMode = cast(typeof(glRenderMode))load("glRenderMode"); + glInitNames = cast(typeof(glInitNames))load("glInitNames"); + glLoadName = cast(typeof(glLoadName))load("glLoadName"); + glPassThrough = cast(typeof(glPassThrough))load("glPassThrough"); + glPopName = cast(typeof(glPopName))load("glPopName"); + glPushName = cast(typeof(glPushName))load("glPushName"); + glClearAccum = cast(typeof(glClearAccum))load("glClearAccum"); + glClearIndex = cast(typeof(glClearIndex))load("glClearIndex"); + glIndexMask = cast(typeof(glIndexMask))load("glIndexMask"); + glAccum = cast(typeof(glAccum))load("glAccum"); + glPopAttrib = cast(typeof(glPopAttrib))load("glPopAttrib"); + glPushAttrib = cast(typeof(glPushAttrib))load("glPushAttrib"); + glMap1d = cast(typeof(glMap1d))load("glMap1d"); + glMap1f = cast(typeof(glMap1f))load("glMap1f"); + glMap2d = cast(typeof(glMap2d))load("glMap2d"); + glMap2f = cast(typeof(glMap2f))load("glMap2f"); + glMapGrid1d = cast(typeof(glMapGrid1d))load("glMapGrid1d"); + glMapGrid1f = cast(typeof(glMapGrid1f))load("glMapGrid1f"); + glMapGrid2d = cast(typeof(glMapGrid2d))load("glMapGrid2d"); + glMapGrid2f = cast(typeof(glMapGrid2f))load("glMapGrid2f"); + glEvalCoord1d = cast(typeof(glEvalCoord1d))load("glEvalCoord1d"); + glEvalCoord1dv = cast(typeof(glEvalCoord1dv))load("glEvalCoord1dv"); + glEvalCoord1f = cast(typeof(glEvalCoord1f))load("glEvalCoord1f"); + glEvalCoord1fv = cast(typeof(glEvalCoord1fv))load("glEvalCoord1fv"); + glEvalCoord2d = cast(typeof(glEvalCoord2d))load("glEvalCoord2d"); + glEvalCoord2dv = cast(typeof(glEvalCoord2dv))load("glEvalCoord2dv"); + glEvalCoord2f = cast(typeof(glEvalCoord2f))load("glEvalCoord2f"); + glEvalCoord2fv = cast(typeof(glEvalCoord2fv))load("glEvalCoord2fv"); + glEvalMesh1 = cast(typeof(glEvalMesh1))load("glEvalMesh1"); + glEvalPoint1 = cast(typeof(glEvalPoint1))load("glEvalPoint1"); + glEvalMesh2 = cast(typeof(glEvalMesh2))load("glEvalMesh2"); + glEvalPoint2 = cast(typeof(glEvalPoint2))load("glEvalPoint2"); + glAlphaFunc = cast(typeof(glAlphaFunc))load("glAlphaFunc"); + glPixelZoom = cast(typeof(glPixelZoom))load("glPixelZoom"); + glPixelTransferf = cast(typeof(glPixelTransferf))load("glPixelTransferf"); + glPixelTransferi = cast(typeof(glPixelTransferi))load("glPixelTransferi"); + glPixelMapfv = cast(typeof(glPixelMapfv))load("glPixelMapfv"); + glPixelMapuiv = cast(typeof(glPixelMapuiv))load("glPixelMapuiv"); + glPixelMapusv = cast(typeof(glPixelMapusv))load("glPixelMapusv"); + glCopyPixels = cast(typeof(glCopyPixels))load("glCopyPixels"); + glDrawPixels = cast(typeof(glDrawPixels))load("glDrawPixels"); + glGetClipPlane = cast(typeof(glGetClipPlane))load("glGetClipPlane"); + glGetLightfv = cast(typeof(glGetLightfv))load("glGetLightfv"); + glGetLightiv = cast(typeof(glGetLightiv))load("glGetLightiv"); + glGetMapdv = cast(typeof(glGetMapdv))load("glGetMapdv"); + glGetMapfv = cast(typeof(glGetMapfv))load("glGetMapfv"); + glGetMapiv = cast(typeof(glGetMapiv))load("glGetMapiv"); + glGetMaterialfv = cast(typeof(glGetMaterialfv))load("glGetMaterialfv"); + glGetMaterialiv = cast(typeof(glGetMaterialiv))load("glGetMaterialiv"); + glGetPixelMapfv = cast(typeof(glGetPixelMapfv))load("glGetPixelMapfv"); + glGetPixelMapuiv = cast(typeof(glGetPixelMapuiv))load("glGetPixelMapuiv"); + glGetPixelMapusv = cast(typeof(glGetPixelMapusv))load("glGetPixelMapusv"); + glGetPolygonStipple = cast(typeof(glGetPolygonStipple))load("glGetPolygonStipple"); + glGetTexEnvfv = cast(typeof(glGetTexEnvfv))load("glGetTexEnvfv"); + glGetTexEnviv = cast(typeof(glGetTexEnviv))load("glGetTexEnviv"); + glGetTexGendv = cast(typeof(glGetTexGendv))load("glGetTexGendv"); + glGetTexGenfv = cast(typeof(glGetTexGenfv))load("glGetTexGenfv"); + glGetTexGeniv = cast(typeof(glGetTexGeniv))load("glGetTexGeniv"); + glIsList = cast(typeof(glIsList))load("glIsList"); + glFrustum = cast(typeof(glFrustum))load("glFrustum"); + glLoadIdentity = cast(typeof(glLoadIdentity))load("glLoadIdentity"); + glLoadMatrixf = cast(typeof(glLoadMatrixf))load("glLoadMatrixf"); + glLoadMatrixd = cast(typeof(glLoadMatrixd))load("glLoadMatrixd"); + glMatrixMode = cast(typeof(glMatrixMode))load("glMatrixMode"); + glMultMatrixf = cast(typeof(glMultMatrixf))load("glMultMatrixf"); + glMultMatrixd = cast(typeof(glMultMatrixd))load("glMultMatrixd"); + glOrtho = cast(typeof(glOrtho))load("glOrtho"); + glPopMatrix = cast(typeof(glPopMatrix))load("glPopMatrix"); + glPushMatrix = cast(typeof(glPushMatrix))load("glPushMatrix"); + glRotated = cast(typeof(glRotated))load("glRotated"); + glRotatef = cast(typeof(glRotatef))load("glRotatef"); + glScaled = cast(typeof(glScaled))load("glScaled"); + glScalef = cast(typeof(glScalef))load("glScalef"); + glTranslated = cast(typeof(glTranslated))load("glTranslated"); + glTranslatef = cast(typeof(glTranslatef))load("glTranslatef"); + return; +} + +void load_GL_VERSION_1_1(Loader load) { + if(!GL_VERSION_1_1) return; + glDrawArrays = cast(typeof(glDrawArrays))load("glDrawArrays"); + glDrawElements = cast(typeof(glDrawElements))load("glDrawElements"); + glGetPointerv = cast(typeof(glGetPointerv))load("glGetPointerv"); + glPolygonOffset = cast(typeof(glPolygonOffset))load("glPolygonOffset"); + glCopyTexImage1D = cast(typeof(glCopyTexImage1D))load("glCopyTexImage1D"); + glCopyTexImage2D = cast(typeof(glCopyTexImage2D))load("glCopyTexImage2D"); + glCopyTexSubImage1D = cast(typeof(glCopyTexSubImage1D))load("glCopyTexSubImage1D"); + glCopyTexSubImage2D = cast(typeof(glCopyTexSubImage2D))load("glCopyTexSubImage2D"); + glTexSubImage1D = cast(typeof(glTexSubImage1D))load("glTexSubImage1D"); + glTexSubImage2D = cast(typeof(glTexSubImage2D))load("glTexSubImage2D"); + glBindTexture = cast(typeof(glBindTexture))load("glBindTexture"); + glDeleteTextures = cast(typeof(glDeleteTextures))load("glDeleteTextures"); + glGenTextures = cast(typeof(glGenTextures))load("glGenTextures"); + glIsTexture = cast(typeof(glIsTexture))load("glIsTexture"); + glArrayElement = cast(typeof(glArrayElement))load("glArrayElement"); + glColorPointer = cast(typeof(glColorPointer))load("glColorPointer"); + glDisableClientState = cast(typeof(glDisableClientState))load("glDisableClientState"); + glEdgeFlagPointer = cast(typeof(glEdgeFlagPointer))load("glEdgeFlagPointer"); + glEnableClientState = cast(typeof(glEnableClientState))load("glEnableClientState"); + glIndexPointer = cast(typeof(glIndexPointer))load("glIndexPointer"); + glInterleavedArrays = cast(typeof(glInterleavedArrays))load("glInterleavedArrays"); + glNormalPointer = cast(typeof(glNormalPointer))load("glNormalPointer"); + glTexCoordPointer = cast(typeof(glTexCoordPointer))load("glTexCoordPointer"); + glVertexPointer = cast(typeof(glVertexPointer))load("glVertexPointer"); + glAreTexturesResident = cast(typeof(glAreTexturesResident))load("glAreTexturesResident"); + glPrioritizeTextures = cast(typeof(glPrioritizeTextures))load("glPrioritizeTextures"); + glIndexub = cast(typeof(glIndexub))load("glIndexub"); + glIndexubv = cast(typeof(glIndexubv))load("glIndexubv"); + glPopClientAttrib = cast(typeof(glPopClientAttrib))load("glPopClientAttrib"); + glPushClientAttrib = cast(typeof(glPushClientAttrib))load("glPushClientAttrib"); + return; +} + +void load_GL_VERSION_1_2(Loader load) { + if(!GL_VERSION_1_2) return; + glDrawRangeElements = cast(typeof(glDrawRangeElements))load("glDrawRangeElements"); + glTexImage3D = cast(typeof(glTexImage3D))load("glTexImage3D"); + glTexSubImage3D = cast(typeof(glTexSubImage3D))load("glTexSubImage3D"); + glCopyTexSubImage3D = cast(typeof(glCopyTexSubImage3D))load("glCopyTexSubImage3D"); + return; +} + +void load_GL_VERSION_1_3(Loader load) { + if(!GL_VERSION_1_3) return; + glActiveTexture = cast(typeof(glActiveTexture))load("glActiveTexture"); + glSampleCoverage = cast(typeof(glSampleCoverage))load("glSampleCoverage"); + glCompressedTexImage3D = cast(typeof(glCompressedTexImage3D))load("glCompressedTexImage3D"); + glCompressedTexImage2D = cast(typeof(glCompressedTexImage2D))load("glCompressedTexImage2D"); + glCompressedTexImage1D = cast(typeof(glCompressedTexImage1D))load("glCompressedTexImage1D"); + glCompressedTexSubImage3D = cast(typeof(glCompressedTexSubImage3D))load("glCompressedTexSubImage3D"); + glCompressedTexSubImage2D = cast(typeof(glCompressedTexSubImage2D))load("glCompressedTexSubImage2D"); + glCompressedTexSubImage1D = cast(typeof(glCompressedTexSubImage1D))load("glCompressedTexSubImage1D"); + glGetCompressedTexImage = cast(typeof(glGetCompressedTexImage))load("glGetCompressedTexImage"); + glClientActiveTexture = cast(typeof(glClientActiveTexture))load("glClientActiveTexture"); + glMultiTexCoord1d = cast(typeof(glMultiTexCoord1d))load("glMultiTexCoord1d"); + glMultiTexCoord1dv = cast(typeof(glMultiTexCoord1dv))load("glMultiTexCoord1dv"); + glMultiTexCoord1f = cast(typeof(glMultiTexCoord1f))load("glMultiTexCoord1f"); + glMultiTexCoord1fv = cast(typeof(glMultiTexCoord1fv))load("glMultiTexCoord1fv"); + glMultiTexCoord1i = cast(typeof(glMultiTexCoord1i))load("glMultiTexCoord1i"); + glMultiTexCoord1iv = cast(typeof(glMultiTexCoord1iv))load("glMultiTexCoord1iv"); + glMultiTexCoord1s = cast(typeof(glMultiTexCoord1s))load("glMultiTexCoord1s"); + glMultiTexCoord1sv = cast(typeof(glMultiTexCoord1sv))load("glMultiTexCoord1sv"); + glMultiTexCoord2d = cast(typeof(glMultiTexCoord2d))load("glMultiTexCoord2d"); + glMultiTexCoord2dv = cast(typeof(glMultiTexCoord2dv))load("glMultiTexCoord2dv"); + glMultiTexCoord2f = cast(typeof(glMultiTexCoord2f))load("glMultiTexCoord2f"); + glMultiTexCoord2fv = cast(typeof(glMultiTexCoord2fv))load("glMultiTexCoord2fv"); + glMultiTexCoord2i = cast(typeof(glMultiTexCoord2i))load("glMultiTexCoord2i"); + glMultiTexCoord2iv = cast(typeof(glMultiTexCoord2iv))load("glMultiTexCoord2iv"); + glMultiTexCoord2s = cast(typeof(glMultiTexCoord2s))load("glMultiTexCoord2s"); + glMultiTexCoord2sv = cast(typeof(glMultiTexCoord2sv))load("glMultiTexCoord2sv"); + glMultiTexCoord3d = cast(typeof(glMultiTexCoord3d))load("glMultiTexCoord3d"); + glMultiTexCoord3dv = cast(typeof(glMultiTexCoord3dv))load("glMultiTexCoord3dv"); + glMultiTexCoord3f = cast(typeof(glMultiTexCoord3f))load("glMultiTexCoord3f"); + glMultiTexCoord3fv = cast(typeof(glMultiTexCoord3fv))load("glMultiTexCoord3fv"); + glMultiTexCoord3i = cast(typeof(glMultiTexCoord3i))load("glMultiTexCoord3i"); + glMultiTexCoord3iv = cast(typeof(glMultiTexCoord3iv))load("glMultiTexCoord3iv"); + glMultiTexCoord3s = cast(typeof(glMultiTexCoord3s))load("glMultiTexCoord3s"); + glMultiTexCoord3sv = cast(typeof(glMultiTexCoord3sv))load("glMultiTexCoord3sv"); + glMultiTexCoord4d = cast(typeof(glMultiTexCoord4d))load("glMultiTexCoord4d"); + glMultiTexCoord4dv = cast(typeof(glMultiTexCoord4dv))load("glMultiTexCoord4dv"); + glMultiTexCoord4f = cast(typeof(glMultiTexCoord4f))load("glMultiTexCoord4f"); + glMultiTexCoord4fv = cast(typeof(glMultiTexCoord4fv))load("glMultiTexCoord4fv"); + glMultiTexCoord4i = cast(typeof(glMultiTexCoord4i))load("glMultiTexCoord4i"); + glMultiTexCoord4iv = cast(typeof(glMultiTexCoord4iv))load("glMultiTexCoord4iv"); + glMultiTexCoord4s = cast(typeof(glMultiTexCoord4s))load("glMultiTexCoord4s"); + glMultiTexCoord4sv = cast(typeof(glMultiTexCoord4sv))load("glMultiTexCoord4sv"); + glLoadTransposeMatrixf = cast(typeof(glLoadTransposeMatrixf))load("glLoadTransposeMatrixf"); + glLoadTransposeMatrixd = cast(typeof(glLoadTransposeMatrixd))load("glLoadTransposeMatrixd"); + glMultTransposeMatrixf = cast(typeof(glMultTransposeMatrixf))load("glMultTransposeMatrixf"); + glMultTransposeMatrixd = cast(typeof(glMultTransposeMatrixd))load("glMultTransposeMatrixd"); + return; +} + +void load_GL_VERSION_1_4(Loader load) { + if(!GL_VERSION_1_4) return; + glBlendFuncSeparate = cast(typeof(glBlendFuncSeparate))load("glBlendFuncSeparate"); + glMultiDrawArrays = cast(typeof(glMultiDrawArrays))load("glMultiDrawArrays"); + glMultiDrawElements = cast(typeof(glMultiDrawElements))load("glMultiDrawElements"); + glPointParameterf = cast(typeof(glPointParameterf))load("glPointParameterf"); + glPointParameterfv = cast(typeof(glPointParameterfv))load("glPointParameterfv"); + glPointParameteri = cast(typeof(glPointParameteri))load("glPointParameteri"); + glPointParameteriv = cast(typeof(glPointParameteriv))load("glPointParameteriv"); + glFogCoordf = cast(typeof(glFogCoordf))load("glFogCoordf"); + glFogCoordfv = cast(typeof(glFogCoordfv))load("glFogCoordfv"); + glFogCoordd = cast(typeof(glFogCoordd))load("glFogCoordd"); + glFogCoorddv = cast(typeof(glFogCoorddv))load("glFogCoorddv"); + glFogCoordPointer = cast(typeof(glFogCoordPointer))load("glFogCoordPointer"); + glSecondaryColor3b = cast(typeof(glSecondaryColor3b))load("glSecondaryColor3b"); + glSecondaryColor3bv = cast(typeof(glSecondaryColor3bv))load("glSecondaryColor3bv"); + glSecondaryColor3d = cast(typeof(glSecondaryColor3d))load("glSecondaryColor3d"); + glSecondaryColor3dv = cast(typeof(glSecondaryColor3dv))load("glSecondaryColor3dv"); + glSecondaryColor3f = cast(typeof(glSecondaryColor3f))load("glSecondaryColor3f"); + glSecondaryColor3fv = cast(typeof(glSecondaryColor3fv))load("glSecondaryColor3fv"); + glSecondaryColor3i = cast(typeof(glSecondaryColor3i))load("glSecondaryColor3i"); + glSecondaryColor3iv = cast(typeof(glSecondaryColor3iv))load("glSecondaryColor3iv"); + glSecondaryColor3s = cast(typeof(glSecondaryColor3s))load("glSecondaryColor3s"); + glSecondaryColor3sv = cast(typeof(glSecondaryColor3sv))load("glSecondaryColor3sv"); + glSecondaryColor3ub = cast(typeof(glSecondaryColor3ub))load("glSecondaryColor3ub"); + glSecondaryColor3ubv = cast(typeof(glSecondaryColor3ubv))load("glSecondaryColor3ubv"); + glSecondaryColor3ui = cast(typeof(glSecondaryColor3ui))load("glSecondaryColor3ui"); + glSecondaryColor3uiv = cast(typeof(glSecondaryColor3uiv))load("glSecondaryColor3uiv"); + glSecondaryColor3us = cast(typeof(glSecondaryColor3us))load("glSecondaryColor3us"); + glSecondaryColor3usv = cast(typeof(glSecondaryColor3usv))load("glSecondaryColor3usv"); + glSecondaryColorPointer = cast(typeof(glSecondaryColorPointer))load("glSecondaryColorPointer"); + glWindowPos2d = cast(typeof(glWindowPos2d))load("glWindowPos2d"); + glWindowPos2dv = cast(typeof(glWindowPos2dv))load("glWindowPos2dv"); + glWindowPos2f = cast(typeof(glWindowPos2f))load("glWindowPos2f"); + glWindowPos2fv = cast(typeof(glWindowPos2fv))load("glWindowPos2fv"); + glWindowPos2i = cast(typeof(glWindowPos2i))load("glWindowPos2i"); + glWindowPos2iv = cast(typeof(glWindowPos2iv))load("glWindowPos2iv"); + glWindowPos2s = cast(typeof(glWindowPos2s))load("glWindowPos2s"); + glWindowPos2sv = cast(typeof(glWindowPos2sv))load("glWindowPos2sv"); + glWindowPos3d = cast(typeof(glWindowPos3d))load("glWindowPos3d"); + glWindowPos3dv = cast(typeof(glWindowPos3dv))load("glWindowPos3dv"); + glWindowPos3f = cast(typeof(glWindowPos3f))load("glWindowPos3f"); + glWindowPos3fv = cast(typeof(glWindowPos3fv))load("glWindowPos3fv"); + glWindowPos3i = cast(typeof(glWindowPos3i))load("glWindowPos3i"); + glWindowPos3iv = cast(typeof(glWindowPos3iv))load("glWindowPos3iv"); + glWindowPos3s = cast(typeof(glWindowPos3s))load("glWindowPos3s"); + glWindowPos3sv = cast(typeof(glWindowPos3sv))load("glWindowPos3sv"); + glBlendColor = cast(typeof(glBlendColor))load("glBlendColor"); + glBlendEquation = cast(typeof(glBlendEquation))load("glBlendEquation"); + return; +} + +void load_GL_VERSION_1_5(Loader load) { + if(!GL_VERSION_1_5) return; + glGenQueries = cast(typeof(glGenQueries))load("glGenQueries"); + glDeleteQueries = cast(typeof(glDeleteQueries))load("glDeleteQueries"); + glIsQuery = cast(typeof(glIsQuery))load("glIsQuery"); + glBeginQuery = cast(typeof(glBeginQuery))load("glBeginQuery"); + glEndQuery = cast(typeof(glEndQuery))load("glEndQuery"); + glGetQueryiv = cast(typeof(glGetQueryiv))load("glGetQueryiv"); + glGetQueryObjectiv = cast(typeof(glGetQueryObjectiv))load("glGetQueryObjectiv"); + glGetQueryObjectuiv = cast(typeof(glGetQueryObjectuiv))load("glGetQueryObjectuiv"); + glBindBuffer = cast(typeof(glBindBuffer))load("glBindBuffer"); + glDeleteBuffers = cast(typeof(glDeleteBuffers))load("glDeleteBuffers"); + glGenBuffers = cast(typeof(glGenBuffers))load("glGenBuffers"); + glIsBuffer = cast(typeof(glIsBuffer))load("glIsBuffer"); + glBufferData = cast(typeof(glBufferData))load("glBufferData"); + glBufferSubData = cast(typeof(glBufferSubData))load("glBufferSubData"); + glGetBufferSubData = cast(typeof(glGetBufferSubData))load("glGetBufferSubData"); + glMapBuffer = cast(typeof(glMapBuffer))load("glMapBuffer"); + glUnmapBuffer = cast(typeof(glUnmapBuffer))load("glUnmapBuffer"); + glGetBufferParameteriv = cast(typeof(glGetBufferParameteriv))load("glGetBufferParameteriv"); + glGetBufferPointerv = cast(typeof(glGetBufferPointerv))load("glGetBufferPointerv"); + return; +} + +void load_GL_VERSION_2_0(Loader load) { + if(!GL_VERSION_2_0) return; + glBlendEquationSeparate = cast(typeof(glBlendEquationSeparate))load("glBlendEquationSeparate"); + glDrawBuffers = cast(typeof(glDrawBuffers))load("glDrawBuffers"); + glStencilOpSeparate = cast(typeof(glStencilOpSeparate))load("glStencilOpSeparate"); + glStencilFuncSeparate = cast(typeof(glStencilFuncSeparate))load("glStencilFuncSeparate"); + glStencilMaskSeparate = cast(typeof(glStencilMaskSeparate))load("glStencilMaskSeparate"); + glAttachShader = cast(typeof(glAttachShader))load("glAttachShader"); + glBindAttribLocation = cast(typeof(glBindAttribLocation))load("glBindAttribLocation"); + glCompileShader = cast(typeof(glCompileShader))load("glCompileShader"); + glCreateProgram = cast(typeof(glCreateProgram))load("glCreateProgram"); + glCreateShader = cast(typeof(glCreateShader))load("glCreateShader"); + glDeleteProgram = cast(typeof(glDeleteProgram))load("glDeleteProgram"); + glDeleteShader = cast(typeof(glDeleteShader))load("glDeleteShader"); + glDetachShader = cast(typeof(glDetachShader))load("glDetachShader"); + glDisableVertexAttribArray = cast(typeof(glDisableVertexAttribArray))load("glDisableVertexAttribArray"); + glEnableVertexAttribArray = cast(typeof(glEnableVertexAttribArray))load("glEnableVertexAttribArray"); + glGetActiveAttrib = cast(typeof(glGetActiveAttrib))load("glGetActiveAttrib"); + glGetActiveUniform = cast(typeof(glGetActiveUniform))load("glGetActiveUniform"); + glGetAttachedShaders = cast(typeof(glGetAttachedShaders))load("glGetAttachedShaders"); + glGetAttribLocation = cast(typeof(glGetAttribLocation))load("glGetAttribLocation"); + glGetProgramiv = cast(typeof(glGetProgramiv))load("glGetProgramiv"); + glGetProgramInfoLog = cast(typeof(glGetProgramInfoLog))load("glGetProgramInfoLog"); + glGetShaderiv = cast(typeof(glGetShaderiv))load("glGetShaderiv"); + glGetShaderInfoLog = cast(typeof(glGetShaderInfoLog))load("glGetShaderInfoLog"); + glGetShaderSource = cast(typeof(glGetShaderSource))load("glGetShaderSource"); + glGetUniformLocation = cast(typeof(glGetUniformLocation))load("glGetUniformLocation"); + glGetUniformfv = cast(typeof(glGetUniformfv))load("glGetUniformfv"); + glGetUniformiv = cast(typeof(glGetUniformiv))load("glGetUniformiv"); + glGetVertexAttribdv = cast(typeof(glGetVertexAttribdv))load("glGetVertexAttribdv"); + glGetVertexAttribfv = cast(typeof(glGetVertexAttribfv))load("glGetVertexAttribfv"); + glGetVertexAttribiv = cast(typeof(glGetVertexAttribiv))load("glGetVertexAttribiv"); + glGetVertexAttribPointerv = cast(typeof(glGetVertexAttribPointerv))load("glGetVertexAttribPointerv"); + glIsProgram = cast(typeof(glIsProgram))load("glIsProgram"); + glIsShader = cast(typeof(glIsShader))load("glIsShader"); + glLinkProgram = cast(typeof(glLinkProgram))load("glLinkProgram"); + glShaderSource = cast(typeof(glShaderSource))load("glShaderSource"); + glUseProgram = cast(typeof(glUseProgram))load("glUseProgram"); + glUniform1f = cast(typeof(glUniform1f))load("glUniform1f"); + glUniform2f = cast(typeof(glUniform2f))load("glUniform2f"); + glUniform3f = cast(typeof(glUniform3f))load("glUniform3f"); + glUniform4f = cast(typeof(glUniform4f))load("glUniform4f"); + glUniform1i = cast(typeof(glUniform1i))load("glUniform1i"); + glUniform2i = cast(typeof(glUniform2i))load("glUniform2i"); + glUniform3i = cast(typeof(glUniform3i))load("glUniform3i"); + glUniform4i = cast(typeof(glUniform4i))load("glUniform4i"); + glUniform1fv = cast(typeof(glUniform1fv))load("glUniform1fv"); + glUniform2fv = cast(typeof(glUniform2fv))load("glUniform2fv"); + glUniform3fv = cast(typeof(glUniform3fv))load("glUniform3fv"); + glUniform4fv = cast(typeof(glUniform4fv))load("glUniform4fv"); + glUniform1iv = cast(typeof(glUniform1iv))load("glUniform1iv"); + glUniform2iv = cast(typeof(glUniform2iv))load("glUniform2iv"); + glUniform3iv = cast(typeof(glUniform3iv))load("glUniform3iv"); + glUniform4iv = cast(typeof(glUniform4iv))load("glUniform4iv"); + glUniformMatrix2fv = cast(typeof(glUniformMatrix2fv))load("glUniformMatrix2fv"); + glUniformMatrix3fv = cast(typeof(glUniformMatrix3fv))load("glUniformMatrix3fv"); + glUniformMatrix4fv = cast(typeof(glUniformMatrix4fv))load("glUniformMatrix4fv"); + glValidateProgram = cast(typeof(glValidateProgram))load("glValidateProgram"); + glVertexAttrib1d = cast(typeof(glVertexAttrib1d))load("glVertexAttrib1d"); + glVertexAttrib1dv = cast(typeof(glVertexAttrib1dv))load("glVertexAttrib1dv"); + glVertexAttrib1f = cast(typeof(glVertexAttrib1f))load("glVertexAttrib1f"); + glVertexAttrib1fv = cast(typeof(glVertexAttrib1fv))load("glVertexAttrib1fv"); + glVertexAttrib1s = cast(typeof(glVertexAttrib1s))load("glVertexAttrib1s"); + glVertexAttrib1sv = cast(typeof(glVertexAttrib1sv))load("glVertexAttrib1sv"); + glVertexAttrib2d = cast(typeof(glVertexAttrib2d))load("glVertexAttrib2d"); + glVertexAttrib2dv = cast(typeof(glVertexAttrib2dv))load("glVertexAttrib2dv"); + glVertexAttrib2f = cast(typeof(glVertexAttrib2f))load("glVertexAttrib2f"); + glVertexAttrib2fv = cast(typeof(glVertexAttrib2fv))load("glVertexAttrib2fv"); + glVertexAttrib2s = cast(typeof(glVertexAttrib2s))load("glVertexAttrib2s"); + glVertexAttrib2sv = cast(typeof(glVertexAttrib2sv))load("glVertexAttrib2sv"); + glVertexAttrib3d = cast(typeof(glVertexAttrib3d))load("glVertexAttrib3d"); + glVertexAttrib3dv = cast(typeof(glVertexAttrib3dv))load("glVertexAttrib3dv"); + glVertexAttrib3f = cast(typeof(glVertexAttrib3f))load("glVertexAttrib3f"); + glVertexAttrib3fv = cast(typeof(glVertexAttrib3fv))load("glVertexAttrib3fv"); + glVertexAttrib3s = cast(typeof(glVertexAttrib3s))load("glVertexAttrib3s"); + glVertexAttrib3sv = cast(typeof(glVertexAttrib3sv))load("glVertexAttrib3sv"); + glVertexAttrib4Nbv = cast(typeof(glVertexAttrib4Nbv))load("glVertexAttrib4Nbv"); + glVertexAttrib4Niv = cast(typeof(glVertexAttrib4Niv))load("glVertexAttrib4Niv"); + glVertexAttrib4Nsv = cast(typeof(glVertexAttrib4Nsv))load("glVertexAttrib4Nsv"); + glVertexAttrib4Nub = cast(typeof(glVertexAttrib4Nub))load("glVertexAttrib4Nub"); + glVertexAttrib4Nubv = cast(typeof(glVertexAttrib4Nubv))load("glVertexAttrib4Nubv"); + glVertexAttrib4Nuiv = cast(typeof(glVertexAttrib4Nuiv))load("glVertexAttrib4Nuiv"); + glVertexAttrib4Nusv = cast(typeof(glVertexAttrib4Nusv))load("glVertexAttrib4Nusv"); + glVertexAttrib4bv = cast(typeof(glVertexAttrib4bv))load("glVertexAttrib4bv"); + glVertexAttrib4d = cast(typeof(glVertexAttrib4d))load("glVertexAttrib4d"); + glVertexAttrib4dv = cast(typeof(glVertexAttrib4dv))load("glVertexAttrib4dv"); + glVertexAttrib4f = cast(typeof(glVertexAttrib4f))load("glVertexAttrib4f"); + glVertexAttrib4fv = cast(typeof(glVertexAttrib4fv))load("glVertexAttrib4fv"); + glVertexAttrib4iv = cast(typeof(glVertexAttrib4iv))load("glVertexAttrib4iv"); + glVertexAttrib4s = cast(typeof(glVertexAttrib4s))load("glVertexAttrib4s"); + glVertexAttrib4sv = cast(typeof(glVertexAttrib4sv))load("glVertexAttrib4sv"); + glVertexAttrib4ubv = cast(typeof(glVertexAttrib4ubv))load("glVertexAttrib4ubv"); + glVertexAttrib4uiv = cast(typeof(glVertexAttrib4uiv))load("glVertexAttrib4uiv"); + glVertexAttrib4usv = cast(typeof(glVertexAttrib4usv))load("glVertexAttrib4usv"); + glVertexAttribPointer = cast(typeof(glVertexAttribPointer))load("glVertexAttribPointer"); + return; +} + +void load_GL_VERSION_2_1(Loader load) { + if(!GL_VERSION_2_1) return; + glUniformMatrix2x3fv = cast(typeof(glUniformMatrix2x3fv))load("glUniformMatrix2x3fv"); + glUniformMatrix3x2fv = cast(typeof(glUniformMatrix3x2fv))load("glUniformMatrix3x2fv"); + glUniformMatrix2x4fv = cast(typeof(glUniformMatrix2x4fv))load("glUniformMatrix2x4fv"); + glUniformMatrix4x2fv = cast(typeof(glUniformMatrix4x2fv))load("glUniformMatrix4x2fv"); + glUniformMatrix3x4fv = cast(typeof(glUniformMatrix3x4fv))load("glUniformMatrix3x4fv"); + glUniformMatrix4x3fv = cast(typeof(glUniformMatrix4x3fv))load("glUniformMatrix4x3fv"); + return; +} + +void load_GL_VERSION_3_0(Loader load) { + if(!GL_VERSION_3_0) return; + glColorMaski = cast(typeof(glColorMaski))load("glColorMaski"); + glGetBooleani_v = cast(typeof(glGetBooleani_v))load("glGetBooleani_v"); + glGetIntegeri_v = cast(typeof(glGetIntegeri_v))load("glGetIntegeri_v"); + glEnablei = cast(typeof(glEnablei))load("glEnablei"); + glDisablei = cast(typeof(glDisablei))load("glDisablei"); + glIsEnabledi = cast(typeof(glIsEnabledi))load("glIsEnabledi"); + glBeginTransformFeedback = cast(typeof(glBeginTransformFeedback))load("glBeginTransformFeedback"); + glEndTransformFeedback = cast(typeof(glEndTransformFeedback))load("glEndTransformFeedback"); + glBindBufferRange = cast(typeof(glBindBufferRange))load("glBindBufferRange"); + glBindBufferBase = cast(typeof(glBindBufferBase))load("glBindBufferBase"); + glTransformFeedbackVaryings = cast(typeof(glTransformFeedbackVaryings))load("glTransformFeedbackVaryings"); + glGetTransformFeedbackVarying = cast(typeof(glGetTransformFeedbackVarying))load("glGetTransformFeedbackVarying"); + glClampColor = cast(typeof(glClampColor))load("glClampColor"); + glBeginConditionalRender = cast(typeof(glBeginConditionalRender))load("glBeginConditionalRender"); + glEndConditionalRender = cast(typeof(glEndConditionalRender))load("glEndConditionalRender"); + glVertexAttribIPointer = cast(typeof(glVertexAttribIPointer))load("glVertexAttribIPointer"); + glGetVertexAttribIiv = cast(typeof(glGetVertexAttribIiv))load("glGetVertexAttribIiv"); + glGetVertexAttribIuiv = cast(typeof(glGetVertexAttribIuiv))load("glGetVertexAttribIuiv"); + glVertexAttribI1i = cast(typeof(glVertexAttribI1i))load("glVertexAttribI1i"); + glVertexAttribI2i = cast(typeof(glVertexAttribI2i))load("glVertexAttribI2i"); + glVertexAttribI3i = cast(typeof(glVertexAttribI3i))load("glVertexAttribI3i"); + glVertexAttribI4i = cast(typeof(glVertexAttribI4i))load("glVertexAttribI4i"); + glVertexAttribI1ui = cast(typeof(glVertexAttribI1ui))load("glVertexAttribI1ui"); + glVertexAttribI2ui = cast(typeof(glVertexAttribI2ui))load("glVertexAttribI2ui"); + glVertexAttribI3ui = cast(typeof(glVertexAttribI3ui))load("glVertexAttribI3ui"); + glVertexAttribI4ui = cast(typeof(glVertexAttribI4ui))load("glVertexAttribI4ui"); + glVertexAttribI1iv = cast(typeof(glVertexAttribI1iv))load("glVertexAttribI1iv"); + glVertexAttribI2iv = cast(typeof(glVertexAttribI2iv))load("glVertexAttribI2iv"); + glVertexAttribI3iv = cast(typeof(glVertexAttribI3iv))load("glVertexAttribI3iv"); + glVertexAttribI4iv = cast(typeof(glVertexAttribI4iv))load("glVertexAttribI4iv"); + glVertexAttribI1uiv = cast(typeof(glVertexAttribI1uiv))load("glVertexAttribI1uiv"); + glVertexAttribI2uiv = cast(typeof(glVertexAttribI2uiv))load("glVertexAttribI2uiv"); + glVertexAttribI3uiv = cast(typeof(glVertexAttribI3uiv))load("glVertexAttribI3uiv"); + glVertexAttribI4uiv = cast(typeof(glVertexAttribI4uiv))load("glVertexAttribI4uiv"); + glVertexAttribI4bv = cast(typeof(glVertexAttribI4bv))load("glVertexAttribI4bv"); + glVertexAttribI4sv = cast(typeof(glVertexAttribI4sv))load("glVertexAttribI4sv"); + glVertexAttribI4ubv = cast(typeof(glVertexAttribI4ubv))load("glVertexAttribI4ubv"); + glVertexAttribI4usv = cast(typeof(glVertexAttribI4usv))load("glVertexAttribI4usv"); + glGetUniformuiv = cast(typeof(glGetUniformuiv))load("glGetUniformuiv"); + glBindFragDataLocation = cast(typeof(glBindFragDataLocation))load("glBindFragDataLocation"); + glGetFragDataLocation = cast(typeof(glGetFragDataLocation))load("glGetFragDataLocation"); + glUniform1ui = cast(typeof(glUniform1ui))load("glUniform1ui"); + glUniform2ui = cast(typeof(glUniform2ui))load("glUniform2ui"); + glUniform3ui = cast(typeof(glUniform3ui))load("glUniform3ui"); + glUniform4ui = cast(typeof(glUniform4ui))load("glUniform4ui"); + glUniform1uiv = cast(typeof(glUniform1uiv))load("glUniform1uiv"); + glUniform2uiv = cast(typeof(glUniform2uiv))load("glUniform2uiv"); + glUniform3uiv = cast(typeof(glUniform3uiv))load("glUniform3uiv"); + glUniform4uiv = cast(typeof(glUniform4uiv))load("glUniform4uiv"); + glTexParameterIiv = cast(typeof(glTexParameterIiv))load("glTexParameterIiv"); + glTexParameterIuiv = cast(typeof(glTexParameterIuiv))load("glTexParameterIuiv"); + glGetTexParameterIiv = cast(typeof(glGetTexParameterIiv))load("glGetTexParameterIiv"); + glGetTexParameterIuiv = cast(typeof(glGetTexParameterIuiv))load("glGetTexParameterIuiv"); + glClearBufferiv = cast(typeof(glClearBufferiv))load("glClearBufferiv"); + glClearBufferuiv = cast(typeof(glClearBufferuiv))load("glClearBufferuiv"); + glClearBufferfv = cast(typeof(glClearBufferfv))load("glClearBufferfv"); + glClearBufferfi = cast(typeof(glClearBufferfi))load("glClearBufferfi"); + glGetStringi = cast(typeof(glGetStringi))load("glGetStringi"); + glIsRenderbuffer = cast(typeof(glIsRenderbuffer))load("glIsRenderbuffer"); + glBindRenderbuffer = cast(typeof(glBindRenderbuffer))load("glBindRenderbuffer"); + glDeleteRenderbuffers = cast(typeof(glDeleteRenderbuffers))load("glDeleteRenderbuffers"); + glGenRenderbuffers = cast(typeof(glGenRenderbuffers))load("glGenRenderbuffers"); + glRenderbufferStorage = cast(typeof(glRenderbufferStorage))load("glRenderbufferStorage"); + glGetRenderbufferParameteriv = cast(typeof(glGetRenderbufferParameteriv))load("glGetRenderbufferParameteriv"); + glIsFramebuffer = cast(typeof(glIsFramebuffer))load("glIsFramebuffer"); + glBindFramebuffer = cast(typeof(glBindFramebuffer))load("glBindFramebuffer"); + glDeleteFramebuffers = cast(typeof(glDeleteFramebuffers))load("glDeleteFramebuffers"); + glGenFramebuffers = cast(typeof(glGenFramebuffers))load("glGenFramebuffers"); + glCheckFramebufferStatus = cast(typeof(glCheckFramebufferStatus))load("glCheckFramebufferStatus"); + glFramebufferTexture1D = cast(typeof(glFramebufferTexture1D))load("glFramebufferTexture1D"); + glFramebufferTexture2D = cast(typeof(glFramebufferTexture2D))load("glFramebufferTexture2D"); + glFramebufferTexture3D = cast(typeof(glFramebufferTexture3D))load("glFramebufferTexture3D"); + glFramebufferRenderbuffer = cast(typeof(glFramebufferRenderbuffer))load("glFramebufferRenderbuffer"); + glGetFramebufferAttachmentParameteriv = cast(typeof(glGetFramebufferAttachmentParameteriv))load("glGetFramebufferAttachmentParameteriv"); + glGenerateMipmap = cast(typeof(glGenerateMipmap))load("glGenerateMipmap"); + glBlitFramebuffer = cast(typeof(glBlitFramebuffer))load("glBlitFramebuffer"); + glRenderbufferStorageMultisample = cast(typeof(glRenderbufferStorageMultisample))load("glRenderbufferStorageMultisample"); + glFramebufferTextureLayer = cast(typeof(glFramebufferTextureLayer))load("glFramebufferTextureLayer"); + glMapBufferRange = cast(typeof(glMapBufferRange))load("glMapBufferRange"); + glFlushMappedBufferRange = cast(typeof(glFlushMappedBufferRange))load("glFlushMappedBufferRange"); + glBindVertexArray = cast(typeof(glBindVertexArray))load("glBindVertexArray"); + glDeleteVertexArrays = cast(typeof(glDeleteVertexArrays))load("glDeleteVertexArrays"); + glGenVertexArrays = cast(typeof(glGenVertexArrays))load("glGenVertexArrays"); + glIsVertexArray = cast(typeof(glIsVertexArray))load("glIsVertexArray"); + return; +} + +void load_GL_VERSION_3_1(Loader load) { + if(!GL_VERSION_3_1) return; + glDrawArraysInstanced = cast(typeof(glDrawArraysInstanced))load("glDrawArraysInstanced"); + glDrawElementsInstanced = cast(typeof(glDrawElementsInstanced))load("glDrawElementsInstanced"); + glTexBuffer = cast(typeof(glTexBuffer))load("glTexBuffer"); + glPrimitiveRestartIndex = cast(typeof(glPrimitiveRestartIndex))load("glPrimitiveRestartIndex"); + glCopyBufferSubData = cast(typeof(glCopyBufferSubData))load("glCopyBufferSubData"); + glGetUniformIndices = cast(typeof(glGetUniformIndices))load("glGetUniformIndices"); + glGetActiveUniformsiv = cast(typeof(glGetActiveUniformsiv))load("glGetActiveUniformsiv"); + glGetActiveUniformName = cast(typeof(glGetActiveUniformName))load("glGetActiveUniformName"); + glGetUniformBlockIndex = cast(typeof(glGetUniformBlockIndex))load("glGetUniformBlockIndex"); + glGetActiveUniformBlockiv = cast(typeof(glGetActiveUniformBlockiv))load("glGetActiveUniformBlockiv"); + glGetActiveUniformBlockName = cast(typeof(glGetActiveUniformBlockName))load("glGetActiveUniformBlockName"); + glUniformBlockBinding = cast(typeof(glUniformBlockBinding))load("glUniformBlockBinding"); + glBindBufferRange = cast(typeof(glBindBufferRange))load("glBindBufferRange"); + glBindBufferBase = cast(typeof(glBindBufferBase))load("glBindBufferBase"); + glGetIntegeri_v = cast(typeof(glGetIntegeri_v))load("glGetIntegeri_v"); + return; +} + +void load_GL_VERSION_3_2(Loader load) { + if(!GL_VERSION_3_2) return; + glDrawElementsBaseVertex = cast(typeof(glDrawElementsBaseVertex))load("glDrawElementsBaseVertex"); + glDrawRangeElementsBaseVertex = cast(typeof(glDrawRangeElementsBaseVertex))load("glDrawRangeElementsBaseVertex"); + glDrawElementsInstancedBaseVertex = cast(typeof(glDrawElementsInstancedBaseVertex))load("glDrawElementsInstancedBaseVertex"); + glMultiDrawElementsBaseVertex = cast(typeof(glMultiDrawElementsBaseVertex))load("glMultiDrawElementsBaseVertex"); + glProvokingVertex = cast(typeof(glProvokingVertex))load("glProvokingVertex"); + glFenceSync = cast(typeof(glFenceSync))load("glFenceSync"); + glIsSync = cast(typeof(glIsSync))load("glIsSync"); + glDeleteSync = cast(typeof(glDeleteSync))load("glDeleteSync"); + glClientWaitSync = cast(typeof(glClientWaitSync))load("glClientWaitSync"); + glWaitSync = cast(typeof(glWaitSync))load("glWaitSync"); + glGetInteger64v = cast(typeof(glGetInteger64v))load("glGetInteger64v"); + glGetSynciv = cast(typeof(glGetSynciv))load("glGetSynciv"); + glGetInteger64i_v = cast(typeof(glGetInteger64i_v))load("glGetInteger64i_v"); + glGetBufferParameteri64v = cast(typeof(glGetBufferParameteri64v))load("glGetBufferParameteri64v"); + glFramebufferTexture = cast(typeof(glFramebufferTexture))load("glFramebufferTexture"); + glTexImage2DMultisample = cast(typeof(glTexImage2DMultisample))load("glTexImage2DMultisample"); + glTexImage3DMultisample = cast(typeof(glTexImage3DMultisample))load("glTexImage3DMultisample"); + glGetMultisamplefv = cast(typeof(glGetMultisamplefv))load("glGetMultisamplefv"); + glSampleMaski = cast(typeof(glSampleMaski))load("glSampleMaski"); + return; +} + +void load_GL_VERSION_3_3(Loader load) { + if(!GL_VERSION_3_3) return; + glBindFragDataLocationIndexed = cast(typeof(glBindFragDataLocationIndexed))load("glBindFragDataLocationIndexed"); + glGetFragDataIndex = cast(typeof(glGetFragDataIndex))load("glGetFragDataIndex"); + glGenSamplers = cast(typeof(glGenSamplers))load("glGenSamplers"); + glDeleteSamplers = cast(typeof(glDeleteSamplers))load("glDeleteSamplers"); + glIsSampler = cast(typeof(glIsSampler))load("glIsSampler"); + glBindSampler = cast(typeof(glBindSampler))load("glBindSampler"); + glSamplerParameteri = cast(typeof(glSamplerParameteri))load("glSamplerParameteri"); + glSamplerParameteriv = cast(typeof(glSamplerParameteriv))load("glSamplerParameteriv"); + glSamplerParameterf = cast(typeof(glSamplerParameterf))load("glSamplerParameterf"); + glSamplerParameterfv = cast(typeof(glSamplerParameterfv))load("glSamplerParameterfv"); + glSamplerParameterIiv = cast(typeof(glSamplerParameterIiv))load("glSamplerParameterIiv"); + glSamplerParameterIuiv = cast(typeof(glSamplerParameterIuiv))load("glSamplerParameterIuiv"); + glGetSamplerParameteriv = cast(typeof(glGetSamplerParameteriv))load("glGetSamplerParameteriv"); + glGetSamplerParameterIiv = cast(typeof(glGetSamplerParameterIiv))load("glGetSamplerParameterIiv"); + glGetSamplerParameterfv = cast(typeof(glGetSamplerParameterfv))load("glGetSamplerParameterfv"); + glGetSamplerParameterIuiv = cast(typeof(glGetSamplerParameterIuiv))load("glGetSamplerParameterIuiv"); + glQueryCounter = cast(typeof(glQueryCounter))load("glQueryCounter"); + glGetQueryObjecti64v = cast(typeof(glGetQueryObjecti64v))load("glGetQueryObjecti64v"); + glGetQueryObjectui64v = cast(typeof(glGetQueryObjectui64v))load("glGetQueryObjectui64v"); + glVertexAttribDivisor = cast(typeof(glVertexAttribDivisor))load("glVertexAttribDivisor"); + glVertexAttribP1ui = cast(typeof(glVertexAttribP1ui))load("glVertexAttribP1ui"); + glVertexAttribP1uiv = cast(typeof(glVertexAttribP1uiv))load("glVertexAttribP1uiv"); + glVertexAttribP2ui = cast(typeof(glVertexAttribP2ui))load("glVertexAttribP2ui"); + glVertexAttribP2uiv = cast(typeof(glVertexAttribP2uiv))load("glVertexAttribP2uiv"); + glVertexAttribP3ui = cast(typeof(glVertexAttribP3ui))load("glVertexAttribP3ui"); + glVertexAttribP3uiv = cast(typeof(glVertexAttribP3uiv))load("glVertexAttribP3uiv"); + glVertexAttribP4ui = cast(typeof(glVertexAttribP4ui))load("glVertexAttribP4ui"); + glVertexAttribP4uiv = cast(typeof(glVertexAttribP4uiv))load("glVertexAttribP4uiv"); + glVertexP2ui = cast(typeof(glVertexP2ui))load("glVertexP2ui"); + glVertexP2uiv = cast(typeof(glVertexP2uiv))load("glVertexP2uiv"); + glVertexP3ui = cast(typeof(glVertexP3ui))load("glVertexP3ui"); + glVertexP3uiv = cast(typeof(glVertexP3uiv))load("glVertexP3uiv"); + glVertexP4ui = cast(typeof(glVertexP4ui))load("glVertexP4ui"); + glVertexP4uiv = cast(typeof(glVertexP4uiv))load("glVertexP4uiv"); + glTexCoordP1ui = cast(typeof(glTexCoordP1ui))load("glTexCoordP1ui"); + glTexCoordP1uiv = cast(typeof(glTexCoordP1uiv))load("glTexCoordP1uiv"); + glTexCoordP2ui = cast(typeof(glTexCoordP2ui))load("glTexCoordP2ui"); + glTexCoordP2uiv = cast(typeof(glTexCoordP2uiv))load("glTexCoordP2uiv"); + glTexCoordP3ui = cast(typeof(glTexCoordP3ui))load("glTexCoordP3ui"); + glTexCoordP3uiv = cast(typeof(glTexCoordP3uiv))load("glTexCoordP3uiv"); + glTexCoordP4ui = cast(typeof(glTexCoordP4ui))load("glTexCoordP4ui"); + glTexCoordP4uiv = cast(typeof(glTexCoordP4uiv))load("glTexCoordP4uiv"); + glMultiTexCoordP1ui = cast(typeof(glMultiTexCoordP1ui))load("glMultiTexCoordP1ui"); + glMultiTexCoordP1uiv = cast(typeof(glMultiTexCoordP1uiv))load("glMultiTexCoordP1uiv"); + glMultiTexCoordP2ui = cast(typeof(glMultiTexCoordP2ui))load("glMultiTexCoordP2ui"); + glMultiTexCoordP2uiv = cast(typeof(glMultiTexCoordP2uiv))load("glMultiTexCoordP2uiv"); + glMultiTexCoordP3ui = cast(typeof(glMultiTexCoordP3ui))load("glMultiTexCoordP3ui"); + glMultiTexCoordP3uiv = cast(typeof(glMultiTexCoordP3uiv))load("glMultiTexCoordP3uiv"); + glMultiTexCoordP4ui = cast(typeof(glMultiTexCoordP4ui))load("glMultiTexCoordP4ui"); + glMultiTexCoordP4uiv = cast(typeof(glMultiTexCoordP4uiv))load("glMultiTexCoordP4uiv"); + glNormalP3ui = cast(typeof(glNormalP3ui))load("glNormalP3ui"); + glNormalP3uiv = cast(typeof(glNormalP3uiv))load("glNormalP3uiv"); + glColorP3ui = cast(typeof(glColorP3ui))load("glColorP3ui"); + glColorP3uiv = cast(typeof(glColorP3uiv))load("glColorP3uiv"); + glColorP4ui = cast(typeof(glColorP4ui))load("glColorP4ui"); + glColorP4uiv = cast(typeof(glColorP4uiv))load("glColorP4uiv"); + glSecondaryColorP3ui = cast(typeof(glSecondaryColorP3ui))load("glSecondaryColorP3ui"); + glSecondaryColorP3uiv = cast(typeof(glSecondaryColorP3uiv))load("glSecondaryColorP3uiv"); + return; +} + + +} /* private */ + diff --git a/source/glad/gl/types.d b/source/glad/gl/types.d new file mode 100644 index 0000000..043a2a1 --- /dev/null +++ b/source/glad/gl/types.d @@ -0,0 +1,46 @@ +module glad.gl.types; + + +alias GLvoid = void; +alias GLintptr = ptrdiff_t; +alias GLsizei = int; +alias GLchar = char; +alias GLcharARB = byte; +alias GLushort = ushort; +alias GLint64EXT = long; +alias GLshort = short; +alias GLuint64 = ulong; +alias GLhalfARB = ushort; +alias GLubyte = ubyte; +alias GLdouble = double; +alias GLhandleARB = uint; +alias GLint64 = long; +alias GLenum = uint; +alias GLeglImageOES = void*; +alias GLintptrARB = ptrdiff_t; +alias GLsizeiptr = ptrdiff_t; +alias GLint = int; +alias GLboolean = ubyte; +alias GLbitfield = uint; +alias GLsizeiptrARB = ptrdiff_t; +alias GLfloat = float; +alias GLuint64EXT = ulong; +alias GLclampf = float; +alias GLbyte = byte; +alias GLclampd = double; +alias GLuint = uint; +alias GLvdpauSurfaceNV = ptrdiff_t; +alias GLfixed = int; +alias GLhalf = ushort; +alias GLclampx = int; +alias GLhalfNV = ushort; +struct ___GLsync; alias __GLsync = ___GLsync*; +alias GLsync = __GLsync*; +struct __cl_context; alias _cl_context = __cl_context*; +struct __cl_event; alias _cl_event = __cl_event*; +extern(System) { +alias GLDEBUGPROC = void function(GLenum, GLenum, GLuint, GLenum, GLsizei, in GLchar*, GLvoid*); +alias GLDEBUGPROCARB = GLDEBUGPROC; +alias GLDEBUGPROCKHR = GLDEBUGPROC; +alias GLDEBUGPROCAMD = void function(GLuint, GLenum, GLenum, GLsizei, in GLchar*, GLvoid*); +}