@nativescript/canvas 2.0.0-alpha.5 → 2.0.0-alpha.50

package/WebGL2/WebGL2RenderingContext/index.js

@@ -1,5 +1,6 @@
 import { WebGLQuery } from '../WebGLQuery';
 import { WebGLSampler } from '../WebGLSampler';
+import { WebGLSync } from '../WebGLSync';
 import { WebGLTransformFeedback } from '../WebGLTransformFeedback';
 import { WebGLVertexArrayObject } from '../WebGLVertexArrayObject';
 import { WebGLFramebuffer } from '../../WebGL/WebGLFramebuffer';
@@ -11,7 +12,6 @@ import { WebGL2RenderingContextBase } from './common';
 import { Canvas } from '../../Canvas';
 import { ImageBitmap } from '../../ImageBitmap';
 import { Helpers } from '../../helpers';
-let ctor;
 export class WebGL2RenderingContext extends WebGL2RenderingContextBase {
     constructor(context, contextOptions) {
         super(null);
@@ -25,253 +25,169 @@ export class WebGL2RenderingContext extends WebGL2RenderingContextBase {
         const ctx = BigInt(nativeContext);
         let direction = 0;
         if (global.isAndroid) {
-            if (androidx.core.text.TextUtilsCompat.getLayoutDirectionFromLocale(java.util.Locale.getDefault()) === androidx.core.view.ViewCompat.LAYOUT_DIRECTION_RTL) {
-                direction = 1;
-            }
+            direction = org.nativescript.canvas.NSCCanvas.getDirection();
         }
         else {
             //direction = 1;
         }
-        const native = ctor(contextOptions, ctx, Screen.mainScreen.scale, -16777216, Screen.mainScreen.scale * 160, direction);
+        const native = global.CanvasModule.createWebGL2Context(contextOptions, ctx, Screen.mainScreen.scale, -16777216, Screen.mainScreen.scale * 160, direction);
         this._context = native;
     }
     /* Transform feedback */
     beginQuery(target, query) {
-        this._glCheckError('beginQuery');
         const value = query.native;
-        const beginQuery = this._getMethod('beginQuery');
-        beginQuery(target, value);
+        this.native.beginQuery(target, value);
     }
     beginTransformFeedback(primitiveMode) {
-        this._glCheckError('beginTransformFeedback');
-        const beginTransformFeedback = this._getMethod('beginTransformFeedback');
-        beginTransformFeedback(primitiveMode);
+        this.native.beginTransformFeedback(primitiveMode);
     }
     bindBufferBase(target, index, buffer) {
-        this._glCheckError('bindBufferBase');
         const value = buffer ? buffer.native : null;
-        const bindBufferBase = this._getMethod('bindBufferBase');
-        bindBufferBase(target, index, value);
+        this.native.bindBufferBase(target, index, value);
     }
     bindBufferRange(target, index, buffer, offset, size) {
-        this._glCheckError('bindBufferRange');
         const value = buffer ? buffer.native : null;
-        const bindBufferRange = this._getMethod('bindBufferRange');
-        bindBufferRange(target, index, value, offset, size);
+        this.native.bindBufferRange(target, index, value, offset, size);
     }
     bindSampler(unit, sampler) {
-        this._glCheckError('bindSampler');
         const value = sampler ? sampler.native : null;
-        const bindSampler = this._getMethod('bindSampler');
-        bindSampler(unit, value);
+        this.native.bindSampler(unit, value);
     }
     bindTransformFeedback(target, transformFeedback) {
-        this._glCheckError('bindTransformFeedback');
         const value = transformFeedback ? transformFeedback.native : null;
-        const bindTransformFeedback = this._getMethod('bindTransformFeedback');
-        bindTransformFeedback(target, value);
+        this.native.bindTransformFeedback(target, value);
     }
     bindVertexArray(vertexArray) {
-        this._glCheckError('bindVertexArray');
         const value = vertexArray ? vertexArray.native : null;
-        const bindVertexArray = this._getMethod('bindVertexArray');
-        bindVertexArray(value);
+        this.native.bindVertexArray(value);
     }
     blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) {
-        this._glCheckError('blitFramebuffer');
-        const blitFramebuffer = this._getMethod('blitFramebuffer');
-        blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+        this.native.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     }
     clearBufferfi(buffer, drawbuffer, depth, stencil) {
-        this._glCheckError('clearBufferfi');
         const value = buffer.native;
-        const clearBufferfi = this._getMethod('clearBufferfi');
-        clearBufferfi(value, drawbuffer, depth, stencil);
+        this.native.clearBufferfi(value, drawbuffer, depth, stencil);
     }
     clearBufferfv(buffer, drawbuffer, values) {
-        this._glCheckError('clearBufferfv');
-        const clearBufferfv = this._getMethod('clearBufferfv');
         const value = buffer.native;
-        clearBufferfv(value, drawbuffer, values);
+        this.native.clearBufferfv(value, drawbuffer, values);
     }
     clearBufferiv(buffer, drawbuffer, values) {
-        this._glCheckError('clearBufferiv');
-        const clearBufferiv = this._getMethod('clearBufferiv');
         const value = buffer ? buffer.native : 0;
-        clearBufferiv(value, drawbuffer, values);
+        this.native.clearBufferiv(value, drawbuffer, values);
     }
     clearBufferuiv(buffer, drawbuffer, values) {
-        this._glCheckError('clearBufferuiv');
-        const clearBufferuiv = this._getMethod('clearBufferuiv');
         const value = buffer ? buffer.native : 0;
-        clearBufferuiv(value, drawbuffer, values);
+        this.native.clearBufferuiv(value, drawbuffer, values);
     }
     clientWaitSync(sync, flags, timeout) {
-        this._glCheckError('clientWaitSync');
-        const clientWaitSync = this._getMethod('clientWaitSync');
         const value = sync.native;
-        return clientWaitSync(value, flags, timeout);
+        return this.native.clientWaitSync(value, flags, timeout);
     }
     compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset = 0, srcLengthOverride = 0) {
-        this._glCheckError('compressedTexSubImage3D');
-        const compressedTexSubImage3D = this._getMethod('compressedTexSubImage3D');
-        compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset);
+        this.native.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset);
     }
     /* Transform feedback */
     /* Framebuffers and renderbuffers */
     copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) {
-        this._glCheckError('copyBufferSubData');
-        const copyBufferSubData = this._getMethod('copyBufferSubData');
-        copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+        this.native.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
     }
     copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) {
-        this._glCheckError('copyTexSubImage3D');
-        const copyTexSubImage3D = this._getMethod('copyTexSubImage3D');
-        copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+        this.native.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
     }
     createQuery() {
-        this._glCheckError('createQuery');
-        const createQuery = this._getMethod('createQuery');
-        return new WebGLQuery(createQuery());
+        return new WebGLQuery(this.native.createQuery());
     }
     createSampler() {
-        this._glCheckError('createSampler');
-        const createSampler = this._getMethod('createSampler');
-        return new WebGLSampler(createSampler());
+        return new WebGLSampler(this.native.createSampler());
     }
     createTransformFeedback() {
-        this._glCheckError('createTransformFeedback');
-        const createTransformFeedback = this._getMethod('createTransformFeedback');
-        return new WebGLTransformFeedback(createTransformFeedback());
+        return new WebGLTransformFeedback(this.native.createTransformFeedback());
     }
     createVertexArray() {
-        this._glCheckError('createVertexArray');
-        const createVertexArray = this._getMethod('createVertexArray');
-        return new WebGLVertexArrayObject(createVertexArray());
+        return new WebGLVertexArrayObject(this.native.createVertexArray());
     }
     deleteQuery(query) {
-        this._glCheckError('deleteQuery');
-        const deleteQuery = this._getMethod('deleteQuery');
         const value = query.native;
-        deleteQuery(value);
+        this.native.deleteQuery(value);
     }
     deleteSampler(sampler) {
-        this._glCheckError('deleteSampler');
-        const deleteSampler = this._getMethod('deleteSampler');
         const value = sampler.native;
-        deleteSampler(value);
+        this.native.deleteSampler(value);
     }
     deleteSync(sync) {
-        this._glCheckError('deleteSync');
-        const deleteSync = this._getMethod('deleteSync');
         const value = sync.native;
-        deleteSync(value);
+        this.native.deleteSync(value);
     }
     deleteTransformFeedback(transformFeedback) {
-        this._glCheckError('deleteTransformFeedback');
-        const deleteTransformFeedback = this._getMethod('deleteTransformFeedback');
         const value = transformFeedback.native;
-        deleteTransformFeedback(value);
+        this.native.deleteTransformFeedback(value);
     }
     deleteVertexArray(vertexArray) {
-        this._glCheckError('deleteVertexArray');
-        const deleteVertexArray = this._getMethod('deleteVertexArray');
         const value = vertexArray.native;
-        deleteVertexArray(value);
+        this.native.deleteVertexArray(value);
     }
     drawArraysInstanced(mode, first, count, instanceCount) {
-        this._glCheckError('drawArraysInstanced');
-        const drawArraysInstanced = this._getMethod('drawArraysInstanced');
-        drawArraysInstanced(mode, first, count, instanceCount);
+        this.native.drawArraysInstanced(mode, first, count, instanceCount);
     }
     drawBuffers(buffers) {
-        this._glCheckError('drawBuffers');
         this._checkArgs('drawBuffers', arguments);
-        const drawBuffers = this._getMethod('drawBuffers');
-        drawBuffers(buffers);
+        this.native.drawBuffers(buffers);
     }
     drawElementsInstanced(mode, count, type, offset, instanceCount) {
-        this._glCheckError('drawElementsInstanced');
-        const drawElementsInstanced = this._getMethod('drawElementsInstanced');
-        drawElementsInstanced(mode, count, type, offset, instanceCount);
+        this.native.drawElementsInstanced(mode, count, type, offset, instanceCount);
     }
     drawRangeElements(mode, start, end, count, type, offset) {
-        this._glCheckError('drawRangeElements');
-        const drawRangeElements = this._getMethod('drawRangeElements');
-        drawRangeElements(mode, start, end, count, type, offset);
+        this.native.drawRangeElements(mode, start, end, count, type, offset);
     }
     endQuery(target) {
-        this._glCheckError('endQuery');
-        const endQuery = this._getMethod('endQuery');
-        endQuery(target);
+        this.native.endQuery(target);
     }
     endTransformFeedback() {
-        this._glCheckError('endTransformFeedback');
-        const endTransformFeedback = this._getMethod('endTransformFeedback');
-        endTransformFeedback();
+        this.native.endTransformFeedback();
     }
     fenceSync(condition, flags) {
-        this._glCheckError('fenceSync');
-        const fenceSync = this._getMethod('fenceSync');
-        fenceSync(condition, flags);
+        return new WebGLSync(this.native.fenceSync(condition, flags));
     }
     framebufferTextureLayer(target, attachment, texture, level, layer) {
-        this._glCheckError('framebufferTextureLayer');
-        const framebufferTextureLayer = this._getMethod('framebufferTextureLayer');
         const value = texture.native;
-        framebufferTextureLayer(target, attachment, value, level, layer);
+        this.native.framebufferTextureLayer(target, attachment, value, level, layer);
     }
     /* Framebuffers and renderbuffers */
     /* Uniforms */
     getActiveUniformBlockName(program, uniformBlockIndex) {
-        this._glCheckError('getActiveUniformBlockName');
-        const getActiveUniformBlockName = this._getMethod('getActiveUniformBlockName');
         const value = program.native;
-        return getActiveUniformBlockName(value, uniformBlockIndex);
+        return this.native.getActiveUniformBlockName(value, uniformBlockIndex);
     }
     getActiveUniformBlockParameter(program, uniformBlockIndex, pname) {
-        this._glCheckError('getActiveUniformBlockParameter');
-        const getActiveUniformBlockParameter = this._getMethod('getActiveUniformBlockParameter');
         const value = program.native;
-        return getActiveUniformBlockParameter(value, uniformBlockIndex, pname);
+        return this.native.getActiveUniformBlockParameter(value, uniformBlockIndex, pname);
     }
     getActiveUniforms(program, uniformIndices, pname) {
-        this._glCheckError('getActiveUniforms');
-        const getActiveUniforms = this._getMethod('getActiveUniforms');
         const value = program.native;
-        return getActiveUniforms(value, uniformIndices, pname);
+        return this.native.getActiveUniforms(value, uniformIndices, pname);
     }
     getBufferSubData(target, srcByteOffset, dstData, dstOffset = 0, length = 0) {
-        this._glCheckError('getBufferSubData');
-        const getBufferSubData = this._getMethod('getBufferSubData');
-        getBufferSubData(target, srcByteOffset, dstData, dstOffset, length);
+        this.native.getBufferSubData(target, srcByteOffset, dstData, dstOffset, length);
     }
     getFragDataLocation(program, name) {
-        this._glCheckError('getFragDataLocation');
-        const getFragDataLocation = this._getMethod('getFragDataLocation');
         const value = program.native;
-        const result = getFragDataLocation(value, name);
+        const result = this.native.getFragDataLocation(value, name);
         return result !== -1 ? result : null;
     }
     getIndexedParameter(target, index) {
-        this._glCheckError('getIndexedParameter');
-        const getIndexedParameter = this._getMethod('getIndexedParameter');
-        const param = getIndexedParameter(target, index);
+        const param = this.native.getIndexedParameter(target, index);
         if (target === this.TRANSFORM_FEEDBACK_BUFFER_BINDING || target === this.UNIFORM_BUFFER_BINDING) {
             return new WebGLBuffer(param);
         }
         return param;
     }
     getInternalformatParameter(target, internalformat, pname) {
-        this._glCheckError('getInternalformatParameter');
-        const getInternalformatParameter = this._getMethod('getInternalformatParameter');
-        return getInternalformatParameter(target, internalformat, pname);
+        return this.native.getInternalformatParameter(target, internalformat, pname);
     }
     getQueryParameter(query, pname) {
-        this._glCheckError('getQueryParameter');
-        const getQueryParameter = this._getMethod('getQueryParameter');
         const value = query.native;
-        const result = getQueryParameter(value, pname);
+        const result = this.native.getQueryParameter(value, pname);
         if (result === 0) {
             return null;
         }
@@ -279,10 +195,8 @@ export class WebGL2RenderingContext extends WebGL2RenderingContextBase {
     }
     //@ts-ignore
     getParameter(pname) {
-        this._glCheckError('getParameter');
         this._checkArgs('getParameter', arguments);
-        const getParameter = this._getMethod('getParameter');
-        const value = getParameter(pname);
+        const value = this.native.getParameter(pname);
         switch (pname) {
             case this.COPY_READ_BUFFER_BINDING:
             case this.COPY_WRITE_BUFFER_BINDING:
@@ -300,338 +214,255 @@ export class WebGL2RenderingContext extends WebGL2RenderingContextBase {
         }
     }
     getQuery(target, pname) {
-        this._glCheckError('getQuery');
-        const getQuery = this._getMethod('getQuery');
-        const query = getQuery(target, pname);
+        const query = this.native.getQuery(target, pname);
         if (query) {
             return new WebGLQuery(query);
         }
         return null;
     }
     getSamplerParameter(sampler, pname) {
-        this._glCheckError('getSamplerParameter');
-        const getSamplerParameter = this._getMethod('getSamplerParameter');
         const value = sampler.native;
-        return getSamplerParameter(value, pname);
+        return this.native.getSamplerParameter(value, pname);
     }
     getSyncParameter(sync, pname) {
-        this._glCheckError('getSyncParameter');
-        const getSyncParameter = this._getMethod('getSyncParameter');
         const value = sync.native;
-        return getSyncParameter(value, pname);
+        return this.native.getSyncParameter(value, pname);
     }
     getTransformFeedbackVarying(program, index) {
-        this._glCheckError('getTransformFeedbackVarying');
         const value = program.native;
-        const getTransformFeedbackVarying = this._getMethod('getTransformFeedbackVarying');
-        const info = getTransformFeedbackVarying(value, index);
+        const info = this.native.getTransformFeedbackVarying(value, index);
         if (info) {
             return new WebGLActiveInfo(info);
         }
         return null;
     }
     getUniformBlockIndex(program, uniformBlockName) {
-        this._glCheckError('getUniformBlockIndex');
-        const getUniformBlockIndex = this._getMethod('getUniformBlockIndex');
         const value = program.native;
-        return getUniformBlockIndex(value, uniformBlockName);
+        return this.native.getUniformBlockIndex(value, uniformBlockName);
     }
     getUniformIndices(program, uniformNames) {
-        this._glCheckError('getUniformIndices');
-        const getUniformIndices = this._getMethod('getUniformIndices');
         const value = program.native;
-        return getUniformIndices(value, uniformNames);
+        return this.native.getUniformIndices(value, uniformNames);
     }
     invalidateFramebuffer(target, attachments) {
-        this._glCheckError('invalidateFramebuffer');
-        const invalidateFramebuffer = this._getMethod('invalidateFramebuffer');
-        invalidateFramebuffer(target, attachments);
+        this.native.invalidateFramebuffer(target, attachments);
     }
     invalidateSubFramebuffer(target, attachments, x, y, width, height) {
-        this._glCheckError('invalidateSubFramebuffer');
-        const invalidateSubFramebuffer = this._getMethod('invalidateSubFramebuffer');
-        invalidateSubFramebuffer(target, attachments, x, y, width, height);
+        this.native.invalidateSubFramebuffer(target, attachments, x, y, width, height);
     }
     isQuery(query) {
-        this._glCheckError('isQuery');
-        const isQuery = this._getMethod('isQuery');
         const value = query.native;
-        return isQuery(value);
+        return this.native.isQuery(value);
     }
     isSampler(sampler) {
-        this._glCheckError('isSampler');
-        const isSampler = this._getMethod('isSampler');
         const value = sampler.native;
-        return isSampler(value);
+        return this.native.isSampler(value);
     }
     isSync(sync) {
-        this._glCheckError('isSync');
-        const isSync = this._getMethod('isSync');
         const value = sync.native;
-        return isSync(value);
+        return this.native.isSync(value);
     }
     isTransformFeedback(transformFeedback) {
-        this._glCheckError('isTransformFeedback');
-        const isTransformFeedback = this._getMethod('isTransformFeedback');
         const value = transformFeedback.native;
-        return isTransformFeedback(value);
+        return this.native.isTransformFeedback(value);
     }
     isVertexArray(vertexArray) {
-        this._glCheckError('isVertexArray');
-        const isVertexArray = this._getMethod('isVertexArray');
         const value = vertexArray.native;
-        return isVertexArray(value);
+        return this.native.isVertexArray(value);
     }
     pauseTransformFeedback() {
-        this._glCheckError('pauseTransformFeedback');
-        const pauseTransformFeedback = this._getMethod('pauseTransformFeedback');
-        pauseTransformFeedback();
+        this.native.pauseTransformFeedback();
     }
     readBuffer(src) {
-        this._glCheckError('readBuffer');
-        const readBuffer = this._getMethod('readBuffer');
-        readBuffer(src);
+        this.native.readBuffer(src);
     }
     renderbufferStorageMultisample(target, samples, internalFormat, width, height) {
-        this._glCheckError('renderbufferStorageMultisample');
-        const renderbufferStorageMultisample = this._getMethod('renderbufferStorageMultisample');
-        renderbufferStorageMultisample(target, samples, internalFormat, width, height);
+        this.native.renderbufferStorageMultisample(target, samples, internalFormat, width, height);
     }
     resumeTransformFeedback() {
-        this._glCheckError('resumeTransformFeedback');
-        const resumeTransformFeedback = this._getMethod('resumeTransformFeedback');
-        resumeTransformFeedback();
+        this.native.resumeTransformFeedback();
     }
     samplerParameterf(sampler, pname, param) {
-        this._glCheckError('samplerParameterf');
-        const samplerParameterf = this._getMethod('samplerParameterf');
         const value = sampler.native;
-        samplerParameterf(value, pname, param);
+        this.native.samplerParameterf(value, pname, param);
     }
     /* Uniforms */
     /* Sync objects */
     samplerParameteri(sampler, pname, param) {
-        this._glCheckError('samplerParameteri');
-        const samplerParameteri = this._getMethod('samplerParameteri');
         const value = sampler.native;
-        samplerParameteri(value, pname, param);
+        this.native.samplerParameteri(value, pname, param);
     }
     texImage3D(target, level, internalformat, width, height, depth, border, format, type, source) {
-        this._glCheckError('texImage3D');
-        const texImage3D = this._getMethod('texImage3D');
         if (typeof source === 'number') {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source && source.buffer) {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source instanceof android.graphics.Bitmap) {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source instanceof ImageSource) {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.android);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.android);
         }
         else if (source instanceof ImageAsset) {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
+        }
+        else if (source instanceof Canvas) {
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
         }
         else if (source instanceof ImageBitmap) {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
         }
         else if (source && typeof source.tagName === 'string' && (source.tagName === 'IMG' || source.tagName === 'IMAGE')) {
             if (source._imageSource instanceof ImageSource) {
-                texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._imageSource.android);
+                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._imageSource.android);
             }
             else if (source._image instanceof android.graphics.Bitmap) {
-                texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._image);
+                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._image);
             }
             else if (source._asset instanceof ImageAsset) {
-                texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._asset.native);
+                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._asset.native);
             }
             else if (typeof source.src === 'string') {
                 const result = ImageSource.fromFileSync(source.src);
-                texImage3D(target, level, internalformat, width, height, depth, border, format, type, result ? result.android : null);
+                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, result ? result.android : null);
             }
         }
         else if (source && typeof source.tagName === 'string' && source.tagName === 'CANVAS' && source._canvas instanceof Canvas) {
-            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._canvas.native);
+            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._canvas.native);
         }
     }
     texStorage2D(target, levels, internalformat, width, height) {
-        this._glCheckError('texStorage2D');
-        const texStorage2D = this._getMethod('texStorage2D');
-        texStorage2D(target, levels, internalformat, width, height);
+        this.native.texStorage2D(target, levels, internalformat, width, height);
     }
     texStorage3D(target, levels, internalformat, width, height, depth) {
-        this._glCheckError('texStorage3D');
-        const texStorage3D = this._getMethod('texStorage3D');
-        texStorage3D(target, levels, internalformat, width, height, depth);
+        this.native.texStorage3D(target, levels, internalformat, width, height, depth);
     }
     texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset = 0) {
-        this._glCheckError('texSubImage3D');
-        const texSubImage3D = this._getMethod('texSubImage3D');
         if (typeof srcData === 'number') {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
         }
         else if (srcData && srcData.buffer) {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset);
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset);
         }
         else if (srcData instanceof android.graphics.Bitmap) {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
         }
         else if (srcData instanceof ImageSource) {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.android);
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.android);
         }
         else if (srcData instanceof ImageAsset) {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
+        }
+        else if (srcData instanceof Canvas) {
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
         }
         else if (srcData instanceof ImageBitmap) {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
         }
         else if (srcData && typeof srcData.tagName === 'string' && (srcData.tagName === 'IMG' || srcData.tagName === 'IMAGE')) {
             if (srcData._imageSource instanceof ImageSource) {
-                texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._imageSource.android);
+                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._imageSource.android);
             }
             else if (srcData._image instanceof android.graphics.Bitmap) {
-                texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._image);
+                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._image);
             }
             else if (srcData._asset instanceof ImageAsset) {
-                texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._asset.native);
+                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._asset.native);
             }
             else if (typeof srcData.src === 'string') {
                 const result = ImageSource.fromFileSync(srcData.src);
-                texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, result ? result.android : null);
+                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, result ? result.android : null);
             }
         }
