@nativescript/canvas 2.0.0-alpha.20 → 2.0.0-alpha.22

package/WebGL/WebGLRenderingContext/index.js

@@ -47,7 +47,7 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 // todo
                 //direction = 1;
             }
-            this._context = ctor(contextOptions, ctx, Screen.mainScreen.scale, -16777216, Screen.mainScreen.scale * 160, direction);
+            this._context = global.CanvasModule.createWebGLContext(contextOptions, ctx, Screen.mainScreen.scale, -16777216, Screen.mainScreen.scale * 160, direction);
         }
         else {
             this._context = context;
@@ -69,397 +69,334 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return this.native.drawingBufferWidth;
     }
     __toDataURL() {
-        const __toDataURL = this._getMethod('__toDataURL');
-        return __toDataURL(arguments[0], arguments[1]);
+        return this.native.__toDataURL(arguments[0], arguments[1]);
     }
     activeTexture(texture) {
         this._glCheckError('activeTexture');
         this._checkArgs('activeTexture', arguments);
-        const activeTexture = this._getMethod('activeTexture');
-        activeTexture(texture);
+        this.native.activeTexture(texture);
     }
     attachShader(program, shader) {
         this._glCheckError('attachShader');
         this._checkArgs('attachShader', arguments);
         const value = program.native;
         const value2 = shader.native;
-        const attachShader = this._getMethod('attachShader');
-        attachShader(value, value2);
+        this.native.attachShader(value, value2);
     }
     bindAttribLocation(program, index, name) {
         this._glCheckError('bindAttribLocation');
         this._checkArgs('bindAttribLocation', arguments);
-        const bindAttribLocation = this._getMethod('bindAttribLocation');
         const value = program.native;
-        bindAttribLocation(value, index, name);
+        this.native.bindAttribLocation(value, index, name);
     }
     bindBuffer(target, buffer) {
         this._glCheckError('bindBuffer');
         this._checkArgs('bindBuffer', arguments);
         const value = buffer ? buffer.native : null;
-        const bindBuffer = this._getMethod('bindBuffer');
-        bindBuffer(target, value);
+        this.native.bindBuffer(target, value);
     }
     bindFramebuffer(target, framebuffer) {
         this._glCheckError('bindFramebuffer');
         this._checkArgs('bindFramebuffer', arguments);
         const value = framebuffer ? framebuffer.native : null;
-        const bindFramebuffer = this._getMethod('bindFramebuffer');
-        bindFramebuffer(target, value);
+        this.native.bindFramebuffer(target, value);
     }
     bindRenderbuffer(target, renderbuffer) {
         this._glCheckError('bindRenderbuffer');
         this._checkArgs('bindRenderbuffer', arguments);
         const value = renderbuffer ? renderbuffer.native : null;
-        const bindRenderbuffer = this._getMethod('bindRenderbuffer');
-        bindRenderbuffer(target, value);
+        this.native.bindRenderbuffer(target, value);
     }
     bindTexture(target, texture) {
         this._glCheckError('bindTexture');
         this._checkArgs('bindTexture', arguments);
         const value = texture ? texture.native : null;
-        const bindTexture = this._getMethod('bindTexture');
-        bindTexture(target, value);
+        this.native.bindTexture(target, value);
     }
     blendColor(red, green, blue, alpha) {
         this._glCheckError('blendColor');
         this._checkArgs('blendColor', arguments);
-        const blendColor = this._getMethod('blendColor');
-        blendColor(red, green, blue, alpha);
+        this.native.blendColor(red, green, blue, alpha);
     }
     blendEquationSeparate(modeRGB, modeAlpha) {
         this._glCheckError('blendEquationSeparate');
         this._checkArgs('blendEquationSeparate', arguments);
-        const blendEquationSeparate = this._getMethod('blendEquationSeparate');
-        blendEquationSeparate(modeRGB, modeAlpha);
+        this.native.blendEquationSeparate(modeRGB, modeAlpha);
     }
     blendEquation(mode) {
         this._glCheckError('blendEquation');
         this._checkArgs('blendEquation', arguments);
-        const blendEquation = this._getMethod('blendEquation');
-        blendEquation(mode);
+        this.native.blendEquation(mode);
     }
     blendFuncSeparate(srcRGB = this.ONE, dstRGB = this.ZERO, srcAlpha = this.ONE, dstAlpha = this.ZERO) {
         this._glCheckError('blendFuncSeparate');
         this._checkArgs('blendFuncSeparate', arguments);
-        const blendFuncSeparate = this._getMethod('blendFuncSeparate');
-        blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+        this.native.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
     }
     blendFunc(sfactor = this.ONE, dfactor = this.ZERO) {
         this._glCheckError('blendFunc');
         this._checkArgs('blendFunc', arguments);
-        const blendFunc = this._getMethod('blendFunc');
-        blendFunc(sfactor, dfactor);
+        this.native.blendFunc(sfactor, dfactor);
     }
     bufferData(target, srcData, usage) {
         this._glCheckError('bufferData');
         this._checkArgs('bufferData', arguments);
-        const bufferData = this._getMethod('bufferData');
-        bufferData(target, srcData, usage);
+        this.native.bufferData(target, srcData, usage);
     }
     bufferSubData(target, offset, srcData) {
         this._glCheckError('bufferSubData');
         this._checkArgs('bufferSubData', arguments);
-        const bufferSubData = this._getMethod('bufferSubData');
-        bufferSubData(target, offset, srcData);
+        this.native.bufferSubData(target, offset, srcData);
     }
     checkFramebufferStatus(target) {
         this._glCheckError('checkFramebufferStatus');
         this._checkArgs('checkFramebufferStatus', arguments);
-        const checkFramebufferStatus = this._getMethod('checkFramebufferStatus');
-        return checkFramebufferStatus(target);
+        return this.native.checkFramebufferStatus(target);
     }
     clearColor(red, green, blue, alpha) {
         this._glCheckError('clearColor');
         this._checkArgs('clearColor', arguments);
-        const clearColor = this._getMethod('clearColor');
-        clearColor(red, green, blue, alpha);
+        this.native.clearColor(red, green, blue, alpha);
     }
     clearDepth(depth) {
         this._glCheckError('clearDepth');
         this._checkArgs('clearDepth', arguments);
-        const clearDepth = this._getMethod('clearDepth');
-        clearDepth(depth);
+        this.native.clearDepth(depth);
     }
     clearStencil(stencil) {
         this._glCheckError('clearStencil');
         this._checkArgs('clearStencil', arguments);
-        const clearStencil = this._getMethod('clearStencil');
-        clearStencil(stencil);
+        this.native.clearStencil(stencil);
     }
     clear(mask) {
         this._glCheckError('clear');
         this._checkArgs('clear', arguments);
-        const clear = this._getMethod('clear');
-        clear(mask);
+        this.native.clear(mask);
     }
     colorMask(red, green, blue, alpha) {
         this._glCheckError('colorMask');
         this._checkArgs('colorMask', arguments);
-        const colorMask = this._getMethod('colorMask');
-        colorMask(red, green, blue, alpha);
+        this.native.colorMask(red, green, blue, alpha);
     }
     commit() {
         // NOOP
-        const commit = this._getMethod('commit');
-        commit();
+        this.native.commit();
     }
     compileShader(shader) {
         this._glCheckError('compileShader');
         this._checkArgs('compileShader', arguments);
-        const compileShader = this._getMethod('compileShader');
         const value = shader.native;
-        compileShader(value);
+        this.native.compileShader(value);
     }
     compressedTexImage2D(target, level, internalformat, width, height, border, pixels) {
         this._glCheckError('compressedTexImage2D');
         this._checkArgs('compressedTexImage2D', arguments);
-        const compressedTexImage2D = this._getMethod('compressedTexImage2D');
-        compressedTexImage2D(target, level, internalformat, width, height, border, pixels);
+        this.native.compressedTexImage2D(target, level, internalformat, width, height, border, pixels);
     }
     compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, pixels) {
         this._glCheckError('compressedTexSubImage2D');
         this._checkArgs('compressedTexSubImage2D', arguments);
-        const compressedTexSubImage2D = this._getMethod('compressedTexSubImage2D');
-        compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, pixels);
+        this.native.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, pixels);
     }
     copyTexImage2D(target, level, internalformat, x, y, width, height, border) {
         this._glCheckError('copyTexImage2D');
         this._checkArgs('copyTexImage2D', arguments);
-        const copyTexImage2D = this._getMethod('copyTexImage2D');
-        copyTexImage2D(target, level, internalformat, x, y, width, height, border);
+        this.native.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
     }
     copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) {
         this._glCheckError('copyTexSubImage2D');
         this._checkArgs('copyTexSubImage2D', arguments);
-        const copyTexSubImage2D = this._getMethod('copyTexSubImage2D');
-        copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+        this.native.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
     }
     createBuffer() {
         this._glCheckError('createBuffer');
         this._checkArgs('createBuffer', arguments);
-        const createBuffer = this._getMethod('createBuffer');
-        const id = createBuffer();
+        const id = this.native.createBuffer();
         return new WebGLBuffer(id);
     }
     createFramebuffer() {
         this._glCheckError('createFramebuffer');
         this._checkArgs('createFramebuffer', arguments);
-        const createFramebuffer = this._getMethod('createFramebuffer');
-        return new WebGLFramebuffer(createFramebuffer());
+        return new WebGLFramebuffer(this.native.createFramebuffer());
     }
     createProgram() {
         this._glCheckError('createProgram');
         this._checkArgs('createProgram', arguments);
-        const createProgram = this._getMethod('createProgram');
-        return new WebGLProgram(createProgram());
+        return new WebGLProgram(this.native.createProgram());
     }
     createRenderbuffer() {
         this._glCheckError('createRenderbuffer');
         this._checkArgs('createRenderbuffer', arguments);
-        const createRenderbuffer = this._getMethod('createRenderbuffer');
-        return new WebGLRenderbuffer(createRenderbuffer());
+        return new WebGLRenderbuffer(this.native.createRenderbuffer());
     }
     createShader(type) {
         this._glCheckError('createShader');
         this._checkArgs('createShader', arguments);
-        const createShader = this._getMethod('createShader');
-        return new WebGLShader(createShader(type));
+        return new WebGLShader(this.native.createShader(type));
     }
     createTexture() {
         this._glCheckError('createTexture');
         this._checkArgs('createTexture', arguments);
-        const createTexture = this._getMethod('createTexture');
-        return new WebGLTexture(createTexture());
+        return new WebGLTexture(this.native.createTexture());
     }
     cullFace(mode) {
         this._glCheckError('cullFace');
         this._checkArgs('cullFace', arguments);
-        const cullFace = this._getMethod('cullFace');
-        cullFace(mode);
+        this.native.cullFace(mode);
     }
     deleteBuffer(buffer) {
         this._glCheckError('deleteBuffer');
         this._checkArgs('deleteBuffer', arguments);
         const value = buffer.native;
-        const deleteBuffer = this._getMethod('deleteBuffer');
-        deleteBuffer(value);
+        this.native.deleteBuffer(value);
     }
     deleteFramebuffer(frameBuffer) {
         this._glCheckError('deleteFramebuffer');
         this._checkArgs('deleteFramebuffer', arguments);
         const value = frameBuffer.native;
-        const deleteFramebuffer = this._getMethod('deleteFramebuffer');
-        deleteFramebuffer(value);
+        this.native.deleteFramebuffer(value);
     }
     deleteProgram(program) {
         this._glCheckError('deleteProgram');
         this._checkArgs('deleteProgram', arguments);
         const value = program.native;
-        const deleteProgram = this._getMethod('deleteProgram');
-        deleteProgram(value);
+        this.native.deleteProgram(value);
     }
     deleteRenderbuffer(renderBuffer) {
         this._glCheckError('deleteRenderbuffer');
         this._checkArgs('deleteRenderbuffer', arguments);
         const value = renderBuffer.native;
-        const deleteRenderbuffer = this._getMethod('deleteRenderbuffer');
-        deleteRenderbuffer(value);
+        this.native.deleteRenderbuffer(value);
     }
     deleteShader(shader) {
         this._glCheckError('deleteShader');
         this._checkArgs('deleteShader', arguments);
-        const deleteShader = this._getMethod('deleteShader');
-        deleteShader(shader.native);
+        this.native.deleteShader(shader.native);
     }
     deleteTexture(texture) {
         this._glCheckError('deleteTexture');
         this._checkArgs('deleteTexture', arguments);
         const value = texture.native;
-        const deleteTexture = this._getMethod('deleteTexture');
-        deleteTexture(value);
+        this.native.deleteTexture(value);
     }
     depthFunc(func) {
         this._glCheckError('depthFunc');
         this._checkArgs('depthFunc', arguments);
-        const depthFunc = this._getMethod('depthFunc');
-        depthFunc(func);
+        this.native.depthFunc(func);
     }
     depthMask(flag) {
         this._glCheckError('depthMask');
         this._checkArgs('depthMask', arguments);
-        const depthMask = this._getMethod('depthMask');
-        depthMask(flag);
+        this.native.depthMask(flag);
     }
     depthRange(zNear, zFar) {
         this._glCheckError('depthRange');
         this._checkArgs('depthRange', arguments);
-        const depthRange = this._getMethod('depthRange');
-        depthRange(zNear, zFar);
+        this.native.depthRange(zNear, zFar);
     }
     detachShader(program, shader) {
         this._glCheckError('detachShader');
         this._checkArgs('detachShader', arguments);
         const value = program.native;
         const value2 = shader.native;
-        const detachShader = this._getMethod('detachShader');
-        detachShader(value, value2);
+        this.native.detachShader(value, value2);
     }
     disableVertexAttribArray(index) {
         this._glCheckError('disableVertexAttribArray');
         this._checkArgs('disableVertexAttribArray', arguments);
-        const disableVertexAttribArray = this._getMethod('disableVertexAttribArray');
-        disableVertexAttribArray(index);
+        this.native.disableVertexAttribArray(index);
     }
     disable(cap) {
         this._glCheckError('disable');
         this._checkArgs('disable', arguments);
-        const disable = this._getMethod('disable');
-        disable(cap);
+        this.native.disable(cap);
     }
     drawArrays(mode, first, count) {
         this._glCheckError('drawArrays');
         this._checkArgs('drawArrays', arguments);
-        const drawArrays = this._getMethod('drawArrays');
-        drawArrays(mode, first, count);
+        this.native.drawArrays(mode, first, count);
     }
     drawElements(mode, count, type, offset) {
         this._glCheckError('drawElements');
         this._checkArgs('drawElements', arguments);
-        const drawElements = this._getMethod('drawElements');
-        drawElements(mode, count, type, offset);
+        this.native.drawElements(mode, count, type, offset);
     }
     enableVertexAttribArray(index) {
         this._glCheckError('enableVertexAttribArray');
         this._checkArgs('enableVertexAttribArray', arguments);
-        const enableVertexAttribArray = this._getMethod('enableVertexAttribArray');
-        enableVertexAttribArray(index);
+        this.native.enableVertexAttribArray(index);
     }
     enable(cap) {
         this._glCheckError('enable');
         this._checkArgs('enable', arguments);
-        const enable = this._getMethod('enable');
-        enable(cap);
+        this.native.enable(cap);
     }
     finish() {
         this._glCheckError('finish');
-        const finish = this._getMethod('finish');
-        finish();
+        this.native.finish();
     }
     flush() {
         this._glCheckError('flush');
-        const flush = this._getMethod('flush');
-        flush();
+        this.native.flush();
     }
     framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
         this._glCheckError('framebufferRenderbuffer');
         this._checkArgs('framebufferRenderbuffer', arguments);
         const value = renderbuffer.native;
