Documentation

Index

Constants

View Source
const (
	FALSE = 0
	TRUE  = 1
	NONE  = 0

	BYTE           = 0x1400
	UNSIGNED_BYTE  = 0x1401
	SHORT          = 0x1402
	UNSIGNED_SHORT = 0x1403
	INT            = 0x1404
	UNSIGNED_INT   = 0x1405
	FLOAT          = 0x1406
	N2_BYTES       = 0x1407
	N3_BYTES       = 0x1408
	N4_BYTES       = 0x1409
	DOUBLE         = 0x140A
	HALF_FLOAT     = 0x140B
	FIXED          = 0x140C

	ACCUM  = 0x0100
	LOAD   = 0x0101
	RETURN = 0x0102
	MULT   = 0x0103
	ADD    = 0x0104

	ACCUM_BUFFER_BIT    = 0x00000200
	ALL_ATTRIB_BITS     = 0xFFFFFFFF
	COLOR_BUFFER_BIT    = 0x00004000
	CURRENT_BIT         = 0x00000001
	DEPTH_BUFFER_BIT    = 0x00000100
	ENABLE_BIT          = 0x00002000
	EVAL_BIT            = 0x00010000
	FOG_BIT             = 0x00000080
	HINT_BIT            = 0x00008000
	LIGHTING_BIT        = 0x00000040
	LINE_BIT            = 0x00000004
	LIST_BIT            = 0x00020000
	MULTISAMPLE_BIT     = 0x20000000
	PIXEL_MODE_BIT      = 0x00000020
	POINT_BIT           = 0x00000002
	POLYGON_BIT         = 0x00000008
	POLYGON_STIPPLE_BIT = 0x00000010
	SCISSOR_BIT         = 0x00080000
	STENCIL_BUFFER_BIT  = 0x00000400
	TEXTURE_BIT         = 0x00040000
	TRANSFORM_BIT       = 0x00001000
	VIEWPORT_BIT        = 0x00000800

	ALWAYS   = 0x0207
	EQUAL    = 0x0202
	GEQUAL   = 0x0206
	GREATER  = 0x0204
	LEQUAL   = 0x0203
	LESS     = 0x0201
	NEVER    = 0x0200
	NOTEQUAL = 0x0205

	LOGIC_OP = 0x0BF1

	DST_ALPHA           = 0x0304
	ONE                 = 1
	ONE_MINUS_DST_ALPHA = 0x0305
	ONE_MINUS_SRC_ALPHA = 0x0303
	ONE_MINUS_SRC_COLOR = 0x0301
	SRC_ALPHA           = 0x0302
	SRC_COLOR           = 0x0300
	ZERO                = 0

	DST_COLOR           = 0x0306
	ONE_MINUS_DST_COLOR = 0x0307
	SRC_ALPHA_SATURATE  = 0x0308

	CLIENT_ALL_ATTRIB_BITS  = 0xFFFFFFFF
	CLIENT_PIXEL_STORE_BIT  = 0x00000001
	CLIENT_VERTEX_ARRAY_BIT = 0x00000002

	CLIP_DISTANCE0 = 0x3000
	CLIP_DISTANCE1 = 0x3001
	CLIP_DISTANCE2 = 0x3002
	CLIP_DISTANCE3 = 0x3003
	CLIP_DISTANCE4 = 0x3004
	CLIP_DISTANCE5 = 0x3005
	CLIP_DISTANCE6 = 0x3006
	CLIP_DISTANCE7 = 0x3007
	CLIP_PLANE0    = 0x3000
	CLIP_PLANE1    = 0x3001
	CLIP_PLANE2    = 0x3002
	CLIP_PLANE3    = 0x3003
	CLIP_PLANE4    = 0x3004
	CLIP_PLANE5    = 0x3005

	BACK           = 0x0405
	FRONT          = 0x0404
	FRONT_AND_BACK = 0x0408

	AMBIENT             = 0x1200
	AMBIENT_AND_DIFFUSE = 0x1602
	DIFFUSE             = 0x1201
	EMISSION            = 0x1600
	SPECULAR            = 0x1202

	CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001

	CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002
	CONTEXT_CORE_PROFILE_BIT          = 0x00000001

	AUX0        = 0x0409
	AUX1        = 0x040A
	AUX2        = 0x040B
	AUX3        = 0x040C
	BACK_LEFT   = 0x0402
	BACK_RIGHT  = 0x0403
	FRONT_LEFT  = 0x0400
	FRONT_RIGHT = 0x0401
	LEFT        = 0x0406
	RIGHT       = 0x0407

	ALPHA_TEST           = 0x0BC0
	AUTO_NORMAL          = 0x0D80
	BLEND                = 0x0BE2
	COLOR_ARRAY          = 0x8076
	COLOR_LOGIC_OP       = 0x0BF2
	COLOR_MATERIAL       = 0x0B57
	CULL_FACE            = 0x0B44
	DEPTH_TEST           = 0x0B71
	DITHER               = 0x0BD0
	EDGE_FLAG_ARRAY      = 0x8079
	FOG                  = 0x0B60
	INDEX_ARRAY          = 0x8077
	INDEX_LOGIC_OP       = 0x0BF1
	LIGHT0               = 0x4000
	LIGHT1               = 0x4001
	LIGHT2               = 0x4002
	LIGHT3               = 0x4003
	LIGHT4               = 0x4004
	LIGHT5               = 0x4005
	LIGHT6               = 0x4006
	LIGHT7               = 0x4007
	LIGHTING             = 0x0B50
	LINE_SMOOTH          = 0x0B20
	LINE_STIPPLE         = 0x0B24
	MAP1_COLOR_4         = 0x0D90
	MAP1_INDEX           = 0x0D91
	MAP1_NORMAL          = 0x0D92
	MAP1_TEXTURE_COORD_1 = 0x0D93
	MAP1_TEXTURE_COORD_2 = 0x0D94
	MAP1_TEXTURE_COORD_3 = 0x0D95
	MAP1_TEXTURE_COORD_4 = 0x0D96
	MAP1_VERTEX_3        = 0x0D97
	MAP1_VERTEX_4        = 0x0D98
	MAP2_COLOR_4         = 0x0DB0
	MAP2_INDEX           = 0x0DB1
	MAP2_NORMAL          = 0x0DB2
	MAP2_TEXTURE_COORD_1 = 0x0DB3
	MAP2_TEXTURE_COORD_2 = 0x0DB4
	MAP2_TEXTURE_COORD_3 = 0x0DB5
	MAP2_TEXTURE_COORD_4 = 0x0DB6
	MAP2_VERTEX_3        = 0x0DB7
	MAP2_VERTEX_4        = 0x0DB8
	NORMALIZE            = 0x0BA1
	NORMAL_ARRAY         = 0x8075
	POINT_SMOOTH         = 0x0B10
	POLYGON_OFFSET_FILL  = 0x8037
	POLYGON_OFFSET_LINE  = 0x2A02
	POLYGON_OFFSET_POINT = 0x2A01
	POLYGON_SMOOTH       = 0x0B41
	POLYGON_STIPPLE      = 0x0B42
	SCISSOR_TEST         = 0x0C11
	STENCIL_TEST         = 0x0B90
	TEXTURE_1D           = 0x0DE0
	TEXTURE_2D           = 0x0DE1
	TEXTURE_COORD_ARRAY  = 0x8078
	TEXTURE_GEN_Q        = 0x0C63
	TEXTURE_GEN_R        = 0x0C62
	TEXTURE_GEN_S        = 0x0C60
	TEXTURE_GEN_T        = 0x0C61
	VERTEX_ARRAY         = 0x8074

	INVALID_ENUM                  = 0x0500
	INVALID_FRAMEBUFFER_OPERATION = 0x0506
	INVALID_OPERATION             = 0x0502
	INVALID_VALUE                 = 0x0501
	NO_ERROR                      = 0
	OUT_OF_MEMORY                 = 0x0505
	STACK_OVERFLOW                = 0x0503
	STACK_UNDERFLOW               = 0x0504

	N2D               = 0x0600
	N3D               = 0x0601
	N3D_COLOR         = 0x0602
	N3D_COLOR_TEXTURE = 0x0603
	N4D_COLOR_TEXTURE = 0x0604

	BITMAP_TOKEN       = 0x0704
	COPY_PIXEL_TOKEN   = 0x0706
	DRAW_PIXEL_TOKEN   = 0x0705
	LINE_RESET_TOKEN   = 0x0707
	LINE_TOKEN         = 0x0702
	PASS_THROUGH_TOKEN = 0x0700
	POINT_TOKEN        = 0x0701
	POLYGON_TOKEN      = 0x0703

	EXP    = 0x0800
	EXP2   = 0x0801
	LINEAR = 0x2601

	FOG_COLOR   = 0x0B66
	FOG_DENSITY = 0x0B62
	FOG_END     = 0x0B64
	FOG_INDEX   = 0x0B61
	FOG_MODE    = 0x0B65
	FOG_START   = 0x0B63

	CCW = 0x0901
	CW  = 0x0900

	COEFF  = 0x0A00
	DOMAIN = 0x0A02
	ORDER  = 0x0A01

	PIXEL_MAP_A_TO_A = 0x0C79
	PIXEL_MAP_B_TO_B = 0x0C78
	PIXEL_MAP_G_TO_G = 0x0C77
	PIXEL_MAP_I_TO_A = 0x0C75
	PIXEL_MAP_I_TO_B = 0x0C74
	PIXEL_MAP_I_TO_G = 0x0C73
	PIXEL_MAP_I_TO_I = 0x0C70
	PIXEL_MAP_I_TO_R = 0x0C72
	PIXEL_MAP_R_TO_R = 0x0C76
	PIXEL_MAP_S_TO_S = 0x0C71

	ACCUM_ALPHA_BITS              = 0x0D5B
	ACCUM_BLUE_BITS               = 0x0D5A
	ACCUM_CLEAR_VALUE             = 0x0B80
	ACCUM_GREEN_BITS              = 0x0D59
	ACCUM_RED_BITS                = 0x0D58
	ALIASED_LINE_WIDTH_RANGE      = 0x846E
	ALIASED_POINT_SIZE_RANGE      = 0x846D
	ALPHA_BIAS                    = 0x0D1D
	ALPHA_BITS                    = 0x0D55
	ALPHA_SCALE                   = 0x0D1C
	ALPHA_TEST_FUNC               = 0x0BC1
	ALPHA_TEST_REF                = 0x0BC2
	ATTRIB_STACK_DEPTH            = 0x0BB0
	AUX_BUFFERS                   = 0x0C00
	BLEND_DST                     = 0x0BE0
	BLEND_SRC                     = 0x0BE1
	BLUE_BIAS                     = 0x0D1B
	BLUE_BITS                     = 0x0D54
	BLUE_SCALE                    = 0x0D1A
	CLIENT_ATTRIB_STACK_DEPTH     = 0x0BB1
	COLOR_ARRAY_SIZE              = 0x8081
	COLOR_ARRAY_STRIDE            = 0x8083
	COLOR_ARRAY_TYPE              = 0x8082
	COLOR_CLEAR_VALUE             = 0x0C22
	COLOR_MATERIAL_FACE           = 0x0B55
	COLOR_MATERIAL_PARAMETER      = 0x0B56
	COLOR_WRITEMASK               = 0x0C23
	CULL_FACE_MODE                = 0x0B45
	CURRENT_COLOR                 = 0x0B00
	CURRENT_INDEX                 = 0x0B01
	CURRENT_NORMAL                = 0x0B02
	CURRENT_RASTER_COLOR          = 0x0B04
	CURRENT_RASTER_DISTANCE       = 0x0B09
	CURRENT_RASTER_INDEX          = 0x0B05
	CURRENT_RASTER_POSITION       = 0x0B07
	CURRENT_RASTER_POSITION_VALID = 0x0B08
	CURRENT_RASTER_TEXTURE_COORDS = 0x0B06
	CURRENT_TEXTURE_COORDS        = 0x0B03
	DEPTH_BIAS                    = 0x0D1F
	DEPTH_BITS                    = 0x0D56
	DEPTH_CLEAR_VALUE             = 0x0B73
	DEPTH_FUNC                    = 0x0B74
	DEPTH_RANGE                   = 0x0B70
	DEPTH_SCALE                   = 0x0D1E
	DEPTH_WRITEMASK               = 0x0B72
	DOUBLEBUFFER                  = 0x0C32
	DRAW_BUFFER                   = 0x0C01
	EDGE_FLAG                     = 0x0B43
	EDGE_FLAG_ARRAY_STRIDE        = 0x808C
	FEEDBACK_BUFFER_SIZE          = 0x0DF1
	FEEDBACK_BUFFER_TYPE          = 0x0DF2
	FOG_HINT                      = 0x0C54
	FRONT_FACE                    = 0x0B46
	GREEN_BIAS                    = 0x0D19
	GREEN_BITS                    = 0x0D53
	GREEN_SCALE                   = 0x0D18
	INDEX_ARRAY_STRIDE            = 0x8086
	INDEX_ARRAY_TYPE              = 0x8085
	INDEX_BITS                    = 0x0D51
	INDEX_CLEAR_VALUE             = 0x0C20
	INDEX_MODE                    = 0x0C30
	INDEX_OFFSET                  = 0x0D13
	INDEX_SHIFT                   = 0x0D12
	INDEX_WRITEMASK               = 0x0C21
	LIGHT_MODEL_AMBIENT           = 0x0B53
	LIGHT_MODEL_COLOR_CONTROL     = 0x81F8
	LIGHT_MODEL_LOCAL_VIEWER      = 0x0B51
	LIGHT_MODEL_TWO_SIDE          = 0x0B52
	LINE_SMOOTH_HINT              = 0x0C52
	LINE_STIPPLE_PATTERN          = 0x0B25
	LINE_STIPPLE_REPEAT           = 0x0B26
	LINE_WIDTH                    = 0x0B21
	LINE_WIDTH_GRANULARITY        = 0x0B23
	LINE_WIDTH_RANGE              = 0x0B22
	LIST_BASE                     = 0x0B32
	LIST_INDEX                    = 0x0B33
	LIST_MODE                     = 0x0B30
	LOGIC_OP_MODE                 = 0x0BF0
	MAP1_GRID_DOMAIN              = 0x0DD0
	MAP1_GRID_SEGMENTS            = 0x0DD1
	MAP2_GRID_DOMAIN              = 0x0DD2
	MAP2_GRID_SEGMENTS            = 0x0DD3
	MAP_COLOR                     = 0x0D10
	MAP_STENCIL                   = 0x0D11
	MATRIX_MODE                   = 0x0BA0
	MAX_ATTRIB_STACK_DEPTH        = 0x0D35
	MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B
	MAX_CLIP_DISTANCES            = 0x0D32
	MAX_CLIP_PLANES               = 0x0D32
	MAX_EVAL_ORDER                = 0x0D30
	MAX_LIGHTS                    = 0x0D31
	MAX_LIST_NESTING              = 0x0B31
	MAX_MODELVIEW_STACK_DEPTH     = 0x0D36
	MAX_NAME_STACK_DEPTH          = 0x0D37
	MAX_PIXEL_MAP_TABLE           = 0x0D34
	MAX_PROJECTION_STACK_DEPTH    = 0x0D38
	MAX_TEXTURE_SIZE              = 0x0D33
	MAX_TEXTURE_STACK_DEPTH       = 0x0D39
	MAX_VIEWPORT_DIMS             = 0x0D3A
	MODELVIEW_MATRIX              = 0x0BA6
	MODELVIEW_STACK_DEPTH         = 0x0BA3
	NAME_STACK_DEPTH              = 0x0D70
	NORMAL_ARRAY_STRIDE           = 0x807F
	NORMAL_ARRAY_TYPE             = 0x807E
	PACK_ALIGNMENT                = 0x0D05
	PACK_LSB_FIRST                = 0x0D01
	PACK_ROW_LENGTH               = 0x0D02
	PACK_SKIP_PIXELS              = 0x0D04
	PACK_SKIP_ROWS                = 0x0D03
	PACK_SWAP_BYTES               = 0x0D00
	PERSPECTIVE_CORRECTION_HINT   = 0x0C50
	PIXEL_MAP_A_TO_A_SIZE         = 0x0CB9
	PIXEL_MAP_B_TO_B_SIZE         = 0x0CB8
	PIXEL_MAP_G_TO_G_SIZE         = 0x0CB7
	PIXEL_MAP_I_TO_A_SIZE         = 0x0CB5
	PIXEL_MAP_I_TO_B_SIZE         = 0x0CB4
	PIXEL_MAP_I_TO_G_SIZE         = 0x0CB3
	PIXEL_MAP_I_TO_I_SIZE         = 0x0CB0
	PIXEL_MAP_I_TO_R_SIZE         = 0x0CB2
	PIXEL_MAP_R_TO_R_SIZE         = 0x0CB6
	PIXEL_MAP_S_TO_S_SIZE         = 0x0CB1
	POINT_SIZE                    = 0x0B11
	POINT_SIZE_GRANULARITY        = 0x0B13
	POINT_SIZE_RANGE              = 0x0B12
	POINT_SMOOTH_HINT             = 0x0C51
	POLYGON_MODE                  = 0x0B40
	POLYGON_OFFSET_FACTOR         = 0x8038
	POLYGON_OFFSET_UNITS          = 0x2A00
	POLYGON_SMOOTH_HINT           = 0x0C53
	PROJECTION_MATRIX             = 0x0BA7
	PROJECTION_STACK_DEPTH        = 0x0BA4
	READ_BUFFER                   = 0x0C02
	RED_BIAS                      = 0x0D15
	RED_BITS                      = 0x0D52
	RED_SCALE                     = 0x0D14
	RENDER_MODE                   = 0x0C40
	RGBA_MODE                     = 0x0C31
	SCISSOR_BOX                   = 0x0C10
	SELECTION_BUFFER_SIZE         = 0x0DF4
	SHADE_MODEL                   = 0x0B54
	SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23
	SMOOTH_LINE_WIDTH_RANGE       = 0x0B22
	SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13
	SMOOTH_POINT_SIZE_RANGE       = 0x0B12
	STENCIL_BITS                  = 0x0D57
	STENCIL_CLEAR_VALUE           = 0x0B91
	STENCIL_FAIL                  = 0x0B94
	STENCIL_FUNC                  = 0x0B92
	STENCIL_PASS_DEPTH_FAIL       = 0x0B95
	STENCIL_PASS_DEPTH_PASS       = 0x0B96
	STENCIL_REF                   = 0x0B97
	STENCIL_VALUE_MASK            = 0x0B93
	STENCIL_WRITEMASK             = 0x0B98
	STEREO                        = 0x0C33
	SUBPIXEL_BITS                 = 0x0D50
	TEXTURE_BINDING_1D            = 0x8068
	TEXTURE_BINDING_2D            = 0x8069
	TEXTURE_BINDING_3D            = 0x806A
	TEXTURE_COORD_ARRAY_SIZE      = 0x8088
	TEXTURE_COORD_ARRAY_STRIDE    = 0x808A
	TEXTURE_COORD_ARRAY_TYPE      = 0x8089
	TEXTURE_MATRIX                = 0x0BA8
	TEXTURE_STACK_DEPTH           = 0x0BA5
	UNPACK_ALIGNMENT              = 0x0CF5
	UNPACK_LSB_FIRST              = 0x0CF1
	UNPACK_ROW_LENGTH             = 0x0CF2
	UNPACK_SKIP_PIXELS            = 0x0CF4
	UNPACK_SKIP_ROWS              = 0x0CF3
	UNPACK_SWAP_BYTES             = 0x0CF0
	VERTEX_ARRAY_SIZE             = 0x807A
	VERTEX_ARRAY_STRIDE           = 0x807C
	VERTEX_ARRAY_TYPE             = 0x807B
	VIEWPORT                      = 0x0BA2
	ZOOM_X                        = 0x0D16
	ZOOM_Y                        = 0x0D17

	COLOR_ARRAY_POINTER         = 0x8090
	EDGE_FLAG_ARRAY_POINTER     = 0x8093
	FEEDBACK_BUFFER_POINTER     = 0x0DF0
	INDEX_ARRAY_POINTER         = 0x8091
	NORMAL_ARRAY_POINTER        = 0x808F
	SELECTION_BUFFER_POINTER    = 0x0DF3
	TEXTURE_COORD_ARRAY_POINTER = 0x8092
	VERTEX_ARRAY_POINTER        = 0x808E

	TEXTURE_ALPHA_SIZE      = 0x805F
	TEXTURE_BLUE_SIZE       = 0x805E
	TEXTURE_BORDER          = 0x1005
	TEXTURE_BORDER_COLOR    = 0x1004
	TEXTURE_COMPONENTS      = 0x1003
	TEXTURE_GREEN_SIZE      = 0x805D
	TEXTURE_HEIGHT          = 0x1001
	TEXTURE_INTENSITY_SIZE  = 0x8061
	TEXTURE_INTERNAL_FORMAT = 0x1003
	TEXTURE_LUMINANCE_SIZE  = 0x8060
	TEXTURE_MAG_FILTER      = 0x2800
	TEXTURE_MIN_FILTER      = 0x2801
	TEXTURE_PRIORITY        = 0x8066
	TEXTURE_RED_SIZE        = 0x805C
	TEXTURE_RESIDENT        = 0x8067
	TEXTURE_WIDTH           = 0x1000
	TEXTURE_WRAP_S          = 0x2802
	TEXTURE_WRAP_T          = 0x2803

	DONT_CARE = 0x1100
	FASTEST   = 0x1101
	NICEST    = 0x1102

	FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B
	GENERATE_MIPMAP_HINT            = 0x8192
	PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257
	TEXTURE_COMPRESSION_HINT        = 0x84EF

	C3F_V3F         = 0x2A24
	C4F_N3F_V3F     = 0x2A26
	C4UB_V2F        = 0x2A22
	C4UB_V3F        = 0x2A23
	N3F_V3F         = 0x2A25
	T2F_C3F_V3F     = 0x2A2A
	T2F_C4F_N3F_V3F = 0x2A2C
	T2F_C4UB_V3F    = 0x2A29
	T2F_N3F_V3F     = 0x2A2B
	T2F_V3F         = 0x2A27
	T4F_C4F_N3F_V4F = 0x2A2D
	T4F_V4F         = 0x2A28
	V2F             = 0x2A20
	V3F             = 0x2A21

	MODULATE = 0x2100
	REPLACE  = 0x1E01

	SEPARATE_SPECULAR_COLOR = 0x81FA
	SINGLE_COLOR            = 0x81F9

	CONSTANT_ATTENUATION  = 0x1207
	LINEAR_ATTENUATION    = 0x1208
	POSITION              = 0x1203
	QUADRATIC_ATTENUATION = 0x1209
	SPOT_CUTOFF           = 0x1206
	SPOT_DIRECTION        = 0x1204
	SPOT_EXPONENT         = 0x1205

	COMPILE             = 0x1300
	COMPILE_AND_EXECUTE = 0x1301

	AND           = 0x1501
	AND_INVERTED  = 0x1504
	AND_REVERSE   = 0x1502
	CLEAR         = 0x1500
	COPY          = 0x1503
	COPY_INVERTED = 0x150C
	EQUIV         = 0x1509
	INVERT        = 0x150A
	NAND          = 0x150E
	NOOP          = 0x1505
	NOR           = 0x1508
	OR            = 0x1507
	OR_INVERTED   = 0x150D
	OR_REVERSE    = 0x150B
	SET           = 0x150F
	XOR           = 0x1506

	MAP_FLUSH_EXPLICIT_BIT    = 0x0010
	MAP_INVALIDATE_BUFFER_BIT = 0x0008
	MAP_INVALIDATE_RANGE_BIT  = 0x0004
	MAP_READ_BIT              = 0x0001
	MAP_UNSYNCHRONIZED_BIT    = 0x0020
	MAP_WRITE_BIT             = 0x0002

	COLOR_INDEXES = 0x1603
	SHININESS     = 0x1601

	MODELVIEW  = 0x1700
	PROJECTION = 0x1701
	TEXTURE    = 0x1702

	LINE  = 0x1B01
	POINT = 0x1B00

	FILL = 0x1B02

	COLOR   = 0x1800
	DEPTH   = 0x1801
	STENCIL = 0x1802

	ALPHA           = 0x1906
	BLUE            = 0x1905
	COLOR_INDEX     = 0x1900
	DEPTH_COMPONENT = 0x1902
	GREEN           = 0x1904
	LUMINANCE       = 0x1909
	LUMINANCE_ALPHA = 0x190A
	RED             = 0x1903
	RGB             = 0x1907
	RGBA            = 0x1908
	STENCIL_INDEX   = 0x1901

	ALPHA12             = 0x803D
	ALPHA16             = 0x803E
	ALPHA4              = 0x803B
	ALPHA8              = 0x803C
	INTENSITY           = 0x8049
	INTENSITY12         = 0x804C
	INTENSITY16         = 0x804D
	INTENSITY4          = 0x804A
	INTENSITY8          = 0x804B
	LUMINANCE12         = 0x8041
	LUMINANCE12_ALPHA12 = 0x8047
	LUMINANCE12_ALPHA4  = 0x8046
	LUMINANCE16         = 0x8042
	LUMINANCE16_ALPHA16 = 0x8048
	LUMINANCE4          = 0x803F
	LUMINANCE4_ALPHA4   = 0x8043
	LUMINANCE6_ALPHA2   = 0x8044
	LUMINANCE8          = 0x8040
	LUMINANCE8_ALPHA8   = 0x8045
	R3_G3_B2            = 0x2A10
	RGB10               = 0x8052
	RGB10_A2            = 0x8059
	RGB12               = 0x8053
	RGB16               = 0x8054
	RGB4                = 0x804F
	RGB5                = 0x8050
	RGB5_A1             = 0x8057
	RGB8                = 0x8051
	RGBA12              = 0x805A
	RGBA16              = 0x805B
	RGBA2               = 0x8055
	RGBA4               = 0x8056
	RGBA8               = 0x8058

	PACK_IMAGE_HEIGHT   = 0x806C
	PACK_SKIP_IMAGES    = 0x806B
	UNPACK_IMAGE_HEIGHT = 0x806E
	UNPACK_SKIP_IMAGES  = 0x806D

	BITMAP                  = 0x1A00
	UNSIGNED_BYTE_3_3_2     = 0x8032
	UNSIGNED_INT_10_10_10_2 = 0x8036
	UNSIGNED_INT_8_8_8_8    = 0x8035
	UNSIGNED_SHORT_4_4_4_4  = 0x8033
	UNSIGNED_SHORT_5_5_5_1  = 0x8034

	POINT_DISTANCE_ATTENUATION = 0x8129
	POINT_FADE_THRESHOLD_SIZE  = 0x8128
	POINT_SIZE_MAX             = 0x8127
	POINT_SIZE_MIN             = 0x8126

	LINES                    = 0x0001
	LINES_ADJACENCY          = 0x000A
	LINE_LOOP                = 0x0002
	LINE_STRIP               = 0x0003
	LINE_STRIP_ADJACENCY     = 0x000B
	PATCHES                  = 0x000E
	POINTS                   = 0x0000
	POLYGON                  = 0x0009
	QUADS                    = 0x0007
	QUAD_STRIP               = 0x0008
	TRIANGLES                = 0x0004
	TRIANGLES_ADJACENCY      = 0x000C
	TRIANGLE_FAN             = 0x0006
	TRIANGLE_STRIP           = 0x0005
	TRIANGLE_STRIP_ADJACENCY = 0x000D

	FEEDBACK = 0x1C01
	RENDER   = 0x1C00
	SELECT   = 0x1C02

	FLAT   = 0x1D00
	SMOOTH = 0x1D01

	DECR = 0x1E03
	INCR = 0x1E02
	KEEP = 0x1E00

	EXTENSIONS = 0x1F03
	RENDERER   = 0x1F01
	VENDOR     = 0x1F00
	VERSION    = 0x1F02

	S = 0x2000
	T = 0x2001
	R = 0x2002
	Q = 0x2003

	DECAL = 0x2101

	TEXTURE_ENV_COLOR = 0x2201
	TEXTURE_ENV_MODE  = 0x2200

	TEXTURE_ENV = 0x2300

	EYE_LINEAR    = 0x2400
	OBJECT_LINEAR = 0x2401
	SPHERE_MAP    = 0x2402

	EYE_PLANE        = 0x2502
	OBJECT_PLANE     = 0x2501
	TEXTURE_GEN_MODE = 0x2500

	NEAREST = 0x2600

	LINEAR_MIPMAP_LINEAR   = 0x2703
	LINEAR_MIPMAP_NEAREST  = 0x2701
	NEAREST_MIPMAP_LINEAR  = 0x2702
	NEAREST_MIPMAP_NEAREST = 0x2700

	GENERATE_MIPMAP = 0x8191
	TEXTURE_WRAP_R  = 0x8072

	PROXY_TEXTURE_1D   = 0x8063
	PROXY_TEXTURE_2D   = 0x8064
	PROXY_TEXTURE_3D   = 0x8070
	TEXTURE_3D         = 0x806F
	TEXTURE_BASE_LEVEL = 0x813C
	TEXTURE_MAX_LEVEL  = 0x813D
	TEXTURE_MAX_LOD    = 0x813B
	TEXTURE_MIN_LOD    = 0x813A

	CLAMP           = 0x2900
	CLAMP_TO_BORDER = 0x812D
	CLAMP_TO_EDGE   = 0x812F
	REPEAT          = 0x2901

	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

	SYNC_FLUSH_COMMANDS_BIT                            = 0x00000001
	INVALID_INDEX                                      = 0xFFFFFFFF
	TIMEOUT_IGNORED                                    = 0xFFFFFFFFFFFFFFFF
	CONSTANT_COLOR                                     = 0x8001
	ONE_MINUS_CONSTANT_COLOR                           = 0x8002
	CONSTANT_ALPHA                                     = 0x8003
	ONE_MINUS_CONSTANT_ALPHA                           = 0x8004
	FUNC_ADD                                           = 0x8006
	MIN                                                = 0x8007
	MAX                                                = 0x8008
	BLEND_EQUATION_RGB                                 = 0x8009
	FUNC_SUBTRACT                                      = 0x800A
	FUNC_REVERSE_SUBTRACT                              = 0x800B
	RESCALE_NORMAL                                     = 0x803A
	TEXTURE_DEPTH                                      = 0x8071
	MAX_3D_TEXTURE_SIZE                                = 0x8073
	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
	BLEND_DST_RGB                                      = 0x80C8
	BLEND_SRC_RGB                                      = 0x80C9
	BLEND_DST_ALPHA                                    = 0x80CA
	BLEND_SRC_ALPHA                                    = 0x80CB
	BGR                                                = 0x80E0
	BGRA                                               = 0x80E1
	MAX_ELEMENTS_VERTICES                              = 0x80E8
	MAX_ELEMENTS_INDICES                               = 0x80E9
	DEPTH_COMPONENT16                                  = 0x81A5
	DEPTH_COMPONENT24                                  = 0x81A6
	DEPTH_COMPONENT32                                  = 0x81A7
	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
	MAJOR_VERSION                                      = 0x821B
	MINOR_VERSION                                      = 0x821C
	NUM_EXTENSIONS                                     = 0x821D
	CONTEXT_FLAGS                                      = 0x821E
	COMPRESSED_RED                                     = 0x8225
	COMPRESSED_RG                                      = 0x8226
	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
	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
	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
	MIRRORED_REPEAT                                    = 0x8370
	FOG_COORDINATE_SOURCE                              = 0x8450
	FOG_COORD_SRC                                      = 0x8450
	FOG_COORDINATE                                     = 0x8451
	FOG_COORD                                          = 0x8451
	FRAGMENT_DEPTH                                     = 0x8452
	CURRENT_FOG_COORDINATE                             = 0x8453
	CURRENT_FOG_COORD                                  = 0x8453
	FOG_COORDINATE_ARRAY_TYPE                          = 0x8454
	FOG_COORD_ARRAY_TYPE                               = 0x8454
	FOG_COORDINATE_ARRAY_STRIDE                        = 0x8455
	FOG_COORD_ARRAY_STRIDE                             = 0x8455
	FOG_COORDINATE_ARRAY_POINTER                       = 0x8456
	FOG_COORD_ARRAY_POINTER                            = 0x8456
	FOG_COORDINATE_ARRAY                               = 0x8457
	FOG_COORD_ARRAY                                    = 0x8457
	COLOR_SUM                                          = 0x8458
	CURRENT_SECONDARY_COLOR                            = 0x8459
	SECONDARY_COLOR_ARRAY_SIZE                         = 0x845A
	SECONDARY_COLOR_ARRAY_TYPE                         = 0x845B
	SECONDARY_COLOR_ARRAY_STRIDE                       = 0x845C
	SECONDARY_COLOR_ARRAY_POINTER                      = 0x845D
	SECONDARY_COLOR_ARRAY                              = 0x845E
	CURRENT_RASTER_SECONDARY_COLOR                     = 0x845F
	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
	CLIENT_ACTIVE_TEXTURE                              = 0x84E1
	MAX_TEXTURE_UNITS                                  = 0x84E2
	TRANSPOSE_MODELVIEW_MATRIX                         = 0x84E3
	TRANSPOSE_PROJECTION_MATRIX                        = 0x84E4
	TRANSPOSE_TEXTURE_MATRIX                           = 0x84E5
	TRANSPOSE_COLOR_MATRIX                             = 0x84E6
	SUBTRACT                                           = 0x84E7
	MAX_RENDERBUFFER_SIZE                              = 0x84E8
	COMPRESSED_ALPHA                                   = 0x84E9
	COMPRESSED_LUMINANCE                               = 0x84EA
	COMPRESSED_LUMINANCE_ALPHA                         = 0x84EB
	COMPRESSED_INTENSITY                               = 0x84EC
	COMPRESSED_RGB                                     = 0x84ED
	COMPRESSED_RGBA                                    = 0x84EE
	UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER    = 0x84F0
	UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1
	TEXTURE_RECTANGLE                                  = 0x84F5
	TEXTURE_BINDING_RECTANGLE                          = 0x84F6
	PROXY_TEXTURE_RECTANGLE                            = 0x84F7
	MAX_RECTANGLE_TEXTURE_SIZE                         = 0x84F8
	DEPTH_STENCIL                                      = 0x84F9
	UNSIGNED_INT_24_8                                  = 0x84FA
	MAX_TEXTURE_LOD_BIAS                               = 0x84FD
	TEXTURE_FILTER_CONTROL                             = 0x8500
	TEXTURE_LOD_BIAS                                   = 0x8501
	INCR_WRAP                                          = 0x8507
	DECR_WRAP                                          = 0x8508
	NORMAL_MAP                                         = 0x8511
	REFLECTION_MAP                                     = 0x8512
	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
	COMBINE                                            = 0x8570
	COMBINE_RGB                                        = 0x8571
	COMBINE_ALPHA                                      = 0x8572
	RGB_SCALE                                          = 0x8573
	ADD_SIGNED                                         = 0x8574
	INTERPOLATE                                        = 0x8575
	CONSTANT                                           = 0x8576
	PRIMARY_COLOR                                      = 0x8577
	PREVIOUS                                           = 0x8578
	SOURCE0_RGB                                        = 0x8580
	SRC0_RGB                                           = 0x8580
	SOURCE1_RGB                                        = 0x8581
	SRC1_RGB                                           = 0x8581
	SOURCE2_RGB                                        = 0x8582
	SRC2_RGB                                           = 0x8582
	SOURCE0_ALPHA                                      = 0x8588
	SRC0_ALPHA                                         = 0x8588
	SOURCE1_ALPHA                                      = 0x8589
	SRC1_ALPHA                                         = 0x8589
	SOURCE2_ALPHA                                      = 0x858A
	SRC2_ALPHA                                         = 0x858A
	OPERAND0_RGB                                       = 0x8590
	OPERAND1_RGB                                       = 0x8591
	OPERAND2_RGB                                       = 0x8592
	OPERAND0_ALPHA                                     = 0x8598
	OPERAND1_ALPHA                                     = 0x8599
	OPERAND2_ALPHA                                     = 0x859A
	VERTEX_ARRAY_BINDING                               = 0x85B5
	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
	PROGRAM_POINT_SIZE                                 = 0x8642
	VERTEX_PROGRAM_TWO_SIDE                            = 0x8643
	VERTEX_ATTRIB_ARRAY_POINTER                        = 0x8645
	DEPTH_CLAMP                                        = 0x864F
	TEXTURE_COMPRESSED_IMAGE_SIZE                      = 0x86A0
	TEXTURE_COMPRESSED                                 = 0x86A1
	NUM_COMPRESSED_TEXTURE_FORMATS                     = 0x86A2
	COMPRESSED_TEXTURE_FORMATS                         = 0x86A3
	DOT3_RGB                                           = 0x86AE
	DOT3_RGBA                                          = 0x86AF
	PROGRAM_BINARY_LENGTH                              = 0x8741
	BUFFER_SIZE                                        = 0x8764
	BUFFER_USAGE                                       = 0x8765
	NUM_PROGRAM_BINARY_FORMATS                         = 0x87FE
	PROGRAM_BINARY_FORMATS                             = 0x87FF
	STENCIL_BACK_FUNC                                  = 0x8800
	STENCIL_BACK_FAIL                                  = 0x8801
	STENCIL_BACK_PASS_DEPTH_FAIL                       = 0x8802
	STENCIL_BACK_PASS_DEPTH_PASS                       = 0x8803
	RGBA32F                                            = 0x8814
	RGB32F                                             = 0x8815
	RGBA16F                                            = 0x881A
	RGB16F                                             = 0x881B
	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
	TEXTURE_DEPTH_SIZE                                 = 0x884A
	DEPTH_TEXTURE_MODE                                 = 0x884B
	TEXTURE_COMPARE_MODE                               = 0x884C
	TEXTURE_COMPARE_FUNC                               = 0x884D
	COMPARE_R_TO_TEXTURE                               = 0x884E
	COMPARE_REF_TO_TEXTURE                             = 0x884E
	TEXTURE_CUBE_MAP_SEAMLESS                          = 0x884F
	POINT_SPRITE                                       = 0x8861
	COORD_REPLACE                                      = 0x8862
	QUERY_COUNTER_BITS                                 = 0x8864
	CURRENT_QUERY                                      = 0x8865
	QUERY_RESULT                                       = 0x8866
	QUERY_RESULT_AVAILABLE                             = 0x8867
	MAX_VERTEX_ATTRIBS                                 = 0x8869
	VERTEX_ATTRIB_ARRAY_NORMALIZED                     = 0x886A
	MAX_TESS_CONTROL_INPUT_COMPONENTS                  = 0x886C
	MAX_TESS_EVALUATION_INPUT_COMPONENTS               = 0x886D
	MAX_TEXTURE_COORDS                                 = 0x8871
	MAX_TEXTURE_IMAGE_UNITS                            = 0x8872
	GEOMETRY_SHADER_INVOCATIONS                        = 0x887F
	ARRAY_BUFFER                                       = 0x8892
	ELEMENT_ARRAY_BUFFER                               = 0x8893
	ARRAY_BUFFER_BINDING                               = 0x8894
	ELEMENT_ARRAY_BUFFER_BINDING                       = 0x8895
	VERTEX_ARRAY_BUFFER_BINDING                        = 0x8896
	NORMAL_ARRAY_BUFFER_BINDING                        = 0x8897
	COLOR_ARRAY_BUFFER_BINDING                         = 0x8898
	INDEX_ARRAY_BUFFER_BINDING                         = 0x8899
	TEXTURE_COORD_ARRAY_BUFFER_BINDING                 = 0x889A
	EDGE_FLAG_ARRAY_BUFFER_BINDING                     = 0x889B
	SECONDARY_COLOR_ARRAY_BUFFER_BINDING               = 0x889C
	FOG_COORDINATE_ARRAY_BUFFER_BINDING                = 0x889D
	FOG_COORD_ARRAY_BUFFER_BINDING                     = 0x889D
	WEIGHT_ARRAY_BUFFER_BINDING                        = 0x889E
	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
	TIME_ELAPSED                                       = 0x88BF
	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
	PIXEL_PACK_BUFFER                                  = 0x88EB
	PIXEL_UNPACK_BUFFER                                = 0x88EC
	PIXEL_PACK_BUFFER_BINDING                          = 0x88ED
	PIXEL_UNPACK_BUFFER_BINDING                        = 0x88EF
	DEPTH24_STENCIL8                                   = 0x88F0
	TEXTURE_STENCIL_SIZE                               = 0x88F1
	SRC1_COLOR                                         = 0x88F9
	ONE_MINUS_SRC1_COLOR                               = 0x88FA
	ONE_MINUS_SRC1_ALPHA                               = 0x88FB
	MAX_DUAL_SOURCE_DRAW_BUFFERS                       = 0x88FC
	VERTEX_ATTRIB_ARRAY_INTEGER                        = 0x88FD
	VERTEX_ATTRIB_ARRAY_DIVISOR                        = 0x88FE
	MAX_ARRAY_TEXTURE_LAYERS                           = 0x88FF
	MIN_PROGRAM_TEXEL_OFFSET                           = 0x8904
	MAX_PROGRAM_TEXEL_OFFSET                           = 0x8905
	SAMPLES_PASSED                                     = 0x8914
	GEOMETRY_VERTICES_OUT                              = 0x8916
	GEOMETRY_INPUT_TYPE                                = 0x8917
	GEOMETRY_OUTPUT_TYPE                               = 0x8918
	SAMPLER_BINDING                                    = 0x8919
	CLAMP_VERTEX_COLOR                                 = 0x891A
	CLAMP_FRAGMENT_COLOR                               = 0x891B
	CLAMP_READ_COLOR                                   = 0x891C
	FIXED_ONLY                                         = 0x891D
	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
	FRAGMENT_SHADER                                    = 0x8B30
	VERTEX_SHADER                                      = 0x8B31
	MAX_FRAGMENT_UNIFORM_COMPONENTS                    = 0x8B49
	MAX_VERTEX_UNIFORM_COMPONENTS                      = 0x8B4A
	MAX_VARYING_FLOATS                                 = 0x8B4B
	MAX_VARYING_COMPONENTS                             = 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
	SAMPLER_2D_RECT                                    = 0x8B63
	SAMPLER_2D_RECT_SHADOW                             = 0x8B64
	FLOAT_MAT2x3                                       = 0x8B65
	FLOAT_MAT2x4                                       = 0x8B66
	FLOAT_MAT3x2                                       = 0x8B67
	FLOAT_MAT3x4                                       = 0x8B68
	FLOAT_MAT4x2                                       = 0x8B69
	FLOAT_MAT4x3                                       = 0x8B6A
	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
	SHADING_LANGUAGE_VERSION                           = 0x8B8C
	CURRENT_PROGRAM                                    = 0x8B8D
	IMPLEMENTATION_COLOR_READ_TYPE                     = 0x8B9A
	IMPLEMENTATION_COLOR_READ_FORMAT                   = 0x8B9B
	TEXTURE_RED_TYPE                                   = 0x8C10
	TEXTURE_GREEN_TYPE                                 = 0x8C11
	TEXTURE_BLUE_TYPE                                  = 0x8C12
	TEXTURE_ALPHA_TYPE                                 = 0x8C13
	TEXTURE_DEPTH_TYPE                                 = 0x8C16
	UNSIGNED_NORMALIZED                                = 0x8C17
	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
	MAX_GEOMETRY_TEXTURE_IMAGE_UNITS                   = 0x8C29
	TEXTURE_BUFFER                                     = 0x8C2A
	MAX_TEXTURE_BUFFER_SIZE                            = 0x8C2B
	TEXTURE_BINDING_BUFFER                             = 0x8C2C
	TEXTURE_BUFFER_DATA_STORE_BINDING                  = 0x8C2D
	ANY_SAMPLES_PASSED                                 = 0x8C2F
	SAMPLE_SHADING                                     = 0x8C36
	MIN_SAMPLE_SHADING_VALUE                           = 0x8C37
	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
	SRGB                                               = 0x8C40
	SRGB8                                              = 0x8C41
	SRGB_ALPHA                                         = 0x8C42
	SRGB8_ALPHA8                                       = 0x8C43
	SLUMINANCE_ALPHA                                   = 0x8C44
	SLUMINANCE8_ALPHA8                                 = 0x8C45
	SLUMINANCE                                         = 0x8C46
	SLUMINANCE8                                        = 0x8C47
	COMPRESSED_SRGB                                    = 0x8C48
	COMPRESSED_SRGB_ALPHA                              = 0x8C49
	COMPRESSED_SLUMINANCE                              = 0x8C4A
	COMPRESSED_SLUMINANCE_ALPHA                        = 0x8C4B
	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
	POINT_SPRITE_COORD_ORIGIN                          = 0x8CA0
	LOWER_LEFT                                         = 0x8CA1
	UPPER_LEFT                                         = 0x8CA2
	STENCIL_BACK_REF                                   = 0x8CA3
	STENCIL_BACK_VALUE_MASK                            = 0x8CA4
	STENCIL_BACK_WRITEMASK                             = 0x8CA5
	DRAW_FRAMEBUFFER_BINDING                           = 0x8CA6
	FRAMEBUFFER_BINDING                                = 0x8CA6
	RENDERBUFFER_BINDING                               = 0x8CA7
	READ_FRAMEBUFFER                                   = 0x8CA8
	DRAW_FRAMEBUFFER                                   = 0x8CA9
	READ_FRAMEBUFFER_BINDING                           = 0x8CAA
	RENDERBUFFER_SAMPLES                               = 0x8CAB
	DEPTH_COMPONENT32F                                 = 0x8CAC
	DEPTH32F_STENCIL8                                  = 0x8CAD
	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
	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
	RGB565                                             = 0x8D62
	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
	ALPHA_INTEGER                                      = 0x8D97
	RGB_INTEGER                                        = 0x8D98
	RGBA_INTEGER                                       = 0x8D99
	BGR_INTEGER                                        = 0x8D9A
	BGRA_INTEGER                                       = 0x8D9B
	INT_2_10_10_10_REV                                 = 0x8D9F
	FRAMEBUFFER_ATTACHMENT_LAYERED                     = 0x8DA7
	FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS               = 0x8DA8
	FLOAT_32_UNSIGNED_INT_24_8_REV                     = 0x8DAD
	FRAMEBUFFER_SRGB                                   = 0x8DB9
	COMPRESSED_RED_RGTC1                               = 0x8DBB
	COMPRESSED_SIGNED_RED_RGTC1                        = 0x8DBC
	COMPRESSED_RG_RGTC2                                = 0x8DBD
	COMPRESSED_SIGNED_RG_RGTC2                         = 0x8DBE
	SAMPLER_1D_ARRAY                                   = 0x8DC0
	SAMPLER_2D_ARRAY                                   = 0x8DC1
	SAMPLER_BUFFER                                     = 0x8DC2
	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_2D_RECT                                = 0x8DCD
	INT_SAMPLER_1D_ARRAY                               = 0x8DCE
	INT_SAMPLER_2D_ARRAY                               = 0x8DCF
	INT_SAMPLER_BUFFER                                 = 0x8DD0
	UNSIGNED_INT_SAMPLER_1D                            = 0x8DD1
	UNSIGNED_INT_SAMPLER_2D                            = 0x8DD2
	UNSIGNED_INT_SAMPLER_3D                            = 0x8DD3
	UNSIGNED_INT_SAMPLER_CUBE                          = 0x8DD4
	UNSIGNED_INT_SAMPLER_2D_RECT                       = 0x8DD5
	UNSIGNED_INT_SAMPLER_1D_ARRAY                      = 0x8DD6
	UNSIGNED_INT_SAMPLER_2D_ARRAY                      = 0x8DD7
	UNSIGNED_INT_SAMPLER_BUFFER                        = 0x8DD8
	GEOMETRY_SHADER                                    = 0x8DD9
	MAX_GEOMETRY_UNIFORM_COMPONENTS                    = 0x8DDF
	MAX_GEOMETRY_OUTPUT_VERTICES                       = 0x8DE0
	MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS               = 0x8DE1
	ACTIVE_SUBROUTINES                                 = 0x8DE5
	ACTIVE_SUBROUTINE_UNIFORMS                         = 0x8DE6
	MAX_SUBROUTINES                                    = 0x8DE7
	MAX_SUBROUTINE_UNIFORM_LOCATIONS                   = 0x8DE8
	LOW_FLOAT                                          = 0x8DF0
	MEDIUM_FLOAT                                       = 0x8DF1
	HIGH_FLOAT                                         = 0x8DF2
	LOW_INT                                            = 0x8DF3
	MEDIUM_INT                                         = 0x8DF4
	HIGH_INT                                           = 0x8DF5
	SHADER_BINARY_FORMATS                              = 0x8DF8
	NUM_SHADER_BINARY_FORMATS                          = 0x8DF9
	SHADER_COMPILER                                    = 0x8DFA
	MAX_VERTEX_UNIFORM_VECTORS                         = 0x8DFB
	MAX_VARYING_VECTORS                                = 0x8DFC
	MAX_FRAGMENT_UNIFORM_VECTORS                       = 0x8DFD
	QUERY_WAIT                                         = 0x8E13
	QUERY_NO_WAIT                                      = 0x8E14
	QUERY_BY_REGION_WAIT                               = 0x8E15
	QUERY_BY_REGION_NO_WAIT                            = 0x8E16
	MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS       = 0x8E1E
	MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS    = 0x8E1F
	TRANSFORM_FEEDBACK                                 = 0x8E22
	TRANSFORM_FEEDBACK_BUFFER_PAUSED                   = 0x8E23
	TRANSFORM_FEEDBACK_BUFFER_ACTIVE                   = 0x8E24
	TRANSFORM_FEEDBACK_BINDING                         = 0x8E25
	TIMESTAMP                                          = 0x8E28
	TEXTURE_SWIZZLE_R                                  = 0x8E42
	TEXTURE_SWIZZLE_G                                  = 0x8E43
	TEXTURE_SWIZZLE_B                                  = 0x8E44
	TEXTURE_SWIZZLE_A                                  = 0x8E45
	TEXTURE_SWIZZLE_RGBA                               = 0x8E46
	ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS                = 0x8E47
	ACTIVE_SUBROUTINE_MAX_LENGTH                       = 0x8E48
	ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH               = 0x8E49
	NUM_COMPATIBLE_SUBROUTINES                         = 0x8E4A
	COMPATIBLE_SUBROUTINES                             = 0x8E4B
	QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION           = 0x8E4C
	FIRST_VERTEX_CONVENTION                            = 0x8E4D
	LAST_VERTEX_CONVENTION                             = 0x8E4E
	PROVOKING_VERTEX                                   = 0x8E4F
	SAMPLE_POSITION                                    = 0x8E50
	SAMPLE_MASK                                        = 0x8E51
	SAMPLE_MASK_VALUE                                  = 0x8E52
	MAX_SAMPLE_MASK_WORDS                              = 0x8E59
	MAX_GEOMETRY_SHADER_INVOCATIONS                    = 0x8E5A
	MIN_FRAGMENT_INTERPOLATION_OFFSET                  = 0x8E5B
	MAX_FRAGMENT_INTERPOLATION_OFFSET                  = 0x8E5C
	FRAGMENT_INTERPOLATION_OFFSET_BITS                 = 0x8E5D
	MIN_PROGRAM_TEXTURE_GATHER_OFFSET                  = 0x8E5E
	MAX_PROGRAM_TEXTURE_GATHER_OFFSET                  = 0x8E5F
	MAX_TRANSFORM_FEEDBACK_BUFFERS                     = 0x8E70
	MAX_VERTEX_STREAMS                                 = 0x8E71
	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
	TESS_EVALUATION_SHADER                             = 0x8E87
	TESS_CONTROL_SHADER                                = 0x8E88
	MAX_TESS_CONTROL_UNIFORM_BLOCKS                    = 0x8E89
	MAX_TESS_EVALUATION_UNIFORM_BLOCKS                 = 0x8E8A
	COPY_READ_BUFFER                                   = 0x8F36
	COPY_WRITE_BUFFER                                  = 0x8F37
	DRAW_INDIRECT_BUFFER                               = 0x8F3F
	DRAW_INDIRECT_BUFFER_BINDING                       = 0x8F43
	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
	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
	DOUBLE_VEC2                                        = 0x8FFC
	DOUBLE_VEC3                                        = 0x8FFD
	DOUBLE_VEC4                                        = 0x8FFE
	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
	RGB10_A2UI                                         = 0x906F
	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
	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
	BUFFER_ACCESS_FLAGS                                = 0x911F
	BUFFER_MAP_LENGTH                                  = 0x9120
	BUFFER_MAP_OFFSET                                  = 0x9121
	MAX_VERTEX_OUTPUT_COMPONENTS                       = 0x9122
	MAX_GEOMETRY_INPUT_COMPONENTS                      = 0x9123
	MAX_GEOMETRY_OUTPUT_COMPONENTS                     = 0x9124
	MAX_FRAGMENT_INPUT_COMPONENTS                      = 0x9125
	CONTEXT_PROFILE_MASK                               = 0x9126
)

