gl_unix.go raw
1 // SPDX-License-Identifier: Unlicense OR MIT
2
3 // +build darwin linux freebsd openbsd
4
5 package gl
6
7 import (
8 "runtime"
9 "strings"
10 "unsafe"
11 )
12
13 /*
14 #cgo CFLAGS: -Werror
15 #cgo linux,!android pkg-config: glesv2
16 #cgo linux freebsd LDFLAGS: -ldl
17 #cgo freebsd openbsd android LDFLAGS: -lGLESv2
18 #cgo freebsd CFLAGS: -I/usr/local/include
19 #cgo freebsd LDFLAGS: -L/usr/local/lib
20 #cgo openbsd CFLAGS: -I/usr/X11R6/include
21 #cgo openbsd LDFLAGS: -L/usr/X11R6/lib
22 #cgo darwin,!ios CFLAGS: -DGL_SILENCE_DEPRECATION
23 #cgo darwin,!ios LDFLAGS: -framework OpenGL
24 #cgo darwin,ios CFLAGS: -DGLES_SILENCE_DEPRECATION
25 #cgo darwin,ios LDFLAGS: -framework OpenGLES
26
27 #include <stdlib.h>
28 #define __USE_GNU
29 #include <dlfcn.h>
30
31 #ifdef __APPLE__
32 #include "TargetConditionals.h"
33 #if TARGET_OS_IPHONE
34 #include <OpenGLES/ES3/gl.h>
35 #else
36 #include <OpenGL/gl3.h>
37 #endif
38 #else
39 #include <GLES2/gl2.h>
40 #include <GLES3/gl3.h>
41 #endif
42
43 static void (*_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer);
44 static GLuint (*_glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
45 static void (*_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
46 static void (*_glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments);
47
48 static void (*_glBeginQuery)(GLenum target, GLuint id);
49 static void (*_glDeleteQueries)(GLsizei n, const GLuint *ids);
50 static void (*_glEndQuery)(GLenum target);
51 static void (*_glGenQueries)(GLsizei n, GLuint *ids);
52 static void (*_glGetProgramBinary)(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary);
53 static void (*_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
54 static const GLubyte* (*_glGetStringi)(GLenum name, GLuint index);
55 static void (*_glMemoryBarrier)(GLbitfield barriers);
56 static void (*_glDispatchCompute)(GLuint x, GLuint y, GLuint z);
57 static void* (*_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
58 static GLboolean (*_glUnmapBuffer)(GLenum target);
59 static void (*_glBindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
60 static void (*_glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
61 static void (*_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
62
63 // The pointer-free version of glVertexAttribPointer, to avoid the Cgo pointer checks.
64 __attribute__ ((visibility ("hidden"))) void gio_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t offset) {
65 glVertexAttribPointer(index, size, type, normalized, stride, (const GLvoid *)offset);
66 }
67
68 // The pointer-free version of glDrawElements, to avoid the Cgo pointer checks.
69 __attribute__ ((visibility ("hidden"))) void gio_glDrawElements(GLenum mode, GLsizei count, GLenum type, const uintptr_t offset) {
70 glDrawElements(mode, count, type, (const GLvoid *)offset);
71 }
72
73 __attribute__ ((visibility ("hidden"))) void gio_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) {
74 _glBindBufferBase(target, index, buffer);
75 }
76
77 __attribute__ ((visibility ("hidden"))) void gio_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
78 _glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
79 }
80
81 __attribute__ ((visibility ("hidden"))) GLuint gio_glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) {
82 return _glGetUniformBlockIndex(program, uniformBlockName);
83 }
84
85 __attribute__ ((visibility ("hidden"))) void gio_glInvalidateFramebuffer(GLenum target, GLenum attachment) {
86 // Framebuffer invalidation is just a hint and can safely be ignored.
87 if (_glInvalidateFramebuffer != NULL) {
88 _glInvalidateFramebuffer(target, 1, &attachment);
89 }
90 }
91
92 __attribute__ ((visibility ("hidden"))) void gio_glBeginQuery(GLenum target, GLenum attachment) {
93 _glBeginQuery(target, attachment);
94 }
95
96 __attribute__ ((visibility ("hidden"))) void gio_glDeleteQueries(GLsizei n, const GLuint *ids) {
97 _glDeleteQueries(n, ids);
98 }
99
100 __attribute__ ((visibility ("hidden"))) void gio_glEndQuery(GLenum target) {
101 _glEndQuery(target);
102 }
103
104 __attribute__ ((visibility ("hidden"))) const GLubyte* gio_glGetStringi(GLenum name, GLuint index) {
105 if (_glGetStringi == NULL) {
106 return NULL;
107 }
108 return _glGetStringi(name, index);
109 }
110
111 __attribute__ ((visibility ("hidden"))) void gio_glGenQueries(GLsizei n, GLuint *ids) {
112 _glGenQueries(n, ids);
113 }
114
115 __attribute__ ((visibility ("hidden"))) void gio_glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary) {
116 _glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
117 }
118
119 __attribute__ ((visibility ("hidden"))) void gio_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) {
120 _glGetQueryObjectuiv(id, pname, params);
121 }
122
123 __attribute__ ((visibility ("hidden"))) void gio_glMemoryBarrier(GLbitfield barriers) {
124 _glMemoryBarrier(barriers);
125 }
126
127 __attribute__ ((visibility ("hidden"))) void gio_glDispatchCompute(GLuint x, GLuint y, GLuint z) {
128 _glDispatchCompute(x, y, z);
129 }
130
131 __attribute__ ((visibility ("hidden"))) void *gio_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
132 return _glMapBufferRange(target, offset, length, access);
133 }
134
135 __attribute__ ((visibility ("hidden"))) GLboolean gio_glUnmapBuffer(GLenum target) {
136 return _glUnmapBuffer(target);
137 }
138
139 __attribute__ ((visibility ("hidden"))) void gio_glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) {
140 _glBindImageTexture(unit, texture, level, layered, layer, access, format);
141 }
142
143 __attribute__ ((visibility ("hidden"))) void gio_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) {
144 _glTexStorage2D(target, levels, internalFormat, width, height);
145 }
146
147 __attribute__ ((visibility ("hidden"))) void gio_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
148 _glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
149 }
150
151 __attribute__((constructor)) static void gio_loadGLFunctions() {
152 // Load libGLESv3 if available.
153 dlopen("libGLESv3.so", RTLD_NOW | RTLD_GLOBAL);
154
155 _glBindBufferBase = dlsym(RTLD_DEFAULT, "glBindBufferBase");
156 _glGetUniformBlockIndex = dlsym(RTLD_DEFAULT, "glGetUniformBlockIndex");
157 _glUniformBlockBinding = dlsym(RTLD_DEFAULT, "glUniformBlockBinding");
158 _glInvalidateFramebuffer = dlsym(RTLD_DEFAULT, "glInvalidateFramebuffer");
159 _glGetStringi = dlsym(RTLD_DEFAULT, "glGetStringi");
160 // Fall back to EXT_invalidate_framebuffer if available.
161 if (_glInvalidateFramebuffer == NULL) {
162 _glInvalidateFramebuffer = dlsym(RTLD_DEFAULT, "glDiscardFramebufferEXT");
163 }
164
165 _glBeginQuery = dlsym(RTLD_DEFAULT, "glBeginQuery");
166 if (_glBeginQuery == NULL)
167 _glBeginQuery = dlsym(RTLD_DEFAULT, "glBeginQueryEXT");
168 _glDeleteQueries = dlsym(RTLD_DEFAULT, "glDeleteQueries");
169 if (_glDeleteQueries == NULL)
170 _glDeleteQueries = dlsym(RTLD_DEFAULT, "glDeleteQueriesEXT");
171 _glEndQuery = dlsym(RTLD_DEFAULT, "glEndQuery");
172 if (_glEndQuery == NULL)
173 _glEndQuery = dlsym(RTLD_DEFAULT, "glEndQueryEXT");
174 _glGenQueries = dlsym(RTLD_DEFAULT, "glGenQueries");
175 if (_glGenQueries == NULL)
176 _glGenQueries = dlsym(RTLD_DEFAULT, "glGenQueriesEXT");
177 _glGetQueryObjectuiv = dlsym(RTLD_DEFAULT, "glGetQueryObjectuiv");
178 if (_glGetQueryObjectuiv == NULL)
179 _glGetQueryObjectuiv = dlsym(RTLD_DEFAULT, "glGetQueryObjectuivEXT");
180
181 _glMemoryBarrier = dlsym(RTLD_DEFAULT, "glMemoryBarrier");
182 _glDispatchCompute = dlsym(RTLD_DEFAULT, "glDispatchCompute");
183 _glMapBufferRange = dlsym(RTLD_DEFAULT, "glMapBufferRange");
184 _glUnmapBuffer = dlsym(RTLD_DEFAULT, "glUnmapBuffer");
185 _glBindImageTexture = dlsym(RTLD_DEFAULT, "glBindImageTexture");
186 _glTexStorage2D = dlsym(RTLD_DEFAULT, "glTexStorage2D");
187 _glBlitFramebuffer = dlsym(RTLD_DEFAULT, "glBlitFramebuffer");
188 _glGetProgramBinary = dlsym(RTLD_DEFAULT, "glGetProgramBinary");
189 }
190 */
191 import "C"
192
193 type Context interface{}
194
195 type Functions struct {
196 // Query caches.
197 uints [100]C.GLuint
198 ints [100]C.GLint
199 }
200
201 func NewFunctions(ctx Context) (*Functions, error) {
202 if ctx != nil {
203 panic("non-nil context")
204 }
205 return new(Functions), nil
206 }
207
208 func (f *Functions) ActiveTexture(texture Enum) {
209 C.glActiveTexture(C.GLenum(texture))
210 }
211
212 func (f *Functions) AttachShader(p Program, s Shader) {
213 C.glAttachShader(C.GLuint(p.V), C.GLuint(s.V))
214 }
215
216 func (f *Functions) BeginQuery(target Enum, query Query) {
217 C.gio_glBeginQuery(C.GLenum(target), C.GLenum(query.V))
218 }
219
220 func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) {
221 cname := C.CString(name)
222 defer C.free(unsafe.Pointer(cname))
223 C.glBindAttribLocation(C.GLuint(p.V), C.GLuint(a), cname)
224 }
225
226 func (f *Functions) BindBufferBase(target Enum, index int, b Buffer) {
227 C.gio_glBindBufferBase(C.GLenum(target), C.GLuint(index), C.GLuint(b.V))
228 }
229
230 func (f *Functions) BindBuffer(target Enum, b Buffer) {
231 C.glBindBuffer(C.GLenum(target), C.GLuint(b.V))
232 }
233
234 func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
235 C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb.V))
236 }
237
238 func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) {
239 C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb.V))
240 }
241
242 func (f *Functions) BindImageTexture(unit int, t Texture, level int, layered bool, layer int, access, format Enum) {
243 l := C.GLboolean(C.GL_FALSE)
244 if layered {
245 l = C.GL_TRUE
246 }
247 C.gio_glBindImageTexture(C.GLuint(unit), C.GLuint(t.V), C.GLint(level), l, C.GLint(layer), C.GLenum(access), C.GLenum(format))
248 }
249
250 func (f *Functions) BindTexture(target Enum, t Texture) {
251 C.glBindTexture(C.GLenum(target), C.GLuint(t.V))
252 }
253
254 func (f *Functions) BlendEquation(mode Enum) {
255 C.glBlendEquation(C.GLenum(mode))
256 }
257
258 func (f *Functions) BlendFunc(sfactor, dfactor Enum) {
259 C.glBlendFunc(C.GLenum(sfactor), C.GLenum(dfactor))
260 }
261
262 func (f *Functions) BlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1 int, mask Enum, filter Enum) {
263 C.gio_glBlitFramebuffer(
264 C.GLint(sx0), C.GLint(sy0), C.GLint(sx1), C.GLint(sy1),
265 C.GLint(dx0), C.GLint(dy0), C.GLint(dx1), C.GLint(dy1),
266 C.GLenum(mask), C.GLenum(filter),
267 )
268 }
269
270 func (f *Functions) BufferData(target Enum, size int, usage Enum) {
271 C.glBufferData(C.GLenum(target), C.GLsizeiptr(size), nil, C.GLenum(usage))
272 }
273
274 func (f *Functions) BufferSubData(target Enum, offset int, src []byte) {
275 var p unsafe.Pointer
276 if len(src) > 0 {
277 p = unsafe.Pointer(&src[0])
278 }
279 C.glBufferSubData(C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(len(src)), p)
280 }
281
282 func (f *Functions) CheckFramebufferStatus(target Enum) Enum {
283 return Enum(C.glCheckFramebufferStatus(C.GLenum(target)))
284 }
285
286 func (f *Functions) Clear(mask Enum) {
287 C.glClear(C.GLbitfield(mask))
288 }
289
290 func (f *Functions) ClearColor(red float32, green float32, blue float32, alpha float32) {
291 C.glClearColor(C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha))
292 }
293
294 func (f *Functions) ClearDepthf(d float32) {
295 C.glClearDepthf(C.GLfloat(d))
296 }
297
298 func (f *Functions) CompileShader(s Shader) {
299 C.glCompileShader(C.GLuint(s.V))
300 }
301
302 func (f *Functions) CreateBuffer() Buffer {
303 C.glGenBuffers(1, &f.uints[0])
304 return Buffer{uint(f.uints[0])}
305 }
306
307 func (f *Functions) CreateFramebuffer() Framebuffer {
308 C.glGenFramebuffers(1, &f.uints[0])
309 return Framebuffer{uint(f.uints[0])}
310 }
311
312 func (f *Functions) CreateProgram() Program {
313 return Program{uint(C.glCreateProgram())}
314 }
315
316 func (f *Functions) CreateQuery() Query {
317 C.gio_glGenQueries(1, &f.uints[0])
318 return Query{uint(f.uints[0])}
319 }
320
321 func (f *Functions) CreateRenderbuffer() Renderbuffer {
322 C.glGenRenderbuffers(1, &f.uints[0])
323 return Renderbuffer{uint(f.uints[0])}
324 }
325
326 func (f *Functions) CreateShader(ty Enum) Shader {
327 return Shader{uint(C.glCreateShader(C.GLenum(ty)))}
328 }
329
330 func (f *Functions) CreateTexture() Texture {
331 C.glGenTextures(1, &f.uints[0])
332 return Texture{uint(f.uints[0])}
333 }
334
335 func (f *Functions) DeleteBuffer(v Buffer) {
336 f.uints[0] = C.GLuint(v.V)
337 C.glDeleteBuffers(1, &f.uints[0])
338 }
339
340 func (f *Functions) DeleteFramebuffer(v Framebuffer) {
341 f.uints[0] = C.GLuint(v.V)
342 C.glDeleteFramebuffers(1, &f.uints[0])
343 }
344
345 func (f *Functions) DeleteProgram(p Program) {
346 C.glDeleteProgram(C.GLuint(p.V))
347 }
348
349 func (f *Functions) DeleteQuery(query Query) {
350 f.uints[0] = C.GLuint(query.V)
351 C.gio_glDeleteQueries(1, &f.uints[0])
352 }
353
354 func (f *Functions) DeleteRenderbuffer(v Renderbuffer) {
355 f.uints[0] = C.GLuint(v.V)
356 C.glDeleteRenderbuffers(1, &f.uints[0])
357 }
358
359 func (f *Functions) DeleteShader(s Shader) {
360 C.glDeleteShader(C.GLuint(s.V))
361 }
362
363 func (f *Functions) DeleteTexture(v Texture) {
364 f.uints[0] = C.GLuint(v.V)
365 C.glDeleteTextures(1, &f.uints[0])
366 }
367
368 func (f *Functions) DepthFunc(v Enum) {
369 C.glDepthFunc(C.GLenum(v))
370 }
371
372 func (f *Functions) DepthMask(mask bool) {
373 m := C.GLboolean(C.GL_FALSE)
374 if mask {
375 m = C.GLboolean(C.GL_TRUE)
376 }
377 C.glDepthMask(m)
378 }
379
380 func (f *Functions) DisableVertexAttribArray(a Attrib) {
381 C.glDisableVertexAttribArray(C.GLuint(a))
382 }
383
384 func (f *Functions) Disable(cap Enum) {
385 C.glDisable(C.GLenum(cap))
386 }
387
388 func (f *Functions) DrawArrays(mode Enum, first int, count int) {
389 C.glDrawArrays(C.GLenum(mode), C.GLint(first), C.GLsizei(count))
390 }
391
392 func (f *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) {
393 C.gio_glDrawElements(C.GLenum(mode), C.GLsizei(count), C.GLenum(ty), C.uintptr_t(offset))
394 }
395
396 func (f *Functions) DispatchCompute(x, y, z int) {
397 C.gio_glDispatchCompute(C.GLuint(x), C.GLuint(y), C.GLuint(z))
398 }
399
400 func (f *Functions) Enable(cap Enum) {
401 C.glEnable(C.GLenum(cap))
402 }
403
404 func (f *Functions) EndQuery(target Enum) {
405 C.gio_glEndQuery(C.GLenum(target))
406 }
407
408 func (f *Functions) EnableVertexAttribArray(a Attrib) {
409 C.glEnableVertexAttribArray(C.GLuint(a))
410 }
411
412 func (f *Functions) Finish() {
413 C.glFinish()
414 }
415
416 func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
417 C.glFramebufferRenderbuffer(C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer.V))
418 }
419
420 func (f *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
421 C.glFramebufferTexture2D(C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level))
422 }
423
424 func (c *Functions) GetBinding(pname Enum) Object {
425 return Object{uint(c.GetInteger(pname))}
426 }
427
428 func (f *Functions) GetError() Enum {
429 return Enum(C.glGetError())
430 }
431
432 func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int {
433 C.glGetRenderbufferParameteriv(C.GLenum(target), C.GLenum(pname), &f.ints[0])
434 return int(f.ints[0])
435 }
436
437 func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int {
438 C.glGetFramebufferAttachmentParameteriv(C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), &f.ints[0])
439 return int(f.ints[0])
440 }
441
442 func (f *Functions) GetInteger(pname Enum) int {
443 C.glGetIntegerv(C.GLenum(pname), &f.ints[0])
444 return int(f.ints[0])
445 }
446
447 func (f *Functions) GetProgrami(p Program, pname Enum) int {
448 C.glGetProgramiv(C.GLuint(p.V), C.GLenum(pname), &f.ints[0])
449 return int(f.ints[0])
450 }
451
452 func (f *Functions) GetProgramBinary(p Program) []byte {
453 sz := f.GetProgrami(p, PROGRAM_BINARY_LENGTH)
454 if sz == 0 {
455 return nil
456 }
457 buf := make([]byte, sz)
458 var format C.GLenum
459 C.gio_glGetProgramBinary(C.GLuint(p.V), C.GLsizei(sz), nil, &format, unsafe.Pointer(&buf[0]))
460 return buf
461 }
462
463 func (f *Functions) GetProgramInfoLog(p Program) string {
464 n := f.GetProgrami(p, INFO_LOG_LENGTH)
465 buf := make([]byte, n)
466 C.glGetProgramInfoLog(C.GLuint(p.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0])))
467 return string(buf)
468 }
469
470 func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
471 C.gio_glGetQueryObjectuiv(C.GLuint(query.V), C.GLenum(pname), &f.uints[0])
472 return uint(f.uints[0])
473 }
474
475 func (f *Functions) GetShaderi(s Shader, pname Enum) int {
476 C.glGetShaderiv(C.GLuint(s.V), C.GLenum(pname), &f.ints[0])
477 return int(f.ints[0])
478 }
479
480 func (f *Functions) GetShaderInfoLog(s Shader) string {
481 n := f.GetShaderi(s, INFO_LOG_LENGTH)
482 buf := make([]byte, n)
483 C.glGetShaderInfoLog(C.GLuint(s.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0])))
484 return string(buf)
485 }
486
487 func (f *Functions) GetStringi(pname Enum, index int) string {
488 str := C.gio_glGetStringi(C.GLenum(pname), C.GLuint(index))
489 if str == nil {
490 return ""
491 }
492 return C.GoString((*C.char)(unsafe.Pointer(str)))
493 }
494
495 func (f *Functions) GetString(pname Enum) string {
496 switch {
497 case runtime.GOOS == "darwin" && pname == EXTENSIONS:
498 // macOS OpenGL 3 core profile doesn't support glGetString(GL_EXTENSIONS).
499 // Use glGetStringi(GL_EXTENSIONS, <index>).
500 var exts []string
501 nexts := f.GetInteger(NUM_EXTENSIONS)
502 for i := 0; i < nexts; i++ {
503 ext := f.GetStringi(EXTENSIONS, i)
504 exts = append(exts, ext)
505 }
506 return strings.Join(exts, " ")
507 default:
508 str := C.glGetString(C.GLenum(pname))
509 return C.GoString((*C.char)(unsafe.Pointer(str)))
510 }
511 }
512
513 func (f *Functions) GetUniformBlockIndex(p Program, name string) uint {
514 cname := C.CString(name)
515 defer C.free(unsafe.Pointer(cname))
516 return uint(C.gio_glGetUniformBlockIndex(C.GLuint(p.V), cname))
517 }
518
519 func (f *Functions) GetUniformLocation(p Program, name string) Uniform {
520 cname := C.CString(name)
521 defer C.free(unsafe.Pointer(cname))
522 return Uniform{int(C.glGetUniformLocation(C.GLuint(p.V), cname))}
523 }
524
525 func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
526 C.gio_glInvalidateFramebuffer(C.GLenum(target), C.GLenum(attachment))
527 }
528
529 func (f *Functions) LinkProgram(p Program) {
530 C.glLinkProgram(C.GLuint(p.V))
531 }
532
533 func (f *Functions) PixelStorei(pname Enum, param int32) {
534 C.glPixelStorei(C.GLenum(pname), C.GLint(param))
535 }
536
537 func (f *Functions) MemoryBarrier(barriers Enum) {
538 C.gio_glMemoryBarrier(C.GLbitfield(barriers))
539 }
540
541 func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum) []byte {
542 p := C.gio_glMapBufferRange(C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length), C.GLbitfield(access))
543 if p == nil {
544 return nil
545 }
546 return (*[1 << 30]byte)(p)[:length:length]
547 }
548
549 func (f *Functions) Scissor(x, y, width, height int32) {
550 C.glScissor(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
551 }
552
553 func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []byte) {
554 var p unsafe.Pointer
555 if len(data) > 0 {
556 p = unsafe.Pointer(&data[0])
557 }
558 C.glReadPixels(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(ty), p)
559 }
560
561 func (f *Functions) RenderbufferStorage(target, internalformat Enum, width, height int) {
562 C.glRenderbufferStorage(C.GLenum(target), C.GLenum(internalformat), C.GLsizei(width), C.GLsizei(height))
563 }
564
565 func (f *Functions) ShaderSource(s Shader, src string) {
566 csrc := C.CString(src)
567 defer C.free(unsafe.Pointer(csrc))
568 strlen := C.GLint(len(src))
569 C.glShaderSource(C.GLuint(s.V), 1, &csrc, &strlen)
570 }
571
572 func (f *Functions) TexImage2D(target Enum, level int, internalFormat Enum, width int, height int, format Enum, ty Enum) {
573 C.glTexImage2D(C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), 0, C.GLenum(format), C.GLenum(ty), nil)
574 }
575
576 func (f *Functions) TexStorage2D(target Enum, levels int, internalFormat Enum, width, height int) {
577 C.gio_glTexStorage2D(C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height))
578 }
579
580 func (f *Functions) TexSubImage2D(target Enum, level int, x int, y int, width int, height int, format Enum, ty Enum, data []byte) {
581 var p unsafe.Pointer
582 if len(data) > 0 {
583 p = unsafe.Pointer(&data[0])
584 }
585 C.glTexSubImage2D(C.GLenum(target), C.GLint(level), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(ty), p)
586 }
587
588 func (f *Functions) TexParameteri(target, pname Enum, param int) {
589 C.glTexParameteri(C.GLenum(target), C.GLenum(pname), C.GLint(param))
590 }
591
592 func (f *Functions) UniformBlockBinding(p Program, uniformBlockIndex uint, uniformBlockBinding uint) {
593 C.gio_glUniformBlockBinding(C.GLuint(p.V), C.GLuint(uniformBlockIndex), C.GLuint(uniformBlockBinding))
594 }
595
596 func (f *Functions) Uniform1f(dst Uniform, v float32) {
597 C.glUniform1f(C.GLint(dst.V), C.GLfloat(v))
598 }
599
600 func (f *Functions) Uniform1i(dst Uniform, v int) {
601 C.glUniform1i(C.GLint(dst.V), C.GLint(v))
602 }
603
604 func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) {
605 C.glUniform2f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1))
606 }
607
608 func (f *Functions) Uniform3f(dst Uniform, v0 float32, v1 float32, v2 float32) {
609 C.glUniform3f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2))
610 }
611
612 func (f *Functions) Uniform4f(dst Uniform, v0 float32, v1 float32, v2 float32, v3 float32) {
613 C.glUniform4f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3))
614 }
615
616 func (f *Functions) UseProgram(p Program) {
617 C.glUseProgram(C.GLuint(p.V))
618 }
619
620 func (f *Functions) UnmapBuffer(target Enum) bool {
621 r := C.gio_glUnmapBuffer(C.GLenum(target))
622 return r == C.GL_TRUE
623 }
624
625 func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride int, offset int) {
626 var n C.GLboolean = C.GL_FALSE
627 if normalized {
628 n = C.GL_TRUE
629 }
630 C.gio_glVertexAttribPointer(C.GLuint(dst), C.GLint(size), C.GLenum(ty), n, C.GLsizei(stride), C.uintptr_t(offset))
631 }
632
633 func (f *Functions) Viewport(x int, y int, width int, height int) {
634 C.glViewport(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
635 }
636