joejulian/gio-patched
1
0
Fork 0
forked from joejulian/gio
Code Pull Requests 1 Activity

internal/gl: [js] replace Call to Bind/Invoke

Browse Source 
Before that patch, the Call function was used to call each
JS function related to WebGL. The Call function contains
strings, which is slow on most browsers. Now, it uses
Bind on the initialization and re-use the same function,
avoiding the usage of strings.

Signed-off-by: Inkeliz <inkeliz@inkeliz.com>
This commit is contained in:
Inkeliz
2022-02-14 22:23:04 +00:00
parent 0d32ab3f62
commit 182e701081
1 changed files with 272 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/gl/gl_js.go
+272 -91
View File
@@ -21,14 +21,188 @@ type Functions struct {
int32Buf js.Value
isWebGL2 bool
_getExtension js.Value
_activeTexture js.Value
_attachShader js.Value
_beginQuery js.Value
_beginQueryEXT js.Value
_bindAttribLocation js.Value
_bindBuffer js.Value
_bindBufferBase js.Value
_bindFramebuffer js.Value
_bindRenderbuffer js.Value
_bindTexture js.Value
_blendEquation js.Value
_blendFunc js.Value
_bufferData js.Value
_bufferSubData js.Value
_checkFramebufferStatus js.Value
_clear js.Value
_clearColor js.Value
_clearDepth js.Value
_compileShader js.Value
_copyTexSubImage2D js.Value
_createBuffer js.Value
_createFramebuffer js.Value
_createProgram js.Value
_createQuery js.Value
_createRenderbuffer js.Value
_createShader js.Value
_createTexture js.Value
_deleteBuffer js.Value
_deleteFramebuffer js.Value
_deleteProgram js.Value
_deleteQuery js.Value
_deleteQueryEXT js.Value
_deleteShader js.Value
_deleteRenderbuffer js.Value
_deleteTexture js.Value
_depthFunc js.Value
_depthMask js.Value
_disableVertexAttribArray js.Value
_disable js.Value
_drawArrays js.Value
_drawElements js.Value
_enable js.Value
_enableVertexAttribArray js.Value
_endQuery js.Value
_endQueryEXT js.Value
_finish js.Value
_flush js.Value
_framebufferRenderbuffer js.Value
_framebufferTexture2D js.Value
_getRenderbufferParameteri js.Value
_getFramebufferAttachmentParameter js.Value
_getParameter js.Value
_getIndexedParameter js.Value
_getProgramParameter js.Value
_getProgramInfoLog js.Value
_getQueryParameter js.Value
_getQueryObjectEXT js.Value
_getShaderParameter js.Value
_getShaderInfoLog js.Value
_getSupportedExtensions js.Value
_getUniformBlockIndex js.Value
_getUniformLocation js.Value
_getVertexAttrib js.Value
_getVertexAttribOffset js.Value
_invalidateFramebuffer js.Value
_isEnabled js.Value
_linkProgram js.Value
_pixelStorei js.Value
_renderbufferStorage js.Value
_readPixels js.Value
_scissor js.Value
_shaderSource js.Value
_texImage2D js.Value
_texStorage2D js.Value
_texSubImage2D js.Value
_texParameteri js.Value
_uniformBlockBinding js.Value
_uniform1f js.Value
_uniform1i js.Value
_uniform2f js.Value
_uniform3f js.Value
_uniform4f js.Value
_useProgram js.Value
_vertexAttribPointer js.Value
_viewport js.Value
}
type Context js.Value
func NewFunctions(ctx Context, forceES bool) (*Functions, error) {
webgl := js.Value(ctx)
f := &Functions{
Ctx: js.Value(ctx),
uint8Array: js.Global().Get("Uint8Array"),
Ctx: webgl,
uint8Array: js.Global().Get("Uint8Array"),
_getExtension: _bind(webgl, `getExtension`),
_activeTexture: _bind(webgl, `activeTexture`),
_attachShader: _bind(webgl, `attachShader`),
_beginQuery: _bind(webgl, `beginQuery`),
_beginQueryEXT: _bind(webgl, `beginQueryEXT`),
_bindAttribLocation: _bind(webgl, `bindAttribLocation`),
_bindBuffer: _bind(webgl, `bindBuffer`),
_bindBufferBase: _bind(webgl, `bindBufferBase`),
_bindFramebuffer: _bind(webgl, `bindFramebuffer`),
_bindRenderbuffer: _bind(webgl, `bindRenderbuffer`),
_bindTexture: _bind(webgl, `bindTexture`),
_blendEquation: _bind(webgl, `blendEquation`),
_blendFunc: _bind(webgl, `blendFunc`),
_bufferData: _bind(webgl, `bufferData`),
_bufferSubData: _bind(webgl, `bufferSubData`),
_checkFramebufferStatus: _bind(webgl, `checkFramebufferStatus`),
_clear: _bind(webgl, `clear`),
_clearColor: _bind(webgl, `clearColor`),
_clearDepth: _bind(webgl, `clearDepth`),
_compileShader: _bind(webgl, `compileShader`),
_copyTexSubImage2D: _bind(webgl, `copyTexSubImage2D`),
_createBuffer: _bind(webgl, `createBuffer`),
_createFramebuffer: _bind(webgl, `createFramebuffer`),
_createProgram: _bind(webgl, `createProgram`),
_createQuery: _bind(webgl, `createQuery`),
_createRenderbuffer: _bind(webgl, `createRenderbuffer`),
_createShader: _bind(webgl, `createShader`),
_createTexture: _bind(webgl, `createTexture`),
_deleteBuffer: _bind(webgl, `deleteBuffer`),
_deleteFramebuffer: _bind(webgl, `deleteFramebuffer`),
_deleteProgram: _bind(webgl, `deleteProgram`),
_deleteQuery: _bind(webgl, `deleteQuery`),
_deleteQueryEXT: _bind(webgl, `deleteQueryEXT`),
_deleteShader: _bind(webgl, `deleteShader`),
_deleteRenderbuffer: _bind(webgl, `deleteRenderbuffer`),
_deleteTexture: _bind(webgl, `deleteTexture`),
_depthFunc: _bind(webgl, `depthFunc`),
_depthMask: _bind(webgl, `depthMask`),
_disableVertexAttribArray: _bind(webgl, `disableVertexAttribArray`),
_disable: _bind(webgl, `disable`),
_drawArrays: _bind(webgl, `drawArrays`),
_drawElements: _bind(webgl, `drawElements`),
_enable: _bind(webgl, `enable`),
_enableVertexAttribArray: _bind(webgl, `enableVertexAttribArray`),
_endQuery: _bind(webgl, `endQuery`),
_endQueryEXT: _bind(webgl, `endQueryEXT`),
_finish: _bind(webgl, `finish`),
_flush: _bind(webgl, `flush`),
_framebufferRenderbuffer: _bind(webgl, `framebufferRenderbuffer`),
_framebufferTexture2D: _bind(webgl, `framebufferTexture2D`),
_getRenderbufferParameteri: _bind(webgl, `getRenderbufferParameteri`),
_getFramebufferAttachmentParameter: _bind(webgl, `getFramebufferAttachmentParameter`),
_getParameter: _bind(webgl, `getParameter`),
_getIndexedParameter: _bind(webgl, `getIndexedParameter`),
_getProgramParameter: _bind(webgl, `getProgramParameter`),
_getProgramInfoLog: _bind(webgl, `getProgramInfoLog`),
_getQueryParameter: _bind(webgl, `getQueryParameter`),
_getQueryObjectEXT: _bind(webgl, `getQueryObjectEXT`),
_getShaderParameter: _bind(webgl, `getShaderParameter`),
_getShaderInfoLog: _bind(webgl, `getShaderInfoLog`),
_getSupportedExtensions: _bind(webgl, `getSupportedExtensions`),
_getUniformBlockIndex: _bind(webgl, `getUniformBlockIndex`),
_getUniformLocation: _bind(webgl, `getUniformLocation`),
_getVertexAttrib: _bind(webgl, `getVertexAttrib`),
_getVertexAttribOffset: _bind(webgl, `getVertexAttribOffset`),
_invalidateFramebuffer: _bind(webgl, `invalidateFramebuffer`),
_isEnabled: _bind(webgl, `isEnabled`),
_linkProgram: _bind(webgl, `linkProgram`),
_pixelStorei: _bind(webgl, `pixelStorei`),
_renderbufferStorage: _bind(webgl, `renderbufferStorage`),
_readPixels: _bind(webgl, `readPixels`),
_scissor: _bind(webgl, `scissor`),
_shaderSource: _bind(webgl, `shaderSource`),
_texImage2D: _bind(webgl, `texImage2D`),
_texStorage2D: _bind(webgl, `texStorage2D`),
_texSubImage2D: _bind(webgl, `texSubImage2D`),
_texParameteri: _bind(webgl, `texParameteri`),
_uniformBlockBinding: _bind(webgl, `uniformBlockBinding`),
_uniform1f: _bind(webgl, `uniform1f`),
_uniform1i: _bind(webgl, `uniform1i`),
_uniform2f: _bind(webgl, `uniform2f`),
_uniform3f: _bind(webgl, `uniform3f`),
_uniform4f: _bind(webgl, `uniform4f`),
_useProgram: _bind(webgl, `useProgram`),
_vertexAttribPointer: _bind(webgl, `vertexAttribPointer`),
_viewport: _bind(webgl, `viewport`),
}
if err := f.Init(); err != nil {
return nil, err
@@ -36,6 +210,13 @@ func NewFunctions(ctx Context, forceES bool) (*Functions, error) {
return f, nil
}
func _bind(ctx js.Value, p string) js.Value {
if o := ctx.Get(p); o.Truthy() {
return o.Call("bind", ctx)
}
return js.Undefined()
}
func (f *Functions) Init() error {
webgl2Class := js.Global().Get("WebGL2RenderingContext")
f.isWebGL2 = !webgl2Class.IsUndefined() && f.Ctx.InstanceOf(webgl2Class)
@@ -58,39 +239,39 @@ func (f *Functions) Init() error {
}
func (f *Functions) getExtension(name string) js.Value {
return f.Ctx.Call("getExtension", name)
return f._getExtension.Invoke(name)
}
func (f *Functions) ActiveTexture(t Enum) {
f.Ctx.Call("activeTexture", int(t))
f._activeTexture.Invoke(int(t))
}
func (f *Functions) AttachShader(p Program, s Shader) {
f.Ctx.Call("attachShader", js.Value(p), js.Value(s))
f._attachShader.Invoke(js.Value(p), js.Value(s))
}
func (f *Functions) BeginQuery(target Enum, query Query) {
if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
f.Ctx.Call("beginQuery", int(target), js.Value(query))
f._beginQuery.Invoke(int(target), js.Value(query))
} else {
f.EXT_disjoint_timer_query.Call("beginQueryEXT", int(target), js.Value(query))
}
}
func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) {
f.Ctx.Call("bindAttribLocation", js.Value(p), int(a), name)
f._bindAttribLocation.Invoke(js.Value(p), int(a), name)
}
func (f *Functions) BindBuffer(target Enum, b Buffer) {
f.Ctx.Call("bindBuffer", int(target), js.Value(b))
f._bindBuffer.Invoke(int(target), js.Value(b))
}
func (f *Functions) BindBufferBase(target Enum, index int, b Buffer) {
f.Ctx.Call("bindBufferBase", int(target), index, js.Value(b))
f._bindBufferBase.Invoke(int(target), index, js.Value(b))
}
func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
f.Ctx.Call("bindFramebuffer", int(target), js.Value(fb))
f._bindFramebuffer.Invoke(int(target), js.Value(fb))
}
func (f *Functions) BindRenderbuffer(target Enum, rb Renderbuffer) {
f.Ctx.Call("bindRenderbuffer", int(target), js.Value(rb))
f._bindRenderbuffer.Invoke(int(target), js.Value(rb))
}
func (f *Functions) BindTexture(target Enum, t Texture) {
f.Ctx.Call("bindTexture", int(target), js.Value(t))
f._bindTexture.Invoke(int(target), js.Value(t))
}
func (f *Functions) BindImageTexture(unit int, t Texture, level int, layered bool, layer int, access, format Enum) {
panic("not implemented")
@@ -99,163 +280,163 @@ func (f *Functions) BindVertexArray(a VertexArray) {
panic("not supported")
}
func (f *Functions) BlendEquation(mode Enum) {
f.Ctx.Call("blendEquation", int(mode))
f._blendEquation.Invoke(int(mode))
}
func (f *Functions) BlendFuncSeparate(srcRGB, dstRGB, srcA, dstA Enum) {
f.Ctx.Call("blendFunc", int(srcRGB), int(dstRGB), int(srcA), int(dstA))
f._blendFunc.Invoke(int(srcRGB), int(dstRGB), int(srcA), int(dstA))
}
func (f *Functions) BufferData(target Enum, size int, usage Enum, data []byte) {
if data == nil {
f.Ctx.Call("bufferData", int(target), size, int(usage))
f._bufferData.Invoke(int(target), size, int(usage))
} else {
if len(data) != size {
panic("size mismatch")
}
f.Ctx.Call("bufferData", int(target), f.byteArrayOf(data), int(usage))
f._bufferData.Invoke(int(target), f.byteArrayOf(data), int(usage))
}
}
func (f *Functions) BufferSubData(target Enum, offset int, src []byte) {
f.Ctx.Call("bufferSubData", int(target), offset, f.byteArrayOf(src))
f._bufferSubData.Invoke(int(target), offset, f.byteArrayOf(src))
}
func (f *Functions) CheckFramebufferStatus(target Enum) Enum {
return Enum(f.Ctx.Call("checkFramebufferStatus", int(target)).Int())
return Enum(f._checkFramebufferStatus.Invoke(int(target)).Int())
}
func (f *Functions) Clear(mask Enum) {
f.Ctx.Call("clear", int(mask))
f._clear.Invoke(int(mask))
}
func (f *Functions) ClearColor(red, green, blue, alpha float32) {
f.Ctx.Call("clearColor", red, green, blue, alpha)
f._clearColor.Invoke(red, green, blue, alpha)
}
func (f *Functions) ClearDepthf(d float32) {
f.Ctx.Call("clearDepth", d)
f._clearDepth.Invoke(d)
}
func (f *Functions) CompileShader(s Shader) {
f.Ctx.Call("compileShader", js.Value(s))
f._compileShader.Invoke(js.Value(s))
}
func (f *Functions) CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) {
f.Ctx.Call("copyTexSubImage2D", int(target), level, xoffset, yoffset, x, y, width, height)
f._copyTexSubImage2D.Invoke(int(target), level, xoffset, yoffset, x, y, width, height)
}
func (f *Functions) CreateBuffer() Buffer {
return Buffer(f.Ctx.Call("createBuffer"))
return Buffer(f._createBuffer.Invoke())
}
func (f *Functions) CreateFramebuffer() Framebuffer {
return Framebuffer(f.Ctx.Call("createFramebuffer"))
return Framebuffer(f._createFramebuffer.Invoke())
}
func (f *Functions) CreateProgram() Program {
return Program(f.Ctx.Call("createProgram"))
return Program(f._createProgram.Invoke())
}
func (f *Functions) CreateQuery() Query {
return Query(f.Ctx.Call("createQuery"))
return Query(f._createQuery.Invoke())
}
func (f *Functions) CreateRenderbuffer() Renderbuffer {
return Renderbuffer(f.Ctx.Call("createRenderbuffer"))
return Renderbuffer(f._createRenderbuffer.Invoke())
}
func (f *Functions) CreateShader(ty Enum) Shader {
return Shader(f.Ctx.Call("createShader", int(ty)))
return Shader(f._createShader.Invoke(int(ty)))
}
func (f *Functions) CreateTexture() Texture {
return Texture(f.Ctx.Call("createTexture"))
return Texture(f._createTexture.Invoke())
}
func (f *Functions) CreateVertexArray() VertexArray {
panic("not supported")
}
func (f *Functions) DeleteBuffer(v Buffer) {
f.Ctx.Call("deleteBuffer", js.Value(v))
f._deleteBuffer.Invoke(js.Value(v))
}
func (f *Functions) DeleteFramebuffer(v Framebuffer) {
f.Ctx.Call("deleteFramebuffer", js.Value(v))
f._deleteFramebuffer.Invoke(js.Value(v))
}
func (f *Functions) DeleteProgram(p Program) {
f.Ctx.Call("deleteProgram", js.Value(p))
f._deleteProgram.Invoke(js.Value(p))
}
func (f *Functions) DeleteQuery(query Query) {
if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
f.Ctx.Call("deleteQuery", js.Value(query))
f._deleteQuery.Invoke(js.Value(query))
} else {
f.EXT_disjoint_timer_query.Call("deleteQueryEXT", js.Value(query))
}
}
func (f *Functions) DeleteShader(s Shader) {
f.Ctx.Call("deleteShader", js.Value(s))
f._deleteShader.Invoke(js.Value(s))
}
func (f *Functions) DeleteRenderbuffer(v Renderbuffer) {
f.Ctx.Call("deleteRenderbuffer", js.Value(v))
f._deleteRenderbuffer.Invoke(js.Value(v))
}
func (f *Functions) DeleteTexture(v Texture) {
f.Ctx.Call("deleteTexture", js.Value(v))
f._deleteTexture.Invoke(js.Value(v))
}
func (f *Functions) DeleteVertexArray(a VertexArray) {
panic("not implemented")
}
func (f *Functions) DepthFunc(fn Enum) {
f.Ctx.Call("depthFunc", int(fn))
f._depthFunc.Invoke(int(fn))
}
func (f *Functions) DepthMask(mask bool) {
f.Ctx.Call("depthMask", mask)
f._depthMask.Invoke(mask)
}
func (f *Functions) DisableVertexAttribArray(a Attrib) {
f.Ctx.Call("disableVertexAttribArray", int(a))
f._disableVertexAttribArray.Invoke(int(a))
}
func (f *Functions) Disable(cap Enum) {
f.Ctx.Call("disable", int(cap))
f._disable.Invoke(int(cap))
}
func (f *Functions) DrawArrays(mode Enum, first, count int) {
f.Ctx.Call("drawArrays", int(mode), first, count)
f._drawArrays.Invoke(int(mode), first, count)
}
func (f *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) {
f.Ctx.Call("drawElements", int(mode), count, int(ty), offset)
f._drawElements.Invoke(int(mode), count, int(ty), offset)
}
func (f *Functions) DispatchCompute(x, y, z int) {
panic("not implemented")
}
func (f *Functions) Enable(cap Enum) {
f.Ctx.Call("enable", int(cap))
f._enable.Invoke(int(cap))
}
func (f *Functions) EnableVertexAttribArray(a Attrib) {
f.Ctx.Call("enableVertexAttribArray", int(a))
f._enableVertexAttribArray.Invoke(int(a))
}
func (f *Functions) EndQuery(target Enum) {
if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
f.Ctx.Call("endQuery", int(target))
f._endQuery.Invoke(int(target))
} else {
f.EXT_disjoint_timer_query.Call("endQueryEXT", int(target))
}
}
func (f *Functions) Finish() {
f.Ctx.Call("finish")
f._finish.Invoke()
}
func (f *Functions) Flush() {
f.Ctx.Call("flush")
f._flush.Invoke()
}
func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
f.Ctx.Call("framebufferRenderbuffer", int(target), int(attachment), int(renderbuffertarget), js.Value(renderbuffer))
f._framebufferRenderbuffer.Invoke(int(target), int(attachment), int(renderbuffertarget), js.Value(renderbuffer))
}
func (f *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
f.Ctx.Call("framebufferTexture2D", int(target), int(attachment), int(texTarget), js.Value(t), level)
f._framebufferTexture2D.Invoke(int(target), int(attachment), int(texTarget), js.Value(t), level)
}
func (f *Functions) GetError() Enum {
// Avoid slow getError calls. See gio#179.
return 0
}
func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int {
return paramVal(f.Ctx.Call("getRenderbufferParameteri", int(pname)))
return paramVal(f._getRenderbufferParameteri.Invoke(int(pname)))
}
func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int {
if !f.isWebGL2 && pname == FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING {
// FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING is only available on WebGL 2
return LINEAR
}
return paramVal(f.Ctx.Call("getFramebufferAttachmentParameter", int(target), int(attachment), int(pname)))
return paramVal(f._getFramebufferAttachmentParameter.Invoke(int(target), int(attachment), int(pname)))
}
func (f *Functions) GetBinding(pname Enum) Object {
obj := f.Ctx.Call("getParameter", int(pname))
obj := f._getParameter.Invoke(int(pname))
if !obj.Truthy() {
return Object{}
}
return Object(obj)
}
func (f *Functions) GetBindingi(pname Enum, idx int) Object {
obj := f.Ctx.Call("getIndexedParameter", int(pname), idx)
obj := f._getIndexedParameter.Invoke(int(pname), idx)
if !obj.Truthy() {
return Object{}
}
@@ -268,13 +449,13 @@ func (f *Functions) GetInteger(pname Enum) int {
return 0 // PACK_ROW_LENGTH and UNPACK_ROW_LENGTH is only available on WebGL 2
}
}
return paramVal(f.Ctx.Call("getParameter", int(pname)))
return paramVal(f._getParameter.Invoke(int(pname)))
}
func (f *Functions) GetFloat(pname Enum) float32 {
return float32(f.Ctx.Call("getParameter", int(pname)).Float())
return float32(f._getParameter.Invoke(int(pname)).Float())
}
func (f *Functions) GetInteger4(pname Enum) [4]int {
arr := f.Ctx.Call("getParameter", int(pname))
arr := f._getParameter.Invoke(int(pname))
var res [4]int
for i := range res {
res[i] = arr.Index(i).Int()
@@ -282,7 +463,7 @@ func (f *Functions) GetInteger4(pname Enum) [4]int {
return res
}
func (f *Functions) GetFloat4(pname Enum) [4]float32 {
arr := f.Ctx.Call("getParameter", int(pname))
arr := f._getParameter.Invoke(int(pname))
var res [4]float32
for i := range res {
res[i] = float32(arr.Index(i).Float())
@@ -290,55 +471,55 @@ func (f *Functions) GetFloat4(pname Enum) [4]float32 {
return res
}
func (f *Functions) GetProgrami(p Program, pname Enum) int {
return paramVal(f.Ctx.Call("getProgramParameter", js.Value(p), int(pname)))
return paramVal(f._getProgramParameter.Invoke(js.Value(p), int(pname)))
}
func (f *Functions) GetProgramInfoLog(p Program) string {
return f.Ctx.Call("getProgramInfoLog", js.Value(p)).String()
return f._getProgramInfoLog.Invoke(js.Value(p)).String()
}
func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
return uint(paramVal(f.Ctx.Call("getQueryParameter", js.Value(query), int(pname))))
return uint(paramVal(f._getQueryParameter.Invoke(js.Value(query), int(pname))))
} else {
return uint(paramVal(f.EXT_disjoint_timer_query.Call("getQueryObjectEXT", js.Value(query), int(pname))))
}
}
func (f *Functions) GetShaderi(s Shader, pname Enum) int {
return paramVal(f.Ctx.Call("getShaderParameter", js.Value(s), int(pname)))
return paramVal(f._getShaderParameter.Invoke(js.Value(s), int(pname)))
}
func (f *Functions) GetShaderInfoLog(s Shader) string {
return f.Ctx.Call("getShaderInfoLog", js.Value(s)).String()
return f._getShaderInfoLog.Invoke(js.Value(s)).String()
}
func (f *Functions) GetString(pname Enum) string {
switch pname {
case EXTENSIONS:
extsjs := f.Ctx.Call("getSupportedExtensions")
extsjs := f._getSupportedExtensions.Invoke()
var exts []string
for i := 0; i < extsjs.Length(); i++ {
exts = append(exts, "GL_"+extsjs.Index(i).String())
}
return strings.Join(exts, " ")
default:
return f.Ctx.Call("getParameter", int(pname)).String()
return f._getParameter.Invoke(int(pname)).String()
}
}
func (f *Functions) GetUniformBlockIndex(p Program, name string) uint {
return uint(paramVal(f.Ctx.Call("getUniformBlockIndex", js.Value(p), name)))
return uint(paramVal(f._getUniformBlockIndex.Invoke(js.Value(p), name)))
}
func (f *Functions) GetUniformLocation(p Program, name string) Uniform {
return Uniform(f.Ctx.Call("getUniformLocation", js.Value(p), name))
return Uniform(f._getUniformLocation.Invoke(js.Value(p), name))
}
func (f *Functions) GetVertexAttrib(index int, pname Enum) int {
return paramVal(f.Ctx.Call("getVertexAttrib", index, int(pname)))
return paramVal(f._getVertexAttrib.Invoke(index, int(pname)))
}
func (f *Functions) GetVertexAttribBinding(index int, pname Enum) Object {
obj := f.Ctx.Call("getVertexAttrib", index, int(pname))
obj := f._getVertexAttrib.Invoke(index, int(pname))
if !obj.Truthy() {
return Object{}
}
return Object(obj)
}
func (f *Functions) GetVertexAttribPointer(index int, pname Enum) uintptr {
return uintptr(f.Ctx.Call("getVertexAttribOffset", index, int(pname)).Int())
return uintptr(f._getVertexAttribOffset.Invoke(index, int(pname)).Int())
}
func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
fn := f.Ctx.Get("invalidateFramebuffer")
@@ -347,17 +528,17 @@ func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
f.int32Buf = js.Global().Get("Int32Array").New(1)
}
f.int32Buf.SetIndex(0, int32(attachment))
f.Ctx.Call("invalidateFramebuffer", int(target), f.int32Buf)
f._invalidateFramebuffer.Invoke(int(target), f.int32Buf)
}
}
func (f *Functions) IsEnabled(cap Enum) bool {
return f.Ctx.Call("isEnabled", int(cap)).Truthy()
return f._isEnabled.Invoke(int(cap)).Truthy()
}
func (f *Functions) LinkProgram(p Program) {
f.Ctx.Call("linkProgram", js.Value(p))
f._linkProgram.Invoke(js.Value(p))
}
func (f *Functions) PixelStorei(pname Enum, param int) {
f.Ctx.Call("pixelStorei", int(pname), param)
f._pixelStorei.Invoke(int(pname), param)
}
func (f *Functions) MemoryBarrier(barriers Enum) {
panic("not implemented")
@@ -366,60 +547,60 @@ func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum)
panic("not implemented")
}
func (f *Functions) RenderbufferStorage(target, internalformat Enum, width, height int) {
f.Ctx.Call("renderbufferStorage", int(target), int(internalformat), width, height)
f._renderbufferStorage.Invoke(int(target), int(internalformat), width, height)
}
func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []byte) {
ba := f.byteArrayOf(data)
f.Ctx.Call("readPixels", x, y, width, height, int(format), int(ty), ba)
f._readPixels.Invoke(x, y, width, height, int(format), int(ty), ba)
js.CopyBytesToGo(data, ba)
}
func (f *Functions) Scissor(x, y, width, height int32) {
f.Ctx.Call("scissor", x, y, width, height)
f._scissor.Invoke(x, y, width, height)
}
func (f *Functions) ShaderSource(s Shader, src string) {
f.Ctx.Call("shaderSource", js.Value(s), src)
f._shaderSource.Invoke(js.Value(s), src)
}
func (f *Functions) TexImage2D(target Enum, level int, internalFormat Enum, width, height int, format, ty Enum) {
f.Ctx.Call("texImage2D", int(target), int(level), int(internalFormat), int(width), int(height), 0, int(format), int(ty), nil)
f._texImage2D.Invoke(int(target), int(level), int(internalFormat), int(width), int(height), 0, int(format), int(ty), nil)
}
func (f *Functions) TexStorage2D(target Enum, levels int, internalFormat Enum, width, height int) {
f.Ctx.Call("texStorage2D", int(target), levels, int(internalFormat), width, height)
f._texStorage2D.Invoke(int(target), levels, int(internalFormat), width, height)
}
func (f *Functions) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
f.Ctx.Call("texSubImage2D", int(target), level, x, y, width, height, int(format), int(ty), f.byteArrayOf(data))
f._texSubImage2D.Invoke(int(target), level, x, y, width, height, int(format), int(ty), f.byteArrayOf(data))
}
func (f *Functions) TexParameteri(target, pname Enum, param int) {
f.Ctx.Call("texParameteri", int(target), int(pname), int(param))
f._texParameteri.Invoke(int(target), int(pname), int(param))
}
func (f *Functions) UniformBlockBinding(p Program, uniformBlockIndex uint, uniformBlockBinding uint) {
f.Ctx.Call("uniformBlockBinding", js.Value(p), int(uniformBlockIndex), int(uniformBlockBinding))
f._uniformBlockBinding.Invoke(js.Value(p), int(uniformBlockIndex), int(uniformBlockBinding))
}
func (f *Functions) Uniform1f(dst Uniform, v float32) {
f.Ctx.Call("uniform1f", js.Value(dst), v)
f._uniform1f.Invoke(js.Value(dst), v)
}
func (f *Functions) Uniform1i(dst Uniform, v int) {
f.Ctx.Call("uniform1i", js.Value(dst), v)
f._uniform1i.Invoke(js.Value(dst), v)
}
func (f *Functions) Uniform2f(dst Uniform, v0, v1 float32) {
f.Ctx.Call("uniform2f", js.Value(dst), v0, v1)
f._uniform2f.Invoke(js.Value(dst), v0, v1)
}
func (f *Functions) Uniform3f(dst Uniform, v0, v1, v2 float32) {
f.Ctx.Call("uniform3f", js.Value(dst), v0, v1, v2)
f._uniform3f.Invoke(js.Value(dst), v0, v1, v2)
}
func (f *Functions) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
f.Ctx.Call("uniform4f", js.Value(dst), v0, v1, v2, v3)
f._uniform4f.Invoke(js.Value(dst), v0, v1, v2, v3)
}
func (f *Functions) UseProgram(p Program) {
f.Ctx.Call("useProgram", js.Value(p))
f._useProgram.Invoke(js.Value(p))
}
func (f *Functions) UnmapBuffer(target Enum) bool {
panic("not implemented")
}
func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
f.Ctx.Call("vertexAttribPointer", int(dst), size, int(ty), normalized, stride, offset)
f._vertexAttribPointer.Invoke(int(dst), size, int(ty), normalized, stride, offset)
}
func (f *Functions) Viewport(x, y, width, height int) {
f.Ctx.Call("viewport", x, y, width, height)
f._viewport.Invoke(x, y, width, height)
}
func (f *Functions) byteArrayOf(data []byte) js.Value {