-        else if (srcData && typeof srcData.tagName === 'string' && srcData.tagName === 'CANVAS' && srcData._canvas instanceof TNSCanvas) {
-            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._canvas.native);
+        else if (srcData && typeof srcData.tagName === 'string' && srcData.tagName === 'CANVAS' && srcData._canvas instanceof Canvas) {
+            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._canvas.native);
         }
     }
     transformFeedbackVaryings(program, varyings, bufferMode) {
-        this._glCheckError('transformFeedbackVaryings');
-        const transformFeedbackVaryings = this._getMethod('transformFeedbackVaryings');
         const value = program.native;
-        transformFeedbackVaryings(value, varyings, bufferMode);
+        this.native.transformFeedbackVaryings(value, varyings, bufferMode);
     }
     uniform1ui(location, v0) {
-        this._glCheckError('uniform1ui');
         const value = location.native;
-        const uniform1ui = this._getMethod('uniform1ui');
-        uniform1ui(value, v0);
+        this.native.uniform1ui(value, v0);
     }
     uniform1uiv(location, data) {
-        this._glCheckError('uniform1uiv');
-        const uniform1uiv = this._getMethod('uniform1uiv');
         const value = location.native;
-        uniform1uiv(value, data);
+        this.native.uniform1uiv(value, data);
     }
     uniform2ui(location, v0, v1) {
-        this._glCheckError('uniform2ui');
-        const uniform2ui = this._getMethod('uniform2ui');
         const value = location.native;
-        uniform2ui(value, v0, v1);
+        this.native.uniform2ui(value, v0, v1);
     }
     uniform2uiv(location, data) {
-        this._glCheckError('uniform2uiv');
-        const uniform2uiv = this._getMethod('uniform2uiv');
         const value = location.native;
-        uniform2uiv(value, data);
+        this.native.uniform2uiv(value, data);
     }
     /* Sync objects */
     /* Miscellaneous constants */
     uniform3ui(location, v0, v1, v2) {
-        this._glCheckError('uniform3ui');
-        const uniform3ui = this._getMethod('uniform3ui');
         const value = location.native;
-        uniform3ui(value, v0, v1, v2);
+        this.native.uniform3ui(value, v0, v1, v2);
     }
     uniform3uiv(location, data) {
-        this._glCheckError('uniform3uiv');
-        const uniform3uiv = this._getMethod('uniform3uiv');
         const value = location.native;
-        uniform3uiv(value, data);
+        this.native.uniform3uiv(value, data);
     }
     uniform4ui(location, v0, v1, v2, v3) {
-        this._glCheckError('uniform4ui');
-        const uniform4ui = this._getMethod('uniform4ui');
         const value = location.native;
-        uniform4ui(value, v0, v1, v2, v3);
+        this.native.uniform4ui(value, v0, v1, v2, v3);
     }
     uniform4uiv(location, data) {
-        this._glCheckError('uniform4uiv');
-        const uniform4uiv = this._getMethod('uniform4uiv');
         const value = location.native;
-        uniform4uiv(value, data);
+        this.native.uniform4uiv(value, data);
     }
     uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) {
-        this._glCheckError('uniformBlockBinding');
-        const uniformBlockBindingFunc = this._getMethod('uniformBlockBinding');
         const value = program.native;
-        uniformBlockBindingFunc(value, uniformBlockIndex, uniformBlockBinding);
+        this.native.uniformBlockBinding(value, uniformBlockIndex, uniformBlockBinding);
     }
     uniformMatrix2x3fv(location, transpose, data) {
-        this._glCheckError('uniformMatrix2x3fv');
-        const uniformMatrix2x3fv = this._getMethod('uniformMatrix2x3fv');
         const value = location.native;
-        uniformMatrix2x3fv(value, transpose, data);
+        this.native.uniformMatrix2x3fv(value, transpose, data);
     }
     uniformMatrix2x4fv(location, transpose, data) {
-        this._glCheckError('uniformMatrix2x4fv');
-        const uniformMatrix2x4fv = this._getMethod('uniformMatrix2x4fv');
         const value = location.native;
-        uniformMatrix2x4fv(value, transpose, data);
+        this.native.uniformMatrix2x4fv(value, transpose, data);
     }
     uniformMatrix3x2fv(location, transpose, data) {
-        this._glCheckError('uniformMatrix3x2fv');
-        const uniformMatrix3x2fv = this._getMethod('uniformMatrix3x2fv');
         const value = location.native;
-        uniformMatrix3x2fv(value, transpose, data);
+        this.native.uniformMatrix3x2fv(value, transpose, data);
     }
     uniformMatrix3x4fv(location, transpose, data) {
-        this._glCheckError('uniformMatrix3x4fv');
-        const uniformMatrix3x4fv = this._getMethod('uniformMatrix3x4fv');
         const value = location.native;
-        uniformMatrix3x4fv(value, transpose, data);
+        this.native.uniformMatrix3x4fv(value, transpose, data);
     }
     uniformMatrix4x2fv(location, transpose, data) {
-        this._glCheckError('uniformMatrix4x2fv');
-        const uniformMatrix4x2fv = this._getMethod('uniformMatrix4x2fv');
         const value = location.native;
-        uniformMatrix4x2fv(value, transpose, data);
+        this.native.uniformMatrix4x2fv(value, transpose, data);
     }
     uniformMatrix4x3fv(location, transpose, data) {
-        this._glCheckError('uniformMatrix4x3fv');
-        const uniformMatrix4x3fv = this._getMethod('uniformMatrix4x3fv');
         const value = location.native;
-        uniformMatrix4x3fv(value, transpose, data);
+        this.native.uniformMatrix4x3fv(value, transpose, data);
     }
     vertexAttribDivisor(index, divisor) {
-        this._glCheckError('vertexAttribDivisor');
-        const vertexAttribDivisor = this._getMethod('vertexAttribDivisor');
-        vertexAttribDivisor(index, divisor);
+        this.native.vertexAttribDivisor(index, divisor);
     }
     vertexAttribI4i(index, v0, v1, v2, v3) {
-        this._glCheckError('vertexAttribI4i');
-        const vertexAttribI4i = this._getMethod('vertexAttribI4i');
-        vertexAttribI4i(index, v0, v1, v2, v3);
+        this.native.vertexAttribI4i(index, v0, v1, v2, v3);
     }
     vertexAttribI4iv(index, value) {
-        this._glCheckError('vertexAttribI4iv');
-        const vertexAttribI4iv = this._getMethod('vertexAttribI4iv');
-        vertexAttribI4iv(index, value);
+        this.native.vertexAttribI4iv(index, value);
     }
     vertexAttribI4ui(index, v0, v1, v2, v3) {
-        this._glCheckError('vertexAttribI4ui');
-        const vertexAttribI4ui = this._getMethod('vertexAttribI4ui');
-        vertexAttribI4ui(index, v0, v1, v2, v3);
+        this.native.vertexAttribI4ui(index, v0, v1, v2, v3);
     }
     vertexAttribI4uiv(index, value) {
-        this._glCheckError('vertexAttribI4uiv');
-        const vertexAttribI4uiv = this._getMethod('vertexAttribI4uiv');
-        vertexAttribI4uiv(index, value);
+        this.native.vertexAttribI4uiv(index, value);
     }
 }
 (() => {
     Helpers.initialize();
-    ctor = global.CanvasJSIModule.createWebGL2Context;
 })();
 //# sourceMappingURL=index.js.map