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

	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_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

	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_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_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

	GENERATE_MIPMAP_HINT     = 0x8192
	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

	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
	LINE_LOOP      = 0x0002
	LINE_STRIP     = 0x0003
	POINTS         = 0x0000
	POLYGON        = 0x0009
	QUADS          = 0x0007
	QUAD_STRIP     = 0x0008
	TRIANGLES      = 0x0004
	TRIANGLE_FAN   = 0x0006
	TRIANGLE_STRIP = 0x0005

	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

	CONSTANT_COLOR                 = 0x8001
	ONE_MINUS_CONSTANT_COLOR       = 0x8002
	CONSTANT_ALPHA                 = 0x8003
	ONE_MINUS_CONSTANT_ALPHA       = 0x8004
	FUNC_ADD                       = 0x8006
	MIN                            = 0x8007
	MAX                            = 0x8008
	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
	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_COORDINATE                 = 0x8451
	FRAGMENT_DEPTH                 = 0x8452
	CURRENT_FOG_COORDINATE         = 0x8453
	FOG_COORDINATE_ARRAY_TYPE      = 0x8454
	FOG_COORDINATE_ARRAY_STRIDE    = 0x8455
	FOG_COORDINATE_ARRAY_POINTER   = 0x8456
	FOG_COORDINATE_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
	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
	COMPRESSED_ALPHA               = 0x84E9
	COMPRESSED_LUMINANCE           = 0x84EA
	COMPRESSED_LUMINANCE_ALPHA     = 0x84EB
	COMPRESSED_INTENSITY           = 0x84EC
	COMPRESSED_RGB                 = 0x84ED
	COMPRESSED_RGBA                = 0x84EE
	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
	SOURCE1_RGB                    = 0x8581
	SOURCE2_RGB                    = 0x8582
	SOURCE0_ALPHA                  = 0x8588
	SOURCE1_ALPHA                  = 0x8589
	SOURCE2_ALPHA                  = 0x858A
	OPERAND0_RGB                   = 0x8590
	OPERAND1_RGB                   = 0x8591
	OPERAND2_RGB                   = 0x8592
	OPERAND0_ALPHA                 = 0x8598
	OPERAND1_ALPHA                 = 0x8599
	OPERAND2_ALPHA                 = 0x859A
	TEXTURE_COMPRESSED_IMAGE_SIZE  = 0x86A0
	TEXTURE_COMPRESSED             = 0x86A1
	NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2
	COMPRESSED_TEXTURE_FORMATS     = 0x86A3
	DOT3_RGB                       = 0x86AE
	DOT3_RGBA                      = 0x86AF
	TEXTURE_DEPTH_SIZE             = 0x884A
	DEPTH_TEXTURE_MODE             = 0x884B
	TEXTURE_COMPARE_MODE           = 0x884C
	TEXTURE_COMPARE_FUNC           = 0x884D
	COMPARE_R_TO_TEXTURE           = 0x884E
)

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 1.4 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 1.4 API.

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

      func (*GL) Accum

      func (gl *GL) Accum(op glbase.Enum, value float32)

        Accum executes an operation on the accumulation buffer.

        Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is used.

        The accumulation buffer is an extended-range color buffer. Images are not rendered into it. Rather, images rendered into one of the color buffers are added to the contents of the accumulation buffer after rendering. Effects such as antialiasing (of points, lines, and polygons), motion blur, and depth of field can be created by accumulating images generated with different transformation matrices.

        Each pixel in the accumulation buffer consists of red, green, blue, and alpha values. The number of bits per component in the accumulation buffer depends on the implementation. You can examine this number by calling GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. Regardless of the number of bits per component, the range of values stored by each component is (-1, 1). The accumulation buffer pixels are mapped one-to-one with frame buffer pixels.

        All accumulation buffer operations are limited to the area of the current scissor box and applied identically to the red, green, blue, and alpha components of each pixel. If a Accum operation results in a value outside the range (-1, 1), the contents of an accumulation buffer pixel component are undefined.

        The operations are as follows:

        GL.ACCUM
            Obtains R, G, B, and A values from the buffer currently selected for
            reading (see ReadBuffer). Each component value is divided by 2 n -
            1 , where n is the number of bits allocated to each color component
            in the currently selected buffer. The result is a floating-point
            value in the range 0 1 , which is multiplied by value and added to
            the corresponding pixel component in the accumulation buffer,
            thereby updating the accumulation buffer.
        
        GL.LOAD
            Similar to GL.ACCUM, except that the current value in the
            accumulation buffer is not used in the calculation of the new value.
            That is, the R, G, B, and A values from the currently selected
            buffer are divided by 2 n - 1 , multiplied by value, and then stored
            in the corresponding accumulation buffer cell, overwriting the
            current value.
        
        GL.ADD
            Adds value to each R, G, B, and A in the accumulation buffer.
        
        GL.MULT
            Multiplies each R, G, B, and A in the accumulation buffer by value
            and returns the scaled component to its corresponding accumulation
            buffer location.
        
        GL.RETURN
            Transfers accumulation buffer values to the color buffer or buffers
            currently selected for writing. Each R, G, B, and A component is
            multiplied by value, then multiplied by 2 n - 1 , clamped to the
            range 0 2 n - 1 , and stored in the corresponding display buffer
            cell. The only fragment operations that are applied to this transfer
            are pixel ownership, scissor, dithering, and color writemasks.
        

        To clear the accumulation buffer, call ClearAccum with R, G, B, and A values to set it to, then call Clear with the accumulation buffer enabled.

        Error GL.INVALID_ENUM is generated if op is not an accepted value. GL.INVALID_OPERATION is generated if there is no accumulation buffer. GL.INVALID_OPERATION is generated if Accum is executed between the execution of Begin and the corresponding execution of End.

        func (*GL) AreTexturesResident

        func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool

          https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml

          func (*GL) Bitmap

          func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8)

            https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml

            func (*GL) BlendColor

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

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

              func (*GL) BlendFunc

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

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

                func (*GL) BlendFuncSeparate

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

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

                  func (*GL) CallLists

                  func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{})

                    https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml

                    func (*GL) ClearAccum

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

                      https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml

                      func (*GL) ClearColor

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

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

                        func (*GL) ClipPlane

                        func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64)

                          https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml

                          func (*GL) Color3b

                          func (gl *GL) Color3b(red, green, blue byte)

                            https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml

                            func (*GL) Color3d

                            func (gl *GL) Color3d(red, green, blue float64)

                              https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml

                              func (*GL) Color3f

                              func (gl *GL) Color3f(red, green, blue float32)

                                https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml

                                func (*GL) Color3i

                                func (gl *GL) Color3i(red, green, blue int32)

                                  https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml

                                  func (*GL) Color3s

                                  func (gl *GL) Color3s(red, green, blue int16)

                                    https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml

                                    func (*GL) Color3ub

                                    func (gl *GL) Color3ub(red, green, blue uint8)

                                      https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml

                                      func (*GL) Color3ui

                                      func (gl *GL) Color3ui(red, green, blue uint32)

                                        https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml

                                        func (*GL) Color3us

                                        func (gl *GL) Color3us(red, green, blue uint16)

                                          https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml

                                          func (*GL) Color4b

                                          func (gl *GL) Color4b(red, green, blue, alpha byte)

                                            https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml

                                            func (*GL) Color4d

                                            func (gl *GL) Color4d(red, green, blue, alpha float64)

                                              https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml

                                              func (*GL) Color4f

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

                                                https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml

                                                func (*GL) Color4i

                                                func (gl *GL) Color4i(red, green, blue, alpha int32)

                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml

                                                  func (*GL) Color4s

                                                  func (gl *GL) Color4s(red, green, blue, alpha int16)

                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml

                                                    func (*GL) Color4ub

                                                    func (gl *GL) Color4ub(red, green, blue, alpha uint8)

                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml

                                                      func (*GL) Color4ui

                                                      func (gl *GL) Color4ui(red, green, blue, alpha uint32)

                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml

                                                        func (*GL) Color4us

                                                        func (gl *GL) Color4us(red, green, blue, alpha uint16)

                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml

                                                          func (*GL) ColorMask

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

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

                                                            func (*GL) ColorPointer

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

                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml

                                                              func (*GL) ColorSubTable

                                                              func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{})

                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml

                                                                func (*GL) ColorTable

                                                                func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{})

                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml

                                                                  func (*GL) ColorTableParameterfv

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

                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml

                                                                    func (*GL) ColorTableParameteriv

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

                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml

                                                                      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/man2/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/man2/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/man2/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/man2/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/man2/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/man2/xhtml/glCompressedTexSubImage3D.xml

                                                                                  func (*GL) ConvolutionFilter1D

                                                                                  func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{})

                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml

                                                                                    func (*GL) ConvolutionFilter2D

                                                                                    func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{})

                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml

                                                                                      func (*GL) ConvolutionParameterf

                                                                                      func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32)

                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml

                                                                                        func (*GL) ConvolutionParameterfv

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

                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml

                                                                                          func (*GL) ConvolutionParameteri

                                                                                          func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32)

                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml

                                                                                            func (*GL) ConvolutionParameteriv

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

                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml

                                                                                              func (*GL) CopyColorSubTable

                                                                                              func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int)

                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml

                                                                                                func (*GL) CopyColorTable

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

                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml

                                                                                                  func (*GL) CopyConvolutionFilter1D

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

                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml

                                                                                                    func (*GL) CopyConvolutionFilter2D

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

                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml

                                                                                                      func (*GL) CopyPixels

                                                                                                      func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum)

                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.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/man2/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/man2/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/man2/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/man2/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/man2/xhtml/glCopyTexSubImage3D.xml

                                                                                                                  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/man2/xhtml/glDrawArrays.xml

                                                                                                                        func (*GL) DrawElements

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

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

                                                                                                                          func (*GL) DrawPixels

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

                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.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/man2/xhtml/glDrawRangeElements.xml

                                                                                                                              func (*GL) EdgeFlagPointer

                                                                                                                              func (gl *GL) EdgeFlagPointer(stride int, pointer interface{})

                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml

                                                                                                                                func (*GL) EvalMesh2

                                                                                                                                func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32)

                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml

                                                                                                                                  func (*GL) FeedbackBuffer

                                                                                                                                  func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32)

                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml

                                                                                                                                    func (*GL) FogCoordPointer

                                                                                                                                    func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{})

                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordPointer.xml

                                                                                                                                      func (*GL) Fogiv

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

                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml

                                                                                                                                        func (*GL) Frustum

                                                                                                                                        func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64)

                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.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) GetColorTable

                                                                                                                                            func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{})

                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml

                                                                                                                                              func (*GL) GetColorTableParameterfv

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

                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml

                                                                                                                                                func (*GL) GetColorTableParameteriv

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

                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml

                                                                                                                                                  func (*GL) GetCompressedTexImage

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

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

                                                                                                                                                    func (*GL) GetConvolutionFilter

                                                                                                                                                    func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{})

                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml

                                                                                                                                                      func (*GL) GetConvolutionParameterfv

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

                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml

                                                                                                                                                        func (*GL) GetConvolutionParameteriv

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

                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml

                                                                                                                                                          func (*GL) GetHistogram

                                                                                                                                                          func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{})

                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml

                                                                                                                                                            func (*GL) GetHistogramParameterfv

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

                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml

                                                                                                                                                              func (*GL) GetHistogramParameteriv

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

                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml

                                                                                                                                                                func (*GL) GetLightfv

                                                                                                                                                                func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32)

                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml

                                                                                                                                                                  func (*GL) GetLightiv

                                                                                                                                                                  func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32)

                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml

                                                                                                                                                                    func (*GL) GetMapdv

                                                                                                                                                                    func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64)

                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml

                                                                                                                                                                      func (*GL) GetMapfv

                                                                                                                                                                      func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32)

                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml

                                                                                                                                                                        func (*GL) GetMapiv

                                                                                                                                                                        func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32)

                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml

                                                                                                                                                                          func (*GL) GetMaterialfv

                                                                                                                                                                          func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32)

                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml

                                                                                                                                                                            func (*GL) GetMaterialiv

                                                                                                                                                                            func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32)

                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml

                                                                                                                                                                              func (*GL) GetMinmax

                                                                                                                                                                              func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{})

                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml

                                                                                                                                                                                func (*GL) GetMinmaxParameterfv

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

                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml

                                                                                                                                                                                  func (*GL) GetMinmaxParameteriv

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

                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml

                                                                                                                                                                                    func (*GL) GetSeparableFilter

                                                                                                                                                                                    func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{})

                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml

                                                                                                                                                                                      func (*GL) GetTexEnvfv

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

                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml

                                                                                                                                                                                        func (*GL) GetTexEnviv

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

                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml

                                                                                                                                                                                          func (*GL) GetTexGendv

                                                                                                                                                                                          func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64)

                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml

                                                                                                                                                                                            func (*GL) GetTexGenfv

                                                                                                                                                                                            func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32)

                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml

                                                                                                                                                                                              func (*GL) GetTexGeniv

                                                                                                                                                                                              func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32)

                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.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/man2/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/man2/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/man2/xhtml/glGetTexLevelParameteriv.xml

                                                                                                                                                                                                      func (*GL) GetTexParameterfv

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

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

                                                                                                                                                                                                        func (*GL) GetTexParameteriv

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

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

                                                                                                                                                                                                          func (*GL) Hint

                                                                                                                                                                                                          func (gl *GL) Hint(target, mode glbase.Enum)

                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml

                                                                                                                                                                                                            func (*GL) Histogram

                                                                                                                                                                                                            func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool)

                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml

                                                                                                                                                                                                              func (*GL) IndexPointer

                                                                                                                                                                                                              func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{})

                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml

                                                                                                                                                                                                                func (*GL) InterleavedArrays

                                                                                                                                                                                                                func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{})

                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml

                                                                                                                                                                                                                  func (*GL) Lightf

                                                                                                                                                                                                                  func (gl *GL) Lightf(light, pname glbase.Enum, param float32)

                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml

                                                                                                                                                                                                                    func (*GL) Lightfv

                                                                                                                                                                                                                    func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml

                                                                                                                                                                                                                      func (*GL) Lighti

                                                                                                                                                                                                                      func (gl *GL) Lighti(light, pname glbase.Enum, param int32)

                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml

                                                                                                                                                                                                                        func (*GL) Lightiv

                                                                                                                                                                                                                        func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml

                                                                                                                                                                                                                          func (*GL) LineStipple

                                                                                                                                                                                                                          func (gl *GL) LineStipple(factor int32, pattern uint16)

                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml

                                                                                                                                                                                                                            func (*GL) Map1d

                                                                                                                                                                                                                            func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64)

                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml

                                                                                                                                                                                                                              func (*GL) Map1f

                                                                                                                                                                                                                              func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32)

                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml

                                                                                                                                                                                                                                func (*GL) Map2d

                                                                                                                                                                                                                                func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64)

                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml

                                                                                                                                                                                                                                  func (*GL) Map2f

                                                                                                                                                                                                                                  func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32)

                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml

                                                                                                                                                                                                                                    func (*GL) MapGrid2d

                                                                                                                                                                                                                                    func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64)

                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml

                                                                                                                                                                                                                                      func (*GL) MapGrid2f

                                                                                                                                                                                                                                      func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32)

                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml

                                                                                                                                                                                                                                        func (*GL) Materialf

                                                                                                                                                                                                                                        func (gl *GL) Materialf(face, pname glbase.Enum, param float32)

                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml

                                                                                                                                                                                                                                          func (*GL) Materialfv

                                                                                                                                                                                                                                          func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml

                                                                                                                                                                                                                                            func (*GL) Materiali

                                                                                                                                                                                                                                            func (gl *GL) Materiali(face, pname glbase.Enum, param int32)

                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml

                                                                                                                                                                                                                                              func (*GL) Materialiv

                                                                                                                                                                                                                                              func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml

                                                                                                                                                                                                                                                func (*GL) Minmax

                                                                                                                                                                                                                                                func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool)

                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml

                                                                                                                                                                                                                                                  func (*GL) MultMatrixd

                                                                                                                                                                                                                                                  func (gl *GL) MultMatrixd(m []float64)

                                                                                                                                                                                                                                                    MultMatrixd multiplies the current matrix with the provided matrix.

                                                                                                                                                                                                                                                    The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix.

                                                                                                                                                                                                                                                    The current matrix is determined by the current matrix mode (see MatrixMode). It is either the projection matrix, modelview matrix, or the texture matrix.

                                                                                                                                                                                                                                                    For example, if the current matrix is C and the coordinates to be transformed are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or

                                                                                                                                                                                                                                                    c[0]  c[4]  c[8]  c[12]     v[0]
                                                                                                                                                                                                                                                    c[1]  c[5]  c[9]  c[13]     v[1]
                                                                                                                                                                                                                                                    c[2]  c[6]  c[10] c[14]  X  v[2]
                                                                                                                                                                                                                                                    c[3]  c[7]  c[11] c[15]     v[3]
                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                    Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] replaces the current transformation with (C X M) x v, or

                                                                                                                                                                                                                                                    c[0]  c[4]  c[8]  c[12]   m[0]  m[4]  m[8]  m[12]   v[0]
                                                                                                                                                                                                                                                    c[1]  c[5]  c[9]  c[13]   m[1]  m[5]  m[9]  m[13]   v[1]
                                                                                                                                                                                                                                                    c[2]  c[6]  c[10] c[14] X m[2]  m[6]  m[10] m[14] X v[2]
                                                                                                                                                                                                                                                    c[3]  c[7]  c[11] c[15]   m[3]  m[7]  m[11] m[15]   v[3]
                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                    Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix.

                                                                                                                                                                                                                                                    While the elements of the matrix may be specified with single or double precision, the GL may store or operate on these values in less-than-single precision.

                                                                                                                                                                                                                                                    In many computer languages, 4×4 arrays are represented in row-major order. The transformations just described represent these matrices in column-major order. The order of the multiplication is important. For example, if the current transformation is a rotation, and MultMatrix is called with a translation matrix, the translation is done directly on the coordinates to be transformed, while the rotation is done on the results of that translation.

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

                                                                                                                                                                                                                                                    func (*GL) MultMatrixf

                                                                                                                                                                                                                                                    func (gl *GL) MultMatrixf(m []float32)

                                                                                                                                                                                                                                                      MultMatrixf multiplies the current matrix with the provided matrix.

                                                                                                                                                                                                                                                      The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix.

                                                                                                                                                                                                                                                      The current matrix is determined by the current matrix mode (see MatrixMode). It is either the projection matrix, modelview matrix, or the texture matrix.

                                                                                                                                                                                                                                                      For example, if the current matrix is C and the coordinates to be transformed are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or

                                                                                                                                                                                                                                                      c[0]  c[4]  c[8]  c[12]     v[0]
                                                                                                                                                                                                                                                      c[1]  c[5]  c[9]  c[13]     v[1]
                                                                                                                                                                                                                                                      c[2]  c[6]  c[10] c[14]  X  v[2]
                                                                                                                                                                                                                                                      c[3]  c[7]  c[11] c[15]     v[3]
                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                      Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] replaces the current transformation with (C X M) x v, or

                                                                                                                                                                                                                                                      c[0]  c[4]  c[8]  c[12]   m[0]  m[4]  m[8]  m[12]   v[0]
                                                                                                                                                                                                                                                      c[1]  c[5]  c[9]  c[13]   m[1]  m[5]  m[9]  m[13]   v[1]
                                                                                                                                                                                                                                                      c[2]  c[6]  c[10] c[14] X m[2]  m[6]  m[10] m[14] X v[2]
                                                                                                                                                                                                                                                      c[3]  c[7]  c[11] c[15]   m[3]  m[7]  m[11] m[15]   v[3]
                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                      Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix.

                                                                                                                                                                                                                                                      While the elements of the matrix may be specified with single or double precision, the GL may store or operate on these values in less-than-single precision.

                                                                                                                                                                                                                                                      In many computer languages, 4×4 arrays are represented in row-major order. The transformations just described represent these matrices in column-major order. The order of the multiplication is important. For example, if the current transformation is a rotation, and MultMatrix is called with a translation matrix, the translation is done directly on the coordinates to be transformed, while the rotation is done on the results of that translation.

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

                                                                                                                                                                                                                                                      func (*GL) MultiDrawArrays

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

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

                                                                                                                                                                                                                                                        func (*GL) MultiTexCoord4i

                                                                                                                                                                                                                                                        func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32)

                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4i.xml

                                                                                                                                                                                                                                                          func (*GL) MultiTexCoord4s

                                                                                                                                                                                                                                                          func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16)

                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4s.xml

                                                                                                                                                                                                                                                            func (*GL) Normal3b

                                                                                                                                                                                                                                                            func (gl *GL) Normal3b(nx, ny, nz byte)

                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml

                                                                                                                                                                                                                                                              func (*GL) NormalPointer

                                                                                                                                                                                                                                                              func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{})

                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml

                                                                                                                                                                                                                                                                func (*GL) Ortho

                                                                                                                                                                                                                                                                func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64)

                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml

                                                                                                                                                                                                                                                                  func (*GL) PixelMapfv

                                                                                                                                                                                                                                                                  func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32)

                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml

                                                                                                                                                                                                                                                                    func (*GL) PixelMapuiv

                                                                                                                                                                                                                                                                    func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32)

                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml

                                                                                                                                                                                                                                                                      func (*GL) PixelMapusv

                                                                                                                                                                                                                                                                      func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16)

                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml

                                                                                                                                                                                                                                                                        func (*GL) PixelZoom

                                                                                                                                                                                                                                                                        func (gl *GL) PixelZoom(xfactor, yfactor float32)

                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml

                                                                                                                                                                                                                                                                          func (*GL) PrioritizeTextures

                                                                                                                                                                                                                                                                          func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32)

                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml

                                                                                                                                                                                                                                                                            func (*GL) RasterPos4i

                                                                                                                                                                                                                                                                            func (gl *GL) RasterPos4i(x, y, z, w int)

                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.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/man2/xhtml/glReadPixels.xml

                                                                                                                                                                                                                                                                                func (*GL) Rectd

                                                                                                                                                                                                                                                                                func (gl *GL) Rectd(x1, y1, x2, y2 float64)

                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml

                                                                                                                                                                                                                                                                                  func (*GL) Rectf

                                                                                                                                                                                                                                                                                  func (gl *GL) Rectf(x1, y1, x2, y2 float32)

                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml

                                                                                                                                                                                                                                                                                    func (*GL) Recti

                                                                                                                                                                                                                                                                                    func (gl *GL) Recti(x1, y1, x2, y2 int32)

                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml

                                                                                                                                                                                                                                                                                      func (*GL) Rects

                                                                                                                                                                                                                                                                                      func (gl *GL) Rects(x1, y1, x2, y2 int16)

                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml

                                                                                                                                                                                                                                                                                        func (*GL) Rotated

                                                                                                                                                                                                                                                                                        func (gl *GL) Rotated(angle, x, y, z float64)

                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml

                                                                                                                                                                                                                                                                                          func (*GL) Rotatef

                                                                                                                                                                                                                                                                                          func (gl *GL) Rotatef(angle, x, y, z float32)

                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml

                                                                                                                                                                                                                                                                                            func (*GL) Scissor

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

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

                                                                                                                                                                                                                                                                                              func (*GL) SecondaryColor3b

                                                                                                                                                                                                                                                                                              func (gl *GL) SecondaryColor3b(red, green, blue byte)

                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3b.xml

                                                                                                                                                                                                                                                                                                func (*GL) SecondaryColor3d

                                                                                                                                                                                                                                                                                                func (gl *GL) SecondaryColor3d(red, green, blue float64)

                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3d.xml

                                                                                                                                                                                                                                                                                                  func (*GL) SecondaryColor3f

                                                                                                                                                                                                                                                                                                  func (gl *GL) SecondaryColor3f(red, green, blue float32)

                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3f.xml

                                                                                                                                                                                                                                                                                                    func (*GL) SecondaryColor3i

                                                                                                                                                                                                                                                                                                    func (gl *GL) SecondaryColor3i(red, green, blue int32)

                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3i.xml

                                                                                                                                                                                                                                                                                                      func (*GL) SecondaryColor3s

                                                                                                                                                                                                                                                                                                      func (gl *GL) SecondaryColor3s(red, green, blue int16)

                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3s.xml

                                                                                                                                                                                                                                                                                                        func (*GL) SecondaryColor3ub

                                                                                                                                                                                                                                                                                                        func (gl *GL) SecondaryColor3ub(red, green, blue uint8)

                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ub.xml

                                                                                                                                                                                                                                                                                                          func (*GL) SecondaryColor3ui

                                                                                                                                                                                                                                                                                                          func (gl *GL) SecondaryColor3ui(red, green, blue uint32)

                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ui.xml

                                                                                                                                                                                                                                                                                                            func (*GL) SecondaryColor3us

                                                                                                                                                                                                                                                                                                            func (gl *GL) SecondaryColor3us(red, green, blue uint16)

                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3us.xml

                                                                                                                                                                                                                                                                                                              func (*GL) SecondaryColorPointer

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

                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColorPointer.xml

                                                                                                                                                                                                                                                                                                                func (*GL) SeparableFilter2D

                                                                                                                                                                                                                                                                                                                func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{})

                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml

                                                                                                                                                                                                                                                                                                                  func (*GL) StencilOp

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

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

                                                                                                                                                                                                                                                                                                                    func (*GL) TexCoordPointer

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

                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml

                                                                                                                                                                                                                                                                                                                      func (*GL) TexEnvf

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

                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml

                                                                                                                                                                                                                                                                                                                        func (*GL) TexEnvfv

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

                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml

                                                                                                                                                                                                                                                                                                                          func (*GL) TexEnvi

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

                                                                                                                                                                                                                                                                                                                            https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml

                                                                                                                                                                                                                                                                                                                            func (*GL) TexEnviv

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

                                                                                                                                                                                                                                                                                                                              https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml

                                                                                                                                                                                                                                                                                                                              func (*GL) TexGend

                                                                                                                                                                                                                                                                                                                              func (gl *GL) TexGend(coord, pname glbase.Enum, param float64)

                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml

                                                                                                                                                                                                                                                                                                                                func (*GL) TexGendv

                                                                                                                                                                                                                                                                                                                                func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64)

                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml

                                                                                                                                                                                                                                                                                                                                  func (*GL) TexGenf

                                                                                                                                                                                                                                                                                                                                  func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32)

                                                                                                                                                                                                                                                                                                                                    https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml

                                                                                                                                                                                                                                                                                                                                    func (*GL) TexGenfv

                                                                                                                                                                                                                                                                                                                                    func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32)

                                                                                                                                                                                                                                                                                                                                      https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml

                                                                                                                                                                                                                                                                                                                                      func (*GL) TexGeni

                                                                                                                                                                                                                                                                                                                                      func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32)

                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml

                                                                                                                                                                                                                                                                                                                                        func (*GL) TexGeniv

                                                                                                                                                                                                                                                                                                                                        func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32)

                                                                                                                                                                                                                                                                                                                                          https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.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/man2/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/man2/xhtml/glTexImage2D.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/man2/xhtml/glTexImage3D.xml

                                                                                                                                                                                                                                                                                                                                                func (*GL) TexParameterf

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

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

                                                                                                                                                                                                                                                                                                                                                  func (*GL) TexParameterfv

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

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

                                                                                                                                                                                                                                                                                                                                                    func (*GL) TexParameteri

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

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

                                                                                                                                                                                                                                                                                                                                                      func (*GL) TexParameteriv

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

                                                                                                                                                                                                                                                                                                                                                        https://www.opengl.org/sdk/docs/man2/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/man2/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/man2/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/man2/xhtml/glTexSubImage3D.xml

                                                                                                                                                                                                                                                                                                                                                              func (*GL) Vertex4i

                                                                                                                                                                                                                                                                                                                                                              func (gl *GL) Vertex4i(x, y, z, w int)

                                                                                                                                                                                                                                                                                                                                                                https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml

                                                                                                                                                                                                                                                                                                                                                                func (*GL) VertexPointer

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

                                                                                                                                                                                                                                                                                                                                                                  https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml

                                                                                                                                                                                                                                                                                                                                                                  func (*GL) Viewport

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

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

                                                                                                                                                                                                                                                                                                                                                                    Source Files