diff --git a/internal/graphicsdriver/opengl/gl/package_purego.go b/internal/graphicsdriver/opengl/gl/package_darwin.go similarity index 99% rename from internal/graphicsdriver/opengl/gl/package_purego.go rename to internal/graphicsdriver/opengl/gl/package_darwin.go index 17238533a..c87ba3305 100644 --- a/internal/graphicsdriver/opengl/gl/package_purego.go +++ b/internal/graphicsdriver/opengl/gl/package_darwin.go @@ -1,8 +1,5 @@ // SPDX-License-Identifier: MIT -//go:build darwin || windows -// +build darwin windows - package gl import ( diff --git a/internal/graphicsdriver/opengl/gl/package_notpurego.go b/internal/graphicsdriver/opengl/gl/package_others.go similarity index 100% rename from internal/graphicsdriver/opengl/gl/package_notpurego.go rename to internal/graphicsdriver/opengl/gl/package_others.go diff --git a/internal/graphicsdriver/opengl/gl/package_windows.go b/internal/graphicsdriver/opengl/gl/package_windows.go new file mode 100644 index 000000000..fdae541a0 --- /dev/null +++ b/internal/graphicsdriver/opengl/gl/package_windows.go @@ -0,0 +1,677 @@ +// SPDX-License-Identifier: MIT + +package gl + +import ( + "errors" + "math" + "syscall" + "unsafe" +) + +var ( + gpActiveTexture uintptr + gpAttachShader uintptr + gpBindAttribLocation uintptr + gpBindBuffer uintptr + gpBindFramebufferEXT uintptr + gpBindRenderbufferEXT uintptr + gpBindTexture uintptr + gpBlendFunc uintptr + gpBufferData uintptr + gpBufferSubData uintptr + gpCheckFramebufferStatusEXT uintptr + gpClear uintptr + gpColorMask uintptr + gpCompileShader uintptr + gpCreateProgram uintptr + gpCreateShader uintptr + gpDeleteBuffers uintptr + gpDeleteFramebuffersEXT uintptr + gpDeleteProgram uintptr + gpDeleteRenderbuffersEXT uintptr + gpDeleteShader uintptr + gpDeleteTextures uintptr + gpDisable uintptr + gpDisableVertexAttribArray uintptr + gpDrawElements uintptr + gpEnable uintptr + gpEnableVertexAttribArray uintptr + gpFlush uintptr + gpFramebufferRenderbufferEXT uintptr + gpFramebufferTexture2DEXT uintptr + gpGenBuffers uintptr + gpGenFramebuffersEXT uintptr + gpGenRenderbuffersEXT uintptr + gpGenTextures uintptr + gpGetDoublei_v uintptr + gpGetDoublei_vEXT uintptr + gpGetError uintptr + gpGetFloati_v uintptr + gpGetFloati_vEXT uintptr + gpGetIntegeri_v uintptr + gpGetIntegerui64i_vNV uintptr + gpGetIntegerv uintptr + gpGetPointeri_vEXT uintptr + gpGetProgramInfoLog uintptr + gpGetProgramiv uintptr + gpGetShaderInfoLog uintptr + gpGetShaderiv uintptr + gpGetTransformFeedbacki64_v uintptr + gpGetTransformFeedbacki_v uintptr + gpGetUniformLocation uintptr + gpGetUnsignedBytei_vEXT uintptr + gpGetVertexArrayIntegeri_vEXT uintptr + gpGetVertexArrayPointeri_vEXT uintptr + gpIsFramebufferEXT uintptr + gpIsProgram uintptr + gpIsRenderbufferEXT uintptr + gpIsTexture uintptr + gpLinkProgram uintptr + gpPixelStorei uintptr + gpReadPixels uintptr + gpRenderbufferStorageEXT uintptr + gpScissor uintptr + gpShaderSource uintptr + gpStencilFunc uintptr + gpStencilOp uintptr + gpTexImage2D uintptr + gpTexParameteri uintptr + gpTexSubImage2D uintptr + gpUniform1f uintptr + gpUniform1i uintptr + gpUniform1fv uintptr + gpUniform2fv uintptr + gpUniform3fv uintptr + gpUniform4fv uintptr + gpUniformMatrix2fv uintptr + gpUniformMatrix3fv uintptr + gpUniformMatrix4fv uintptr + gpUseProgram uintptr + gpVertexAttribPointer uintptr + gpViewport uintptr +) + +func boolToUintptr(b bool) uintptr { + if b { + return 1 + } + return 0 +} + +func ActiveTexture(texture uint32) { + _, _, _ = syscall.Syscall(gpActiveTexture, 1, uintptr(texture), 0, 0) +} + +func AttachShader(program uint32, shader uint32) { + _, _, _ = syscall.Syscall(gpAttachShader, 2, uintptr(program), uintptr(shader), 0) +} + +func BindAttribLocation(program uint32, index uint32, name *uint8) { + _, _, _ = syscall.Syscall(gpBindAttribLocation, 3, uintptr(program), uintptr(index), uintptr(unsafe.Pointer(name))) +} + +func BindBuffer(target uint32, buffer uint32) { + _, _, _ = syscall.Syscall(gpBindBuffer, 2, uintptr(target), uintptr(buffer), 0) +} + +func BindFramebufferEXT(target uint32, framebuffer uint32) { + _, _, _ = syscall.Syscall(gpBindFramebufferEXT, 2, uintptr(target), uintptr(framebuffer), 0) +} + +func BindRenderbufferEXT(target uint32, renderbuffer uint32) { + _, _, _ = syscall.Syscall(gpBindRenderbufferEXT, 2, uintptr(target), uintptr(renderbuffer), 0) +} + +func BindTexture(target uint32, texture uint32) { + _, _, _ = syscall.Syscall(gpBindTexture, 2, uintptr(target), uintptr(texture), 0) +} + +func BlendFunc(sfactor uint32, dfactor uint32) { + _, _, _ = syscall.Syscall(gpBlendFunc, 2, uintptr(sfactor), uintptr(dfactor), 0) +} + +func BufferData(target uint32, size int, data unsafe.Pointer, usage uint32) { + _, _, _ = syscall.Syscall6(gpBufferData, 4, uintptr(target), uintptr(size), uintptr(data), uintptr(usage), 0, 0) +} + +func BufferSubData(target uint32, offset int, size int, data unsafe.Pointer) { + _, _, _ = syscall.Syscall6(gpBufferSubData, 4, uintptr(target), uintptr(offset), uintptr(size), uintptr(data), 0, 0) +} + +func CheckFramebufferStatusEXT(target uint32) uint32 { + ret, _, _ := syscall.Syscall(gpCheckFramebufferStatusEXT, 1, uintptr(target), 0, 0) + return uint32(ret) +} + +func Clear(mask uint32) { + _, _, _ = syscall.Syscall(gpClear, 1, uintptr(mask), 0, 0) +} + +func ColorMask(red bool, green bool, blue bool, alpha bool) { + _, _, _ = syscall.Syscall6(gpColorMask, 4, boolToUintptr(red), boolToUintptr(green), boolToUintptr(blue), boolToUintptr(alpha), 0, 0) +} + +func CompileShader(shader uint32) { + _, _, _ = syscall.Syscall(gpCompileShader, 1, uintptr(shader), 0, 0) +} + +func CreateProgram() uint32 { + ret, _, _ := syscall.Syscall(gpCreateProgram, 0, 0, 0, 0) + return uint32(ret) +} + +func CreateShader(xtype uint32) uint32 { + ret, _, _ := syscall.Syscall(gpCreateShader, 1, uintptr(xtype), 0, 0) + return uint32(ret) +} + +func DeleteBuffers(n int32, buffers *uint32) { + _, _, _ = syscall.Syscall(gpDeleteBuffers, 2, uintptr(n), uintptr(unsafe.Pointer(buffers)), 0) +} + +func DeleteFramebuffersEXT(n int32, framebuffers *uint32) { + _, _, _ = syscall.Syscall(gpDeleteFramebuffersEXT, 2, uintptr(n), uintptr(unsafe.Pointer(framebuffers)), 0) +} + +func DeleteProgram(program uint32) { + _, _, _ = syscall.Syscall(gpDeleteProgram, 1, uintptr(program), 0, 0) +} + +func DeleteRenderbuffersEXT(n int32, renderbuffers *uint32) { + _, _, _ = syscall.Syscall(gpDeleteRenderbuffersEXT, 2, uintptr(n), uintptr(unsafe.Pointer(renderbuffers)), 0) +} + +func DeleteShader(shader uint32) { + _, _, _ = syscall.Syscall(gpDeleteShader, 1, uintptr(shader), 0, 0) +} + +func DeleteTextures(n int32, textures *uint32) { + _, _, _ = syscall.Syscall(gpDeleteTextures, 2, uintptr(n), uintptr(unsafe.Pointer(textures)), 0) +} + +func Disable(cap uint32) { + _, _, _ = syscall.Syscall(gpDisable, 1, uintptr(cap), 0, 0) +} + +func DisableVertexAttribArray(index uint32) { + _, _, _ = syscall.Syscall(gpDisableVertexAttribArray, 1, uintptr(index), 0, 0) +} + +func DrawElements(mode uint32, count int32, xtype uint32, indices uintptr) { + _, _, _ = syscall.Syscall6(gpDrawElements, 4, uintptr(mode), uintptr(count), uintptr(xtype), uintptr(indices), 0, 0) +} + +func Enable(cap uint32) { + _, _, _ = syscall.Syscall(gpEnable, 1, uintptr(cap), 0, 0) +} + +func EnableVertexAttribArray(index uint32) { + _, _, _ = syscall.Syscall(gpEnableVertexAttribArray, 1, uintptr(index), 0, 0) +} + +func Flush() { + _, _, _ = syscall.Syscall(gpFlush, 0, 0, 0, 0) +} + +func FramebufferRenderbufferEXT(target uint32, attachment uint32, renderbuffertarget uint32, renderbuffer uint32) { + _, _, _ = syscall.Syscall6(gpFramebufferRenderbufferEXT, 4, uintptr(target), uintptr(attachment), uintptr(renderbuffertarget), uintptr(renderbuffer), 0, 0) +} + +func FramebufferTexture2DEXT(target uint32, attachment uint32, textarget uint32, texture uint32, level int32) { + _, _, _ = syscall.Syscall6(gpFramebufferTexture2DEXT, 5, uintptr(target), uintptr(attachment), uintptr(textarget), uintptr(texture), uintptr(level), 0) +} + +func GenBuffers(n int32, buffers *uint32) { + _, _, _ = syscall.Syscall(gpGenBuffers, 2, uintptr(n), uintptr(unsafe.Pointer(buffers)), 0) +} + +func GenFramebuffersEXT(n int32, framebuffers *uint32) { + _, _, _ = syscall.Syscall(gpGenFramebuffersEXT, 2, uintptr(n), uintptr(unsafe.Pointer(framebuffers)), 0) +} + +func GenRenderbuffersEXT(n int32, renderbuffers *uint32) { + _, _, _ = syscall.Syscall(gpGenRenderbuffersEXT, 2, uintptr(n), uintptr(unsafe.Pointer(renderbuffers)), 0) +} + +func GenTextures(n int32, textures *uint32) { + _, _, _ = syscall.Syscall(gpGenTextures, 2, uintptr(n), uintptr(unsafe.Pointer(textures)), 0) +} + +func GetDoublei_v(target uint32, index uint32, data *float64) { + _, _, _ = syscall.Syscall(gpGetDoublei_v, 3, uintptr(target), uintptr(index), uintptr(unsafe.Pointer(data))) +} +func GetDoublei_vEXT(pname uint32, index uint32, params *float64) { + _, _, _ = syscall.Syscall(gpGetDoublei_vEXT, 3, uintptr(pname), uintptr(index), uintptr(unsafe.Pointer(params))) +} + +func GetError() uint32 { + ret, _, _ := syscall.Syscall(gpGetError, 0, 0, 0, 0) + return uint32(ret) +} +func GetFloati_v(target uint32, index uint32, data *float32) { + _, _, _ = syscall.Syscall(gpGetFloati_v, 3, uintptr(target), uintptr(index), uintptr(unsafe.Pointer(data))) +} +func GetFloati_vEXT(pname uint32, index uint32, params *float32) { + _, _, _ = syscall.Syscall(gpGetFloati_vEXT, 3, uintptr(pname), uintptr(index), uintptr(unsafe.Pointer(params))) +} + +func GetIntegeri_v(target uint32, index uint32, data *int32) { + _, _, _ = syscall.Syscall(gpGetIntegeri_v, 3, uintptr(target), uintptr(index), uintptr(unsafe.Pointer(data))) +} +func GetIntegerui64i_vNV(value uint32, index uint32, result *uint64) { + _, _, _ = syscall.Syscall(gpGetIntegerui64i_vNV, 3, uintptr(value), uintptr(index), uintptr(unsafe.Pointer(result))) +} +func GetIntegerv(pname uint32, data *int32) { + _, _, _ = syscall.Syscall(gpGetIntegerv, 2, uintptr(pname), uintptr(unsafe.Pointer(data)), 0) +} + +func GetPointeri_vEXT(pname uint32, index uint32, params *unsafe.Pointer) { + _, _, _ = syscall.Syscall(gpGetPointeri_vEXT, 3, uintptr(pname), uintptr(index), uintptr(unsafe.Pointer(params))) +} + +func GetProgramInfoLog(program uint32, bufSize int32, length *int32, infoLog *uint8) { + _, _, _ = syscall.Syscall6(gpGetProgramInfoLog, 4, uintptr(program), uintptr(bufSize), uintptr(unsafe.Pointer(length)), uintptr(unsafe.Pointer(infoLog)), 0, 0) +} + +func GetProgramiv(program uint32, pname uint32, params *int32) { + _, _, _ = syscall.Syscall(gpGetProgramiv, 3, uintptr(program), uintptr(pname), uintptr(unsafe.Pointer(params))) +} + +func GetShaderInfoLog(shader uint32, bufSize int32, length *int32, infoLog *uint8) { + _, _, _ = syscall.Syscall6(gpGetShaderInfoLog, 4, uintptr(shader), uintptr(bufSize), uintptr(unsafe.Pointer(length)), uintptr(unsafe.Pointer(infoLog)), 0, 0) +} + +func GetShaderiv(shader uint32, pname uint32, params *int32) { + _, _, _ = syscall.Syscall(gpGetShaderiv, 3, uintptr(shader), uintptr(pname), uintptr(unsafe.Pointer(params))) +} + +func GetTransformFeedbacki64_v(xfb uint32, pname uint32, index uint32, param *int64) { + _, _, _ = syscall.Syscall6(gpGetTransformFeedbacki64_v, 4, uintptr(xfb), uintptr(pname), uintptr(index), uintptr(unsafe.Pointer(param)), 0, 0) +} +func GetTransformFeedbacki_v(xfb uint32, pname uint32, index uint32, param *int32) { + _, _, _ = syscall.Syscall6(gpGetTransformFeedbacki_v, 4, uintptr(xfb), uintptr(pname), uintptr(index), uintptr(unsafe.Pointer(param)), 0, 0) +} + +func GetUniformLocation(program uint32, name *uint8) int32 { + ret, _, _ := syscall.Syscall(gpGetUniformLocation, 2, uintptr(program), uintptr(unsafe.Pointer(name)), 0) + return int32(ret) +} + +func GetUnsignedBytei_vEXT(target uint32, index uint32, data *uint8) { + _, _, _ = syscall.Syscall(gpGetUnsignedBytei_vEXT, 3, uintptr(target), uintptr(index), uintptr(unsafe.Pointer(data))) +} +func GetVertexArrayIntegeri_vEXT(vaobj uint32, index uint32, pname uint32, param *int32) { + _, _, _ = syscall.Syscall6(gpGetVertexArrayIntegeri_vEXT, 4, uintptr(vaobj), uintptr(index), uintptr(pname), uintptr(unsafe.Pointer(param)), 0, 0) +} +func GetVertexArrayPointeri_vEXT(vaobj uint32, index uint32, pname uint32, param *unsafe.Pointer) { + _, _, _ = syscall.Syscall6(gpGetVertexArrayPointeri_vEXT, 4, uintptr(vaobj), uintptr(index), uintptr(pname), uintptr(unsafe.Pointer(param)), 0, 0) +} + +func IsFramebufferEXT(framebuffer uint32) bool { + ret, _, _ := syscall.Syscall(gpIsFramebufferEXT, 1, uintptr(framebuffer), 0, 0) + return byte(ret) != 0 +} + +func IsProgram(program uint32) bool { + ret, _, _ := syscall.Syscall(gpIsProgram, 1, uintptr(program), 0, 0) + return byte(ret) != 0 +} + +func IsRenderbufferEXT(renderbuffer uint32) bool { + ret, _, _ := syscall.Syscall(gpIsRenderbufferEXT, 1, uintptr(renderbuffer), 0, 0) + return byte(ret) != 0 +} + +func IsTexture(texture uint32) bool { + ret, _, _ := syscall.Syscall(gpIsTexture, 1, uintptr(texture), 0, 0) + return byte(ret) != 0 +} + +func LinkProgram(program uint32) { + _, _, _ = syscall.Syscall(gpLinkProgram, 1, uintptr(program), 0, 0) +} + +func PixelStorei(pname uint32, param int32) { + _, _, _ = syscall.Syscall(gpPixelStorei, 2, uintptr(pname), uintptr(param), 0) +} + +func ReadPixels(x int32, y int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + _, _, _ = syscall.Syscall9(gpReadPixels, 7, uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(format), uintptr(xtype), uintptr(pixels), 0, 0) +} + +func RenderbufferStorageEXT(target uint32, internalformat uint32, width int32, height int32) { + _, _, _ = syscall.Syscall6(gpRenderbufferStorageEXT, 4, uintptr(target), uintptr(internalformat), uintptr(width), uintptr(height), 0, 0) +} + +func Scissor(x int32, y int32, width int32, height int32) { + _, _, _ = syscall.Syscall6(gpScissor, 4, uintptr(x), uintptr(y), uintptr(width), uintptr(height), 0, 0) +} + +func ShaderSource(shader uint32, count int32, xstring **uint8, length *int32) { + _, _, _ = syscall.Syscall6(gpShaderSource, 4, uintptr(shader), uintptr(count), uintptr(unsafe.Pointer(xstring)), uintptr(unsafe.Pointer(length)), 0, 0) +} + +func StencilFunc(xfunc uint32, ref int32, mask uint32) { + _, _, _ = syscall.Syscall(gpStencilFunc, 3, uintptr(xfunc), uintptr(ref), uintptr(mask)) +} + +func StencilOp(fail uint32, zfail uint32, zpass uint32) { + _, _, _ = syscall.Syscall(gpStencilOp, 3, uintptr(fail), uintptr(zfail), uintptr(zpass)) +} + +func TexImage2D(target uint32, level int32, internalformat int32, width int32, height int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + _, _, _ = syscall.Syscall9(gpTexImage2D, 9, uintptr(target), uintptr(level), uintptr(internalformat), uintptr(width), uintptr(height), uintptr(border), uintptr(format), uintptr(xtype), uintptr(pixels)) +} + +func TexParameteri(target uint32, pname uint32, param int32) { + _, _, _ = syscall.Syscall(gpTexParameteri, 3, uintptr(target), uintptr(pname), uintptr(param)) +} + +func TexSubImage2D(target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + _, _, _ = syscall.Syscall9(gpTexSubImage2D, 9, uintptr(target), uintptr(level), uintptr(xoffset), uintptr(yoffset), uintptr(width), uintptr(height), uintptr(format), uintptr(xtype), uintptr(pixels)) +} + +func Uniform1f(location int32, v0 float32) { + _, _, _ = syscall.Syscall(gpUniform1f, 2, uintptr(location), uintptr(math.Float32bits(v0)), 0) +} + +func Uniform1i(location int32, v0 int32) { + _, _, _ = syscall.Syscall(gpUniform1i, 2, uintptr(location), uintptr(v0), 0) +} + +func Uniform1fv(location int32, count int32, value *float32) { + _, _, _ = syscall.Syscall(gpUniform1fv, 3, uintptr(location), uintptr(count), uintptr(unsafe.Pointer(value))) +} + +func Uniform2fv(location int32, count int32, value *float32) { + _, _, _ = syscall.Syscall(gpUniform2fv, 3, uintptr(location), uintptr(count), uintptr(unsafe.Pointer(value))) +} + +func Uniform3fv(location int32, count int32, value *float32) { + _, _, _ = syscall.Syscall(gpUniform3fv, 3, uintptr(location), uintptr(count), uintptr(unsafe.Pointer(value))) +} + +func Uniform4fv(location int32, count int32, value *float32) { + _, _, _ = syscall.Syscall(gpUniform4fv, 3, uintptr(location), uintptr(count), uintptr(unsafe.Pointer(value))) +} + +func UniformMatrix2fv(location int32, count int32, transpose bool, value *float32) { + _, _, _ = syscall.Syscall6(gpUniformMatrix2fv, 4, uintptr(location), uintptr(count), boolToUintptr(transpose), uintptr(unsafe.Pointer(value)), 0, 0) +} + +func UniformMatrix3fv(location int32, count int32, transpose bool, value *float32) { + _, _, _ = syscall.Syscall6(gpUniformMatrix3fv, 4, uintptr(location), uintptr(count), boolToUintptr(transpose), uintptr(unsafe.Pointer(value)), 0, 0) +} + +func UniformMatrix4fv(location int32, count int32, transpose bool, value *float32) { + _, _, _ = syscall.Syscall6(gpUniformMatrix4fv, 4, uintptr(location), uintptr(count), boolToUintptr(transpose), uintptr(unsafe.Pointer(value)), 0, 0) +} + +func UseProgram(program uint32) { + _, _, _ = syscall.Syscall(gpUseProgram, 1, uintptr(program), 0, 0) +} + +func VertexAttribPointer(index uint32, size int32, xtype uint32, normalized bool, stride int32, pointer uintptr) { + _, _, _ = syscall.Syscall6(gpVertexAttribPointer, 6, uintptr(index), uintptr(size), uintptr(xtype), boolToUintptr(normalized), uintptr(stride), uintptr(pointer)) +} + +func Viewport(x int32, y int32, width int32, height int32) { + _, _, _ = syscall.Syscall6(gpViewport, 4, uintptr(x), uintptr(y), uintptr(width), uintptr(height), 0, 0) +} + +// InitWithProcAddrFunc intializes the package using the specified OpenGL +// function pointer loading function. +// +// For more cases Init should be used. +func InitWithProcAddrFunc(getProcAddr func(name string) uintptr) error { + gpActiveTexture = getProcAddr("glActiveTexture") + if gpActiveTexture == 0 { + return errors.New("glActiveTexture") + } + gpAttachShader = getProcAddr("glAttachShader") + if gpAttachShader == 0 { + return errors.New("glAttachShader") + } + gpBindAttribLocation = getProcAddr("glBindAttribLocation") + if gpBindAttribLocation == 0 { + return errors.New("glBindAttribLocation") + } + gpBindBuffer = getProcAddr("glBindBuffer") + if gpBindBuffer == 0 { + return errors.New("glBindBuffer") + } + gpBindFramebufferEXT = getProcAddr("glBindFramebufferEXT") + gpBindRenderbufferEXT = getProcAddr("glBindRenderbufferEXT") + gpBindTexture = getProcAddr("glBindTexture") + if gpBindTexture == 0 { + return errors.New("glBindTexture") + } + gpBlendFunc = getProcAddr("glBlendFunc") + if gpBlendFunc == 0 { + return errors.New("glBlendFunc") + } + gpBufferData = getProcAddr("glBufferData") + if gpBufferData == 0 { + return errors.New("glBufferData") + } + gpBufferSubData = getProcAddr("glBufferSubData") + if gpBufferSubData == 0 { + return errors.New("glBufferSubData") + } + gpCheckFramebufferStatusEXT = getProcAddr("glCheckFramebufferStatusEXT") + gpClear = getProcAddr("glClear") + if gpClear == 0 { + return errors.New("glClear") + } + gpColorMask = getProcAddr("glColorMask") + if gpColorMask == 0 { + return errors.New("glColorMask") + } + gpCompileShader = getProcAddr("glCompileShader") + if gpCompileShader == 0 { + return errors.New("glCompileShader") + } + gpCreateProgram = getProcAddr("glCreateProgram") + if gpCreateProgram == 0 { + return errors.New("glCreateProgram") + } + gpCreateShader = getProcAddr("glCreateShader") + if gpCreateShader == 0 { + return errors.New("glCreateShader") + } + gpDeleteBuffers = getProcAddr("glDeleteBuffers") + if gpDeleteBuffers == 0 { + return errors.New("glDeleteBuffers") + } + gpDeleteFramebuffersEXT = getProcAddr("glDeleteFramebuffersEXT") + gpDeleteProgram = getProcAddr("glDeleteProgram") + if gpDeleteProgram == 0 { + return errors.New("glDeleteProgram") + } + gpDeleteRenderbuffersEXT = getProcAddr("glDeleteRenderbuffersEXT") + gpDeleteShader = getProcAddr("glDeleteShader") + if gpDeleteShader == 0 { + return errors.New("glDeleteShader") + } + gpDeleteTextures = getProcAddr("glDeleteTextures") + if gpDeleteTextures == 0 { + return errors.New("glDeleteTextures") + } + gpDisable = getProcAddr("glDisable") + if gpDisable == 0 { + return errors.New("glDisable") + } + gpDisableVertexAttribArray = getProcAddr("glDisableVertexAttribArray") + if gpDisableVertexAttribArray == 0 { + return errors.New("glDisableVertexAttribArray") + } + gpDrawElements = getProcAddr("glDrawElements") + if gpDrawElements == 0 { + return errors.New("glDrawElements") + } + gpEnable = getProcAddr("glEnable") + if gpEnable == 0 { + return errors.New("glEnable") + } + gpEnableVertexAttribArray = getProcAddr("glEnableVertexAttribArray") + if gpEnableVertexAttribArray == 0 { + return errors.New("glEnableVertexAttribArray") + } + gpFlush = getProcAddr("glFlush") + if gpFlush == 0 { + return errors.New("glFlush") + } + gpFramebufferRenderbufferEXT = getProcAddr("glFramebufferRenderbufferEXT") + gpFramebufferTexture2DEXT = getProcAddr("glFramebufferTexture2DEXT") + gpGenBuffers = getProcAddr("glGenBuffers") + if gpGenBuffers == 0 { + return errors.New("glGenBuffers") + } + gpGenFramebuffersEXT = getProcAddr("glGenFramebuffersEXT") + gpGenRenderbuffersEXT = getProcAddr("glGenRenderbuffersEXT") + gpGenTextures = getProcAddr("glGenTextures") + if gpGenTextures == 0 { + return errors.New("glGenTextures") + } + gpGetDoublei_v = getProcAddr("glGetDoublei_v") + gpGetDoublei_vEXT = getProcAddr("glGetDoublei_vEXT") + gpGetError = getProcAddr("glGetError") + if gpGetError == 0 { + return errors.New("glGetError") + } + gpGetFloati_v = getProcAddr("glGetFloati_v") + gpGetFloati_vEXT = getProcAddr("glGetFloati_vEXT") + gpGetIntegeri_v = getProcAddr("glGetIntegeri_v") + gpGetIntegerui64i_vNV = getProcAddr("glGetIntegerui64i_vNV") + gpGetIntegerv = getProcAddr("glGetIntegerv") + if gpGetIntegerv == 0 { + return errors.New("glGetIntegerv") + } + gpGetPointeri_vEXT = getProcAddr("glGetPointeri_vEXT") + gpGetProgramInfoLog = getProcAddr("glGetProgramInfoLog") + if gpGetProgramInfoLog == 0 { + return errors.New("glGetProgramInfoLog") + } + gpGetProgramiv = getProcAddr("glGetProgramiv") + if gpGetProgramiv == 0 { + return errors.New("glGetProgramiv") + } + gpGetShaderInfoLog = getProcAddr("glGetShaderInfoLog") + if gpGetShaderInfoLog == 0 { + return errors.New("glGetShaderInfoLog") + } + gpGetShaderiv = getProcAddr("glGetShaderiv") + if gpGetShaderiv == 0 { + return errors.New("glGetShaderiv") + } + gpGetTransformFeedbacki64_v = getProcAddr("glGetTransformFeedbacki64_v") + gpGetTransformFeedbacki_v = getProcAddr("glGetTransformFeedbacki_v") + gpGetUniformLocation = getProcAddr("glGetUniformLocation") + if gpGetUniformLocation == 0 { + return errors.New("glGetUniformLocation") + } + gpGetUnsignedBytei_vEXT = getProcAddr("glGetUnsignedBytei_vEXT") + gpGetVertexArrayIntegeri_vEXT = getProcAddr("glGetVertexArrayIntegeri_vEXT") + gpGetVertexArrayPointeri_vEXT = getProcAddr("glGetVertexArrayPointeri_vEXT") + gpIsFramebufferEXT = getProcAddr("glIsFramebufferEXT") + gpIsProgram = getProcAddr("glIsProgram") + if gpIsProgram == 0 { + return errors.New("glIsProgram") + } + gpIsRenderbufferEXT = getProcAddr("glIsRenderbufferEXT") + gpIsTexture = getProcAddr("glIsTexture") + if gpIsTexture == 0 { + return errors.New("glIsTexture") + } + gpLinkProgram = getProcAddr("glLinkProgram") + if gpLinkProgram == 0 { + return errors.New("glLinkProgram") + } + gpPixelStorei = getProcAddr("glPixelStorei") + if gpPixelStorei == 0 { + return errors.New("glPixelStorei") + } + gpReadPixels = getProcAddr("glReadPixels") + if gpReadPixels == 0 { + return errors.New("glReadPixels") + } + gpRenderbufferStorageEXT = getProcAddr("glRenderbufferStorageEXT") + gpScissor = getProcAddr("glScissor") + if gpScissor == 0 { + return errors.New("glScissor") + } + gpShaderSource = getProcAddr("glShaderSource") + if gpShaderSource == 0 { + return errors.New("glShaderSource") + } + gpStencilFunc = getProcAddr("glStencilFunc") + if gpStencilFunc == 0 { + return errors.New("glStencilFunc") + } + gpStencilOp = getProcAddr("glStencilOp") + if gpStencilOp == 0 { + return errors.New("glStencilOp") + } + gpTexImage2D = getProcAddr("glTexImage2D") + if gpTexImage2D == 0 { + return errors.New("glTexImage2D") + } + gpTexParameteri = getProcAddr("glTexParameteri") + if gpTexParameteri == 0 { + return errors.New("glTexParameteri") + } + gpTexSubImage2D = getProcAddr("glTexSubImage2D") + if gpTexSubImage2D == 0 { + return errors.New("glTexSubImage2D") + } + gpUniform1f = getProcAddr("glUniform1f") + if gpUniform1f == 0 { + return errors.New("glUniform1f") + } + gpUniform1i = getProcAddr("glUniform1i") + if gpUniform1i == 0 { + return errors.New("glUniform1i") + } + gpUniform1fv = getProcAddr("glUniform1fv") + if gpUniform1fv == 0 { + return errors.New("glUniform1fv") + } + gpUniform2fv = getProcAddr("glUniform2fv") + if gpUniform2fv == 0 { + return errors.New("glUniform2fv") + } + gpUniform3fv = getProcAddr("glUniform3fv") + if gpUniform3fv == 0 { + return errors.New("glUniform3fv") + } + gpUniform4fv = getProcAddr("glUniform4fv") + if gpUniform4fv == 0 { + return errors.New("glUniform4fv") + } + gpUniformMatrix2fv = getProcAddr("glUniformMatrix2fv") + if gpUniformMatrix2fv == 0 { + return errors.New("glUniformMatrix2fv") + } + gpUniformMatrix3fv = getProcAddr("glUniformMatrix3fv") + if gpUniformMatrix3fv == 0 { + return errors.New("glUniformMatrix3fv") + } + gpUniformMatrix4fv = getProcAddr("glUniformMatrix4fv") + if gpUniformMatrix4fv == 0 { + return errors.New("glUniformMatrix4fv") + } + gpUseProgram = getProcAddr("glUseProgram") + if gpUseProgram == 0 { + return errors.New("glUseProgram") + } + gpVertexAttribPointer = getProcAddr("glVertexAttribPointer") + if gpVertexAttribPointer == 0 { + return errors.New("glVertexAttribPointer") + } + gpViewport = getProcAddr("glViewport") + if gpViewport == 0 { + return errors.New("glViewport") + } + return nil +}