3bd69d3fcc
Compiling a binary with "-tags gldebug" will add log tracing to each GL function call. This is the best I can offer in lieu of of real error handling. A colleague has accused me of Aspect-oriented programming. The wikipedia article on the topic lost me in the first paragraph, so just for the record, this was inspired by the way the cover tool rewrites source code. LGTM=sameer R=golang-codereviews, sameer CC=golang-codereviews https://golang.org/cl/128640043
1904 lines
48 KiB
Go
1904 lines
48 KiB
Go
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Generated from gl.go. DO NOT EDIT.
|
|
// See doc.org for details.
|
|
|
|
// +build gldebug
|
|
|
|
package gl
|
|
|
|
//#cgo darwin LDFLAGS: -framework OpenGL
|
|
//#cgo linux LDFLAGS: -lGLESv2
|
|
//#include <stdlib.h>
|
|
//#include "gl2.h"
|
|
import "C"
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"unsafe"
|
|
)
|
|
|
|
/*
|
|
Partially generated from the Khronos OpenGL API specification in XML
|
|
format, which is covered by the license:
|
|
|
|
Copyright (c) 2013-2014 The Khronos Group Inc.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a
|
|
copy of this software and/or associated documentation files (the
|
|
"Materials"), to deal in the Materials without restriction, including
|
|
without limitation the rights to use, copy, modify, merge, publish,
|
|
distribute, sublicense, and/or sell copies of the Materials, and to
|
|
permit persons to whom the Materials are furnished to do so, subject to
|
|
the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included
|
|
in all copies or substantial portions of the Materials.
|
|
|
|
THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
|
|
|
|
*/
|
|
|
|
func errDrain() string {
|
|
var errs []Enum
|
|
for {
|
|
e := Enum(C.glGetError())
|
|
if e == 0 {
|
|
break
|
|
}
|
|
errs = append(errs, e)
|
|
}
|
|
if len(errs) > 0 {
|
|
return fmt.Sprintf(" error: %v", errs)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (v Enum) String() string {
|
|
switch v {
|
|
case 0x0:
|
|
return "0"
|
|
case 0x1:
|
|
return "1"
|
|
case 0x2:
|
|
return "LINE_LOOP"
|
|
case 0x3:
|
|
return "LINE_STRIP"
|
|
case 0x4:
|
|
return "TRIANGLES"
|
|
case 0x5:
|
|
return "TRIANGLE_STRIP"
|
|
case 0x6:
|
|
return "TRIANGLE_FAN"
|
|
case 0x300:
|
|
return "SRC_COLOR"
|
|
case 0x301:
|
|
return "ONE_MINUS_SRC_COLOR"
|
|
case 0x302:
|
|
return "SRC_ALPHA"
|
|
case 0x303:
|
|
return "ONE_MINUS_SRC_ALPHA"
|
|
case 0x304:
|
|
return "DST_ALPHA"
|
|
case 0x305:
|
|
return "ONE_MINUS_DST_ALPHA"
|
|
case 0x306:
|
|
return "DST_COLOR"
|
|
case 0x307:
|
|
return "ONE_MINUS_DST_COLOR"
|
|
case 0x308:
|
|
return "SRC_ALPHA_SATURATE"
|
|
case 0x8006:
|
|
return "FUNC_ADD"
|
|
case 0x8009:
|
|
return "32777"
|
|
case 0x883d:
|
|
return "BLEND_EQUATION_ALPHA"
|
|
case 0x800a:
|
|
return "FUNC_SUBTRACT"
|
|
case 0x800b:
|
|
return "FUNC_REVERSE_SUBTRACT"
|
|
case 0x80c8:
|
|
return "BLEND_DST_RGB"
|
|
case 0x80c9:
|
|
return "BLEND_SRC_RGB"
|
|
case 0x80ca:
|
|
return "BLEND_DST_ALPHA"
|
|
case 0x80cb:
|
|
return "BLEND_SRC_ALPHA"
|
|
case 0x8001:
|
|
return "CONSTANT_COLOR"
|
|
case 0x8002:
|
|
return "ONE_MINUS_CONSTANT_COLOR"
|
|
case 0x8003:
|
|
return "CONSTANT_ALPHA"
|
|
case 0x8004:
|
|
return "ONE_MINUS_CONSTANT_ALPHA"
|
|
case 0x8005:
|
|
return "BLEND_COLOR"
|
|
case 0x8892:
|
|
return "ARRAY_BUFFER"
|
|
case 0x8893:
|
|
return "ELEMENT_ARRAY_BUFFER"
|
|
case 0x8894:
|
|
return "ARRAY_BUFFER_BINDING"
|
|
case 0x8895:
|
|
return "ELEMENT_ARRAY_BUFFER_BINDING"
|
|
case 0x88e0:
|
|
return "STREAM_DRAW"
|
|
case 0x88e4:
|
|
return "STATIC_DRAW"
|
|
case 0x88e8:
|
|
return "DYNAMIC_DRAW"
|
|
case 0x8764:
|
|
return "BUFFER_SIZE"
|
|
case 0x8765:
|
|
return "BUFFER_USAGE"
|
|
case 0x8626:
|
|
return "CURRENT_VERTEX_ATTRIB"
|
|
case 0x404:
|
|
return "FRONT"
|
|
case 0x405:
|
|
return "BACK"
|
|
case 0x408:
|
|
return "FRONT_AND_BACK"
|
|
case 0xde1:
|
|
return "TEXTURE_2D"
|
|
case 0xb44:
|
|
return "CULL_FACE"
|
|
case 0xbe2:
|
|
return "BLEND"
|
|
case 0xbd0:
|
|
return "DITHER"
|
|
case 0xb90:
|
|
return "STENCIL_TEST"
|
|
case 0xb71:
|
|
return "DEPTH_TEST"
|
|
case 0xc11:
|
|
return "SCISSOR_TEST"
|
|
case 0x8037:
|
|
return "POLYGON_OFFSET_FILL"
|
|
case 0x809e:
|
|
return "SAMPLE_ALPHA_TO_COVERAGE"
|
|
case 0x80a0:
|
|
return "SAMPLE_COVERAGE"
|
|
case 0x500:
|
|
return "INVALID_ENUM"
|
|
case 0x501:
|
|
return "INVALID_VALUE"
|
|
case 0x502:
|
|
return "INVALID_OPERATION"
|
|
case 0x505:
|
|
return "OUT_OF_MEMORY"
|
|
case 0x900:
|
|
return "CW"
|
|
case 0x901:
|
|
return "CCW"
|
|
case 0xb21:
|
|
return "LINE_WIDTH"
|
|
case 0x846d:
|
|
return "ALIASED_POINT_SIZE_RANGE"
|
|
case 0x846e:
|
|
return "ALIASED_LINE_WIDTH_RANGE"
|
|
case 0xb45:
|
|
return "CULL_FACE_MODE"
|
|
case 0xb46:
|
|
return "FRONT_FACE"
|
|
case 0xb70:
|
|
return "DEPTH_RANGE"
|
|
case 0xb72:
|
|
return "DEPTH_WRITEMASK"
|
|
case 0xb73:
|
|
return "DEPTH_CLEAR_VALUE"
|
|
case 0xb74:
|
|
return "DEPTH_FUNC"
|
|
case 0xb91:
|
|
return "STENCIL_CLEAR_VALUE"
|
|
case 0xb92:
|
|
return "STENCIL_FUNC"
|
|
case 0xb94:
|
|
return "STENCIL_FAIL"
|
|
case 0xb95:
|
|
return "STENCIL_PASS_DEPTH_FAIL"
|
|
case 0xb96:
|
|
return "STENCIL_PASS_DEPTH_PASS"
|
|
case 0xb97:
|
|
return "STENCIL_REF"
|
|
case 0xb93:
|
|
return "STENCIL_VALUE_MASK"
|
|
case 0xb98:
|
|
return "STENCIL_WRITEMASK"
|
|
case 0x8800:
|
|
return "STENCIL_BACK_FUNC"
|
|
case 0x8801:
|
|
return "STENCIL_BACK_FAIL"
|
|
case 0x8802:
|
|
return "STENCIL_BACK_PASS_DEPTH_FAIL"
|
|
case 0x8803:
|
|
return "STENCIL_BACK_PASS_DEPTH_PASS"
|
|
case 0x8ca3:
|
|
return "STENCIL_BACK_REF"
|
|
case 0x8ca4:
|
|
return "STENCIL_BACK_VALUE_MASK"
|
|
case 0x8ca5:
|
|
return "STENCIL_BACK_WRITEMASK"
|
|
case 0xba2:
|
|
return "VIEWPORT"
|
|
case 0xc10:
|
|
return "SCISSOR_BOX"
|
|
case 0xc22:
|
|
return "COLOR_CLEAR_VALUE"
|
|
case 0xc23:
|
|
return "COLOR_WRITEMASK"
|
|
case 0xcf5:
|
|
return "UNPACK_ALIGNMENT"
|
|
case 0xd05:
|
|
return "PACK_ALIGNMENT"
|
|
case 0xd33:
|
|
return "MAX_TEXTURE_SIZE"
|
|
case 0xd3a:
|
|
return "MAX_VIEWPORT_DIMS"
|
|
case 0xd50:
|
|
return "SUBPIXEL_BITS"
|
|
case 0xd52:
|
|
return "RED_BITS"
|
|
case 0xd53:
|
|
return "GREEN_BITS"
|
|
case 0xd54:
|
|
return "BLUE_BITS"
|
|
case 0xd55:
|
|
return "ALPHA_BITS"
|
|
case 0xd56:
|
|
return "DEPTH_BITS"
|
|
case 0xd57:
|
|
return "STENCIL_BITS"
|
|
case 0x2a00:
|
|
return "POLYGON_OFFSET_UNITS"
|
|
case 0x8038:
|
|
return "POLYGON_OFFSET_FACTOR"
|
|
case 0x8069:
|
|
return "TEXTURE_BINDING_2D"
|
|
case 0x80a8:
|
|
return "SAMPLE_BUFFERS"
|
|
case 0x80a9:
|
|
return "SAMPLES"
|
|
case 0x80aa:
|
|
return "SAMPLE_COVERAGE_VALUE"
|
|
case 0x80ab:
|
|
return "SAMPLE_COVERAGE_INVERT"
|
|
case 0x86a2:
|
|
return "NUM_COMPRESSED_TEXTURE_FORMATS"
|
|
case 0x86a3:
|
|
return "COMPRESSED_TEXTURE_FORMATS"
|
|
case 0x1100:
|
|
return "DONT_CARE"
|
|
case 0x1101:
|
|
return "FASTEST"
|
|
case 0x1102:
|
|
return "NICEST"
|
|
case 0x8192:
|
|
return "GENERATE_MIPMAP_HINT"
|
|
case 0x1400:
|
|
return "BYTE"
|
|
case 0x1401:
|
|
return "UNSIGNED_BYTE"
|
|
case 0x1402:
|
|
return "SHORT"
|
|
case 0x1403:
|
|
return "UNSIGNED_SHORT"
|
|
case 0x1404:
|
|
return "INT"
|
|
case 0x1405:
|
|
return "UNSIGNED_INT"
|
|
case 0x1406:
|
|
return "FLOAT"
|
|
case 0x140c:
|
|
return "FIXED"
|
|
case 0x1902:
|
|
return "DEPTH_COMPONENT"
|
|
case 0x1906:
|
|
return "ALPHA"
|
|
case 0x1907:
|
|
return "RGB"
|
|
case 0x1908:
|
|
return "RGBA"
|
|
case 0x1909:
|
|
return "LUMINANCE"
|
|
case 0x190a:
|
|
return "LUMINANCE_ALPHA"
|
|
case 0x8033:
|
|
return "UNSIGNED_SHORT_4_4_4_4"
|
|
case 0x8034:
|
|
return "UNSIGNED_SHORT_5_5_5_1"
|
|
case 0x8363:
|
|
return "UNSIGNED_SHORT_5_6_5"
|
|
case 0x8869:
|
|
return "MAX_VERTEX_ATTRIBS"
|
|
case 0x8dfb:
|
|
return "MAX_VERTEX_UNIFORM_VECTORS"
|
|
case 0x8dfc:
|
|
return "MAX_VARYING_VECTORS"
|
|
case 0x8b4d:
|
|
return "MAX_COMBINED_TEXTURE_IMAGE_UNITS"
|
|
case 0x8b4c:
|
|
return "MAX_VERTEX_TEXTURE_IMAGE_UNITS"
|
|
case 0x8872:
|
|
return "MAX_TEXTURE_IMAGE_UNITS"
|
|
case 0x8dfd:
|
|
return "MAX_FRAGMENT_UNIFORM_VECTORS"
|
|
case 0x8b4f:
|
|
return "SHADER_TYPE"
|
|
case 0x8b80:
|
|
return "DELETE_STATUS"
|
|
case 0x8b82:
|
|
return "LINK_STATUS"
|
|
case 0x8b83:
|
|
return "VALIDATE_STATUS"
|
|
case 0x8b85:
|
|
return "ATTACHED_SHADERS"
|
|
case 0x8b86:
|
|
return "ACTIVE_UNIFORMS"
|
|
case 0x8b87:
|
|
return "ACTIVE_UNIFORM_MAX_LENGTH"
|
|
case 0x8b89:
|
|
return "ACTIVE_ATTRIBUTES"
|
|
case 0x8b8a:
|
|
return "ACTIVE_ATTRIBUTE_MAX_LENGTH"
|
|
case 0x8b8c:
|
|
return "SHADING_LANGUAGE_VERSION"
|
|
case 0x8b8d:
|
|
return "CURRENT_PROGRAM"
|
|
case 0x200:
|
|
return "NEVER"
|
|
case 0x201:
|
|
return "LESS"
|
|
case 0x202:
|
|
return "EQUAL"
|
|
case 0x203:
|
|
return "LEQUAL"
|
|
case 0x204:
|
|
return "GREATER"
|
|
case 0x205:
|
|
return "NOTEQUAL"
|
|
case 0x206:
|
|
return "GEQUAL"
|
|
case 0x207:
|
|
return "ALWAYS"
|
|
case 0x1e00:
|
|
return "KEEP"
|
|
case 0x1e01:
|
|
return "REPLACE"
|
|
case 0x1e02:
|
|
return "INCR"
|
|
case 0x1e03:
|
|
return "DECR"
|
|
case 0x150a:
|
|
return "INVERT"
|
|
case 0x8507:
|
|
return "INCR_WRAP"
|
|
case 0x8508:
|
|
return "DECR_WRAP"
|
|
case 0x1f00:
|
|
return "VENDOR"
|
|
case 0x1f01:
|
|
return "RENDERER"
|
|
case 0x1f02:
|
|
return "VERSION"
|
|
case 0x1f03:
|
|
return "EXTENSIONS"
|
|
case 0x2600:
|
|
return "NEAREST"
|
|
case 0x2601:
|
|
return "LINEAR"
|
|
case 0x2700:
|
|
return "NEAREST_MIPMAP_NEAREST"
|
|
case 0x2701:
|
|
return "LINEAR_MIPMAP_NEAREST"
|
|
case 0x2702:
|
|
return "NEAREST_MIPMAP_LINEAR"
|
|
case 0x2703:
|
|
return "LINEAR_MIPMAP_LINEAR"
|
|
case 0x2800:
|
|
return "TEXTURE_MAG_FILTER"
|
|
case 0x2801:
|
|
return "TEXTURE_MIN_FILTER"
|
|
case 0x2802:
|
|
return "TEXTURE_WRAP_S"
|
|
case 0x2803:
|
|
return "TEXTURE_WRAP_T"
|
|
case 0x1702:
|
|
return "TEXTURE"
|
|
case 0x8513:
|
|
return "TEXTURE_CUBE_MAP"
|
|
case 0x8514:
|
|
return "TEXTURE_BINDING_CUBE_MAP"
|
|
case 0x8515:
|
|
return "TEXTURE_CUBE_MAP_POSITIVE_X"
|
|
case 0x8516:
|
|
return "TEXTURE_CUBE_MAP_NEGATIVE_X"
|
|
case 0x8517:
|
|
return "TEXTURE_CUBE_MAP_POSITIVE_Y"
|
|
case 0x8518:
|
|
return "TEXTURE_CUBE_MAP_NEGATIVE_Y"
|
|
case 0x8519:
|
|
return "TEXTURE_CUBE_MAP_POSITIVE_Z"
|
|
case 0x851a:
|
|
return "TEXTURE_CUBE_MAP_NEGATIVE_Z"
|
|
case 0x851c:
|
|
return "MAX_CUBE_MAP_TEXTURE_SIZE"
|
|
case 0x84c0:
|
|
return "TEXTURE0"
|
|
case 0x84c1:
|
|
return "TEXTURE1"
|
|
case 0x84c2:
|
|
return "TEXTURE2"
|
|
case 0x84c3:
|
|
return "TEXTURE3"
|
|
case 0x84c4:
|
|
return "TEXTURE4"
|
|
case 0x84c5:
|
|
return "TEXTURE5"
|
|
case 0x84c6:
|
|
return "TEXTURE6"
|
|
case 0x84c7:
|
|
return "TEXTURE7"
|
|
case 0x84c8:
|
|
return "TEXTURE8"
|
|
case 0x84c9:
|
|
return "TEXTURE9"
|
|
case 0x84ca:
|
|
return "TEXTURE10"
|
|
case 0x84cb:
|
|
return "TEXTURE11"
|
|
case 0x84cc:
|
|
return "TEXTURE12"
|
|
case 0x84cd:
|
|
return "TEXTURE13"
|
|
case 0x84ce:
|
|
return "TEXTURE14"
|
|
case 0x84cf:
|
|
return "TEXTURE15"
|
|
case 0x84d0:
|
|
return "TEXTURE16"
|
|
case 0x84d1:
|
|
return "TEXTURE17"
|
|
case 0x84d2:
|
|
return "TEXTURE18"
|
|
case 0x84d3:
|
|
return "TEXTURE19"
|
|
case 0x84d4:
|
|
return "TEXTURE20"
|
|
case 0x84d5:
|
|
return "TEXTURE21"
|
|
case 0x84d6:
|
|
return "TEXTURE22"
|
|
case 0x84d7:
|
|
return "TEXTURE23"
|
|
case 0x84d8:
|
|
return "TEXTURE24"
|
|
case 0x84d9:
|
|
return "TEXTURE25"
|
|
case 0x84da:
|
|
return "TEXTURE26"
|
|
case 0x84db:
|
|
return "TEXTURE27"
|
|
case 0x84dc:
|
|
return "TEXTURE28"
|
|
case 0x84dd:
|
|
return "TEXTURE29"
|
|
case 0x84de:
|
|
return "TEXTURE30"
|
|
case 0x84df:
|
|
return "TEXTURE31"
|
|
case 0x84e0:
|
|
return "ACTIVE_TEXTURE"
|
|
case 0x2901:
|
|
return "REPEAT"
|
|
case 0x812f:
|
|
return "CLAMP_TO_EDGE"
|
|
case 0x8370:
|
|
return "MIRRORED_REPEAT"
|
|
case 0x8622:
|
|
return "VERTEX_ATTRIB_ARRAY_ENABLED"
|
|
case 0x8623:
|
|
return "VERTEX_ATTRIB_ARRAY_SIZE"
|
|
case 0x8624:
|
|
return "VERTEX_ATTRIB_ARRAY_STRIDE"
|
|
case 0x8625:
|
|
return "VERTEX_ATTRIB_ARRAY_TYPE"
|
|
case 0x886a:
|
|
return "VERTEX_ATTRIB_ARRAY_NORMALIZED"
|
|
case 0x8645:
|
|
return "VERTEX_ATTRIB_ARRAY_POINTER"
|
|
case 0x889f:
|
|
return "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"
|
|
case 0x8b9a:
|
|
return "IMPLEMENTATION_COLOR_READ_TYPE"
|
|
case 0x8b9b:
|
|
return "IMPLEMENTATION_COLOR_READ_FORMAT"
|
|
case 0x8b81:
|
|
return "COMPILE_STATUS"
|
|
case 0x8b84:
|
|
return "INFO_LOG_LENGTH"
|
|
case 0x8b88:
|
|
return "SHADER_SOURCE_LENGTH"
|
|
case 0x8dfa:
|
|
return "SHADER_COMPILER"
|
|
case 0x8df8:
|
|
return "SHADER_BINARY_FORMATS"
|
|
case 0x8df9:
|
|
return "NUM_SHADER_BINARY_FORMATS"
|
|
case 0x8df0:
|
|
return "LOW_FLOAT"
|
|
case 0x8df1:
|
|
return "MEDIUM_FLOAT"
|
|
case 0x8df2:
|
|
return "HIGH_FLOAT"
|
|
case 0x8df3:
|
|
return "LOW_INT"
|
|
case 0x8df4:
|
|
return "MEDIUM_INT"
|
|
case 0x8df5:
|
|
return "HIGH_INT"
|
|
case 0x8d40:
|
|
return "FRAMEBUFFER"
|
|
case 0x8d41:
|
|
return "RENDERBUFFER"
|
|
case 0x8056:
|
|
return "RGBA4"
|
|
case 0x8057:
|
|
return "RGB5_A1"
|
|
case 0x8d62:
|
|
return "RGB565"
|
|
case 0x81a5:
|
|
return "DEPTH_COMPONENT16"
|
|
case 0x8d48:
|
|
return "STENCIL_INDEX8"
|
|
case 0x8d42:
|
|
return "RENDERBUFFER_WIDTH"
|
|
case 0x8d43:
|
|
return "RENDERBUFFER_HEIGHT"
|
|
case 0x8d44:
|
|
return "RENDERBUFFER_INTERNAL_FORMAT"
|
|
case 0x8d50:
|
|
return "RENDERBUFFER_RED_SIZE"
|
|
case 0x8d51:
|
|
return "RENDERBUFFER_GREEN_SIZE"
|
|
case 0x8d52:
|
|
return "RENDERBUFFER_BLUE_SIZE"
|
|
case 0x8d53:
|
|
return "RENDERBUFFER_ALPHA_SIZE"
|
|
case 0x8d54:
|
|
return "RENDERBUFFER_DEPTH_SIZE"
|
|
case 0x8d55:
|
|
return "RENDERBUFFER_STENCIL_SIZE"
|
|
case 0x8cd0:
|
|
return "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"
|
|
case 0x8cd1:
|
|
return "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"
|
|
case 0x8cd2:
|
|
return "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"
|
|
case 0x8cd3:
|
|
return "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"
|
|
case 0x8ce0:
|
|
return "COLOR_ATTACHMENT0"
|
|
case 0x8d00:
|
|
return "DEPTH_ATTACHMENT"
|
|
case 0x8d20:
|
|
return "STENCIL_ATTACHMENT"
|
|
case 0x8cd5:
|
|
return "FRAMEBUFFER_COMPLETE"
|
|
case 0x8cd6:
|
|
return "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"
|
|
case 0x8cd7:
|
|
return "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"
|
|
case 0x8cd9:
|
|
return "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"
|
|
case 0x8cdd:
|
|
return "FRAMEBUFFER_UNSUPPORTED"
|
|
case 0x8ca6:
|
|
return "FRAMEBUFFER_BINDING"
|
|
case 0x8ca7:
|
|
return "RENDERBUFFER_BINDING"
|
|
case 0x84e8:
|
|
return "MAX_RENDERBUFFER_SIZE"
|
|
case 0x506:
|
|
return "INVALID_FRAMEBUFFER_OPERATION"
|
|
case 0x100:
|
|
return "DEPTH_BUFFER_BIT"
|
|
case 0x400:
|
|
return "STENCIL_BUFFER_BIT"
|
|
case 0x4000:
|
|
return "COLOR_BUFFER_BIT"
|
|
case 0x8b50:
|
|
return "FLOAT_VEC2"
|
|
case 0x8b51:
|
|
return "FLOAT_VEC3"
|
|
case 0x8b52:
|
|
return "FLOAT_VEC4"
|
|
case 0x8b53:
|
|
return "INT_VEC2"
|
|
case 0x8b54:
|
|
return "INT_VEC3"
|
|
case 0x8b55:
|
|
return "INT_VEC4"
|
|
case 0x8b56:
|
|
return "BOOL"
|
|
case 0x8b57:
|
|
return "BOOL_VEC2"
|
|
case 0x8b58:
|
|
return "BOOL_VEC3"
|
|
case 0x8b59:
|
|
return "BOOL_VEC4"
|
|
case 0x8b5a:
|
|
return "FLOAT_MAT2"
|
|
case 0x8b5b:
|
|
return "FLOAT_MAT3"
|
|
case 0x8b5c:
|
|
return "FLOAT_MAT4"
|
|
case 0x8b5e:
|
|
return "SAMPLER_2D"
|
|
case 0x8b60:
|
|
return "SAMPLER_CUBE"
|
|
case 0x8b30:
|
|
return "FRAGMENT_SHADER"
|
|
case 0x8b31:
|
|
return "VERTEX_SHADER"
|
|
default:
|
|
return fmt.Sprintf("gl.Enum(0x%x)", uint32(v))
|
|
}
|
|
}
|
|
|
|
func ActiveTexture(texture Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ActiveTexture(%v) %v", texture, errstr)
|
|
}()
|
|
C.glActiveTexture(texture.c())
|
|
}
|
|
|
|
func AttachShader(p Program, s Shader) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.AttachShader(%v, %v) %v", p, s, errstr)
|
|
}()
|
|
C.glAttachShader(p.c(), s.c())
|
|
}
|
|
|
|
func BindAttribLocation(p Program, a Attrib, name string) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BindAttribLocation(%v, %v, %v) %v", p, a, name, errstr)
|
|
}()
|
|
str := unsafe.Pointer(C.CString(name))
|
|
defer C.free(str)
|
|
C.glBindAttribLocation(p.c(), a.c(), (*C.GLchar)(str))
|
|
}
|
|
|
|
func BindBuffer(target Enum, b Buffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BindBuffer(%v, %v) %v", target, b, errstr)
|
|
}()
|
|
C.glBindBuffer(target.c(), b.c())
|
|
}
|
|
|
|
func BindFramebuffer(target Enum, fb Framebuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BindFramebuffer(%v, %v) %v", target, fb, errstr)
|
|
}()
|
|
C.glBindFramebuffer(target.c(), fb.c())
|
|
}
|
|
|
|
func BindRenderbuffer(target Enum, rb Renderbuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BindRenderbuffer(%v, %v) %v", target, rb, errstr)
|
|
}()
|
|
C.glBindRenderbuffer(target.c(), rb.c())
|
|
}
|
|
|
|
func BindTexture(target Enum, t Texture) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BindTexture(%v, %v) %v", target, t, errstr)
|
|
}()
|
|
C.glBindTexture(target.c(), t.c())
|
|
}
|
|
|
|
func BlendColor(red, green, blue, alpha float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BlendColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
|
|
}()
|
|
C.glBlendColor(C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha))
|
|
}
|
|
|
|
func BlendEquation(mode Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BlendEquation(%v) %v", mode, errstr)
|
|
}()
|
|
C.glBlendEquation(mode.c())
|
|
}
|
|
|
|
func BlendEquationSeparate(modeRGB, modeAlpha Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BlendEquationSeparate(%v, %v) %v", modeRGB, modeAlpha, errstr)
|
|
}()
|
|
C.glBlendEquationSeparate(modeRGB.c(), modeAlpha.c())
|
|
}
|
|
|
|
func BlendFunc(sfactor, dfactor Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BlendFunc(%v, %v) %v", sfactor, dfactor, errstr)
|
|
}()
|
|
C.glBlendFunc(sfactor.c(), dfactor.c())
|
|
}
|
|
|
|
func BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BlendFuncSeparate(%v, %v, %v, %v) %v", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha, errstr)
|
|
}()
|
|
C.glBlendFuncSeparate(sfactorRGB.c(), dfactorRGB.c(), sfactorAlpha.c(), dfactorAlpha.c())
|
|
}
|
|
|
|
func BufferData(target Enum, usage Enum, src []byte) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BufferData(%v, %v, len(%d)) %v", target, usage, len(src), errstr)
|
|
}()
|
|
C.glBufferData(target.c(), C.GLsizeiptr(len(src)), unsafe.Pointer(&src[0]), usage.c())
|
|
}
|
|
|
|
func BufferInit(target Enum, size int, usage Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BufferInit(%v, %v, %v) %v", target, size, usage, errstr)
|
|
}()
|
|
C.glBufferData(target.c(), C.GLsizeiptr(size), nil, usage.c())
|
|
}
|
|
|
|
func BufferSubData(target Enum, offset int, data []byte) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.BufferSubData(%v, %v, len(%d)) %v", target, offset, len(data), errstr)
|
|
}()
|
|
C.glBufferSubData(target.c(), C.GLintptr(offset), C.GLsizeiptr(len(data)), unsafe.Pointer(&data[0]))
|
|
}
|
|
|
|
func CheckFramebufferStatus(target Enum) (r0 Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CheckFramebufferStatus(%v) %v%v", target, r0, errstr)
|
|
}()
|
|
return Enum(C.glCheckFramebufferStatus(target.c()))
|
|
}
|
|
|
|
func Clear(mask Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Clear(%v) %v", mask, errstr)
|
|
}()
|
|
C.glClear(C.GLbitfield(mask))
|
|
}
|
|
|
|
func ClearColor(red, green, blue, alpha float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ClearColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
|
|
}()
|
|
C.glClearColor(C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha))
|
|
}
|
|
|
|
func ClearDepthf(d float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ClearDepthf(%v) %v", d, errstr)
|
|
}()
|
|
C.glClearDepthf(C.GLfloat(d))
|
|
}
|
|
|
|
func ClearStencil(s int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ClearStencil(%v) %v", s, errstr)
|
|
}()
|
|
C.glClearStencil(C.GLint(s))
|
|
}
|
|
|
|
func ColorMask(red, green, blue, alpha bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ColorMask(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
|
|
}()
|
|
C.glColorMask(glBoolean(red), glBoolean(green), glBoolean(blue), glBoolean(alpha))
|
|
}
|
|
|
|
func CompileShader(s Shader) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CompileShader(%v) %v", s, errstr)
|
|
}()
|
|
C.glCompileShader(s.c())
|
|
}
|
|
|
|
func CompressedTexImage2D(target Enum, level int, internalformat Enum, width, height, border int, data []byte) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CompressedTexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, internalformat, width, height, border, len(data), errstr)
|
|
}()
|
|
C.glCompressedTexImage2D(target.c(), C.GLint(level), internalformat.c(), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(len(data)), unsafe.Pointer(&data[0]))
|
|
}
|
|
|
|
func CompressedTexSubImage2D(target Enum, level, xoffset, yoffset, width, height int, format Enum, data []byte) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CompressedTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, xoffset, yoffset, width, height, format, len(data), errstr)
|
|
}()
|
|
C.glCompressedTexSubImage2D(target.c(), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), format.c(), C.GLsizei(len(data)), unsafe.Pointer(&data[0]))
|
|
}
|
|
|
|
func CopyTexImage2D(target Enum, level int, internalformat Enum, x, y, width, height, border int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CopyTexImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, internalformat, x, y, width, height, border, errstr)
|
|
}()
|
|
C.glCopyTexImage2D(target.c(), C.GLint(level), internalformat.c(), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border))
|
|
}
|
|
|
|
func CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CopyTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, xoffset, yoffset, x, y, width, height, errstr)
|
|
}()
|
|
C.glCopyTexSubImage2D(target.c(), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
|
|
}
|
|
|
|
func CreateProgram() (r0 Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CreateProgram() %v%v", r0, errstr)
|
|
}()
|
|
return Program(C.glCreateProgram())
|
|
}
|
|
|
|
func CreateShader(ty Enum) (r0 Shader) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CreateShader(%v) %v%v", ty, r0, errstr)
|
|
}()
|
|
return Shader(C.glCreateShader(ty.c()))
|
|
}
|
|
|
|
func CullFace(mode Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.CullFace(%v) %v", mode, errstr)
|
|
}()
|
|
C.glCullFace(mode.c())
|
|
}
|
|
|
|
func DeleteBuffers(v []Buffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DeleteBuffers(%v) %v", v, errstr)
|
|
}()
|
|
C.glDeleteBuffers(C.GLsizei(len(v)), (*C.GLuint)(unsafe.Pointer(&v[0])))
|
|
}
|
|
|
|
func DeleteFramebuffers(v []Framebuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DeleteFramebuffers(%v) %v", v, errstr)
|
|
}()
|
|
C.glDeleteFramebuffers(C.GLsizei(len(v)), (*C.GLuint)(unsafe.Pointer(&v[0])))
|
|
}
|
|
|
|
func DeleteProgram(p Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DeleteProgram(%v) %v", p, errstr)
|
|
}()
|
|
C.glDeleteProgram(p.c())
|
|
}
|
|
|
|
func DeleteRenderbuffers(v []Renderbuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DeleteRenderbuffers(%v) %v", v, errstr)
|
|
}()
|
|
C.glDeleteRenderbuffers(C.GLsizei(len(v)), (*C.GLuint)(unsafe.Pointer(&v[0])))
|
|
}
|
|
|
|
func DeleteShader(s Shader) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DeleteShader(%v) %v", s, errstr)
|
|
}()
|
|
C.glDeleteShader(s.c())
|
|
}
|
|
|
|
func DeleteTextures(v []Texture) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DeleteTextures(%v) %v", v, errstr)
|
|
}()
|
|
C.glDeleteTextures(C.GLsizei(len(v)), (*C.GLuint)(unsafe.Pointer(&v[0])))
|
|
}
|
|
|
|
func DepthFunc(fn Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DepthFunc(%v) %v", fn, errstr)
|
|
}()
|
|
C.glDepthFunc(fn.c())
|
|
}
|
|
|
|
func DepthMask(flag bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DepthMask(%v) %v", flag, errstr)
|
|
}()
|
|
C.glDepthMask(glBoolean(flag))
|
|
}
|
|
|
|
func DepthRangef(n, f float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DepthRangef(%v, %v) %v", n, f, errstr)
|
|
}()
|
|
C.glDepthRangef(C.GLfloat(n), C.GLfloat(f))
|
|
}
|
|
|
|
func DetachShader(p Program, s Shader) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DetachShader(%v, %v) %v", p, s, errstr)
|
|
}()
|
|
C.glDetachShader(p.c(), s.c())
|
|
}
|
|
|
|
func Disable(cap Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Disable(%v) %v", cap, errstr)
|
|
}()
|
|
C.glDisable(cap.c())
|
|
}
|
|
|
|
func DisableVertexAttribArray(index Attrib) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DisableVertexAttribArray(%v) %v", index, errstr)
|
|
}()
|
|
C.glDisableVertexAttribArray(index.c())
|
|
}
|
|
|
|
func DrawArrays(mode Enum, first, count int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DrawArrays(%v, %v, %v) %v", mode, first, count, errstr)
|
|
}()
|
|
C.glDrawArrays(mode.c(), C.GLint(first), C.GLsizei(count))
|
|
}
|
|
|
|
func DrawElements(mode, ty Enum, offset, count int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.DrawElements(%v, %v, %v, %v) %v", mode, ty, offset, count, errstr)
|
|
}()
|
|
C.glDrawElements(mode.c(), C.GLsizei(count), ty.c(), unsafe.Pointer(uintptr(offset)))
|
|
}
|
|
|
|
func Enable(cap Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Enable(%v) %v", cap, errstr)
|
|
}()
|
|
C.glEnable(cap.c())
|
|
}
|
|
|
|
func EnableVertexAttribArray(index Attrib) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.EnableVertexAttribArray(%v) %v", index, errstr)
|
|
}()
|
|
C.glEnableVertexAttribArray(index.c())
|
|
}
|
|
|
|
func Finish() {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Finish() %v", errstr)
|
|
}()
|
|
C.glFinish()
|
|
}
|
|
|
|
func Flush() {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Flush() %v", errstr)
|
|
}()
|
|
C.glFlush()
|
|
}
|
|
|
|
func FramebufferRenderbuffer(target, attachment, rbTarget Enum, rb Renderbuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.FramebufferRenderbuffer(%v, %v, %v, %v) %v", target, attachment, rbTarget, rb, errstr)
|
|
}()
|
|
C.glFramebufferRenderbuffer(target.c(), attachment.c(), rbTarget.c(), rb.c())
|
|
}
|
|
|
|
func FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.FramebufferTexture2D(%v, %v, %v, %v, %v) %v", target, attachment, texTarget, t, level, errstr)
|
|
}()
|
|
C.glFramebufferTexture2D(target.c(), attachment.c(), texTarget.c(), t.c(), C.GLint(level))
|
|
}
|
|
|
|
func FrontFace(mode Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.FrontFace(%v) %v", mode, errstr)
|
|
}()
|
|
C.glFrontFace(mode.c())
|
|
}
|
|
|
|
func GenBuffers(n int) (r0 []Buffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GenBuffers(%v) %v%v", n, r0, errstr)
|
|
}()
|
|
buf := make([]Buffer, n)
|
|
C.glGenBuffers(C.GLsizei(n), (*C.GLuint)(&buf[0]))
|
|
return buf
|
|
}
|
|
|
|
func GenerateMipmap(target Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GenerateMipmap(%v) %v", target, errstr)
|
|
}()
|
|
C.glGenerateMipmap(target.c())
|
|
}
|
|
|
|
func GenFramebuffers(n int) (r0 []Framebuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GenFramebuffers(%v) %v%v", n, r0, errstr)
|
|
}()
|
|
buf := make([]Framebuffer, n)
|
|
C.glGenFramebuffers(C.GLsizei(n), (*C.GLuint)(&buf[0]))
|
|
return buf
|
|
}
|
|
|
|
func GenRenderbuffers(n int) (r0 []Renderbuffer) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GenRenderbuffers(%v) %v%v", n, r0, errstr)
|
|
}()
|
|
buf := make([]Renderbuffer, n)
|
|
C.glGenRenderbuffers(C.GLsizei(n), (*C.GLuint)(&buf[0]))
|
|
return buf
|
|
}
|
|
|
|
func GenTextures(n int) (r0 []Texture) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GenTextures(%v) %v%v", n, r0, errstr)
|
|
}()
|
|
buf := make([]Texture, n)
|
|
C.glGenTextures(C.GLsizei(n), (*C.GLuint)(&buf[0]))
|
|
return buf
|
|
}
|
|
|
|
func GetActiveAttrib(p Program, a Attrib) (name string, size int, ty Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetActiveAttrib(%v, %v) (%v, %v, %v) %v", p, a, name, size, ty, errstr)
|
|
}()
|
|
bufSize := GetProgrami(p, ACTIVE_ATTRIBUTE_MAX_LENGTH)
|
|
buf := C.malloc(C.size_t(bufSize))
|
|
defer C.free(buf)
|
|
var cSize C.GLint
|
|
var cType C.GLenum
|
|
C.glGetActiveAttrib(p.c(), a.c(), C.GLsizei(bufSize), nil, &cSize, &cType, (*C.GLchar)(buf))
|
|
return C.GoString((*C.char)(buf)), int(cSize), Enum(cType)
|
|
}
|
|
|
|
func GetActiveUniform(p Program, u Uniform) (name string, size int, ty Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetActiveUniform(%v, %v) (%v, %v, %v) %v", p, u, name, size, ty, errstr)
|
|
}()
|
|
bufSize := GetProgrami(p, ACTIVE_UNIFORM_MAX_LENGTH)
|
|
buf := C.malloc(C.size_t(bufSize))
|
|
defer C.free(buf)
|
|
var cSize C.GLint
|
|
var cType C.GLenum
|
|
C.glGetActiveUniform(p.c(), C.GLuint(u), C.GLsizei(bufSize), nil, &cSize, &cType, (*C.GLchar)(buf))
|
|
return C.GoString((*C.char)(buf)), int(cSize), Enum(cType)
|
|
}
|
|
|
|
func GetAttachedShaders(p Program) (r0 []Shader) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetAttachedShaders(%v) %v%v", p, r0, errstr)
|
|
}()
|
|
shadersLen := GetProgrami(p, ATTACHED_SHADERS)
|
|
buf := make([]Shader, shadersLen)
|
|
var n C.GLsizei
|
|
C.glGetAttachedShaders(p.c(), C.GLsizei(shadersLen), &n, (*C.GLuint)(&buf[0]))
|
|
return buf[:int(n)]
|
|
}
|
|
|
|
func GetAttribLocation(p Program, name string) (r0 Attrib) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetAttribLocation(%v, %v) %v%v", p, name, r0, errstr)
|
|
}()
|
|
str := unsafe.Pointer(C.CString(name))
|
|
defer C.free(str)
|
|
return Attrib(C.glGetAttribLocation(p.c(), (*C.GLchar)(str)))
|
|
}
|
|
|
|
func GetBooleanv(dst []bool, pname Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetBooleanv(%v, %v) %v", dst, pname, errstr)
|
|
}()
|
|
buf := make([]C.GLboolean, len(dst))
|
|
C.glGetBooleanv(pname.c(), &buf[0])
|
|
for i, v := range buf {
|
|
dst[i] = v != 0
|
|
}
|
|
}
|
|
|
|
func GetFloatv(dst []float32, pname Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetFloatv(len(%d), %v) %v", len(dst), pname, errstr)
|
|
}()
|
|
C.glGetFloatv(pname.c(), (*C.GLfloat)(&dst[0]))
|
|
}
|
|
|
|
func GetIntegerv(pname Enum, data []int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetIntegerv(%v, %v) %v", pname, data, errstr)
|
|
}()
|
|
buf := make([]C.GLint, len(data))
|
|
C.glGetIntegerv(pname.c(), &buf[0])
|
|
for i, v := range buf {
|
|
data[i] = int32(v)
|
|
}
|
|
}
|
|
|
|
func GetInteger(pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetInteger(%v) %v%v", pname, r0, errstr)
|
|
}()
|
|
var v C.GLint
|
|
C.glGetIntegerv(pname.c(), &v)
|
|
return int(v)
|
|
}
|
|
|
|
func GetBufferParameteri(target, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetBufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)
|
|
}()
|
|
var params C.GLint
|
|
C.glGetBufferParameteriv(target.c(), pname.c(), ¶ms)
|
|
return int(params)
|
|
}
|
|
|
|
func GetError() (r0 Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetError() %v%v", r0, errstr)
|
|
}()
|
|
return Enum(C.glGetError())
|
|
}
|
|
|
|
func GetFramebufferAttachmentParameteri(target, attachment, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetFramebufferAttachmentParameteri(%v, %v, %v) %v%v", target, attachment, pname, r0, errstr)
|
|
}()
|
|
var params C.GLint
|
|
C.glGetFramebufferAttachmentParameteriv(target.c(), attachment.c(), pname.c(), ¶ms)
|
|
return int(params)
|
|
}
|
|
|
|
func GetProgrami(p Program, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetProgrami(%v, %v) %v%v", p, pname, r0, errstr)
|
|
}()
|
|
var params C.GLint
|
|
C.glGetProgramiv(p.c(), pname.c(), ¶ms)
|
|
return int(params)
|
|
}
|
|
|
|
func GetProgramInfoLog(p Program) (r0 string) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetProgramInfoLog(%v) %v%v", p, r0, errstr)
|
|
}()
|
|
infoLen := GetProgrami(p, INFO_LOG_LENGTH)
|
|
buf := C.malloc(C.size_t(infoLen))
|
|
C.free(buf)
|
|
C.glGetProgramInfoLog(p.c(), C.GLsizei(infoLen), nil, (*C.GLchar)(buf))
|
|
return C.GoString((*C.char)(buf))
|
|
}
|
|
|
|
func GetRenderbufferParameteri(target, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetRenderbufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)
|
|
}()
|
|
var params C.GLint
|
|
C.glGetRenderbufferParameteriv(target.c(), pname.c(), ¶ms)
|
|
return int(params)
|
|
}
|
|
|
|
func GetShaderi(s Shader, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetShaderi(%v, %v) %v%v", s, pname, r0, errstr)
|
|
}()
|
|
var params C.GLint
|
|
C.glGetShaderiv(s.c(), pname.c(), ¶ms)
|
|
return int(params)
|
|
}
|
|
|
|
func GetShaderInfoLog(s Shader) (r0 string) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetShaderInfoLog(%v) %v%v", s, r0, errstr)
|
|
}()
|
|
infoLen := GetShaderi(s, INFO_LOG_LENGTH)
|
|
buf := C.malloc(C.size_t(infoLen))
|
|
defer C.free(buf)
|
|
C.glGetShaderInfoLog(s.c(), C.GLsizei(infoLen), nil, (*C.GLchar)(buf))
|
|
return C.GoString((*C.char)(buf))
|
|
}
|
|
|
|
func GetShaderPrecisionFormat(shadertype, precisiontype Enum) (rangeLow, rangeHigh, precision int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetShaderPrecisionFormat(%v, %v) (%v, %v, %v) %v", shadertype, precisiontype, rangeLow, rangeHigh, precision, errstr)
|
|
}()
|
|
const glintSize = 4
|
|
var cRange [2]C.GLint
|
|
var cPrecision C.GLint
|
|
C.glGetShaderPrecisionFormat(shadertype.c(), precisiontype.c(), &cRange[0], &cPrecision)
|
|
return int(cRange[0]), int(cRange[1]), int(cPrecision)
|
|
}
|
|
|
|
func GetShaderSource(s Shader) (r0 string) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetShaderSource(%v) %v%v", s, r0, errstr)
|
|
}()
|
|
sourceLen := GetShaderi(s, SHADER_SOURCE_LENGTH)
|
|
if sourceLen == 0 {
|
|
return ""
|
|
}
|
|
buf := C.malloc(C.size_t(sourceLen))
|
|
defer C.free(buf)
|
|
C.glGetShaderSource(s.c(), C.GLsizei(sourceLen), nil, (*C.GLchar)(buf))
|
|
return C.GoString((*C.char)(buf))
|
|
}
|
|
|
|
func GetString(name Enum) (r0 string) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetString(%v) %v%v", name, r0, errstr)
|
|
}()
|
|
return C.GoString((*C.char)((unsafe.Pointer)(C.glGetString(name.c()))))
|
|
}
|
|
|
|
func GetTexParameterfv(dst []float32, target, pname Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetTexParameterfv(len(%d), %v, %v) %v", len(dst), target, pname, errstr)
|
|
}()
|
|
C.glGetTexParameterfv(target.c(), pname.c(), (*C.GLfloat)(&dst[0]))
|
|
}
|
|
|
|
func GetTexParameteriv(dst []int32, target, pname Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetTexParameteriv(%v, %v, %v) %v", dst, target, pname, errstr)
|
|
}()
|
|
C.glGetTexParameteriv(target.c(), pname.c(), (*C.GLint)(&dst[0]))
|
|
}
|
|
|
|
func GetUniformfv(dst []float32, src Uniform, p Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetUniformfv(len(%d), %v, %v) %v", len(dst), src, p, errstr)
|
|
}()
|
|
C.glGetUniformfv(p.c(), src.c(), (*C.GLfloat)(&dst[0]))
|
|
}
|
|
|
|
func GetUniformiv(dst []int32, src Uniform, p Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetUniformiv(%v, %v, %v) %v", dst, src, p, errstr)
|
|
}()
|
|
C.glGetUniformiv(p.c(), src.c(), (*C.GLint)(&dst[0]))
|
|
}
|
|
|
|
func GetUniformLocation(p Program, name string) (r0 Uniform) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetUniformLocation(%v, %v) %v%v", p, name, r0, errstr)
|
|
}()
|
|
str := C.CString(name)
|
|
defer C.free((unsafe.Pointer)(str))
|
|
return Uniform(C.glGetUniformLocation(p.c(), (*C.GLchar)(str)))
|
|
}
|
|
|
|
func GetVertexAttribf(src Attrib, pname Enum) (r0 float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetVertexAttribf(%v, %v) %v%v", src, pname, r0, errstr)
|
|
}()
|
|
var params C.GLfloat
|
|
C.glGetVertexAttribfv(src.c(), pname.c(), ¶ms)
|
|
return float32(params)
|
|
}
|
|
|
|
func GetVertexAttribfv(dst []float32, src Attrib, pname Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetVertexAttribfv(len(%d), %v, %v) %v", len(dst), src, pname, errstr)
|
|
}()
|
|
C.glGetVertexAttribfv(src.c(), pname.c(), (*C.GLfloat)(&dst[0]))
|
|
}
|
|
|
|
func GetVertexAttribi(src Attrib, pname Enum) (r0 int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetVertexAttribi(%v, %v) %v%v", src, pname, r0, errstr)
|
|
}()
|
|
var params C.GLint
|
|
C.glGetVertexAttribiv(src.c(), pname.c(), ¶ms)
|
|
return int32(params)
|
|
}
|
|
|
|
func GetVertexAttribiv(dst []int32, src Attrib, pname Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.GetVertexAttribiv(%v, %v, %v) %v", dst, src, pname, errstr)
|
|
}()
|
|
C.glGetVertexAttribiv(src.c(), pname.c(), (*C.GLint)(&dst[0]))
|
|
}
|
|
|
|
func Hint(target, mode Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Hint(%v, %v) %v", target, mode, errstr)
|
|
}()
|
|
C.glHint(target.c(), mode.c())
|
|
}
|
|
|
|
func IsBuffer(b Buffer) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsBuffer(%v) %v%v", b, r0, errstr)
|
|
}()
|
|
return C.glIsBuffer(b.c()) != 0
|
|
}
|
|
|
|
func IsEnabled(cap Enum) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsEnabled(%v) %v%v", cap, r0, errstr)
|
|
}()
|
|
return C.glIsEnabled(cap.c()) != 0
|
|
}
|
|
|
|
func IsFramebuffer(fb Framebuffer) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsFramebuffer(%v) %v%v", fb, r0, errstr)
|
|
}()
|
|
return C.glIsFramebuffer(fb.c()) != 0
|
|
}
|
|
|
|
func IsProgram(p Program) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsProgram(%v) %v%v", p, r0, errstr)
|
|
}()
|
|
return C.glIsProgram(p.c()) != 0
|
|
}
|
|
|
|
func IsRenderbuffer(rb Renderbuffer) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsRenderbuffer(%v) %v%v", rb, r0, errstr)
|
|
}()
|
|
return C.glIsRenderbuffer(rb.c()) != 0
|
|
}
|
|
|
|
func IsShader(s Shader) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsShader(%v) %v%v", s, r0, errstr)
|
|
}()
|
|
return C.glIsShader(s.c()) != 0
|
|
}
|
|
|
|
func IsTexture(t Texture) (r0 bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.IsTexture(%v) %v%v", t, r0, errstr)
|
|
}()
|
|
return C.glIsTexture(t.c()) != 0
|
|
}
|
|
|
|
func LineWidth(width float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.LineWidth(%v) %v", width, errstr)
|
|
}()
|
|
C.glLineWidth(C.GLfloat(width))
|
|
}
|
|
|
|
func LinkProgram(p Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.LinkProgram(%v) %v", p, errstr)
|
|
}()
|
|
C.glLinkProgram(p.c())
|
|
}
|
|
|
|
func PixelStorei(pname Enum, param int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.PixelStorei(%v, %v) %v", pname, param, errstr)
|
|
}()
|
|
C.glPixelStorei(pname.c(), C.GLint(param))
|
|
}
|
|
|
|
func PolygonOffset(factor, units float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.PolygonOffset(%v, %v) %v", factor, units, errstr)
|
|
}()
|
|
C.glPolygonOffset(C.GLfloat(factor), C.GLfloat(units))
|
|
}
|
|
|
|
func ReadPixels(dst []byte, x, y, width, height int, format, ty Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ReadPixels(len(%d), %v, %v, %v, %v, %v, %v) %v", len(dst), x, y, width, height, format, ty, errstr)
|
|
}()
|
|
C.glReadPixels(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), format.c(), ty.c(), unsafe.Pointer(&dst[0]))
|
|
}
|
|
|
|
func ReleaseShaderCompiler() {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ReleaseShaderCompiler() %v", errstr)
|
|
}()
|
|
C.glReleaseShaderCompiler()
|
|
}
|
|
|
|
func RenderbufferStorage(target, internalFormat Enum, width, height int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.RenderbufferStorage(%v, %v, %v, %v) %v", target, internalFormat, width, height, errstr)
|
|
}()
|
|
C.glRenderbufferStorage(target.c(), internalFormat.c(), C.GLsizei(width), C.GLsizei(height))
|
|
}
|
|
|
|
func SampleCoverage(value float32, invert bool) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.SampleCoverage(%v, %v) %v", value, invert, errstr)
|
|
}()
|
|
C.glSampleCoverage(C.GLfloat(value), glBoolean(invert))
|
|
}
|
|
|
|
func glBoolean(b bool) (r0 C.GLboolean) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.glBoolean(%v) %v%v", b, r0, errstr)
|
|
}()
|
|
if b {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
func Scissor(x, y, width, height int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Scissor(%v, %v, %v, %v) %v", x, y, width, height, errstr)
|
|
}()
|
|
C.glScissor(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
|
|
}
|
|
|
|
func ShaderSource(s Shader, src string) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ShaderSource(%v, %v) %v", s, src, errstr)
|
|
}()
|
|
str := (*C.GLchar)(C.CString(src))
|
|
defer C.free(unsafe.Pointer(str))
|
|
C.glShaderSource(s.c(), 1, &str, nil)
|
|
}
|
|
|
|
func StencilFunc(fn Enum, ref int, mask uint32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.StencilFunc(%v, %v, %v) %v", fn, ref, mask, errstr)
|
|
}()
|
|
C.glStencilFunc(fn.c(), C.GLint(ref), C.GLuint(mask))
|
|
}
|
|
|
|
func StencilFuncSeparate(face, fn Enum, ref int, mask uint32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.StencilFuncSeparate(%v, %v, %v, %v) %v", face, fn, ref, mask, errstr)
|
|
}()
|
|
C.glStencilFuncSeparate(face.c(), fn.c(), C.GLint(ref), C.GLuint(mask))
|
|
}
|
|
|
|
func StencilMask(mask uint32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.StencilMask(%v) %v", mask, errstr)
|
|
}()
|
|
C.glStencilMask(C.GLuint(mask))
|
|
}
|
|
|
|
func StencilMaskSeparate(face Enum, mask uint32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.StencilMaskSeparate(%v, %v) %v", face, mask, errstr)
|
|
}()
|
|
C.glStencilMaskSeparate(face.c(), C.GLuint(mask))
|
|
}
|
|
|
|
func StencilOp(fail, zfail, zpass Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.StencilOp(%v, %v, %v) %v", fail, zfail, zpass, errstr)
|
|
}()
|
|
C.glStencilOp(fail.c(), zfail.c(), zpass.c())
|
|
}
|
|
|
|
func StencilOpSeparate(face, sfail, dpfail, dppass Enum) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.StencilOpSeparate(%v, %v, %v, %v) %v", face, sfail, dpfail, dppass, errstr)
|
|
}()
|
|
C.glStencilOpSeparate(face.c(), sfail.c(), dpfail.c(), dppass.c())
|
|
}
|
|
|
|
func TexImage2D(target Enum, level int, width, height int, format Enum, ty Enum, data []byte) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.TexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, width, height, format, ty, len(data), errstr)
|
|
}()
|
|
p := unsafe.Pointer(nil)
|
|
if len(data) > 0 {
|
|
p = unsafe.Pointer(&data[0])
|
|
}
|
|
C.glTexImage2D(target.c(), C.GLint(level), C.GLint(format), C.GLsizei(width), C.GLsizei(height), 0, format.c(), ty.c(), p)
|
|
}
|
|
|
|
func TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.TexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, x, y, width, height, format, ty, len(data), errstr)
|
|
}()
|
|
C.glTexSubImage2D(target.c(), C.GLint(level), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), format.c(), ty.c(), unsafe.Pointer(&data[0]))
|
|
}
|
|
|
|
func TexParameterf(target, pname Enum, param float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.TexParameterf(%v, %v, %v) %v", target, pname, param, errstr)
|
|
}()
|
|
C.glTexParameterf(target.c(), pname.c(), C.GLfloat(param))
|
|
}
|
|
|
|
func TexParameterfv(target, pname Enum, params []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.TexParameterfv(%v, %v, len(%d)) %v", target, pname, len(params), errstr)
|
|
}()
|
|
C.glTexParameterfv(target.c(), pname.c(), (*C.GLfloat)(¶ms[0]))
|
|
}
|
|
|
|
func TexParameteri(target, pname Enum, param int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.TexParameteri(%v, %v, %v) %v", target, pname, param, errstr)
|
|
}()
|
|
C.glTexParameteri(target.c(), pname.c(), C.GLint(param))
|
|
}
|
|
|
|
func TexParameteriv(target, pname Enum, params []int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.TexParameteriv(%v, %v, %v) %v", target, pname, params, errstr)
|
|
}()
|
|
C.glTexParameteriv(target.c(), pname.c(), (*C.GLint)(¶ms[0]))
|
|
}
|
|
|
|
func Uniform1f(dst Uniform, v float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform1f(%v, %v) %v", dst, v, errstr)
|
|
}()
|
|
C.glUniform1f(dst.c(), C.GLfloat(v))
|
|
}
|
|
|
|
func Uniform1fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform1fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniform1fv(dst.c(), C.GLsizei(len(src)), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func Uniform1i(dst Uniform, v int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform1i(%v, %v) %v", dst, v, errstr)
|
|
}()
|
|
C.glUniform1i(dst.c(), C.GLint(v))
|
|
}
|
|
|
|
func Uniform1iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform1iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
C.glUniform1iv(dst.c(), C.GLsizei(len(src)), (*C.GLint)(&src[0]))
|
|
}
|
|
|
|
func Uniform2f(dst Uniform, v0, v1 float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform2f(%v, %v, %v) %v", dst, v0, v1, errstr)
|
|
}()
|
|
C.glUniform2f(dst.c(), C.GLfloat(v0), C.GLfloat(v1))
|
|
}
|
|
|
|
func Uniform2fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform2fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniform2fv(dst.c(), C.GLsizei(len(src)/2), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func Uniform2i(location, v0, v1 int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform2i(%v, %v, %v) %v", location, v0, v1, errstr)
|
|
}()
|
|
C.glUniform2i(C.GLint(location), C.GLint(v0), C.GLint(v1))
|
|
}
|
|
|
|
func Uniform2iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform2iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
C.glUniform2iv(dst.c(), C.GLsizei(len(src)/2), (*C.GLint)(&src[0]))
|
|
}
|
|
|
|
func Uniform3f(dst Uniform, v0, v1, v2 float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform3f(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
|
|
}()
|
|
C.glUniform3f(dst.c(), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2))
|
|
}
|
|
|
|
func Uniform3fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform3fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniform3fv(dst.c(), C.GLsizei(len(src)/3), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func Uniform3i(location, v0, v1, v2 int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform3i(%v, %v, %v, %v) %v", location, v0, v1, v2, errstr)
|
|
}()
|
|
C.glUniform3i(C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2))
|
|
}
|
|
|
|
func Uniform3iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform3iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
C.glUniform3iv(dst.c(), C.GLsizei(len(src)/3), (*C.GLint)(&src[0]))
|
|
}
|
|
|
|
func Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform4f(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
|
|
}()
|
|
C.glUniform4f(dst.c(), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3))
|
|
}
|
|
|
|
func Uniform4fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform4fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniform4fv(dst.c(), C.GLsizei(len(src)/4), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func Uniform4i(dst Uniform, v0, v1, v2, v3 int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform4i(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
|
|
}()
|
|
C.glUniform4i(dst.c(), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3))
|
|
}
|
|
|
|
func Uniform4iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Uniform4iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
C.glUniform4iv(dst.c(), C.GLsizei(len(src)/4), (*C.GLint)(&src[0]))
|
|
}
|
|
|
|
func UniformMatrix2fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.UniformMatrix2fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniformMatrix2fv(dst.c(), C.GLsizei(len(src)/4), 0, (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func UniformMatrix3fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.UniformMatrix3fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniformMatrix3fv(dst.c(), C.GLsizei(len(src)/9), 0, (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func UniformMatrix4fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.UniformMatrix4fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glUniformMatrix4fv(dst.c(), C.GLsizei(len(src)/16), 0, (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func UseProgram(p Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.UseProgram(%v) %v", p, errstr)
|
|
}()
|
|
C.glUseProgram(p.c())
|
|
}
|
|
|
|
func ValidateProgram(p Program) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.ValidateProgram(%v) %v", p, errstr)
|
|
}()
|
|
C.glValidateProgram(p.c())
|
|
}
|
|
|
|
func VertexAttrib1f(dst Attrib, x float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib1f(%v, %v) %v", dst, x, errstr)
|
|
}()
|
|
C.glVertexAttrib1f(dst.c(), C.GLfloat(x))
|
|
}
|
|
|
|
func VertexAttrib1fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib1fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glVertexAttrib1fv(dst.c(), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func VertexAttrib2f(dst Attrib, x, y float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib2f(%v, %v, %v) %v", dst, x, y, errstr)
|
|
}()
|
|
C.glVertexAttrib2f(dst.c(), C.GLfloat(x), C.GLfloat(y))
|
|
}
|
|
|
|
func VertexAttrib2fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib2fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glVertexAttrib2fv(dst.c(), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func VertexAttrib3f(dst Attrib, x, y, z float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib3f(%v, %v, %v, %v) %v", dst, x, y, z, errstr)
|
|
}()
|
|
C.glVertexAttrib3f(dst.c(), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z))
|
|
}
|
|
|
|
func VertexAttrib3fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib3fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glVertexAttrib3fv(dst.c(), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func VertexAttrib4f(dst Attrib, x, y, z, w float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib4f(%v, %v, %v, %v, %v) %v", dst, x, y, z, w, errstr)
|
|
}()
|
|
C.glVertexAttrib4f(dst.c(), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w))
|
|
}
|
|
|
|
func VertexAttrib4fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttrib4fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
C.glVertexAttrib4fv(dst.c(), (*C.GLfloat)(&src[0]))
|
|
}
|
|
|
|
func VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.VertexAttribPointer(%v, %v, %v, %v, %v, %v) %v", dst, size, ty, normalized, stride, offset, errstr)
|
|
}()
|
|
n := glBoolean(normalized)
|
|
s := C.GLsizei(stride)
|
|
C.glVertexAttribPointer(dst.c(), C.GLint(size), ty.c(), n, s, unsafe.Pointer(uintptr(offset)))
|
|
}
|
|
|
|
func Viewport(x, y, width, height int) {
|
|
defer func() {
|
|
errstr := errDrain()
|
|
log.Printf("gl.Viewport(%v, %v, %v, %v) %v", x, y, width, height, errstr)
|
|
}()
|
|
C.glViewport(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
|
|
}
|