-        const framebufferRenderbuffer = this._getMethod('framebufferRenderbuffer');
-        framebufferRenderbuffer(target, attachment, renderbuffertarget, value);
+        this.native.framebufferRenderbuffer(target, attachment, renderbuffertarget, value);
     }
     framebufferTexture2D(target, attachment, textarget, texture, level) {
         this._glCheckError('framebufferTexture2D');
         this._checkArgs('framebufferTexture2D', arguments);
         const value = texture.native;
-        const framebufferTexture2D = this._getMethod('framebufferTexture2D');
-        framebufferTexture2D(target, attachment, textarget, value, level);
+        this.native.framebufferTexture2D(target, attachment, textarget, value, level);
     }
     frontFace(mode) {
         this._checkArgs('frontFace', arguments);
         this._glCheckError('frontFace');
-        const frontFace = this._getMethod('frontFace');
-        frontFace(mode);
+        this.native.frontFace(mode);
     }
     generateMipmap(target) {
         this._checkArgs('generateMipmap', arguments);
         this._glCheckError('generateMipmap');
-        const generateMipmap = this._getMethod('generateMipmap');
-        generateMipmap(target);
+        this.native.generateMipmap(target);
     }
     getActiveAttrib(program, index) {
         this._glCheckError('getActiveAttrib');
         this._checkArgs('getActiveAttrib', arguments);
         const value = program.native;
-        const getActiveAttrib = this._getMethod('getActiveAttrib');
-        const attrib = getActiveAttrib(value, index);
+        const attrib = this.native.getActiveAttrib(value, index);
         return new WebGLActiveInfo(attrib);
     }
     getActiveUniform(program, index) {
         this._glCheckError('getActiveUniform');
         this._checkArgs('getActiveUniform', arguments);
         const value = program.native;
-        const getActiveUniform = this._getMethod('getActiveUniform');
-        const uniform = getActiveUniform(value, index);
+        const uniform = this.native.getActiveUniform(value, index);
         return new WebGLActiveInfo(uniform);
     }
     getAttachedShaders(program) {
         this._glCheckError('getAttachedShaders');
         this._checkArgs('getAttachedShaders', arguments);
-        const getAttachedShaders = this._getMethod('getAttachedShaders');
         const value = program.native;
-        return getAttachedShaders(value).map((shader) => new WebGLShader(shader));
+        return this.native.getAttachedShaders(value).map((shader) => new WebGLShader(shader));
     }
     getAttribLocation(program, name) {
         this._glCheckError('getAttribLocation');
         this._checkArgs('getAttribLocation', arguments);
-        const getAttribLocation = this._getMethod('getAttribLocation');
         const value = program.native;
-        return getAttribLocation(value, name);
+        return this.native.getAttribLocation(value, name);
     }
     getBufferParameter(target, pname) {
         this._glCheckError('getBufferParameter');
         this._checkArgs('getBufferParameter', arguments);
-        const getBufferParameter = this._getMethod('getBufferParameter');
-        return getBufferParameter(target, pname);
+        return this.native.getBufferParameter(target, pname);
     }
     getContextAttributes() {
-        const getContextAttributes = this._getMethod('getContextAttributes');
-        return getContextAttributes();
+        return this.native.getContextAttributes();
     }
     getError() {
-        const getError = this._getMethod('getError');
-        return getError();
+        return this.native.getError();
     }
     getExtension(name) {
         this._glCheckError('getExtension');
@@ -467,8 +404,7 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         if (name === 'EXT_disjoint_timer_query_webgl2') {
             return null;
         }
-        const getExtension = this._getMethod('getExtension');
-        const ext = getExtension(name);
+        const ext = this.native.getExtension(name);
         if (ext) {
             const ext_name = ext.ext_name;
             switch (ext_name) {
@@ -525,8 +461,7 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     getFramebufferAttachmentParameter(target, attachment, pname) {
         this._glCheckError('getFramebufferAttachmentParameter');
         this._checkArgs('getFramebufferAttachmentParameter', arguments);
-        const getFramebufferAttachmentParameter = this._getMethod('getFramebufferAttachmentParameter');
-        const param = getFramebufferAttachmentParameter(target, attachment, pname);
+        const param = this.native.getFramebufferAttachmentParameter(target, attachment, pname);
         if (typeof param === 'object') {
             if (param.isRenderbuffer) {
                 return new WebGLRenderbuffer(param);
@@ -593,77 +528,66 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     getParameter(pname) {
         this._glCheckError('getParameter');
         this._checkArgs('getParameter', arguments);
-        const getParameter = this._getMethod('getParameter');
-        const value = getParameter(pname);
+        const value = this.native.getParameter(pname);
         return this._handleGetParameter(pname, value);
     }
     getProgramInfoLog(program) {
         this._glCheckError('getProgramInfoLog');
         this._checkArgs('getProgramInfoLog', arguments);
-        const getProgramInfoLog = this._getMethod('getProgramInfoLog');
         const value = program.native;
-        return getProgramInfoLog(value);
+        return this.native.getProgramInfoLog(value);
     }
     getProgramParameter(program, pname) {
         this._glCheckError('getProgramParameter');
         this._checkArgs('getProgramParameter', arguments);
-        const getProgramParameter = this._getMethod('getProgramParameter');
         const value = program.native;
-        const result = getProgramParameter(value, pname);
+        const result = this.native.getProgramParameter(value, pname);
         return result;
     }
     getRenderbufferParameter(target, pname) {
         this._glCheckError('getRenderbufferParameter');
         this._checkArgs('getRenderbufferParameter', arguments);
-        const getRenderbufferParameter = this._getMethod('getRenderbufferParameter');
-        return getRenderbufferParameter(target, pname);
+        return this.native.getRenderbufferParameter(target, pname);
     }
     getShaderInfoLog(shader) {
         this._glCheckError('getShaderInfoLog');
         this._checkArgs('getShaderInfoLog', arguments);
-        const getShaderInfoLog = this._getMethod('getShaderInfoLog');
         const value = shader.native;
-        return getShaderInfoLog(value);
+        return this.native.getShaderInfoLog(value);
     }
     getShaderParameter(shader, pname) {
         this._glCheckError('getShaderParameter');
         this._checkArgs('getShaderParameter', arguments);
-        const getShaderParameter = this._getMethod('getShaderParameter');
         const value = shader.native;
-        const result = getShaderParameter(value, pname);
+        const result = this.native.getShaderParameter(value, pname);
         return result;
     }
     getShaderPrecisionFormat(shaderType, precisionType) {
         this._glCheckError('getShaderPrecisionFormat');
         this._checkArgs('getShaderPrecisionFormat', arguments);
-        const getShaderPrecisionFormat = this._getMethod('getShaderPrecisionFormat');
-        const precision = getShaderPrecisionFormat(shaderType, precisionType);
+        const precision = this.native.getShaderPrecisionFormat(shaderType, precisionType);
         return new WebGLShaderPrecisionFormat(precision);
     }
     getShaderSource(shader) {
         this._glCheckError('getShaderSource');
         this._checkArgs('getShaderSource', arguments);
-        const getShaderSource = this._getMethod('getShaderSource');
         const value = shader ? shader.native : 0;
-        return getShaderSource(value);
+        return this.native.getShaderSource(value);
     }
     getSupportedExtensions() {
         this._glCheckError('getSupportedExtensions');
-        const getSupportedExtensions = this._getMethod('getSupportedExtensions');
-        return getSupportedExtensions();
+        return this.native.getSupportedExtensions();
     }
     getTexParameter(target, pname) {
         this._glCheckError('getTexParameter');
         this._checkArgs('getTexParameter', arguments);
-        const getTexParameter = this._getMethod('getTexParameter');
-        return getTexParameter(target, pname);
+        return this.native.getTexParameter(target, pname);
     }
     getUniformLocation(program, name) {
         this._glCheckError('getUniformLocation');
         this._checkArgs('getUniformLocation', arguments);
-        const getUniformLocation = this._getMethod('getUniformLocation');
         const value = program.native;
-        const id = getUniformLocation(value, name);
+        const id = this.native.getUniformLocation(value, name);
         if (id === -1) {
             return null;
         }
@@ -672,10 +596,9 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     getUniform(program, location) {
         this._glCheckError('getUniform');
         this._checkArgs('getUniform', arguments);
-        const getUniform = this._getMethod('getUniform');
         const value = program.native;
         const value2 = location.native;
-        const uniform = getUniform(value, value2);
+        const uniform = this.native.getUniform(value, value2);
         if (uniform && uniform.length) {
             return uniform;
         }
@@ -684,14 +607,12 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     getVertexAttribOffset(index, pname) {
         this._glCheckError('getVertexAttribOffset');
         this._checkArgs('getVertexAttribOffset', arguments);
-        const getVertexAttribOffset = this._getMethod('getVertexAttribOffset');
-        return getVertexAttribOffset(index, pname);
+        return this.native.getVertexAttribOffset(index, pname);
     }
     getVertexAttrib(index, pname) {
         this._glCheckError('getVertexAttrib');
         this._checkArgs('getVertexAttrib', arguments);
-        const getVertexAttrib = this._getMethod('getVertexAttrib');
-        const value = getVertexAttrib(index, pname);
+        const value = this.native.getVertexAttrib(index, pname);
         if (pname === this.CURRENT_VERTEX_ATTRIB) {
             return value;
         }
@@ -700,84 +621,72 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     hint(target, mode) {
         this._glCheckError('hint');
         this._checkArgs('hint', arguments);
-        const hint = this._getMethod('hint');
-        hint(target, mode);
+        this.native.hint(target, mode);
     }
     isBuffer(buffer) {
         this._glCheckError('isBuffer');
         this._checkArgs('isBuffer', arguments);
-        const isBuffer = this._getMethod('isBuffer');
         const value = buffer.native;
-        return isBuffer(value);
+        return this.native.isBuffer(value);
     }
     isContextLost() {
         this._glCheckError('isContextLost');
-        const isContextLost = this._getMethod('isContextLost');
-        return isContextLost();
+        return this.native.isContextLost();
     }
     isEnabled(cap) {
         this._glCheckError('isEnabled');
         this._checkArgs('isEnabled', arguments);
-        const isEnabled = this._getMethod('isEnabled');
-        return isEnabled(cap);
+        return this.native.isEnabled(cap);
     }
     isFramebuffer(framebuffer) {
         this._glCheckError('isFramebuffer');
         this._checkArgs('isFramebuffer', arguments);
-        const isFramebuffer = this._getMethod('isFramebuffer');
         const value = framebuffer ? framebuffer.native : 0;
-        return isFramebuffer(value);
+        return this.native.isFramebuffer(value);
     }
     isProgram(program) {
         this._glCheckError('isProgram');
         this._checkArgs('isProgram', arguments);
-        const isProgram = this._getMethod('isProgram');
         const value = program.native;
-        return isProgram(value);
+        return this.native.isProgram(value);
     }
     isRenderbuffer(renderbuffer) {
         this._glCheckError('isRenderbuffer');
         this._checkArgs('isRenderbuffer', arguments);
-        const isRenderbuffer = this._getMethod('isRenderbuffer');
         const value = renderbuffer.native;
-        return isRenderbuffer(value);
+        return this.native.isRenderbuffer(value);
     }
     isShader(shader) {
         this._glCheckError('isShader');
         this._checkArgs('isShader', arguments);
-        const isShader = this._getMethod('isShader');
         const value = shader.native;
-        return isShader(value);
+        return this.native.isShader(value);
     }
     isTexture(texture) {
         this._glCheckError('isTexture');
         this._checkArgs('isTexture', arguments);
-        const isTexture = this._getMethod('isTexture');
         const value = texture.native;
-        return isTexture(value);
+        return this.native.isTexture(value);
     }
     lineWidth(width) {
         this._glCheckError('lineWidth');
         this._checkArgs('lineWidth', arguments);
-        const lineWidth = this._getMethod('lineWidth');
-        lineWidth(width);
+        this.native.lineWidth(width);
     }
     linkProgram(program) {
         this._glCheckError('linkProgram');
         this._checkArgs('linkProgram', arguments);
-        const linkProgram = this._getMethod('linkProgram');
         const value = program ? program.native : 0;
-        linkProgram(value);
+        this.native.linkProgram(value);
     }
     pixelStorei(pname, param) {
         this._glCheckError('pixelStorei');
         this._checkArgs('pixelStorei', arguments);
-        const pixelStorei = this._getMethod('pixelStorei');
         if (pname === this.UNPACK_FLIP_Y_WEBGL || pname === this.UNPACK_PREMULTIPLY_ALPHA_WEBGL) {
             if (pname === this.UNPACK_FLIP_Y_WEBGL) {
                 this._flipY = param;
             }
-            pixelStorei(pname, param);
+            this.native.pixelStorei(pname, param);
         }
         else if (pname === this.PACK_ALIGNMENT || pname === this.UNPACK_ALIGNMENT || pname === this.UNPACK_COLORSPACE_CONVERSION_WEBGL) {
             if (pname === this.UNPACK_COLORSPACE_CONVERSION_WEBGL) {
@@ -786,96 +695,83 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
             else if (pname === this.PACK_ALIGNMENT || pname === this.UNPACK_ALIGNMENT) {
                 //param = 1;
             }
-            pixelStorei(pname, param);
+            this.native.pixelStorei(pname, param);
         }
         else {
-            pixelStorei(pname, param);
+            this.native.pixelStorei(pname, param);
         }
     }
     polygonOffset(factor, units) {
         this._glCheckError('polygonOffset');
         this._checkArgs('polygonOffset', arguments);
-        const polygonOffset = this._getMethod('polygonOffset');
-        polygonOffset(factor, units);
+        this.native.polygonOffset(factor, units);
     }
     readPixels(x, y, width, height, format, type, pixels) {
         this._glCheckError('readPixels');
         this._checkArgs('readPixels', arguments);
-        const readPixels = this._getMethod('readPixels');
-        readPixels(x, y, width, height, format, type, pixels);
+        this.native.readPixels(x, y, width, height, format, type, pixels);
     }
     renderbufferStorage(target, internalFormat, width, height) {
         this._glCheckError('renderbufferStorage');
         this._checkArgs('renderbufferStorage', arguments);
-        const renderbufferStorage = this._getMethod('renderbufferStorage');
         if (internalFormat === this.DEPTH_STENCIL) {
             // DEPTH24_STENCIL8 = 35056
             // DEPTH24_STENCIL8_OES = 0x88F0
             internalFormat = 0x88f0;
         }
-        renderbufferStorage(target, internalFormat, width, height);
+        this.native.renderbufferStorage(target, internalFormat, width, height);
     }
     sampleCoverage(value, invert) {
         this._glCheckError('sampleCoverage');
         this._checkArgs('sampleCoverage', arguments);
-        const sampleCoverage = this._getMethod('sampleCoverage');
-        sampleCoverage(value, invert);
+        this.native.sampleCoverage(value, invert);
     }
     scissor(x, y, width, height) {
         this._glCheckError('scissor');
         this._checkArgs('scissor', arguments);
-        const scissor = this._getMethod('scissor');
-        scissor(x, y, width, height);
+        this.native.scissor(x, y, width, height);
     }
     shaderSource(shader, source) {
         this._glCheckError('shaderSource');
         this._checkArgs('shaderSource', arguments);
-        const shaderSource = this._getMethod('shaderSource');
         const value = shader ? shader.native : 0;
-        shaderSource(value, source);
+        this.native.shaderSource(value, source);
     }
     stencilFuncSeparate(face, func, ref, mask) {
         this._glCheckError('stencilFuncSeparate');
         this._checkArgs('stencilFuncSeparate', arguments);
-        const stencilFuncSeparate = this._getMethod('stencilFuncSeparate');
-        stencilFuncSeparate(face, func, ref, mask);
+        this.native.stencilFuncSeparate(face, func, ref, mask);
     }
     stencilFunc(func, ref, mask) {
         this._glCheckError('stencilFunc');
         this._checkArgs('stencilFunc', arguments);
-        const stencilFunc = this._getMethod('stencilFunc');
-        stencilFunc(func, ref, mask);
+        this.native.stencilFunc(func, ref, mask);
     }
     stencilMaskSeparate(face, mask) {
         this._glCheckError('stencilMaskSeparate');
         this._checkArgs('stencilMaskSeparate', arguments);
-        const stencilMaskSeparate = this._getMethod('stencilMaskSeparate');
-        stencilMaskSeparate(face, mask);
+        this.native.stencilMaskSeparate(face, mask);
     }
     stencilMask(mask) {
         this._glCheckError('stencilMask');
         this._checkArgs('stencilMask', arguments);
-        const stencilMask = this._getMethod('stencilMask');
-        stencilMask(mask);
+        this.native.stencilMask(mask);
     }
     stencilOpSeparate(face, fail, zfail, zpass) {
         this._glCheckError('stencilOpSeparate');
         this._checkArgs('stencilOpSeparate', arguments);
-        const stencilOpSeparate = this._getMethod('stencilOpSeparate');
-        stencilOpSeparate(face, fail, zfail, zpass);
+        this.native.stencilOpSeparate(face, fail, zfail, zpass);
     }
     stencilOp(fail, zfail, zpass) {
         this._glCheckError('stencilOp');
         this._checkArgs('stencilOp', arguments);
-        const stencilOp = this._getMethod('stencilOp');
-        stencilOp(fail, zfail, zpass);
+        this.native.stencilOp(fail, zfail, zpass);
     }
     texImage2D(target, level, internalformat, width, height, border, format, type, pixels) {
         this._glCheckError('texImage2D');
         this._checkArgs('texImage2D', arguments);
-        const texImage2D = this._getMethod('texImage2D');
         if (arguments.length === 9) {
-            texImage2D(target, level, internalformat, width, height, border, format, type ?? internalformat, pixels);
+            this.native.texImage2D(target, level, internalformat, width, height, border, format, type ?? internalformat, pixels);
         }
         else if (arguments.length === 6) {
             if (border && typeof border.tagName === 'string' && (border.tagName === 'VID' || border.tagName === 'VIDEO') && border._video && typeof border._video.getCurrentFrame === 'function') {
@@ -885,298 +781,264 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 border.getCurrentFrame(this.native, this, target, level, internalformat, width, height);
             }
             else if (border instanceof ImageAsset) {
-                texImage2D(target, level, internalformat, width, height, border.native);
+                this.native.texImage2D(target, level, internalformat, width, height, border.native);
             }
             else if (border instanceof ImageBitmap) {
-                texImage2D(target, level, internalformat, width, height, border.native);
+                this.native.texImage2D(target, level, internalformat, width, height, border.native);
             }
             else if (global.isAndroid && border instanceof android.graphics.Bitmap) {
                 // todo ios
-                texImage2D(target, level, internalformat, width, height, border);
+                this.native.texImage2D(target, level, internalformat, width, height, border);
             }
             else if (border instanceof ImageSource) {
-                texImage2D(target, level, internalformat, width, height, border.android);
+                this.native.texImage2D(target, level, internalformat, width, height, border.android);
             }
             else if (border && typeof border.tagName === 'string' && (border.tagName === 'IMG' || border.tagName === 'IMAGE')) {
                 if (border._asset instanceof ImageAsset) {
-                    texImage2D(target, level, internalformat, width, height, border._asset.native);
+                    this.native.texImage2D(target, level, internalformat, width, height, border._asset.native);
                 }
                 else if (border._imageSource instanceof ImageSource) {
-                    texImage2D(target, level, internalformat, width, height, border._imageSource.android);
+                    this.native.texImage2D(target, level, internalformat, width, height, border._imageSource.android);
                 }
                 else if (global.isAndroid && border._image instanceof android.graphics.Bitmap) {
                     //todo ios
-                    texImage2D(target, level, internalformat, width, height, border._image);
+                    this.native.texImage2D(target, level, internalformat, width, height, border._image);
                 }
                 else if (typeof border.src === 'string') {
-                    texImage2D(target, level, internalformat, width, height, ImageSource.fromFileSync(border.src).android);
+                    this.native.texImage2D(target, level, internalformat, width, height, ImageSource.fromFileSync(border.src).android);
                 }
             }
             else if (border && typeof border.tagName === 'string' && border.tagName === 'CANVAS' && border._canvas instanceof Canvas) {
-                texImage2D(target, level, internalformat, width, height, border._canvas.native);
+                this.native.texImage2D(target, level, internalformat, width, height, border._canvas.native);
             }
         }
     }
     texParameterf(target, pname, param) {
         this._glCheckError('texParameterf');
         this._checkArgs('texParameterf', arguments);
-        const texParameterf = this._getMethod('texParameterf');
-        texParameterf(target, pname, param);
+        this.native.texParameterf(target, pname, param);
     }
     texParameteri(target, pname, param) {
         this._glCheckError('texParameteri');
         this._checkArgs('texParameteri', arguments);
-        const texParameteri = this._getMethod('texParameteri');
-        texParameteri(target, pname, param);
+        this.native.texParameteri(target, pname, param);
     }
     texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
         this._glCheckError('texSubImage2D');
         this._checkArgs('texSubImage2D', arguments);
-        const texSubImage2D = this._getMethod('texSubImage2D');
         if (arguments.length === 9) {
-            texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+            this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
         }
         else if (arguments.length === 7) {
             if (global.isAndroid && format instanceof android.graphics.Bitmap) {
                 // todo
-                texSubImage2D(target, level, xoffset, yoffset, width, height, format);
+                this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format);
             }
             else if (format instanceof ImageSource) {
-                texSubImage2D(target, level, xoffset, yoffset, width, height, format.android);
+                this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format.android);
             }
             else if (format instanceof ImageAsset) {
-                texSubImage2D(target, level, xoffset, yoffset, width, height, format.native);
+                this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format.native);
             }
             else if (format instanceof ImageBitmap) {
-                texSubImage2D(target, level, xoffset, yoffset, width, height, format.native);
+                this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format.native);
             }
             else if (format && typeof format.tagName === 'string' && (format.tagName === 'IMG' || format.tagName === 'IMAGE')) {
                 if (format._imageSource instanceof ImageSource) {
-                    texSubImage2D(target, level, xoffset, yoffset, width, height, format._imageSource.android);
+                    this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format._imageSource.android);
                 }
                 else if (global.isAndroid && format._image instanceof android.graphics.Bitmap) {
                     // todo
-                    texSubImage2D(target, level, xoffset, yoffset, width, height, format._image);
+                    this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format._image);
                 }
                 else if (format._asset instanceof ImageAsset) {
-                    texSubImage2D(target, level, xoffset, yoffset, width, height, format._asset.native);
+                    this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format._asset.native);
                 }
                 else if (typeof format.src === 'string') {
                     const result = ImageSource.fromFileSync(format.src);
-                    texSubImage2D(target, level, xoffset, yoffset, width, height, result ? result.android : null);
+                    this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, result ? result.android : null);
                 }
             }
             else if (format && typeof format.tagName === 'string' && format.tagName === 'CANVAS' && format._canvas instanceof Canvas) {
-                texSubImage2D(target, level, xoffset, yoffset, width, height, format._canvas.native);
+                this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format._canvas.native);
             }
         }
     }
     uniform1f(location, v0) {
         this._glCheckError('uniform1f');
         this._checkArgs('uniform1f', arguments);
-        const uniform1f = this._getMethod('uniform1f');
         const loc = location.native;
-        uniform1f(loc, v0);
+        this.native.uniform1f(loc, v0);
     }
     uniform1iv(location, value) {
         this._glCheckError('uniform1iv');
         this._checkArgs('uniform1iv', arguments);
         const loc = location.native;
-        const uniform1iv = this._getMethod('uniform1iv');
-        uniform1iv(loc, value);
+        this.native.uniform1iv(loc, value);
     }
     uniform1fv(location, value) {
         this._glCheckError('uniform1fv');
         this._checkArgs('uniform1fv', arguments);
         const loc = location.native;
-        const uniform1fv = this._getMethod('uniform1fv');
-        uniform1fv(loc, value);
+        this.native.uniform1fv(loc, value);
     }
     uniform1i(location, v0) {
         this._glCheckError('uniform1i');
         this._checkArgs('uniform1i', arguments);
-        const uniform1i = this._getMethod('uniform1i');
         const loc = location.native;
-        uniform1i(loc, Number(v0));
+        this.native.uniform1i(loc, Number(v0));
     }
     uniform2f(location, v0, v1) {
         this._glCheckError('uniform2f');
         this._checkArgs('uniform2f', arguments);
-        const uniform2f = this._getMethod('uniform2f');
         const loc = location.native;
-        uniform2f(loc, v0, v1);
+        this.native.uniform2f(loc, v0, v1);
     }
     uniform2iv(location, value) {
         this._glCheckError('uniform2iv');
         this._checkArgs('uniform2iv', arguments);
         const loc = location.native;
-        const uniform2iv = this._getMethod('uniform2iv');
-        uniform2iv(loc, value);
+        this.native.uniform2iv(loc, value);
     }
     uniform2fv(location, value) {
         this._glCheckError('uniform2fv');
         this._checkArgs('uniform2fv', arguments);
         const loc = location.native;
-        const uniform2fv = this._getMethod('uniform2fv');
-        uniform2fv(loc, value);
+        this.native.uniform2fv(loc, value);
     }
     uniform2i(location, v0, v1) {
         this._glCheckError('uniform2i');
         this._checkArgs('uniform2i', arguments);
-        const uniform2i = this._getMethod('uniform2i');
         const loc = location.native;
-        uniform2i(loc, v0, v1);
+        this.native.uniform2i(loc, v0, v1);
     }
     uniform3f(location, v0, v1, v2) {
         this._glCheckError('uniform3f');
         this._checkArgs('uniform3f', arguments);
-        const uniform3f = this._getMethod('uniform3f');
         const loc = location.native;
-        uniform3f(loc, v0, v1, v2);
+        this.native.uniform3f(loc, v0, v1, v2);
     }
     uniform3iv(location, value) {
         this._glCheckError('uniform3iv');
         this._checkArgs('uniform3iv', arguments);
         const loc = location.native;
-        const uniform3iv = this._getMethod('uniform3iv');
-        uniform3iv(loc, value);
+        this.native.uniform3iv(loc, value);
     }
     uniform3fv(location, value) {
         this._glCheckError('uniform3fv');
         this._checkArgs('uniform3fv', arguments);
         const loc = location.native;
-        const uniform3fv = this._getMethod('uniform3fv');
-        uniform3fv(loc, value);
+        this.native.uniform3fv(loc, value);
     }
     uniform3i(location, v0, v1, v2) {
         this._glCheckError('uniform3i');
         this._checkArgs('uniform3i', arguments);
-        const uniform3i = this._getMethod('uniform3i');
         const loc = location.native;
-        uniform3i(loc, v0, v1, v2);
+        this.native.uniform3i(loc, v0, v1, v2);
     }
     uniform4f(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4f');
         this._checkArgs('uniform4f', arguments);
-        const uniform4f = this._getMethod('uniform4f');
         const loc = location.native;
-        uniform4f(loc, v0, v1, v2, v3);
+        this.native.uniform4f(loc, v0, v1, v2, v3);
     }
     uniform4iv(location, value) {
         this._glCheckError('uniform4iv');
         this._checkArgs('uniform4iv', arguments);
         const loc = location.native;
-        const uniform4iv = this._getMethod('uniform4iv');
-        uniform4iv(loc, value);
+        this.native.uniform4iv(loc, value);
     }
     uniform4fv(location, value) {
         this._glCheckError('uniform4fv');
         this._checkArgs('uniform4fv', arguments);
         const loc = location.native;
-        const uniform4fv = this._getMethod('uniform4fv');
-        uniform4fv(loc, value);
+        this.native.uniform4fv(loc, value);
     }
     uniform4i(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4i');
         this._checkArgs('uniform4i', arguments);
-        const uniform4i = this._getMethod('uniform4i');
         const loc = location.native;
-        uniform4i(loc, v0, v1, v2, v3);
+        this.native.uniform4i(loc, v0, v1, v2, v3);
     }
     uniformMatrix2fv(location, transpose, value) {
         this._glCheckError('uniformMatrix2fv');
         this._checkArgs('uniformMatrix2fv', arguments);
         const loc = location.native;
-        const uniformMatrix2fv = this._getMethod('uniformMatrix2fv');
-        uniformMatrix2fv(loc, transpose, value);
+        this.native.uniformMatrix2fv(loc, transpose, value);
     }
     uniformMatrix3fv(location, transpose, value) {
         this._glCheckError('uniformMatrix3fv');
         this._checkArgs('uniformMatrix3fv', arguments);
         const loc = location.native;
-        const uniformMatrix3fv = this._getMethod('uniformMatrix3fv');
-        uniformMatrix3fv(loc, transpose, value);
+        this.native.uniformMatrix3fv(loc, transpose, value);
     }
     uniformMatrix4fv(location, transpose, value) {
         this._glCheckError('uniformMatrix4fv');
         this._checkArgs('uniformMatrix4fv', arguments);
         const loc = location.native;
-        const uniformMatrix4fv = this._getMethod('uniformMatrix4fv');
-        uniformMatrix4fv(loc, transpose, value);
+        this.native.uniformMatrix4fv(loc, transpose, value);
     }
     useProgram(program) {
         this._glCheckError('useProgram');
         this._checkArgs('useProgram', arguments);
-        const useProgram = this._getMethod('useProgram');
         const value = program ? program.native : null;
-        useProgram(value);
+        this.native.useProgram(value);
     }
     validateProgram(program) {
         this._glCheckError('validateProgram');
         this._checkArgs('validateProgram', arguments);
-        const validateProgram = this._getMethod('validateProgram');
         const value = program.native;
-        validateProgram(value);
+        this.native.validateProgram(value);
     }
     vertexAttrib1f(index, v0) {
         this._glCheckError('vertexAttrib1f');
         this._checkArgs('vertexAttrib1f', arguments);
-        const vertexAttrib1f = this._getMethod('vertexAttrib1f');
-        vertexAttrib1f(index, v0);
+        this.native.vertexAttrib1f(index, v0);
     }
     vertexAttrib1fv(index, value) {
         this._glCheckError('vertexAttrib1fv');
         this._checkArgs('vertexAttrib1fv', arguments);
-        const vertexAttrib1fv = this._getMethod('vertexAttrib1fv');
-        vertexAttrib1fv(index, value);
+        this.native.vertexAttrib1fv(index, value);
     }
     vertexAttrib2f(index, v0, v1) {
         this._glCheckError('vertexAttrib2f');
         this._checkArgs('vertexAttrib2f', arguments);
-        const vertexAttrib2f = this._getMethod('vertexAttrib2f');
-        vertexAttrib2f(index, v0, v1);
+        this.native.vertexAttrib2f(index, v0, v1);
     }
     vertexAttrib2fv(index, value) {
         this._glCheckError('vertexAttrib2fv');
         this._checkArgs('vertexAttrib2fv', arguments);
-        const vertexAttrib2fv = this._getMethod('vertexAttrib2fv');
-        vertexAttrib2fv(index, value);
+        this.native.vertexAttrib2fv(index, value);
     }
     vertexAttrib3f(index, v0, v1, v2) {
         this._glCheckError('vertexAttrib3f');
         this._checkArgs('vertexAttrib3f', arguments);
-        const vertexAttrib3f = this._getMethod('vertexAttrib3f');
-        vertexAttrib3f(index, v0, v1, v2);
+        this.native.vertexAttrib3f(index, v0, v1, v2);
     }
     vertexAttrib3fv(index, value) {
         this._glCheckError('vertexAttrib3fv');
         this._checkArgs('vertexAttrib3fv', arguments);
-        const vertexAttrib3fv = this._getMethod('vertexAttrib3fv');
-        vertexAttrib3fv(index, value);
+        this.native.vertexAttrib3fv(index, value);
     }
     vertexAttrib4f(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttrib4f');
         this._checkArgs('vertexAttrib4f', arguments);
-        const vertexAttrib4f = this._getMethod('vertexAttrib4f');
-        vertexAttrib4f(index, v0, v1, v2, v3);
+        this.native.vertexAttrib4f(index, v0, v1, v2, v3);
     }
     vertexAttrib4fv(index, value) {
         this._glCheckError('vertexAttrib4fv');
         this._checkArgs('vertexAttrib4fv', arguments);
-        const vertexAttrib4fv = this._getMethod('vertexAttrib4fv');
-        vertexAttrib4fv(index, value);
+        this.native.vertexAttrib4fv(index, value);
     }
     vertexAttribPointer(index, size, type, normalized, stride, offset) {
         this._glCheckError('vertexAttribPointer');
         this._checkArgs('vertexAttribPointer', arguments);
-        const vertexAttribPointer = this._getMethod('vertexAttribPointer');
-        vertexAttribPointer(index, size, type, !!normalized, stride, offset);
+        this.native.vertexAttribPointer(index, size, type, !!normalized, stride, offset);
     }
     viewport(x, y, width, height) {
         this._glCheckError('viewport');
         this._checkArgs('viewport', arguments);
-        const viewport = this._getMethod('viewport');
-        viewport(x, y, width, height);
+        this.native.viewport(x, y, width, height);
     }
     _glCheckError(message) {
         if (!WebGLRenderingContext.isDebug) {
@@ -1201,7 +1063,6 @@ WebGLRenderingContext.isDebug = false;
 WebGLRenderingContext.filter = 'both';
 (() => {
     Helpers.initialize();
-    ctor = global.CanvasJSIModule.createWebGLContext;
 })();
 __decorate([
     profile,