From f5eeecaca5842e4594ad2ed482c529a683bfb012 Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Mon, 19 Dec 2016 11:56:45 +0000 Subject: Begin generic declarations for lists of specifications --- core/math.odin | 29 +- core/opengl.odin | 117 +- core/opengl_constants.odin | 2732 ++++++++++++++++++++++---------------------- core/utf8.odin | 22 +- src/checker/checker.c | 93 +- src/checker/expr.c | 83 ++ src/checker/stmt.c | 84 ++ src/parser.c | 479 ++++---- src/ssa.c | 72 +- 9 files changed, 2017 insertions(+), 1694 deletions(-) diff --git a/core/math.odin b/core/math.odin index 1b503c0a2..691961ce9 100644 --- a/core/math.odin +++ b/core/math.odin @@ -1,21 +1,22 @@ -const TAU = 6.28318530717958647692528676655900576; -const PI = 3.14159265358979323846264338327950288; -const ONE_OVER_TAU = 0.636619772367581343075535053490057448; -const ONE_OVER_PI = 0.159154943091895335768883763372514362; +const ( + TAU = 6.28318530717958647692528676655900576; + PI = 3.14159265358979323846264338327950288; + ONE_OVER_TAU = 0.636619772367581343075535053490057448; + ONE_OVER_PI = 0.159154943091895335768883763372514362; -const E = 2.71828182845904523536; -const SQRT_TWO = 1.41421356237309504880168872420969808; -const SQRT_THREE = 1.73205080756887729352744634150587236; -const SQRT_FIVE = 2.23606797749978969640917366873127623; + E = 2.71828182845904523536; + SQRT_TWO = 1.41421356237309504880168872420969808; + SQRT_THREE = 1.73205080756887729352744634150587236; + SQRT_FIVE = 2.23606797749978969640917366873127623; -const LOG_TWO = 0.693147180559945309417232121458176568; -const LOG_TEN = 2.30258509299404568401799145468436421; + LOG_TWO = 0.693147180559945309417232121458176568; + LOG_TEN = 2.30258509299404568401799145468436421; -const EPSILON = 1.19209290e-7; - -const τ = TAU; -const π = PI; + EPSILON = 1.19209290e-7; + τ = TAU; + π = PI; +); type Vec2 [vector 2]f32; type Vec3 [vector 3]f32; diff --git a/core/opengl.odin b/core/opengl.odin index 8d7575b94..b0e979188 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -41,64 +41,65 @@ proc GetProcAddress(name string) -> proc() { return res; } - -var GenBuffers proc(count i32, buffers ^u32); -var GenVertexArrays proc(count i32, buffers ^u32); -var GenSamplers proc(count i32, buffers ^u32); -var BindBuffer proc(target i32, buffer u32); -var BindVertexArray proc(buffer u32); -var BindSampler proc(position i32, sampler u32); -var BufferData proc(target i32, size int, data rawptr, usage i32); -var BufferSubData proc(target i32, offset, size int, data rawptr); - -var DrawArrays proc(mode, first i32, count u32); -var DrawElements proc(mode i32, count u32, type_ i32, indices rawptr); - -var MapBuffer proc(target, access i32) -> rawptr; -var UnmapBuffer proc(target i32); - -var VertexAttribPointer proc(index u32, size, type_ i32, normalized i32, stride u32, pointer rawptr); -var EnableVertexAttribArray proc(index u32); - -var CreateShader proc(shader_type i32) -> u32; -var ShaderSource proc(shader u32, count u32, str ^^byte, length ^i32); -var CompileShader proc(shader u32); -var CreateProgram proc() -> u32; -var AttachShader proc(program, shader u32); -var DetachShader proc(program, shader u32); -var DeleteShader proc(shader u32); -var LinkProgram proc(program u32); -var UseProgram proc(program u32); -var DeleteProgram proc(program u32); - - -var GetShaderiv proc(shader u32, pname i32, params ^i32); -var GetProgramiv proc(program u32, pname i32, params ^i32); -var GetShaderInfoLog proc(shader u32, max_length u32, length ^u32, info_long ^byte); -var GetProgramInfoLog proc(program u32, max_length u32, length ^u32, info_long ^byte); - -var ActiveTexture proc(texture i32); -var GenerateMipmap proc(target i32); - -var SamplerParameteri proc(sampler u32, pname i32, param i32); -var SamplerParameterf proc(sampler u32, pname i32, param f32); -var SamplerParameteriv proc(sampler u32, pname i32, params ^i32); -var SamplerParameterfv proc(sampler u32, pname i32, params ^f32); -var SamplerParameterIiv proc(sampler u32, pname i32, params ^i32); -var SamplerParameterIuiv proc(sampler u32, pname i32, params ^u32); - - -var Uniform1i proc(loc i32, v0 i32); -var Uniform2i proc(loc i32, v0, v1 i32); -var Uniform3i proc(loc i32, v0, v1, v2 i32); -var Uniform4i proc(loc i32, v0, v1, v2, v3 i32); -var Uniform1f proc(loc i32, v0 f32); -var Uniform2f proc(loc i32, v0, v1 f32); -var Uniform3f proc(loc i32, v0, v1, v2 f32); -var Uniform4f proc(loc i32, v0, v1, v2, v3 f32); -var UniformMatrix4fv proc(loc i32, count u32, transpose i32, value ^f32); - -var GetUniformLocation proc(program u32, name ^byte) -> i32; +var ( + GenBuffers proc(count i32, buffers ^u32); + GenVertexArrays proc(count i32, buffers ^u32); + GenSamplers proc(count i32, buffers ^u32); + BindBuffer proc(target i32, buffer u32); + BindVertexArray proc(buffer u32); + BindSampler proc(position i32, sampler u32); + BufferData proc(target i32, size int, data rawptr, usage i32); + BufferSubData proc(target i32, offset, size int, data rawptr); + + DrawArrays proc(mode, first i32, count u32); + DrawElements proc(mode i32, count u32, type_ i32, indices rawptr); + + MapBuffer proc(target, access i32) -> rawptr; + UnmapBuffer proc(target i32); + + VertexAttribPointer proc(index u32, size, type_ i32, normalized i32, stride u32, pointer rawptr); + EnableVertexAttribArray proc(index u32); + + CreateShader proc(shader_type i32) -> u32; + ShaderSource proc(shader u32, count u32, str ^^byte, length ^i32); + CompileShader proc(shader u32); + CreateProgram proc() -> u32; + AttachShader proc(program, shader u32); + DetachShader proc(program, shader u32); + DeleteShader proc(shader u32); + LinkProgram proc(program u32); + UseProgram proc(program u32); + DeleteProgram proc(program u32); + + + GetShaderiv proc(shader u32, pname i32, params ^i32); + GetProgramiv proc(program u32, pname i32, params ^i32); + GetShaderInfoLog proc(shader u32, max_length u32, length ^u32, info_long ^byte); + GetProgramInfoLog proc(program u32, max_length u32, length ^u32, info_long ^byte); + + ActiveTexture proc(texture i32); + GenerateMipmap proc(target i32); + + SamplerParameteri proc(sampler u32, pname i32, param i32); + SamplerParameterf proc(sampler u32, pname i32, param f32); + SamplerParameteriv proc(sampler u32, pname i32, params ^i32); + SamplerParameterfv proc(sampler u32, pname i32, params ^f32); + SamplerParameterIiv proc(sampler u32, pname i32, params ^i32); + SamplerParameterIuiv proc(sampler u32, pname i32, params ^u32); + + + Uniform1i proc(loc i32, v0 i32); + Uniform2i proc(loc i32, v0, v1 i32); + Uniform3i proc(loc i32, v0, v1, v2 i32); + Uniform4i proc(loc i32, v0, v1, v2, v3 i32); + Uniform1f proc(loc i32, v0 f32); + Uniform2f proc(loc i32, v0, v1 f32); + Uniform3f proc(loc i32, v0, v1, v2 f32); + Uniform4f proc(loc i32, v0, v1, v2, v3 f32); + UniformMatrix4fv proc(loc i32, count u32, transpose i32, value ^f32); + + GetUniformLocation proc(program u32, name ^byte) -> i32; +); proc init() { proc set_proc_address(p rawptr, name string) #inline { (p as ^proc())^ = GetProcAddress(name); } diff --git a/core/opengl_constants.odin b/core/opengl_constants.odin index ddb9377ce..8c9a02f68 100644 --- a/core/opengl_constants.odin +++ b/core/opengl_constants.odin @@ -1,1383 +1,1385 @@ -const FALSE = 0; -const TRUE = 1; +const ( + FALSE = 0; + TRUE = 1; -const DEPTH_BUFFER_BIT = 0x00000100; -const STENCIL_BUFFER_BIT = 0x00000400; -const COLOR_BUFFER_BIT = 0x00004000; -const POINTS = 0x0000; -const LINES = 0x0001; -const LINE_LOOP = 0x0002; -const LINE_STRIP = 0x0003; -const TRIANGLES = 0x0004; -const TRIANGLE_STRIP = 0x0005; -const TRIANGLE_FAN = 0x0006; -const QUADS = 0x0007; -const NEVER = 0x0200; -const LESS = 0x0201; -const EQUAL = 0x0202; -const LEQUAL = 0x0203; -const GREATER = 0x0204; -const NOTEQUAL = 0x0205; -const GEQUAL = 0x0206; -const ALWAYS = 0x0207; -const ZERO = 0; -const ONE = 1; -const SRC_COLOR = 0x0300; -const ONE_MINUS_SRC_COLOR = 0x0301; -const SRC_ALPHA = 0x0302; -const ONE_MINUS_SRC_ALPHA = 0x0303; -const DST_ALPHA = 0x0304; -const ONE_MINUS_DST_ALPHA = 0x0305; -const DST_COLOR = 0x0306; -const ONE_MINUS_DST_COLOR = 0x0307; -const SRC_ALPHA_SATURATE = 0x0308; -const NONE = 0; -const FRONT_LEFT = 0x0400; -const FRONT_RIGHT = 0x0401; -const BACK_LEFT = 0x0402; -const BACK_RIGHT = 0x0403; -const FRONT = 0x0404; -const BACK = 0x0405; -const LEFT = 0x0406; -const RIGHT = 0x0407; -const FRONT_AND_BACK = 0x0408; -const NO_ERROR = 0; -const INVALID_ENUM = 0x0500; -const INVALID_VALUE = 0x0501; -const INVALID_OPERATION = 0x0502; -const OUT_OF_MEMORY = 0x0505; -const CW = 0x0900; -const CCW = 0x0901; -const POINT_SIZE = 0x0B11; -const POINT_SIZE_RANGE = 0x0B12; -const POINT_SIZE_GRANULARITY = 0x0B13; -const LINE_SMOOTH = 0x0B20; -const LINE_WIDTH = 0x0B21; -const LINE_WIDTH_RANGE = 0x0B22; -const LINE_WIDTH_GRANULARITY = 0x0B23; -const POLYGON_MODE = 0x0B40; -const POLYGON_SMOOTH = 0x0B41; -const CULL_FACE = 0x0B44; -const CULL_FACE_MODE = 0x0B45; -const FRONT_FACE = 0x0B46; -const DEPTH_RANGE = 0x0B70; -const DEPTH_TEST = 0x0B71; -const DEPTH_WRITEMASK = 0x0B72; -const DEPTH_CLEAR_VALUE = 0x0B73; -const DEPTH_FUNC = 0x0B74; -const STENCIL_TEST = 0x0B90; -const STENCIL_CLEAR_VALUE = 0x0B91; -const STENCIL_FUNC = 0x0B92; -const STENCIL_VALUE_MASK = 0x0B93; -const STENCIL_FAIL = 0x0B94; -const STENCIL_PASS_DEPTH_FAIL = 0x0B95; -const STENCIL_PASS_DEPTH_PASS = 0x0B96; -const STENCIL_REF = 0x0B97; -const STENCIL_WRITEMASK = 0x0B98; -const VIEWPORT = 0x0BA2; -const DITHER = 0x0BD0; -const BLEND_DST = 0x0BE0; -const BLEND_SRC = 0x0BE1; -const BLEND = 0x0BE2; -const LOGIC_OP_MODE = 0x0BF0; -const COLOR_LOGIC_OP = 0x0BF2; -const DRAW_BUFFER = 0x0C01; -const READ_BUFFER = 0x0C02; -const SCISSOR_BOX = 0x0C10; -const SCISSOR_TEST = 0x0C11; -const COLOR_CLEAR_VALUE = 0x0C22; -const COLOR_WRITEMASK = 0x0C23; -const DOUBLEBUFFER = 0x0C32; -const STEREO = 0x0C33; -const LINE_SMOOTH_HINT = 0x0C52; -const POLYGON_SMOOTH_HINT = 0x0C53; -const UNPACK_SWAP_BYTES = 0x0CF0; -const UNPACK_LSB_FIRST = 0x0CF1; -const UNPACK_ROW_LENGTH = 0x0CF2; -const UNPACK_SKIP_ROWS = 0x0CF3; -const UNPACK_SKIP_PIXELS = 0x0CF4; -const UNPACK_ALIGNMENT = 0x0CF5; -const PACK_SWAP_BYTES = 0x0D00; -const PACK_LSB_FIRST = 0x0D01; -const PACK_ROW_LENGTH = 0x0D02; -const PACK_SKIP_ROWS = 0x0D03; -const PACK_SKIP_PIXELS = 0x0D04; -const PACK_ALIGNMENT = 0x0D05; -const MAX_TEXTURE_SIZE = 0x0D33; -const MAX_VIEWPORT_DIMS = 0x0D3A; -const SUBPIXEL_BITS = 0x0D50; -const TEXTURE_1D = 0x0DE0; -const TEXTURE_2D = 0x0DE1; -const POLYGON_OFFSET_UNITS = 0x2A00; -const POLYGON_OFFSET_POINT = 0x2A01; -const POLYGON_OFFSET_LINE = 0x2A02; -const POLYGON_OFFSET_FILL = 0x8037; -const POLYGON_OFFSET_FACTOR = 0x8038; -const TEXTURE_BINDING_1D = 0x8068; -const TEXTURE_BINDING_2D = 0x8069; -const TEXTURE_WIDTH = 0x1000; -const TEXTURE_HEIGHT = 0x1001; -const TEXTURE_INTERNAL_FORMAT = 0x1003; -const TEXTURE_BORDER_COLOR = 0x1004; -const TEXTURE_RED_SIZE = 0x805C; -const TEXTURE_GREEN_SIZE = 0x805D; -const TEXTURE_BLUE_SIZE = 0x805E; -const TEXTURE_ALPHA_SIZE = 0x805F; -const DONT_CARE = 0x1100; -const FASTEST = 0x1101; -const NICEST = 0x1102; -const BYTE = 0x1400; -const UNSIGNED_BYTE = 0x1401; -const SHORT = 0x1402; -const UNSIGNED_SHORT = 0x1403; -const INT = 0x1404; -const UNSIGNED_INT = 0x1405; -const FLOAT = 0x1406; -const DOUBLE = 0x140A; -const STACK_OVERFLOW = 0x0503; -const STACK_UNDERFLOW = 0x0504; -const CLEAR = 0x1500; -const AND = 0x1501; -const AND_REVERSE = 0x1502; -const COPY = 0x1503; -const AND_INVERTED = 0x1504; -const NOOP = 0x1505; -const XOR = 0x1506; -const OR = 0x1507; -const NOR = 0x1508; -const EQUIV = 0x1509; -const INVERT = 0x150A; -const OR_REVERSE = 0x150B; -const COPY_INVERTED = 0x150C; -const OR_INVERTED = 0x150D; -const NAND = 0x150E; -const SET = 0x150F; -const TEXTURE = 0x1702; -const COLOR = 0x1800; -const DEPTH = 0x1801; -const STENCIL = 0x1802; -const STENCIL_INDEX = 0x1901; -const DEPTH_COMPONENT = 0x1902; -const RED = 0x1903; -const GREEN = 0x1904; -const BLUE = 0x1905; -const ALPHA = 0x1906; -const RGB = 0x1907; -const RGBA = 0x1908; -const POINT = 0x1B00; -const LINE = 0x1B01; -const FILL = 0x1B02; -const KEEP = 0x1E00; -const REPLACE = 0x1E01; -const INCR = 0x1E02; -const DECR = 0x1E03; -const VENDOR = 0x1F00; -const RENDERER = 0x1F01; -const VERSION = 0x1F02; -const EXTENSIONS = 0x1F03; -const NEAREST = 0x2600; -const LINEAR = 0x2601; -const NEAREST_MIPMAP_NEAREST = 0x2700; -const LINEAR_MIPMAP_NEAREST = 0x2701; -const NEAREST_MIPMAP_LINEAR = 0x2702; -const LINEAR_MIPMAP_LINEAR = 0x2703; -const TEXTURE_MAG_FILTER = 0x2800; -const TEXTURE_MIN_FILTER = 0x2801; -const TEXTURE_WRAP_S = 0x2802; -const TEXTURE_WRAP_T = 0x2803; -const PROXY_TEXTURE_1D = 0x8063; -const PROXY_TEXTURE_2D = 0x8064; -const REPEAT = 0x2901; -const R3_G3_B2 = 0x2A10; -const RGB4 = 0x804F; -const RGB5 = 0x8050; -const RGB8 = 0x8051; -const RGB10 = 0x8052; -const RGB12 = 0x8053; -const RGB16 = 0x8054; -const RGBA2 = 0x8055; -const RGBA4 = 0x8056; -const RGB5_A1 = 0x8057; -const RGBA8 = 0x8058; -const RGB10_A2 = 0x8059; -const RGBA12 = 0x805A; -const RGBA16 = 0x805B; -const VERTEX_ARRAY = 0x8074; + DEPTH_BUFFER_BIT = 0x00000100; + STENCIL_BUFFER_BIT = 0x00000400; + COLOR_BUFFER_BIT = 0x00004000; + POINTS = 0x0000; + LINES = 0x0001; + LINE_LOOP = 0x0002; + LINE_STRIP = 0x0003; + TRIANGLES = 0x0004; + TRIANGLE_STRIP = 0x0005; + TRIANGLE_FAN = 0x0006; + QUADS = 0x0007; + NEVER = 0x0200; + LESS = 0x0201; + EQUAL = 0x0202; + LEQUAL = 0x0203; + GREATER = 0x0204; + NOTEQUAL = 0x0205; + GEQUAL = 0x0206; + ALWAYS = 0x0207; + ZERO = 0; + ONE = 1; + SRC_COLOR = 0x0300; + ONE_MINUS_SRC_COLOR = 0x0301; + SRC_ALPHA = 0x0302; + ONE_MINUS_SRC_ALPHA = 0x0303; + DST_ALPHA = 0x0304; + ONE_MINUS_DST_ALPHA = 0x0305; + DST_COLOR = 0x0306; + ONE_MINUS_DST_COLOR = 0x0307; + SRC_ALPHA_SATURATE = 0x0308; + NONE = 0; + FRONT_LEFT = 0x0400; + FRONT_RIGHT = 0x0401; + BACK_LEFT = 0x0402; + BACK_RIGHT = 0x0403; + FRONT = 0x0404; + BACK = 0x0405; + LEFT = 0x0406; + RIGHT = 0x0407; + FRONT_AND_BACK = 0x0408; + NO_ERROR = 0; + INVALID_ENUM = 0x0500; + INVALID_VALUE = 0x0501; + INVALID_OPERATION = 0x0502; + OUT_OF_MEMORY = 0x0505; + CW = 0x0900; + CCW = 0x0901; + POINT_SIZE = 0x0B11; + POINT_SIZE_RANGE = 0x0B12; + POINT_SIZE_GRANULARITY = 0x0B13; + LINE_SMOOTH = 0x0B20; + LINE_WIDTH = 0x0B21; + LINE_WIDTH_RANGE = 0x0B22; + LINE_WIDTH_GRANULARITY = 0x0B23; + POLYGON_MODE = 0x0B40; + POLYGON_SMOOTH = 0x0B41; + CULL_FACE = 0x0B44; + CULL_FACE_MODE = 0x0B45; + FRONT_FACE = 0x0B46; + DEPTH_RANGE = 0x0B70; + DEPTH_TEST = 0x0B71; + DEPTH_WRITEMASK = 0x0B72; + DEPTH_CLEAR_VALUE = 0x0B73; + DEPTH_FUNC = 0x0B74; + STENCIL_TEST = 0x0B90; + STENCIL_CLEAR_VALUE = 0x0B91; + STENCIL_FUNC = 0x0B92; + STENCIL_VALUE_MASK = 0x0B93; + STENCIL_FAIL = 0x0B94; + STENCIL_PASS_DEPTH_FAIL = 0x0B95; + STENCIL_PASS_DEPTH_PASS = 0x0B96; + STENCIL_REF = 0x0B97; + STENCIL_WRITEMASK = 0x0B98; + VIEWPORT = 0x0BA2; + DITHER = 0x0BD0; + BLEND_DST = 0x0BE0; + BLEND_SRC = 0x0BE1; + BLEND = 0x0BE2; + LOGIC_OP_MODE = 0x0BF0; + COLOR_LOGIC_OP = 0x0BF2; + DRAW_BUFFER = 0x0C01; + READ_BUFFER = 0x0C02; + SCISSOR_BOX = 0x0C10; + SCISSOR_TEST = 0x0C11; + COLOR_CLEAR_VALUE = 0x0C22; + COLOR_WRITEMASK = 0x0C23; + DOUBLEBUFFER = 0x0C32; + STEREO = 0x0C33; + LINE_SMOOTH_HINT = 0x0C52; + POLYGON_SMOOTH_HINT = 0x0C53; + UNPACK_SWAP_BYTES = 0x0CF0; + UNPACK_LSB_FIRST = 0x0CF1; + UNPACK_ROW_LENGTH = 0x0CF2; + UNPACK_SKIP_ROWS = 0x0CF3; + UNPACK_SKIP_PIXELS = 0x0CF4; + UNPACK_ALIGNMENT = 0x0CF5; + PACK_SWAP_BYTES = 0x0D00; + PACK_LSB_FIRST = 0x0D01; + PACK_ROW_LENGTH = 0x0D02; + PACK_SKIP_ROWS = 0x0D03; + PACK_SKIP_PIXELS = 0x0D04; + PACK_ALIGNMENT = 0x0D05; + MAX_TEXTURE_SIZE = 0x0D33; + MAX_VIEWPORT_DIMS = 0x0D3A; + SUBPIXEL_BITS = 0x0D50; + TEXTURE_1D = 0x0DE0; + TEXTURE_2D = 0x0DE1; + POLYGON_OFFSET_UNITS = 0x2A00; + POLYGON_OFFSET_POINT = 0x2A01; + POLYGON_OFFSET_LINE = 0x2A02; + POLYGON_OFFSET_FILL = 0x8037; + POLYGON_OFFSET_FACTOR = 0x8038; + TEXTURE_BINDING_1D = 0x8068; + TEXTURE_BINDING_2D = 0x8069; + TEXTURE_WIDTH = 0x1000; + TEXTURE_HEIGHT = 0x1001; + TEXTURE_INTERNAL_FORMAT = 0x1003; + TEXTURE_BORDER_COLOR = 0x1004; + TEXTURE_RED_SIZE = 0x805C; + TEXTURE_GREEN_SIZE = 0x805D; + TEXTURE_BLUE_SIZE = 0x805E; + TEXTURE_ALPHA_SIZE = 0x805F; + DONT_CARE = 0x1100; + FASTEST = 0x1101; + NICEST = 0x1102; + BYTE = 0x1400; + UNSIGNED_BYTE = 0x1401; + SHORT = 0x1402; + UNSIGNED_SHORT = 0x1403; + INT = 0x1404; + UNSIGNED_INT = 0x1405; + FLOAT = 0x1406; + DOUBLE = 0x140A; + STACK_OVERFLOW = 0x0503; + STACK_UNDERFLOW = 0x0504; + CLEAR = 0x1500; + AND = 0x1501; + AND_REVERSE = 0x1502; + COPY = 0x1503; + AND_INVERTED = 0x1504; + NOOP = 0x1505; + XOR = 0x1506; + OR = 0x1507; + NOR = 0x1508; + EQUIV = 0x1509; + INVERT = 0x150A; + OR_REVERSE = 0x150B; + COPY_INVERTED = 0x150C; + OR_INVERTED = 0x150D; + NAND = 0x150E; + SET = 0x150F; + TEXTURE = 0x1702; + COLOR = 0x1800; + DEPTH = 0x1801; + STENCIL = 0x1802; + STENCIL_INDEX = 0x1901; + DEPTH_COMPONENT = 0x1902; + RED = 0x1903; + GREEN = 0x1904; + BLUE = 0x1905; + ALPHA = 0x1906; + RGB = 0x1907; + RGBA = 0x1908; + POINT = 0x1B00; + LINE = 0x1B01; + FILL = 0x1B02; + KEEP = 0x1E00; + REPLACE = 0x1E01; + INCR = 0x1E02; + DECR = 0x1E03; + VENDOR = 0x1F00; + RENDERER = 0x1F01; + VERSION = 0x1F02; + EXTENSIONS = 0x1F03; + NEAREST = 0x2600; + LINEAR = 0x2601; + NEAREST_MIPMAP_NEAREST = 0x2700; + LINEAR_MIPMAP_NEAREST = 0x2701; + NEAREST_MIPMAP_LINEAR = 0x2702; + LINEAR_MIPMAP_LINEAR = 0x2703; + TEXTURE_MAG_FILTER = 0x2800; + TEXTURE_MIN_FILTER = 0x2801; + TEXTURE_WRAP_S = 0x2802; + TEXTURE_WRAP_T = 0x2803; + PROXY_TEXTURE_1D = 0x8063; + PROXY_TEXTURE_2D = 0x8064; + REPEAT = 0x2901; + R3_G3_B2 = 0x2A10; + RGB4 = 0x804F; + RGB5 = 0x8050; + RGB8 = 0x8051; + RGB10 = 0x8052; + RGB12 = 0x8053; + RGB16 = 0x8054; + RGBA2 = 0x8055; + RGBA4 = 0x8056; + RGB5_A1 = 0x8057; + RGBA8 = 0x8058; + RGB10_A2 = 0x8059; + RGBA12 = 0x805A; + RGBA16 = 0x805B; + VERTEX_ARRAY = 0x8074; -const UNSIGNED_BYTE_3_3_2 = 0x8032; -const UNSIGNED_SHORT_4_4_4_4 = 0x8033; -const UNSIGNED_SHORT_5_5_5_1 = 0x8034; -const UNSIGNED_INT_8_8_8_8 = 0x8035; -const UNSIGNED_INT_10_10_10_2 = 0x8036; -const TEXTURE_BINDING_3D = 0x806A; -const PACK_SKIP_IMAGES = 0x806B; -const PACK_IMAGE_HEIGHT = 0x806C; -const UNPACK_SKIP_IMAGES = 0x806D; -const UNPACK_IMAGE_HEIGHT = 0x806E; -const TEXTURE_3D = 0x806F; -const PROXY_TEXTURE_3D = 0x8070; -const TEXTURE_DEPTH = 0x8071; -const TEXTURE_WRAP_R = 0x8072; -const MAX_3D_TEXTURE_SIZE = 0x8073; -const UNSIGNED_BYTE_2_3_3_REV = 0x8362; -const UNSIGNED_SHORT_5_6_5 = 0x8363; -const UNSIGNED_SHORT_5_6_5_REV = 0x8364; -const UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; -const UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; -const UNSIGNED_INT_8_8_8_8_REV = 0x8367; -const UNSIGNED_INT_2_10_10_10_REV = 0x8368; -const BGR = 0x80E0; -const BGRA = 0x80E1; -const MAX_ELEMENTS_VERTICES = 0x80E8; -const MAX_ELEMENTS_INDICES = 0x80E9; -const CLAMP_TO_EDGE = 0x812F; -const TEXTURE_MIN_LOD = 0x813A; -const TEXTURE_MAX_LOD = 0x813B; -const TEXTURE_BASE_LEVEL = 0x813C; -const TEXTURE_MAX_LEVEL = 0x813D; -const SMOOTH_POINT_SIZE_RANGE = 0x0B12; -const SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; -const SMOOTH_LINE_WIDTH_RANGE = 0x0B22; -const SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; -const ALIASED_LINE_WIDTH_RANGE = 0x846E; + UNSIGNED_BYTE_3_3_2 = 0x8032; + UNSIGNED_SHORT_4_4_4_4 = 0x8033; + UNSIGNED_SHORT_5_5_5_1 = 0x8034; + UNSIGNED_INT_8_8_8_8 = 0x8035; + UNSIGNED_INT_10_10_10_2 = 0x8036; + TEXTURE_BINDING_3D = 0x806A; + PACK_SKIP_IMAGES = 0x806B; + PACK_IMAGE_HEIGHT = 0x806C; + UNPACK_SKIP_IMAGES = 0x806D; + UNPACK_IMAGE_HEIGHT = 0x806E; + TEXTURE_3D = 0x806F; + PROXY_TEXTURE_3D = 0x8070; + TEXTURE_DEPTH = 0x8071; + TEXTURE_WRAP_R = 0x8072; + MAX_3D_TEXTURE_SIZE = 0x8073; + UNSIGNED_BYTE_2_3_3_REV = 0x8362; + UNSIGNED_SHORT_5_6_5 = 0x8363; + UNSIGNED_SHORT_5_6_5_REV = 0x8364; + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; + UNSIGNED_INT_8_8_8_8_REV = 0x8367; + UNSIGNED_INT_2_10_10_10_REV = 0x8368; + BGR = 0x80E0; + BGRA = 0x80E1; + MAX_ELEMENTS_VERTICES = 0x80E8; + MAX_ELEMENTS_INDICES = 0x80E9; + CLAMP_TO_EDGE = 0x812F; + TEXTURE_MIN_LOD = 0x813A; + TEXTURE_MAX_LOD = 0x813B; + TEXTURE_BASE_LEVEL = 0x813C; + TEXTURE_MAX_LEVEL = 0x813D; + SMOOTH_POINT_SIZE_RANGE = 0x0B12; + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; + SMOOTH_LINE_WIDTH_RANGE = 0x0B22; + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; + ALIASED_LINE_WIDTH_RANGE = 0x846E; -const TEXTURE0 = 0x84C0; -const TEXTURE1 = 0x84C1; -const TEXTURE2 = 0x84C2; -const TEXTURE3 = 0x84C3; -const TEXTURE4 = 0x84C4; -const TEXTURE5 = 0x84C5; -const TEXTURE6 = 0x84C6; -const TEXTURE7 = 0x84C7; -const TEXTURE8 = 0x84C8; -const TEXTURE9 = 0x84C9; -const TEXTURE10 = 0x84CA; -const TEXTURE11 = 0x84CB; -const TEXTURE12 = 0x84CC; -const TEXTURE13 = 0x84CD; -const TEXTURE14 = 0x84CE; -const TEXTURE15 = 0x84CF; -const TEXTURE16 = 0x84D0; -const TEXTURE17 = 0x84D1; -const TEXTURE18 = 0x84D2; -const TEXTURE19 = 0x84D3; -const TEXTURE20 = 0x84D4; -const TEXTURE21 = 0x84D5; -const TEXTURE22 = 0x84D6; -const TEXTURE23 = 0x84D7; -const TEXTURE24 = 0x84D8; -const TEXTURE25 = 0x84D9; -const TEXTURE26 = 0x84DA; -const TEXTURE27 = 0x84DB; -const TEXTURE28 = 0x84DC; -const TEXTURE29 = 0x84DD; -const TEXTURE30 = 0x84DE; -const TEXTURE31 = 0x84DF; -const ACTIVE_TEXTURE = 0x84E0; -const MULTISAMPLE = 0x809D; -const SAMPLE_ALPHA_TO_COVERAGE = 0x809E; -const SAMPLE_ALPHA_TO_ONE = 0x809F; -const SAMPLE_COVERAGE = 0x80A0; -const SAMPLE_BUFFERS = 0x80A8; -const SAMPLES = 0x80A9; -const SAMPLE_COVERAGE_VALUE = 0x80AA; -const SAMPLE_COVERAGE_INVERT = 0x80AB; -const TEXTURE_CUBE_MAP = 0x8513; -const TEXTURE_BINDING_CUBE_MAP = 0x8514; -const TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; -const TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; -const TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; -const TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; -const TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; -const TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; -const PROXY_TEXTURE_CUBE_MAP = 0x851B; -const MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; -const COMPRESSED_RGB = 0x84ED; -const COMPRESSED_RGBA = 0x84EE; -const TEXTURE_COMPRESSION_HINT = 0x84EF; -const TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0; -const TEXTURE_COMPRESSED = 0x86A1; -const NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; -const COMPRESSED_TEXTURE_FORMATS = 0x86A3; -const CLAMP_TO_BORDER = 0x812D; + TEXTURE0 = 0x84C0; + TEXTURE1 = 0x84C1; + TEXTURE2 = 0x84C2; + TEXTURE3 = 0x84C3; + TEXTURE4 = 0x84C4; + TEXTURE5 = 0x84C5; + TEXTURE6 = 0x84C6; + TEXTURE7 = 0x84C7; + TEXTURE8 = 0x84C8; + TEXTURE9 = 0x84C9; + TEXTURE10 = 0x84CA; + TEXTURE11 = 0x84CB; + TEXTURE12 = 0x84CC; + TEXTURE13 = 0x84CD; + TEXTURE14 = 0x84CE; + TEXTURE15 = 0x84CF; + TEXTURE16 = 0x84D0; + TEXTURE17 = 0x84D1; + TEXTURE18 = 0x84D2; + TEXTURE19 = 0x84D3; + TEXTURE20 = 0x84D4; + TEXTURE21 = 0x84D5; + TEXTURE22 = 0x84D6; + TEXTURE23 = 0x84D7; + TEXTURE24 = 0x84D8; + TEXTURE25 = 0x84D9; + TEXTURE26 = 0x84DA; + TEXTURE27 = 0x84DB; + TEXTURE28 = 0x84DC; + TEXTURE29 = 0x84DD; + TEXTURE30 = 0x84DE; + TEXTURE31 = 0x84DF; + ACTIVE_TEXTURE = 0x84E0; + MULTISAMPLE = 0x809D; + SAMPLE_ALPHA_TO_COVERAGE = 0x809E; + SAMPLE_ALPHA_TO_ONE = 0x809F; + SAMPLE_COVERAGE = 0x80A0; + SAMPLE_BUFFERS = 0x80A8; + SAMPLES = 0x80A9; + SAMPLE_COVERAGE_VALUE = 0x80AA; + SAMPLE_COVERAGE_INVERT = 0x80AB; + TEXTURE_CUBE_MAP = 0x8513; + TEXTURE_BINDING_CUBE_MAP = 0x8514; + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; + PROXY_TEXTURE_CUBE_MAP = 0x851B; + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; + COMPRESSED_RGB = 0x84ED; + COMPRESSED_RGBA = 0x84EE; + TEXTURE_COMPRESSION_HINT = 0x84EF; + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0; + TEXTURE_COMPRESSED = 0x86A1; + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; + COMPRESSED_TEXTURE_FORMATS = 0x86A3; + CLAMP_TO_BORDER = 0x812D; -const BLEND_DST_RGB = 0x80C8; -const BLEND_SRC_RGB = 0x80C9; -const BLEND_DST_ALPHA = 0x80CA; -const BLEND_SRC_ALPHA = 0x80CB; -const POINT_FADE_THRESHOLD_SIZE = 0x8128; -const DEPTH_COMPONENT16 = 0x81A5; -const DEPTH_COMPONENT24 = 0x81A6; -const DEPTH_COMPONENT32 = 0x81A7; -const MIRRORED_REPEAT = 0x8370; -const MAX_TEXTURE_LOD_BIAS = 0x84FD; -const TEXTURE_LOD_BIAS = 0x8501; -const INCR_WRAP = 0x8507; -const DECR_WRAP = 0x8508; -const TEXTURE_DEPTH_SIZE = 0x884A; -const TEXTURE_COMPARE_MODE = 0x884C; -const TEXTURE_COMPARE_FUNC = 0x884D; -const FUNC_ADD = 0x8006; -const FUNC_SUBTRACT = 0x800A; -const FUNC_REVERSE_SUBTRACT = 0x800B; -const MIN = 0x8007; -const MAX = 0x8008; -const CONSTANT_COLOR = 0x8001; -const ONE_MINUS_CONSTANT_COLOR = 0x8002; -const CONSTANT_ALPHA = 0x8003; -const ONE_MINUS_CONSTANT_ALPHA = 0x8004; + BLEND_DST_RGB = 0x80C8; + BLEND_SRC_RGB = 0x80C9; + BLEND_DST_ALPHA = 0x80CA; + BLEND_SRC_ALPHA = 0x80CB; + POINT_FADE_THRESHOLD_SIZE = 0x8128; + DEPTH_COMPONENT16 = 0x81A5; + DEPTH_COMPONENT24 = 0x81A6; + DEPTH_COMPONENT32 = 0x81A7; + MIRRORED_REPEAT = 0x8370; + MAX_TEXTURE_LOD_BIAS = 0x84FD; + TEXTURE_LOD_BIAS = 0x8501; + INCR_WRAP = 0x8507; + DECR_WRAP = 0x8508; + TEXTURE_DEPTH_SIZE = 0x884A; + TEXTURE_COMPARE_MODE = 0x884C; + TEXTURE_COMPARE_FUNC = 0x884D; + FUNC_ADD = 0x8006; + FUNC_SUBTRACT = 0x800A; + FUNC_REVERSE_SUBTRACT = 0x800B; + MIN = 0x8007; + MAX = 0x8008; + CONSTANT_COLOR = 0x8001; + ONE_MINUS_CONSTANT_COLOR = 0x8002; + CONSTANT_ALPHA = 0x8003; + ONE_MINUS_CONSTANT_ALPHA = 0x8004; -const BUFFER_SIZE = 0x8764; -const BUFFER_USAGE = 0x8765; -const QUERY_COUNTER_BITS = 0x8864; -const CURRENT_QUERY = 0x8865; -const QUERY_RESULT = 0x8866; -const QUERY_RESULT_AVAILABLE = 0x8867; -const ARRAY_BUFFER = 0x8892; -const ELEMENT_ARRAY_BUFFER = 0x8893; -const ARRAY_BUFFER_BINDING = 0x8894; -const ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; -const VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; -const READ_ONLY = 0x88B8; -const WRITE_ONLY = 0x88B9; -const READ_WRITE = 0x88BA; -const BUFFER_ACCESS = 0x88BB; -const BUFFER_MAPPED = 0x88BC; -const BUFFER_MAP_POINTER = 0x88BD; -const STREAM_DRAW = 0x88E0; -const STREAM_READ = 0x88E1; -const STREAM_COPY = 0x88E2; -const STATIC_DRAW = 0x88E4; -const STATIC_READ = 0x88E5; -const STATIC_COPY = 0x88E6; -const DYNAMIC_DRAW = 0x88E8; -const DYNAMIC_READ = 0x88E9; -const DYNAMIC_COPY = 0x88EA; -const SAMPLES_PASSED = 0x8914; -const SRC1_ALPHA = 0x8589; + BUFFER_SIZE = 0x8764; + BUFFER_USAGE = 0x8765; + QUERY_COUNTER_BITS = 0x8864; + CURRENT_QUERY = 0x8865; + QUERY_RESULT = 0x8866; + QUERY_RESULT_AVAILABLE = 0x8867; + ARRAY_BUFFER = 0x8892; + ELEMENT_ARRAY_BUFFER = 0x8893; + ARRAY_BUFFER_BINDING = 0x8894; + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; + READ_ONLY = 0x88B8; + WRITE_ONLY = 0x88B9; + READ_WRITE = 0x88BA; + BUFFER_ACCESS = 0x88BB; + BUFFER_MAPPED = 0x88BC; + BUFFER_MAP_POINTER = 0x88BD; + STREAM_DRAW = 0x88E0; + STREAM_READ = 0x88E1; + STREAM_COPY = 0x88E2; + STATIC_DRAW = 0x88E4; + STATIC_READ = 0x88E5; + STATIC_COPY = 0x88E6; + DYNAMIC_DRAW = 0x88E8; + DYNAMIC_READ = 0x88E9; + DYNAMIC_COPY = 0x88EA; + SAMPLES_PASSED = 0x8914; + SRC1_ALPHA = 0x8589; -const BLEND_EQUATION_RGB = 0x8009; -const VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; -const VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; -const VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; -const VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; -const CURRENT_VERTEX_ATTRIB = 0x8626; -const VERTEX_PROGRAM_POINT_SIZE = 0x8642; -const VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; -const STENCIL_BACK_FUNC = 0x8800; -const STENCIL_BACK_FAIL = 0x8801; -const STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; -const STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; -const MAX_DRAW_BUFFERS = 0x8824; -const DRAW_BUFFER0 = 0x8825; -const DRAW_BUFFER1 = 0x8826; -const DRAW_BUFFER2 = 0x8827; -const DRAW_BUFFER3 = 0x8828; -const DRAW_BUFFER4 = 0x8829; -const DRAW_BUFFER5 = 0x882A; -const DRAW_BUFFER6 = 0x882B; -const DRAW_BUFFER7 = 0x882C; -const DRAW_BUFFER8 = 0x882D; -const DRAW_BUFFER9 = 0x882E; -const DRAW_BUFFER10 = 0x882F; -const DRAW_BUFFER11 = 0x8830; -const DRAW_BUFFER12 = 0x8831; -const DRAW_BUFFER13 = 0x8832; -const DRAW_BUFFER14 = 0x8833; -const DRAW_BUFFER15 = 0x8834; -const BLEND_EQUATION_ALPHA = 0x883D; -const MAX_VERTEX_ATTRIBS = 0x8869; -const VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; -const MAX_TEXTURE_IMAGE_UNITS = 0x8872; -const FRAGMENT_SHADER = 0x8B30; -const VERTEX_SHADER = 0x8B31; -const MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; -const MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; -const MAX_VARYING_FLOATS = 0x8B4B; -const MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; -const MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; -const SHADER_TYPE = 0x8B4F; -const FLOAT_VEC2 = 0x8B50; -const FLOAT_VEC3 = 0x8B51; -const FLOAT_VEC4 = 0x8B52; -const INT_VEC2 = 0x8B53; -const INT_VEC3 = 0x8B54; -const INT_VEC4 = 0x8B55; -const BOOL = 0x8B56; -const BOOL_VEC2 = 0x8B57; -const BOOL_VEC3 = 0x8B58; -const BOOL_VEC4 = 0x8B59; -const FLOAT_MAT2 = 0x8B5A; -const FLOAT_MAT3 = 0x8B5B; -const FLOAT_MAT4 = 0x8B5C; -const SAMPLER_1D = 0x8B5D; -const SAMPLER_2D = 0x8B5E; -const SAMPLER_3D = 0x8B5F; -const SAMPLER_CUBE = 0x8B60; -const SAMPLER_1D_SHADOW = 0x8B61; -const SAMPLER_2D_SHADOW = 0x8B62; -const DELETE_STATUS = 0x8B80; -const COMPILE_STATUS = 0x8B81; -const LINK_STATUS = 0x8B82; -const VALIDATE_STATUS = 0x8B83; -const INFO_LOG_LENGTH = 0x8B84; -const ATTACHED_SHADERS = 0x8B85; -const ACTIVE_UNIFORMS = 0x8B86; -const ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; -const SHADER_SOURCE_LENGTH = 0x8B88; -const ACTIVE_ATTRIBUTES = 0x8B89; -const ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; -const FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; -const SHADING_LANGUAGE_VERSION = 0x8B8C; -const CURRENT_PROGRAM = 0x8B8D; -const POINT_SPRITE_COORD_ORIGIN = 0x8CA0; -const LOWER_LEFT = 0x8CA1; -const UPPER_LEFT = 0x8CA2; -const STENCIL_BACK_REF = 0x8CA3; -const STENCIL_BACK_VALUE_MASK = 0x8CA4; -const STENCIL_BACK_WRITEMASK = 0x8CA5; + BLEND_EQUATION_RGB = 0x8009; + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; + CURRENT_VERTEX_ATTRIB = 0x8626; + VERTEX_PROGRAM_POINT_SIZE = 0x8642; + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; + STENCIL_BACK_FUNC = 0x8800; + STENCIL_BACK_FAIL = 0x8801; + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; + MAX_DRAW_BUFFERS = 0x8824; + DRAW_BUFFER0 = 0x8825; + DRAW_BUFFER1 = 0x8826; + DRAW_BUFFER2 = 0x8827; + DRAW_BUFFER3 = 0x8828; + DRAW_BUFFER4 = 0x8829; + DRAW_BUFFER5 = 0x882A; + DRAW_BUFFER6 = 0x882B; + DRAW_BUFFER7 = 0x882C; + DRAW_BUFFER8 = 0x882D; + DRAW_BUFFER9 = 0x882E; + DRAW_BUFFER10 = 0x882F; + DRAW_BUFFER11 = 0x8830; + DRAW_BUFFER12 = 0x8831; + DRAW_BUFFER13 = 0x8832; + DRAW_BUFFER14 = 0x8833; + DRAW_BUFFER15 = 0x8834; + BLEND_EQUATION_ALPHA = 0x883D; + MAX_VERTEX_ATTRIBS = 0x8869; + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; + MAX_TEXTURE_IMAGE_UNITS = 0x8872; + FRAGMENT_SHADER = 0x8B30; + VERTEX_SHADER = 0x8B31; + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; + MAX_VARYING_FLOATS = 0x8B4B; + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; + SHADER_TYPE = 0x8B4F; + FLOAT_VEC2 = 0x8B50; + FLOAT_VEC3 = 0x8B51; + FLOAT_VEC4 = 0x8B52; + INT_VEC2 = 0x8B53; + INT_VEC3 = 0x8B54; + INT_VEC4 = 0x8B55; + BOOL = 0x8B56; + BOOL_VEC2 = 0x8B57; + BOOL_VEC3 = 0x8B58; + BOOL_VEC4 = 0x8B59; + FLOAT_MAT2 = 0x8B5A; + FLOAT_MAT3 = 0x8B5B; + FLOAT_MAT4 = 0x8B5C; + SAMPLER_1D = 0x8B5D; + SAMPLER_2D = 0x8B5E; + SAMPLER_3D = 0x8B5F; + SAMPLER_CUBE = 0x8B60; + SAMPLER_1D_SHADOW = 0x8B61; + SAMPLER_2D_SHADOW = 0x8B62; + DELETE_STATUS = 0x8B80; + COMPILE_STATUS = 0x8B81; + LINK_STATUS = 0x8B82; + VALIDATE_STATUS = 0x8B83; + INFO_LOG_LENGTH = 0x8B84; + ATTACHED_SHADERS = 0x8B85; + ACTIVE_UNIFORMS = 0x8B86; + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; + SHADER_SOURCE_LENGTH = 0x8B88; + ACTIVE_ATTRIBUTES = 0x8B89; + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; + SHADING_LANGUAGE_VERSION = 0x8B8C; + CURRENT_PROGRAM = 0x8B8D; + POINT_SPRITE_COORD_ORIGIN = 0x8CA0; + LOWER_LEFT = 0x8CA1; + UPPER_LEFT = 0x8CA2; + STENCIL_BACK_REF = 0x8CA3; + STENCIL_BACK_VALUE_MASK = 0x8CA4; + STENCIL_BACK_WRITEMASK = 0x8CA5; -const PIXEL_PACK_BUFFER = 0x88EB; -const PIXEL_UNPACK_BUFFER = 0x88EC; -const PIXEL_PACK_BUFFER_BINDING = 0x88ED; -const PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; -const FLOAT_MAT2x3 = 0x8B65; -const FLOAT_MAT2x4 = 0x8B66; -const FLOAT_MAT3x2 = 0x8B67; -const FLOAT_MAT3x4 = 0x8B68; -const FLOAT_MAT4x2 = 0x8B69; -const FLOAT_MAT4x3 = 0x8B6A; -const SRGB = 0x8C40; -const SRGB8 = 0x8C41; -const SRGB_ALPHA = 0x8C42; -const SRGB8_ALPHA8 = 0x8C43; -const COMPRESSED_SRGB = 0x8C48; -const COMPRESSED_SRGB_ALPHA = 0x8C49; + PIXEL_PACK_BUFFER = 0x88EB; + PIXEL_UNPACK_BUFFER = 0x88EC; + PIXEL_PACK_BUFFER_BINDING = 0x88ED; + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; + FLOAT_MAT2x3 = 0x8B65; + FLOAT_MAT2x4 = 0x8B66; + FLOAT_MAT3x2 = 0x8B67; + FLOAT_MAT3x4 = 0x8B68; + FLOAT_MAT4x2 = 0x8B69; + FLOAT_MAT4x3 = 0x8B6A; + SRGB = 0x8C40; + SRGB8 = 0x8C41; + SRGB_ALPHA = 0x8C42; + SRGB8_ALPHA8 = 0x8C43; + COMPRESSED_SRGB = 0x8C48; + COMPRESSED_SRGB_ALPHA = 0x8C49; -const COMPARE_REF_TO_TEXTURE = 0x884E; -const CLIP_DISTANCE0 = 0x3000; -const CLIP_DISTANCE1 = 0x3001; -const CLIP_DISTANCE2 = 0x3002; -const CLIP_DISTANCE3 = 0x3003; -const CLIP_DISTANCE4 = 0x3004; -const CLIP_DISTANCE5 = 0x3005; -const CLIP_DISTANCE6 = 0x3006; -const CLIP_DISTANCE7 = 0x3007; -const MAX_CLIP_DISTANCES = 0x0D32; -const MAJOR_VERSION = 0x821B; -const MINOR_VERSION = 0x821C; -const NUM_EXTENSIONS = 0x821D; -const CONTEXT_FLAGS = 0x821E; -const COMPRESSED_RED = 0x8225; -const COMPRESSED_RG = 0x8226; -const CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001; -const RGBA32F = 0x8814; -const RGB32F = 0x8815; -const RGBA16F = 0x881A; -const RGB16F = 0x881B; -const VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; -const MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; -const MIN_PROGRAM_TEXEL_OFFSET = 0x8904; -const MAX_PROGRAM_TEXEL_OFFSET = 0x8905; -const CLAMP_READ_COLOR = 0x891C; -const FIXED_ONLY = 0x891D; -const MAX_VARYING_COMPONENTS = 0x8B4B; -const TEXTURE_1D_ARRAY = 0x8C18; -const PROXY_TEXTURE_1D_ARRAY = 0x8C19; -const TEXTURE_2D_ARRAY = 0x8C1A; -const PROXY_TEXTURE_2D_ARRAY = 0x8C1B; -const TEXTURE_BINDING_1D_ARRAY = 0x8C1C; -const TEXTURE_BINDING_2D_ARRAY = 0x8C1D; -const R11F_G11F_B10F = 0x8C3A; -const UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; -const RGB9_E5 = 0x8C3D; -const UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; -const TEXTURE_SHARED_SIZE = 0x8C3F; -const TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; -const TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; -const MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; -const TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; -const TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; -const TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; -const PRIMITIVES_GENERATED = 0x8C87; -const TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; -const RASTERIZER_DISCARD = 0x8C89; -const MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; -const MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; -const INTERLEAVED_ATTRIBS = 0x8C8C; -const SEPARATE_ATTRIBS = 0x8C8D; -const TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; -const TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; -const RGBA32UI = 0x8D70; -const RGB32UI = 0x8D71; -const RGBA16UI = 0x8D76; -const RGB16UI = 0x8D77; -const RGBA8UI = 0x8D7C; -const RGB8UI = 0x8D7D; -const RGBA32I = 0x8D82; -const RGB32I = 0x8D83; -const RGBA16I = 0x8D88; -const RGB16I = 0x8D89; -const RGBA8I = 0x8D8E; -const RGB8I = 0x8D8F; -const RED_INTEGER = 0x8D94; -const GREEN_INTEGER = 0x8D95; -const BLUE_INTEGER = 0x8D96; -const RGB_INTEGER = 0x8D98; -const RGBA_INTEGER = 0x8D99; -const BGR_INTEGER = 0x8D9A; -const BGRA_INTEGER = 0x8D9B; -const SAMPLER_1D_ARRAY = 0x8DC0; -const SAMPLER_2D_ARRAY = 0x8DC1; -const SAMPLER_1D_ARRAY_SHADOW = 0x8DC3; -const SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; -const SAMPLER_CUBE_SHADOW = 0x8DC5; -const UNSIGNED_INT_VEC2 = 0x8DC6; -const UNSIGNED_INT_VEC3 = 0x8DC7; -const UNSIGNED_INT_VEC4 = 0x8DC8; -const INT_SAMPLER_1D = 0x8DC9; -const INT_SAMPLER_2D = 0x8DCA; -const INT_SAMPLER_3D = 0x8DCB; -const INT_SAMPLER_CUBE = 0x8DCC; -const INT_SAMPLER_1D_ARRAY = 0x8DCE; -const INT_SAMPLER_2D_ARRAY = 0x8DCF; -const UNSIGNED_INT_SAMPLER_1D = 0x8DD1; -const UNSIGNED_INT_SAMPLER_2D = 0x8DD2; -const UNSIGNED_INT_SAMPLER_3D = 0x8DD3; -const UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; -const UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6; -const UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; -const QUERY_WAIT = 0x8E13; -const QUERY_NO_WAIT = 0x8E14; -const QUERY_BY_REGION_WAIT = 0x8E15; -const QUERY_BY_REGION_NO_WAIT = 0x8E16; -const BUFFER_ACCESS_FLAGS = 0x911F; -const BUFFER_MAP_LENGTH = 0x9120; -const BUFFER_MAP_OFFSET = 0x9121; -const DEPTH_COMPONENT32F = 0x8CAC; -const DEPTH32F_STENCIL8 = 0x8CAD; -const FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; -const INVALID_FRAMEBUFFER_OPERATION = 0x0506; -const FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; -const FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; -const FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; -const FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; -const FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; -const FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; -const FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; -const FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; -const FRAMEBUFFER_DEFAULT = 0x8218; -const FRAMEBUFFER_UNDEFINED = 0x8219; -const DEPTH_STENCIL_ATTACHMENT = 0x821A; -const MAX_RENDERBUFFER_SIZE = 0x84E8; -const DEPTH_STENCIL = 0x84F9; -const UNSIGNED_INT_24_8 = 0x84FA; -const DEPTH24_STENCIL8 = 0x88F0; -const TEXTURE_STENCIL_SIZE = 0x88F1; -const TEXTURE_RED_TYPE = 0x8C10; -const TEXTURE_GREEN_TYPE = 0x8C11; -const TEXTURE_BLUE_TYPE = 0x8C12; -const TEXTURE_ALPHA_TYPE = 0x8C13; -const TEXTURE_DEPTH_TYPE = 0x8C16; -const UNSIGNED_NORMALIZED = 0x8C17; -const FRAMEBUFFER_BINDING = 0x8CA6; -const DRAW_FRAMEBUFFER_BINDING = 0x8CA6; -const RENDERBUFFER_BINDING = 0x8CA7; -const READ_FRAMEBUFFER = 0x8CA8; -const DRAW_FRAMEBUFFER = 0x8CA9; -const READ_FRAMEBUFFER_BINDING = 0x8CAA; -const RENDERBUFFER_SAMPLES = 0x8CAB; -const FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; -const FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; -const FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; -const FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; -const FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; -const FRAMEBUFFER_COMPLETE = 0x8CD5; -const FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; -const FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; -const FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB; -const FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC; -const FRAMEBUFFER_UNSUPPORTED = 0x8CDD; -const MAX_COLOR_ATTACHMENTS = 0x8CDF; -const COLOR_ATTACHMENT0 = 0x8CE0; -const COLOR_ATTACHMENT1 = 0x8CE1; -const COLOR_ATTACHMENT2 = 0x8CE2; -const COLOR_ATTACHMENT3 = 0x8CE3; -const COLOR_ATTACHMENT4 = 0x8CE4; -const COLOR_ATTACHMENT5 = 0x8CE5; -const COLOR_ATTACHMENT6 = 0x8CE6; -const COLOR_ATTACHMENT7 = 0x8CE7; -const COLOR_ATTACHMENT8 = 0x8CE8; -const COLOR_ATTACHMENT9 = 0x8CE9; -const COLOR_ATTACHMENT10 = 0x8CEA; -const COLOR_ATTACHMENT11 = 0x8CEB; -const COLOR_ATTACHMENT12 = 0x8CEC; -const COLOR_ATTACHMENT13 = 0x8CED; -const COLOR_ATTACHMENT14 = 0x8CEE; -const COLOR_ATTACHMENT15 = 0x8CEF; -const COLOR_ATTACHMENT16 = 0x8CF0; -const COLOR_ATTACHMENT17 = 0x8CF1; -const COLOR_ATTACHMENT18 = 0x8CF2; -const COLOR_ATTACHMENT19 = 0x8CF3; -const COLOR_ATTACHMENT20 = 0x8CF4; -const COLOR_ATTACHMENT21 = 0x8CF5; -const COLOR_ATTACHMENT22 = 0x8CF6; -const COLOR_ATTACHMENT23 = 0x8CF7; -const COLOR_ATTACHMENT24 = 0x8CF8; -const COLOR_ATTACHMENT25 = 0x8CF9; -const COLOR_ATTACHMENT26 = 0x8CFA; -const COLOR_ATTACHMENT27 = 0x8CFB; -const COLOR_ATTACHMENT28 = 0x8CFC; -const COLOR_ATTACHMENT29 = 0x8CFD; -const COLOR_ATTACHMENT30 = 0x8CFE; -const COLOR_ATTACHMENT31 = 0x8CFF; -const DEPTH_ATTACHMENT = 0x8D00; -const STENCIL_ATTACHMENT = 0x8D20; -const FRAMEBUFFER = 0x8D40; -const RENDERBUFFER = 0x8D41; -const RENDERBUFFER_WIDTH = 0x8D42; -const RENDERBUFFER_HEIGHT = 0x8D43; -const RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; -const STENCIL_INDEX1 = 0x8D46; -const STENCIL_INDEX4 = 0x8D47; -const STENCIL_INDEX8 = 0x8D48; -const STENCIL_INDEX16 = 0x8D49; -const RENDERBUFFER_RED_SIZE = 0x8D50; -const RENDERBUFFER_GREEN_SIZE = 0x8D51; -const RENDERBUFFER_BLUE_SIZE = 0x8D52; -const RENDERBUFFER_ALPHA_SIZE = 0x8D53; -const RENDERBUFFER_DEPTH_SIZE = 0x8D54; -const RENDERBUFFER_STENCIL_SIZE = 0x8D55; -const FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; -const MAX_SAMPLES = 0x8D57; -const FRAMEBUFFER_SRGB = 0x8DB9; -const HALF_FLOAT = 0x140B; -const MAP_READ_BIT = 0x0001; -const MAP_WRITE_BIT = 0x0002; -const MAP_INVALIDATE_RANGE_BIT = 0x0004; -const MAP_INVALIDATE_BUFFER_BIT = 0x0008; -const MAP_FLUSH_EXPLICIT_BIT = 0x0010; -const MAP_UNSYNCHRONIZED_BIT = 0x0020; -const COMPRESSED_RED_RGTC1 = 0x8DBB; -const COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC; -const COMPRESSED_RG_RGTC2 = 0x8DBD; -const COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; -const RG = 0x8227; -const RG_INTEGER = 0x8228; -const R8 = 0x8229; -const R16 = 0x822A; -const RG8 = 0x822B; -const RG16 = 0x822C; -const R16F = 0x822D; -const R32F = 0x822E; -const RG16F = 0x822F; -const RG32F = 0x8230; -const R8I = 0x8231; -const R8UI = 0x8232; -const R16I = 0x8233; -const R16UI = 0x8234; -const R32I = 0x8235; -const R32UI = 0x8236; -const RG8I = 0x8237; -const RG8UI = 0x8238; -const RG16I = 0x8239; -const RG16UI = 0x823A; -const RG32I = 0x823B; -const RG32UI = 0x823C; -const VERTEX_ARRAY_BINDING = 0x85B5; + COMPARE_REF_TO_TEXTURE = 0x884E; + CLIP_DISTANCE0 = 0x3000; + CLIP_DISTANCE1 = 0x3001; + CLIP_DISTANCE2 = 0x3002; + CLIP_DISTANCE3 = 0x3003; + CLIP_DISTANCE4 = 0x3004; + CLIP_DISTANCE5 = 0x3005; + CLIP_DISTANCE6 = 0x3006; + CLIP_DISTANCE7 = 0x3007; + MAX_CLIP_DISTANCES = 0x0D32; + MAJOR_VERSION = 0x821B; + MINOR_VERSION = 0x821C; + NUM_EXTENSIONS = 0x821D; + CONTEXT_FLAGS = 0x821E; + COMPRESSED_RED = 0x8225; + COMPRESSED_RG = 0x8226; + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001; + RGBA32F = 0x8814; + RGB32F = 0x8815; + RGBA16F = 0x881A; + RGB16F = 0x881B; + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; + MIN_PROGRAM_TEXEL_OFFSET = 0x8904; + MAX_PROGRAM_TEXEL_OFFSET = 0x8905; + CLAMP_READ_COLOR = 0x891C; + FIXED_ONLY = 0x891D; + MAX_VARYING_COMPONENTS = 0x8B4B; + TEXTURE_1D_ARRAY = 0x8C18; + PROXY_TEXTURE_1D_ARRAY = 0x8C19; + TEXTURE_2D_ARRAY = 0x8C1A; + PROXY_TEXTURE_2D_ARRAY = 0x8C1B; + TEXTURE_BINDING_1D_ARRAY = 0x8C1C; + TEXTURE_BINDING_2D_ARRAY = 0x8C1D; + R11F_G11F_B10F = 0x8C3A; + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; + RGB9_E5 = 0x8C3D; + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; + TEXTURE_SHARED_SIZE = 0x8C3F; + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; + PRIMITIVES_GENERATED = 0x8C87; + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; + RASTERIZER_DISCARD = 0x8C89; + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; + INTERLEAVED_ATTRIBS = 0x8C8C; + SEPARATE_ATTRIBS = 0x8C8D; + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; + RGBA32UI = 0x8D70; + RGB32UI = 0x8D71; + RGBA16UI = 0x8D76; + RGB16UI = 0x8D77; + RGBA8UI = 0x8D7C; + RGB8UI = 0x8D7D; + RGBA32I = 0x8D82; + RGB32I = 0x8D83; + RGBA16I = 0x8D88; + RGB16I = 0x8D89; + RGBA8I = 0x8D8E; + RGB8I = 0x8D8F; + RED_INTEGER = 0x8D94; + GREEN_INTEGER = 0x8D95; + BLUE_INTEGER = 0x8D96; + RGB_INTEGER = 0x8D98; + RGBA_INTEGER = 0x8D99; + BGR_INTEGER = 0x8D9A; + BGRA_INTEGER = 0x8D9B; + SAMPLER_1D_ARRAY = 0x8DC0; + SAMPLER_2D_ARRAY = 0x8DC1; + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3; + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; + SAMPLER_CUBE_SHADOW = 0x8DC5; + UNSIGNED_INT_VEC2 = 0x8DC6; + UNSIGNED_INT_VEC3 = 0x8DC7; + UNSIGNED_INT_VEC4 = 0x8DC8; + INT_SAMPLER_1D = 0x8DC9; + INT_SAMPLER_2D = 0x8DCA; + INT_SAMPLER_3D = 0x8DCB; + INT_SAMPLER_CUBE = 0x8DCC; + INT_SAMPLER_1D_ARRAY = 0x8DCE; + INT_SAMPLER_2D_ARRAY = 0x8DCF; + UNSIGNED_INT_SAMPLER_1D = 0x8DD1; + UNSIGNED_INT_SAMPLER_2D = 0x8DD2; + UNSIGNED_INT_SAMPLER_3D = 0x8DD3; + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6; + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; + QUERY_WAIT = 0x8E13; + QUERY_NO_WAIT = 0x8E14; + QUERY_BY_REGION_WAIT = 0x8E15; + QUERY_BY_REGION_NO_WAIT = 0x8E16; + BUFFER_ACCESS_FLAGS = 0x911F; + BUFFER_MAP_LENGTH = 0x9120; + BUFFER_MAP_OFFSET = 0x9121; + DEPTH_COMPONENT32F = 0x8CAC; + DEPTH32F_STENCIL8 = 0x8CAD; + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; + INVALID_FRAMEBUFFER_OPERATION = 0x0506; + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; + FRAMEBUFFER_DEFAULT = 0x8218; + FRAMEBUFFER_UNDEFINED = 0x8219; + DEPTH_STENCIL_ATTACHMENT = 0x821A; + MAX_RENDERBUFFER_SIZE = 0x84E8; + DEPTH_STENCIL = 0x84F9; + UNSIGNED_INT_24_8 = 0x84FA; + DEPTH24_STENCIL8 = 0x88F0; + TEXTURE_STENCIL_SIZE = 0x88F1; + TEXTURE_RED_TYPE = 0x8C10; + TEXTURE_GREEN_TYPE = 0x8C11; + TEXTURE_BLUE_TYPE = 0x8C12; + TEXTURE_ALPHA_TYPE = 0x8C13; + TEXTURE_DEPTH_TYPE = 0x8C16; + UNSIGNED_NORMALIZED = 0x8C17; + FRAMEBUFFER_BINDING = 0x8CA6; + DRAW_FRAMEBUFFER_BINDING = 0x8CA6; + RENDERBUFFER_BINDING = 0x8CA7; + READ_FRAMEBUFFER = 0x8CA8; + DRAW_FRAMEBUFFER = 0x8CA9; + READ_FRAMEBUFFER_BINDING = 0x8CAA; + RENDERBUFFER_SAMPLES = 0x8CAB; + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; + FRAMEBUFFER_COMPLETE = 0x8CD5; + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB; + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC; + FRAMEBUFFER_UNSUPPORTED = 0x8CDD; + MAX_COLOR_ATTACHMENTS = 0x8CDF; + COLOR_ATTACHMENT0 = 0x8CE0; + COLOR_ATTACHMENT1 = 0x8CE1; + COLOR_ATTACHMENT2 = 0x8CE2; + COLOR_ATTACHMENT3 = 0x8CE3; + COLOR_ATTACHMENT4 = 0x8CE4; + COLOR_ATTACHMENT5 = 0x8CE5; + COLOR_ATTACHMENT6 = 0x8CE6; + COLOR_ATTACHMENT7 = 0x8CE7; + COLOR_ATTACHMENT8 = 0x8CE8; + COLOR_ATTACHMENT9 = 0x8CE9; + COLOR_ATTACHMENT10 = 0x8CEA; + COLOR_ATTACHMENT11 = 0x8CEB; + COLOR_ATTACHMENT12 = 0x8CEC; + COLOR_ATTACHMENT13 = 0x8CED; + COLOR_ATTACHMENT14 = 0x8CEE; + COLOR_ATTACHMENT15 = 0x8CEF; + COLOR_ATTACHMENT16 = 0x8CF0; + COLOR_ATTACHMENT17 = 0x8CF1; + COLOR_ATTACHMENT18 = 0x8CF2; + COLOR_ATTACHMENT19 = 0x8CF3; + COLOR_ATTACHMENT20 = 0x8CF4; + COLOR_ATTACHMENT21 = 0x8CF5; + COLOR_ATTACHMENT22 = 0x8CF6; + COLOR_ATTACHMENT23 = 0x8CF7; + COLOR_ATTACHMENT24 = 0x8CF8; + COLOR_ATTACHMENT25 = 0x8CF9; + COLOR_ATTACHMENT26 = 0x8CFA; + COLOR_ATTACHMENT27 = 0x8CFB; + COLOR_ATTACHMENT28 = 0x8CFC; + COLOR_ATTACHMENT29 = 0x8CFD; + COLOR_ATTACHMENT30 = 0x8CFE; + COLOR_ATTACHMENT31 = 0x8CFF; + DEPTH_ATTACHMENT = 0x8D00; + STENCIL_ATTACHMENT = 0x8D20; + FRAMEBUFFER = 0x8D40; + RENDERBUFFER = 0x8D41; + RENDERBUFFER_WIDTH = 0x8D42; + RENDERBUFFER_HEIGHT = 0x8D43; + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; + STENCIL_INDEX1 = 0x8D46; + STENCIL_INDEX4 = 0x8D47; + STENCIL_INDEX8 = 0x8D48; + STENCIL_INDEX16 = 0x8D49; + RENDERBUFFER_RED_SIZE = 0x8D50; + RENDERBUFFER_GREEN_SIZE = 0x8D51; + RENDERBUFFER_BLUE_SIZE = 0x8D52; + RENDERBUFFER_ALPHA_SIZE = 0x8D53; + RENDERBUFFER_DEPTH_SIZE = 0x8D54; + RENDERBUFFER_STENCIL_SIZE = 0x8D55; + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; + MAX_SAMPLES = 0x8D57; + FRAMEBUFFER_SRGB = 0x8DB9; + HALF_FLOAT = 0x140B; + MAP_READ_BIT = 0x0001; + MAP_WRITE_BIT = 0x0002; + MAP_INVALIDATE_RANGE_BIT = 0x0004; + MAP_INVALIDATE_BUFFER_BIT = 0x0008; + MAP_FLUSH_EXPLICIT_BIT = 0x0010; + MAP_UNSYNCHRONIZED_BIT = 0x0020; + COMPRESSED_RED_RGTC1 = 0x8DBB; + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC; + COMPRESSED_RG_RGTC2 = 0x8DBD; + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; + RG = 0x8227; + RG_INTEGER = 0x8228; + R8 = 0x8229; + R16 = 0x822A; + RG8 = 0x822B; + RG16 = 0x822C; + R16F = 0x822D; + R32F = 0x822E; + RG16F = 0x822F; + RG32F = 0x8230; + R8I = 0x8231; + R8UI = 0x8232; + R16I = 0x8233; + R16UI = 0x8234; + R32I = 0x8235; + R32UI = 0x8236; + RG8I = 0x8237; + RG8UI = 0x8238; + RG16I = 0x8239; + RG16UI = 0x823A; + RG32I = 0x823B; + RG32UI = 0x823C; + VERTEX_ARRAY_BINDING = 0x85B5; -const SAMPLER_2D_RECT = 0x8B63; -const SAMPLER_2D_RECT_SHADOW = 0x8B64; -const SAMPLER_BUFFER = 0x8DC2; -const INT_SAMPLER_2D_RECT = 0x8DCD; -const INT_SAMPLER_BUFFER = 0x8DD0; -const UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5; -const UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8; -const TEXTURE_BUFFER = 0x8C2A; -const MAX_TEXTURE_BUFFER_SIZE = 0x8C2B; -const TEXTURE_BINDING_BUFFER = 0x8C2C; -const TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D; -const TEXTURE_RECTANGLE = 0x84F5; -const TEXTURE_BINDING_RECTANGLE = 0x84F6; -const PROXY_TEXTURE_RECTANGLE = 0x84F7; -const MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8; -const R8_SNORM = 0x8F94; -const RG8_SNORM = 0x8F95; -const RGB8_SNORM = 0x8F96; -const RGBA8_SNORM = 0x8F97; -const R16_SNORM = 0x8F98; -const RG16_SNORM = 0x8F99; -const RGB16_SNORM = 0x8F9A; -const RGBA16_SNORM = 0x8F9B; -const SIGNED_NORMALIZED = 0x8F9C; -const PRIMITIVE_RESTART = 0x8F9D; -const PRIMITIVE_RESTART_INDEX = 0x8F9E; -const COPY_READ_BUFFER = 0x8F36; -const COPY_WRITE_BUFFER = 0x8F37; -const UNIFORM_BUFFER = 0x8A11; -const UNIFORM_BUFFER_BINDING = 0x8A28; -const UNIFORM_BUFFER_START = 0x8A29; -const UNIFORM_BUFFER_SIZE = 0x8A2A; -const MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; -const MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C; -const MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; -const MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; -const MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; -const MAX_UNIFORM_BLOCK_SIZE = 0x8A30; -const MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; -const MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32; -const MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; -const UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; -const ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; -const ACTIVE_UNIFORM_BLOCKS = 0x8A36; -const UNIFORM_TYPE = 0x8A37; -const UNIFORM_SIZE = 0x8A38; -const UNIFORM_NAME_LENGTH = 0x8A39; -const UNIFORM_BLOCK_INDEX = 0x8A3A; -const UNIFORM_OFFSET = 0x8A3B; -const UNIFORM_ARRAY_STRIDE = 0x8A3C; -const UNIFORM_MATRIX_STRIDE = 0x8A3D; -const UNIFORM_IS_ROW_MAJOR = 0x8A3E; -const UNIFORM_BLOCK_BINDING = 0x8A3F; -const UNIFORM_BLOCK_DATA_SIZE = 0x8A40; -const UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; -const UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; -const UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; -const UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; -const UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45; -const UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; -const INVALID_INDEX = 0xFFFFFFFF; + SAMPLER_2D_RECT = 0x8B63; + SAMPLER_2D_RECT_SHADOW = 0x8B64; + SAMPLER_BUFFER = 0x8DC2; + INT_SAMPLER_2D_RECT = 0x8DCD; + INT_SAMPLER_BUFFER = 0x8DD0; + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5; + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8; + TEXTURE_BUFFER = 0x8C2A; + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B; + TEXTURE_BINDING_BUFFER = 0x8C2C; + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D; + TEXTURE_RECTANGLE = 0x84F5; + TEXTURE_BINDING_RECTANGLE = 0x84F6; + PROXY_TEXTURE_RECTANGLE = 0x84F7; + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8; + R8_SNORM = 0x8F94; + RG8_SNORM = 0x8F95; + RGB8_SNORM = 0x8F96; + RGBA8_SNORM = 0x8F97; + R16_SNORM = 0x8F98; + RG16_SNORM = 0x8F99; + RGB16_SNORM = 0x8F9A; + RGBA16_SNORM = 0x8F9B; + SIGNED_NORMALIZED = 0x8F9C; + PRIMITIVE_RESTART = 0x8F9D; + PRIMITIVE_RESTART_INDEX = 0x8F9E; + COPY_READ_BUFFER = 0x8F36; + COPY_WRITE_BUFFER = 0x8F37; + UNIFORM_BUFFER = 0x8A11; + UNIFORM_BUFFER_BINDING = 0x8A28; + UNIFORM_BUFFER_START = 0x8A29; + UNIFORM_BUFFER_SIZE = 0x8A2A; + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C; + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; + MAX_UNIFORM_BLOCK_SIZE = 0x8A30; + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32; + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; + ACTIVE_UNIFORM_BLOCKS = 0x8A36; + UNIFORM_TYPE = 0x8A37; + UNIFORM_SIZE = 0x8A38; + UNIFORM_NAME_LENGTH = 0x8A39; + UNIFORM_BLOCK_INDEX = 0x8A3A; + UNIFORM_OFFSET = 0x8A3B; + UNIFORM_ARRAY_STRIDE = 0x8A3C; + UNIFORM_MATRIX_STRIDE = 0x8A3D; + UNIFORM_IS_ROW_MAJOR = 0x8A3E; + UNIFORM_BLOCK_BINDING = 0x8A3F; + UNIFORM_BLOCK_DATA_SIZE = 0x8A40; + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45; + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; + INVALID_INDEX = 0xFFFFFFFF; -const CONTEXT_CORE_PROFILE_BIT = 0x00000001; -const CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002; -const LINES_ADJACENCY = 0x000A; -const LINE_STRIP_ADJACENCY = 0x000B; -const TRIANGLES_ADJACENCY = 0x000C; -const TRIANGLE_STRIP_ADJACENCY = 0x000D; -const PROGRAM_POINT_SIZE = 0x8642; -const MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29; -const FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7; -const FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8; -const GEOMETRY_SHADER = 0x8DD9; -const GEOMETRY_VERTICES_OUT = 0x8916; -const GEOMETRY_INPUT_TYPE = 0x8917; -const GEOMETRY_OUTPUT_TYPE = 0x8918; -const MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF; -const MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0; -const MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1; -const MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; -const MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123; -const MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124; -const MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; -const CONTEXT_PROFILE_MASK = 0x9126; -const DEPTH_CLAMP = 0x864F; -const QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; -const FIRST_VERTEX_CONVENTION = 0x8E4D; -const LAST_VERTEX_CONVENTION = 0x8E4E; -const PROVOKING_VERTEX = 0x8E4F; -const TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; -const MAX_SERVER_WAIT_TIMEOUT = 0x9111; -const OBJECT_TYPE = 0x9112; -const SYNC_CONDITION = 0x9113; -const SYNC_STATUS = 0x9114; -const SYNC_FLAGS = 0x9115; -const SYNC_FENCE = 0x9116; -const SYNC_GPU_COMMANDS_COMPLETE = 0x9117; -const UNSIGNALED = 0x9118; -const SIGNALED = 0x9119; -const ALREADY_SIGNALED = 0x911A; -const TIMEOUT_EXPIRED = 0x911B; -const CONDITION_SATISFIED = 0x911C; -const WAIT_FAILED = 0x911D; -const TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; -const SYNC_FLUSH_COMMANDS_BIT = 0x00000001; -const SAMPLE_POSITION = 0x8E50; -const SAMPLE_MASK = 0x8E51; -const SAMPLE_MASK_VALUE = 0x8E52; -const MAX_SAMPLE_MASK_WORDS = 0x8E59; -const TEXTURE_2D_MULTISAMPLE = 0x9100; -const PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; -const TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; -const PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; -const TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; -const TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; -const TEXTURE_SAMPLES = 0x9106; -const TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; -const SAMPLER_2D_MULTISAMPLE = 0x9108; -const INT_SAMPLER_2D_MULTISAMPLE = 0x9109; -const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; -const SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B; -const INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C; -const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; -const MAX_COLOR_TEXTURE_SAMPLES = 0x910E; -const MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; -const MAX_INTEGER_SAMPLES = 0x9110; + CONTEXT_CORE_PROFILE_BIT = 0x00000001; + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002; + LINES_ADJACENCY = 0x000A; + LINE_STRIP_ADJACENCY = 0x000B; + TRIANGLES_ADJACENCY = 0x000C; + TRIANGLE_STRIP_ADJACENCY = 0x000D; + PROGRAM_POINT_SIZE = 0x8642; + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29; + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7; + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8; + GEOMETRY_SHADER = 0x8DD9; + GEOMETRY_VERTICES_OUT = 0x8916; + GEOMETRY_INPUT_TYPE = 0x8917; + GEOMETRY_OUTPUT_TYPE = 0x8918; + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF; + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0; + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1; + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123; + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124; + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; + CONTEXT_PROFILE_MASK = 0x9126; + DEPTH_CLAMP = 0x864F; + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; + FIRST_VERTEX_CONVENTION = 0x8E4D; + LAST_VERTEX_CONVENTION = 0x8E4E; + PROVOKING_VERTEX = 0x8E4F; + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; + MAX_SERVER_WAIT_TIMEOUT = 0x9111; + OBJECT_TYPE = 0x9112; + SYNC_CONDITION = 0x9113; + SYNC_STATUS = 0x9114; + SYNC_FLAGS = 0x9115; + SYNC_FENCE = 0x9116; + SYNC_GPU_COMMANDS_COMPLETE = 0x9117; + UNSIGNALED = 0x9118; + SIGNALED = 0x9119; + ALREADY_SIGNALED = 0x911A; + TIMEOUT_EXPIRED = 0x911B; + CONDITION_SATISFIED = 0x911C; + WAIT_FAILED = 0x911D; + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; + SYNC_FLUSH_COMMANDS_BIT = 0x00000001; + SAMPLE_POSITION = 0x8E50; + SAMPLE_MASK = 0x8E51; + SAMPLE_MASK_VALUE = 0x8E52; + MAX_SAMPLE_MASK_WORDS = 0x8E59; + TEXTURE_2D_MULTISAMPLE = 0x9100; + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; + TEXTURE_SAMPLES = 0x9106; + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; + SAMPLER_2D_MULTISAMPLE = 0x9108; + INT_SAMPLER_2D_MULTISAMPLE = 0x9109; + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B; + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C; + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; + MAX_COLOR_TEXTURE_SAMPLES = 0x910E; + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; + MAX_INTEGER_SAMPLES = 0x9110; -const VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; -const SRC1_COLOR = 0x88F9; -const ONE_MINUS_SRC1_COLOR = 0x88FA; -const ONE_MINUS_SRC1_ALPHA = 0x88FB; -const MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; -const ANY_SAMPLES_PASSED = 0x8C2F; -const SAMPLER_BINDING = 0x8919; -const RGB10_A2UI = 0x906F; -const TEXTURE_SWIZZLE_R = 0x8E42; -const TEXTURE_SWIZZLE_G = 0x8E43; -const TEXTURE_SWIZZLE_B = 0x8E44; -const TEXTURE_SWIZZLE_A = 0x8E45; -const TEXTURE_SWIZZLE_RGBA = 0x8E46; -const TIME_ELAPSED = 0x88BF; -const TIMESTAMP = 0x8E28; -const INT_2_10_10_10_REV = 0x8D9F; + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; + SRC1_COLOR = 0x88F9; + ONE_MINUS_SRC1_COLOR = 0x88FA; + ONE_MINUS_SRC1_ALPHA = 0x88FB; + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; + ANY_SAMPLES_PASSED = 0x8C2F; + SAMPLER_BINDING = 0x8919; + RGB10_A2UI = 0x906F; + TEXTURE_SWIZZLE_R = 0x8E42; + TEXTURE_SWIZZLE_G = 0x8E43; + TEXTURE_SWIZZLE_B = 0x8E44; + TEXTURE_SWIZZLE_A = 0x8E45; + TEXTURE_SWIZZLE_RGBA = 0x8E46; + TIME_ELAPSED = 0x88BF; + TIMESTAMP = 0x8E28; + INT_2_10_10_10_REV = 0x8D9F; -const SAMPLE_SHADING = 0x8C36; -const MIN_SAMPLE_SHADING_VALUE = 0x8C37; -const MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E; -const MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F; -const TEXTURE_CUBE_MAP_ARRAY = 0x9009; -const TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A; -const PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B; -const SAMPLER_CUBE_MAP_ARRAY = 0x900C; -const SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D; -const INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E; -const UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F; -const DRAW_INDIRECT_BUFFER = 0x8F3F; -const DRAW_INDIRECT_BUFFER_BINDING = 0x8F43; -const GEOMETRY_SHADER_INVOCATIONS = 0x887F; -const MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A; -const MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B; -const MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C; -const FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D; -const MAX_VERTEX_STREAMS = 0x8E71; -const DOUBLE_VEC2 = 0x8FFC; -const DOUBLE_VEC3 = 0x8FFD; -const DOUBLE_VEC4 = 0x8FFE; -const DOUBLE_MAT2 = 0x8F46; -const DOUBLE_MAT3 = 0x8F47; -const DOUBLE_MAT4 = 0x8F48; -const DOUBLE_MAT2x3 = 0x8F49; -const DOUBLE_MAT2x4 = 0x8F4A; -const DOUBLE_MAT3x2 = 0x8F4B; -const DOUBLE_MAT3x4 = 0x8F4C; -const DOUBLE_MAT4x2 = 0x8F4D; -const DOUBLE_MAT4x3 = 0x8F4E; -const ACTIVE_SUBROUTINES = 0x8DE5; -const ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6; -const ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47; -const ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48; -const ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49; -const MAX_SUBROUTINES = 0x8DE7; -const MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8; -const NUM_COMPATIBLE_SUBROUTINES = 0x8E4A; -const COMPATIBLE_SUBROUTINES = 0x8E4B; -const PATCHES = 0x000E; -const PATCH_VERTICES = 0x8E72; -const PATCH_DEFAULT_INNER_LEVEL = 0x8E73; -const PATCH_DEFAULT_OUTER_LEVEL = 0x8E74; -const TESS_CONTROL_OUTPUT_VERTICES = 0x8E75; -const TESS_GEN_MODE = 0x8E76; -const TESS_GEN_SPACING = 0x8E77; -const TESS_GEN_VERTEX_ORDER = 0x8E78; -const TESS_GEN_POINT_MODE = 0x8E79; -const ISOLINES = 0x8E7A; -const FRACTIONAL_ODD = 0x8E7B; -const FRACTIONAL_EVEN = 0x8E7C; -const MAX_PATCH_VERTICES = 0x8E7D; -const MAX_TESS_GEN_LEVEL = 0x8E7E; -const MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F; -const MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80; -const MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81; -const MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82; -const MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83; -const MAX_TESS_PATCH_COMPONENTS = 0x8E84; -const MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85; -const MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86; -const MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89; -const MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A; -const MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C; -const MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D; -const MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E; -const MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F; -const UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0; -const UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1; -const TESS_EVALUATION_SHADER = 0x8E87; -const TESS_CONTROL_SHADER = 0x8E88; -const TRANSFORM_FEEDBACK = 0x8E22; -const TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23; -const TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24; -const TRANSFORM_FEEDBACK_BINDING = 0x8E25; -const MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70; + SAMPLE_SHADING = 0x8C36; + MIN_SAMPLE_SHADING_VALUE = 0x8C37; + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E; + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F; + TEXTURE_CUBE_MAP_ARRAY = 0x9009; + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A; + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B; + SAMPLER_CUBE_MAP_ARRAY = 0x900C; + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D; + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E; + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F; + DRAW_INDIRECT_BUFFER = 0x8F3F; + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43; + GEOMETRY_SHADER_INVOCATIONS = 0x887F; + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A; + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B; + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C; + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D; + MAX_VERTEX_STREAMS = 0x8E71; + DOUBLE_VEC2 = 0x8FFC; + DOUBLE_VEC3 = 0x8FFD; + DOUBLE_VEC4 = 0x8FFE; + DOUBLE_MAT2 = 0x8F46; + DOUBLE_MAT3 = 0x8F47; + DOUBLE_MAT4 = 0x8F48; + DOUBLE_MAT2x3 = 0x8F49; + DOUBLE_MAT2x4 = 0x8F4A; + DOUBLE_MAT3x2 = 0x8F4B; + DOUBLE_MAT3x4 = 0x8F4C; + DOUBLE_MAT4x2 = 0x8F4D; + DOUBLE_MAT4x3 = 0x8F4E; + ACTIVE_SUBROUTINES = 0x8DE5; + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6; + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47; + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48; + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49; + MAX_SUBROUTINES = 0x8DE7; + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8; + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A; + COMPATIBLE_SUBROUTINES = 0x8E4B; + PATCHES = 0x000E; + PATCH_VERTICES = 0x8E72; + PATCH_DEFAULT_INNER_LEVEL = 0x8E73; + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74; + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75; + TESS_GEN_MODE = 0x8E76; + TESS_GEN_SPACING = 0x8E77; + TESS_GEN_VERTEX_ORDER = 0x8E78; + TESS_GEN_POINT_MODE = 0x8E79; + ISOLINES = 0x8E7A; + FRACTIONAL_ODD = 0x8E7B; + FRACTIONAL_EVEN = 0x8E7C; + MAX_PATCH_VERTICES = 0x8E7D; + MAX_TESS_GEN_LEVEL = 0x8E7E; + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F; + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80; + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81; + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82; + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83; + MAX_TESS_PATCH_COMPONENTS = 0x8E84; + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85; + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86; + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89; + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A; + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C; + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D; + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E; + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F; + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0; + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1; + TESS_EVALUATION_SHADER = 0x8E87; + TESS_CONTROL_SHADER = 0x8E88; + TRANSFORM_FEEDBACK = 0x8E22; + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23; + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24; + TRANSFORM_FEEDBACK_BINDING = 0x8E25; + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70; -const FIXED = 0x140C; -const IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; -const IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; -const LOW_FLOAT = 0x8DF0; -const MEDIUM_FLOAT = 0x8DF1; -const HIGH_FLOAT = 0x8DF2; -const LOW_INT = 0x8DF3; -const MEDIUM_INT = 0x8DF4; -const HIGH_INT = 0x8DF5; -const SHADER_COMPILER = 0x8DFA; -const SHADER_BINARY_FORMATS = 0x8DF8; -const NUM_SHADER_BINARY_FORMATS = 0x8DF9; -const MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; -const MAX_VARYING_VECTORS = 0x8DFC; -const MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; -const RGB565 = 0x8D62; -const PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; -const PROGRAM_BINARY_LENGTH = 0x8741; -const NUM_PROGRAM_BINARY_FORMATS = 0x87FE; -const PROGRAM_BINARY_FORMATS = 0x87FF; -const VERTEX_SHADER_BIT = 0x00000001; -const FRAGMENT_SHADER_BIT = 0x00000002; -const GEOMETRY_SHADER_BIT = 0x00000004; -const TESS_CONTROL_SHADER_BIT = 0x00000008; -const TESS_EVALUATION_SHADER_BIT = 0x00000010; -const ALL_SHADER_BITS = 0xFFFFFFFF; -const PROGRAM_SEPARABLE = 0x8258; -const ACTIVE_PROGRAM = 0x8259; -const PROGRAM_PIPELINE_BINDING = 0x825A; -const MAX_VIEWPORTS = 0x825B; -const VIEWPORT_SUBPIXEL_BITS = 0x825C; -const VIEWPORT_BOUNDS_RANGE = 0x825D; -const LAYER_PROVOKING_VERTEX = 0x825E; -const VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F; -const UNDEFINED_VERTEX = 0x8260; + FIXED = 0x140C; + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; + LOW_FLOAT = 0x8DF0; + MEDIUM_FLOAT = 0x8DF1; + HIGH_FLOAT = 0x8DF2; + LOW_INT = 0x8DF3; + MEDIUM_INT = 0x8DF4; + HIGH_INT = 0x8DF5; + SHADER_COMPILER = 0x8DFA; + SHADER_BINARY_FORMATS = 0x8DF8; + NUM_SHADER_BINARY_FORMATS = 0x8DF9; + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; + MAX_VARYING_VECTORS = 0x8DFC; + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; + RGB565 = 0x8D62; + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; + PROGRAM_BINARY_LENGTH = 0x8741; + NUM_PROGRAM_BINARY_FORMATS = 0x87FE; + PROGRAM_BINARY_FORMATS = 0x87FF; + VERTEX_SHADER_BIT = 0x00000001; + FRAGMENT_SHADER_BIT = 0x00000002; + GEOMETRY_SHADER_BIT = 0x00000004; + TESS_CONTROL_SHADER_BIT = 0x00000008; + TESS_EVALUATION_SHADER_BIT = 0x00000010; + ALL_SHADER_BITS = 0xFFFFFFFF; + PROGRAM_SEPARABLE = 0x8258; + ACTIVE_PROGRAM = 0x8259; + PROGRAM_PIPELINE_BINDING = 0x825A; + MAX_VIEWPORTS = 0x825B; + VIEWPORT_SUBPIXEL_BITS = 0x825C; + VIEWPORT_BOUNDS_RANGE = 0x825D; + LAYER_PROVOKING_VERTEX = 0x825E; + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F; + UNDEFINED_VERTEX = 0x8260; -const COPY_READ_BUFFER_BINDING = 0x8F36; -const COPY_WRITE_BUFFER_BINDING = 0x8F37; -const TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; -const TRANSFORM_FEEDBACK_PAUSED = 0x8E23; -const UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127; -const UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128; -const UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129; -const UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A; -const PACK_COMPRESSED_BLOCK_WIDTH = 0x912B; -const PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C; -const PACK_COMPRESSED_BLOCK_DEPTH = 0x912D; -const PACK_COMPRESSED_BLOCK_SIZE = 0x912E; -const NUM_SAMPLE_COUNTS = 0x9380; -const MIN_MAP_BUFFER_ALIGNMENT = 0x90BC; -const ATOMIC_COUNTER_BUFFER = 0x92C0; -const ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1; -const ATOMIC_COUNTER_BUFFER_START = 0x92C2; -const ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3; -const ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4; -const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5; -const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB; -const MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC; -const MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD; -const MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE; -const MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF; -const MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0; -const MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1; -const MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2; -const MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3; -const MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4; -const MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5; -const MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6; -const MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7; -const MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8; -const MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC; -const ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9; -const UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA; -const UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB; -const VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001; -const ELEMENT_ARRAY_BARRIER_BIT = 0x00000002; -const UNIFORM_BARRIER_BIT = 0x00000004; -const TEXTURE_FETCH_BARRIER_BIT = 0x00000008; -const SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020; -const COMMAND_BARRIER_BIT = 0x00000040; -const PIXEL_BUFFER_BARRIER_BIT = 0x00000080; -const TEXTURE_UPDATE_BARRIER_BIT = 0x00000100; -const BUFFER_UPDATE_BARRIER_BIT = 0x00000200; -const FRAMEBUFFER_BARRIER_BIT = 0x00000400; -const TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800; -const ATOMIC_COUNTER_BARRIER_BIT = 0x00001000; -const ALL_BARRIER_BITS = 0xFFFFFFFF; -const MAX_IMAGE_UNITS = 0x8F38; -const MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39; -const IMAGE_BINDING_NAME = 0x8F3A; -const IMAGE_BINDING_LEVEL = 0x8F3B; -const IMAGE_BINDING_LAYERED = 0x8F3C; -const IMAGE_BINDING_LAYER = 0x8F3D; -const IMAGE_BINDING_ACCESS = 0x8F3E; -const IMAGE_1D = 0x904C; -const IMAGE_2D = 0x904D; -const IMAGE_3D = 0x904E; -const IMAGE_2D_RECT = 0x904F; -const IMAGE_CUBE = 0x9050; -const IMAGE_BUFFER = 0x9051; -const IMAGE_1D_ARRAY = 0x9052; -const IMAGE_2D_ARRAY = 0x9053; -const IMAGE_CUBE_MAP_ARRAY = 0x9054; -const IMAGE_2D_MULTISAMPLE = 0x9055; -const IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056; -const INT_IMAGE_1D = 0x9057; -const INT_IMAGE_2D = 0x9058; -const INT_IMAGE_3D = 0x9059; -const INT_IMAGE_2D_RECT = 0x905A; -const INT_IMAGE_CUBE = 0x905B; -const INT_IMAGE_BUFFER = 0x905C; -const INT_IMAGE_1D_ARRAY = 0x905D; -const INT_IMAGE_2D_ARRAY = 0x905E; -const INT_IMAGE_CUBE_MAP_ARRAY = 0x905F; -const INT_IMAGE_2D_MULTISAMPLE = 0x9060; -const INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061; -const UNSIGNED_INT_IMAGE_1D = 0x9062; -const UNSIGNED_INT_IMAGE_2D = 0x9063; -const UNSIGNED_INT_IMAGE_3D = 0x9064; -const UNSIGNED_INT_IMAGE_2D_RECT = 0x9065; -const UNSIGNED_INT_IMAGE_CUBE = 0x9066; -const UNSIGNED_INT_IMAGE_BUFFER = 0x9067; -const UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068; -const UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069; -const UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A; -const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B; -const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C; -const MAX_IMAGE_SAMPLES = 0x906D; -const IMAGE_BINDING_FORMAT = 0x906E; -const IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7; -const IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8; -const IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9; -const MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA; -const MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB; -const MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC; -const MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD; -const MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE; -const MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF; -const COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C; -const COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D; -const COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E; -const COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F; -const TEXTURE_IMMUTABLE_FORMAT = 0x912F; + COPY_READ_BUFFER_BINDING = 0x8F36; + COPY_WRITE_BUFFER_BINDING = 0x8F37; + TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; + TRANSFORM_FEEDBACK_PAUSED = 0x8E23; + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127; + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128; + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129; + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A; + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B; + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C; + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D; + PACK_COMPRESSED_BLOCK_SIZE = 0x912E; + NUM_SAMPLE_COUNTS = 0x9380; + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC; + ATOMIC_COUNTER_BUFFER = 0x92C0; + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1; + ATOMIC_COUNTER_BUFFER_START = 0x92C2; + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3; + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4; + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5; + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB; + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC; + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD; + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE; + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF; + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0; + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1; + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2; + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3; + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4; + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5; + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6; + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7; + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8; + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC; + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9; + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA; + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB; + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001; + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002; + UNIFORM_BARRIER_BIT = 0x00000004; + TEXTURE_FETCH_BARRIER_BIT = 0x00000008; + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020; + COMMAND_BARRIER_BIT = 0x00000040; + PIXEL_BUFFER_BARRIER_BIT = 0x00000080; + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100; + BUFFER_UPDATE_BARRIER_BIT = 0x00000200; + FRAMEBUFFER_BARRIER_BIT = 0x00000400; + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800; + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000; + ALL_BARRIER_BITS = 0xFFFFFFFF; + MAX_IMAGE_UNITS = 0x8F38; + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39; + IMAGE_BINDING_NAME = 0x8F3A; + IMAGE_BINDING_LEVEL = 0x8F3B; + IMAGE_BINDING_LAYERED = 0x8F3C; + IMAGE_BINDING_LAYER = 0x8F3D; + IMAGE_BINDING_ACCESS = 0x8F3E; + IMAGE_1D = 0x904C; + IMAGE_2D = 0x904D; + IMAGE_3D = 0x904E; + IMAGE_2D_RECT = 0x904F; + IMAGE_CUBE = 0x9050; + IMAGE_BUFFER = 0x9051; + IMAGE_1D_ARRAY = 0x9052; + IMAGE_2D_ARRAY = 0x9053; + IMAGE_CUBE_MAP_ARRAY = 0x9054; + IMAGE_2D_MULTISAMPLE = 0x9055; + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056; + INT_IMAGE_1D = 0x9057; + INT_IMAGE_2D = 0x9058; + INT_IMAGE_3D = 0x9059; + INT_IMAGE_2D_RECT = 0x905A; + INT_IMAGE_CUBE = 0x905B; + INT_IMAGE_BUFFER = 0x905C; + INT_IMAGE_1D_ARRAY = 0x905D; + INT_IMAGE_2D_ARRAY = 0x905E; + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F; + INT_IMAGE_2D_MULTISAMPLE = 0x9060; + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061; + UNSIGNED_INT_IMAGE_1D = 0x9062; + UNSIGNED_INT_IMAGE_2D = 0x9063; + UNSIGNED_INT_IMAGE_3D = 0x9064; + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065; + UNSIGNED_INT_IMAGE_CUBE = 0x9066; + UNSIGNED_INT_IMAGE_BUFFER = 0x9067; + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068; + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069; + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A; + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B; + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C; + MAX_IMAGE_SAMPLES = 0x906D; + IMAGE_BINDING_FORMAT = 0x906E; + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7; + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8; + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9; + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA; + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB; + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC; + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD; + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE; + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF; + COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C; + COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D; + COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E; + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F; + TEXTURE_IMMUTABLE_FORMAT = 0x912F; -const NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9; -const VERTEX_ATTRIB_ARRAY_LONG = 0x874E; -const COMPRESSED_RGB8_ETC2 = 0x9274; -const COMPRESSED_SRGB8_ETC2 = 0x9275; -const COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; -const COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; -const COMPRESSED_RGBA8_ETC2_EAC = 0x9278; -const COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; -const COMPRESSED_R11_EAC = 0x9270; -const COMPRESSED_SIGNED_R11_EAC = 0x9271; -const COMPRESSED_RG11_EAC = 0x9272; -const COMPRESSED_SIGNED_RG11_EAC = 0x9273; -const PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; -const ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; -const MAX_ELEMENT_INDEX = 0x8D6B; -const COMPUTE_SHADER = 0x91B9; -const MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB; -const MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC; -const MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD; -const MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262; -const MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263; -const MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264; -const MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265; -const MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266; -const MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB; -const MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE; -const MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF; -const COMPUTE_WORK_GROUP_SIZE = 0x8267; -const UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED; -const DISPATCH_INDIRECT_BUFFER = 0x90EE; -const DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF; -const COMPUTE_SHADER_BIT = 0x00000020; -const DEBUG_OUTPUT_SYNCHRONOUS = 0x8242; -const DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243; -const DEBUG_CALLBACK_FUNCTION = 0x8244; -const DEBUG_CALLBACK_USER_PARAM = 0x8245; -const DEBUG_SOURCE_API = 0x8246; -const DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247; -const DEBUG_SOURCE_SHADER_COMPILER = 0x8248; -const DEBUG_SOURCE_THIRD_PARTY = 0x8249; -const DEBUG_SOURCE_APPLICATION = 0x824A; -const DEBUG_SOURCE_OTHER = 0x824B; -const DEBUG_TYPE_ERROR = 0x824C; -const DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D; -const DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E; -const DEBUG_TYPE_PORTABILITY = 0x824F; -const DEBUG_TYPE_PERFORMANCE = 0x8250; -const DEBUG_TYPE_OTHER = 0x8251; -const MAX_DEBUG_MESSAGE_LENGTH = 0x9143; -const MAX_DEBUG_LOGGED_MESSAGES = 0x9144; -const DEBUG_LOGGED_MESSAGES = 0x9145; -const DEBUG_SEVERITY_HIGH = 0x9146; -const DEBUG_SEVERITY_MEDIUM = 0x9147; -const DEBUG_SEVERITY_LOW = 0x9148; -const DEBUG_TYPE_MARKER = 0x8268; -const DEBUG_TYPE_PUSH_GROUP = 0x8269; -const DEBUG_TYPE_POP_GROUP = 0x826A; -const DEBUG_SEVERITY_NOTIFICATION = 0x826B; -const MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C; -const DEBUG_GROUP_STACK_DEPTH = 0x826D; -const BUFFER = 0x82E0; -const SHADER = 0x82E1; -const PROGRAM = 0x82E2; -const QUERY = 0x82E3; -const PROGRAM_PIPELINE = 0x82E4; -const SAMPLER = 0x82E6; -const MAX_LABEL_LENGTH = 0x82E8; -const DEBUG_OUTPUT = 0x92E0; -const CONTEXT_FLAG_DEBUG_BIT = 0x00000002; -const MAX_UNIFORM_LOCATIONS = 0x826E; -const FRAMEBUFFER_DEFAULT_WIDTH = 0x9310; -const FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311; -const FRAMEBUFFER_DEFAULT_LAYERS = 0x9312; -const FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313; -const FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314; -const MAX_FRAMEBUFFER_WIDTH = 0x9315; -const MAX_FRAMEBUFFER_HEIGHT = 0x9316; -const MAX_FRAMEBUFFER_LAYERS = 0x9317; -const MAX_FRAMEBUFFER_SAMPLES = 0x9318; -const INTERNALFORMAT_SUPPORTED = 0x826F; -const INTERNALFORMAT_PREFERRED = 0x8270; -const INTERNALFORMAT_RED_SIZE = 0x8271; -const INTERNALFORMAT_GREEN_SIZE = 0x8272; -const INTERNALFORMAT_BLUE_SIZE = 0x8273; -const INTERNALFORMAT_ALPHA_SIZE = 0x8274; -const INTERNALFORMAT_DEPTH_SIZE = 0x8275; -const INTERNALFORMAT_STENCIL_SIZE = 0x8276; -const INTERNALFORMAT_SHARED_SIZE = 0x8277; -const INTERNALFORMAT_RED_TYPE = 0x8278; -const INTERNALFORMAT_GREEN_TYPE = 0x8279; -const INTERNALFORMAT_BLUE_TYPE = 0x827A; -const INTERNALFORMAT_ALPHA_TYPE = 0x827B; -const INTERNALFORMAT_DEPTH_TYPE = 0x827C; -const INTERNALFORMAT_STENCIL_TYPE = 0x827D; -const MAX_WIDTH = 0x827E; -const MAX_HEIGHT = 0x827F; -const MAX_DEPTH = 0x8280; -const MAX_LAYERS = 0x8281; -const MAX_COMBINED_DIMENSIONS = 0x8282; -const COLOR_COMPONENTS = 0x8283; -const DEPTH_COMPONENTS = 0x8284; -const STENCIL_COMPONENTS = 0x8285; -const COLOR_RENDERABLE = 0x8286; -const DEPTH_RENDERABLE = 0x8287; -const STENCIL_RENDERABLE = 0x8288; -const FRAMEBUFFER_RENDERABLE = 0x8289; -const FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A; -const FRAMEBUFFER_BLEND = 0x828B; -const READ_PIXELS = 0x828C; -const READ_PIXELS_FORMAT = 0x828D; -const READ_PIXELS_TYPE = 0x828E; -const TEXTURE_IMAGE_FORMAT = 0x828F; -const TEXTURE_IMAGE_TYPE = 0x8290; -const GET_TEXTURE_IMAGE_FORMAT = 0x8291; -const GET_TEXTURE_IMAGE_TYPE = 0x8292; -const MIPMAP = 0x8293; -const MANUAL_GENERATE_MIPMAP = 0x8294; -const AUTO_GENERATE_MIPMAP = 0x8295; -const COLOR_ENCODING = 0x8296; -const SRGB_READ = 0x8297; -const SRGB_WRITE = 0x8298; -const FILTER = 0x829A; -const VERTEX_TEXTURE = 0x829B; -const TESS_CONTROL_TEXTURE = 0x829C; -const TESS_EVALUATION_TEXTURE = 0x829D; -const GEOMETRY_TEXTURE = 0x829E; -const FRAGMENT_TEXTURE = 0x829F; -const COMPUTE_TEXTURE = 0x82A0; -const TEXTURE_SHADOW = 0x82A1; -const TEXTURE_GATHER = 0x82A2; -const TEXTURE_GATHER_SHADOW = 0x82A3; -const SHADER_IMAGE_LOAD = 0x82A4; -const SHADER_IMAGE_STORE = 0x82A5; -const SHADER_IMAGE_ATOMIC = 0x82A6; -const IMAGE_TEXEL_SIZE = 0x82A7; -const IMAGE_COMPATIBILITY_CLASS = 0x82A8; -const IMAGE_PIXEL_FORMAT = 0x82A9; -const IMAGE_PIXEL_TYPE = 0x82AA; -const SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC; -const SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD; -const SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE; -const SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF; -const TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1; -const TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2; -const TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3; -const CLEAR_BUFFER = 0x82B4; -const TEXTURE_VIEW = 0x82B5; -const VIEW_COMPATIBILITY_CLASS = 0x82B6; -const FULL_SUPPORT = 0x82B7; -const CAVEAT_SUPPORT = 0x82B8; -const IMAGE_CLASS_4_X_32 = 0x82B9; -const IMAGE_CLASS_2_X_32 = 0x82BA; -const IMAGE_CLASS_1_X_32 = 0x82BB; -const IMAGE_CLASS_4_X_16 = 0x82BC; -const IMAGE_CLASS_2_X_16 = 0x82BD; -const IMAGE_CLASS_1_X_16 = 0x82BE; -const IMAGE_CLASS_4_X_8 = 0x82BF; -const IMAGE_CLASS_2_X_8 = 0x82C0; -const IMAGE_CLASS_1_X_8 = 0x82C1; -const IMAGE_CLASS_11_11_10 = 0x82C2; -const IMAGE_CLASS_10_10_10_2 = 0x82C3; -const VIEW_CLASS_128_BITS = 0x82C4; -const VIEW_CLASS_96_BITS = 0x82C5; -const VIEW_CLASS_64_BITS = 0x82C6; -const VIEW_CLASS_48_BITS = 0x82C7; -const VIEW_CLASS_32_BITS = 0x82C8; -const VIEW_CLASS_24_BITS = 0x82C9; -const VIEW_CLASS_16_BITS = 0x82CA; -const VIEW_CLASS_8_BITS = 0x82CB; -const VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC; -const VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD; -const VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE; -const VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF; -const VIEW_CLASS_RGTC1_RED = 0x82D0; -const VIEW_CLASS_RGTC2_RG = 0x82D1; -const VIEW_CLASS_BPTC_UNORM = 0x82D2; -const VIEW_CLASS_BPTC_FLOAT = 0x82D3; -const UNIFORM = 0x92E1; -const UNIFORM_BLOCK = 0x92E2; -const PROGRAM_INPUT = 0x92E3; -const PROGRAM_OUTPUT = 0x92E4; -const BUFFER_VARIABLE = 0x92E5; -const SHADER_STORAGE_BLOCK = 0x92E6; -const VERTEX_SUBROUTINE = 0x92E8; -const TESS_CONTROL_SUBROUTINE = 0x92E9; -const TESS_EVALUATION_SUBROUTINE = 0x92EA; -const GEOMETRY_SUBROUTINE = 0x92EB; -const FRAGMENT_SUBROUTINE = 0x92EC; -const COMPUTE_SUBROUTINE = 0x92ED; -const VERTEX_SUBROUTINE_UNIFORM = 0x92EE; -const TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF; -const TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0; -const GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1; -const FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2; -const COMPUTE_SUBROUTINE_UNIFORM = 0x92F3; -const TRANSFORM_FEEDBACK_VARYING = 0x92F4; -const ACTIVE_RESOURCES = 0x92F5; -const MAX_NAME_LENGTH = 0x92F6; -const MAX_NUM_ACTIVE_VARIABLES = 0x92F7; -const MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8; -const NAME_LENGTH = 0x92F9; -const TYPE = 0x92FA; -const ARRAY_SIZE = 0x92FB; -const OFFSET = 0x92FC; -const BLOCK_INDEX = 0x92FD; -const ARRAY_STRIDE = 0x92FE; -const MATRIX_STRIDE = 0x92FF; -const IS_ROW_MAJOR = 0x9300; -const ATOMIC_COUNTER_BUFFER_INDEX = 0x9301; -const BUFFER_BINDING = 0x9302; -const BUFFER_DATA_SIZE = 0x9303; -const NUM_ACTIVE_VARIABLES = 0x9304; -const ACTIVE_VARIABLES = 0x9305; -const REFERENCED_BY_VERTEX_SHADER = 0x9306; -const REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307; -const REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308; -const REFERENCED_BY_GEOMETRY_SHADER = 0x9309; -const REFERENCED_BY_FRAGMENT_SHADER = 0x930A; -const REFERENCED_BY_COMPUTE_SHADER = 0x930B; -const TOP_LEVEL_ARRAY_SIZE = 0x930C; -const TOP_LEVEL_ARRAY_STRIDE = 0x930D; -const LOCATION = 0x930E; -const LOCATION_INDEX = 0x930F; -const IS_PER_PATCH = 0x92E7; -const SHADER_STORAGE_BUFFER = 0x90D2; -const SHADER_STORAGE_BUFFER_BINDING = 0x90D3; -const SHADER_STORAGE_BUFFER_START = 0x90D4; -const SHADER_STORAGE_BUFFER_SIZE = 0x90D5; -const MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6; -const MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7; -const MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8; -const MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9; -const MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA; -const MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB; -const MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC; -const MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD; -const MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE; -const SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF; -const SHADER_STORAGE_BARRIER_BIT = 0x00002000; -const MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39; -const DEPTH_STENCIL_TEXTURE_MODE = 0x90EA; -const TEXTURE_BUFFER_OFFSET = 0x919D; -const TEXTURE_BUFFER_SIZE = 0x919E; -const TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F; -const TEXTURE_VIEW_MIN_LEVEL = 0x82DB; -const TEXTURE_VIEW_NUM_LEVELS = 0x82DC; -const TEXTURE_VIEW_MIN_LAYER = 0x82DD; -const TEXTURE_VIEW_NUM_LAYERS = 0x82DE; -const TEXTURE_IMMUTABLE_LEVELS = 0x82DF; -const VERTEX_ATTRIB_BINDING = 0x82D4; -const VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5; -const VERTEX_BINDING_DIVISOR = 0x82D6; -const VERTEX_BINDING_OFFSET = 0x82D7; -const VERTEX_BINDING_STRIDE = 0x82D8; -const MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9; -const MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA; -const VERTEX_BINDING_BUFFER = 0x8F4F; + NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9; + VERTEX_ATTRIB_ARRAY_LONG = 0x874E; + COMPRESSED_RGB8_ETC2 = 0x9274; + COMPRESSED_SRGB8_ETC2 = 0x9275; + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; + COMPRESSED_RGBA8_ETC2_EAC = 0x9278; + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; + COMPRESSED_R11_EAC = 0x9270; + COMPRESSED_SIGNED_R11_EAC = 0x9271; + COMPRESSED_RG11_EAC = 0x9272; + COMPRESSED_SIGNED_RG11_EAC = 0x9273; + PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; + ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; + MAX_ELEMENT_INDEX = 0x8D6B; + COMPUTE_SHADER = 0x91B9; + MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB; + MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC; + MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD; + MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262; + MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263; + MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264; + MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265; + MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266; + MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB; + MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE; + MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF; + COMPUTE_WORK_GROUP_SIZE = 0x8267; + UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED; + DISPATCH_INDIRECT_BUFFER = 0x90EE; + DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF; + COMPUTE_SHADER_BIT = 0x00000020; + DEBUG_OUTPUT_SYNCHRONOUS = 0x8242; + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243; + DEBUG_CALLBACK_FUNCTION = 0x8244; + DEBUG_CALLBACK_USER_PARAM = 0x8245; + DEBUG_SOURCE_API = 0x8246; + DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247; + DEBUG_SOURCE_SHADER_COMPILER = 0x8248; + DEBUG_SOURCE_THIRD_PARTY = 0x8249; + DEBUG_SOURCE_APPLICATION = 0x824A; + DEBUG_SOURCE_OTHER = 0x824B; + DEBUG_TYPE_ERROR = 0x824C; + DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D; + DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E; + DEBUG_TYPE_PORTABILITY = 0x824F; + DEBUG_TYPE_PERFORMANCE = 0x8250; + DEBUG_TYPE_OTHER = 0x8251; + MAX_DEBUG_MESSAGE_LENGTH = 0x9143; + MAX_DEBUG_LOGGED_MESSAGES = 0x9144; + DEBUG_LOGGED_MESSAGES = 0x9145; + DEBUG_SEVERITY_HIGH = 0x9146; + DEBUG_SEVERITY_MEDIUM = 0x9147; + DEBUG_SEVERITY_LOW = 0x9148; + DEBUG_TYPE_MARKER = 0x8268; + DEBUG_TYPE_PUSH_GROUP = 0x8269; + DEBUG_TYPE_POP_GROUP = 0x826A; + DEBUG_SEVERITY_NOTIFICATION = 0x826B; + MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C; + DEBUG_GROUP_STACK_DEPTH = 0x826D; + BUFFER = 0x82E0; + SHADER = 0x82E1; + PROGRAM = 0x82E2; + QUERY = 0x82E3; + PROGRAM_PIPELINE = 0x82E4; + SAMPLER = 0x82E6; + MAX_LABEL_LENGTH = 0x82E8; + DEBUG_OUTPUT = 0x92E0; + CONTEXT_FLAG_DEBUG_BIT = 0x00000002; + MAX_UNIFORM_LOCATIONS = 0x826E; + FRAMEBUFFER_DEFAULT_WIDTH = 0x9310; + FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311; + FRAMEBUFFER_DEFAULT_LAYERS = 0x9312; + FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313; + FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314; + MAX_FRAMEBUFFER_WIDTH = 0x9315; + MAX_FRAMEBUFFER_HEIGHT = 0x9316; + MAX_FRAMEBUFFER_LAYERS = 0x9317; + MAX_FRAMEBUFFER_SAMPLES = 0x9318; + INTERNALFORMAT_SUPPORTED = 0x826F; + INTERNALFORMAT_PREFERRED = 0x8270; + INTERNALFORMAT_RED_SIZE = 0x8271; + INTERNALFORMAT_GREEN_SIZE = 0x8272; + INTERNALFORMAT_BLUE_SIZE = 0x8273; + INTERNALFORMAT_ALPHA_SIZE = 0x8274; + INTERNALFORMAT_DEPTH_SIZE = 0x8275; + INTERNALFORMAT_STENCIL_SIZE = 0x8276; + INTERNALFORMAT_SHARED_SIZE = 0x8277; + INTERNALFORMAT_RED_TYPE = 0x8278; + INTERNALFORMAT_GREEN_TYPE = 0x8279; + INTERNALFORMAT_BLUE_TYPE = 0x827A; + INTERNALFORMAT_ALPHA_TYPE = 0x827B; + INTERNALFORMAT_DEPTH_TYPE = 0x827C; + INTERNALFORMAT_STENCIL_TYPE = 0x827D; + MAX_WIDTH = 0x827E; + MAX_HEIGHT = 0x827F; + MAX_DEPTH = 0x8280; + MAX_LAYERS = 0x8281; + MAX_COMBINED_DIMENSIONS = 0x8282; + COLOR_COMPONENTS = 0x8283; + DEPTH_COMPONENTS = 0x8284; + STENCIL_COMPONENTS = 0x8285; + COLOR_RENDERABLE = 0x8286; + DEPTH_RENDERABLE = 0x8287; + STENCIL_RENDERABLE = 0x8288; + FRAMEBUFFER_RENDERABLE = 0x8289; + FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A; + FRAMEBUFFER_BLEND = 0x828B; + READ_PIXELS = 0x828C; + READ_PIXELS_FORMAT = 0x828D; + READ_PIXELS_TYPE = 0x828E; + TEXTURE_IMAGE_FORMAT = 0x828F; + TEXTURE_IMAGE_TYPE = 0x8290; + GET_TEXTURE_IMAGE_FORMAT = 0x8291; + GET_TEXTURE_IMAGE_TYPE = 0x8292; + MIPMAP = 0x8293; + MANUAL_GENERATE_MIPMAP = 0x8294; + AUTO_GENERATE_MIPMAP = 0x8295; + COLOR_ENCODING = 0x8296; + SRGB_READ = 0x8297; + SRGB_WRITE = 0x8298; + FILTER = 0x829A; + VERTEX_TEXTURE = 0x829B; + TESS_CONTROL_TEXTURE = 0x829C; + TESS_EVALUATION_TEXTURE = 0x829D; + GEOMETRY_TEXTURE = 0x829E; + FRAGMENT_TEXTURE = 0x829F; + COMPUTE_TEXTURE = 0x82A0; + TEXTURE_SHADOW = 0x82A1; + TEXTURE_GATHER = 0x82A2; + TEXTURE_GATHER_SHADOW = 0x82A3; + SHADER_IMAGE_LOAD = 0x82A4; + SHADER_IMAGE_STORE = 0x82A5; + SHADER_IMAGE_ATOMIC = 0x82A6; + IMAGE_TEXEL_SIZE = 0x82A7; + IMAGE_COMPATIBILITY_CLASS = 0x82A8; + IMAGE_PIXEL_FORMAT = 0x82A9; + IMAGE_PIXEL_TYPE = 0x82AA; + SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC; + SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD; + SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE; + SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF; + TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1; + TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2; + TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3; + CLEAR_BUFFER = 0x82B4; + TEXTURE_VIEW = 0x82B5; + VIEW_COMPATIBILITY_CLASS = 0x82B6; + FULL_SUPPORT = 0x82B7; + CAVEAT_SUPPORT = 0x82B8; + IMAGE_CLASS_4_X_32 = 0x82B9; + IMAGE_CLASS_2_X_32 = 0x82BA; + IMAGE_CLASS_1_X_32 = 0x82BB; + IMAGE_CLASS_4_X_16 = 0x82BC; + IMAGE_CLASS_2_X_16 = 0x82BD; + IMAGE_CLASS_1_X_16 = 0x82BE; + IMAGE_CLASS_4_X_8 = 0x82BF; + IMAGE_CLASS_2_X_8 = 0x82C0; + IMAGE_CLASS_1_X_8 = 0x82C1; + IMAGE_CLASS_11_11_10 = 0x82C2; + IMAGE_CLASS_10_10_10_2 = 0x82C3; + VIEW_CLASS_128_BITS = 0x82C4; + VIEW_CLASS_96_BITS = 0x82C5; + VIEW_CLASS_64_BITS = 0x82C6; + VIEW_CLASS_48_BITS = 0x82C7; + VIEW_CLASS_32_BITS = 0x82C8; + VIEW_CLASS_24_BITS = 0x82C9; + VIEW_CLASS_16_BITS = 0x82CA; + VIEW_CLASS_8_BITS = 0x82CB; + VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC; + VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD; + VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE; + VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF; + VIEW_CLASS_RGTC1_RED = 0x82D0; + VIEW_CLASS_RGTC2_RG = 0x82D1; + VIEW_CLASS_BPTC_UNORM = 0x82D2; + VIEW_CLASS_BPTC_FLOAT = 0x82D3; + UNIFORM = 0x92E1; + UNIFORM_BLOCK = 0x92E2; + PROGRAM_INPUT = 0x92E3; + PROGRAM_OUTPUT = 0x92E4; + BUFFER_VARIABLE = 0x92E5; + SHADER_STORAGE_BLOCK = 0x92E6; + VERTEX_SUBROUTINE = 0x92E8; + TESS_CONTROL_SUBROUTINE = 0x92E9; + TESS_EVALUATION_SUBROUTINE = 0x92EA; + GEOMETRY_SUBROUTINE = 0x92EB; + FRAGMENT_SUBROUTINE = 0x92EC; + COMPUTE_SUBROUTINE = 0x92ED; + VERTEX_SUBROUTINE_UNIFORM = 0x92EE; + TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF; + TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0; + GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1; + FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2; + COMPUTE_SUBROUTINE_UNIFORM = 0x92F3; + TRANSFORM_FEEDBACK_VARYING = 0x92F4; + ACTIVE_RESOURCES = 0x92F5; + MAX_NAME_LENGTH = 0x92F6; + MAX_NUM_ACTIVE_VARIABLES = 0x92F7; + MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8; + NAME_LENGTH = 0x92F9; + TYPE = 0x92FA; + ARRAY_SIZE = 0x92FB; + OFFSET = 0x92FC; + BLOCK_INDEX = 0x92FD; + ARRAY_STRIDE = 0x92FE; + MATRIX_STRIDE = 0x92FF; + IS_ROW_MAJOR = 0x9300; + ATOMIC_COUNTER_BUFFER_INDEX = 0x9301; + BUFFER_BINDING = 0x9302; + BUFFER_DATA_SIZE = 0x9303; + NUM_ACTIVE_VARIABLES = 0x9304; + ACTIVE_VARIABLES = 0x9305; + REFERENCED_BY_VERTEX_SHADER = 0x9306; + REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307; + REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308; + REFERENCED_BY_GEOMETRY_SHADER = 0x9309; + REFERENCED_BY_FRAGMENT_SHADER = 0x930A; + REFERENCED_BY_COMPUTE_SHADER = 0x930B; + TOP_LEVEL_ARRAY_SIZE = 0x930C; + TOP_LEVEL_ARRAY_STRIDE = 0x930D; + LOCATION = 0x930E; + LOCATION_INDEX = 0x930F; + IS_PER_PATCH = 0x92E7; + SHADER_STORAGE_BUFFER = 0x90D2; + SHADER_STORAGE_BUFFER_BINDING = 0x90D3; + SHADER_STORAGE_BUFFER_START = 0x90D4; + SHADER_STORAGE_BUFFER_SIZE = 0x90D5; + MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6; + MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7; + MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8; + MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9; + MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA; + MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB; + MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC; + MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD; + MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE; + SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF; + SHADER_STORAGE_BARRIER_BIT = 0x00002000; + MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39; + DEPTH_STENCIL_TEXTURE_MODE = 0x90EA; + TEXTURE_BUFFER_OFFSET = 0x919D; + TEXTURE_BUFFER_SIZE = 0x919E; + TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F; + TEXTURE_VIEW_MIN_LEVEL = 0x82DB; + TEXTURE_VIEW_NUM_LEVELS = 0x82DC; + TEXTURE_VIEW_MIN_LAYER = 0x82DD; + TEXTURE_VIEW_NUM_LAYERS = 0x82DE; + TEXTURE_IMMUTABLE_LEVELS = 0x82DF; + VERTEX_ATTRIB_BINDING = 0x82D4; + VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5; + VERTEX_BINDING_DIVISOR = 0x82D6; + VERTEX_BINDING_OFFSET = 0x82D7; + VERTEX_BINDING_STRIDE = 0x82D8; + MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9; + MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA; + VERTEX_BINDING_BUFFER = 0x8F4F; -const MAX_VERTEX_ATTRIB_STRIDE = 0x82E5; -const PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221; -const TEXTURE_BUFFER_BINDING = 0x8C2A; -const MAP_PERSISTENT_BIT = 0x0040; -const MAP_COHERENT_BIT = 0x0080; -const DYNAMIC_STORAGE_BIT = 0x0100; -const CLIENT_STORAGE_BIT = 0x0200; -const CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000; -const BUFFER_IMMUTABLE_STORAGE = 0x821F; -const BUFFER_STORAGE_FLAGS = 0x8220; -const CLEAR_TEXTURE = 0x9365; -const LOCATION_COMPONENT = 0x934A; -const TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B; -const TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C; -const QUERY_BUFFER = 0x9192; -const QUERY_BUFFER_BARRIER_BIT = 0x00008000; -const QUERY_BUFFER_BINDING = 0x9193; -const QUERY_RESULT_NO_WAIT = 0x9194; -const MIRROR_CLAMP_TO_EDGE = 0x8743; + MAX_VERTEX_ATTRIB_STRIDE = 0x82E5; + PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221; + TEXTURE_BUFFER_BINDING = 0x8C2A; + MAP_PERSISTENT_BIT = 0x0040; + MAP_COHERENT_BIT = 0x0080; + DYNAMIC_STORAGE_BIT = 0x0100; + CLIENT_STORAGE_BIT = 0x0200; + CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000; + BUFFER_IMMUTABLE_STORAGE = 0x821F; + BUFFER_STORAGE_FLAGS = 0x8220; + CLEAR_TEXTURE = 0x9365; + LOCATION_COMPONENT = 0x934A; + TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B; + TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C; + QUERY_BUFFER = 0x9192; + QUERY_BUFFER_BARRIER_BIT = 0x00008000; + QUERY_BUFFER_BINDING = 0x9193; + QUERY_RESULT_NO_WAIT = 0x9194; + MIRROR_CLAMP_TO_EDGE = 0x8743; -const CONTEXT_LOST = 0x0507; -const NEGATIVE_ONE_TO_ONE = 0x935E; -const ZERO_TO_ONE = 0x935F; -const CLIP_ORIGIN = 0x935C; -const CLIP_DEPTH_MODE = 0x935D; -const QUERY_WAIT_INVERTED = 0x8E17; -const QUERY_NO_WAIT_INVERTED = 0x8E18; -const QUERY_BY_REGION_WAIT_INVERTED = 0x8E19; -const QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A; -const MAX_CULL_DISTANCES = 0x82F9; -const MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA; -const TEXTURE_TARGET = 0x1006; -const QUERY_TARGET = 0x82EA; -const GUILTY_CONTEXT_RESET = 0x8253; -const INNOCENT_CONTEXT_RESET = 0x8254; -const UNKNOWN_CONTEXT_RESET = 0x8255; -const RESET_NOTIFICATION_STRATEGY = 0x8256; -const LOSE_CONTEXT_ON_RESET = 0x8252; -const NO_RESET_NOTIFICATION = 0x8261; -const CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004; -const CONTEXT_RELEASE_BEHAVIOR = 0x82FB; -const CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC; + CONTEXT_LOST = 0x0507; + NEGATIVE_ONE_TO_ONE = 0x935E; + ZERO_TO_ONE = 0x935F; + CLIP_ORIGIN = 0x935C; + CLIP_DEPTH_MODE = 0x935D; + QUERY_WAIT_INVERTED = 0x8E17; + QUERY_NO_WAIT_INVERTED = 0x8E18; + QUERY_BY_REGION_WAIT_INVERTED = 0x8E19; + QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A; + MAX_CULL_DISTANCES = 0x82F9; + MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA; + TEXTURE_TARGET = 0x1006; + QUERY_TARGET = 0x82EA; + GUILTY_CONTEXT_RESET = 0x8253; + INNOCENT_CONTEXT_RESET = 0x8254; + UNKNOWN_CONTEXT_RESET = 0x8255; + RESET_NOTIFICATION_STRATEGY = 0x8256; + LOSE_CONTEXT_ON_RESET = 0x8252; + NO_RESET_NOTIFICATION = 0x8261; + CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004; + CONTEXT_RELEASE_BEHAVIOR = 0x82FB; + CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC; -const DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242; -const DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243; -const DEBUG_CALLBACK_FUNCTION_ARB = 0x8244; -const DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245; -const DEBUG_SOURCE_API_ARB = 0x8246; -const DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247; -const DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248; -const DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249; -const DEBUG_SOURCE_APPLICATION_ARB = 0x824A; -const DEBUG_SOURCE_OTHER_ARB = 0x824B; -const DEBUG_TYPE_ERROR_ARB = 0x824C; -const DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D; -const DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E; -const DEBUG_TYPE_PORTABILITY_ARB = 0x824F; -const DEBUG_TYPE_PERFORMANCE_ARB = 0x8250; -const DEBUG_TYPE_OTHER_ARB = 0x8251; -const MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143; -const MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144; -const DEBUG_LOGGED_MESSAGES_ARB = 0x9145; -const DEBUG_SEVERITY_HIGH_ARB = 0x9146; -const DEBUG_SEVERITY_MEDIUM_ARB = 0x9147; -const DEBUG_SEVERITY_LOW_ARB = 0x9148; + DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242; + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243; + DEBUG_CALLBACK_FUNCTION_ARB = 0x8244; + DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245; + DEBUG_SOURCE_API_ARB = 0x8246; + DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247; + DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248; + DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249; + DEBUG_SOURCE_APPLICATION_ARB = 0x824A; + DEBUG_SOURCE_OTHER_ARB = 0x824B; + DEBUG_TYPE_ERROR_ARB = 0x824C; + DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D; + DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E; + DEBUG_TYPE_PORTABILITY_ARB = 0x824F; + DEBUG_TYPE_PERFORMANCE_ARB = 0x8250; + DEBUG_TYPE_OTHER_ARB = 0x8251; + MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143; + MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144; + DEBUG_LOGGED_MESSAGES_ARB = 0x9145; + DEBUG_SEVERITY_HIGH_ARB = 0x9146; + DEBUG_SEVERITY_MEDIUM_ARB = 0x9147; + DEBUG_SEVERITY_LOW_ARB = 0x9148; +); diff --git a/core/utf8.odin b/core/utf8.odin index bbfd2cbff..1e0b7a72f 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -1,14 +1,14 @@ -const RUNE_ERROR = '\ufffd'; -const RUNE_SELF = 0x80; -const RUNE_BOM = 0xfeff; -const RUNE_EOF = ~(0 as rune); -const MAX_RUNE = '\U0010ffff'; -const UTF_MAX = 4; - - -const SURROGATE_MIN = 0xd800; -const SURROGATE_MAX = 0xdfff; - +const ( + RUNE_ERROR = '\ufffd'; + RUNE_SELF = 0x80; + RUNE_BOM = 0xfeff; + RUNE_EOF = ~(0 as rune); + MAX_RUNE = '\U0010ffff'; + UTF_MAX = 4; + + SURROGATE_MIN = 0xd800; + SURROGATE_MAX = 0xdfff; +); type Accept_Range struct { lo, hi u8; diff --git a/src/checker/checker.c b/src/checker/checker.c index 3e0606d6a..3af0c2f8b 100644 --- a/src/checker/checker.c +++ b/src/checker/checker.c @@ -1106,6 +1106,94 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As switch (decl->kind) { case_ast_node(bd, BadDecl, decl); case_end; + case_ast_node(gd, GenericDecl, decl); + if (!parent_scope->is_file) { + // NOTE(bill): Within a procedure, variables must be in order + continue; + } + + for_array(spec_index, gd->specs) { + AstNode *spec = gd->specs.e[spec_index]; + switch (spec->kind) { + case_ast_node(vs, ValueSpec, spec); + switch (vs->keyword) { + case Token_var: { + // NOTE(bill): You need to store the entity information here unline a constant declaration + isize entity_count = vs->names.count; + isize entity_index = 0; + Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_count); + DeclInfo *di = NULL; + if (vs->values.count > 0) { + di = make_declaration_info(heap_allocator(), parent_scope); + di->entities = entities; + di->entity_count = entity_count; + di->type_expr = vs->type; + di->init_expr = vs->values.e[0]; + } + + for_array(i, vs->names) { + AstNode *name = vs->names.e[i]; + AstNode *value = NULL; + if (i < vs->values.count) { + value = vs->values.e[i]; + } + if (name->kind != AstNode_Ident) { + error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); + continue; + } + Entity *e = make_entity_variable(c->allocator, parent_scope, name->Ident, NULL); + e->identifier = name; + entities[entity_index++] = e; + + DeclInfo *d = di; + if (d == NULL) { + AstNode *init_expr = value; + d = make_declaration_info(heap_allocator(), e->scope); + d->type_expr = vs->type; + d->init_expr = init_expr; + d->var_decl_tags = gd->tags; + } + + add_entity_and_decl_info(c, name, e, d); + } + } break; + + case Token_const: { + for_array(i, vs->values) { + AstNode *name = vs->names.e[i]; + AstNode *value = unparen_expr(vs->values.e[i]); + if (name->kind != AstNode_Ident) { + error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); + continue; + } + + ExactValue v = {ExactValue_Invalid}; + Entity *e = make_entity_constant(c->allocator, parent_scope, name->Ident, NULL, v); + e->identifier = name; + DeclInfo *di = make_declaration_info(c->allocator, e->scope); + di->type_expr = vs->type; + di->init_expr = value; + add_entity_and_decl_info(c, name, e, di); + } + + isize lhs_count = vs->names.count; + isize rhs_count = vs->values.count; + + if (rhs_count == 0 && vs->type == NULL) { + error_node(decl, "Missing type or initial expression"); + } else if (lhs_count < rhs_count) { + error_node(decl, "Extra initial expression"); + } + } break; + } + case_end; + + default: + error(ast_node_token(spec), "Invalid specification in declaration: `%.*s`", LIT(ast_node_strings[spec->kind])); + break; + } + } + case_end; case_ast_node(id, ImportDecl, decl); if (!parent_scope->is_file) { // NOTE(bill): _Should_ be caught by the parser @@ -1428,7 +1516,10 @@ void check_parsed_files(Checker *c) { ImplicitValueInfo *ivi = &implicit_value_infos[i]; Entity *backing = scope_lookup_entity(e->scope, ivi->backing_name); - GB_ASSERT(backing != NULL); + // GB_ASSERT(backing != NULL); + if (backing == NULL) { + gb_exit(1); + } e->ImplicitValue.backing = backing; } diff --git a/src/checker/expr.c b/src/checker/expr.c index 8900cb4a7..3f8215f55 100644 --- a/src/checker/expr.c +++ b/src/checker/expr.c @@ -80,6 +80,89 @@ void check_local_collect_entities(Checker *c, AstNodeArray nodes, DelayedEntitie case_ast_node(ws, WhenStmt, node); // Will be handled later case_end; + case_ast_node(gd, GenericDecl, node); + for_array(spec_index, gd->specs) { + AstNode *spec = gd->specs.e[spec_index]; + switch (spec->kind) { + case_ast_node(vs, ValueSpec, spec); + switch (vs->keyword) { + case Token_var: + break; + + case Token_const: { + gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); + + isize entity_count = vs->names.count; + isize entity_index = 0; + Entity **entities = gb_alloc_array(c->tmp_allocator, Entity *, entity_count); + + for_array(i, vs->values) { + AstNode *name = vs->names.e[i]; + AstNode *value = unparen_expr(vs->values.e[i]); + if (name->kind != AstNode_Ident) { + error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); + entities[entity_index++] = NULL; + continue; + } + + ExactValue v = {ExactValue_Invalid}; + Entity *e = make_entity_constant(c->allocator, c->context.scope, name->Ident, NULL, v); + e->identifier = name; + entities[entity_index++] = e; + DeclInfo *d = make_declaration_info(c->allocator, e->scope); + d->type_expr = vs->type; + d->init_expr = value; + add_entity_and_decl_info(c, name, e, d); + + DelayedEntity delay = {name, e, d}; + array_add(delayed_entities, delay); + } + + isize lhs_count = vs->names.count; + isize rhs_count = vs->values.count; + + // TODO(bill): Better error messages or is this good enough? + if (rhs_count == 0 && vs->type == NULL) { + error_node(node, "Missing type or initial expression"); + } else if (lhs_count < rhs_count) { + error_node(node, "Extra initial expression"); + } + + if (dof != NULL) { + // NOTE(bill): Within a record + for_array(i, vs->names) { + Entity *e = entities[i]; + if (e == NULL) { + continue; + } + AstNode *name = vs->names.e[i]; + if (name->kind != AstNode_Ident) { + continue; + } + Token name_token = name->Ident; + if (str_eq(name_token.string, str_lit("_"))) { + dof->other_fields[dof->other_field_index++] = e; + } else { + HashKey key = hash_string(name_token.string); + if (map_entity_get(dof->entity_map, key) != NULL) { + // TODO(bill): Scope checking already checks the declaration + error(name_token, "`%.*s` is already declared in this record", LIT(name_token.string)); + } else { + map_entity_set(dof->entity_map, key, e); + dof->other_fields[dof->other_field_index++] = e; + } + add_entity(c, c->context.scope, name, e); + } + } + } + + gb_temp_arena_memory_end(tmp); + } break; + } + case_end; + } + } + case_end; case_ast_node(cd, ConstDecl, node); gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); diff --git a/src/checker/stmt.c b/src/checker/stmt.c index f1074e2e6..7e1578987 100644 --- a/src/checker/stmt.c +++ b/src/checker/stmt.c @@ -1074,6 +1074,90 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_var_decl_node(c, node); case_end; + case_ast_node(gd, GenericDecl, node); + for_array(spec_index, gd->specs) { + AstNode *spec = gd->specs.e[spec_index]; + switch (spec->kind) { + case_ast_node(vs, ValueSpec, spec); + switch (vs->keyword) { + case Token_var: { + isize entity_count = vs->names.count; + isize entity_index = 0; + Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_count); + + for_array(i, vs->names) { + AstNode *name = vs->names.e[i]; + Entity *entity = NULL; + if (name->kind == AstNode_Ident) { + Token token = name->Ident; + String str = token.string; + Entity *found = NULL; + // NOTE(bill): Ignore assignments to `_` + if (str_ne(str, str_lit("_"))) { + found = current_scope_lookup_entity(c->context.scope, str); + } + if (found == NULL) { + entity = make_entity_variable(c->allocator, c->context.scope, token, NULL); + add_entity_definition(&c->info, name, entity); + } else { + TokenPos pos = found->token.pos; + error(token, + "Redeclaration of `%.*s` in this scope\n" + "\tat %.*s(%td:%td)", + LIT(str), LIT(pos.file), pos.line, pos.column); + entity = found; + } + } else { + error_node(name, "A variable declaration must be an identifier"); + } + if (entity == NULL) { + entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name)); + } + entities[entity_index++] = entity; + } + + Type *init_type = NULL; + if (vs->type) { + init_type = check_type_extra(c, vs->type, NULL); + if (init_type == NULL) { + init_type = t_invalid; + } + } + + for (isize i = 0; i < entity_count; i++) { + Entity *e = entities[i]; + GB_ASSERT(e != NULL); + if (e->flags & EntityFlag_Visited) { + e->type = t_invalid; + continue; + } + e->flags |= EntityFlag_Visited; + + if (e->type == NULL) + e->type = init_type; + } + + check_init_variables(c, entities, entity_count, vs->values, str_lit("variable declaration")); + + for_array(i, vs->names) { + if (entities[i] != NULL) { + add_entity(c, c->context.scope, vs->names.e[i], entities[i]); + } + } + } break; + + case Token_const: + break; + } + case_end; + + default: + error(ast_node_token(spec), "Invalid specification in declaration: `%.*s`", LIT(ast_node_strings[spec->kind])); + break; + } + } + case_end; + case_ast_node(cd, ConstDecl, node); // NOTE(bill): Handled elsewhere case_end; diff --git a/src/parser.c b/src/parser.c index c8329aabe..f8460e824 100644 --- a/src/parser.c +++ b/src/parser.c @@ -224,37 +224,53 @@ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ \ AST_NODE_KIND(_ComplexStmtEnd, "", i32) \ AST_NODE_KIND(_StmtEnd, "", i32) \ +AST_NODE_KIND(_SpecBegin, "", i32) \ + AST_NODE_KIND(ValueSpec, "value specification", struct { \ + TokenKind keyword; \ + AstNodeArray names; \ + AstNode * type; \ + AstNodeArray values; \ + }) \ +AST_NODE_KIND(_SpecEnd, "", i32) \ AST_NODE_KIND(_DeclBegin, "", i32) \ - AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \ + AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \ + AST_NODE_KIND(GenericDecl, "generic declaration", struct { \ + Token token; \ + Token open, close; \ + AstNodeArray specs; \ + u64 tags; \ + bool is_using; \ + }) \ AST_NODE_KIND(VarDecl, "variable declaration", struct { \ - u64 tags; \ - bool is_using; \ - AstNodeArray names; \ - AstNode * type; \ - AstNodeArray values; \ - AstNode * note; \ + u64 tags; \ + bool is_using; \ + AstNodeArray names; \ + AstNode * type; \ + AstNodeArray values; \ + AstNode * note; \ }) \ AST_NODE_KIND(ConstDecl, "constant declaration", struct { \ - u64 tags; \ - AstNodeArray names; \ - AstNode * type; \ - AstNodeArray values; \ - AstNode * note; \ - }) \ - AST_NODE_KIND(ProcDecl, "procedure declaration", struct { \ - AstNode *name; \ - AstNode *type; \ - AstNode *body; \ - u64 tags; \ - String foreign_name; \ - String link_name; \ - AstNode *note; \ + u64 tags; \ + AstNodeArray names; \ + AstNode * type; \ + AstNodeArray values; \ + AstNode * note; \ }) \ AST_NODE_KIND(TypeDecl, "type declaration", struct { \ - Token token; \ - AstNode *name, *type; \ + Token token; \ + AstNode *name; \ + AstNode *type; \ AstNode *note; \ }) \ + AST_NODE_KIND(ProcDecl, "procedure declaration", struct { \ + AstNode *name; \ + AstNode *type; \ + AstNode *body; \ + u64 tags; \ + String foreign_name; \ + String link_name; \ + AstNode *note; \ + }) \ AST_NODE_KIND(ImportDecl, "import declaration", struct { \ Token token, relpath; \ String fullpath; \ @@ -459,20 +475,27 @@ Token ast_node_token(AstNode *node) { return node->PushAllocator.token; case AstNode_PushContext: return node->PushContext.token; + case AstNode_BadDecl: return node->BadDecl.begin; + case AstNode_GenericDecl: + return node->GenericDecl.token; case AstNode_VarDecl: return ast_node_token(node->VarDecl.names.e[0]); case AstNode_ConstDecl: return ast_node_token(node->ConstDecl.names.e[0]); case AstNode_ProcDecl: - return node->ProcDecl.name->Ident; + return ast_node_token(node->ProcDecl.name); case AstNode_TypeDecl: - return node->TypeDecl.token; + return ast_node_token(node->TypeDecl.name); case AstNode_ImportDecl: return node->ImportDecl.token; case AstNode_ForeignLibrary: return node->ForeignLibrary.token; + + case AstNode_ValueSpec: + return ast_node_token(node->ValueSpec.names.e[0]); + case AstNode_Parameter: { if (node->Parameter.names.count > 0) { return ast_node_token(node->Parameter.names.e[0]); @@ -1033,6 +1056,29 @@ AstNode *make_foreign_library(AstFile *f, Token token, Token filepath, AstNode * return result; } + +AstNode *make_generic_decl(AstFile *f, Token token, Token open, Token close, AstNodeArray specs, u64 tags, bool is_using) { + AstNode *result = make_node(f, AstNode_GenericDecl); + result->GenericDecl.token = token; + result->GenericDecl.open = open; + result->GenericDecl.close = close; + result->GenericDecl.specs = specs; + result->GenericDecl.tags = tags; + result->GenericDecl.is_using = is_using; + return result; +} + +AstNode *make_value_spec(AstFile *f, TokenKind keyword, AstNodeArray names, AstNode *type, AstNodeArray values) { + AstNode *result = make_node(f, AstNode_ValueSpec); + result->ValueSpec.keyword = keyword; + result->ValueSpec.names = names; + result->ValueSpec.type = type; + result->ValueSpec.values = values; + return result; +} + + + bool next_token(AstFile *f) { if (f->curr_token_index+1 < f->tokens.count) { if (f->curr_token.kind != Token_Comment) { @@ -1054,16 +1100,9 @@ Token expect_token(AstFile *f, TokenKind kind) { Token prev = f->curr_token; if (prev.kind != kind) { String p = token_strings[prev.kind]; - if (prev.kind == Token_Semicolon && - str_eq(prev.string, str_lit("\n"))) { - syntax_error(f->curr_token, "Expected `%.*s`, got newline", - LIT(token_strings[kind]), - LIT(p)); - } else { - syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", - LIT(token_strings[kind]), - LIT(token_strings[prev.kind])); - } + syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", + LIT(token_strings[kind]), + LIT(token_strings[prev.kind])); } next_token(f); return prev; @@ -1073,10 +1112,6 @@ Token expect_token_after(AstFile *f, TokenKind kind, char *msg) { Token prev = f->curr_token; if (prev.kind != kind) { String p = token_strings[prev.kind]; - if (prev.kind == Token_Semicolon && - str_eq(prev.string, str_lit("\n"))) { - p = str_lit("newline"); - } syntax_error(f->curr_token, "Expected `%.*s` after %s, got `%.*s`", LIT(token_strings[kind]), msg, @@ -1136,6 +1171,11 @@ void fix_advance_to_next_stmt(AstFile *f) { case Token_Semicolon: return; + case Token_var: + case Token_const: + case Token_type: + case Token_proc: + case Token_if: case Token_when: case Token_return: @@ -1204,8 +1244,9 @@ void expect_semicolon(AstFile *f, AstNode *s) { break; } - syntax_error(prev_token, "Expected `;` after %.*s, got %.*s", - LIT(ast_node_strings[s->kind]), LIT(token_strings[prev_token.kind])); + syntax_error(prev_token, "Expected `;` after %.*s, got %.*s %d %d", + LIT(ast_node_strings[s->kind]), LIT(token_strings[prev_token.kind]), + Token_Semicolon, prev_token.kind); } else { syntax_error(prev_token, "Expected `;`"); } @@ -1831,6 +1872,21 @@ AstNodeArray parse_rhs_expr_list(AstFile *f) { return parse_expr_list(f, false); } +AstNodeArray parse_identfier_list(AstFile *f) { + AstNodeArray list = make_ast_node_array(f); + + do { + array_add(&list, parse_identifier(f)); + if (f->curr_token.kind != Token_Comma || + f->curr_token.kind == Token_EOF) { + break; + } + next_token(f); + } while (true); + + return list; +} + void parse_check_name_list_for_reserves(AstFile *f, AstNodeArray names) { for_array(i, names) { AstNode *name = names.e[i]; @@ -1845,13 +1901,126 @@ void parse_check_name_list_for_reserves(AstFile *f, AstNodeArray names) { } } -AstNode *parse_value_decl(AstFile *f); +AstNode *parse_type_attempt(AstFile *f) { + AstNode *type = parse_identifier_or_type(f); + if (type != NULL) { + // TODO(bill): Handle? + } + return type; +} + +AstNode *parse_type(AstFile *f) { + AstNode *type = parse_type_attempt(f); + if (type == NULL) { + Token token = f->curr_token; + syntax_error(token, "Expected a type"); + next_token(f); + return make_bad_expr(f, token, f->curr_token); + } + return type; +} + + +#define PARSE_SPEC_PROC(name) AstNode *(name)(AstFile *f, TokenKind keyword) +typedef PARSE_SPEC_PROC(*ParserSpecProc); + + +AstNode *parse_generic_decl(AstFile *f, TokenKind keyword, ParserSpecProc spec_proc) { + Token token = expect_token(f, keyword); + Token open = {0}, close = {0}; + AstNodeArray specs = {0}; + if (f->curr_token.kind == Token_OpenParen) { + open = expect_token(f, Token_OpenParen); + array_init(&specs, heap_allocator()); + + while (f->curr_token.kind != Token_CloseParen && + f->curr_token.kind != Token_EOF) { + AstNode *spec = spec_proc(f, keyword); + array_add(&specs, spec); + expect_semicolon(f, spec); + } + + close = expect_token(f, Token_CloseParen); + } else { + array_init_reserve(&specs, heap_allocator(), 1); + array_add(&specs, spec_proc(f, keyword)); + } + + return make_generic_decl(f, token, open, close, specs, 0, false); +} + +PARSE_SPEC_PROC(parse_value_spec) { + AstNodeArray names = parse_identfier_list(f); + parse_check_name_list_for_reserves(f, names); + AstNode *type = parse_type_attempt(f); + AstNodeArray values = {0}; + + if (allow_token(f, Token_Eq)) { + values = parse_rhs_expr_list(f); + } + + if (values.count > names.count) { + syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); + } + + if (keyword == Token_const) { + if (values.count < names.count) { + syntax_error(f->curr_token, "All constant declarations must be defined"); + } else if (values.count == 0) { + syntax_error(f->curr_token, "Expected an expression for this declaration"); + } + } + + if (type == NULL && values.count == 0 && names.count > 0) { + syntax_error(f->curr_token, "Missing type or initialization"); + return make_bad_decl(f, f->curr_token, f->curr_token); + } + + // TODO(bill): Fix this so it does not require it + if (values.e == NULL) { + values = make_ast_node_array(f); + } + + return make_value_spec(f, keyword, names, type, values); +} + + +AstNode *parse_type_decl(AstFile *f) { + Token token = expect_token(f, Token_type); + AstNode *name = parse_identifier(f); + AstNode *type = parse_type(f); + return make_type_decl(f, token, name, type); +} + +AstNode *parse_proc_decl(AstFile *f); + +AstNode *parse_decl(AstFile *f) { + switch (f->curr_token.kind) { + case Token_var: + case Token_const: + return parse_generic_decl(f, f->curr_token.kind, parse_value_spec); + + case Token_type: + return parse_type_decl(f); + + case Token_proc: + return parse_proc_decl(f); + + default: { + Token token = f->curr_token; + syntax_error(token, "Expected a declaration"); + fix_advance_to_next_stmt(f); + return make_bad_decl(f, token, f->curr_token); + } + } +} + AstNode *parse_simple_stmt(AstFile *f) { switch (f->curr_token.kind) { case Token_var: case Token_const: - return parse_value_decl(f); + return parse_decl(f); } isize lhs_count = 0, rhs_count = 0; @@ -1888,85 +2057,6 @@ AstNode *parse_simple_stmt(AstFile *f) { } return make_assign_stmt(f, token, lhs, rhs); } break; - - // case Token_Colon: { // Declare - // AstNodeArray names = lhs; - // parse_check_name_list_for_reserves(f, names); - - // Token colon = expect_token(f, Token_Colon); - // AstNode *type = parse_identifier_or_type(f); - // AstNodeArray values = {0}; - - // if (allow_token(f, Token_Eq)) { - // values = parse_rhs_expr_list(f); - // if (values.count > names.count) { - // syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); - // } else if (values.count == 0) { - // syntax_error(f->curr_token, "Expected an expression for this declaration"); - // } - // if (type == NULL && values.count == 0) { - // syntax_error(f->curr_token, "Missing variable type or initialization"); - // return make_bad_decl(f, f->curr_token, f->curr_token); - // } - // } - - // if (values.e == NULL) { - // values = make_ast_node_array(f); - // } - - // return make_var_decl(f, names, type, values); - // } break; - - // case Token_ColonColon: { - // AstNodeArray names = lhs; - // parse_check_name_list_for_reserves(f, names); - - // Token colon_colon = expect_token(f, Token_ColonColon); - - // // if (f->curr_token.kind == Token_type || - // // f->curr_token.kind == Token_struct || - // // f->curr_token.kind == Token_enum || - // // f->curr_token.kind == Token_union || - // // f->curr_token.kind == Token_raw_union) { - // // // if (f->curr_token.kind == Token_type) { - // // Token token = f->curr_token; - // // if (token.kind == Token_type) { - // // next_token(f); - // // } - // // if (names.count != 1) { - // // syntax_error_node(names.e[0], "You can only declare one type at a time"); - // // return make_bad_decl(f, names.e[0]->Ident, token); - // // } - - // // return make_type_decl(f, token, names.e[0], parse_type(f)); - // // } else if (f->curr_token.kind == Token_proc) { - // // // NOTE(bill): Procedure declarations - // // Token proc_token = f->curr_token; - // // AstNode *name = names.e[0]; - // // if (names.count != 1) { - // // syntax_error(proc_token, "You can only declare one procedure at a time"); - // // return make_bad_decl(f, name->Ident, proc_token); - // // } - - // // return parse_proc_decl(f, proc_token, name); - // // } - - // AstNodeArray values = parse_rhs_expr_list(f); - // if (values.count > names.count) { - // syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); - // } else if (values.count < names.count) { - // syntax_error(f->curr_token, "All constant declarations must be defined"); - // } else if (values.count == 0) { - // syntax_error(f->curr_token, "Expected an expression for this declaration"); - // } - - // if (values.count == 0 && names.count > 0) { - // syntax_error(f->curr_token, "Missing constant value"); - // return make_bad_decl(f, f->curr_token, f->curr_token); - // } - - // return make_const_decl(f, names, NULL, values); - // } break; } if (lhs_count > 1) { @@ -2013,41 +2103,6 @@ AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) { return make_bad_expr(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); } -AstNodeArray parse_identfier_list(AstFile *f) { - AstNodeArray list = make_ast_node_array(f); - - do { - array_add(&list, parse_identifier(f)); - if (f->curr_token.kind != Token_Comma || - f->curr_token.kind == Token_EOF) { - break; - } - next_token(f); - } while (true); - - return list; -} - - - -AstNode *parse_type_attempt(AstFile *f) { - AstNode *type = parse_identifier_or_type(f); - if (type != NULL) { - // TODO(bill): Handle? - } - return type; -} - -AstNode *parse_type(AstFile *f) { - AstNode *type = parse_type_attempt(f); - if (type == NULL) { - Token token = f->curr_token; - syntax_error(token, "Expected a type"); - next_token(f); - return make_bad_expr(f, token, f->curr_token); - } - return type; -} void parse_proc_signature(AstFile *f, AstNodeArray *params, AstNodeArray *results); @@ -2691,75 +2746,15 @@ AstNode *parse_asm_stmt(AstFile *f) { } -AstNode *parse_type_decl(AstFile *f) { - Token token = expect_token(f, Token_type); - AstNode *name = parse_identifier(f); - AstNode *type = parse_type(f); - return make_type_decl(f, token, name, type); -} - -AstNode *parse_value_decl(AstFile *f) { - Token token = f->curr_token; - switch (token.kind) { - case Token_var: - case Token_const: - next_token(f); - break; - default: - next_token(f); - syntax_error(token, "Expected a variable or constant declaration"); - fix_advance_to_next_stmt(f); - return make_bad_decl(f, token, f->curr_token); - } - - AstNodeArray names = parse_identfier_list(f); - parse_check_name_list_for_reserves(f, names); - AstNode *type = parse_type_attempt(f); - AstNodeArray values = {0}; - - if (allow_token(f, Token_Eq)) { - values = parse_rhs_expr_list(f); - } - - if (values.count > names.count) { - syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); - } else if (token.kind == Token_const) { - if (values.count < names.count) { - syntax_error(f->curr_token, "All constant declarations must be defined"); - } else if (values.count == 0) { - syntax_error(f->curr_token, "Expected an expression for this declaration"); - } - } - - if (type == NULL && values.count == 0 && names.count > 0) { - syntax_error(f->curr_token, "Missing type or initialization"); - return make_bad_decl(f, f->curr_token, f->curr_token); - } - - // TODO(bill): Fix this so it does not require it - if (values.e == NULL) { - values = make_ast_node_array(f); - } - - - AstNode *decl = NULL; - - switch (token.kind) { - case Token_var: - decl = make_var_decl(f, names, type, values); - break; - case Token_const: - decl = make_const_decl(f, names, type, values); - break; - } - return decl; -} AstNode *parse_stmt(AstFile *f) { AstNode *s = NULL; Token token = f->curr_token; switch (token.kind) { // Operands + case Token_var: + case Token_const: + case Token_Ident: case Token_Integer: case Token_Float: @@ -2775,6 +2770,13 @@ AstNode *parse_stmt(AstFile *f) { expect_semicolon(f, s); return s; + case Token_proc: + return parse_proc_decl(f); + case Token_type: + s = parse_type_decl(f); + expect_semicolon(f, s); + return s; + // TODO(bill): other keywords case Token_if: return parse_if_stmt(f); case Token_when: return parse_when_stmt(f); @@ -2792,25 +2794,9 @@ AstNode *parse_stmt(AstFile *f) { expect_semicolon(f, s); return s; - case Token_proc: - return parse_proc_decl(f); - case Token_type: - s = parse_type_decl(f); - expect_semicolon(f, s); - return s; - case Token_var: - case Token_const: - s = parse_value_decl(f); - expect_semicolon(f, s); - return s; - - case Token_using: { - AstNode *node = NULL; - next_token(f); - node = parse_stmt(f); - + AstNode *node = parse_stmt(f); bool valid = false; switch (node->kind) { @@ -2833,7 +2819,6 @@ AstNode *parse_stmt(AstFile *f) { return make_bad_stmt(f, token, f->curr_token); } - return make_using_stmt(f, token, node); } break; @@ -2961,17 +2946,23 @@ AstNode *parse_stmt(AstFile *f) { expect_semicolon(f, s); return s; } else if (str_eq(tag, str_lit("thread_local"))) { - AstNode *var_decl = parse_simple_stmt(f); - if (var_decl->kind != AstNode_VarDecl) { + AstNode *decl = parse_simple_stmt(f); + if (decl->kind != AstNode_VarDecl && + (decl->kind == AstNode_GenericDecl && + decl->GenericDecl.token.kind != Token_var)) { syntax_error(token, "#thread_local may only be applied to variable declarations"); - return make_bad_decl(f, token, ast_node_token(var_decl)); + return make_bad_decl(f, token, ast_node_token(decl)); } if (f->curr_proc != NULL) { syntax_error(token, "#thread_local is only allowed at the file scope"); - return make_bad_decl(f, token, ast_node_token(var_decl)); + return make_bad_decl(f, token, ast_node_token(decl)); + } + if (decl->kind == AstNode_VarDecl) { + decl->VarDecl.tags |= VarDeclTag_thread_local; + } else if (decl->kind == AstNode_GenericDecl) { + decl->GenericDecl.tags |= VarDeclTag_thread_local; } - var_decl->VarDecl.tags |= VarDeclTag_thread_local; - return var_decl; + return decl; } else if (str_eq(tag, str_lit("bounds_check"))) { s = parse_stmt(f); s->stmt_state_flags |= StmtStateFlag_bounds_check; diff --git a/src/ssa.c b/src/ssa.c index f4100e9cf..bc5737676 100644 --- a/src/ssa.c +++ b/src/ssa.c @@ -3849,7 +3849,8 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { case_ast_node(us, UsingStmt, node); AstNode *decl = unparen_expr(us->node); - if (decl->kind == AstNode_VarDecl) { + if (decl->kind == AstNode_VarDecl && + decl->kind == AstNode_GenericDecl) { ssa_build_stmt(proc, decl); } case_end; @@ -3858,6 +3859,75 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { ssa_build_when_stmt(proc, ws); case_end; + + case_ast_node(gd, GenericDecl, node); + for_array(spec_index, gd->specs) { + AstNode *spec = gd->specs.e[spec_index]; + switch (spec->kind) { + case_ast_node(vs, ValueSpec, spec); + switch (vs->keyword) { + case Token_const: + break; + case Token_var: { + ssaModule *m = proc->module; + gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena); + + if (vs->values.count == 0) { // declared and zero-initialized + for_array(i, vs->names) { + AstNode *name = vs->names.e[i]; + if (!ssa_is_blank_ident(name)) { + ssa_add_local_for_identifier(proc, name, true); + } + } + } else { // Tuple(s) + Array(ssaAddr) lvals; + ssaValueArray inits; + array_init_reserve(&lvals, m->tmp_allocator, vs->names.count); + array_init_reserve(&inits, m->tmp_allocator, vs->names.count); + + for_array(i, vs->names) { + AstNode *name = vs->names.e[i]; + ssaAddr lval = ssa_make_addr(NULL, NULL); + if (!ssa_is_blank_ident(name)) { + ssa_add_local_for_identifier(proc, name, false); + lval = ssa_build_addr(proc, name); + } + + array_add(&lvals, lval); + } + + for_array(i, vs->values) { + ssaValue *init = ssa_build_expr(proc, vs->values.e[i]); + Type *t = ssa_type(init); + if (t->kind == Type_Tuple) { + for (isize i = 0; i < t->Tuple.variable_count; i++) { + Entity *e = t->Tuple.variables[i]; + ssaValue *v = ssa_emit_struct_ev(proc, init, i); + array_add(&inits, v); + } + } else { + array_add(&inits, init); + } + } + + + for_array(i, inits) { + if (lvals.e[i].addr == NULL) { + continue; + } + ssaValue *v = ssa_emit_conv(proc, inits.e[i], ssa_addr_type(lvals.e[i])); + ssa_addr_store(proc, lvals.e[i], v); + } + } + + gb_temp_arena_memory_end(tmp); + } break; + } + case_end; + } + } + case_end; + case_ast_node(vd, VarDecl, node); ssaModule *m = proc->module; gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena); -- cgit v1.2.3