27e7ed5775
It is an error to use a gl.Context concurrently. (Each Context
contains a state machine, so there is no way this can work.)
Up until now only the GL driver could report such a misuse, and
it generally does a poor job of it. Our command buffer adds some
small oppertunity for the race detector to help, but it makes it
harder to debug other kinds of driver crashes, so it is worth
disabling in debug mode.
To make it easy, compiling with -tags gldebug now inserts an
explicit check that there are no other active GL calls outstanding.
Adding something like:
go func() {
for {
glctx.GetInteger(gl.ALPHA_BITS)
}
}()
to x/mobile/example/basic now reliably crashes when compiled
with -tags gldebug, providing a stack trace that includes both
misbehaving goroutines.
Change-Id: I3d85d94220bca2a15eaf2742f13b44db1f3428bf
Reviewed-on: https://go-review.googlesource.com/15180
Reviewed-by: Hyang-Ah Hana Kim <hyangah@gmail.com>
2868 lines
64 KiB
Go
2868 lines
64 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 using go generate. DO NOT EDIT.
|
|
// See doc.go for details.
|
|
|
|
// +build linux darwin
|
|
// +build gldebug
|
|
|
|
package gl
|
|
|
|
// #include "work.h"
|
|
import "C"
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"sync/atomic"
|
|
"unsafe"
|
|
)
|
|
|
|
func (ctx *context) errDrain() string {
|
|
var errs []Enum
|
|
for {
|
|
e := ctx.GetError()
|
|
if e == 0 {
|
|
break
|
|
}
|
|
errs = append(errs, e)
|
|
}
|
|
if len(errs) > 0 {
|
|
return fmt.Sprintf(" error: %v", errs)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ctx *context) enqueueDebug(c call) C.uintptr_t {
|
|
numCalls := atomic.AddInt32(&ctx.debug, 1)
|
|
if numCalls > 1 {
|
|
panic("concurrent calls made to the same GL context")
|
|
}
|
|
defer func() {
|
|
if atomic.AddInt32(&ctx.debug, -1) > 0 {
|
|
select {} // block so you see us in the panic
|
|
}
|
|
}()
|
|
|
|
return ctx.enqueue(c)
|
|
}
|
|
|
|
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 (ctx *context) ActiveTexture(texture Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ActiveTexture(%v) %v", texture, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnActiveTexture,
|
|
a0: texture.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) AttachShader(p Program, s Shader) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.AttachShader(%v, %v) %v", p, s, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnAttachShader,
|
|
a0: p.c(),
|
|
a1: s.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BindAttribLocation(p Program, a Attrib, name string) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BindAttribLocation(%v, %v, %v) %v", p, a, name, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBindAttribLocation,
|
|
a0: p.c(),
|
|
a1: a.c(),
|
|
a2: C.uintptr_t(uintptr(unsafe.Pointer(C.CString(name)))),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BindBuffer(target Enum, b Buffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BindBuffer(%v, %v) %v", target, b, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBindBuffer,
|
|
a0: target.c(),
|
|
a1: b.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BindFramebuffer(target Enum, fb Framebuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BindFramebuffer(%v, %v) %v", target, fb, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBindFramebuffer,
|
|
a0: target.c(),
|
|
a1: fb.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BindRenderbuffer(target Enum, rb Renderbuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BindRenderbuffer(%v, %v) %v", target, rb, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBindRenderbuffer,
|
|
a0: target.c(),
|
|
a1: rb.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BindTexture(target Enum, t Texture) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BindTexture(%v, %v) %v", target, t, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBindTexture,
|
|
a0: target.c(),
|
|
a1: t.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BlendColor(red, green, blue, alpha float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BlendColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBlendColor,
|
|
a0: C.uintptr_t(math.Float32bits(red)),
|
|
a1: C.uintptr_t(math.Float32bits(green)),
|
|
a2: C.uintptr_t(math.Float32bits(blue)),
|
|
a3: C.uintptr_t(math.Float32bits(alpha)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BlendEquation(mode Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BlendEquation(%v) %v", mode, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBlendEquation,
|
|
a0: mode.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BlendEquationSeparate(modeRGB, modeAlpha Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BlendEquationSeparate(%v, %v) %v", modeRGB, modeAlpha, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBlendEquationSeparate,
|
|
a0: modeRGB.c(),
|
|
a1: modeAlpha.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BlendFunc(sfactor, dfactor Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BlendFunc(%v, %v) %v", sfactor, dfactor, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBlendFunc,
|
|
a0: sfactor.c(),
|
|
a1: dfactor.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BlendFuncSeparate(%v, %v, %v, %v) %v", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBlendFuncSeparate,
|
|
a0: sfactorRGB.c(),
|
|
a1: dfactorRGB.c(),
|
|
a2: sfactorAlpha.c(),
|
|
a3: dfactorAlpha.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BufferData(target Enum, src []byte, usage Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BufferData(%v, len(%d), %v) %v", target, len(src), usage, errstr)
|
|
}()
|
|
parg := unsafe.Pointer(nil)
|
|
if len(src) > 0 {
|
|
parg = unsafe.Pointer(&src[0])
|
|
}
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBufferData,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(len(src)),
|
|
a2: usage.c(),
|
|
},
|
|
parg: parg,
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) BufferInit(target Enum, size int, usage Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BufferInit(%v, %v, %v) %v", target, size, usage, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBufferData,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(size),
|
|
a2: 0,
|
|
a3: usage.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) BufferSubData(target Enum, offset int, data []byte) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.BufferSubData(%v, %v, len(%d)) %v", target, offset, len(data), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnBufferSubData,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(offset),
|
|
a2: C.uintptr_t(len(data)),
|
|
},
|
|
parg: unsafe.Pointer(&data[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) CheckFramebufferStatus(target Enum) (r0 Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CheckFramebufferStatus(%v) %v%v", target, r0, errstr)
|
|
}()
|
|
return Enum(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCheckFramebufferStatus,
|
|
a0: target.c(),
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) Clear(mask Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Clear(%v) %v", mask, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnClear,
|
|
a0: C.uintptr_t(mask),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ClearColor(red, green, blue, alpha float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ClearColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnClearColor,
|
|
a0: C.uintptr_t(math.Float32bits(red)),
|
|
a1: C.uintptr_t(math.Float32bits(green)),
|
|
a2: C.uintptr_t(math.Float32bits(blue)),
|
|
a3: C.uintptr_t(math.Float32bits(alpha)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ClearDepthf(d float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ClearDepthf(%v) %v", d, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnClearDepthf,
|
|
a0: C.uintptr_t(math.Float32bits(d)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ClearStencil(s int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ClearStencil(%v) %v", s, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnClearStencil,
|
|
a0: C.uintptr_t(s),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ColorMask(red, green, blue, alpha bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ColorMask(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnColorMask,
|
|
a0: glBoolean(red),
|
|
a1: glBoolean(green),
|
|
a2: glBoolean(blue),
|
|
a3: glBoolean(alpha),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) CompileShader(s Shader) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CompileShader(%v) %v", s, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCompileShader,
|
|
a0: s.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) CompressedTexImage2D(target Enum, level int, internalformat Enum, width, height, border int, data []byte) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CompressedTexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, internalformat, width, height, border, len(data), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCompressedTexImage2D,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(level),
|
|
a2: internalformat.c(),
|
|
a3: C.uintptr_t(width),
|
|
a4: C.uintptr_t(height),
|
|
a5: C.uintptr_t(border),
|
|
a6: C.uintptr_t(len(data)),
|
|
},
|
|
parg: unsafe.Pointer(&data[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) CompressedTexSubImage2D(target Enum, level, xoffset, yoffset, width, height int, format Enum, data []byte) {
|
|
defer func() {
|
|
errstr := ctx.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)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCompressedTexSubImage2D,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(level),
|
|
a2: C.uintptr_t(xoffset),
|
|
a3: C.uintptr_t(yoffset),
|
|
a4: C.uintptr_t(width),
|
|
a5: C.uintptr_t(height),
|
|
a6: format.c(),
|
|
a7: C.uintptr_t(len(data)),
|
|
},
|
|
parg: unsafe.Pointer(&data[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) CopyTexImage2D(target Enum, level int, internalformat Enum, x, y, width, height, border int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CopyTexImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, internalformat, x, y, width, height, border, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCopyTexImage2D,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(level),
|
|
a2: internalformat.c(),
|
|
a3: C.uintptr_t(x),
|
|
a4: C.uintptr_t(y),
|
|
a5: C.uintptr_t(width),
|
|
a6: C.uintptr_t(height),
|
|
a7: C.uintptr_t(border),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CopyTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, xoffset, yoffset, x, y, width, height, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCopyTexSubImage2D,
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(level),
|
|
a2: C.uintptr_t(xoffset),
|
|
a3: C.uintptr_t(yoffset),
|
|
a4: C.uintptr_t(x),
|
|
a5: C.uintptr_t(y),
|
|
a6: C.uintptr_t(width),
|
|
a7: C.uintptr_t(height),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) CreateBuffer() (r0 Buffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CreateBuffer() %v%v", r0, errstr)
|
|
}()
|
|
return Buffer{Value: uint32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGenBuffer,
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) CreateFramebuffer() (r0 Framebuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CreateFramebuffer() %v%v", r0, errstr)
|
|
}()
|
|
return Framebuffer{Value: uint32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGenFramebuffer,
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) CreateProgram() (r0 Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CreateProgram() %v%v", r0, errstr)
|
|
}()
|
|
return Program{Value: uint32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCreateProgram,
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) CreateRenderbuffer() (r0 Renderbuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CreateRenderbuffer() %v%v", r0, errstr)
|
|
}()
|
|
return Renderbuffer{Value: uint32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGenRenderbuffer,
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) CreateShader(ty Enum) (r0 Shader) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CreateShader(%v) %v%v", ty, r0, errstr)
|
|
}()
|
|
return Shader{Value: uint32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCreateShader,
|
|
a0: C.uintptr_t(ty),
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) CreateTexture() (r0 Texture) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CreateTexture() %v%v", r0, errstr)
|
|
}()
|
|
return Texture{Value: uint32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGenTexture,
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) CullFace(mode Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.CullFace(%v) %v", mode, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnCullFace,
|
|
a0: mode.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DeleteBuffer(v Buffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DeleteBuffer(%v) %v", v, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDeleteBuffer,
|
|
a0: C.uintptr_t(v.Value),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DeleteFramebuffer(v Framebuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DeleteFramebuffer(%v) %v", v, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDeleteFramebuffer,
|
|
a0: C.uintptr_t(v.Value),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DeleteProgram(p Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DeleteProgram(%v) %v", p, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDeleteProgram,
|
|
a0: p.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DeleteRenderbuffer(v Renderbuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DeleteRenderbuffer(%v) %v", v, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDeleteRenderbuffer,
|
|
a0: v.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DeleteShader(s Shader) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DeleteShader(%v) %v", s, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDeleteShader,
|
|
a0: s.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DeleteTexture(v Texture) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DeleteTexture(%v) %v", v, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDeleteTexture,
|
|
a0: v.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DepthFunc(fn Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DepthFunc(%v) %v", fn, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDepthFunc,
|
|
a0: fn.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DepthMask(flag bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DepthMask(%v) %v", flag, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDepthMask,
|
|
a0: glBoolean(flag),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DepthRangef(n, f float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DepthRangef(%v, %v) %v", n, f, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDepthRangef,
|
|
a0: C.uintptr_t(math.Float32bits(n)),
|
|
a1: C.uintptr_t(math.Float32bits(f)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DetachShader(p Program, s Shader) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DetachShader(%v, %v) %v", p, s, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDetachShader,
|
|
a0: p.c(),
|
|
a1: s.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Disable(cap Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Disable(%v) %v", cap, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDisable,
|
|
a0: cap.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DisableVertexAttribArray(a Attrib) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DisableVertexAttribArray(%v) %v", a, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDisableVertexAttribArray,
|
|
a0: a.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DrawArrays(mode Enum, first, count int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DrawArrays(%v, %v, %v) %v", mode, first, count, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDrawArrays,
|
|
a0: mode.c(),
|
|
a1: C.uintptr_t(first),
|
|
a2: C.uintptr_t(count),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) DrawElements(mode Enum, count int, ty Enum, offset int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.DrawElements(%v, %v, %v, %v) %v", mode, count, ty, offset, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnDrawElements,
|
|
a0: mode.c(),
|
|
a1: C.uintptr_t(count),
|
|
a2: ty.c(),
|
|
a3: C.uintptr_t(offset),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Enable(cap Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Enable(%v) %v", cap, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnEnable,
|
|
a0: cap.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) EnableVertexAttribArray(a Attrib) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.EnableVertexAttribArray(%v) %v", a, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnEnableVertexAttribArray,
|
|
a0: a.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Finish() {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Finish() %v", errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnFinish,
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Flush() {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Flush() %v", errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnFlush,
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) FramebufferRenderbuffer(target, attachment, rbTarget Enum, rb Renderbuffer) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.FramebufferRenderbuffer(%v, %v, %v, %v) %v", target, attachment, rbTarget, rb, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnFramebufferRenderbuffer,
|
|
a0: target.c(),
|
|
a1: attachment.c(),
|
|
a2: rbTarget.c(),
|
|
a3: rb.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.FramebufferTexture2D(%v, %v, %v, %v, %v) %v", target, attachment, texTarget, t, level, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnFramebufferTexture2D,
|
|
a0: target.c(),
|
|
a1: attachment.c(),
|
|
a2: texTarget.c(),
|
|
a3: t.c(),
|
|
a4: C.uintptr_t(level),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) FrontFace(mode Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.FrontFace(%v) %v", mode, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnFrontFace,
|
|
a0: mode.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) GenerateMipmap(target Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GenerateMipmap(%v) %v", target, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGenerateMipmap,
|
|
a0: target.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) GetActiveAttrib(p Program, index uint32) (name string, size int, ty Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetActiveAttrib(%v, %v) (%v, %v, %v) %v", p, index, name, size, ty, errstr)
|
|
}()
|
|
bufSize := ctx.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
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetActiveAttrib,
|
|
a0: p.c(),
|
|
a1: C.uintptr_t(index),
|
|
a2: C.uintptr_t(bufSize),
|
|
a3: 0,
|
|
a4: C.uintptr_t(uintptr(unsafe.Pointer(&cSize))),
|
|
a5: C.uintptr_t(uintptr(unsafe.Pointer(&cType))),
|
|
a6: C.uintptr_t(uintptr(unsafe.Pointer(buf))),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return C.GoString((*C.char)(buf)), int(cSize), Enum(cType)
|
|
}
|
|
|
|
func (ctx *context) GetActiveUniform(p Program, index uint32) (name string, size int, ty Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetActiveUniform(%v, %v) (%v, %v, %v) %v", p, index, name, size, ty, errstr)
|
|
}()
|
|
bufSize := ctx.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
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetActiveUniform,
|
|
a0: p.c(),
|
|
a1: C.uintptr_t(index),
|
|
a2: C.uintptr_t(bufSize),
|
|
a3: 0,
|
|
a4: C.uintptr_t(uintptr(unsafe.Pointer(&cSize))),
|
|
a5: C.uintptr_t(uintptr(unsafe.Pointer(&cType))),
|
|
a6: C.uintptr_t(uintptr(unsafe.Pointer(buf))),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return C.GoString((*C.char)(buf)), int(cSize), Enum(cType)
|
|
}
|
|
|
|
func (ctx *context) GetAttachedShaders(p Program) (r0 []Shader) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetAttachedShaders(%v) %v%v", p, r0, errstr)
|
|
}()
|
|
shadersLen := ctx.GetProgrami(p, ATTACHED_SHADERS)
|
|
if shadersLen == 0 {
|
|
return nil
|
|
}
|
|
var n C.GLsizei
|
|
buf := make([]C.GLuint, shadersLen)
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetAttachedShaders,
|
|
a0: p.c(),
|
|
a1: C.uintptr_t(shadersLen),
|
|
a2: C.uintptr_t(uintptr(unsafe.Pointer(&n))),
|
|
a3: C.uintptr_t(uintptr(unsafe.Pointer(&buf[0]))),
|
|
},
|
|
blocking: true,
|
|
})
|
|
buf = buf[:int(n)]
|
|
shaders := make([]Shader, len(buf))
|
|
for i, s := range buf {
|
|
shaders[i] = Shader{Value: uint32(s)}
|
|
}
|
|
return shaders
|
|
}
|
|
|
|
func (ctx *context) GetAttribLocation(p Program, name string) (r0 Attrib) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
r0.name = name
|
|
log.Printf("gl.GetAttribLocation(%v, %v) %v%v", p, name, r0, errstr)
|
|
}()
|
|
return Attrib{Value: uint(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetAttribLocation,
|
|
a0: p.c(),
|
|
a1: C.uintptr_t(uintptr(unsafe.Pointer(C.CString(name)))),
|
|
},
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) GetBooleanv(dst []bool, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetBooleanv(%v, %v) %v", dst, pname, errstr)
|
|
}()
|
|
buf := make([]C.GLboolean, len(dst))
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetBooleanv,
|
|
a0: pname.c(),
|
|
a1: C.uintptr_t(uintptr(unsafe.Pointer(&buf[0]))),
|
|
},
|
|
blocking: true,
|
|
})
|
|
for i, v := range buf {
|
|
dst[i] = v != 0
|
|
}
|
|
}
|
|
|
|
func (ctx *context) GetFloatv(dst []float32, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetFloatv(len(%d), %v) %v", len(dst), pname, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetFloatv,
|
|
a0: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) GetIntegerv(dst []int32, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetIntegerv(%v, %v) %v", dst, pname, errstr)
|
|
}()
|
|
buf := make([]C.GLint, len(dst))
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetIntegerv,
|
|
a0: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(&buf[0]),
|
|
blocking: true,
|
|
})
|
|
for i, v := range buf {
|
|
dst[i] = int32(v)
|
|
}
|
|
}
|
|
|
|
func (ctx *context) GetInteger(pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetInteger(%v) %v%v", pname, r0, errstr)
|
|
}()
|
|
var v [1]int32
|
|
ctx.GetIntegerv(v[:], pname)
|
|
return int(v[0])
|
|
}
|
|
|
|
func (ctx *context) GetBufferParameteri(target, value Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetBufferParameteri(%v, %v) %v%v", target, value, r0, errstr)
|
|
}()
|
|
return int(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetBufferParameteri,
|
|
a0: target.c(),
|
|
a1: value.c(),
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) GetError() (r0 Enum) {
|
|
return Enum(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetError,
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetFramebufferAttachmentParameteri(%v, %v, %v) %v%v", target, attachment, pname, r0, errstr)
|
|
}()
|
|
return int(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetFramebufferAttachmentParameteriv,
|
|
a0: target.c(),
|
|
a1: attachment.c(),
|
|
a2: pname.c(),
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) GetProgrami(p Program, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetProgrami(%v, %v) %v%v", p, pname, r0, errstr)
|
|
}()
|
|
return int(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetProgramiv,
|
|
a0: p.c(),
|
|
a1: pname.c(),
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) GetProgramInfoLog(p Program) (r0 string) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetProgramInfoLog(%v) %v%v", p, r0, errstr)
|
|
}()
|
|
infoLen := ctx.GetProgrami(p, INFO_LOG_LENGTH)
|
|
buf := C.malloc(C.size_t(infoLen))
|
|
defer C.free(buf)
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetProgramInfoLog,
|
|
a0: p.c(),
|
|
a1: C.uintptr_t(infoLen),
|
|
a2: 0,
|
|
a3: C.uintptr_t(uintptr(buf)),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return C.GoString((*C.char)(buf))
|
|
}
|
|
|
|
func (ctx *context) GetRenderbufferParameteri(target, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetRenderbufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)
|
|
}()
|
|
return int(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetRenderbufferParameteriv,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) GetShaderi(s Shader, pname Enum) (r0 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetShaderi(%v, %v) %v%v", s, pname, r0, errstr)
|
|
}()
|
|
return int(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetShaderiv,
|
|
a0: s.c(),
|
|
a1: pname.c(),
|
|
},
|
|
blocking: true,
|
|
}))
|
|
}
|
|
|
|
func (ctx *context) GetShaderInfoLog(s Shader) (r0 string) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetShaderInfoLog(%v) %v%v", s, r0, errstr)
|
|
}()
|
|
infoLen := ctx.GetShaderi(s, INFO_LOG_LENGTH)
|
|
buf := C.malloc(C.size_t(infoLen))
|
|
defer C.free(buf)
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetShaderInfoLog,
|
|
a0: s.c(),
|
|
a1: C.uintptr_t(infoLen),
|
|
a2: 0,
|
|
a3: C.uintptr_t(uintptr(buf)),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return C.GoString((*C.char)(buf))
|
|
}
|
|
|
|
func (ctx *context) GetShaderPrecisionFormat(shadertype, precisiontype Enum) (rangeLow, rangeHigh, precision int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetShaderPrecisionFormat(%v, %v) (%v, %v, %v) %v", shadertype, precisiontype, rangeLow, rangeHigh, precision, errstr)
|
|
}()
|
|
var cRange [2]C.GLint
|
|
var cPrecision C.GLint
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetShaderPrecisionFormat,
|
|
a0: shadertype.c(),
|
|
a1: precisiontype.c(),
|
|
a2: C.uintptr_t(uintptr(unsafe.Pointer(&cRange[0]))),
|
|
a3: C.uintptr_t(uintptr(unsafe.Pointer(&cPrecision))),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return int(cRange[0]), int(cRange[1]), int(cPrecision)
|
|
}
|
|
|
|
func (ctx *context) GetShaderSource(s Shader) (r0 string) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetShaderSource(%v) %v%v", s, r0, errstr)
|
|
}()
|
|
sourceLen := ctx.GetShaderi(s, SHADER_SOURCE_LENGTH)
|
|
if sourceLen == 0 {
|
|
return ""
|
|
}
|
|
buf := C.malloc(C.size_t(sourceLen))
|
|
defer C.free(buf)
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetShaderSource,
|
|
a0: s.c(),
|
|
a1: C.uintptr_t(sourceLen),
|
|
a2: 0,
|
|
a3: C.uintptr_t(uintptr(buf)),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return C.GoString((*C.char)(buf))
|
|
}
|
|
|
|
func (ctx *context) GetString(pname Enum) (r0 string) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetString(%v) %v%v", pname, r0, errstr)
|
|
}()
|
|
ret := ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetString,
|
|
a0: pname.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
return C.GoString((*C.char)((unsafe.Pointer(uintptr(ret)))))
|
|
}
|
|
|
|
func (ctx *context) GetTexParameterfv(dst []float32, target, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetTexParameterfv(len(%d), %v, %v) %v", len(dst), target, pname, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetTexParameterfv,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) GetTexParameteriv(dst []int32, target, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetTexParameteriv(%v, %v, %v) %v", dst, target, pname, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetTexParameteriv,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) GetUniformfv(dst []float32, src Uniform, p Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetUniformfv(len(%d), %v, %v) %v", len(dst), src, p, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetUniformfv,
|
|
a0: p.c(),
|
|
a1: src.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) GetUniformiv(dst []int32, src Uniform, p Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetUniformiv(%v, %v, %v) %v", dst, src, p, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetUniformiv,
|
|
a0: p.c(),
|
|
a1: src.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) GetUniformLocation(p Program, name string) (r0 Uniform) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
r0.name = name
|
|
log.Printf("gl.GetUniformLocation(%v, %v) %v%v", p, name, r0, errstr)
|
|
}()
|
|
return Uniform{Value: int32(ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetUniformLocation,
|
|
a0: p.c(),
|
|
},
|
|
parg: unsafe.Pointer(C.CString(name)),
|
|
blocking: true,
|
|
}))}
|
|
}
|
|
|
|
func (ctx *context) GetVertexAttribf(src Attrib, pname Enum) (r0 float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetVertexAttribf(%v, %v) %v%v", src, pname, r0, errstr)
|
|
}()
|
|
var params [1]float32
|
|
ctx.GetVertexAttribfv(params[:], src, pname)
|
|
return params[0]
|
|
}
|
|
|
|
func (ctx *context) GetVertexAttribfv(dst []float32, src Attrib, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetVertexAttribfv(len(%d), %v, %v) %v", len(dst), src, pname, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetVertexAttribfv,
|
|
a0: src.c(),
|
|
a1: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) GetVertexAttribi(src Attrib, pname Enum) (r0 int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetVertexAttribi(%v, %v) %v%v", src, pname, r0, errstr)
|
|
}()
|
|
var params [1]int32
|
|
ctx.GetVertexAttribiv(params[:], src, pname)
|
|
return params[0]
|
|
}
|
|
|
|
func (ctx *context) GetVertexAttribiv(dst []int32, src Attrib, pname Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.GetVertexAttribiv(%v, %v, %v) %v", dst, src, pname, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnGetVertexAttribiv,
|
|
a0: src.c(),
|
|
a1: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Hint(target, mode Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Hint(%v, %v) %v", target, mode, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnHint,
|
|
a0: target.c(),
|
|
a1: mode.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) IsBuffer(b Buffer) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsBuffer(%v) %v%v", b, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsBuffer,
|
|
a0: b.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) IsEnabled(cap Enum) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsEnabled(%v) %v%v", cap, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsEnabled,
|
|
a0: cap.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) IsFramebuffer(fb Framebuffer) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsFramebuffer(%v) %v%v", fb, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsFramebuffer,
|
|
a0: fb.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) IsProgram(p Program) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsProgram(%v) %v%v", p, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsProgram,
|
|
a0: p.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) IsRenderbuffer(rb Renderbuffer) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsRenderbuffer(%v) %v%v", rb, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsRenderbuffer,
|
|
a0: rb.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) IsShader(s Shader) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsShader(%v) %v%v", s, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsShader,
|
|
a0: s.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) IsTexture(t Texture) (r0 bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.IsTexture(%v) %v%v", t, r0, errstr)
|
|
}()
|
|
return 0 != ctx.enqueue(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnIsTexture,
|
|
a0: t.c(),
|
|
},
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) LineWidth(width float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.LineWidth(%v) %v", width, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnLineWidth,
|
|
a0: C.uintptr_t(math.Float32bits(width)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) LinkProgram(p Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.LinkProgram(%v) %v", p, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnLinkProgram,
|
|
a0: p.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) PixelStorei(pname Enum, param int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.PixelStorei(%v, %v) %v", pname, param, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnPixelStorei,
|
|
a0: pname.c(),
|
|
a1: C.uintptr_t(param),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) PolygonOffset(factor, units float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.PolygonOffset(%v, %v) %v", factor, units, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnPolygonOffset,
|
|
a0: C.uintptr_t(math.Float32bits(factor)),
|
|
a1: C.uintptr_t(math.Float32bits(units)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ReadPixels(dst []byte, x, y, width, height int, format, ty Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ReadPixels(len(%d), %v, %v, %v, %v, %v, %v) %v", len(dst), x, y, width, height, format, ty, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnReadPixels,
|
|
|
|
a0: C.uintptr_t(x),
|
|
a1: C.uintptr_t(y),
|
|
a2: C.uintptr_t(width),
|
|
a3: C.uintptr_t(height),
|
|
a4: format.c(),
|
|
a5: ty.c(),
|
|
},
|
|
parg: unsafe.Pointer(&dst[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) ReleaseShaderCompiler() {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ReleaseShaderCompiler() %v", errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnReleaseShaderCompiler,
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) RenderbufferStorage(target, internalFormat Enum, width, height int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.RenderbufferStorage(%v, %v, %v, %v) %v", target, internalFormat, width, height, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnRenderbufferStorage,
|
|
a0: target.c(),
|
|
a1: internalFormat.c(),
|
|
a2: C.uintptr_t(width),
|
|
a3: C.uintptr_t(height),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) SampleCoverage(value float32, invert bool) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.SampleCoverage(%v, %v) %v", value, invert, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnSampleCoverage,
|
|
a0: C.uintptr_t(math.Float32bits(value)),
|
|
a1: glBoolean(invert),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Scissor(x, y, width, height int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Scissor(%v, %v, %v, %v) %v", x, y, width, height, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnScissor,
|
|
a0: C.uintptr_t(x),
|
|
a1: C.uintptr_t(y),
|
|
a2: C.uintptr_t(width),
|
|
a3: C.uintptr_t(height),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ShaderSource(s Shader, src string) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ShaderSource(%v, %v) %v", s, src, errstr)
|
|
}()
|
|
cstr := C.CString(src)
|
|
cstrp := (**C.char)(C.malloc(C.size_t(unsafe.Sizeof(cstr))))
|
|
*cstrp = cstr
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnShaderSource,
|
|
a0: s.c(),
|
|
a1: 1,
|
|
a2: C.uintptr_t(uintptr(unsafe.Pointer(cstrp))),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) StencilFunc(fn Enum, ref int, mask uint32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.StencilFunc(%v, %v, %v) %v", fn, ref, mask, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnStencilFunc,
|
|
a0: fn.c(),
|
|
a1: C.uintptr_t(ref),
|
|
a2: C.uintptr_t(mask),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) StencilFuncSeparate(face, fn Enum, ref int, mask uint32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.StencilFuncSeparate(%v, %v, %v, %v) %v", face, fn, ref, mask, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnStencilFuncSeparate,
|
|
a0: face.c(),
|
|
a1: fn.c(),
|
|
a2: C.uintptr_t(ref),
|
|
a3: C.uintptr_t(mask),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) StencilMask(mask uint32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.StencilMask(%v) %v", mask, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnStencilMask,
|
|
a0: C.uintptr_t(mask),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) StencilMaskSeparate(face Enum, mask uint32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.StencilMaskSeparate(%v, %v) %v", face, mask, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnStencilMaskSeparate,
|
|
a0: face.c(),
|
|
a1: C.uintptr_t(mask),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) StencilOp(fail, zfail, zpass Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.StencilOp(%v, %v, %v) %v", fail, zfail, zpass, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnStencilOp,
|
|
a0: fail.c(),
|
|
a1: zfail.c(),
|
|
a2: zpass.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) StencilOpSeparate(face, sfail, dpfail, dppass Enum) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.StencilOpSeparate(%v, %v, %v, %v) %v", face, sfail, dpfail, dppass, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnStencilOpSeparate,
|
|
a0: face.c(),
|
|
a1: sfail.c(),
|
|
a2: dpfail.c(),
|
|
a3: dppass.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) TexImage2D(target Enum, level int, width, height int, format Enum, ty Enum, data []byte) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.TexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, width, height, format, ty, len(data), errstr)
|
|
}()
|
|
parg := unsafe.Pointer(nil)
|
|
if len(data) > 0 {
|
|
parg = unsafe.Pointer(&data[0])
|
|
}
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnTexImage2D,
|
|
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(level),
|
|
a2: C.uintptr_t(format),
|
|
a3: C.uintptr_t(width),
|
|
a4: C.uintptr_t(height),
|
|
a5: format.c(),
|
|
a6: ty.c(),
|
|
},
|
|
parg: parg,
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
|
|
defer func() {
|
|
errstr := ctx.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)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnTexSubImage2D,
|
|
|
|
a0: target.c(),
|
|
a1: C.uintptr_t(level),
|
|
a2: C.uintptr_t(x),
|
|
a3: C.uintptr_t(y),
|
|
a4: C.uintptr_t(width),
|
|
a5: C.uintptr_t(height),
|
|
a6: format.c(),
|
|
a7: ty.c(),
|
|
},
|
|
parg: unsafe.Pointer(&data[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) TexParameterf(target, pname Enum, param float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.TexParameterf(%v, %v, %v) %v", target, pname, param, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnTexParameterf,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
a2: C.uintptr_t(math.Float32bits(param)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) TexParameterfv(target, pname Enum, params []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.TexParameterfv(%v, %v, len(%d)) %v", target, pname, len(params), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnTexParameterfv,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(¶ms[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) TexParameteri(target, pname Enum, param int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.TexParameteri(%v, %v, %v) %v", target, pname, param, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnTexParameteri,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
a2: C.uintptr_t(param),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) TexParameteriv(target, pname Enum, params []int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.TexParameteriv(%v, %v, %v) %v", target, pname, params, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnTexParameteriv,
|
|
a0: target.c(),
|
|
a1: pname.c(),
|
|
},
|
|
parg: unsafe.Pointer(¶ms[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform1f(dst Uniform, v float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform1f(%v, %v) %v", dst, v, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform1f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(v)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform1fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform1fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform1fv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src)),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform1i(dst Uniform, v int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform1i(%v, %v) %v", dst, v, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform1i,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(v),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform1iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform1iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform1iv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src)),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform2f(dst Uniform, v0, v1 float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform2f(%v, %v, %v) %v", dst, v0, v1, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform2f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(v0)),
|
|
a2: C.uintptr_t(math.Float32bits(v1)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform2fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform2fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform2fv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 2),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform2i(dst Uniform, v0, v1 int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform2i(%v, %v, %v) %v", dst, v0, v1, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform2i,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(v0),
|
|
a2: C.uintptr_t(v1),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform2iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform2iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform2iv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 2),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform3f(dst Uniform, v0, v1, v2 float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform3f(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform3f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(v0)),
|
|
a2: C.uintptr_t(math.Float32bits(v1)),
|
|
a3: C.uintptr_t(math.Float32bits(v2)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform3fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform3fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform3fv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 3),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform3i(dst Uniform, v0, v1, v2 int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform3i(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform3i,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(v0),
|
|
a2: C.uintptr_t(v1),
|
|
a3: C.uintptr_t(v2),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform3iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform3iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform3iv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 3),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform4f(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform4f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(v0)),
|
|
a2: C.uintptr_t(math.Float32bits(v1)),
|
|
a3: C.uintptr_t(math.Float32bits(v2)),
|
|
a4: C.uintptr_t(math.Float32bits(v3)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform4fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform4fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform4fv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 4),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) Uniform4i(dst Uniform, v0, v1, v2, v3 int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform4i(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform4i,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(v0),
|
|
a2: C.uintptr_t(v1),
|
|
a3: C.uintptr_t(v2),
|
|
a4: C.uintptr_t(v3),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Uniform4iv(dst Uniform, src []int32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Uniform4iv(%v, %v) %v", dst, src, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniform4iv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 4),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) UniformMatrix2fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.UniformMatrix2fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniformMatrix2fv,
|
|
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 4),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) UniformMatrix3fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.UniformMatrix3fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniformMatrix3fv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 9),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) UniformMatrix4fv(dst Uniform, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.UniformMatrix4fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUniformMatrix4fv,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(len(src) / 16),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) UseProgram(p Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.UseProgram(%v) %v", p, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnUseProgram,
|
|
a0: p.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) ValidateProgram(p Program) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.ValidateProgram(%v) %v", p, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnValidateProgram,
|
|
a0: p.c(),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib1f(dst Attrib, x float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib1f(%v, %v) %v", dst, x, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib1f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(x)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib1fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib1fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib1fv,
|
|
a0: dst.c(),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib2f(dst Attrib, x, y float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib2f(%v, %v, %v) %v", dst, x, y, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib2f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(x)),
|
|
a2: C.uintptr_t(math.Float32bits(y)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib2fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib2fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib2fv,
|
|
a0: dst.c(),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib3f(dst Attrib, x, y, z float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib3f(%v, %v, %v, %v) %v", dst, x, y, z, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib3f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(x)),
|
|
a2: C.uintptr_t(math.Float32bits(y)),
|
|
a3: C.uintptr_t(math.Float32bits(z)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib3fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib3fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib3fv,
|
|
a0: dst.c(),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib4f(dst Attrib, x, y, z, w float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib4f(%v, %v, %v, %v, %v) %v", dst, x, y, z, w, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib4f,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(math.Float32bits(x)),
|
|
a2: C.uintptr_t(math.Float32bits(y)),
|
|
a3: C.uintptr_t(math.Float32bits(z)),
|
|
a4: C.uintptr_t(math.Float32bits(w)),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) VertexAttrib4fv(dst Attrib, src []float32) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttrib4fv(%v, len(%d)) %v", dst, len(src), errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttrib4fv,
|
|
a0: dst.c(),
|
|
},
|
|
parg: unsafe.Pointer(&src[0]),
|
|
blocking: true,
|
|
})
|
|
}
|
|
|
|
func (ctx *context) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.VertexAttribPointer(%v, %v, %v, %v, %v, %v) %v", dst, size, ty, normalized, stride, offset, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnVertexAttribPointer,
|
|
a0: dst.c(),
|
|
a1: C.uintptr_t(size),
|
|
a2: ty.c(),
|
|
a3: glBoolean(normalized),
|
|
a4: C.uintptr_t(stride),
|
|
a5: C.uintptr_t(offset),
|
|
},
|
|
blocking: true})
|
|
}
|
|
|
|
func (ctx *context) Viewport(x, y, width, height int) {
|
|
defer func() {
|
|
errstr := ctx.errDrain()
|
|
log.Printf("gl.Viewport(%v, %v, %v, %v) %v", x, y, width, height, errstr)
|
|
}()
|
|
ctx.enqueueDebug(call{
|
|
args: C.struct_fnargs{
|
|
fn: C.glfnViewport,
|
|
a0: C.uintptr_t(x),
|
|
a1: C.uintptr_t(y),
|
|
a2: C.uintptr_t(width),
|
|
a3: C.uintptr_t(height),
|
|
},
|
|
blocking: true})
|
|
}
|