diff --git a/.gitignore b/.gitignore index 304e955..3e72d61 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,5 @@ docs/ *.o *.obj *.lst +*.cap +imgui.ini diff --git a/imgui.ini b/imgui.ini deleted file mode 100644 index cc124ba..0000000 --- a/imgui.ini +++ /dev/null @@ -1,10 +0,0 @@ -[Window][Debug##Default] -Pos=60,60 -Size=400,400 -Collapsed=0 - -[Window][Emulator Status] -Pos=425,47 -Size=444,533 -Collapsed=0 - diff --git a/source/app.d b/source/app.d index 3de6b9b..44ded8d 100644 --- a/source/app.d +++ b/source/app.d @@ -6,6 +6,340 @@ import glad.gl.all; import window; import imgui; +bool checkShaderError(GLuint shader, GLuint flag, bool is_program, in char[] shader_path) nothrow { + + GLint result; + + (is_program) ? glGetProgramiv(shader, flag, &result) + : glGetShaderiv(shader, flag, &result); + + if (result == GL_FALSE) { + + GLchar[256] log; //FIXME this is potentially fatal + (is_program) ? glGetProgramInfoLog(shader, log.sizeof, null, log.ptr) + : glGetShaderInfoLog(shader, log.sizeof, null, log.ptr); + + printf("[OpenGL] Error in %s: %s\n", shader_path.ptr, log.ptr); + return false; + + } + + return true; + +} // checkShaderError + +struct PixelBuffer { + + struct Shader { + + private { + GLuint shader_prog; + } + + @disable this(this); + + void compile(const (GLchar*)* vs_source, const (GLchar*)* fs_source) { + + import core.stdc.stdlib : exit; + + GLuint new_vs_shader = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(new_vs_shader, 1, vs_source, null); + glCompileShader(new_vs_shader); + if (!checkShaderError(new_vs_shader, GL_COMPILE_STATUS, false, "vertex_shader")) { + exit(-1); + } + + GLuint new_fs_shader = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(new_fs_shader, 1, fs_source, null); + glCompileShader(new_fs_shader); + if (!checkShaderError(new_fs_shader, GL_COMPILE_STATUS, false, "fragment_shader")) { + exit(-1); + } + + GLuint new_shader = glCreateProgram(); + glAttachShader(new_shader, new_vs_shader); + glAttachShader(new_shader, new_fs_shader); + + // glBindAttribLocation(new_shader, 0, "screen_size"); + + glLinkProgram(new_shader); + if (!checkShaderError(new_shader, GL_LINK_STATUS, true, "shader_program")) { + exit(-1); + } + + glValidateProgram(new_shader); + if (!checkShaderError(new_shader, GL_VALIDATE_STATUS, true, "shader_program")) { + exit(-1); + } + + shader_prog = new_shader; + + } // compile + + void setUniforms(int w, int h) { + auto attr_loc = glGetUniformLocation(shader_prog, "screen_size"); + glUniform2f(attr_loc, cast(float)w, cast(float)h); + } // setUniforms + + void bind() { + glUseProgram(shader_prog); + } // bind + + void unbind() { + glUseProgram(0); + } // unbind + + } // Shader + + struct Texture { + + import derelict.sdl2.sdl; + import derelict.sdl2.image; + + private { + + GLuint texture_; //OpenGL handle for texture + GLenum input_format_, output_format_, data_type_; + int width_, height_; + + } + + @property @nogc nothrow { + + int width() const { return width_; } + int height() const { return height_; } + GLuint handle() { return texture_; } + + } + + @disable this(this); + + nothrow @nogc + this(int width, int height, GLenum input_format, GLenum output_format, GLenum unpack_alignment) { + + width_ = width; + height_ = height; + input_format_ = input_format; + output_format_ = output_format; + data_type_ = GL_UNSIGNED_BYTE; + + glGenTextures(1, &texture_); + glBindTexture(GL_TEXTURE_2D, texture_); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment); + glTexImage2D(GL_TEXTURE_2D, 0, input_format_, width_, height_, 0, output_format_, GL_UNSIGNED_BYTE, cast(void*)0); + + glBindTexture(GL_TEXTURE_2D, 0); + + } //this + + nothrow @nogc + void create(void* pixels, int width, int height, GLenum input_format = GL_RGB, GLenum output_format = GL_RGB, GLenum data_type = GL_UNSIGNED_BYTE) { + + width_ = width; + height_ = height; + input_format_ = input_format; + output_format_ = output_format; + data_type_ = data_type; + + //generate single texture, put handle in texture + glGenTextures(1, &texture_); + + //normal 2d texture, bind to our texture handle + glBindTexture(GL_TEXTURE_2D, texture_); + + //set texture parameters in currently bound texture, controls texture wrapping (or GL_CLAMP?) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + //linearly interpolate between pixels, MIN if texture is too small for drawing area, MAG if drawing area is smaller than texture + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + //texture type, level, format to store as, width, height, border, format loaded in + glTexImage2D(GL_TEXTURE_2D, 0, input_format_, width_, height_, 0, output_format_, data_type_, pixels); + + //UNBIND + glBindTexture(GL_TEXTURE_2D, 0); + + } // this + + ~this() nothrow @nogc { + + if (texture_ != 0) { + glDeleteTextures(1, &texture_); + } + + } // ~this + + /** + * Binds the texture handle, takes an argument for which texture unit to use. + */ + nothrow @nogc + void bind(int unit) { + + assert(unit >= 0 && unit <= 31); + glActiveTexture(GL_TEXTURE0 + unit); //since this is sequential, this works + glBindTexture(GL_TEXTURE_2D, texture_); + + } // bind + + nothrow @nogc + void unbind() { + + glBindTexture(GL_TEXTURE_2D, 0); + + } // unbind + + /** + * Updates the texture in place given the new texture buffer. + * Takes an optional offset to update only a part of the texture. + **/ + nothrow @nogc + void update(void[] pixels, size_t offset = 0) { + + bind(0); + glBufferSubData(GL_ARRAY_BUFFER, cast(GLintptr)offset, pixels.length, pixels.ptr); + unbind(); + + } // update + + } // Texture + + /** + * Generic VertexArray structure, used to upload data of any given vertex type to the GPU. + */ + struct VertexArray { + + private { + + GLuint vao_; + GLuint vbo_; + GLenum type_; // type of vertex data, GL_TRIANGLES etc + uint num_vertices_; + + } + + @disable this(this); + + nothrow @nogc + void create(in float[2][] vertices, GLenum draw_type = GL_STATIC_DRAW, GLenum primitive = GL_TRIANGLES) { + + this.num_vertices_ = cast(uint)vertices.length; + this.type_ = primitive; + + glGenVertexArrays(1, &vao_); + glBindVertexArray(vao_); + + glGenBuffers(1, &vbo_); + glBindBuffer(GL_ARRAY_BUFFER, vbo_); + glBufferData(GL_ARRAY_BUFFER, vertices.length * vertices[0].sizeof, vertices.ptr, draw_type); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, + vertices[0].length, + GL_FLOAT, + GL_FALSE, + vertices[0].sizeof, + vertices.ptr + ); + + glBindVertexArray(0); + + } // this + + ~this() nothrow @nogc { + if (vao_ != 0) { + glDeleteVertexArrays(1, &vao_); + } + } // ~this + + void bind() nothrow @nogc { + glBindVertexArray(vao_); + } // bind + + void draw() nothrow @nogc { + glDrawArrays(type_, 0, num_vertices_); + } // draw + + void unbind() nothrow @nogc { + glBindVertexArray(0); + } // unbind + + } // VertexArray + + const char* vs_shader = q{ + #version 330 core + + uniform vec2 screen_size; + + layout(location = 0) in vec2 pos; + layout(location = 1) in vec2 uv; + + out vec2 frag_uv; + + void main() { + frag_uv = uv; + gl_Position = vec4(pos, 0.0, 0.0); + } + + }; + + const char* fs_shader = q{ + #version 330 core + + uniform sampler2D tex; + + in vec2 frag_uv; + + out vec4 out_col; + + void main() { + out_col = texture(tex, frag_uv.st); + } + + }; + + Shader shader; + VertexArray vao; + Texture tex; + + void create(void* pixels, int w, int h) { + + float[2][6] rect = [ + [0.0f, 0.0f], // top left + [1.0f, 0.0f], // top right + [1.0f, 1.0f], // bottom right + + [0.0f, 0.0f], // top left + [0.0f, 1.0f], // bottom left + [1.0f, 1.0f], // bottom right + ]; + + vao.create(rect[]); + tex.create(pixels, w, h); + shader.compile(&vs_shader, &fs_shader); + + } // create + + void draw(int screen_w, int screen_h) { + + vao.bind(); + shader.bind(); + shader.setUniforms(screen_w, screen_h); + tex.bind(0); + vao.draw(); + + } // draw + +} // PixelBuffer + struct Chip8Status { //emu ptr @@ -47,6 +381,12 @@ struct Chip8Status { } // getStackFrame + void resetShortcut() { + + emu_.reset(); + + } // resetShortcut + void loadShortcut() { import std.file : read; @@ -88,12 +428,12 @@ struct Chip8Status { if (igBeginMenu("Menu")) { - if (igMenuItem("Load", "CTRL+L")) { - loadShortcut(); + if (igMenuItem("Reset", "CTRL+R")) { + resetShortcut(); } - if (igMenuItem("Save", "CTRL+S")) { - saveShortcut(); + if (igMenuItem("Load", "CTRL+L")) { + loadShortcut(); } if (igMenuItem("Debug", "CTRL+D")) { @@ -171,12 +511,12 @@ struct Chip8Status { case SDL_KEYDOWN: if ((ev.key.keysym.mod & KMOD_CTRL) != 0) { switch (ev.key.keysym.scancode) with (SDL_EventType) { + case SDL_SCANCODE_R: resetShortcut(); break; case SDL_SCANCODE_L: loadShortcut(); break; - case SDL_SCANCODE_S: saveShortcut(); break; case SDL_SCANCODE_D: debugShortcut(); break; case SDL_SCANCODE_G: redrawShortcut(); break; - case SDL_SCANCODE_R: toggleRunShortcut(); break; - case SDL_SCANCODE_T: stepShortcut(); break; + case SDL_SCANCODE_T: toggleRunShortcut(); break; + case SDL_SCANCODE_S: stepShortcut(); break; case SDL_SCANCODE_Q: quitShortcut(); default: break; } @@ -193,6 +533,7 @@ struct Chip8Status { } // Chip8Status +// this is a collosally awful solution, but if it works :D string doCapture(string sym, uint start, uint end)(){ import std.string : format; @@ -274,6 +615,14 @@ struct Chip8 { } // load + void reset() { + + cpu = cpu.init; + screen_buf = screen_buf.init; + screen_data = screen_data.init; + + } // reset + void step() { cpu.opcode = ram[cpu.pc] << 8 | ram[cpu.pc + 1]; @@ -288,16 +637,12 @@ struct Chip8 { switch (cpu.opcode & 0x0FFF) { case 0x00E0: // 0x00E0 Clears the screen. - - screen_buf[0..$] = 0; + // 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. @@ -309,9 +654,7 @@ struct Chip8 { break; case 0x1000: // 0x1NNN Jumps to address NNN. - pc_target = cpu.opcode.capture!(0, 12); - break; case 0x2000: // 0x2NNN Calls subroutine at NNN. @@ -346,15 +689,11 @@ struct Chip8 { 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: @@ -365,39 +704,27 @@ struct Chip8 { 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. @@ -405,13 +732,10 @@ struct Chip8 { 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 - + 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. @@ -419,10 +743,9 @@ struct Chip8 { auto vx = cpu.v[x]; cpu.v[0xF] = (vx & 0b10000000) >> 7; cpu.v[x] <<= 1; - break; - default: //unhandled for some reason + default: // unhandled for some reason writefln("unknown opcode: 0x%x", cpu.opcode); break; @@ -439,15 +762,11 @@ struct Chip8 { 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. @@ -455,7 +774,6 @@ struct Chip8 { 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 @@ -470,11 +788,10 @@ struct Chip8 { 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]; + ushort pixel = ram[spr_addr + row]; foreach (int col; 0 .. 8) { if ((pixel & (0x80 >> col)) != 0) { @@ -519,9 +836,7 @@ struct Chip8 { 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. @@ -529,21 +844,15 @@ struct Chip8 { 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. @@ -551,7 +860,6 @@ struct Chip8 { 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, @@ -563,7 +871,6 @@ struct Chip8 { 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. @@ -607,7 +914,7 @@ struct Chip8 { if (cpu.sound_timer != 0u) { - if (cpu.sound_timer == 1) { + if (cpu.sound_timer == 1u) { writefln("beep!"); } @@ -683,6 +990,9 @@ struct Emulator { Imgui imgui; Chip8 emu; + // drawing + PixelBuffer buf; + void create() { // create window @@ -695,6 +1005,12 @@ struct Emulator { // setup debug ui status.initialize(&this, &emu); + // set up pixel buffer to poke at + emu.screen_data[0][] = 255; + buf.create(emu.screen_data.ptr, 64, 32); + + emu.screen_buf[] = 255; + } void handleEvents() { @@ -741,6 +1057,11 @@ struct Emulator { void draw() { window.renderClear(0x428bca); + + int w, h; + window.windowSize(w, h); + + buf.draw(w, h); imgui.newFrame(window); status.draw(); diff --git a/source/glad/gl/all.d b/source/glad/gl/all.d index 5781698..f8aac65 100644 --- a/source/glad/gl/all.d +++ b/source/glad/gl/all.d @@ -1,21 +1,22 @@ /* - OpenGL loader generated by glad 0.1.24a0 on Wed Jun 20 01:57:03 2018. + OpenGL loader generated by glad 0.1.27 on Sun Sep 30 18:03:39 2018. Language/Generator: D Specification: gl APIs: gl=3.3 - Profile: compatibility + Profile: core Extensions: - + GL_KHR_debug Loader: True Local files: False Omit khrplatform: False + Reproducible: False Commandline: - --profile="compatibility" --api="gl=3.3" --generator="d" --spec="gl" --extensions="" + --profile="core" --api="gl=3.3" --generator="d" --spec="gl" --extensions="GL_KHR_debug" Online: - http://glad.dav1d.de/#profile=compatibility&language=d&specification=gl&loader=on&api=gl%3D3.3 + http://glad.dav1d.de/#profile=core&language=d&specification=gl&loader=on&api=gl%3D3.3&extensions=GL_KHR_debug */ module glad.gl.all; diff --git a/source/glad/gl/enums.d b/source/glad/gl/enums.d index 261d2c6..dcd0948 100644 --- a/source/glad/gl/enums.d +++ b/source/glad/gl/enums.d @@ -25,7 +25,6 @@ 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; @@ -130,8 +129,6 @@ 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; @@ -182,257 +179,6 @@ 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; @@ -463,80 +209,6 @@ 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; @@ -573,11 +245,6 @@ 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; @@ -637,43 +304,6 @@ 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; @@ -690,29 +320,6 @@ 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; @@ -752,28 +359,6 @@ 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; @@ -854,10 +439,6 @@ 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; @@ -874,13 +455,6 @@ 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; @@ -1077,9 +651,6 @@ 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; @@ -1115,9 +686,6 @@ 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; @@ -1257,3 +825,84 @@ 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; +enum uint GL_DEBUG_OUTPUT_SYNCHRONOUS = 0x8242; +enum uint GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243; +enum uint GL_DEBUG_CALLBACK_FUNCTION = 0x8244; +enum uint GL_DEBUG_CALLBACK_USER_PARAM = 0x8245; +enum uint GL_DEBUG_SOURCE_API = 0x8246; +enum uint GL_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247; +enum uint GL_DEBUG_SOURCE_SHADER_COMPILER = 0x8248; +enum uint GL_DEBUG_SOURCE_THIRD_PARTY = 0x8249; +enum uint GL_DEBUG_SOURCE_APPLICATION = 0x824A; +enum uint GL_DEBUG_SOURCE_OTHER = 0x824B; +enum uint GL_DEBUG_TYPE_ERROR = 0x824C; +enum uint GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D; +enum uint GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E; +enum uint GL_DEBUG_TYPE_PORTABILITY = 0x824F; +enum uint GL_DEBUG_TYPE_PERFORMANCE = 0x8250; +enum uint GL_DEBUG_TYPE_OTHER = 0x8251; +enum uint GL_DEBUG_TYPE_MARKER = 0x8268; +enum uint GL_DEBUG_TYPE_PUSH_GROUP = 0x8269; +enum uint GL_DEBUG_TYPE_POP_GROUP = 0x826A; +enum uint GL_DEBUG_SEVERITY_NOTIFICATION = 0x826B; +enum uint GL_MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C; +enum uint GL_DEBUG_GROUP_STACK_DEPTH = 0x826D; +enum uint GL_BUFFER = 0x82E0; +enum uint GL_SHADER = 0x82E1; +enum uint GL_PROGRAM = 0x82E2; +enum uint GL_VERTEX_ARRAY = 0x8074; +enum uint GL_QUERY = 0x82E3; +enum uint GL_PROGRAM_PIPELINE = 0x82E4; +enum uint GL_SAMPLER = 0x82E6; +enum uint GL_MAX_LABEL_LENGTH = 0x82E8; +enum uint GL_MAX_DEBUG_MESSAGE_LENGTH = 0x9143; +enum uint GL_MAX_DEBUG_LOGGED_MESSAGES = 0x9144; +enum uint GL_DEBUG_LOGGED_MESSAGES = 0x9145; +enum uint GL_DEBUG_SEVERITY_HIGH = 0x9146; +enum uint GL_DEBUG_SEVERITY_MEDIUM = 0x9147; +enum uint GL_DEBUG_SEVERITY_LOW = 0x9148; +enum uint GL_DEBUG_OUTPUT = 0x92E0; +enum uint GL_CONTEXT_FLAG_DEBUG_BIT = 0x00000002; +enum uint GL_STACK_OVERFLOW = 0x0503; +enum uint GL_STACK_UNDERFLOW = 0x0504; +enum uint GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR = 0x8242; +enum uint GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = 0x8243; +enum uint GL_DEBUG_CALLBACK_FUNCTION_KHR = 0x8244; +enum uint GL_DEBUG_CALLBACK_USER_PARAM_KHR = 0x8245; +enum uint GL_DEBUG_SOURCE_API_KHR = 0x8246; +enum uint GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR = 0x8247; +enum uint GL_DEBUG_SOURCE_SHADER_COMPILER_KHR = 0x8248; +enum uint GL_DEBUG_SOURCE_THIRD_PARTY_KHR = 0x8249; +enum uint GL_DEBUG_SOURCE_APPLICATION_KHR = 0x824A; +enum uint GL_DEBUG_SOURCE_OTHER_KHR = 0x824B; +enum uint GL_DEBUG_TYPE_ERROR_KHR = 0x824C; +enum uint GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = 0x824D; +enum uint GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = 0x824E; +enum uint GL_DEBUG_TYPE_PORTABILITY_KHR = 0x824F; +enum uint GL_DEBUG_TYPE_PERFORMANCE_KHR = 0x8250; +enum uint GL_DEBUG_TYPE_OTHER_KHR = 0x8251; +enum uint GL_DEBUG_TYPE_MARKER_KHR = 0x8268; +enum uint GL_DEBUG_TYPE_PUSH_GROUP_KHR = 0x8269; +enum uint GL_DEBUG_TYPE_POP_GROUP_KHR = 0x826A; +enum uint GL_DEBUG_SEVERITY_NOTIFICATION_KHR = 0x826B; +enum uint GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826C; +enum uint GL_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826D; +enum uint GL_BUFFER_KHR = 0x82E0; +enum uint GL_SHADER_KHR = 0x82E1; +enum uint GL_PROGRAM_KHR = 0x82E2; +enum uint GL_VERTEX_ARRAY_KHR = 0x8074; +enum uint GL_QUERY_KHR = 0x82E3; +enum uint GL_PROGRAM_PIPELINE_KHR = 0x82E4; +enum uint GL_SAMPLER_KHR = 0x82E6; +enum uint GL_MAX_LABEL_LENGTH_KHR = 0x82E8; +enum uint GL_MAX_DEBUG_MESSAGE_LENGTH_KHR = 0x9143; +enum uint GL_MAX_DEBUG_LOGGED_MESSAGES_KHR = 0x9144; +enum uint GL_DEBUG_LOGGED_MESSAGES_KHR = 0x9145; +enum uint GL_DEBUG_SEVERITY_HIGH_KHR = 0x9146; +enum uint GL_DEBUG_SEVERITY_MEDIUM_KHR = 0x9147; +enum uint GL_DEBUG_SEVERITY_LOW_KHR = 0x9148; +enum uint GL_DEBUG_OUTPUT_KHR = 0x92E0; +enum uint GL_CONTEXT_FLAG_DEBUG_BIT_KHR = 0x00000002; +enum uint GL_STACK_OVERFLOW_KHR = 0x0503; +enum uint GL_STACK_UNDERFLOW_KHR = 0x0504; +enum uint GL_DISPLAY_LIST = 0x82E7; diff --git a/source/glad/gl/ext.d b/source/glad/gl/ext.d index ad03be6..7b161f9 100644 --- a/source/glad/gl/ext.d +++ b/source/glad/gl/ext.d @@ -4,7 +4,52 @@ module glad.gl.ext; private import glad.gl.types; private import glad.gl.enums; private import glad.gl.funcs; +bool GL_KHR_debug; nothrow @nogc extern(System) { +alias fp_glDebugMessageControl = void function(GLenum, GLenum, GLenum, GLsizei, const(GLuint)*, GLboolean); +alias fp_glDebugMessageInsert = void function(GLenum, GLenum, GLuint, GLenum, GLsizei, const(GLchar)*); +alias fp_glDebugMessageCallback = void function(GLDEBUGPROC, const(void)*); +alias fp_glGetDebugMessageLog = GLuint function(GLuint, GLsizei, GLenum*, GLenum*, GLuint*, GLenum*, GLsizei*, GLchar*); +alias fp_glPushDebugGroup = void function(GLenum, GLuint, GLsizei, const(GLchar)*); +alias fp_glPopDebugGroup = void function(); +alias fp_glObjectLabel = void function(GLenum, GLuint, GLsizei, const(GLchar)*); +alias fp_glGetObjectLabel = void function(GLenum, GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glObjectPtrLabel = void function(const(void)*, GLsizei, const(GLchar)*); +alias fp_glGetObjectPtrLabel = void function(const(void)*, GLsizei, GLsizei*, GLchar*); +alias fp_glGetPointerv = void function(GLenum, void**); +alias fp_glDebugMessageControlKHR = void function(GLenum, GLenum, GLenum, GLsizei, const(GLuint)*, GLboolean); +alias fp_glDebugMessageInsertKHR = void function(GLenum, GLenum, GLuint, GLenum, GLsizei, const(GLchar)*); +alias fp_glDebugMessageCallbackKHR = void function(GLDEBUGPROCKHR, const(void)*); +alias fp_glGetDebugMessageLogKHR = GLuint function(GLuint, GLsizei, GLenum*, GLenum*, GLuint*, GLenum*, GLsizei*, GLchar*); +alias fp_glPushDebugGroupKHR = void function(GLenum, GLuint, GLsizei, const(GLchar)*); +alias fp_glPopDebugGroupKHR = void function(); +alias fp_glObjectLabelKHR = void function(GLenum, GLuint, GLsizei, const(GLchar)*); +alias fp_glGetObjectLabelKHR = void function(GLenum, GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glObjectPtrLabelKHR = void function(const(void)*, GLsizei, const(GLchar)*); +alias fp_glGetObjectPtrLabelKHR = void function(const(void)*, GLsizei, GLsizei*, GLchar*); +alias fp_glGetPointervKHR = void function(GLenum, void**); } __gshared { +fp_glGetObjectLabelKHR glGetObjectLabelKHR; +fp_glGetDebugMessageLog glGetDebugMessageLog; +fp_glObjectLabel glObjectLabel; +fp_glGetObjectPtrLabelKHR glGetObjectPtrLabelKHR; +fp_glDebugMessageControlKHR glDebugMessageControlKHR; +fp_glGetObjectPtrLabel glGetObjectPtrLabel; +fp_glObjectLabelKHR glObjectLabelKHR; +fp_glGetObjectLabel glGetObjectLabel; +fp_glDebugMessageControl glDebugMessageControl; +fp_glDebugMessageInsert glDebugMessageInsert; +fp_glGetDebugMessageLogKHR glGetDebugMessageLogKHR; +fp_glGetPointervKHR glGetPointervKHR; +fp_glDebugMessageCallbackKHR glDebugMessageCallbackKHR; +fp_glPushDebugGroup glPushDebugGroup; +fp_glGetPointerv glGetPointerv; +fp_glPushDebugGroupKHR glPushDebugGroupKHR; +fp_glDebugMessageCallback glDebugMessageCallback; +fp_glDebugMessageInsertKHR glDebugMessageInsertKHR; +fp_glPopDebugGroupKHR glPopDebugGroupKHR; +fp_glObjectPtrLabel glObjectPtrLabel; +fp_glObjectPtrLabelKHR glObjectPtrLabelKHR; +fp_glPopDebugGroup glPopDebugGroup; } diff --git a/source/glad/gl/funcs.d b/source/glad/gl/funcs.d index 037ad38..28741e3 100644 --- a/source/glad/gl/funcs.d +++ b/source/glad/gl/funcs.d @@ -63,267 +63,8 @@ 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); @@ -335,22 +76,6 @@ 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)*); @@ -364,43 +89,6 @@ alias fp_glCompressedTexSubImage3D = void function(GLenum, GLint, GLint, GLint, 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); @@ -408,44 +96,6 @@ 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*); @@ -743,43 +393,21 @@ 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_glStencilMaskSeparate glStencilMaskSeparate; fp_glFramebufferRenderbuffer glFramebufferRenderbuffer; -fp_glRectdv glRectdv; fp_glCompressedTexSubImage3D glCompressedTexSubImage3D; -fp_glEvalCoord2d glEvalCoord2d; -fp_glEvalCoord2f glEvalCoord2f; -fp_glIndexd glIndexd; +fp_glTexCoordP3uiv glTexCoordP3uiv; 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_glVertexAttribIPointer glVertexAttribIPointer; 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; @@ -789,297 +417,151 @@ fp_glCopyTexSubImage2D glCopyTexSubImage2D; fp_glCompressedTexImage2D glCompressedTexImage2D; fp_glVertexAttrib1f glVertexAttrib1f; fp_glBlendFuncSeparate glBlendFuncSeparate; -fp_glVertex4fv glVertex4fv; -fp_glBindTexture glBindTexture; +fp_glHint glHint; 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_glVertexAttrib4Nuiv glVertexAttrib4Nuiv; fp_glRenderbufferStorage glRenderbufferStorage; +fp_glWaitSync glWaitSync; fp_glUniformMatrix4x3fv glUniformMatrix4x3fv; -fp_glColor3b glColor3b; +fp_glUniform3i glUniform3i; 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_glGetBufferParameteriv glGetBufferParameteriv; fp_glTexCoordP2ui glTexCoordP2ui; fp_glColorMaski glColorMaski; fp_glClearBufferfi glClearBufferfi; -fp_glTexCoord1iv glTexCoord1iv; -fp_glBlitFramebuffer glBlitFramebuffer; +fp_glGenVertexArrays glGenVertexArrays; 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_glVertexAttribI2i glVertexAttribI2i; 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_glDeleteVertexArrays glDeleteVertexArrays; 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_glGetAttribLocation glGetAttribLocation; 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_glGetUniformfv glGetUniformfv; fp_glGetUniformuiv glGetUniformuiv; -fp_glNormal3fv glNormal3fv; -fp_glSecondaryColor3s glSecondaryColor3s; -fp_glDepthRange glDepthRange; -fp_glFrustum glFrustum; -fp_glMultiTexCoord4sv glMultiTexCoord4sv; +fp_glGetVertexAttribIiv glGetVertexAttribIiv; fp_glDrawBuffer glDrawBuffer; -fp_glPushMatrix glPushMatrix; -fp_glRasterPos3fv glRasterPos3fv; -fp_glOrtho glOrtho; +fp_glClearBufferuiv glClearBufferuiv; 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_glGetActiveUniformBlockName glGetActiveUniformBlockName; fp_glUniform2i glUniform2i; -fp_glMapGrid2d glMapGrid2d; -fp_glMapGrid2f glMapGrid2f; +fp_glUniform2f glUniform2f; fp_glTexCoordP4ui glTexCoordP4ui; -fp_glVertex2i glVertex2i; +fp_glGetProgramiv glGetProgramiv; 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_glDeleteSamplers glDeleteSamplers; fp_glCopyTexImage2D glCopyTexImage2D; -fp_glTexEnvi glTexEnvi; -fp_glMultiTexCoord1iv glMultiTexCoord1iv; +fp_glBlitFramebuffer glBlitFramebuffer; 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_glPolygonOffset glPolygonOffset; 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_glDepthRange glDepthRange; 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_glCopyTexSubImage3D glCopyTexSubImage3D; 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_glDeleteBuffers glDeleteBuffers; 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_glUniform2ui glUniform2ui; fp_glVertexAttribI3i glVertexAttribI3i; fp_glClearDepth glClearDepth; fp_glVertexAttribI4usv glVertexAttribI4usv; @@ -1087,367 +569,189 @@ fp_glTexParameterf glTexParameterf; fp_glTexParameteri glTexParameteri; fp_glGetShaderSource glGetShaderSource; fp_glTexBuffer glTexBuffer; -fp_glPopName glPopName; +fp_glPixelStorei glPixelStorei; fp_glValidateProgram glValidateProgram; fp_glPixelStoref glPixelStoref; -fp_glUniform3uiv glUniform3uiv; -fp_glRasterPos4fv glRasterPos4fv; -fp_glEvalCoord1dv glEvalCoord1dv; +fp_glGetBooleani_v glGetBooleani_v; 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_glBindTexture glBindTexture; 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_glNormalP3ui glNormalP3ui; 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_glDrawElementsBaseVertex glDrawElementsBaseVertex; 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_glDrawElements glDrawElements; fp_glVertexAttribI4sv glVertexAttribI4sv; -fp_glSecondaryColor3us glSecondaryColor3us; -fp_glNormalP3ui glNormalP3ui; -fp_glTexEnvfv glTexEnvfv; +fp_glUniform1iv glUniform1iv; +fp_glGetQueryObjectiv glGetQueryObjectiv; 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_glVertexAttrib3f glVertexAttrib3f; +fp_glVertexAttrib4uiv glVertexAttrib4uiv; +fp_glPointParameteri glPointParameteri; +fp_glBlendColor glBlendColor; +fp_glSamplerParameterIuiv glSamplerParameterIuiv; fp_glUnmapBuffer glUnmapBuffer; -fp_glTexCoord2i glTexCoord2i; -fp_glRasterPos4d glRasterPos4d; -fp_glRasterPos4f glRasterPos4f; +fp_glPointParameterf glPointParameterf; 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_glUniformMatrix3fv glUniformMatrix3fv; 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_glGetShaderInfoLog glGetShaderInfoLog; 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_glGetInteger64v glGetInteger64v; fp_glScissor glScissor; fp_glTexCoordP4uiv glTexCoordP4uiv; -fp_glClipPlane glClipPlane; -fp_glPushName glPushName; -fp_glTexGendv glTexGendv; -fp_glIndexub glIndexub; +fp_glGetBooleanv glGetBooleanv; fp_glVertexP2uiv glVertexP2uiv; -fp_glSecondaryColor3iv glSecondaryColor3iv; -fp_glRasterPos4i glRasterPos4i; -fp_glMultTransposeMatrixd glMultTransposeMatrixd; +fp_glUniform3uiv glUniform3uiv; fp_glClearColor glClearColor; -fp_glVertexAttrib4uiv glVertexAttrib4uiv; -fp_glNormal3s glNormal3s; fp_glVertexAttrib4Niv glVertexAttrib4Niv; fp_glClearBufferiv glClearBufferiv; -fp_glPointParameteri glPointParameteri; +fp_glGetBufferParameteri64v glGetBufferParameteri64v; 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_glUniformMatrix2x3fv glUniformMatrix2x3fv; 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_glMultiTexCoordP1ui glMultiTexCoordP1ui; 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_glUniform4fv glUniform4fv; 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_glDrawRangeElementsBaseVertex glDrawRangeElementsBaseVertex; fp_glCheckFramebufferStatus glCheckFramebufferStatus; -fp_glTexCoord1d glTexCoord1d; -fp_glTexCoord1f glTexCoord1f; fp_glEndConditionalRender glEndConditionalRender; -fp_glEnableClientState glEnableClientState; +fp_glVertexP3uiv glVertexP3uiv; fp_glBindAttribLocation glBindAttribLocation; fp_glUniformMatrix4x2fv glUniformMatrix4x2fv; -fp_glMultiTexCoord2sv glMultiTexCoord2sv; fp_glVertexAttrib1dv glVertexAttrib1dv; fp_glDrawRangeElements glDrawRangeElements; -fp_glTexCoord1s glTexCoord1s; +fp_glGetQueryObjectuiv glGetQueryObjectuiv; 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_glDeleteRenderbuffers glDeleteRenderbuffers; fp_glVertexAttribI3uiv glVertexAttribI3uiv; -fp_glClearAccum glClearAccum; fp_glGetSynciv glGetSynciv; fp_glTexCoordP2uiv glTexCoordP2uiv; -fp_glUniform2f glUniform2f; fp_glBeginQuery glBeginQuery; -fp_glGetUniformBlockIndex glGetUniformBlockIndex; +fp_glUniformMatrix4fv glUniformMatrix4fv; fp_glBindBuffer glBindBuffer; -fp_glMap2d glMap2d; -fp_glMap2f glMap2f; -fp_glVertex4d glVertex4d; fp_glUniformMatrix2fv glUniformMatrix2fv; -fp_glTexCoord1sv glTexCoord1sv; +fp_glUniformMatrix2x4fv glUniformMatrix2x4fv; 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_glVertexAttribI1i glVertexAttribI1i; 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_glFramebufferTexture3D glFramebufferTexture3D; 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_glSamplerParameterfv glSamplerParameterfv; fp_glIsTexture glIsTexture; -fp_glGetMaterialiv glGetMaterialiv; fp_glUniform1fv glUniform1fv; -fp_glLoadMatrixf glLoadMatrixf; -fp_glLoadMatrixd glLoadMatrixd; +fp_glVertexAttrib4Nubv glVertexAttrib4Nubv; 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_glGetSamplerParameteriv glGetSamplerParameteriv; fp_glCopyBufferSubData glCopyBufferSubData; fp_glVertexAttribI1uiv glVertexAttribI1uiv; fp_glVertexAttrib2d glVertexAttrib2d; @@ -1456,13 +760,9 @@ 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_glGetUniformBlockIndex glGetUniformBlockIndex; +fp_glTexImage2DMultisample glTexImage2DMultisample; 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 index 2659e44..96e79a1 100644 --- a/source/glad/gl/gl.d +++ b/source/glad/gl/gl.d @@ -3,402 +3,268 @@ 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; +glMultiTexCoordP2uiv, glCopyTexImage1D, glVertexAttribI3ui, glStencilMaskSeparate, glVertexAttribP1uiv, +glLinkProgram, glHint, glGetUniformiv, glFramebufferRenderbuffer, glGetString, +glVertexAttribP2uiv, glCompressedTexSubImage3D, glDetachShader, glTexCoordP3uiv, glVertexAttrib1sv, +glBindSampler, glLineWidth, glColorP3uiv, glGetIntegeri_v, glVertexAttribI2ui, +glCompileShader, glGetTransformFeedbackVarying, glColorMask, glDeleteTextures, glStencilOpSeparate, +glCopyBufferSubData, glDeleteQueries, glNormalP3uiv, glVertexAttrib4f, glUniformMatrix3x4fv, +glGetBufferParameteri64v, glVertexAttribIPointer, glMultiTexCoordP3ui, glBeginConditionalRender, glDrawElementsBaseVertex, +glVertexP4ui, glEnablei, glSampleCoverage, glSamplerParameteri, glSamplerParameterf, +glUniform1f, glGetVertexAttribfv, glGetCompressedTexImage, glVertexAttribP4ui, glCreateShader, +glIsBuffer, glGetMultisamplefv, glGenRenderbuffers, glCopyTexSubImage2D, glCompressedTexImage2D, +glVertexAttrib1f, glVertexP3ui, glBlendFuncSeparate, glLogicOp, glDrawBuffers, +glVertexAttrib1s, glUniform4ui, glSampleMaski, glVertexP2ui, glBindFramebuffer, +glCullFace, glUniformMatrix3x2fv, glPointSize, glVertexAttribI2uiv, glVertexAttrib2dv, +glDeleteProgram, glVertexAttrib4Nuiv, glRenderbufferStorage, glWaitSync, glAttachShader, +glUniformMatrix4x3fv, glUniform3i, glClearBufferfv, glQueryCounter, glProvokingVertex, +glUniform3f, glVertexAttrib4ubv, glGetBufferParameteriv, glTexCoordP2ui, glDrawElements, +glColorMaski, glClearBufferfi, glGenVertexArrays, glVertexAttribI4sv, glMultiTexCoordP2ui, +glGetQueryObjectiv, glGetSamplerParameterIiv, glGetFragDataIndex, glSecondaryColorP3uiv, glTexParameterIuiv, +glDrawArraysInstanced, glMultiDrawArrays, glGenerateMipmap, glGetVertexAttribdv, glSamplerParameteriv, +glVertexAttrib3f, glVertexAttrib4uiv, glVertexAttrib3d, glBlendColor, glSamplerParameterIuiv, +glUnmapBuffer, glPointParameterf, glMultiTexCoordP4ui, glVertexAttribI4iv, glEndQuery, +glBindRenderbuffer, glDeleteFramebuffers, glDrawArrays, glUniform1ui, glIsProgram, +glVertexAttrib4bv, glTexCoordP1ui, glVertexAttribI2i, glClear, glVertexAttrib4fv, +glGetActiveUniformName, glUniform4i, glActiveTexture, glEnableVertexAttribArray, glDrawRangeElements, +glBindTexture, glIsEnabled, glStencilOp, glReadPixels, glVertexAttribI3iv, +glUniform4f, glFramebufferTexture2D, glGetFramebufferAttachmentParameteriv, glVertexAttrib4Nub, glUniformMatrix3fv, +glGetFragDataLocation, glTexImage1D, glDrawElementsInstancedBaseVertex, glTexParameteriv, glGetTexImage, +glGetTexLevelParameterfv, glUniform1iv, glGetQueryObjecti64v, glGenFramebuffers, glStencilFunc, +glGetAttachedShaders, glUniformBlockBinding, glIsRenderbuffer, glDeleteVertexArrays, glMapBufferRange, +glVertexAttrib4Nubv, glIsVertexArray, glDisableVertexAttribArray, glReadBuffer, glGetQueryiv, +glGetSamplerParameterfv, glGetShaderInfoLog, glGetUniformIndices, glIsShader, glVertexAttribI4ubv, +glGetInteger64v, glVertexAttribI4i, glPointParameteriv, glDisable, glGetBufferSubData, +glBindAttribLocation, glEnable, glGetActiveUniformsiv, glBindBufferRange, glTexParameterfv, +glBlendEquationSeparate, glVertexAttribI1ui, glGenBuffers, glGetAttribLocation, glVertexAttrib4dv, +glTexCoordP1uiv, glVertexAttrib2fv, glBlendFunc, glCreateProgram, glTexImage3D, +glMultiTexCoordP3uiv, glVertexAttribP3ui, glIsFramebuffer, glPrimitiveRestartIndex, glGetUniformfv, +glGetUniformuiv, glGetVertexAttribIiv, glDrawBuffer, glColorP4ui, glClearBufferuiv, +glDrawElementsInstanced, glVertexAttrib4d, glGetBooleanv, glVertexP2uiv, glGetTexParameteriv, +glFlush, glGetRenderbufferParameteriv, glClearColor, glVertexAttribI2iv, glGetUniformBlockIndex, +glVertexAttrib4Niv, glClearBufferiv, glPointParameteri, glGetVertexAttribPointerv, glColorP4uiv, +glGetStringi, glFenceSync, glUniform3ui, glColorP3ui, glVertexAttrib3sv, +glVertexAttrib4s, glVertexAttribI4uiv, glGetTexLevelParameteriv, glUniform2fv, glMultiTexCoordP4uiv, +glGetSamplerParameterIuiv, glStencilFuncSeparate, glTexCoordP3ui, glGenSamplers, glClampColor, +glUniform4iv, glClearStencil, glVertexAttrib2sv, glUniformMatrix2x3fv, glGetVertexAttribIuiv, +glVertexAttrib4Nusv, glGenTextures, glDepthFunc, glCompressedTexSubImage2D, glGetTexParameterIuiv, +glVertexAttribI4bv, glVertexAttrib4Nbv, glGetTexParameterfv, glMultiTexCoordP1ui, glVertexAttrib3s, +glIsSync, glGetActiveUniformBlockName, glClientWaitSync, glUniform2i, glUniform2f, +glShaderSource, glGetProgramiv, glVertexAttribPointer, glFramebufferTextureLayer, glTexParameterIiv, +glBlendEquation, glGetUniformLocation, glGetSamplerParameteriv, glEndTransformFeedback, glFlushMappedBufferRange, +glVertexAttrib4usv, glUniform4fv, glBeginTransformFeedback, glVertexAttribI1iv, glIsSampler, +glVertexAttribP4uiv, glVertexAttribDivisor, glGenQueries, glCompressedTexImage1D, glVertexAttribP1ui, +glCopyTexSubImage1D, glDrawRangeElementsBaseVertex, glCheckFramebufferStatus, glTexSubImage3D, glGetInteger64i_v, +glDeleteSamplers, glCopyTexImage2D, glVertexP3uiv, glBlitFramebuffer, glIsEnabledi, +glUniformMatrix4x2fv, glSecondaryColorP3ui, glBindFragDataLocationIndexed, glVertexAttrib1dv, glUniform2iv, +glGetQueryObjectuiv, glSamplerParameterIiv, glBufferSubData, glVertexAttrib4iv, glUniform4uiv, +glFramebufferTexture, glUniform1i, glFramebufferTexture1D, glGetShaderiv, glVertexP4uiv, +glGetActiveAttrib, glBindFragDataLocation, glVertexAttrib2d, glPolygonOffset, glDisablei, +glGetDoublev, glTexCoordP4ui, glVertexAttrib1d, glVertexAttribI3uiv, glTexSubImage2D, +glGetSynciv, glVertexAttrib1fv, glTexCoordP2uiv, glVertexAttribI4ui, glTexImage2DMultisample, +glBeginQuery, glMultiTexCoordP1uiv, glUniform3fv, glDepthRange, glMapBuffer, +glUniformMatrix2x4fv, glBindBuffer, glBufferData, glGetTexParameterIiv, glCompressedTexImage3D, +glDeleteSync, glCopyTexSubImage3D, glGetError, glDeleteRenderbuffers, glGetVertexAttribiv, +glMultiDrawElements, glVertexAttrib3fv, glGetFloatv, glTexSubImage1D, glUniform3iv, +glNormalP3ui, glPolygonMode, glVertexAttribI1i, glVertexAttribP3uiv, glGetActiveUniformBlockiv, +glGetIntegerv, glGetBufferPointerv, glFramebufferTexture3D, glRenderbufferStorageMultisample, glIsQuery, +glUniformMatrix2fv, glUseProgram, glVertexAttrib4sv, glTexImage2D, glGetProgramInfoLog, +glStencilMask, glSamplerParameterfv, glBindVertexArray, glIsTexture, glUniform1fv, +glDeleteBuffers, glMultiDrawElementsBaseVertex, glEndConditionalRender, glScissor, glTexCoordP4uiv, +glUniform2uiv, glCompressedTexSubImage1D, glFinish, glDeleteShader, glPointParameterfv, +glVertexAttrib4Nsv, glViewport, glBindBufferBase, glVertexAttribI1uiv, glUniform1uiv, +glTransformFeedbackVaryings, glVertexAttrib2f, glVertexAttrib3dv, glGetQueryObjectui64v, glUniform2ui, +glDepthMask, glVertexAttribI3i, glVertexAttrib2s, glTexImage3DMultisample, glUniformMatrix4fv, +glClearDepth, glGetActiveUniform, glVertexAttribI4usv, glTexParameterf, glTexParameteri, +glFrontFace, glGetShaderSource, glTexBuffer, glPixelStorei, glValidateProgram, +glPixelStoref, glUniform3uiv, glVertexAttribP2ui, glGetBooleani_v; + +public import glad.gl.ext : +glObjectPtrLabel, glGetDebugMessageLog, glPushDebugGroup, glDebugMessageCallbackKHR, glObjectLabelKHR, +glGetObjectPtrLabelKHR, glGetPointerv, glDebugMessageControlKHR, glGetObjectPtrLabel, glObjectLabel, +glDebugMessageCallback, glDebugMessageInsertKHR, glPopDebugGroupKHR, glGetObjectLabel, glDebugMessageControl, +glDebugMessageInsert, glObjectPtrLabelKHR, glGetObjectLabelKHR, glPopDebugGroup, glPushDebugGroupKHR, +glGetDebugMessageLogKHR, glGetPointervKHR; 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_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GL_UNSIGNED_INT_VEC2, GL_UNSIGNED_INT_VEC3, GL_UNSIGNED_INT_VEC4, +GL_UNSIGNED_SHORT_5_6_5, GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_DEPTH_ATTACHMENT, GL_DITHER, GL_RGB16UI, +GL_QUERY_RESULT, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, GL_FLOAT_VEC2, GL_FLOAT_VEC3, +GL_R16_SNORM, GL_FLOAT_VEC4, GL_FLOAT, GL_RGB32UI, GL_TEXTURE_MAX_LOD, +GL_BUFFER_MAP_OFFSET, GL_MIN_PROGRAM_TEXEL_OFFSET, GL_BUFFER_SIZE, GL_RGB16_SNORM, GL_SAMPLER_2D_RECT, +GL_RGB9_E5, GL_UNIFORM_BUFFER_START, GL_TEXTURE_COMPRESSED, GL_TEXTURE_COMPRESSION_HINT, GL_RGBA32UI, +GL_UNSIGNED_INT_SAMPLER_2D, GL_VERTEX_ARRAY_KHR, GL_TEXTURE_MIN_LOD, GL_DEBUG_TYPE_OTHER_KHR, GL_TEXTURE9, +GL_MAX_VARYING_FLOATS, GL_TEXTURE4, GL_TEXTURE5, GL_TEXTURE6, GL_TEXTURE7, +GL_TEXTURE0, GL_LINEAR_MIPMAP_LINEAR, GL_TEXTURE2, GL_TEXTURE3, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, +GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_DOUBLE, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_BYTE, GL_BOOL_VEC3, +GL_BOOL_VEC2, GL_TIMEOUT_IGNORED, GL_RENDERBUFFER_SAMPLES, GL_ONE, GL_RG, +GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_COLOR_CLEAR_VALUE, GL_MAX_SAMPLES, GL_DEPTH_WRITEMASK, GL_DEBUG_SOURCE_THIRD_PARTY, +GL_UNPACK_IMAGE_HEIGHT, GL_GREEN_INTEGER, GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR, GL_TEXTURE_DEPTH_SIZE, GL_FLOAT_MAT3x2, +GL_TRIANGLE_STRIP, GL_NOOP, GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_FLOAT_MAT3x4, GL_CONTEXT_FLAGS, +GL_FRONT_LEFT, GL_COLOR_ATTACHMENT28, GL_COLOR_ATTACHMENT29, GL_DEBUG_SEVERITY_NOTIFICATION, 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 -; +GL_COMPRESSED_RGBA, GL_COLOR_ATTACHMENT23, GL_RGBA32I, GL_TRANSFORM_FEEDBACK_BUFFER, GL_QUERY_WAIT, +GL_UNSIGNED_SHORT_5_5_5_1, GL_TIMEOUT_EXPIRED, GL_QUERY_NO_WAIT, GL_PROVOKING_VERTEX, GL_UNPACK_SWAP_BYTES, +GL_STENCIL_FUNC, GL_MAX_TEXTURE_LOD_BIAS, GL_ALIASED_LINE_WIDTH_RANGE, GL_LINE_STRIP_ADJACENCY, GL_POINT_SIZE, +GL_INVERT, GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR, GL_TEXTURE_COMPARE_FUNC, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, GL_RGB12, +GL_INT, GL_RGB10, GL_RGB16, GL_DEBUG_TYPE_POP_GROUP, GL_CLIP_DISTANCE1, +GL_BGRA, GL_POLYGON_OFFSET_FILL, GL_CLIP_DISTANCE2, GL_CLIP_DISTANCE5, GL_CLIP_DISTANCE4, +GL_CLIP_DISTANCE7, GL_CLIP_DISTANCE6, GL_DOUBLEBUFFER, GL_FRONT_AND_BACK, GL_R8, +GL_POINT, GL_RGB_INTEGER, GL_BUFFER_KHR, GL_STENCIL_CLEAR_VALUE, GL_SRGB, +GL_SYNC_FENCE, GL_ONE_MINUS_CONSTANT_COLOR, GL_UNSIGNED_INT_8_8_8_8, GL_SHADING_LANGUAGE_VERSION, GL_TEXTURE_BUFFER_DATA_STORE_BINDING, +GL_RGB8_SNORM, GL_TEXTURE_ALPHA_SIZE, GL_DEBUG_LOGGED_MESSAGES, GL_DEBUG_GROUP_STACK_DEPTH_KHR, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, +GL_FRAGMENT_SHADER, GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, GL_FRAGMENT_SHADER_DERIVATIVE_HINT, +GL_TEXTURE_DEPTH, GL_STENCIL_BACK_REF, GL_DEBUG_OUTPUT, GL_NO_ERROR, GL_VIEWPORT, +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GL_BLEND_SRC_ALPHA, GL_DRAW_BUFFER6, GL_DRAW_BUFFER7, GL_DRAW_BUFFER4, +GL_DRAW_BUFFER5, GL_DRAW_BUFFER2, GL_DRAW_BUFFER3, GL_AND_REVERSE, GL_DRAW_BUFFER1, +GL_RENDERBUFFER, GL_MAX_LABEL_LENGTH_KHR, GL_COPY, GL_QUERY_RESULT_AVAILABLE, GL_MAX_DEBUG_MESSAGE_LENGTH, +GL_DRAW_BUFFER9, GL_MAX_DRAW_BUFFERS, GL_KEEP, GL_VERTEX_ARRAY_BINDING, GL_ONE_MINUS_DST_ALPHA, +GL_TEXTURE_CUBE_MAP_SEAMLESS, GL_R32UI, GL_RGBA8_SNORM, GL_FILL, GL_INT_SAMPLER_3D, +GL_DEBUG_TYPE_PUSH_GROUP_KHR, GL_SRC_COLOR, GL_SAMPLER_BINDING, GL_AND, GL_DEPTH24_STENCIL8, +GL_SAMPLE_BUFFERS, GL_SAMPLER_CUBE, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, GL_MAJOR_VERSION, GL_STATIC_COPY, +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_EXTENSIONS, GL_BGR_INTEGER, GL_PROXY_TEXTURE_RECTANGLE, GL_UPPER_LEFT, +GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_TYPE, GL_RENDERBUFFER_BLUE_SIZE, GL_TEXTURE_COMPARE_MODE, GL_ANY_SAMPLES_PASSED, +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GL_DEBUG_TYPE_ERROR, GL_DEPTH_BUFFER_BIT, GL_STENCIL_BACK_PASS_DEPTH_FAIL, GL_DEBUG_CALLBACK_USER_PARAM_KHR, +GL_UNIFORM_BUFFER, GL_MAP_WRITE_BIT, GL_SMOOTH_POINT_SIZE_RANGE, GL_SAMPLE_MASK, GL_CCW, +GL_FRONT_RIGHT, GL_RGB32I, GL_MAP_INVALIDATE_BUFFER_BIT, GL_DEPTH_COMPONENT24, GL_UNSIGNED_INT_5_9_9_9_REV, +GL_DEPTH_TEST, GL_SYNC_GPU_COMMANDS_COMPLETE, GL_SAMPLER_KHR, GL_UNSIGNED_INT_SAMPLER_BUFFER, GL_VERTEX_ATTRIB_ARRAY_INTEGER, +GL_DEBUG_SOURCE_THIRD_PARTY_KHR, GL_MULTISAMPLE, GL_MAX_GEOMETRY_OUTPUT_VERTICES, GL_MAX_VERTEX_UNIFORM_BLOCKS, GL_ONE_MINUS_SRC1_COLOR, +GL_STREAM_READ, GL_LINEAR, GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_FUNC_SUBTRACT, GL_R32F, +GL_VERTEX_ARRAY, GL_OR_REVERSE, GL_MAX_VARYING_COMPONENTS, GL_SAMPLER_BUFFER, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, +GL_CLAMP_TO_BORDER, GL_UNSIGNED_SHORT_5_6_5_REV, GL_COLOR_ATTACHMENT14, GL_COLOR_ATTACHMENT17, GL_DEPTH_RANGE, +GL_GREATER, GL_CLAMP_TO_EDGE, GL_COLOR_ATTACHMENT13, GL_COLOR_ATTACHMENT12, GL_NEAREST, +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, GL_COMPRESSED_TEXTURE_FORMATS, GL_COLOR_ATTACHMENT19, GL_TEXTURE21, GL_MAX_TEXTURE_IMAGE_UNITS, +GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR, GL_FLOAT_MAT2, GL_FLOAT_MAT3, GL_FRONT_FACE, GL_DEPTH, +GL_SHADER, GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, +GL_SAMPLER_2D_RECT_SHADOW, GL_STACK_OVERFLOW_KHR, GL_TEXTURE30, GL_TEXTURE31, GL_RG8I, +GL_UNSIGNED_INT_SAMPLER_1D, GL_RGBA8I, GL_DEBUG_SEVERITY_NOTIFICATION_KHR, GL_DEPTH_CLEAR_VALUE, GL_GEOMETRY_INPUT_TYPE, +GL_BACK_LEFT, GL_BUFFER_MAP_POINTER, GL_LINE_SMOOTH, GL_RENDERBUFFER_BINDING, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, +GL_QUERY, GL_QUERY_COUNTER_BITS, GL_MAX_3D_TEXTURE_SIZE, GL_COPY_WRITE_BUFFER, GL_BLEND, +GL_DEBUG_SEVERITY_HIGH, GL_R16UI, GL_TEXTURE_BINDING_3D, GL_UNSIGNED_SHORT, GL_MIN, +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER, GL_COMPRESSED_SRGB_ALPHA, GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DELETE_STATUS, +GL_TEXTURE, GL_TEXTURE8, GL_PROXY_TEXTURE_1D_ARRAY, GL_MAX_CLIP_DISTANCES, GL_DEBUG_SOURCE_SHADER_COMPILER_KHR, +GL_DEBUG_SOURCE_SHADER_COMPILER, GL_PIXEL_PACK_BUFFER_BINDING, GL_MAX_DEBUG_GROUP_STACK_DEPTH, GL_TIMESTAMP, GL_COLOR_BUFFER_BIT, +GL_DONT_CARE, GL_ACTIVE_UNIFORMS, GL_VERTEX_PROGRAM_POINT_SIZE, GL_TEXTURE_BINDING_CUBE_MAP, GL_SAMPLER_2D, +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, GL_SRGB_ALPHA, GL_DRAW_BUFFER12, GL_NEAREST_MIPMAP_NEAREST, GL_NUM_COMPRESSED_TEXTURE_FORMATS, +GL_PACK_SKIP_ROWS, GL_TEXTURE_MAG_FILTER, GL_STENCIL_INDEX1, GL_TEXTURE1, GL_BLEND_EQUATION_RGB, +GL_CONTEXT_COMPATIBILITY_PROFILE_BIT, GL_LINK_STATUS, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, GL_TEXTURE_MAX_LEVEL, GL_R32I, +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, GL_BLEND_COLOR, GL_BOOL_VEC4, GL_PROGRAM_PIPELINE_KHR, GL_ONE_MINUS_CONSTANT_ALPHA, +GL_NEAREST_MIPMAP_LINEAR, GL_INT_2_10_10_10_REV, GL_SAMPLER_CUBE_SHADOW, GL_LEFT, GL_AND_INVERTED, +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, GL_CULL_FACE, GL_WAIT_FAILED, GL_SAMPLER_1D, GL_LINE, +GL_POLYGON_OFFSET_POINT, GL_INT_SAMPLER_1D_ARRAY, GL_MAX_TEXTURE_SIZE, GL_RG32F, GL_DEBUG_TYPE_MARKER, +GL_DEBUG_OUTPUT_KHR, GL_SAMPLES_PASSED, GL_ARRAY_BUFFER, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT16, +GL_RENDERBUFFER_RED_SIZE, GL_MAX_SAMPLE_MASK_WORDS, GL_UNSIGNALED, GL_BLUE_INTEGER, GL_RGBA16_SNORM, +GL_TEXTURE_1D, GL_BLEND_SRC_RGB, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, GL_BGRA_INTEGER, GL_PROXY_TEXTURE_2D_MULTISAMPLE, +GL_SYNC_FLAGS, GL_FALSE, GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, GL_ONE_MINUS_SRC_ALPHA, GL_RG32I, +GL_UNSIGNED_BYTE_2_3_3_REV, GL_SAMPLE_ALPHA_TO_ONE, GL_RENDERBUFFER_INTERNAL_FORMAT, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_TEXTURE_HEIGHT, +GL_PROGRAM_POINT_SIZE, GL_RGBA16I, GL_R8I, GL_STENCIL_INDEX8, GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER, +GL_SAMPLE_ALPHA_TO_COVERAGE, GL_INT_SAMPLER_2D, GL_SAMPLER_2D_MULTISAMPLE, GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, GL_STENCIL_PASS_DEPTH_FAIL, +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR, GL_RED, GL_POLYGON_OFFSET_LINE, GL_FUNC_REVERSE_SUBTRACT, GL_RGBA8UI, +GL_COLOR_ATTACHMENT15, GL_GREEN, GL_INVALID_OPERATION, GL_MAX_RECTANGLE_TEXTURE_SIZE, GL_FIXED_ONLY, +GL_CLAMP_READ_COLOR, GL_RED_INTEGER, GL_NONE, GL_POLYGON_MODE, GL_COLOR_ATTACHMENT5, +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, GL_COLOR_ATTACHMENT7, GL_UNIFORM_BLOCK_NAME_LENGTH, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT0, +GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT2, GL_BACK, GL_FRAMEBUFFER_DEFAULT, GL_COLOR_ATTACHMENT9, +GL_COLOR_ATTACHMENT8, GL_LINE_SMOOTH_HINT, GL_COLOR_ATTACHMENT10, GL_PACK_IMAGE_HEIGHT, GL_NAND, +GL_UNIFORM_BLOCK_DATA_SIZE, GL_BUFFER_USAGE, GL_DEBUG_TYPE_PERFORMANCE, GL_CULL_FACE_MODE, GL_UNSIGNED_INT_8_8_8_8_REV, +GL_RG32UI, GL_CONTEXT_FLAG_DEBUG_BIT_KHR, GL_NUM_EXTENSIONS, GL_UNIFORM_IS_ROW_MAJOR, GL_MAX_UNIFORM_BLOCK_SIZE, +GL_BOOL, GL_MAX_COMBINED_UNIFORM_BLOCKS, GL_FRAMEBUFFER_BINDING, GL_RGB32F, GL_ALPHA, +GL_SET, GL_COLOR_WRITEMASK, GL_DST_COLOR, GL_UNSIGNED_INT_SAMPLER_1D_ARRAY, GL_UNSIGNED_INT, +GL_DEPTH_FUNC, GL_TEXTURE_WRAP_R, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_DST_ALPHA, +GL_UNIFORM_BLOCK_BINDING, GL_STENCIL_BACK_VALUE_MASK, GL_INT_SAMPLER_2D_ARRAY, GL_POINT_SPRITE_COORD_ORIGIN, GL_POINT_SIZE_RANGE, +GL_COMPRESSED_RGB, GL_TIME_ELAPSED, GL_DEPTH_COMPONENT, GL_SRC1_COLOR, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, +GL_BLEND_SRC, GL_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_RECTANGLE, GL_SHADER_TYPE, GL_RG16_SNORM, +GL_COMPARE_REF_TO_TEXTURE, GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, GL_TRUE, GL_TEXTURE_MIN_FILTER, +GL_FLOAT_MAT4, GL_STACK_UNDERFLOW, GL_RG_INTEGER, GL_TEXTURE_SWIZZLE_R, GL_PACK_SWAP_BYTES, +GL_EQUAL, GL_TEXTURE_SWIZZLE_G, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_HEIGHT, GL_RG16UI, +GL_TEXTURE_BINDING_1D_ARRAY, GL_INTERLEAVED_ATTRIBS, GL_TEXTURE_ALPHA_TYPE, GL_TEXTURE_BINDING_2D_MULTISAMPLE, GL_DEBUG_TYPE_ERROR_KHR, +GL_LINE_WIDTH_GRANULARITY, GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH, GL_COMPRESSED_RED_RGTC1, GL_BLUE, GL_DRAW_BUFFER14, +GL_SHADER_SOURCE_LENGTH, GL_POINT_FADE_THRESHOLD_SIZE, GL_INT_SAMPLER_BUFFER, GL_COLOR_ATTACHMENT6, GL_VERTEX_ATTRIB_ARRAY_POINTER, +GL_TEXTURE_BLUE_TYPE, GL_UNPACK_ALIGNMENT, GL_COMPILE_STATUS, GL_STEREO, GL_PROGRAM, +GL_ALREADY_SIGNALED, GL_LINE_STRIP, GL_STREAM_COPY, GL_PACK_ROW_LENGTH, GL_BUFFER, +GL_TEXTURE_CUBE_MAP, GL_COLOR_ATTACHMENT22, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, GL_COLOR, GL_INT_SAMPLER_2D_RECT, +GL_TRIANGLE_STRIP_ADJACENCY, GL_RENDERBUFFER_DEPTH_SIZE, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_DYNAMIC_READ, GL_TEXTURE_BUFFER, +GL_TEXTURE_BINDING_RECTANGLE, GL_DEPTH_STENCIL, GL_DEBUG_SOURCE_APPLICATION_KHR, GL_UNPACK_SKIP_PIXELS, GL_RG8UI, +GL_MAX_VERTEX_OUTPUT_COMPONENTS, GL_POINTS, GL_SYNC_STATUS, GL_READ_WRITE, GL_PROXY_TEXTURE_2D, +GL_UNIFORM_NAME_LENGTH, GL_FASTEST, GL_SYNC_CONDITION, GL_FRONT, GL_HALF_FLOAT, +GL_TEXTURE_RED_TYPE, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, GL_SCISSOR_BOX, GL_OR, GL_MAP_INVALIDATE_RANGE_BIT, +GL_TEXTURE23, GL_TEXTURE22, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER, 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_TEXTURE_COMPRESSED_IMAGE_SIZE, GL_PRIMITIVE_RESTART_INDEX, +GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TRIANGLES_ADJACENCY, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_LINE_LOOP, GL_REPLACE, +GL_DEBUG_SEVERITY_LOW, GL_READ_BUFFER, GL_MAP_FLUSH_EXPLICIT_BIT, GL_PACK_SKIP_PIXELS, GL_BACK_RIGHT, +GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, GL_RGBA, GL_DEBUG_SOURCE_WINDOW_SYSTEM, GL_R16F, GL_RIGHT, +GL_DEBUG_SOURCE_APPLICATION, GL_DISPLAY_LIST, GL_GEQUAL, GL_R3_G3_B2, GL_DEBUG_OUTPUT_SYNCHRONOUS, +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, GL_LINE_WIDTH, GL_UNIFORM_OFFSET, GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_LEQUAL, +GL_UNSIGNED_INT_SAMPLER_CUBE, GL_TEXTURE_WIDTH, GL_ONE_MINUS_SRC1_ALPHA, GL_COLOR_ATTACHMENT4, GL_UNIFORM_SIZE, +GL_DEPTH_CLAMP, GL_SRC1_ALPHA, GL_FUNC_ADD, GL_FLOAT_MAT4x2, GL_FLOAT_MAT4x3, +GL_BUFFER_ACCESS, GL_UNSIGNED_BYTE, GL_VERSION, GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR, GL_SIGNED_NORMALIZED, +GL_CURRENT_VERTEX_ATTRIB, GL_ARRAY_BUFFER_BINDING, GL_TEXTURE_2D, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_DYNAMIC_DRAW, +GL_OUT_OF_MEMORY, GL_LINES_ADJACENCY, GL_NICEST, GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, GL_UNSIGNED_SHORT_4_4_4_4_REV, +GL_UNPACK_ROW_LENGTH, GL_CURRENT_PROGRAM, GL_QUERY_KHR, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, GL_GEOMETRY_OUTPUT_TYPE, +GL_RASTERIZER_DISCARD, GL_RENDERBUFFER_GREEN_SIZE, GL_DEBUG_TYPE_PUSH_GROUP, GL_STREAM_DRAW, GL_POLYGON_SMOOTH_HINT, +GL_DEBUG_SEVERITY_MEDIUM, GL_MAX_UNIFORM_BUFFER_BINDINGS, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, GL_SIGNALED, GL_PIXEL_PACK_BUFFER, +GL_FRAMEBUFFER, GL_INT_SAMPLER_2D_MULTISAMPLE, GL_STENCIL_TEST, GL_R16, GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION, +GL_R11F_G11F_B10F, GL_SRGB8, GL_MAX_SERVER_WAIT_TIMEOUT, GL_BUFFER_MAPPED, GL_DEBUG_CALLBACK_USER_PARAM, +GL_PIXEL_UNPACK_BUFFER_BINDING, GL_DECR, GL_PROXY_TEXTURE_1D, GL_STENCIL_BACK_FAIL, GL_POLYGON_OFFSET_FACTOR, +GL_MAX_LABEL_LENGTH, GL_DEBUG_TYPE_PORTABILITY, GL_DEBUG_GROUP_STACK_DEPTH, GL_DEPTH_COMPONENT32F, GL_TRIANGLE_FAN, +GL_PROGRAM_KHR, GL_COMPRESSED_RG, GL_DRAW_FRAMEBUFFER_BINDING, GL_MAX_ELEMENTS_VERTICES, GL_STENCIL_BACK_WRITEMASK, +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, GL_INVALID_FRAMEBUFFER_OPERATION, GL_BUFFER_ACCESS_FLAGS, GL_UNIFORM_BUFFER_SIZE, GL_TEXTURE_BINDING_BUFFER, +GL_TRIANGLES, GL_SAMPLER_2D_ARRAY_SHADOW, GL_DEPTH32F_STENCIL8, GL_MAX_ARRAY_TEXTURE_LAYERS, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, +GL_UNIFORM_MATRIX_STRIDE, GL_MAX_DEPTH_TEXTURE_SAMPLES, GL_MAX_DEBUG_MESSAGE_LENGTH_KHR, GL_QUERY_BY_REGION_WAIT, GL_NOR, +GL_SRGB8_ALPHA8, GL_RGBA16F, GL_DEBUG_CALLBACK_FUNCTION_KHR, GL_TRANSFORM_FEEDBACK_VARYINGS, GL_PACK_ALIGNMENT, +GL_DEBUG_CALLBACK_FUNCTION, GL_DEBUG_TYPE_POP_GROUP_KHR, GL_SAMPLER_2D_ARRAY, GL_RENDERER, GL_UNPACK_LSB_FIRST, +GL_MAX_COLOR_ATTACHMENTS, GL_CLIP_DISTANCE0, GL_ACTIVE_UNIFORM_BLOCKS, GL_CLIP_DISTANCE3, GL_UNPACK_SKIP_IMAGES, +GL_PROGRAM_PIPELINE, GL_STENCIL_BACK_FUNC, GL_RGB16I, GL_STACK_UNDERFLOW_KHR, GL_ACTIVE_TEXTURE, +GL_TEXTURE_BASE_LEVEL, GL_RGB16F, GL_SMOOTH_LINE_WIDTH_RANGE, GL_FIRST_VERTEX_CONVENTION, GL_COLOR_LOGIC_OP, +GL_MINOR_VERSION, GL_LAST_VERTEX_CONVENTION, GL_UNSIGNED_INT_SAMPLER_3D, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, GL_ALWAYS, +GL_INT_VEC4, GL_INT_VEC3, GL_INT_VEC2, GL_STENCIL_FAIL, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, +GL_MAX_VERTEX_ATTRIBS, GL_CONDITION_SATISFIED, GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT, GL_LINE_WIDTH_RANGE, GL_XOR, +GL_FRAMEBUFFER_UNSUPPORTED, GL_INVALID_ENUM, GL_CONTEXT_PROFILE_MASK, GL_DYNAMIC_COPY, GL_LESS, +GL_MAX_CUBE_MAP_TEXTURE_SIZE, GL_FRAMEBUFFER_UNDEFINED, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_STENCIL_SIZE, GL_RENDERBUFFER_WIDTH, +GL_READ_FRAMEBUFFER_BINDING, GL_FRAMEBUFFER_ATTACHMENT_LAYERED, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_DEPTH_TYPE, GL_INT_SAMPLER_1D, +GL_RGBA2, GL_RGBA4, GL_DRAW_BUFFER10, GL_DRAW_BUFFER11, GL_RGBA8, +GL_DRAW_BUFFER13, GL_UNSIGNED_INT_10_10_10_2, GL_DRAW_BUFFER15, GL_INFO_LOG_LENGTH, GL_COMPRESSED_RG_RGTC2, +GL_POLYGON_OFFSET_UNITS, GL_SRC_ALPHA_SATURATE, GL_RENDERBUFFER_STENCIL_SIZE, GL_REPEAT, GL_R16I, +GL_RG8_SNORM, GL_POINT_SIZE_GRANULARITY, GL_STATIC_READ, GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, GL_SCISSOR_TEST, +GL_VALIDATE_STATUS, GL_MAP_READ_BIT, GL_RG16, GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, GL_STENCIL, +GL_SAMPLE_MASK_VALUE, GL_STENCIL_BUFFER_BIT, GL_TEXTURE_2D_MULTISAMPLE, GL_DEBUG_TYPE_PERFORMANCE_KHR, GL_SAMPLER_1D_ARRAY_SHADOW, +GL_TEXTURE_SWIZZLE_B, GL_BLEND_EQUATION_ALPHA, GL_RGBA_INTEGER, GL_ACTIVE_ATTRIBUTES, GL_MAX_RENDERBUFFER_SIZE, +GL_COLOR_ATTACHMENT31, GL_COLOR_ATTACHMENT30, GL_STENCIL_PASS_DEPTH_PASS, GL_INCR_WRAP, GL_RENDERBUFFER_ALPHA_SIZE, +GL_COLOR_ATTACHMENT16, GL_DECR_WRAP, GL_SHADER_KHR, GL_POLYGON_SMOOTH, GL_ATTACHED_SHADERS, +GL_SAMPLE_POSITION, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_QUERY_BY_REGION_NO_WAIT, GL_FLOAT_MAT2x3, GL_SAMPLE_COVERAGE_INVERT, +GL_INCR, GL_TEXTURE18, GL_TEXTURE19, GL_TEXTURE16, GL_TEXTURE17, +GL_RGBA12, GL_TEXTURE15, GL_TEXTURE12, GL_COLOR_ATTACHMENT11, GL_RGBA16, +GL_UNPACK_SKIP_ROWS, GL_DEBUG_LOGGED_MESSAGES_KHR, GL_BLEND_DST_ALPHA, GL_RGB, GL_INT_SAMPLER_CUBE, +GL_DEBUG_TYPE_OTHER, GL_CURRENT_QUERY, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_RGB5_A1, GL_VERTEX_SHADER, +GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_TRANSFORM_FEEDBACK_BUFFER_START, GL_COPY_INVERTED, GL_MAX_PROGRAM_TEXEL_OFFSET, GL_STACK_OVERFLOW, +GL_DEBUG_SOURCE_OTHER_KHR, GL_MAX_GEOMETRY_INPUT_COMPONENTS, GL_LOWER_LEFT, GL_CONSTANT_COLOR, GL_UNSIGNED_INT_SAMPLER_2D_RECT, +GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_MARKER_KHR, GL_MAX_DEBUG_LOGGED_MESSAGES_KHR, GL_RGBA32F, GL_TEXTURE_BINDING_1D, +GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_STENCIL_REF, GL_PIXEL_UNPACK_BUFFER, GL_DEBUG_TYPE_PORTABILITY_KHR, GL_LINEAR_MIPMAP_NEAREST, +GL_STENCIL_WRITEMASK, GL_RG8, GL_DEBUG_SEVERITY_HIGH_KHR, GL_RGB10_A2, GL_STENCIL_BACK_PASS_DEPTH_PASS, +GL_INVALID_VALUE, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_SEPARATE_ATTRIBS, GL_MAP_UNSYNCHRONIZED_BIT, GL_ZERO, +GL_PRIMITIVE_RESTART, GL_ELEMENT_ARRAY_BUFFER, GL_CONTEXT_CORE_PROFILE_BIT, GL_CLEAR, GL_BUFFER_MAP_LENGTH, +GL_DEBUG_SOURCE_OTHER, GL_READ_ONLY, GL_MAX_FRAGMENT_INPUT_COMPONENTS, GL_MAX_ELEMENTS_INDICES, GL_UNSIGNED_NORMALIZED, +GL_CONSTANT_ALPHA, GL_SRC_ALPHA, GL_TEXTURE_3D, GL_GEOMETRY_VERTICES_OUT, GL_DEBUG_SOURCE_API_KHR, +GL_SYNC_FLUSH_COMMANDS_BIT, GL_RGB8, GL_NOTEQUAL, GL_UNIFORM_ARRAY_STRIDE, GL_TEXTURE_SAMPLES, +GL_RGB4, GL_RGB5, GL_LINES, GL_SMOOTH_LINE_WIDTH_GRANULARITY, GL_COMPRESSED_RED, +GL_BGR, GL_SAMPLE_COVERAGE_VALUE, GL_TEXTURE_RED_SIZE, GL_PROXY_TEXTURE_CUBE_MAP, GL_MAX_VIEWPORT_DIMS, +GL_ACTIVE_UNIFORM_MAX_LENGTH, GL_TEXTURE_SWIZZLE_A, GL_TEXTURE_BORDER_COLOR, GL_COMPRESSED_SIGNED_RG_RGTC2, GL_CONTEXT_FLAG_DEBUG_BIT, +GL_TEXTURE11, GL_TEXTURE14, GL_NEVER, GL_STENCIL_VALUE_MASK, GL_BLEND_DST, +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR, GL_TEXTURE13, GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_SHARED_SIZE, GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR, +GL_TEXTURE10, GL_LOGIC_OP_MODE, GL_FRAMEBUFFER_COMPLETE, GL_MAX_FRAGMENT_UNIFORM_BLOCKS, GL_COPY_READ_BUFFER, +GL_STENCIL_ATTACHMENT, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, GL_TEXTURE_SWIZZLE_RGBA, GL_DEPTH_COMPONENT32, GL_SUBPIXEL_BITS, +GL_SHORT, GL_READ_FRAMEBUFFER, GL_CW, GL_UNSIGNED_INT_24_8, GL_SMOOTH_POINT_SIZE_GRANULARITY, +GL_MAX_TEXTURE_BUFFER_SIZE, GL_MAX_VERTEX_UNIFORM_COMPONENTS, GL_VENDOR, GL_DEBUG_SEVERITY_MEDIUM_KHR, GL_TEXTURE_2D_ARRAY, +GL_UNSIGNED_INT_10F_11F_11F_REV, GL_TEXTURE_BINDING_2D, GL_OBJECT_TYPE, GL_BLEND_EQUATION, GL_GEOMETRY_SHADER, +GL_R8UI, GL_STATIC_DRAW, GL_PACK_LSB_FIRST, GL_PACK_SKIP_IMAGES, GL_RGBA16UI, +GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, GL_UNSIGNED_BYTE_3_3_2, GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GL_FLOAT_MAT2x4, GL_RGB8I, +GL_COLOR_ATTACHMENT18, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, GL_DRAW_BUFFER, GL_PROXY_TEXTURE_3D, GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY, +GL_PRIMITIVES_GENERATED, GL_DRAW_BUFFER0, GL_STENCIL_INDEX4, GL_SAMPLER_3D, GL_MAX, +GL_TEXTURE_GREEN_TYPE, GL_PROXY_TEXTURE_2D_ARRAY, GL_MAX_INTEGER_SAMPLES, GL_COMPRESSED_SRGB, GL_OR_INVERTED, +GL_RGB8UI, GL_STENCIL_INDEX16, GL_UNIFORM_BLOCK_INDEX, GL_INVALID_INDEX, GL_FRAMEBUFFER_SRGB, +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, GL_MIRRORED_REPEAT, GL_SAMPLER_1D_SHADOW, GL_BLEND_DST_RGB, GL_SAMPLER_2D_SHADOW, +GL_EQUIV, GL_TEXTURE_BINDING_2D_ARRAY, GL_MAX_GEOMETRY_UNIFORM_BLOCKS, GL_RG16F, GL_DEBUG_SEVERITY_LOW_KHR, +GL_DRAW_BUFFER8, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, GL_RG16I, GL_WRITE_ONLY, +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, GL_TEXTURE_GREEN_SIZE, GL_SAMPLE_COVERAGE, GL_DRAW_FRAMEBUFFER, GL_RGB10_A2UI, +GL_TEXTURE_LOD_BIAS, GL_MAX_DEBUG_LOGGED_MESSAGES, GL_SAMPLER, GL_SAMPLES; diff --git a/source/glad/gl/loader.d b/source/glad/gl/loader.d index 91fef93..0caf0ea 100644 --- a/source/glad/gl/loader.d +++ b/source/glad/gl/loader.d @@ -167,6 +167,7 @@ bool gladLoadGL(Loader load) { load_GL_VERSION_3_3(load); find_extensionsGL(); + load_GL_KHR_debug(load); return GLVersion.major != 0 || GLVersion.minor != 0; } @@ -215,6 +216,7 @@ void find_coreGL() { } void find_extensionsGL() { + GL_KHR_debug = has_ext("GL_KHR_debug"); return; } @@ -268,264 +270,6 @@ void load_GL_VERSION_1_0(Loader load) { 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; } @@ -533,7 +277,6 @@ 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"); @@ -545,22 +288,6 @@ void load_GL_VERSION_1_1(Loader load) { 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; } @@ -584,43 +311,6 @@ void load_GL_VERSION_1_3(Loader load) { 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; } @@ -633,44 +323,6 @@ void load_GL_VERSION_1_4(Loader load) { 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; @@ -1005,6 +657,32 @@ void load_GL_VERSION_3_3(Loader load) { return; } +void load_GL_KHR_debug(Loader load) { + if(!GL_KHR_debug) return; + glDebugMessageControl = cast(typeof(glDebugMessageControl))load("glDebugMessageControl"); + glDebugMessageInsert = cast(typeof(glDebugMessageInsert))load("glDebugMessageInsert"); + glDebugMessageCallback = cast(typeof(glDebugMessageCallback))load("glDebugMessageCallback"); + glGetDebugMessageLog = cast(typeof(glGetDebugMessageLog))load("glGetDebugMessageLog"); + glPushDebugGroup = cast(typeof(glPushDebugGroup))load("glPushDebugGroup"); + glPopDebugGroup = cast(typeof(glPopDebugGroup))load("glPopDebugGroup"); + glObjectLabel = cast(typeof(glObjectLabel))load("glObjectLabel"); + glGetObjectLabel = cast(typeof(glGetObjectLabel))load("glGetObjectLabel"); + glObjectPtrLabel = cast(typeof(glObjectPtrLabel))load("glObjectPtrLabel"); + glGetObjectPtrLabel = cast(typeof(glGetObjectPtrLabel))load("glGetObjectPtrLabel"); + glGetPointerv = cast(typeof(glGetPointerv))load("glGetPointerv"); + glDebugMessageControlKHR = cast(typeof(glDebugMessageControlKHR))load("glDebugMessageControlKHR"); + glDebugMessageInsertKHR = cast(typeof(glDebugMessageInsertKHR))load("glDebugMessageInsertKHR"); + glDebugMessageCallbackKHR = cast(typeof(glDebugMessageCallbackKHR))load("glDebugMessageCallbackKHR"); + glGetDebugMessageLogKHR = cast(typeof(glGetDebugMessageLogKHR))load("glGetDebugMessageLogKHR"); + glPushDebugGroupKHR = cast(typeof(glPushDebugGroupKHR))load("glPushDebugGroupKHR"); + glPopDebugGroupKHR = cast(typeof(glPopDebugGroupKHR))load("glPopDebugGroupKHR"); + glObjectLabelKHR = cast(typeof(glObjectLabelKHR))load("glObjectLabelKHR"); + glGetObjectLabelKHR = cast(typeof(glGetObjectLabelKHR))load("glGetObjectLabelKHR"); + glObjectPtrLabelKHR = cast(typeof(glObjectPtrLabelKHR))load("glObjectPtrLabelKHR"); + glGetObjectPtrLabelKHR = cast(typeof(glGetObjectPtrLabelKHR))load("glGetObjectPtrLabelKHR"); + glGetPointervKHR = cast(typeof(glGetPointervKHR))load("glGetPointervKHR"); + return; +} } /* private */ diff --git a/source/imgui.d b/source/imgui.d index ba5f589..973daca 100644 --- a/source/imgui.d +++ b/source/imgui.d @@ -277,16 +277,16 @@ struct Imgui { auto io = igGetIO(); int win_w, win_h; - win.window_size(win_w, win_h); + win.windowSize(win_w, win_h); int fbo_w, fbo_h; - win.framebuffer_size(fbo_w, fbo_h); + win.framebufferSize(fbo_w, fbo_h); io.DisplaySize = ImVec2(win_w, win_h); io.DisplayFramebufferScale = ImVec2(cast(float)fbo_w / win_w, cast(float)fbo_h / win_h); int m_x, m_y; - win.mouse_pos(m_x, m_y); + win.mousePos(m_x, m_y); io.MousePos = ImVec2(cast(float)m_x, cast(float)m_y); io.MouseDown[0] = mouse_buttons_pressed[0] || (SDL_GetMouseState(null, null) & SDL_BUTTON_LEFT) != 0; diff --git a/source/window.d b/source/window.d index adeb6d6..54d164f 100644 --- a/source/window.d +++ b/source/window.d @@ -28,16 +28,39 @@ struct Window { SDL_Window* window; SDL_GLContext context; + extern(Windows) nothrow @nogc + static void openGLCallbackFunction( + GLenum source, GLenum type, + GLuint id, GLenum severity, + GLsizei length, const (GLchar)* message, + void* userParam) + { + + printf("Message: %s \nSource: %s \nType: %s \nID: %d \nSeverity: %s\n\n", + message, to!(char*)(source), to!(char*)(type), id, to!(char*)(severity)); + + if (severity == GL_DEBUG_SEVERITY_HIGH) { + printf("Aborting...\n"); + import core.stdc.stdlib : exit; + exit(-1); + } + + } // openGLCallbackFunction + void createWindow(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_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32); + // DEBUGGERING! + SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG); + 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()); @@ -60,6 +83,21 @@ struct Window { printf("Renderer: %s\n", glGetString(GL_RENDERER)); printf("Version: %s\n", glGetString(GL_VERSION)); + // enable debuggering + glEnable(GL_DEBUG_OUTPUT); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + glDebugMessageCallback(&openGLCallbackFunction, null); + + //enable all + glDebugMessageControl( + GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, null, true + ); + + //disable notification messages + glDebugMessageControl( + GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, null, false + ); + // assign em yes window = new_win; context = new_con; @@ -86,16 +124,57 @@ struct Window { } // renderPresent - void mouse_pos(ref int x, ref int y) { + void mousePos(ref int x, ref int y) { SDL_GetMouseState(&x, &y); } - void window_size(ref int w, ref int h) { + void windowSize(ref int w, ref int h) { SDL_GetWindowSize(window, &w, &h); } - void framebuffer_size(ref int w, ref int h) { + void framebufferSize(ref int w, ref int h) { SDL_GL_GetDrawableSize(window, &w, &h); } -} // Window \ No newline at end of file +} // Window + +/** + * Converts a GLenum representation of a value to a c string representation, + * for use with debug printing of OpenGL info, from debug callbacks for example. +*/ +const (char*) to(T : char*)(GLenum value) { + + import glad.gl.all; + + switch (value) { + + // sources + case GL_DEBUG_SOURCE_API: return "API"; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "Window System"; + case GL_DEBUG_SOURCE_SHADER_COMPILER: return "Shader Compiler"; + case GL_DEBUG_SOURCE_THIRD_PARTY: return "Third Party"; + case GL_DEBUG_SOURCE_APPLICATION: return "Application"; + case GL_DEBUG_SOURCE_OTHER: return "Other"; + + // error types + case GL_DEBUG_TYPE_ERROR: return "Error"; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "Deprecated Behaviour"; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "Undefined Behaviour"; + case GL_DEBUG_TYPE_PORTABILITY: return "Portability"; + case GL_DEBUG_TYPE_PERFORMANCE: return "Performance"; + case GL_DEBUG_TYPE_MARKER: return "Marker"; + case GL_DEBUG_TYPE_PUSH_GROUP: return "Push Group"; + case GL_DEBUG_TYPE_POP_GROUP: return "Pop Group"; + case GL_DEBUG_TYPE_OTHER: return "Other"; + + // severity markers + case GL_DEBUG_SEVERITY_HIGH: return "High"; + case GL_DEBUG_SEVERITY_MEDIUM: return "Medium"; + case GL_DEBUG_SEVERITY_LOW: return "Low"; + case GL_DEBUG_SEVERITY_NOTIFICATION: return "Notification"; + + default: return "(undefined)"; + + } + +} // to!string(GLenum) \ No newline at end of file