diff --git a/ui/app/egl.go b/ui/app/egl.go index b8d01ed7..7a79d3bf 100644 --- a/ui/app/egl.go +++ b/ui/app/egl.go @@ -33,6 +33,13 @@ type eglContext struct { srgb bool } +var ( + nilEGLSurface _EGLSurface + nilEGLContext _EGLContext + nilEGLConfig _EGLConfig + nilEGLNativeWindowType _EGLNativeWindowType +) + const ( _EGL_ALPHA_SIZE = 0x3021 _EGL_BLUE_SIZE = 0x3022 diff --git a/ui/app/egl_linux.go b/ui/app/egl_linux.go index 13653e3a..051c2292 100644 --- a/ui/app/egl_linux.go +++ b/ui/app/egl_linux.go @@ -20,13 +20,6 @@ type ( _EGLSurface = C.EGLSurface ) -var ( - nilEGLSurface _EGLSurface - nilEGLContext _EGLContext - nilEGLConfig _EGLConfig - nilEGLNativeWindowType _EGLNativeWindowType -) - func eglChooseConfig(disp _EGLDisplay, attribs []_EGLint) (_EGLConfig, bool) { var cfg C.EGLConfig var ncfg C.EGLint diff --git a/ui/app/egl_windows.go b/ui/app/egl_windows.go index e7afc6ca..58cb20f8 100644 --- a/ui/app/egl_windows.go +++ b/ui/app/egl_windows.go @@ -41,13 +41,6 @@ var ( _eglQueryString = libEGL.NewProc("eglQueryString") ) -const ( - nilEGLSurface _EGLSurface = 0 - nilEGLContext _EGLContext = 0 - nilEGLConfig _EGLConfig = 0 - nilEGLNativeWindowType _EGLNativeWindowType = 0 -) - func init() { mustLoadDLL(libEGL, "libEGL.dll") mustLoadDLL(gl.LibGLESv2, "libGLESv2.dll") diff --git a/ui/app/internal/gl/functions.go b/ui/app/internal/gl/functions.go index cf24c3d5..4145a742 100644 --- a/ui/app/internal/gl/functions.go +++ b/ui/app/internal/gl/functions.go @@ -120,33 +120,33 @@ func (f *Functions) ActiveTexture(texture Enum) { } func (f *Functions) AttachShader(p Program, s Shader) { - C.glAttachShader(C.GLuint(p), C.GLuint(s)) + C.glAttachShader(C.GLuint(p.V), C.GLuint(s.V)) } func (f *Functions) BeginQuery(target Enum, query Query) { - C.gio_glBeginQuery(C.GLenum(target), C.GLenum(query)) + C.gio_glBeginQuery(C.GLenum(target), C.GLenum(query.V)) } func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) - C.glBindAttribLocation(C.GLuint(p), C.GLuint(a), cname) + C.glBindAttribLocation(C.GLuint(p.V), C.GLuint(a), cname) } func (f *Functions) BindBuffer(target Enum, b Buffer) { - C.glBindBuffer(C.GLenum(target), C.GLuint(b)) + C.glBindBuffer(C.GLenum(target), C.GLuint(b.V)) } func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) { - C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb)) + C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb.V)) } func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) { - C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb)) + C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb.V)) } func (f *Functions) BindTexture(target Enum, t Texture) { - C.glBindTexture(C.GLenum(target), C.GLuint(t)) + C.glBindTexture(C.GLenum(target), C.GLuint(t.V)) } func (f *Functions) BlendEquation(mode Enum) { @@ -182,77 +182,77 @@ func (f *Functions) ClearDepthf(d float32) { } func (f *Functions) CompileShader(s Shader) { - C.glCompileShader(C.GLuint(s)) + C.glCompileShader(C.GLuint(s.V)) } func (f *Functions) CreateBuffer() Buffer { var handle C.GLuint C.glGenBuffers(1, &handle) - return Buffer(handle) + return Buffer{uint(handle)} } func (f *Functions) CreateFramebuffer() Framebuffer { var handle C.GLuint C.glGenFramebuffers(1, &handle) - return Framebuffer(handle) + return Framebuffer{uint(handle)} } func (f *Functions) CreateProgram() Program { - return Program(C.glCreateProgram()) + return Program{uint(C.glCreateProgram())} } func (f *Functions) CreateQuery() Query { var handle C.GLuint C.gio_glGenQueries(1, &handle) - return Query(handle) + return Query{uint(handle)} } func (f *Functions) CreateRenderbuffer() Renderbuffer { var handle C.GLuint C.glGenRenderbuffers(1, &handle) - return Renderbuffer(handle) + return Renderbuffer{uint(handle)} } func (f *Functions) CreateShader(ty Enum) Shader { - return Shader(C.glCreateShader(C.GLenum(ty))) + return Shader{uint(C.glCreateShader(C.GLenum(ty)))} } func (f *Functions) CreateTexture() Texture { var handle C.GLuint C.glGenTextures(1, &handle) - return Texture(handle) + return Texture{uint(handle)} } func (f *Functions) DeleteBuffer(v Buffer) { - handle := C.GLuint(v) + handle := C.GLuint(v.V) C.glDeleteBuffers(1, &handle) } func (f *Functions) DeleteFramebuffer(v Framebuffer) { - handle := C.GLuint(v) + handle := C.GLuint(v.V) C.glDeleteFramebuffers(1, &handle) } func (f *Functions) DeleteProgram(p Program) { - C.glDeleteProgram(C.GLuint(p)) + C.glDeleteProgram(C.GLuint(p.V)) } func (f *Functions) DeleteQuery(query Query) { - handle := C.GLuint(query) + handle := C.GLuint(query.V) C.gio_glDeleteQueries(1, &handle) } func (f *Functions) DeleteRenderbuffer(v Renderbuffer) { - handle := C.GLuint(v) + handle := C.GLuint(v.V) C.glDeleteRenderbuffers(1, &handle) } func (f *Functions) DeleteShader(s Shader) { - C.glDeleteShader(C.GLuint(s)) + C.glDeleteShader(C.GLuint(s.V)) } func (f *Functions) DeleteTexture(v Texture) { - handle := C.GLuint(v) + handle := C.GLuint(v.V) C.glDeleteTextures(1, &handle) } @@ -301,11 +301,15 @@ func (f *Functions) Finish() { } func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) { - C.glFramebufferRenderbuffer(C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) + C.glFramebufferRenderbuffer(C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer.V)) } func (f *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) { - C.glFramebufferTexture2D(C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t), C.GLint(level)) + C.glFramebufferTexture2D(C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level)) +} + +func (c *Functions) GetBinding(pname Enum) Object { + return Object{uint(c.GetInteger(pname))} } func (f *Functions) GetError() Enum { @@ -336,45 +340,45 @@ func (f *Functions) GetInteger(pname Enum) int { func (f *Functions) GetProgrami(p Program, pname Enum) int { // Hope this is enough room. var buf [100]C.GLint - C.glGetProgramiv(C.GLuint(p), C.GLenum(pname), &buf[0]) + C.glGetProgramiv(C.GLuint(p.V), C.GLenum(pname), &buf[0]) return int(buf[0]) } func (f *Functions) GetProgramInfoLog(p Program) string { var plen C.GLsizei - C.glGetProgramInfoLog(C.GLuint(p), 0, &plen, nil) + C.glGetProgramInfoLog(C.GLuint(p.V), 0, &plen, nil) if plen == 0 { return "" } // Make room for the string and the null terminator. buf := make([]byte, plen+1) - C.glGetProgramInfoLog(C.GLuint(p), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0]))) + C.glGetProgramInfoLog(C.GLuint(p.V), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0]))) return string(buf[:len(buf)-1]) } func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint { // Hope this is enough room. var buf [100]C.GLuint - C.gio_glGetQueryObjectuiv(C.GLuint(query), C.GLenum(pname), &buf[0]) + C.gio_glGetQueryObjectuiv(C.GLuint(query.V), C.GLenum(pname), &buf[0]) return uint(buf[0]) } func (f *Functions) GetShaderi(s Shader, pname Enum) int { // Hope this is enough room. var buf [100]C.GLint - C.glGetShaderiv(C.GLuint(s), C.GLenum(pname), &buf[0]) + C.glGetShaderiv(C.GLuint(s.V), C.GLenum(pname), &buf[0]) return int(buf[0]) } func (f *Functions) GetShaderInfoLog(s Shader) string { var plen C.GLsizei - C.glGetShaderInfoLog(C.GLuint(s), 0, &plen, nil) + C.glGetShaderInfoLog(C.GLuint(s.V), 0, &plen, nil) if plen == 0 { return "" } // Make room for the string and the null terminator. buf := make([]byte, plen+1) - C.glGetShaderInfoLog(C.GLuint(s), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0]))) + C.glGetShaderInfoLog(C.GLuint(s.V), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0]))) return string(buf[:len(buf)-1]) } @@ -386,7 +390,7 @@ func (f *Functions) GetString(pname Enum) string { func (f *Functions) GetUniformLocation(p Program, name string) Uniform { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) - return Uniform(C.glGetUniformLocation(C.GLuint(p), cname)) + return Uniform{int(C.glGetUniformLocation(C.GLuint(p.V), cname))} } func (f *Functions) InvalidateFramebuffer(target, attachment Enum) { @@ -394,7 +398,7 @@ func (f *Functions) InvalidateFramebuffer(target, attachment Enum) { } func (f *Functions) LinkProgram(p Program) { - C.glLinkProgram(C.GLuint(p)) + C.glLinkProgram(C.GLuint(p.V)) } func (f *Functions) PixelStorei(pname Enum, param int32) { @@ -413,7 +417,7 @@ func (f *Functions) ShaderSource(s Shader, src string) { csrc := C.CString(src) defer C.free(unsafe.Pointer(csrc)) strlen := C.GLint(len(src)) - C.glShaderSource(C.GLuint(s), 1, &csrc, &strlen) + C.glShaderSource(C.GLuint(s.V), 1, &csrc, &strlen) } func (f *Functions) TexImage2D(target Enum, level int, internalFormat int, width int, height int, format Enum, ty Enum, data []byte) { @@ -437,27 +441,27 @@ func (f *Functions) TexParameteri(target, pname Enum, param int) { } func (f *Functions) Uniform1f(dst Uniform, v float32) { - C.glUniform1f(C.GLint(dst), C.GLfloat(v)) + C.glUniform1f(C.GLint(dst.V), C.GLfloat(v)) } func (f *Functions) Uniform1i(dst Uniform, v int) { - C.glUniform1i(C.GLint(dst), C.GLint(v)) + C.glUniform1i(C.GLint(dst.V), C.GLint(v)) } func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) { - C.glUniform2f(C.GLint(dst), C.GLfloat(v0), C.GLfloat(v1)) + C.glUniform2f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1)) } func (f *Functions) Uniform3f(dst Uniform, v0 float32, v1 float32, v2 float32) { - C.glUniform3f(C.GLint(dst), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) + C.glUniform3f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) } func (f *Functions) Uniform4f(dst Uniform, v0 float32, v1 float32, v2 float32, v3 float32) { - C.glUniform4f(C.GLint(dst), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) + C.glUniform4f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) } func (f *Functions) UseProgram(p Program) { - C.glUseProgram(C.GLuint(p)) + C.glUseProgram(C.GLuint(p.V)) } func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride int, offset int) { diff --git a/ui/app/internal/gl/gl.go b/ui/app/internal/gl/gl.go index 3276dbf7..72b37af2 100644 --- a/ui/app/internal/gl/gl.go +++ b/ui/app/internal/gl/gl.go @@ -3,16 +3,8 @@ package gl type ( - Attrib uint - Buffer uint - Enum uint - Framebuffer uint - Program uint - Renderbuffer uint - Shader uint - Texture uint - Uniform int - Query uint + Attrib uint + Enum uint ) type Context interface { @@ -135,6 +127,7 @@ var _ interface { Finish() FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) + GetBinding(pname Enum) Object GetError() Enum GetRenderbufferParameteri(target, pname Enum) int GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int diff --git a/ui/app/internal/gl/gl_windows.go b/ui/app/internal/gl/gl_windows.go index bd842e9f..49054abd 100644 --- a/ui/app/internal/gl/gl_windows.go +++ b/ui/app/internal/gl/gl_windows.go @@ -91,26 +91,26 @@ func (c *Functions) ActiveTexture(t Enum) { syscall.Syscall(_glActiveTexture.Addr(), 1, uintptr(t), 0, 0) } func (c *Functions) AttachShader(p Program, s Shader) { - syscall.Syscall(_glAttachShader.Addr(), 2, uintptr(p), uintptr(s), 0) + syscall.Syscall(_glAttachShader.Addr(), 2, uintptr(p.V), uintptr(s.V), 0) } func (f *Functions) BeginQuery(target Enum, query Query) { - syscall.Syscall(_glBeginQuery.Addr(), 2, uintptr(target), uintptr(query), 0) + syscall.Syscall(_glBeginQuery.Addr(), 2, uintptr(target), uintptr(query.V), 0) } func (c *Functions) BindAttribLocation(p Program, a Attrib, name string) { cname := cString(name) - syscall.Syscall(_glBindAttribLocation.Addr(), 3, uintptr(p), uintptr(a), uintptr(unsafe.Pointer(&cname[0]))) + syscall.Syscall(_glBindAttribLocation.Addr(), 3, uintptr(p.V), uintptr(a), uintptr(unsafe.Pointer(&cname[0]))) } func (c *Functions) BindBuffer(target Enum, b Buffer) { - syscall.Syscall(_glBindBuffer.Addr(), 2, uintptr(target), uintptr(b), 0) + syscall.Syscall(_glBindBuffer.Addr(), 2, uintptr(target), uintptr(b.V), 0) } func (c *Functions) BindFramebuffer(target Enum, fb Framebuffer) { - syscall.Syscall(_glBindFramebuffer.Addr(), 2, uintptr(target), uintptr(fb), 0) + syscall.Syscall(_glBindFramebuffer.Addr(), 2, uintptr(target), uintptr(fb.V), 0) } func (c *Functions) BindRenderbuffer(target Enum, rb Renderbuffer) { - syscall.Syscall(_glBindRenderbuffer.Addr(), 2, uintptr(target), uintptr(rb), 0) + syscall.Syscall(_glBindRenderbuffer.Addr(), 2, uintptr(target), uintptr(rb.V), 0) } func (c *Functions) BindTexture(target Enum, t Texture) { - syscall.Syscall(_glBindTexture.Addr(), 2, uintptr(target), uintptr(t), 0) + syscall.Syscall(_glBindTexture.Addr(), 2, uintptr(target), uintptr(t.V), 0) } func (c *Functions) BlendEquation(mode Enum) { syscall.Syscall(_glBlendEquation.Addr(), 1, uintptr(mode), 0, 0) @@ -139,61 +139,61 @@ func (c *Functions) ClearDepthf(d float32) { syscall.Syscall(_glClearDepthf.Addr(), 1, uintptr(math.Float32bits(d)), 0, 0) } func (c *Functions) CompileShader(s Shader) { - syscall.Syscall(_glCompileShader.Addr(), 1, uintptr(s), 0, 0) + syscall.Syscall(_glCompileShader.Addr(), 1, uintptr(s.V), 0, 0) } func (c *Functions) CreateBuffer() Buffer { var buf uintptr syscall.Syscall(_glGenBuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&buf)), 0) - return Buffer(buf) + return Buffer{uint(buf)} } func (c *Functions) CreateFramebuffer() Framebuffer { var fb uintptr syscall.Syscall(_glGenFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&fb)), 0) - return Framebuffer(fb) + return Framebuffer{uint(fb)} } func (c *Functions) CreateProgram() Program { p, _, _ := syscall.Syscall(_glCreateProgram.Addr(), 0, 0, 0, 0) - return Program(p) + return Program{uint(p)} } func (f *Functions) CreateQuery() Query { var q uintptr syscall.Syscall(_glGenQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&q)), 0) - return Query(q) + return Query{uint(q)} } func (c *Functions) CreateRenderbuffer() Renderbuffer { var rb uintptr syscall.Syscall(_glGenRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&rb)), 0) - return Renderbuffer(rb) + return Renderbuffer{uint(rb)} } func (c *Functions) CreateShader(ty Enum) Shader { s, _, _ := syscall.Syscall(_glCreateShader.Addr(), 1, uintptr(ty), 0, 0) - return Shader(s) + return Shader{uint(s)} } func (c *Functions) CreateTexture() Texture { var t uintptr syscall.Syscall(_glGenTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&t)), 0) - return Texture(t) + return Texture{uint(t)} } func (c *Functions) DeleteBuffer(v Buffer) { syscall.Syscall(_glDeleteBuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0) } func (c *Functions) DeleteFramebuffer(v Framebuffer) { - syscall.Syscall(_glDeleteFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0) + syscall.Syscall(_glDeleteFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0) } func (c *Functions) DeleteProgram(p Program) { - syscall.Syscall(_glDeleteProgram.Addr(), 1, uintptr(p), 0, 0) + syscall.Syscall(_glDeleteProgram.Addr(), 1, uintptr(p.V), 0, 0) } func (f *Functions) DeleteQuery(query Query) { - syscall.Syscall(_glDeleteQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&query)), 0) + syscall.Syscall(_glDeleteQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&query.V)), 0) } func (c *Functions) DeleteShader(s Shader) { - syscall.Syscall(_glDeleteShader.Addr(), 1, uintptr(s), 0, 0) + syscall.Syscall(_glDeleteShader.Addr(), 1, uintptr(s.V), 0, 0) } func (c *Functions) DeleteRenderbuffer(v Renderbuffer) { - syscall.Syscall(_glDeleteRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0) + syscall.Syscall(_glDeleteRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0) } func (c *Functions) DeleteTexture(v Texture) { - syscall.Syscall(_glDeleteTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0) + syscall.Syscall(_glDeleteTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0) } func (c *Functions) DepthFunc(f Enum) { syscall.Syscall(_glDepthFunc.Addr(), 1, uintptr(f), 0, 0) @@ -230,10 +230,13 @@ func (c *Functions) Finish() { syscall.Syscall(_glFinish.Addr(), 0, 0, 0, 0) } func (c *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) { - syscall.Syscall6(_glFramebufferRenderbuffer.Addr(), 4, uintptr(target), uintptr(attachment), uintptr(renderbuffertarget), uintptr(renderbuffer), 0, 0) + syscall.Syscall6(_glFramebufferRenderbuffer.Addr(), 4, uintptr(target), uintptr(attachment), uintptr(renderbuffertarget), uintptr(renderbuffer.V), 0, 0) } func (c *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) { - syscall.Syscall6(_glFramebufferTexture2D.Addr(), 5, uintptr(target), uintptr(attachment), uintptr(texTarget), uintptr(t), uintptr(level), 0) + syscall.Syscall6(_glFramebufferTexture2D.Addr(), 5, uintptr(target), uintptr(attachment), uintptr(texTarget), uintptr(t.V), uintptr(level), 0) +} +func (c *Functions) GetBinding(pname Enum) Object { + return Object{uint(c.GetInteger(pname))} } func (c *Functions) GetError() Enum { e, _, _ := syscall.Syscall(_glGetError.Addr(), 0, 0, 0, 0) @@ -256,41 +259,41 @@ func (c *Functions) GetInteger(pname Enum) int { func (c *Functions) GetProgrami(p Program, pname Enum) int { // Hopefully enough space. var params [100]int32 - syscall.Syscall(_glGetProgramiv.Addr(), 3, uintptr(p), uintptr(pname), uintptr(unsafe.Pointer(¶ms[0]))) + syscall.Syscall(_glGetProgramiv.Addr(), 3, uintptr(p.V), uintptr(pname), uintptr(unsafe.Pointer(¶ms[0]))) return int(params[0]) } func (c *Functions) GetProgramInfoLog(p Program) string { var n uintptr - syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0) + syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p.V), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0) if n == 0 { return "" } // Make space for the null terminator. buf := make([]byte, n+1) - syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0) + syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p.V), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0) return string(buf[:len(buf)-1]) } func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint { // Hope this is enough room. var buf [100]int32 - syscall.Syscall(_glGetQueryObjectuiv.Addr(), 3, uintptr(query), uintptr(pname), uintptr(unsafe.Pointer(&buf[0]))) + syscall.Syscall(_glGetQueryObjectuiv.Addr(), 3, uintptr(query.V), uintptr(pname), uintptr(unsafe.Pointer(&buf[0]))) return uint(buf[0]) } func (c *Functions) GetShaderi(s Shader, pname Enum) int { // Hopefully enough room. var params [100]int32 - syscall.Syscall(_glGetShaderiv.Addr(), 3, uintptr(s), uintptr(pname), uintptr(unsafe.Pointer(¶ms[0]))) + syscall.Syscall(_glGetShaderiv.Addr(), 3, uintptr(s.V), uintptr(pname), uintptr(unsafe.Pointer(¶ms[0]))) return int(params[0]) } func (c *Functions) GetShaderInfoLog(s Shader) string { var n uintptr - syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0) + syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s.V), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0) if n == 0 { return "" } // Make space for the null terminator. buf := make([]byte, n+1) - syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0) + syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s.V), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0) return string(buf[:len(buf)-1]) } func (c *Functions) GetString(pname Enum) string { @@ -299,8 +302,8 @@ func (c *Functions) GetString(pname Enum) string { } func (c *Functions) GetUniformLocation(p Program, name string) Uniform { cname := cString(name) - u, _, _ := syscall.Syscall(_glGetUniformLocation.Addr(), 2, uintptr(p), uintptr(unsafe.Pointer(&cname[0])), 0) - return Uniform(u) + u, _, _ := syscall.Syscall(_glGetUniformLocation.Addr(), 2, uintptr(p.V), uintptr(unsafe.Pointer(&cname[0])), 0) + return Uniform{int(u)} } func (c *Functions) InvalidateFramebuffer(target, attachment Enum) { addr := _glInvalidateFramebuffer.Addr() @@ -311,7 +314,7 @@ func (c *Functions) InvalidateFramebuffer(target, attachment Enum) { syscall.Syscall(addr, 3, uintptr(target), 1, uintptr(unsafe.Pointer(&attachment))) } func (c *Functions) LinkProgram(p Program) { - syscall.Syscall(_glLinkProgram.Addr(), 1, uintptr(p), 0, 0) + syscall.Syscall(_glLinkProgram.Addr(), 1, uintptr(p.V), 0, 0) } func (c *Functions) PixelStorei(pname Enum, param int32) { syscall.Syscall(_glPixelStorei.Addr(), 2, uintptr(pname), uintptr(param), 0) @@ -324,7 +327,7 @@ func (c *Functions) Scissor(x, y, width, height int32) { } func (c *Functions) ShaderSource(s Shader, src string) { var n uintptr = uintptr(len(src)) - syscall.Syscall6(_glShaderSource.Addr(), 4, uintptr(s), 1, uintptr(unsafe.Pointer(&src)), uintptr(unsafe.Pointer(&n)), 0, 0) + syscall.Syscall6(_glShaderSource.Addr(), 4, uintptr(s.V), 1, uintptr(unsafe.Pointer(&src)), uintptr(unsafe.Pointer(&n)), 0, 0) } func (c *Functions) TexImage2D(target Enum, level int, internalFormat int, width, height int, format, ty Enum, data []byte) { if len(data) == 0 { @@ -340,22 +343,22 @@ func (c *Functions) TexParameteri(target, pname Enum, param int) { syscall.Syscall(_glTexParameteri.Addr(), 3, uintptr(target), uintptr(pname), uintptr(param)) } func (c *Functions) Uniform1f(dst Uniform, v float32) { - syscall.Syscall(_glUniform1f.Addr(), 2, uintptr(dst), uintptr(math.Float32bits(v)), 0) + syscall.Syscall(_glUniform1f.Addr(), 2, uintptr(dst.V), uintptr(math.Float32bits(v)), 0) } func (c *Functions) Uniform1i(dst Uniform, v int) { - syscall.Syscall(_glUniform1i.Addr(), 2, uintptr(dst), uintptr(v), 0) + syscall.Syscall(_glUniform1i.Addr(), 2, uintptr(dst.V), uintptr(v), 0) } func (c *Functions) Uniform2f(dst Uniform, v0, v1 float32) { - syscall.Syscall(_glUniform2f.Addr(), 3, uintptr(dst), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1))) + syscall.Syscall(_glUniform2f.Addr(), 3, uintptr(dst.V), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1))) } func (c *Functions) Uniform3f(dst Uniform, v0, v1, v2 float32) { - syscall.Syscall6(_glUniform3f.Addr(), 4, uintptr(dst), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), 0, 0) + syscall.Syscall6(_glUniform3f.Addr(), 4, uintptr(dst.V), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), 0, 0) } func (c *Functions) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) { - syscall.Syscall6(_glUniform4f.Addr(), 5, uintptr(dst), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), uintptr(math.Float32bits(v3)), 0) + syscall.Syscall6(_glUniform4f.Addr(), 5, uintptr(dst.V), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), uintptr(math.Float32bits(v3)), 0) } func (c *Functions) UseProgram(p Program) { - syscall.Syscall(_glUseProgram.Addr(), 1, uintptr(p), 0, 0) + syscall.Syscall(_glUseProgram.Addr(), 1, uintptr(p.V), 0, 0) } func (c *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) { var norm uintptr diff --git a/ui/app/internal/gl/srgb.go b/ui/app/internal/gl/srgb.go index 56385c4d..de86494c 100644 --- a/ui/app/internal/gl/srgb.go +++ b/ui/app/internal/gl/srgb.go @@ -69,7 +69,7 @@ func NewSRGBFBO(f *Functions) (*SRGBFBO, error) { } func (s *SRGBFBO) Blit() { - s.c.BindFramebuffer(FRAMEBUFFER, 0) + s.c.BindFramebuffer(FRAMEBUFFER, Framebuffer{}) s.c.ClearColor(1, 0, 1, 1) s.c.Clear(COLOR_BUFFER_BIT) s.c.UseProgram(s.prog) @@ -80,7 +80,7 @@ func (s *SRGBFBO) Blit() { s.c.EnableVertexAttribArray(0) s.c.EnableVertexAttribArray(1) s.c.DrawArrays(TRIANGLE_STRIP, 0, 4) - s.c.BindTexture(TEXTURE_2D, 0) + s.c.BindTexture(TEXTURE_2D, Texture{}) s.c.DisableVertexAttribArray(0) s.c.DisableVertexAttribArray(1) s.c.BindFramebuffer(FRAMEBUFFER, s.frameBuffer) @@ -106,7 +106,7 @@ func (s *SRGBFBO) Refresh(w, h int) error { } else /* EXT_sRGB */ { s.c.TexImage2D(TEXTURE_2D, 0, SRGB_ALPHA_EXT, w, h, SRGB_ALPHA_EXT, UNSIGNED_BYTE, nil) } - currentRB := Renderbuffer(s.c.GetInteger(RENDERBUFFER_BINDING)) + currentRB := Renderbuffer(s.c.GetBinding(RENDERBUFFER_BINDING)) s.c.BindRenderbuffer(RENDERBUFFER, s.depthBuffer) s.c.RenderbufferStorage(RENDERBUFFER, DEPTH_COMPONENT16, w, h) s.c.BindRenderbuffer(RENDERBUFFER, currentRB) diff --git a/ui/app/internal/gl/types.go b/ui/app/internal/gl/types.go new file mode 100644 index 00000000..2f007ca2 --- /dev/null +++ b/ui/app/internal/gl/types.go @@ -0,0 +1,19 @@ +// +build !js + +package gl + +type ( + Buffer struct{ V uint } + Framebuffer struct{ V uint } + Program struct{ V uint } + Renderbuffer struct{ V uint } + Shader struct{ V uint } + Texture struct{ V uint } + Query struct{ V uint } + Uniform struct{ V int } + Object struct{ V uint } +) + +func (u Uniform) Valid() bool { + return u.V != -1 +} diff --git a/ui/app/internal/gl/util.go b/ui/app/internal/gl/util.go index 76080a19..b2213123 100644 --- a/ui/app/internal/gl/util.go +++ b/ui/app/internal/gl/util.go @@ -13,17 +13,17 @@ import ( func CreateProgram(ctx *Functions, vsSrc, fsSrc string, attribs []string) (Program, error) { vs, err := createShader(ctx, VERTEX_SHADER, vsSrc) if err != nil { - return 0, err + return Program{}, err } defer ctx.DeleteShader(vs) fs, err := createShader(ctx, FRAGMENT_SHADER, fsSrc) if err != nil { - return 0, err + return Program{}, err } defer ctx.DeleteShader(fs) prog := ctx.CreateProgram() - if prog == 0 { - return 0, errors.New("glCreateProgram failed") + if prog == (Program{}) { + return Program{}, errors.New("glCreateProgram failed") } ctx.AttachShader(prog, vs) ctx.AttachShader(prog, fs) @@ -34,14 +34,14 @@ func CreateProgram(ctx *Functions, vsSrc, fsSrc string, attribs []string) (Progr if ctx.GetProgrami(prog, LINK_STATUS) == 0 { log := ctx.GetProgramInfoLog(prog) ctx.DeleteProgram(prog) - return 0, fmt.Errorf("program link failed: %s", strings.TrimSpace(log)) + return Program{}, fmt.Errorf("program link failed: %s", strings.TrimSpace(log)) } return prog, nil } func GetUniformLocation(ctx *Functions, prog Program, name string) Uniform { loc := ctx.GetUniformLocation(prog, name) - if loc == -1 { + if !loc.Valid() { panic(fmt.Errorf("uniform %s not found", name)) } return loc @@ -49,15 +49,15 @@ func GetUniformLocation(ctx *Functions, prog Program, name string) Uniform { func createShader(ctx *Functions, typ Enum, src string) (Shader, error) { sh := ctx.CreateShader(typ) - if sh == 0 { - return 0, errors.New("glCreateShader failed") + if sh == (Shader{}) { + return Shader{}, errors.New("glCreateShader failed") } ctx.ShaderSource(sh, src) ctx.CompileShader(sh) if ctx.GetShaderi(sh, COMPILE_STATUS) == 0 { log := ctx.GetShaderInfoLog(sh) ctx.DeleteShader(sh) - return 0, fmt.Errorf("shader compilation failed: %s", strings.TrimSpace(log)) + return Shader{}, fmt.Errorf("shader compilation failed: %s", strings.TrimSpace(log)) } return sh, nil } diff --git a/ui/app/internal/gpu/gpu.go b/ui/app/internal/gpu/gpu.go index bc4fedc0..60dc819c 100644 --- a/ui/app/internal/gpu/gpu.go +++ b/ui/app/internal/gpu/gpu.go @@ -326,7 +326,7 @@ func (g *GPU) setErr(err error) { } func (r *renderer) texHandle(t *texture) gl.Texture { - if t.id != 0 { + if t.id != (gl.Texture{}) { return t.id } t.id = createTexture(r.ctx) @@ -336,7 +336,7 @@ func (r *renderer) texHandle(t *texture) gl.Texture { } func (t *texture) release(ctx *gl.Functions) { - if t.id != 0 { + if t.id != (gl.Texture{}) { ctx.DeleteTexture(t.id) } } diff --git a/ui/app/internal/gpu/path.go b/ui/app/internal/gpu/path.go index b07c81e8..14fe12c3 100644 --- a/ui/app/internal/gpu/path.go +++ b/ui/app/internal/gpu/path.go @@ -117,7 +117,7 @@ func newCoverer(ctx *gl.Functions) *coverer { } func newStenciler(ctx *gl.Functions) *stenciler { - defFBO := gl.Framebuffer(ctx.GetInteger(gl.FRAMEBUFFER_BINDING)) + defFBO := gl.Framebuffer(ctx.GetBinding(gl.FRAMEBUFFER_BINDING)) prog, err := gl.CreateProgram(ctx, stencilVSrc, stencilFSrc, pathAttribs) if err != nil { panic(err) @@ -248,7 +248,7 @@ func (p *pather) stencilPath(bounds image.Rectangle, offset f32.Point, uv image. func (s *stenciler) beginIntersect(sizes []image.Point) { s.ctx.ActiveTexture(gl.TEXTURE1) - s.ctx.BindTexture(gl.TEXTURE_2D, 0) + s.ctx.BindTexture(gl.TEXTURE_2D, gl.Texture{}) s.ctx.ActiveTexture(gl.TEXTURE0) s.ctx.BlendFunc(gl.DST_COLOR, gl.ZERO) // 8 bit coverage is enough, but OpenGL ES only supports single channel @@ -275,7 +275,7 @@ func (s *stenciler) cover(idx int) stencilFBO { func (s *stenciler) begin(sizes []image.Point) { s.ctx.ActiveTexture(gl.TEXTURE1) - s.ctx.BindTexture(gl.TEXTURE_2D, 0) + s.ctx.BindTexture(gl.TEXTURE_2D, gl.Texture{}) s.ctx.ActiveTexture(gl.TEXTURE0) s.ctx.BlendFunc(gl.ONE, gl.ONE) s.fbos.resize(s.ctx, sizes, gl.R16F, gl.RED, gl.HALF_FLOAT)