@nativescript/canvas 2.0.0-alpha.23 → 2.0.0-alpha.25

package/WebGL/WebGLRenderingContext/index.js

@@ -72,110 +72,70 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return this.native.__toDataURL(arguments[0], arguments[1]);
     }
     activeTexture(texture) {
-        this._glCheckError('activeTexture');
-        this._checkArgs('activeTexture', arguments);
         this.native.activeTexture(texture);
     }
     attachShader(program, shader) {
-        this._glCheckError('attachShader');
-        this._checkArgs('attachShader', arguments);
         const value = program.native;
         const value2 = shader.native;
         this.native.attachShader(value, value2);
     }
     bindAttribLocation(program, index, name) {
-        this._glCheckError('bindAttribLocation');
-        this._checkArgs('bindAttribLocation', arguments);
         const value = program.native;
         this.native.bindAttribLocation(value, index, name);
     }
     bindBuffer(target, buffer) {
-        this._glCheckError('bindBuffer');
-        this._checkArgs('bindBuffer', arguments);
         const value = buffer ? buffer.native : null;
         this.native.bindBuffer(target, value);
     }
     bindFramebuffer(target, framebuffer) {
-        this._glCheckError('bindFramebuffer');
-        this._checkArgs('bindFramebuffer', arguments);
         const value = framebuffer ? framebuffer.native : null;
         this.native.bindFramebuffer(target, value);
     }
     bindRenderbuffer(target, renderbuffer) {
-        this._glCheckError('bindRenderbuffer');
-        this._checkArgs('bindRenderbuffer', arguments);
         const value = renderbuffer ? renderbuffer.native : null;
         this.native.bindRenderbuffer(target, value);
     }
     bindTexture(target, texture) {
-        this._glCheckError('bindTexture');
-        this._checkArgs('bindTexture', arguments);
         const value = texture ? texture.native : null;
         this.native.bindTexture(target, value);
     }
     blendColor(red, green, blue, alpha) {
-        this._glCheckError('blendColor');
-        this._checkArgs('blendColor', arguments);
         this.native.blendColor(red, green, blue, alpha);
     }
     blendEquationSeparate(modeRGB, modeAlpha) {
-        this._glCheckError('blendEquationSeparate');
-        this._checkArgs('blendEquationSeparate', arguments);
         this.native.blendEquationSeparate(modeRGB, modeAlpha);
     }
     blendEquation(mode) {
-        this._glCheckError('blendEquation');
-        this._checkArgs('blendEquation', arguments);
         this.native.blendEquation(mode);
     }
     blendFuncSeparate(srcRGB = this.ONE, dstRGB = this.ZERO, srcAlpha = this.ONE, dstAlpha = this.ZERO) {
-        this._glCheckError('blendFuncSeparate');
-        this._checkArgs('blendFuncSeparate', arguments);
         this.native.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
     }
     blendFunc(sfactor = this.ONE, dfactor = this.ZERO) {
-        this._glCheckError('blendFunc');
-        this._checkArgs('blendFunc', arguments);
         this.native.blendFunc(sfactor, dfactor);
     }
     bufferData(target, srcData, usage) {
-        this._glCheckError('bufferData');
-        this._checkArgs('bufferData', arguments);
         this.native.bufferData(target, srcData, usage);
     }
     bufferSubData(target, offset, srcData) {
-        this._glCheckError('bufferSubData');
-        this._checkArgs('bufferSubData', arguments);
         this.native.bufferSubData(target, offset, srcData);
     }
     checkFramebufferStatus(target) {
-        this._glCheckError('checkFramebufferStatus');
-        this._checkArgs('checkFramebufferStatus', arguments);
         return this.native.checkFramebufferStatus(target);
     }
     clearColor(red, green, blue, alpha) {
-        this._glCheckError('clearColor');
-        this._checkArgs('clearColor', arguments);
         this.native.clearColor(red, green, blue, alpha);
     }
     clearDepth(depth) {
-        this._glCheckError('clearDepth');
-        this._checkArgs('clearDepth', arguments);
         this.native.clearDepth(depth);
     }
     clearStencil(stencil) {
-        this._glCheckError('clearStencil');
-        this._checkArgs('clearStencil', arguments);
         this.native.clearStencil(stencil);
     }
     clear(mask) {
-        this._glCheckError('clear');
-        this._checkArgs('clear', arguments);
         this.native.clear(mask);
     }
     colorMask(red, green, blue, alpha) {
-        this._glCheckError('colorMask');
-        this._checkArgs('colorMask', arguments);
         this.native.colorMask(red, green, blue, alpha);
     }
     commit() {
@@ -183,115 +143,73 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         this.native.commit();
     }
     compileShader(shader) {
-        this._glCheckError('compileShader');
-        this._checkArgs('compileShader', arguments);
         const value = shader.native;
         this.native.compileShader(value);
     }
     compressedTexImage2D(target, level, internalformat, width, height, border, pixels) {
-        this._glCheckError('compressedTexImage2D');
-        this._checkArgs('compressedTexImage2D', arguments);
         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);
         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);
         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);
         this.native.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
     }
     createBuffer() {
-        this._glCheckError('createBuffer');
-        this._checkArgs('createBuffer', arguments);
         const id = this.native.createBuffer();
         return new WebGLBuffer(id);
     }
     createFramebuffer() {
-        this._glCheckError('createFramebuffer');
-        this._checkArgs('createFramebuffer', arguments);
         return new WebGLFramebuffer(this.native.createFramebuffer());
     }
     createProgram() {
-        this._glCheckError('createProgram');
-        this._checkArgs('createProgram', arguments);
         return new WebGLProgram(this.native.createProgram());
     }
     createRenderbuffer() {
-        this._glCheckError('createRenderbuffer');
-        this._checkArgs('createRenderbuffer', arguments);
         return new WebGLRenderbuffer(this.native.createRenderbuffer());
     }
     createShader(type) {
-        this._glCheckError('createShader');
-        this._checkArgs('createShader', arguments);
         return new WebGLShader(this.native.createShader(type));
     }
     createTexture() {
-        this._glCheckError('createTexture');
-        this._checkArgs('createTexture', arguments);
         return new WebGLTexture(this.native.createTexture());
     }
     cullFace(mode) {
-        this._glCheckError('cullFace');
-        this._checkArgs('cullFace', arguments);
         this.native.cullFace(mode);
     }
     deleteBuffer(buffer) {
-        this._glCheckError('deleteBuffer');
-        this._checkArgs('deleteBuffer', arguments);
         const value = buffer.native;
         this.native.deleteBuffer(value);
     }
     deleteFramebuffer(frameBuffer) {
-        this._glCheckError('deleteFramebuffer');
-        this._checkArgs('deleteFramebuffer', arguments);
         const value = frameBuffer.native;
         this.native.deleteFramebuffer(value);
     }
     deleteProgram(program) {
-        this._glCheckError('deleteProgram');
-        this._checkArgs('deleteProgram', arguments);
         const value = program.native;
         this.native.deleteProgram(value);
     }
     deleteRenderbuffer(renderBuffer) {
-        this._glCheckError('deleteRenderbuffer');
-        this._checkArgs('deleteRenderbuffer', arguments);
         const value = renderBuffer.native;
         this.native.deleteRenderbuffer(value);
     }
     deleteShader(shader) {
-        this._glCheckError('deleteShader');
-        this._checkArgs('deleteShader', arguments);
         this.native.deleteShader(shader.native);
     }
     deleteTexture(texture) {
-        this._glCheckError('deleteTexture');
-        this._checkArgs('deleteTexture', arguments);
         const value = texture.native;
         this.native.deleteTexture(value);
     }
     depthFunc(func) {
-        this._glCheckError('depthFunc');
-        this._checkArgs('depthFunc', arguments);
         this.native.depthFunc(func);
     }
     depthMask(flag) {
-        this._glCheckError('depthMask');
-        this._checkArgs('depthMask', arguments);
         this.native.depthMask(flag);
     }
     depthRange(zNear, zFar) {
-        this._glCheckError('depthRange');
-        this._checkArgs('depthRange', arguments);
         this.native.depthRange(zNear, zFar);
     }
     detachShader(program, shader) {
@@ -302,94 +220,62 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         this.native.detachShader(value, value2);
     }
     disableVertexAttribArray(index) {
-        this._glCheckError('disableVertexAttribArray');
-        this._checkArgs('disableVertexAttribArray', arguments);
         this.native.disableVertexAttribArray(index);
     }
     disable(cap) {
-        this._glCheckError('disable');
-        this._checkArgs('disable', arguments);
         this.native.disable(cap);
     }
     drawArrays(mode, first, count) {
-        this._glCheckError('drawArrays');
-        this._checkArgs('drawArrays', arguments);
         this.native.drawArrays(mode, first, count);
     }
     drawElements(mode, count, type, offset) {
-        this._glCheckError('drawElements');
-        this._checkArgs('drawElements', arguments);
         this.native.drawElements(mode, count, type, offset);
     }
     enableVertexAttribArray(index) {
-        this._glCheckError('enableVertexAttribArray');
-        this._checkArgs('enableVertexAttribArray', arguments);
         this.native.enableVertexAttribArray(index);
     }
     enable(cap) {
-        this._glCheckError('enable');
-        this._checkArgs('enable', arguments);
         this.native.enable(cap);
     }
     finish() {
-        this._glCheckError('finish');
         this.native.finish();
     }
     flush() {
-        this._glCheckError('flush');
         this.native.flush();
     }
     framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