Variables

This section is empty.

Functions

This section is empty.

Types

type GL

type GL struct {
	// contains filtered or unexported fields
}

    GL implements the OpenGL version 4.1 API. Values of this type must be created via the API function, and it must not be used after the associated OpenGL context becomes invalid.

    func API

    func API(context glbase.Contexter) *GL

      API returns a value that offers methods matching the OpenGL version 4.1 API.

      The returned API must not be used after the provided OpenGL context becomes invalid.

      func (*GL) AttachShader

      func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader)

        AttachShader attaches a shader object to a program object.

        In order to create an executable, there must be a way to specify the list of things that will be linked together. Program objects provide this mechanism. Shaders that are to be linked together in a program object must first be attached to that program object. This indicates that shader will be included in link operations that will be performed on program.

        All operations that can be performed on a shader object are valid whether or not the shader object is attached to a program object. It is permissible to attach a shader object to a program object before source code has been loaded into the shader object or before the shader object has been compiled. It is permissible to attach multiple shader objects of the same type because each may contain a portion of the complete shader. It is also permissible to attach a shader object to more than one program object. If a shader object is deleted while it is attached to a program object, it will be flagged for deletion, and deletion will not occur until DetachShader is called to detach it from all program objects to which it is attached.

        Error GL.INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if shader is not a shader object. GL.INVALID_OPERATION is generated if shader is already attached to program. GL.INVALID_OPERATION is generated if AttachShader is executed between the execution of Begin and the corresponding execution of End.

        AttachShader is available in GL version 2.0 or greater.

        func (*GL) BindAttribLocation

        func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string)

          BindAttribLocation associates a user-defined attribute variable in the program object specified by program with a generic vertex attribute index. The name parameter specifies the name of the vertex shader attribute variable to which index is to be bound. When program is made part of the current state, values provided via the generic vertex attribute index will modify the value of the user-defined attribute variable specified by name.

          If name refers to a matrix attribute variable, index refers to the first column of the matrix. Other matrix columns are then automatically bound to locations index+1 for a matrix of type mat2; index+1 and index+2 for a matrix of type mat3; and index+1, index+2, and index+3 for a matrix of type mat4.

          This command makes it possible for vertex shaders to use descriptive names for attribute variables rather than generic variables that are numbered from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic attribute index are part of current state, just like standard vertex attributes such as color, normal, and vertex position. If a different program object is made current by calling UseProgram, the generic vertex attributes are tracked in such a way that the same values will be observed by attributes in the new program object that are also bound to index.

          Attribute variable name-to-generic attribute index bindings for a program object can be explicitly assigned at any time by calling BindAttribLocation. Attribute bindings do not go into effect until LinkProgram is called. After a program object has been linked successfully, the index values for generic attributes remain fixed (and their values can be queried) until the next link command occurs.

          Applications are not allowed to bind any of the standard OpenGL vertex attributes using this command, as they are bound automatically when needed. Any attribute binding that occurs after the program object has been linked will not take effect until the next time the program object is linked.

          If name was bound previously, that information is lost. Thus you cannot bind one user-defined attribute variable to multiple indices, but you can bind multiple user-defined attribute variables to the same index.

          Applications are allowed to bind more than one user-defined attribute variable to the same generic vertex attribute index. This is called aliasing, and it is allowed only if just one of the aliased attributes is active in the executable program, or if no path through the shader consumes more than one attribute of a set of attributes aliased to the same location. The compiler and linker are allowed to assume that no aliasing is done and are free to employ optimizations that work only in the absence of aliasing. OpenGL implementations are not required to do error checking to detect aliasing. Because there is no way to bind standard attributes, it is not possible to alias generic attributes with conventional ones (except for generic attribute 0).

          BindAttribLocation can be called before any vertex shader objects are bound to the specified program object. It is also permissible to bind a generic attribute index to an attribute variable name that is never used in a vertex shader.

          Active attributes that are not explicitly bound will be bound by the linker when LinkProgram is called. The locations assigned can be queried by calling GetAttribLocation.

          Error GL.INVALID_VALUE is generated if index is greater than or equal to GL.MAX_VERTEX_ATTRIBS. GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if BindAttribLocation is executed between the execution of Begin and the corresponding execution of End.

          BindAttribLocation is available in GL version 2.0 or greater.

          func (*GL) BindBuffer

          func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer)

            BindBuffer creates or puts in use a named buffer object. Calling BindBuffer with target set to GL.ARRAY_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER and buffer set to the name of the new buffer object binds the buffer object name to the target. When a buffer object is bound to a target, the previous binding for that target is automatically broken.

            Buffer object names are unsigned integers. The value zero is reserved, but there is no default buffer object for each buffer object target. Instead, buffer set to zero effectively unbinds any buffer object previously bound, and restores client memory usage for that buffer object target. Buffer object names and the corresponding buffer object contents are local to the shared display-list space (see XCreateContext) of the current GL rendering context; two rendering contexts share buffer object names only if they also share display lists.

            GenBuffers may be called to generate a set of new buffer object names.

            The state of a buffer object immediately after it is first bound is an unmapped zero-sized memory buffer with GL.READ_WRITE access and GL.STATIC_DRAW usage.

            While a non-zero buffer object name is bound, GL operations on the target to which it is bound affect the bound buffer object, and queries of the target to which it is bound return state from the bound buffer object. While buffer object name zero is bound, as in the initial state, attempts to modify or query state on the target to which it is bound generates an GL.INVALID_OPERATION error.

            When vertex array pointer state is changed, for example by a call to NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) is copied into the corresponding client state for the vertex array type being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex array pointer parameter that is traditionally interpreted as a pointer to client-side memory is instead interpreted as an offset within the buffer object measured in basic machine units.

            While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER target, the indices parameter of DrawElements, DrawRangeElements, or MultiDrawElements that is traditionally interpreted as a pointer to client-side memory is instead interpreted as an offset within the buffer object measured in basic machine units.

            While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER target, the following commands are affected: GetCompressedTexImage, GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The pointer parameter that is traditionally interpreted as a pointer to client-side memory where the pixels are to be packed is instead interpreted as an offset within the buffer object measured in basic machine units.

            While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER target, the following commands are affected: Bitmap, ColorSubTable, ColorTable, CompressedTexImage1D, CompressedTexImage2D, CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. The pointer parameter that is traditionally interpreted as a pointer to client-side memory from which the pixels are to be unpacked is instead interpreted as an offset within the buffer object measured in basic machine units.

            A buffer object binding created with BindBuffer remains active until a different buffer object name is bound to the same target, or until the bound buffer object is deleted with DeleteBuffers.

            Once created, a named buffer object may be re-bound to any target as often as needed. However, the GL implementation may make choices about how to optimize the storage of a buffer object based on its initial binding target.

            Error GL.INVALID_ENUM is generated if target is not one of the allowable values. GL.INVALID_OPERATION is generated if BindBuffer is executed between the execution of Begin and the corresponding execution of End.

            BindBuffer is available in GL version 1.5 or greater.

            func (*GL) BindBufferRange

            func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int)

              https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml

              func (*GL) BindFragDataLocationIndexed

              func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte)

                https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml

                func (*GL) BindSampler

                func (gl *GL) BindSampler(unit, sampler uint32)

                  https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml

                  func (*GL) BlendColor

                  func (gl *GL) BlendColor(red, green, blue, alpha float32)

                    https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml

                    func (*GL) BlendEquationSeparate

                    func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum)

                      https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml

                      func (*GL) BlendEquationSeparatei

                      func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum)

                        https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml

                        func (*GL) BlendFunc

                        func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum)

                          https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml

                          func (*GL) BlendFuncSeparate

                          func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum)

                            https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml

                            func (*GL) BlendFuncSeparatei

                            func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum)

                              https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml

                              func (*GL) BlitFramebuffer

                              func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum)

                                https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml

                                func (*GL) BufferData

                                func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum)

                                  BufferData creates a new data store for the buffer object currently bound to target. Any pre-existing data store is deleted. The new data store is created with the specified size in bytes and usage. If data is not nil, it must be a slice that is used to initialize the data store. In that case the size parameter is ignored and the store size will match the slice data size.

                                  In its initial state, the new data store is not mapped, it has a NULL mapped pointer, and its mapped access is GL.READ_WRITE.

                                  The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, or GL.UNIFORM_BUFFER.

                                  The usage parameter is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make more intelligent decisions that may significantly impact buffer object performance. It does not, however, constrain the actual usage of the data store. usage can be broken down into two parts: first, the frequency of access (modification and usage), and second, the nature of that access.

                                  A usage frequency of STREAM and nature of DRAW is specified via the constant GL.STREAM_DRAW, for example.

                                  The usage frequency of access may be one of:

                                  STREAM
                                      The data store contents will be modified once and used at most a few times.
                                  
                                  STATIC
                                      The data store contents will be modified once and used many times.
                                  
                                  DYNAMIC
                                      The data store contents will be modified repeatedly and used many times.
                                  

                                  The usage nature of access may be one of:

                                  DRAW
                                      The data store contents are modified by the application, and used as
                                      the source for GL drawing and image specification commands.
                                  
                                  READ
                                      The data store contents are modified by reading data from the GL,
                                      and used to return that data when queried by the application.
                                  
                                  COPY
                                      The data store contents are modified by reading data from the GL,
                                      and used as the source for GL drawing and image specification
                                      commands.
                                  

                                  Clients must align data elements consistent with the requirements of the client platform, with an additional base-level requirement that an offset within a buffer to a datum comprising N bytes be a multiple of N.

                                  Error GL.INVALID_ENUM is generated if target is not one of the accepted buffer targets. GL.INVALID_ENUM is generated if usage is not GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to create a data store with the specified size.

                                  func (*GL) BufferSubData

                                  func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{})

                                    https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml

                                    func (*GL) ClearBufferfi

                                    func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32)

                                      https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml

                                      func (*GL) ClearBufferfv

                                      func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32)

                                        https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml

                                        func (*GL) ClearBufferiv

                                        func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32)

                                          https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml

                                          func (*GL) ClearBufferuiv

                                          func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32)

                                            https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml

                                            func (*GL) ClearColor

                                            func (gl *GL) ClearColor(red, green, blue, alpha float32)

                                              https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml

                                              func (*GL) ColorMask

                                              func (gl *GL) ColorMask(red, green, blue, alpha bool)

                                                https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml

                                                func (*GL) ColorMaski

                                                func (gl *GL) ColorMaski(index uint32, r, g, b, a bool)

                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml

                                                  func (*GL) CompileShader

                                                  func (gl *GL) CompileShader(shader glbase.Shader)

                                                    CompileShader compiles the source code strings that have been stored in the shader object specified by shader.

                                                    The compilation status will be stored as part of the shader object's state. This value will be set to GL.TRUE if the shader was compiled without errors and is ready for use, and GL.FALSE otherwise. It can be queried by calling GetShaderiv with arguments shader and GL.COMPILE_STATUS.

                                                    Compilation of a shader can fail for a number of reasons as specified by the OpenGL Shading Language Specification. Whether or not the compilation was successful, information about the compilation can be obtained from the shader object's information log by calling GetShaderInfoLog.

                                                    Error GL.INVALID_VALUE is generated if shader is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader object. GL.INVALID_OPERATION is generated if CompileShader is executed between the execution of Begin and the corresponding execution of End.

                                                    CompileShader is available in GL version 2.0 or greater.

                                                    func (*GL) CompressedTexImage1D

                                                    func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{})

                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml

                                                      func (*GL) CompressedTexImage2D

                                                      func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{})

                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml

                                                        func (*GL) CompressedTexImage3D

                                                        func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{})

                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml

                                                          func (*GL) CompressedTexSubImage1D

                                                          func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{})

                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml

                                                            func (*GL) CompressedTexSubImage2D

                                                            func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{})

                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml

                                                              func (*GL) CompressedTexSubImage3D

                                                              func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{})

                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml

                                                                func (*GL) CopyBufferSubData

                                                                func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int)

                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml

                                                                  func (*GL) CopyTexImage1D

                                                                  func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int)

                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml

                                                                    func (*GL) CopyTexImage2D

                                                                    func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int)

                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml

                                                                      func (*GL) CopyTexSubImage1D

                                                                      func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int)

                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml

                                                                        func (*GL) CopyTexSubImage2D

                                                                        func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int)

                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml

                                                                          func (*GL) CopyTexSubImage3D

                                                                          func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int)

                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml

                                                                            func (*GL) CreateProgram

                                                                            func (gl *GL) CreateProgram() glbase.Program

                                                                              CreateProgram creates an empty program object and returns a non-zero value by which it can be referenced. A program object is an object to which shader objects can be attached. This provides a mechanism to specify the shader objects that will be linked to create a program. It also provides a means for checking the compatibility of the shaders that will be used to create a program (for instance, checking the compatibility between a vertex shader and a fragment shader). When no longer needed as part of a program object, shader objects can be detached.

                                                                              One or more executables are created in a program object by successfully attaching shader objects to it with AttachShader, successfully compiling the shader objects with CompileShader, and successfully linking the program object with LinkProgram. These executables are made part of current state when UseProgram is called. Program objects can be deleted by calling DeleteProgram. The memory associated with the program object will be deleted when it is no longer part of current rendering state for any context.

                                                                              Like display lists and texture objects, the name space for program objects may be shared across a set of contexts, as long as the server sides of the contexts share the same address space. If the name space is shared across contexts, any attached objects and the data associated with those attached objects are shared as well.

                                                                              Applications are responsible for providing the synchronization across API calls when objects are accessed from different execution threads.

                                                                              This function returns 0 if an error occurs creating the program object.

                                                                              Error GL.INVALID_OPERATION is generated if CreateProgram is executed between the execution of Begin and the corresponding execution of End.

                                                                              CreateProgram is available in GL version 2.0 or greater.

                                                                              func (*GL) CreateShader

                                                                              func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader

                                                                                CreateShader creates an empty shader object and returns a non-zero value by which it can be referenced. A shader object is used to maintain the source code strings that define a shader. shaderType indicates the type of shader to be created.

                                                                                Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a shader that is intended to run on the programmable vertex processor and replace the fixed functionality vertex processing in OpenGL. A shader of type GL.FRAGMENT_SHADER is a shader that is intended to run on the programmable fragment processor and replace the fixed functionality fragment processing in OpenGL.

                                                                                When created, a shader object's GL.SHADER_TYPE parameter is set to either GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of shaderType.

                                                                                Like display lists and texture objects, the name space for shader objects may be shared across a set of contexts, as long as the server sides of the contexts share the same address space. If the name space is shared across contexts, any attached objects and the data associated with those attached objects are shared as well.

                                                                                This function returns 0 if an error occurs creating the shader object.

                                                                                Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. GL.INVALID_OPERATION is generated if CreateShader is executed between the execution of Begin and the corresponding execution of End.

                                                                                CreateShader is available in GL version 2.0 or greater.

                                                                                func (*GL) DeleteBuffers

                                                                                func (gl *GL) DeleteBuffers(buffers []glbase.Buffer)

                                                                                  DeleteBuffers deletes the buffer objects whose names are stored in the buffers slice.

                                                                                  After a buffer object is deleted, it has no contents, and its name is free for reuse (for example by GenBuffers). If a buffer object that is currently bound is deleted, the binding reverts to 0 (the absence of any buffer object, which reverts to client memory usage).

                                                                                  DeleteBuffers silently ignores 0's and names that do not correspond to existing buffer objects.

                                                                                  Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION is generated if DeleteBuffers is executed between the execution of Begin and the corresponding execution of End.

                                                                                  DeleteBuffers is available in GL version 1.5 or greater.

                                                                                  func (*GL) DeleteFramebuffers

                                                                                  func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer)

                                                                                    DeleteFramebuffers deletes the framebuffer objects whose names are stored in the framebuffers slice. The name zero is reserved by the GL and is silently ignored, should it occur in framebuffers, as are other unused names. Once a framebuffer object is deleted, its name is again unused and it has no attachments. If a framebuffer that is currently bound to one or more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, it is as though BindFramebuffer had been executed with the corresponding target and framebuffer zero.

                                                                                    Error GL.INVALID_VALUE is generated if n is negative.

                                                                                    DeleteFramebuffers is available in GL version 3.0 or greater.

                                                                                    func (*GL) DeleteProgram

                                                                                    func (gl *GL) DeleteProgram(program glbase.Program)

                                                                                      DeleteProgram frees the memory and invalidates the name associated with the program object specified by program. This command effectively undoes the effects of a call to CreateProgram.

                                                                                      If a program object is in use as part of current rendering state, it will be flagged for deletion, but it will not be deleted until it is no longer part of current state for any rendering context. If a program object to be deleted has shader objects attached to it, those shader objects will be automatically detached but not deleted unless they have already been flagged for deletion by a previous call to DeleteShader. A value of 0 for program will be silently ignored.

                                                                                      To determine whether a program object has been flagged for deletion, call GetProgram with arguments program and GL.DELETE_STATUS.

                                                                                      Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL.

                                                                                      DeleteProgram is available in GL version 2.0 or greater.

                                                                                      func (*GL) DeleteRenderbuffers

                                                                                      func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer)

                                                                                        DeleteRenderbuffers deletes the renderbuffer objects whose names are stored in the renderbuffers slice. The name zero is reserved by the GL and is silently ignored, should it occur in renderbuffers, as are other unused names. Once a renderbuffer object is deleted, its name is again unused and it has no contents. If a renderbuffer that is currently bound to the target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had been executed with a target of GL.RENDERBUFFER and a name of zero.

                                                                                        If a renderbuffer object is attached to one or more attachment points in the currently bound framebuffer, then it as if FramebufferRenderbuffer had been called, with a renderbuffer of zero for each attachment point to which this image was attached in the currently bound framebuffer. In other words, this renderbuffer object is first detached from all attachment ponits in the currently bound framebuffer. Note that the renderbuffer image is specifically not detached from any non-bound framebuffers.

                                                                                        Error GL.INVALID_VALUE is generated if n is negative.

                                                                                        DeleteRenderbuffers is available in GL version 3.0 or greater.

                                                                                        func (*GL) DeleteSamplers

                                                                                        func (gl *GL) DeleteSamplers(count int, samplers []uint32)

                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml

                                                                                          func (*GL) DeleteShader

                                                                                          func (gl *GL) DeleteShader(shader glbase.Shader)

                                                                                            DeleteShader frees the memory and invalidates the name associated with the shader object specified by shader. This command effectively undoes the effects of a call to CreateShader.

                                                                                            If a shader object to be deleted is attached to a program object, it will be flagged for deletion, but it will not be deleted until it is no longer attached to any program object, for any rendering context (it must be detached from wherever it was attached before it will be deleted). A value of 0 for shader will be silently ignored.

                                                                                            To determine whether an object has been flagged for deletion, call GetShader with arguments shader and GL.DELETE_STATUS.

                                                                                            Error GL.INVALID_VALUE is generated if shader is not a value generated by OpenGL.

                                                                                            DeleteShader is available in GL version 2.0 or greater.

                                                                                            func (*GL) DeleteTextures

                                                                                            func (gl *GL) DeleteTextures(textures []glbase.Texture)

                                                                                              DeleteTextures deletes the textures objects whose names are stored in the textures slice. After a texture is deleted, it has no contents or dimensionality, and its name is free for reuse (for example by GenTextures). If a texture that is currently bound is deleted, the binding reverts to 0 (the default texture).

                                                                                              DeleteTextures silently ignores 0's and names that do not correspond to existing textures.

                                                                                              Error GL.INVALID_VALUE is generated if n is negative.

                                                                                              DeleteTextures is available in GL version 2.0 or greater.

                                                                                              func (*GL) DepthRange

                                                                                              func (gl *GL) DepthRange(nearVal, farVal float64)

                                                                                                DepthRange specifies the mapping of depth values from normalized device coordinates to window coordinates.

                                                                                                Parameter nearVal specifies the mapping of the near clipping plane to window coordinates (defaults to 0), while farVal specifies the mapping of the far clipping plane to window coordinates (defaults to 1).

                                                                                                After clipping and division by w, depth coordinates range from -1 to 1, corresponding to the near and far clipping planes. DepthRange specifies a linear mapping of the normalized depth coordinates in this range to window depth coordinates. Regardless of the actual depth buffer implementation, window coordinate depth values are treated as though they range from 0 through 1 (like color components). Thus, the values accepted by DepthRange are both clamped to this range before they are accepted.

                                                                                                The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. With this mapping, the depth buffer range is fully utilized.

                                                                                                It is not necessary that nearVal be less than farVal. Reverse mappings such as nearVal 1, and farVal 0 are acceptable.

                                                                                                GL.INVALID_OPERATION is generated if DepthRange is executed between the execution of Begin and the corresponding execution of End.

                                                                                                func (*GL) DrawArrays

                                                                                                func (gl *GL) DrawArrays(mode glbase.Enum, first, count int)

                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml

                                                                                                  func (*GL) DrawArraysIndirect

                                                                                                  func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{})

                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml

                                                                                                    func (*GL) DrawArraysInstanced

                                                                                                    func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32)

                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml

                                                                                                      func (*GL) DrawElements

                                                                                                      func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{})

                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml

                                                                                                        func (*GL) DrawElementsBaseVertex

                                                                                                        func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32)

                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml

                                                                                                          func (*GL) DrawElementsIndirect

                                                                                                          func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{})

                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml

                                                                                                            func (*GL) DrawElementsInstanced

                                                                                                            func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32)

                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml

                                                                                                              func (*GL) DrawElementsInstancedBaseVertex

                                                                                                              func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32)

                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml

                                                                                                                func (*GL) DrawRangeElements

                                                                                                                func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{})

                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml

                                                                                                                  func (*GL) DrawRangeElementsBaseVertex

                                                                                                                  func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32)

                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml

                                                                                                                    func (*GL) FlushMappedBufferRange

                                                                                                                    func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int)

                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml

                                                                                                                      func (*GL) FramebufferRenderbuffer

                                                                                                                      func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer)

                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml

                                                                                                                        func (*GL) FramebufferTexture

                                                                                                                        func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int)

                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml

                                                                                                                          func (*GL) FramebufferTexture1D

                                                                                                                          func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int)

                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml

                                                                                                                            func (*GL) FramebufferTexture2D

                                                                                                                            func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int)

                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml

                                                                                                                              func (*GL) FramebufferTexture3D

                                                                                                                              func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32)

                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml

                                                                                                                                func (*GL) FramebufferTextureLayer

                                                                                                                                func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32)

                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml

                                                                                                                                  func (*GL) GenBuffers

                                                                                                                                  func (gl *GL) GenBuffers(n int) []glbase.Buffer

                                                                                                                                    GenBuffers returns n buffer object names. There is no guarantee that the names form a contiguous set of integers; however, it is guaranteed that none of the returned names was in use immediately before the call to GenBuffers.

                                                                                                                                    Buffer object names returned by a call to GenBuffers are not returned by subsequent calls, unless they are first deleted with DeleteBuffers.

                                                                                                                                    No buffer objects are associated with the returned buffer object names until they are first bound by calling BindBuffer.

                                                                                                                                    Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION is generated if GenBuffers is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                    GenBuffers is available in GL version 1.5 or greater.

                                                                                                                                    func (*GL) GenFramebuffers

                                                                                                                                    func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer

                                                                                                                                      GenFramebuffers returns n framebuffer object names in ids. There is no guarantee that the names form a contiguous set of integers; however, it is guaranteed that none of the returned names was in use immediately before the call to GenFramebuffers.

                                                                                                                                      Framebuffer object names returned by a call to GenFramebuffers are not returned by subsequent calls, unless they are first deleted with DeleteFramebuffers.

                                                                                                                                      The names returned in ids are marked as used, for the purposes of GenFramebuffers only, but they acquire state and type only when they are first bound.

                                                                                                                                      Error GL.INVALID_VALUE is generated if n is negative.

                                                                                                                                      func (*GL) GenRenderbuffers

                                                                                                                                      func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer

                                                                                                                                        GenRenderbuffers returns n renderbuffer object names in renderbuffers. There is no guarantee that the names form a contiguous set of integers; however, it is guaranteed that none of the returned names was in use immediately before the call to GenRenderbuffers.

                                                                                                                                        Renderbuffer object names returned by a call to GenRenderbuffers are not returned by subsequent calls, unless they are first deleted with DeleteRenderbuffers.

                                                                                                                                        The names returned in renderbuffers are marked as used, for the purposes of GenRenderbuffers only, but they acquire state and type only when they are first bound.

                                                                                                                                        Error GL.INVALID_VALUE is generated if n is negative.

                                                                                                                                        GenRenderbuffers is available in GL version 3.0 or greater.

                                                                                                                                        func (*GL) GenSamplers

                                                                                                                                        func (gl *GL) GenSamplers(count int, samplers []uint32)

                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml

                                                                                                                                          func (*GL) GenTextures

                                                                                                                                          func (gl *GL) GenTextures(n int) []glbase.Texture

                                                                                                                                            GenTextures returns n texture names in textures. There is no guarantee that the names form a contiguous set of integers; however, it is guaranteed that none of the returned names was in use immediately before the call to GenTextures.

                                                                                                                                            The generated textures have no dimensionality; they assume the dimensionality of the texture target to which they are first bound (see BindTexture).

                                                                                                                                            Texture names returned by a call to GenTextures are not returned by subsequent calls, unless they are first deleted with DeleteTextures.

                                                                                                                                            Error GL.INVALID_VALUE is generated if n is negative.

                                                                                                                                            GenTextures is available in GL version 2.0 or greater.

                                                                                                                                            func (*GL) GetActiveAttrib

                                                                                                                                            func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte)

                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml

                                                                                                                                              func (*GL) GetActiveSubroutineName

                                                                                                                                              func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte)

                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml

                                                                                                                                                func (*GL) GetActiveSubroutineUniformName

                                                                                                                                                func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte)

                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml

                                                                                                                                                  func (*GL) GetActiveSubroutineUniformiv

                                                                                                                                                  func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32)

                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml

                                                                                                                                                    func (*GL) GetActiveUniform

                                                                                                                                                    func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte)

                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml

                                                                                                                                                      func (*GL) GetActiveUniformBlockName

                                                                                                                                                      func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte)

                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml

                                                                                                                                                        func (*GL) GetActiveUniformBlockiv

                                                                                                                                                        func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32)

                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml

                                                                                                                                                          func (*GL) GetActiveUniformName

                                                                                                                                                          func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte)

                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml

                                                                                                                                                            func (*GL) GetActiveUniformsiv

                                                                                                                                                            func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32)

                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml

                                                                                                                                                              func (*GL) GetAttachedShaders

                                                                                                                                                              func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32)

                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml

                                                                                                                                                                func (*GL) GetAttribLocation

                                                                                                                                                                func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib

                                                                                                                                                                  GetAttribLocation queries the previously linked program object specified by program for the attribute variable specified by name and returns the index of the generic vertex attribute that is bound to that attribute variable. If name is a matrix attribute variable, the index of the first column of the matrix is returned. If the named attribute variable is not an active attribute in the specified program object or if name starts with the reserved prefix "gl_", a value of -1 is returned.

                                                                                                                                                                  The association between an attribute variable name and a generic attribute index can be specified at any time by calling BindAttribLocation. Attribute bindings do not go into effect until LinkProgram is called. After a program object has been linked successfully, the index values for attribute variables remain fixed until the next link command occurs. The attribute values can only be queried after a link if the link was successful. GetAttribLocation returns the binding that actually went into effect the last time LinkProgram was called for the specified program object. Attribute bindings that have been specified since the last link operation are not returned by GetAttribLocation.

                                                                                                                                                                  Error GL_INVALID_OPERATION is generated if program is not a value generated by OpenGL. GL_INVALID_OPERATION is generated if program is not a program object. GL_INVALID_OPERATION is generated if program has not been successfully linked. GL_INVALID_OPERATION is generated if GetAttribLocation is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                  GetAttribLocation is available in GL version 2.0 or greater.

                                                                                                                                                                  func (*GL) GetBooleani_v

                                                                                                                                                                  func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool)

                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml

                                                                                                                                                                    func (*GL) GetBufferParameteri64v

                                                                                                                                                                    func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64)

                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml

                                                                                                                                                                      func (*GL) GetBufferParameteriv

                                                                                                                                                                      func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml

                                                                                                                                                                        func (*GL) GetBufferSubData

                                                                                                                                                                        func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{})

                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml

                                                                                                                                                                          func (*GL) GetCompressedTexImage

                                                                                                                                                                          func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{})

                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml

                                                                                                                                                                            func (*GL) GetFramebufferAttachmentParameteriv

                                                                                                                                                                            func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32)

                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml

                                                                                                                                                                              func (*GL) GetIntegeri_v

                                                                                                                                                                              func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32)

                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml

                                                                                                                                                                                func (*GL) GetProgramBinary

                                                                                                                                                                                func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{})

                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml

                                                                                                                                                                                  func (*GL) GetProgramInfoLog

                                                                                                                                                                                  func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte

                                                                                                                                                                                    GetProgramInfoLog returns the information log for the specified program object. The information log for a program object is modified when the program object is linked or validated.

                                                                                                                                                                                    The information log for a program object is either an empty string, or a string containing information about the last link operation, or a string containing information about the last validation operation. It may contain diagnostic messages, warning messages, and other information. When a program object is created, its information log will be a string of length 0, and the size of the current log can be obtained by calling GetProgramiv with the value GL.INFO_LOG_LENGTH.

                                                                                                                                                                                    Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object.

                                                                                                                                                                                    func (*GL) GetProgramPipelineInfoLog

                                                                                                                                                                                    func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte)

                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml

                                                                                                                                                                                      func (*GL) GetProgramPipelineiv

                                                                                                                                                                                      func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32)

                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml

                                                                                                                                                                                        func (*GL) GetProgramStageiv

                                                                                                                                                                                        func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32)

                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml

                                                                                                                                                                                          func (*GL) GetProgramiv

                                                                                                                                                                                          func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32)

                                                                                                                                                                                            GetProgramiv returns in params the value of a parameter for a specific program object. The following parameters are defined:

                                                                                                                                                                                            GL.DELETE_STATUS
                                                                                                                                                                                                params returns GL.TRUE if program is currently flagged for deletion,
                                                                                                                                                                                                and GL.FALSE otherwise.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.LINK_STATUS
                                                                                                                                                                                                params returns GL.TRUE if the last link operation on program was
                                                                                                                                                                                                successful, and GL.FALSE otherwise.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.VALIDATE_STATUS
                                                                                                                                                                                                params returns GL.TRUE or if the last validation operation on
                                                                                                                                                                                                program was successful, and GL.FALSE otherwise.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.INFO_LOG_LENGTH
                                                                                                                                                                                                params returns the number of characters in the information log for
                                                                                                                                                                                                program including the null termination character (the size of
                                                                                                                                                                                                the character buffer required to store the information log). If
                                                                                                                                                                                                program has no information log, a value of 0 is returned.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.ATTACHED_SHADERS
                                                                                                                                                                                                params returns the number of shader objects attached to program.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.ACTIVE_ATTRIBUTES
                                                                                                                                                                                                params returns the number of active attribute variables for program.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.ACTIVE_ATTRIBUTE_MAX_LENGTH
                                                                                                                                                                                                params returns the length of the longest active attribute name for
                                                                                                                                                                                                program, including the null termination character (the size of
                                                                                                                                                                                                the character buffer required to store the longest attribute name).
                                                                                                                                                                                                If no active attributes exist, 0 is returned.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.ACTIVE_UNIFORMS
                                                                                                                                                                                                params returns the number of active uniform variables for program.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.ACTIVE_UNIFORM_MAX_LENGTH
                                                                                                                                                                                                params returns the length of the longest active uniform variable
                                                                                                                                                                                                name for program, including the null termination character (i.e.,
                                                                                                                                                                                                the size of the character buffer required to store the longest
                                                                                                                                                                                                uniform variable name). If no active uniform variables exist, 0 is
                                                                                                                                                                                                returned.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.TRANSFORM_FEEDBACK_BUFFER_MODE
                                                                                                                                                                                                params returns a symbolic constant indicating the buffer mode used
                                                                                                                                                                                                when transform feedback is active. This may be GL.SEPARATE_ATTRIBS
                                                                                                                                                                                                or GL.INTERLEAVED_ATTRIBS.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.TRANSFORM_FEEDBACK_VARYINGS
                                                                                                                                                                                                params returns the number of varying variables to capture in transform
                                                                                                                                                                                                feedback mode for the program.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
                                                                                                                                                                                                params returns the length of the longest variable name to be used for
                                                                                                                                                                                                transform feedback, including the null-terminator.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.GEOMETRY_VERTICES_OUT
                                                                                                                                                                                                params returns the maximum number of vertices that the geometry shader in
                                                                                                                                                                                                program will output.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.GEOMETRY_INPUT_TYPE
                                                                                                                                                                                                params returns a symbolic constant indicating the primitive type accepted
                                                                                                                                                                                                as input to the geometry shader contained in program.
                                                                                                                                                                                            
                                                                                                                                                                                            GL.GEOMETRY_OUTPUT_TYPE
                                                                                                                                                                                                params returns a symbolic constant indicating the primitive type that will
                                                                                                                                                                                                be output by the geometry shader contained in program.
                                                                                                                                                                                            

                                                                                                                                                                                            GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are available only if the GL version 3.1 or greater.

                                                                                                                                                                                            GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or greater.

                                                                                                                                                                                            Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a program object. GL.INVALID_OPERATION is generated if pname is GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. GL.INVALID_ENUM is generated if pname is not an accepted value.

                                                                                                                                                                                            func (*GL) GetQueryIndexediv

                                                                                                                                                                                            func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32)

                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml

                                                                                                                                                                                              func (*GL) GetQueryiv

                                                                                                                                                                                              func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml

                                                                                                                                                                                                func (*GL) GetRenderbufferParameteriv

                                                                                                                                                                                                func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml

                                                                                                                                                                                                  func (*GL) GetSamplerParameterIiv

                                                                                                                                                                                                  func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32)

                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml

                                                                                                                                                                                                    func (*GL) GetSamplerParameteriv

                                                                                                                                                                                                    func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32)

                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml

                                                                                                                                                                                                      func (*GL) GetShaderInfoLog

                                                                                                                                                                                                      func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte

                                                                                                                                                                                                        GetShaderInfoLog returns the information log for the specified shader object. The information log for a shader object is modified when the shader is compiled.

                                                                                                                                                                                                        The information log for a shader object is a string that may contain diagnostic messages, warning messages, and other information about the last compile operation. When a shader object is created, its information log will be a string of length 0, and the size of the current log can be obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH.

                                                                                                                                                                                                        The information log for a shader object is the OpenGL implementer's primary mechanism for conveying information about the compilation process. Therefore, the information log can be helpful to application developers during the development process, even when compilation is successful. Application developers should not expect different OpenGL implementations to produce identical information logs.

                                                                                                                                                                                                        Error GL.INVALID_VALUE is generated if shader is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader object. GL.INVALID_VALUE is generated if maxLength is less than 0. GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                        GetShaderInfoLog is available in GL version 2.0 or greater.

                                                                                                                                                                                                        func (*GL) GetShaderPrecisionFormat

                                                                                                                                                                                                        func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32)

                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml

                                                                                                                                                                                                          func (*GL) GetShaderSource

                                                                                                                                                                                                          func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte)

                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml

                                                                                                                                                                                                            func (*GL) GetShaderiv

                                                                                                                                                                                                            func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32)

                                                                                                                                                                                                              GetShaderiv GetShader returns in params the value of a parameter for a specific shader object. The following parameters are defined:

                                                                                                                                                                                                              GL.SHADER_TYPE
                                                                                                                                                                                                                params returns GL.VERTEX_SHADER if shader is a vertex shader object,
                                                                                                                                                                                                                and GL.FRAGMENT_SHADER if shader is a fragment shader object.
                                                                                                                                                                                                              
                                                                                                                                                                                                              GL.DELETE_STATUS
                                                                                                                                                                                                                params returns GL.TRUE if shader is currently flagged for deletion,
                                                                                                                                                                                                                and GL.FALSE otherwise.
                                                                                                                                                                                                              
                                                                                                                                                                                                              GL.COMPILE_STATUS
                                                                                                                                                                                                                params returns GL.TRUE if the last compile operation on shader was
                                                                                                                                                                                                                successful, and GL.FALSE otherwise.
                                                                                                                                                                                                              
                                                                                                                                                                                                              GL.INFO_LOG_LENGTH
                                                                                                                                                                                                                params returns the number of characters in the information log for
                                                                                                                                                                                                                shader including the null termination character (the size of the
                                                                                                                                                                                                                character buffer required to store the information log). If shader has
                                                                                                                                                                                                                no information log, a value of 0 is returned.
                                                                                                                                                                                                              
                                                                                                                                                                                                              GL.SHADER_SOURCE_LENGTH
                                                                                                                                                                                                                params returns the length of the concatenation of the source strings
                                                                                                                                                                                                                that make up the shader source for the shader, including the null
                                                                                                                                                                                                                termination character. (the size of the character buffer
                                                                                                                                                                                                                required to store the shader source). If no source code exists, 0 is
                                                                                                                                                                                                                returned.
                                                                                                                                                                                                              

                                                                                                                                                                                                              Error GL.INVALID_VALUE is generated if shader is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a shader object. GL.INVALID_ENUM is generated if pname is not an accepted value. GL.INVALID_OPERATION is generated if GetShader is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                              GetShaderiv is available in GL version 2.0 or greater.

                                                                                                                                                                                                              func (*GL) GetSynciv

                                                                                                                                                                                                              func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32)

                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml

                                                                                                                                                                                                                func (*GL) GetTexImage

                                                                                                                                                                                                                func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml

                                                                                                                                                                                                                  func (*GL) GetTexLevelParameterfv

                                                                                                                                                                                                                  func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml

                                                                                                                                                                                                                    func (*GL) GetTexLevelParameteriv

                                                                                                                                                                                                                    func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml

                                                                                                                                                                                                                      func (*GL) GetTexParameterIiv

                                                                                                                                                                                                                      func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml

                                                                                                                                                                                                                        func (*GL) GetTexParameterIuiv

                                                                                                                                                                                                                        func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32)

                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml

                                                                                                                                                                                                                          func (*GL) GetTexParameterfv

                                                                                                                                                                                                                          func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml

                                                                                                                                                                                                                            func (*GL) GetTexParameteriv

                                                                                                                                                                                                                            func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml

                                                                                                                                                                                                                              func (*GL) GetTransformFeedbackVarying

                                                                                                                                                                                                                              func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte)

                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml

                                                                                                                                                                                                                                func (*GL) GetUniformBlockIndex

                                                                                                                                                                                                                                func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32

                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml

                                                                                                                                                                                                                                  func (*GL) GetUniformLocation

                                                                                                                                                                                                                                  func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform

                                                                                                                                                                                                                                    GetUniformLocation returns an integer that represents the location of a specific uniform variable within a program object. name must be an active uniform variable name in program that is not a structure, an array of structures, or a subcomponent of a vector or a matrix. This function returns -1 if name does not correspond to an active uniform variable in program or if name starts with the reserved prefix "gl_".

                                                                                                                                                                                                                                    Uniform variables that are structures or arrays of structures may be queried by calling GetUniformLocation for each field within the structure. The array element operator "[]" and the structure field operator "." may be used in name in order to select elements within an array or fields within a structure. The result of using these operators is not allowed to be another structure, an array of structures, or a subcomponent of a vector or a matrix. Except if the last part of name indicates a uniform variable array, the location of the first element of an array can be retrieved by using the name of the array, or by using the name appended by "[0]".

                                                                                                                                                                                                                                    The actual locations assigned to uniform variables are not known until the program object is linked successfully. After linking has occurred, the command GetUniformLocation can be used to obtain the location of a uniform variable. This location value can then be passed to Uniform to set the value of the uniform variable or to GetUniform in order to query the current value of the uniform variable. After a program object has been linked successfully, the index values for uniform variables remain fixed until the next link command occurs. Uniform variable locations and values can only be queried after a link if the link was successful.

                                                                                                                                                                                                                                    Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if program has not been successfully linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                                                    GetUniformLocation is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                    func (*GL) GetUniformSubroutineuiv

                                                                                                                                                                                                                                    func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32)

                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml

                                                                                                                                                                                                                                      func (*GL) GetUniformfv

                                                                                                                                                                                                                                      func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32)

                                                                                                                                                                                                                                        GetUniformfv returns in params the value of the specified uniform variable. The type of the uniform variable specified by location determines the number of values returned. If the uniform variable is defined in the shader as a boolean, int, or float, a single value will be returned. If it is defined as a vec2, ivec2, or bvec2, two values will be returned. If it is defined as a vec3, ivec3, or bvec3, three values will be returned, and so on. To query values stored in uniform variables declared as arrays, call GetUniformfv for each element of the array. To query values stored in uniform variables declared as structures, call GetUniformfv for each field in the structure. The values for uniform variables declared as a matrix will be returned in column major order.

                                                                                                                                                                                                                                        The locations assigned to uniform variables are not known until the program object is linked. After linking has occurred, the command GetUniformLocation can be used to obtain the location of a uniform variable. This location value can then be passed to GetUniformfv in order to query the current value of the uniform variable. After a program object has been linked successfully, the index values for uniform variables remain fixed until the next link command occurs. The uniform variable values can only be queried after a link if the link was successful.

                                                                                                                                                                                                                                        Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if program has not been successfully linked. GL.INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object. GL.INVALID_OPERATION is generated if GetUniformfv is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                                                        GetUniformfv is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                        func (*GL) GetUniformiv

                                                                                                                                                                                                                                        func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32)

                                                                                                                                                                                                                                          GetUniformiv returns in params the value of the specified uniform variable. The type of the uniform variable specified by location determines the number of values returned. If the uniform variable is defined in the shader as a boolean, int, or float, a single value will be returned. If it is defined as a vec2, ivec2, or bvec2, two values will be returned. If it is defined as a vec3, ivec3, or bvec3, three values will be returned, and so on. To query values stored in uniform variables declared as arrays, call GetUniformiv for each element of the array. To query values stored in uniform variables declared as structures, call GetUniformiv for each field in the structure. The values for uniform variables declared as a matrix will be returned in column major order.

                                                                                                                                                                                                                                          The locations assigned to uniform variables are not known until the program object is linked. After linking has occurred, the command GetUniformLocation can be used to obtain the location of a uniform variable. This location value can then be passed to GetUniformiv in order to query the current value of the uniform variable. After a program object has been linked successfully, the index values for uniform variables remain fixed until the next link command occurs. The uniform variable values can only be queried after a link if the link was successful.

                                                                                                                                                                                                                                          Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if program has not been successfully linked. GL.INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object. GL.INVALID_OPERATION is generated if GetUniformiv is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                                                          GetUniformiv is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                          func (*GL) GetUniformuiv

                                                                                                                                                                                                                                          func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32)

                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml

                                                                                                                                                                                                                                            func (*GL) GetVertexAttribdv

                                                                                                                                                                                                                                            func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64)

                                                                                                                                                                                                                                              GetVertexAttribdv returns in params the value of a generic vertex attribute parameter. The generic vertex attribute to be queried is specified by index, and the parameter to be queried is specified by pname.

                                                                                                                                                                                                                                              The accepted parameter names are as follows:

                                                                                                                                                                                                                                              GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
                                                                                                                                                                                                                                                  params returns a single value, the name of the buffer object
                                                                                                                                                                                                                                                  currently bound to the binding point corresponding to generic vertex
                                                                                                                                                                                                                                                  attribute array index. If no buffer object is bound, 0 is returned.
                                                                                                                                                                                                                                                  The initial value is 0.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              GL.VERTEX_ATTRIB_ARRAY_ENABLED
                                                                                                                                                                                                                                                  params returns a single value that is non-zero (true) if the vertex
                                                                                                                                                                                                                                                  attribute array for index is enabled and 0 (false) if it is
                                                                                                                                                                                                                                                  disabled. The initial value is 0.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              GL.VERTEX_ATTRIB_ARRAY_SIZE
                                                                                                                                                                                                                                                  params returns a single value, the size of the vertex attribute
                                                                                                                                                                                                                                                  array for index. The size is the number of values for each element
                                                                                                                                                                                                                                                  of the vertex attribute array, and it will be 1, 2, 3, or 4. The
                                                                                                                                                                                                                                                  initial value is 4.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              GL.VERTEX_ATTRIB_ARRAY_STRIDE
                                                                                                                                                                                                                                                  params returns a single value, the array stride for (number of bytes
                                                                                                                                                                                                                                                  between successive elements in) the vertex attribute array for
                                                                                                                                                                                                                                                  index. A value of 0 indicates that the array elements are stored
                                                                                                                                                                                                                                                  sequentially in memory. The initial value is 0.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              GL.VERTEX_ATTRIB_ARRAY_TYPE
                                                                                                                                                                                                                                                  params returns a single value, a symbolic constant indicating the
                                                                                                                                                                                                                                                  array type for the vertex attribute array for index. Possible values
                                                                                                                                                                                                                                                  are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT,
                                                                                                                                                                                                                                                  GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is
                                                                                                                                                                                                                                                  GL.FLOAT.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              GL.VERTEX_ATTRIB_ARRAY_NORMALIZED
                                                                                                                                                                                                                                                  params returns a single value that is non-zero (true) if fixed-point
                                                                                                                                                                                                                                                  data types for the vertex attribute array indicated by index are
                                                                                                                                                                                                                                                  normalized when they are converted to floating point, and 0 (false)
                                                                                                                                                                                                                                                  otherwise. The initial value is 0.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              GL.CURRENT_VERTEX_ATTRIB
                                                                                                                                                                                                                                                  params returns four values that represent the current value for the
                                                                                                                                                                                                                                                  generic vertex attribute specified by index. Generic vertex
                                                                                                                                                                                                                                                  attribute 0 is unique in that it has no current state, so an error
                                                                                                                                                                                                                                                  will be generated if index is 0. The initial value for all other
                                                                                                                                                                                                                                                  generic vertex attributes is (0,0,0,1).
                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                              All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent client-side state.

                                                                                                                                                                                                                                              Error GL.INVALID_VALUE is generated if index is greater than or equal to GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname is GL.CURRENT_VERTEX_ATTRIB.

                                                                                                                                                                                                                                              GetVertexAttribdv is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                              func (*GL) GetVertexAttribfv

                                                                                                                                                                                                                                              func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                                                GetVertexAttribfv returns in params the value of a generic vertex attribute parameter. The generic vertex attribute to be queried is specified by index, and the parameter to be queried is specified by pname.

                                                                                                                                                                                                                                                The accepted parameter names are as follows:

                                                                                                                                                                                                                                                GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
                                                                                                                                                                                                                                                    params returns a single value, the name of the buffer object
                                                                                                                                                                                                                                                    currently bound to the binding point corresponding to generic vertex
                                                                                                                                                                                                                                                    attribute array index. If no buffer object is bound, 0 is returned.
                                                                                                                                                                                                                                                    The initial value is 0.
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                GL.VERTEX_ATTRIB_ARRAY_ENABLED
                                                                                                                                                                                                                                                    params returns a single value that is non-zero (true) if the vertex
                                                                                                                                                                                                                                                    attribute array for index is enabled and 0 (false) if it is
                                                                                                                                                                                                                                                    disabled. The initial value is 0.
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                GL.VERTEX_ATTRIB_ARRAY_SIZE
                                                                                                                                                                                                                                                    params returns a single value, the size of the vertex attribute
                                                                                                                                                                                                                                                    array for index. The size is the number of values for each element
                                                                                                                                                                                                                                                    of the vertex attribute array, and it will be 1, 2, 3, or 4. The
                                                                                                                                                                                                                                                    initial value is 4.
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                GL.VERTEX_ATTRIB_ARRAY_STRIDE
                                                                                                                                                                                                                                                    params returns a single value, the array stride for (number of bytes
                                                                                                                                                                                                                                                    between successive elements in) the vertex attribute array for
                                                                                                                                                                                                                                                    index. A value of 0 indicates that the array elements are stored
                                                                                                                                                                                                                                                    sequentially in memory. The initial value is 0.
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                GL.VERTEX_ATTRIB_ARRAY_TYPE
                                                                                                                                                                                                                                                    params returns a single value, a symbolic constant indicating the
                                                                                                                                                                                                                                                    array type for the vertex attribute array for index. Possible values
                                                                                                                                                                                                                                                    are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT,
                                                                                                                                                                                                                                                    GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is
                                                                                                                                                                                                                                                    GL.FLOAT.
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                GL.VERTEX_ATTRIB_ARRAY_NORMALIZED
                                                                                                                                                                                                                                                    params returns a single value that is non-zero (true) if fixed-point
                                                                                                                                                                                                                                                    data types for the vertex attribute array indicated by index are
                                                                                                                                                                                                                                                    normalized when they are converted to floating point, and 0 (false)
                                                                                                                                                                                                                                                    otherwise. The initial value is 0.
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                GL.CURRENT_VERTEX_ATTRIB
                                                                                                                                                                                                                                                    params returns four values that represent the current value for the
                                                                                                                                                                                                                                                    generic vertex attribute specified by index. Generic vertex
                                                                                                                                                                                                                                                    attribute 0 is unique in that it has no current state, so an error
                                                                                                                                                                                                                                                    will be generated if index is 0. The initial value for all other
                                                                                                                                                                                                                                                    generic vertex attributes is (0,0,0,1).
                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent client-side state.

                                                                                                                                                                                                                                                Error GL.INVALID_VALUE is generated if index is greater than or equal to GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname is GL.CURRENT_VERTEX_ATTRIB.

                                                                                                                                                                                                                                                GetVertexAttribfv is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                                func (*GL) GetVertexAttribiv

                                                                                                                                                                                                                                                func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                                                  GetVertexAttribiv returns in params the value of a generic vertex attribute parameter. The generic vertex attribute to be queried is specified by index, and the parameter to be queried is specified by pname.

                                                                                                                                                                                                                                                  The accepted parameter names are as follows:

                                                                                                                                                                                                                                                  GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
                                                                                                                                                                                                                                                      params returns a single value, the name of the buffer object
                                                                                                                                                                                                                                                      currently bound to the binding point corresponding to generic vertex
                                                                                                                                                                                                                                                      attribute array index. If no buffer object is bound, 0 is returned.
                                                                                                                                                                                                                                                      The initial value is 0.
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  GL.VERTEX_ATTRIB_ARRAY_ENABLED
                                                                                                                                                                                                                                                      params returns a single value that is non-zero (true) if the vertex
                                                                                                                                                                                                                                                      attribute array for index is enabled and 0 (false) if it is
                                                                                                                                                                                                                                                      disabled. The initial value is 0.
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  GL.VERTEX_ATTRIB_ARRAY_SIZE
                                                                                                                                                                                                                                                      params returns a single value, the size of the vertex attribute
                                                                                                                                                                                                                                                      array for index. The size is the number of values for each element
                                                                                                                                                                                                                                                      of the vertex attribute array, and it will be 1, 2, 3, or 4. The
                                                                                                                                                                                                                                                      initial value is 4.
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  GL.VERTEX_ATTRIB_ARRAY_STRIDE
                                                                                                                                                                                                                                                      params returns a single value, the array stride for (number of bytes
                                                                                                                                                                                                                                                      between successive elements in) the vertex attribute array for
                                                                                                                                                                                                                                                      index. A value of 0 indicates that the array elements are stored
                                                                                                                                                                                                                                                      sequentially in memory. The initial value is 0.
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  GL.VERTEX_ATTRIB_ARRAY_TYPE
                                                                                                                                                                                                                                                      params returns a single value, a symbolic constant indicating the
                                                                                                                                                                                                                                                      array type for the vertex attribute array for index. Possible values
                                                                                                                                                                                                                                                      are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT,
                                                                                                                                                                                                                                                      GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is
                                                                                                                                                                                                                                                      GL.FLOAT.
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  GL.VERTEX_ATTRIB_ARRAY_NORMALIZED
                                                                                                                                                                                                                                                      params returns a single value that is non-zero (true) if fixed-point
                                                                                                                                                                                                                                                      data types for the vertex attribute array indicated by index are
                                                                                                                                                                                                                                                      normalized when they are converted to floating point, and 0 (false)
                                                                                                                                                                                                                                                      otherwise. The initial value is 0.
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  GL.CURRENT_VERTEX_ATTRIB
                                                                                                                                                                                                                                                      params returns four values that represent the current value for the
                                                                                                                                                                                                                                                      generic vertex attribute specified by index. Generic vertex
                                                                                                                                                                                                                                                      attribute 0 is unique in that it has no current state, so an error
                                                                                                                                                                                                                                                      will be generated if index is 0. The initial value for all other
                                                                                                                                                                                                                                                      generic vertex attributes is (0,0,0,1).
                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                  All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent client-side state.

                                                                                                                                                                                                                                                  Error GL.INVALID_VALUE is generated if index is greater than or equal to GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname is GL.CURRENT_VERTEX_ATTRIB.

                                                                                                                                                                                                                                                  GetVertexAttribiv is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                                  func (*GL) LinkProgram

                                                                                                                                                                                                                                                  func (gl *GL) LinkProgram(program glbase.Program)

                                                                                                                                                                                                                                                    LinkProgram links the program object specified by program. If any shader objects of type GL.VERTEX_SHADER are attached to program, they will be used to create an executable that will run on the programmable vertex processor. If any shader objects of type GL.FRAGMENT_SHADER are attached to program, they will be used to create an executable that will run on the programmable fragment processor.

                                                                                                                                                                                                                                                    The status of the link operation will be stored as part of the program object's state. This value will be set to GL.TRUE if the program object was linked without errors and is ready for use, and GL.FALSE otherwise. It can be queried by calling GetProgramiv with arguments program and GL.LINK_STATUS.

                                                                                                                                                                                                                                                    As a result of a successful link operation, all active user-defined uniform variables belonging to program will be initialized to 0, and each of the program object's active uniform variables will be assigned a location that can be queried by calling GetUniformLocation. Also, any active user-defined attribute variables that have not been bound to a generic vertex attribute index will be bound to one at this time.

                                                                                                                                                                                                                                                    Linking of a program object can fail for a number of reasons as specified in the OpenGL Shading Language Specification. The following lists some of the conditions that will cause a link error.

                                                                                                                                                                                                                                                    - The number of active attribute variables supported by the
                                                                                                                                                                                                                                                      implementation has been exceeded.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - The storage limit for uniform variables has been exceeded.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - The number of active uniform variables supported by the implementation
                                                                                                                                                                                                                                                      has been exceeded.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - The main function is missing for the vertex shader or the fragment
                                                                                                                                                                                                                                                      shader.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - A varying variable actually used in the fragment shader is not
                                                                                                                                                                                                                                                      declared in the same way (or is not declared at all) in the vertex
                                                                                                                                                                                                                                                      shader.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - A reference to a function or variable name is unresolved.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - A shared global is declared with two different types or two different
                                                                                                                                                                                                                                                      initial values.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - One or more of the attached shader objects has not been successfully
                                                                                                                                                                                                                                                      compiled.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - Binding a generic attribute matrix caused some rows of the matrix to
                                                                                                                                                                                                                                                      fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS.
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    - Not enough contiguous vertex attribute slots could be found to bind
                                                                                                                                                                                                                                                      attribute matrices.
                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                    When a program object has been successfully linked, the program object can be made part of current state by calling UseProgram. Whether or not the link operation was successful, the program object's information log will be overwritten. The information log can be retrieved by calling GetProgramInfoLog.

                                                                                                                                                                                                                                                    LinkProgram will also install the generated executables as part of the current rendering state if the link operation was successful and the specified program object is already currently in use as a result of a previous call to UseProgram. If the program object currently in use is relinked unsuccessfully, its link status will be set to GL.FALSE , but the executables and associated state will remain part of the current state until a subsequent call to UseProgram removes it from use. After it is removed from use, it cannot be made part of current state until it has been successfully relinked.

                                                                                                                                                                                                                                                    If program contains shader objects of type GL.VERTEX_SHADER but does not contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will be linked against the implicit interface for fixed functionality fragment processing. Similarly, if program contains shader objects of type GL.FRAGMENT_SHADER but it does not contain shader objects of type GL.VERTEX_SHADER, the fragment shader will be linked against the implicit interface for fixed functionality vertex processing.

                                                                                                                                                                                                                                                    The program object's information log is updated and the program is generated at the time of the link operation. After the link operation, applications are free to modify attached shader objects, compile attached shader objects, detach shader objects, delete shader objects, and attach additional shader objects. None of these operations affects the information log or the program that is part of the program object.

                                                                                                                                                                                                                                                    If the link operation is unsuccessful, any information about a previous link operation on program is lost (a failed link does not restore the old state of program). Certain information can still be retrieved from program even after an unsuccessful link operation. See for instance GetActiveAttrib and GetActiveUniform.

                                                                                                                                                                                                                                                    Error GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if LinkProgram is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                                                                    LinkProgram is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                                    func (*GL) MultiDrawArrays

                                                                                                                                                                                                                                                    func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32)

                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml

                                                                                                                                                                                                                                                      func (*GL) MultiTexCoordP1ui

                                                                                                                                                                                                                                                      func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32)

                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml

                                                                                                                                                                                                                                                        func (*GL) MultiTexCoordP1uiv

                                                                                                                                                                                                                                                        func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32)

                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml

                                                                                                                                                                                                                                                          func (*GL) MultiTexCoordP2ui

                                                                                                                                                                                                                                                          func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32)

                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml

                                                                                                                                                                                                                                                            func (*GL) MultiTexCoordP2uiv

                                                                                                                                                                                                                                                            func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32)

                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml

                                                                                                                                                                                                                                                              func (*GL) MultiTexCoordP3ui

                                                                                                                                                                                                                                                              func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32)

                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml

                                                                                                                                                                                                                                                                func (*GL) MultiTexCoordP3uiv

                                                                                                                                                                                                                                                                func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32)

                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml

                                                                                                                                                                                                                                                                  func (*GL) MultiTexCoordP4ui

                                                                                                                                                                                                                                                                  func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32)

                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml

                                                                                                                                                                                                                                                                    func (*GL) MultiTexCoordP4uiv

                                                                                                                                                                                                                                                                    func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32)

                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml

                                                                                                                                                                                                                                                                      func (*GL) ProgramBinary

                                                                                                                                                                                                                                                                      func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32)

                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml

                                                                                                                                                                                                                                                                        func (*GL) ProgramUniform1dv

                                                                                                                                                                                                                                                                        func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml

                                                                                                                                                                                                                                                                          func (*GL) ProgramUniform1fv

                                                                                                                                                                                                                                                                          func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32)

                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml

                                                                                                                                                                                                                                                                            func (*GL) ProgramUniform1iv

                                                                                                                                                                                                                                                                            func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32)

                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml

                                                                                                                                                                                                                                                                              func (*GL) ProgramUniform1uiv

                                                                                                                                                                                                                                                                              func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32)

                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml

                                                                                                                                                                                                                                                                                func (*GL) ProgramUniform2dv

                                                                                                                                                                                                                                                                                func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml

                                                                                                                                                                                                                                                                                  func (*GL) ProgramUniform2fv

                                                                                                                                                                                                                                                                                  func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32)

                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml

                                                                                                                                                                                                                                                                                    func (*GL) ProgramUniform2iv

                                                                                                                                                                                                                                                                                    func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32)

                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml

                                                                                                                                                                                                                                                                                      func (*GL) ProgramUniform2uiv

                                                                                                                                                                                                                                                                                      func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32)

                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml

                                                                                                                                                                                                                                                                                        func (*GL) ProgramUniform3d

                                                                                                                                                                                                                                                                                        func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64)

                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml

                                                                                                                                                                                                                                                                                          func (*GL) ProgramUniform3dv

                                                                                                                                                                                                                                                                                          func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml

                                                                                                                                                                                                                                                                                            func (*GL) ProgramUniform3f

                                                                                                                                                                                                                                                                                            func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32)

                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml

                                                                                                                                                                                                                                                                                              func (*GL) ProgramUniform3fv

                                                                                                                                                                                                                                                                                              func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32)

                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml

                                                                                                                                                                                                                                                                                                func (*GL) ProgramUniform3i

                                                                                                                                                                                                                                                                                                func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32)

                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml

                                                                                                                                                                                                                                                                                                  func (*GL) ProgramUniform3iv

                                                                                                                                                                                                                                                                                                  func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32)

                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml

                                                                                                                                                                                                                                                                                                    func (*GL) ProgramUniform3ui

                                                                                                                                                                                                                                                                                                    func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32)

                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml

                                                                                                                                                                                                                                                                                                      func (*GL) ProgramUniform3uiv

                                                                                                                                                                                                                                                                                                      func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32)

                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml

                                                                                                                                                                                                                                                                                                        func (*GL) ProgramUniform4d

                                                                                                                                                                                                                                                                                                        func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64)

                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml

                                                                                                                                                                                                                                                                                                          func (*GL) ProgramUniform4dv

                                                                                                                                                                                                                                                                                                          func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml

                                                                                                                                                                                                                                                                                                            func (*GL) ProgramUniform4f

                                                                                                                                                                                                                                                                                                            func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32)

                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml

                                                                                                                                                                                                                                                                                                              func (*GL) ProgramUniform4fv

                                                                                                                                                                                                                                                                                                              func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32)

                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml

                                                                                                                                                                                                                                                                                                                func (*GL) ProgramUniform4i

                                                                                                                                                                                                                                                                                                                func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32)

                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml

                                                                                                                                                                                                                                                                                                                  func (*GL) ProgramUniform4iv

                                                                                                                                                                                                                                                                                                                  func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32)

                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml

                                                                                                                                                                                                                                                                                                                    func (*GL) ProgramUniform4ui

                                                                                                                                                                                                                                                                                                                    func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32)

                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml

                                                                                                                                                                                                                                                                                                                      func (*GL) ProgramUniform4uiv

                                                                                                                                                                                                                                                                                                                      func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32)

                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml

                                                                                                                                                                                                                                                                                                                        func (*GL) ProgramUniformMatrix2dv

                                                                                                                                                                                                                                                                                                                        func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml

                                                                                                                                                                                                                                                                                                                          func (*GL) ProgramUniformMatrix2fv

                                                                                                                                                                                                                                                                                                                          func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml

                                                                                                                                                                                                                                                                                                                            func (*GL) ProgramUniformMatrix2x3dv

                                                                                                                                                                                                                                                                                                                            func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml

                                                                                                                                                                                                                                                                                                                              func (*GL) ProgramUniformMatrix2x3fv

                                                                                                                                                                                                                                                                                                                              func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml

                                                                                                                                                                                                                                                                                                                                func (*GL) ProgramUniformMatrix2x4dv

                                                                                                                                                                                                                                                                                                                                func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml

                                                                                                                                                                                                                                                                                                                                  func (*GL) ProgramUniformMatrix2x4fv

                                                                                                                                                                                                                                                                                                                                  func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml

                                                                                                                                                                                                                                                                                                                                    func (*GL) ProgramUniformMatrix3dv

                                                                                                                                                                                                                                                                                                                                    func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml

                                                                                                                                                                                                                                                                                                                                      func (*GL) ProgramUniformMatrix3fv

                                                                                                                                                                                                                                                                                                                                      func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml

                                                                                                                                                                                                                                                                                                                                        func (*GL) ProgramUniformMatrix3x2dv

                                                                                                                                                                                                                                                                                                                                        func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml

                                                                                                                                                                                                                                                                                                                                          func (*GL) ProgramUniformMatrix3x2fv

                                                                                                                                                                                                                                                                                                                                          func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml

                                                                                                                                                                                                                                                                                                                                            func (*GL) ProgramUniformMatrix3x4dv

                                                                                                                                                                                                                                                                                                                                            func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml

                                                                                                                                                                                                                                                                                                                                              func (*GL) ProgramUniformMatrix3x4fv

                                                                                                                                                                                                                                                                                                                                              func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml

                                                                                                                                                                                                                                                                                                                                                func (*GL) ProgramUniformMatrix4dv

                                                                                                                                                                                                                                                                                                                                                func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml

                                                                                                                                                                                                                                                                                                                                                  func (*GL) ProgramUniformMatrix4fv

                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml

                                                                                                                                                                                                                                                                                                                                                    func (*GL) ProgramUniformMatrix4x2dv

                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml

                                                                                                                                                                                                                                                                                                                                                      func (*GL) ProgramUniformMatrix4x2fv

                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml

                                                                                                                                                                                                                                                                                                                                                        func (*GL) ProgramUniformMatrix4x3dv

                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml

                                                                                                                                                                                                                                                                                                                                                          func (*GL) ProgramUniformMatrix4x3fv

                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml

                                                                                                                                                                                                                                                                                                                                                            func (*GL) ReadPixels

                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml

                                                                                                                                                                                                                                                                                                                                                              func (*GL) RenderbufferStorage

                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int)

                                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml

                                                                                                                                                                                                                                                                                                                                                                func (*GL) RenderbufferStorageMultisample

                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int)

                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml

                                                                                                                                                                                                                                                                                                                                                                  func (*GL) SamplerParameterIiv

                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32)

                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml

                                                                                                                                                                                                                                                                                                                                                                    func (*GL) SamplerParameteriv

                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32)

                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml

                                                                                                                                                                                                                                                                                                                                                                      func (*GL) Scissor

                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) Scissor(x, y, width, height int)

                                                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml

                                                                                                                                                                                                                                                                                                                                                                        func (*GL) ScissorArrayv

                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) ScissorArrayv(first uint32, count int, v []int32)

                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml

                                                                                                                                                                                                                                                                                                                                                                          func (*GL) ScissorIndexed

                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int)

                                                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml

                                                                                                                                                                                                                                                                                                                                                                            func (*GL) ShaderBinary

                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32)

                                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml

                                                                                                                                                                                                                                                                                                                                                                              func (*GL) ShaderSource

                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) ShaderSource(shader glbase.Shader, source ...string)

                                                                                                                                                                                                                                                                                                                                                                                ShaderSource sets the source code in shader to the provided source code. Any source code previously stored in the shader object is completely replaced.

                                                                                                                                                                                                                                                                                                                                                                                Error GL.INVALID_VALUE is generated if shader is not a value generated by OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader object. GL.INVALID_VALUE is generated if count is less than 0. GL.INVALID_OPERATION is generated if ShaderSource is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                                                                                                                                                                                                ShaderSource is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                                                                                                                                                                func (*GL) StencilFuncSeparate

                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32)

                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml

                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) StencilOp

                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum)

                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml

                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) StencilOpSeparate

                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum)

                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml

                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) TexBuffer

                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer)

                                                                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml

                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) TexImage1D

                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml

                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) TexImage2D

                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml

                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) TexImage2DMultisample

                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool)

                                                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml

                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) TexImage3D

                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml

                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) TexImage3DMultisample

                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool)

                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml

                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) TexParameterIiv

                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) TexParameterIuiv

                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) TexParameterf

                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32)

                                                                                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml

                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) TexParameterfv

                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml

                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) TexParameteri

                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32)

                                                                                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml

                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) TexParameteriv

                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml

                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) TexSubImage1D

                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml

                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) TexSubImage2D

                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) TexSubImage3D

                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) Uniform1dv

                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) Uniform1f

                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32)

                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform1f modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform1f operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                        The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                        All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) Uniform1fv

                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform1fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform1fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                          The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                          All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) Uniform1i

                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32)

                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform1i modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform1i operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                            The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                            All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) Uniform1iv

                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32)

                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform1iv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform1iv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                              The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                              All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) Uniform1ui

                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform1ui modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform1ui operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) Uniform1uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                  Uniform1uiv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform1uiv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                  The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                  All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) Uniform2dv

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) Uniform2f

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                      Uniform2f modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform2f operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                      The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                      All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) Uniform2fv

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform2fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform2fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                        The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                        All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) Uniform2i

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32)

                                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform2i modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform2i operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                          The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                          All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) Uniform2iv

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32)

                                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform2iv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform2iv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                            The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                            All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) Uniform2ui

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform2ui modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform2ui operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                              The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                              All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) Uniform2uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform2uiv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform2uiv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) Uniform3d

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) Uniform3dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) Uniform3f

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uniform3f modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform3f operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) Uniform3fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform3fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform3fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) Uniform3i

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform3i modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform3i operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) Uniform3iv

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform3iv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform3iv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) Uniform3ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform3ui modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform3ui operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) Uniform3uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform3uiv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform3uiv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) Uniform4d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) Uniform4dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) Uniform4f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uniform4f modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform4f operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) Uniform4fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform4fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform4fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) Uniform4i

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform4i modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform4i operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) Uniform4iv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform4iv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform4iv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) Uniform4ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform4ui modifies the value of a single uniform variable. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform4ui operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the uniform variable specified by location using the values passed as arguments. The number specified in the function should match the number of components in the data type of the specified uniform variable (1 for float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). The suffix f indicates that floating-point values are being passed; the suffix i indicates that integer values are being passed; the suffix ui indicates that unsigned integer values are being passed, and this type should also match the data type of the specified uniform variable. The i variants of this function should be used to provide values for uniform variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui variants of this function should be used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of these. The f variants should be used to provide values for uniform variables of type float, vec2, vec3, vec4, or arrays of these. Either the i, ui or f variants may be used to provide values for uniform variables of type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input value is 0 or 0.0f, and it will be set to true otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) Uniform4uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform4uiv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. Uniform4uiv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single uniform variable or a uniform variable array. These functions receive a slice with the values to be loaded into a uniform variable or a uniform variable array. A slice with length 1 should be used if modifying the value of a single uniform variable, and a length of 1 or greater can be used to modify an entire array or part of an array. When loading n elements starting at an arbitrary position m in a uniform variable array, elements m + n - 1 in the array will be replaced with the new values. If m + n - 1 is larger than the size of the uniform variable array, values for all array elements beyond the end of the array will be ignored. The number specified in the name of the command indicates the number of components for each element in value, and it should match the number of components in the data type of the specified uniform variable (1 for float, int, bool; 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name of the command must match the data type for the specified uniform variable as described for Uniform{1|2|3|4}{f|i|ui}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Uniform1i and Uniform1iv are the only two functions that may be used to load uniform variables defined as sampler types. Loading samplers with any other function will result in a GL.INVALID_OPERATION error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) UniformMatrix2dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) UniformMatrix2fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UniformMatrix2fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix2fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) UniformMatrix2x3dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) UniformMatrix2x3fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UniformMatrix2x3fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix2x3fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) UniformMatrix2x4dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) UniformMatrix2x4fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UniformMatrix2x4fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix2x4fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) UniformMatrix3dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) UniformMatrix3fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UniformMatrix3fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix3fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) UniformMatrix3x2dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) UniformMatrix3x2fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UniformMatrix3x2fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix3x2fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) UniformMatrix3x4dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) UniformMatrix3x4fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UniformMatrix3x4fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix3x4fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) UniformMatrix4dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) UniformMatrix4fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UniformMatrix4fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix4fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) UniformMatrix4x2dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) UniformMatrix4x2fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UniformMatrix4x2fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix4x2fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) UniformMatrix4x3dv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) UniformMatrix4x3fv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UniformMatrix4x3fv modifies the value of a uniform variable or a uniform variable array. The location of the uniform variable to be modified is specified by location, which should be a value returned by GetUniformLocation. UniformMatrix4x3fv operates on the program object that was made part of current state by calling UseProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to modify a matrix or an array of matrices. The numbers in the function name are interpreted as the dimensionality of the matrix. The number 2 indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 values), and the number 4 indicates a 4x4 matrix (16 values). Non-square matrix dimensionality is explicit, with the first number representing the number of columns and the second number representing the number of rows. For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 values). The length of the provided slice must be a multiple of the number of values per matrix, to update one or more consecutive matrices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If transpose is false, each matrix is assumed to be supplied in column major order. If transpose is true, each matrix is assumed to be supplied in row major order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All active uniform variables defined in a program object are initialized to 0 when the program object is linked successfully. They retain the values assigned to them by a call to Uniform* until the next successful link operation occurs on the program object, when they are once again initialized to 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) UniformSubroutinesuiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) UseProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) UseProgram(program glbase.Program)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UseProgram installs the program object specified by program as part of current rendering state. One or more executables are created in a program object by successfully attaching shader objects to it with AttachShader, successfully compiling the shader objects with CompileShader, and successfully linking the program object with LinkProgram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A program object will contain an executable that will run on the vertex processor if it contains one or more shader objects of type GL.VERTEX_SHADER that have been successfully compiled and linked. Similarly, a program object will contain an executable that will run on the fragment processor if it contains one or more shader objects of type GL.FRAGMENT_SHADER that have been successfully compiled and linked.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Successfully installing an executable on a programmable processor will cause the corresponding fixed functionality of OpenGL to be disabled. Specifically, if an executable is installed on the vertex processor, the OpenGL fixed functionality will be disabled as follows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - The modelview matrix is not applied to vertex coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - The projection matrix is not applied to vertex coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - The texture matrices are not applied to texture coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Normals are not transformed to eye coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Normals are not rescaled or normalized.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Normalization of GL.AUTO_NORMAL evaluated normals is not performed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Texture coordinates are not generated automatically.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Per-vertex lighting is not performed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Color material computations are not performed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Color index lighting is not performed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - This list also applies when setting the current raster position.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The executable that is installed on the vertex processor is expected to implement any or all of the desired functionality from the preceding list. Similarly, if an executable is installed on the fragment processor, the OpenGL fixed functionality will be disabled as follows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Texture environment and texture functions are not applied.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Texture application is not applied.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Color sum is not applied.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Fog is not applied.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Again, the fragment shader that is installed is expected to implement any or all of the desired functionality from the preceding list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        While a program object is in use, applications are free to modify attached shader objects, compile attached shader objects, attach additional shader objects, and detach or delete shader objects. None of these operations will affect the executables that are part of the current state. However, relinking the program object that is currently in use will install the program object as part of the current rendering state if the link operation was successful (see LinkProgram). If the program object currently in use is relinked unsuccessfully, its link status will be set to GL.FALSE, but the executables and associated state will remain part of the current state until a subsequent call to UseProgram removes it from use. After it is removed from use, it cannot be made part of current state until it has been successfully relinked.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If program contains shader objects of type GL.VERTEX_SHADER but it does not contain shader objects of type GL.FRAGMENT_SHADER, an executable will be installed on the vertex processor, but fixed functionality will be used for fragment processing. Similarly, if program contains shader objects of type GL.FRAGMENT_SHADER but it does not contain shader objects of type GL.VERTEX_SHADER, an executable will be installed on the fragment processor, but fixed functionality will be used for vertex processing. If program is 0, the programmable processors will be disabled, and fixed functionality will be used for both vertex and fragment processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        While a program object is in use, the state that controls the disabled fixed functionality may also be updated using the normal OpenGL calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Like display lists and texture objects, the name space for program objects may be shared across a set of contexts, as long as the server sides of the contexts share the same address space. If the name space is shared across contexts, any attached objects and the data associated with those attached objects are shared as well.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Applications are responsible for providing the synchronization across API calls when objects are accessed from different execution threads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error GL.INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. GL.INVALID_OPERATION is generated if program could not be made part of current state. GL.INVALID_OPERATION is generated if UseProgram is executed between the execution of Begin and the corresponding execution of End.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UseProgram is available in GL version 2.0 or greater.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) VertexAttribIPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) VertexAttribLPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) VertexAttribP1ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) VertexAttribP1uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*GL) VertexAttribP2ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GL) VertexAttribP2uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GL) VertexAttribP3ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*GL) VertexAttribP3uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*GL) VertexAttribP4ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*GL) VertexAttribP4uiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*GL) VertexAttribPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              VertexAttribPointer specifies the location and data format of the array of generic vertex attributes at index to use when rendering. size specifies the number of components per attribute and must be 1, 2, 3, or 4. type specifies the data type of each component, and stride specifies the byte stride from one attribute to the next, allowing vertices and attributes to be packed into a single array or stored in separate arrays. normalized indicates whether the values stored in an integer format are to be mapped to the range [-1,1] (for signed values) or [0,1] (for unsigned values) when they are accessed and converted to floating point; otherwise, values will be converted to floats directly without normalization. offset is a byte offset into the buffer object's data store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as generic vertex attribute array client-side state (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To enable and disable a generic vertex attribute array, call EnableVertexAttribArray and DisableVertexAttribArray with index. If enabled, the generic vertex attribute array is used when DrawArrays or DrawElements is called. Each generic vertex attribute array is initially disabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              VertexAttribPointer is typically implemented on the client side.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Error GL.INVALID_ENUM is generated if type is not an accepted value. GL.INVALID_VALUE is generated if index is greater than or equal to GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, 3, or 4. GL.INVALID_VALUE is generated if stride is negative.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*GL) Viewport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) Viewport(x, y, width, height int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Source Files