-        this._glCheckError('framebufferRenderbuffer');
-        this._checkArgs('framebufferRenderbuffer', arguments);
         const value = renderbuffer.native;
         this.native.framebufferRenderbuffer(target, attachment, renderbuffertarget, value);
     }
     framebufferTexture2D(target, attachment, textarget, texture, level) {
-        this._glCheckError('framebufferTexture2D');
-        this._checkArgs('framebufferTexture2D', arguments);
         const value = texture.native;
         this.native.framebufferTexture2D(target, attachment, textarget, value, level);
     }
     frontFace(mode) {
-        this._checkArgs('frontFace', arguments);
-        this._glCheckError('frontFace');
         this.native.frontFace(mode);
     }
     generateMipmap(target) {
-        this._checkArgs('generateMipmap', arguments);
-        this._glCheckError('generateMipmap');
         this.native.generateMipmap(target);
     }
     getActiveAttrib(program, index) {
-        this._glCheckError('getActiveAttrib');
-        this._checkArgs('getActiveAttrib', arguments);
         const value = program.native;
         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 uniform = this.native.getActiveUniform(value, index);
         return new WebGLActiveInfo(uniform);
     }
     getAttachedShaders(program) {
-        this._glCheckError('getAttachedShaders');
-        this._checkArgs('getAttachedShaders', arguments);
         const value = program.native;
         return this.native.getAttachedShaders(value).map((shader) => new WebGLShader(shader));
     }
     getAttribLocation(program, name) {
-        this._glCheckError('getAttribLocation');
-        this._checkArgs('getAttribLocation', arguments);
         const value = program.native;
         return this.native.getAttribLocation(value, name);
     }
     getBufferParameter(target, pname) {
-        this._glCheckError('getBufferParameter');
-        this._checkArgs('getBufferParameter', arguments);
         return this.native.getBufferParameter(target, pname);
     }
     getContextAttributes() {
@@ -399,8 +285,6 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return this.native.getError();
     }
     getExtension(name) {
-        this._glCheckError('getExtension');
-        this._checkArgs('getExtension', arguments);
         if (name === 'EXT_disjoint_timer_query_webgl2') {
             return null;
         }
@@ -459,8 +343,6 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return null;
     }
     getFramebufferAttachmentParameter(target, attachment, pname) {
-        this._glCheckError('getFramebufferAttachmentParameter');
-        this._checkArgs('getFramebufferAttachmentParameter', arguments);
         const param = this.native.getFramebufferAttachmentParameter(target, attachment, pname);
         if (typeof param === 'object') {
             if (param.isRenderbuffer) {
@@ -526,66 +408,45 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         }
     }
     getParameter(pname) {
-        this._glCheckError('getParameter');
-        this._checkArgs('getParameter', arguments);
         const value = this.native.getParameter(pname);
         return this._handleGetParameter(pname, value);
     }
     getProgramInfoLog(program) {
-        this._glCheckError('getProgramInfoLog');
-        this._checkArgs('getProgramInfoLog', arguments);
         const value = program.native;
         return this.native.getProgramInfoLog(value);
     }
     getProgramParameter(program, pname) {
-        this._glCheckError('getProgramParameter');
-        this._checkArgs('getProgramParameter', arguments);
         const value = program.native;
         const result = this.native.getProgramParameter(value, pname);
         return result;
     }
     getRenderbufferParameter(target, pname) {
-        this._glCheckError('getRenderbufferParameter');
-        this._checkArgs('getRenderbufferParameter', arguments);
         return this.native.getRenderbufferParameter(target, pname);
     }
     getShaderInfoLog(shader) {
-        this._glCheckError('getShaderInfoLog');
-        this._checkArgs('getShaderInfoLog', arguments);
         const value = shader.native;
         return this.native.getShaderInfoLog(value);
     }
     getShaderParameter(shader, pname) {
-        this._glCheckError('getShaderParameter');
-        this._checkArgs('getShaderParameter', arguments);
         const value = shader.native;
         const result = this.native.getShaderParameter(value, pname);
         return result;
     }
     getShaderPrecisionFormat(shaderType, precisionType) {
-        this._glCheckError('getShaderPrecisionFormat');
-        this._checkArgs('getShaderPrecisionFormat', arguments);
         const precision = this.native.getShaderPrecisionFormat(shaderType, precisionType);
         return new WebGLShaderPrecisionFormat(precision);
     }
     getShaderSource(shader) {
-        this._glCheckError('getShaderSource');
-        this._checkArgs('getShaderSource', arguments);
         const value = shader ? shader.native : 0;
         return this.native.getShaderSource(value);
     }
     getSupportedExtensions() {
-        this._glCheckError('getSupportedExtensions');
         return this.native.getSupportedExtensions();
     }
     getTexParameter(target, pname) {
-        this._glCheckError('getTexParameter');
-        this._checkArgs('getTexParameter', arguments);
         return this.native.getTexParameter(target, pname);
     }
     getUniformLocation(program, name) {
-        this._glCheckError('getUniformLocation');
-        this._checkArgs('getUniformLocation', arguments);
         const value = program.native;
         const id = this.native.getUniformLocation(value, name);
         if (id === -1) {
@@ -594,8 +455,6 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return new WebGLUniformLocation(id);
     }
     getUniform(program, location) {
-        this._glCheckError('getUniform');
-        this._checkArgs('getUniform', arguments);
         const value = program.native;
         const value2 = location.native;
         const uniform = this.native.getUniform(value, value2);
@@ -605,13 +464,9 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return uniform;
     }
     getVertexAttribOffset(index, pname) {
-        this._glCheckError('getVertexAttribOffset');
-        this._checkArgs('getVertexAttribOffset', arguments);
         return this.native.getVertexAttribOffset(index, pname);
     }
     getVertexAttrib(index, pname) {
-        this._glCheckError('getVertexAttrib');
-        this._checkArgs('getVertexAttrib', arguments);
         const value = this.native.getVertexAttrib(index, pname);
         if (pname === this.CURRENT_VERTEX_ATTRIB) {
             return value;
@@ -619,69 +474,46 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         return value;
     }
     hint(target, mode) {
-        this._glCheckError('hint');
-        this._checkArgs('hint', arguments);
         this.native.hint(target, mode);
     }
     isBuffer(buffer) {
-        this._glCheckError('isBuffer');
-        this._checkArgs('isBuffer', arguments);
         const value = buffer.native;
         return this.native.isBuffer(value);
     }
     isContextLost() {
-        this._glCheckError('isContextLost');
         return this.native.isContextLost();
     }
     isEnabled(cap) {
-        this._glCheckError('isEnabled');
-        this._checkArgs('isEnabled', arguments);
         return this.native.isEnabled(cap);
     }
     isFramebuffer(framebuffer) {
-        this._glCheckError('isFramebuffer');
-        this._checkArgs('isFramebuffer', arguments);
         const value = framebuffer ? framebuffer.native : 0;
         return this.native.isFramebuffer(value);
     }
     isProgram(program) {
-        this._glCheckError('isProgram');
-        this._checkArgs('isProgram', arguments);
         const value = program.native;
         return this.native.isProgram(value);
     }
     isRenderbuffer(renderbuffer) {
-        this._glCheckError('isRenderbuffer');
-        this._checkArgs('isRenderbuffer', arguments);
         const value = renderbuffer.native;
         return this.native.isRenderbuffer(value);
     }
     isShader(shader) {
-        this._glCheckError('isShader');
-        this._checkArgs('isShader', arguments);
         const value = shader.native;
         return this.native.isShader(value);
     }
     isTexture(texture) {
-        this._glCheckError('isTexture');
-        this._checkArgs('isTexture', arguments);
         const value = texture.native;
         return this.native.isTexture(value);
     }
     lineWidth(width) {
-        this._glCheckError('lineWidth');
-        this._checkArgs('lineWidth', arguments);
         this.native.lineWidth(width);
     }
     linkProgram(program) {
-        this._glCheckError('linkProgram');
-        this._checkArgs('linkProgram', arguments);
         const value = program ? program.native : 0;
         this.native.linkProgram(value);
     }
     pixelStorei(pname, param) {
-        this._glCheckError('pixelStorei');
-        this._checkArgs('pixelStorei', arguments);
         if (pname === this.UNPACK_FLIP_Y_WEBGL || pname === this.UNPACK_PREMULTIPLY_ALPHA_WEBGL) {
             if (pname === this.UNPACK_FLIP_Y_WEBGL) {
                 this._flipY = param;
@@ -702,18 +534,12 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         }
     }
     polygonOffset(factor, units) {
-        this._glCheckError('polygonOffset');
-        this._checkArgs('polygonOffset', arguments);
         this.native.polygonOffset(factor, units);
     }
     readPixels(x, y, width, height, format, type, pixels) {
-        this._glCheckError('readPixels');
-        this._checkArgs('readPixels', arguments);
         this.native.readPixels(x, y, width, height, format, type, pixels);
     }
     renderbufferStorage(target, internalFormat, width, height) {
-        this._glCheckError('renderbufferStorage');
-        this._checkArgs('renderbufferStorage', arguments);
         if (internalFormat === this.DEPTH_STENCIL) {
             // DEPTH24_STENCIL8 = 35056
             // DEPTH24_STENCIL8_OES = 0x88F0
@@ -722,54 +548,34 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         this.native.renderbufferStorage(target, internalFormat, width, height);
     }
     sampleCoverage(value, invert) {
-        this._glCheckError('sampleCoverage');
-        this._checkArgs('sampleCoverage', arguments);
         this.native.sampleCoverage(value, invert);
     }
     scissor(x, y, width, height) {
-        this._glCheckError('scissor');
-        this._checkArgs('scissor', arguments);
         this.native.scissor(x, y, width, height);
     }
     shaderSource(shader, source) {
-        this._glCheckError('shaderSource');
-        this._checkArgs('shaderSource', arguments);
         const value = shader ? shader.native : 0;
         this.native.shaderSource(value, source);
     }
     stencilFuncSeparate(face, func, ref, mask) {
-        this._glCheckError('stencilFuncSeparate');
-        this._checkArgs('stencilFuncSeparate', arguments);
         this.native.stencilFuncSeparate(face, func, ref, mask);
     }
     stencilFunc(func, ref, mask) {
-        this._glCheckError('stencilFunc');
-        this._checkArgs('stencilFunc', arguments);
         this.native.stencilFunc(func, ref, mask);
     }
     stencilMaskSeparate(face, mask) {
-        this._glCheckError('stencilMaskSeparate');
-        this._checkArgs('stencilMaskSeparate', arguments);
         this.native.stencilMaskSeparate(face, mask);
     }
     stencilMask(mask) {
-        this._glCheckError('stencilMask');
-        this._checkArgs('stencilMask', arguments);
         this.native.stencilMask(mask);
     }
     stencilOpSeparate(face, fail, zfail, zpass) {
-        this._glCheckError('stencilOpSeparate');
-        this._checkArgs('stencilOpSeparate', arguments);
         this.native.stencilOpSeparate(face, fail, zfail, zpass);
     }
     stencilOp(fail, zfail, zpass) {
-        this._glCheckError('stencilOp');
-        this._checkArgs('stencilOp', arguments);
         this.native.stencilOp(fail, zfail, zpass);
     }
     texImage2D(target, level, internalformat, width, height, border, format, type, pixels) {
-        this._glCheckError('texImage2D');
-        this._checkArgs('texImage2D', arguments);
         if (arguments.length === 9) {
             this.native.texImage2D(target, level, internalformat, width, height, border, format, type ?? internalformat, pixels);
         }
@@ -814,18 +620,12 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         }
     }
     texParameterf(target, pname, param) {
-        this._glCheckError('texParameterf');
-        this._checkArgs('texParameterf', arguments);
         this.native.texParameterf(target, pname, param);
     }
     texParameteri(target, pname, param) {
-        this._glCheckError('texParameteri');
-        this._checkArgs('texParameteri', arguments);
         this.native.texParameteri(target, pname, param);
     }
     texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
-        this._glCheckError('texSubImage2D');
-        this._checkArgs('texSubImage2D', arguments);
         if (arguments.length === 9) {
             this.native.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
         }
@@ -865,179 +665,117 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         }
     }
     uniform1f(location, v0) {
-        this._glCheckError('uniform1f');
-        this._checkArgs('uniform1f', arguments);
         const loc = location.native;
         this.native.uniform1f(loc, v0);
     }
     uniform1iv(location, value) {
-        this._glCheckError('uniform1iv');
-        this._checkArgs('uniform1iv', arguments);
         const loc = location.native;
         this.native.uniform1iv(loc, value);
     }
     uniform1fv(location, value) {
-        this._glCheckError('uniform1fv');
-        this._checkArgs('uniform1fv', arguments);
         const loc = location.native;
         this.native.uniform1fv(loc, value);
     }
     uniform1i(location, v0) {
-        this._glCheckError('uniform1i');
-        this._checkArgs('uniform1i', arguments);
         const loc = location.native;
         this.native.uniform1i(loc, Number(v0));
     }
     uniform2f(location, v0, v1) {
-        this._glCheckError('uniform2f');
-        this._checkArgs('uniform2f', arguments);
         const loc = location.native;
         this.native.uniform2f(loc, v0, v1);
     }
     uniform2iv(location, value) {
-        this._glCheckError('uniform2iv');
-        this._checkArgs('uniform2iv', arguments);
         const loc = location.native;
         this.native.uniform2iv(loc, value);
     }
     uniform2fv(location, value) {
-        this._glCheckError('uniform2fv');
-        this._checkArgs('uniform2fv', arguments);
         const loc = location.native;
         this.native.uniform2fv(loc, value);
     }
     uniform2i(location, v0, v1) {
-        this._glCheckError('uniform2i');
-        this._checkArgs('uniform2i', arguments);
         const loc = location.native;
         this.native.uniform2i(loc, v0, v1);
     }
     uniform3f(location, v0, v1, v2) {
-        this._glCheckError('uniform3f');
-        this._checkArgs('uniform3f', arguments);
         const loc = location.native;
         this.native.uniform3f(loc, v0, v1, v2);
     }
     uniform3iv(location, value) {
-        this._glCheckError('uniform3iv');
-        this._checkArgs('uniform3iv', arguments);
         const loc = location.native;
         this.native.uniform3iv(loc, value);
     }
     uniform3fv(location, value) {
-        this._glCheckError('uniform3fv');
-        this._checkArgs('uniform3fv', arguments);
         const loc = location.native;
         this.native.uniform3fv(loc, value);
     }
     uniform3i(location, v0, v1, v2) {
-        this._glCheckError('uniform3i');
-        this._checkArgs('uniform3i', arguments);
         const loc = location.native;
         this.native.uniform3i(loc, v0, v1, v2);
     }
     uniform4f(location, v0, v1, v2, v3) {
-        this._glCheckError('uniform4f');
-        this._checkArgs('uniform4f', arguments);
         const loc = location.native;
         this.native.uniform4f(loc, v0, v1, v2, v3);
     }
     uniform4iv(location, value) {
-        this._glCheckError('uniform4iv');
-        this._checkArgs('uniform4iv', arguments);
         const loc = location.native;
         this.native.uniform4iv(loc, value);
     }
     uniform4fv(location, value) {
-        this._glCheckError('uniform4fv');
-        this._checkArgs('uniform4fv', arguments);
         const loc = location.native;
         this.native.uniform4fv(loc, value);
     }
     uniform4i(location, v0, v1, v2, v3) {
-        this._glCheckError('uniform4i');
-        this._checkArgs('uniform4i', arguments);
         const loc = location.native;
         this.native.uniform4i(loc, v0, v1, v2, v3);
     }
     uniformMatrix2fv(location, transpose, value) {
-        this._glCheckError('uniformMatrix2fv');
-        this._checkArgs('uniformMatrix2fv', arguments);
         const loc = location.native;
         this.native.uniformMatrix2fv(loc, transpose, value);
     }
     uniformMatrix3fv(location, transpose, value) {
-        this._glCheckError('uniformMatrix3fv');
-        this._checkArgs('uniformMatrix3fv', arguments);
         const loc = location.native;
         this.native.uniformMatrix3fv(loc, transpose, value);
     }
     uniformMatrix4fv(location, transpose, value) {
-        this._glCheckError('uniformMatrix4fv');
-        this._checkArgs('uniformMatrix4fv', arguments);
         const loc = location.native;
         this.native.uniformMatrix4fv(loc, transpose, value);
     }
     useProgram(program) {
-        this._glCheckError('useProgram');
-        this._checkArgs('useProgram', arguments);
         const value = program ? program.native : null;
         this.native.useProgram(value);
     }
     validateProgram(program) {
-        this._glCheckError('validateProgram');
-        this._checkArgs('validateProgram', arguments);
         const value = program.native;
         this.native.validateProgram(value);
     }
     vertexAttrib1f(index, v0) {
-        this._glCheckError('vertexAttrib1f');
-        this._checkArgs('vertexAttrib1f', arguments);
         this.native.vertexAttrib1f(index, v0);
     }
     vertexAttrib1fv(index, value) {
-        this._glCheckError('vertexAttrib1fv');
-        this._checkArgs('vertexAttrib1fv', arguments);
         this.native.vertexAttrib1fv(index, value);
     }
     vertexAttrib2f(index, v0, v1) {
-        this._glCheckError('vertexAttrib2f');
-        this._checkArgs('vertexAttrib2f', arguments);
         this.native.vertexAttrib2f(index, v0, v1);
     }
     vertexAttrib2fv(index, value) {
-        this._glCheckError('vertexAttrib2fv');
-        this._checkArgs('vertexAttrib2fv', arguments);
         this.native.vertexAttrib2fv(index, value);
     }
     vertexAttrib3f(index, v0, v1, v2) {
-        this._glCheckError('vertexAttrib3f');
-        this._checkArgs('vertexAttrib3f', arguments);
         this.native.vertexAttrib3f(index, v0, v1, v2);
     }
     vertexAttrib3fv(index, value) {
-        this._glCheckError('vertexAttrib3fv');
-        this._checkArgs('vertexAttrib3fv', arguments);
         this.native.vertexAttrib3fv(index, value);
     }
     vertexAttrib4f(index, v0, v1, v2, v3) {
-        this._glCheckError('vertexAttrib4f');
-        this._checkArgs('vertexAttrib4f', arguments);
         this.native.vertexAttrib4f(index, v0, v1, v2, v3);
     }
     vertexAttrib4fv(index, value) {
-        this._glCheckError('vertexAttrib4fv');
-        this._checkArgs('vertexAttrib4fv', arguments);
         this.native.vertexAttrib4fv(index, value);
     }
     vertexAttribPointer(index, size, type, normalized, stride, offset) {
-        this._glCheckError('vertexAttribPointer');
-        this._checkArgs('vertexAttribPointer', arguments);
         this.native.vertexAttribPointer(index, size, type, !!normalized, stride, offset);
     }
     viewport(x, y, width, height) {
-        this._glCheckError('viewport');
-        this._checkArgs('viewport', arguments);
         this.native.viewport(x, y, width, height);
     }
     _glCheckError(message) {
@@ -1709,13 +1447,13 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform1iv", null);
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform1fv", null);
 __decorate([
@@ -1733,13 +1471,13 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform2iv", null);
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform2fv", null);
 __decorate([
@@ -1757,13 +1495,13 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform3iv", null);
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform3fv", null);
 __decorate([
@@ -1781,13 +1519,13 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform4iv", null);
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniform4fv", null);
 __decorate([
@@ -1799,19 +1537,19 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Boolean, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Boolean, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniformMatrix2fv", null);
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Boolean, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Boolean, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniformMatrix3fv", null);
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [WebGLUniformLocation, Boolean, Array]),
+    __metadata("design:paramtypes", [WebGLUniformLocation, Boolean, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "uniformMatrix4fv", null);
 __decorate([
@@ -1835,7 +1573,7 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Array]),
+    __metadata("design:paramtypes", [Number, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "vertexAttrib1fv", null);
 __decorate([
@@ -1847,7 +1585,7 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Array]),
+    __metadata("design:paramtypes", [Number, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "vertexAttrib2fv", null);
 __decorate([
@@ -1859,7 +1597,7 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Array]),
+    __metadata("design:paramtypes", [Number, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "vertexAttrib3fv", null);
 __decorate([
@@ -1871,7 +1609,7 @@ __decorate([
 __decorate([
     profile,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Array]),
+    __metadata("design:paramtypes", [Number, Object]),
     __metadata("design:returntype", void 0)
 ], WebGLRenderingContext.prototype, "vertexAttrib4fv", null);
 __decorate([