@nativescript/canvas 1.1.0 → 2.0.0-alpha.1

package/WebGL2/WebGL2RenderingContext/index.android.js

@@ -6,294 +6,290 @@ import { WebGLFramebuffer } from '../../WebGL/WebGLFramebuffer';
 import { WebGLActiveInfo } from '../../WebGL/WebGLActiveInfo';
 import { WebGLBuffer } from '../../WebGL/WebGLBuffer';
 import { ImageAsset } from '../../ImageAsset';
-import { ImageSource } from '@nativescript/core';
+import { ImageSource, Screen } from '@nativescript/core';
 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) {
-        super(context);
-    }
-    /* Transform feedback */
-    static toPrimitive(value) {
-        if (value instanceof java.lang.Integer) {
-            return value.intValue();
-        }
-        else if (value instanceof java.lang.Long) {
-            return value.longValue();
-        }
-        else if (value instanceof java.lang.Short) {
-            return value.shortValue();
-        }
-        else if (value instanceof java.lang.Byte) {
-            return value.byteValue();
-        }
-        else if (value instanceof java.lang.Boolean) {
-            return value.booleanValue();
-        }
-        else if (value instanceof java.lang.String) {
-            return value.toString();
-        }
-        else if (value instanceof java.lang.Float) {
-            return value.floatValue();
+    constructor(context, contextOptions) {
+        super(null);
+        const ctx = BigInt(context.getNativeContext().toString());
+        let direction = 0;
+        if (androidx.core.text.TextUtilsCompat.getLayoutDirectionFromLocale(java.util.Locale.getDefault()) === androidx.core.view.ViewCompat.LAYOUT_DIRECTION_RTL) {
+            direction = 1;
         }
-        else if (value instanceof java.lang.Double) {
-            return value.doubleValue();
-        }
-        return value;
+        const native = ctor(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 ? query.native : 0;
-        this.native.beginQuery(target, value);
+        const value = query.native;
+        const beginQuery = this._getMethod('beginQuery');
+        beginQuery(target, value);
     }
     beginTransformFeedback(primitiveMode) {
         this._glCheckError('beginTransformFeedback');
-        this.native.beginTransformFeedback(primitiveMode);
+        const beginTransformFeedback = this._getMethod('beginTransformFeedback');
+        beginTransformFeedback(primitiveMode);
     }
     bindBufferBase(target, index, buffer) {
         this._glCheckError('bindBufferBase');
-        const value = buffer ? buffer.native : 0;
-        this.native.bindBufferBase(target, index, value);
+        const value = buffer ? buffer.native : null;
+        const bindBufferBase = this._getMethod('bindBufferBase');
+        bindBufferBase(target, index, value);
     }
     bindBufferRange(target, index, buffer, offset, size) {
         this._glCheckError('bindBufferRange');
-        const value = buffer ? buffer.native : 0;
-        this.native.bindBufferRange(target, index, value, offset, size);
+        const value = buffer ? buffer.native : null;
+        const bindBufferRange = this._getMethod('bindBufferRange');
+        bindBufferRange(target, index, value, offset, size);
     }
     bindSampler(unit, sampler) {
         this._glCheckError('bindSampler');
-        const value = sampler ? sampler.native : 0;
-        this.native.bindSampler(unit, value);
+        const value = sampler ? sampler.native : null;
+        const bindSampler = this._getMethod('bindSampler');
+        bindSampler(unit, value);
     }
     bindTransformFeedback(target, transformFeedback) {
         this._glCheckError('bindTransformFeedback');
-        const value = transformFeedback ? transformFeedback.native : 0;
-        this.native.bindTransformFeedback(target, value);
+        const value = transformFeedback ? transformFeedback.native : null;
+        const bindTransformFeedback = this._getMethod('bindTransformFeedback');
+        bindTransformFeedback(target, value);
     }
     bindVertexArray(vertexArray) {
         this._glCheckError('bindVertexArray');
-        const value = vertexArray ? vertexArray.native : 0;
-        if (value) {
-            this.native.bindVertexArray(value);
-        }
-        else {
-            this.native.bindVertexArray();
-        }
+        const value = vertexArray ? vertexArray.native : null;
+        const bindVertexArray = this._getMethod('bindVertexArray');
+        bindVertexArray(value);
     }
     blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) {
         this._glCheckError('blitFramebuffer');
-        this.native.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+        const blitFramebuffer = this._getMethod('blitFramebuffer');
+        blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     }
     clearBufferfi(buffer, drawbuffer, depth, stencil) {
         this._glCheckError('clearBufferfi');
-        const value = buffer ? buffer.native : 0;
-        this.native.clearBufferfi(value, drawbuffer, depth, stencil);
+        const value = buffer.native;
+        const clearBufferfi = this._getMethod('clearBufferfi');
+        clearBufferfi(value, drawbuffer, depth, stencil);
     }
     clearBufferfv(buffer, drawbuffer, values) {
         this._glCheckError('clearBufferfv');
-        const value = buffer ? buffer.native : 0;
-        if (values instanceof Float32Array) {
-            values = this.toNativeArray(values, 'float');
-        }
-        this.native.clearBufferfv(value, drawbuffer, values);
+        const clearBufferfv = this._getMethod('clearBufferfv');
+        const value = buffer.native;
+        clearBufferfv(value, drawbuffer, values);
     }
     clearBufferiv(buffer, drawbuffer, values) {
         this._glCheckError('clearBufferiv');
+        const clearBufferiv = this._getMethod('clearBufferiv');
         const value = buffer ? buffer.native : 0;
-        if (values instanceof Int32Array) {
-            values = this.toNativeArray(values, 'int');
-        }
-        this.native.clearBufferiv(value, drawbuffer, values);
+        clearBufferiv(value, drawbuffer, values);
     }
     clearBufferuiv(buffer, drawbuffer, values) {
         this._glCheckError('clearBufferuiv');
+        const clearBufferuiv = this._getMethod('clearBufferuiv');
         const value = buffer ? buffer.native : 0;
-        if (values instanceof Uint32Array) {
-            values = this.toNativeArray(values, 'int');
-        }
-        this.native.clearBufferuiv(value, drawbuffer, values);
+        clearBufferuiv(value, drawbuffer, values);
     }
     clientWaitSync(sync, flags, timeout) {
         this._glCheckError('clientWaitSync');
-        const value = sync ? sync.native : 0;
-        return this.native.clientWaitSync(value, flags, timeout);
+        const clientWaitSync = this._getMethod('clientWaitSync');
+        const value = sync.native;
+        return clientWaitSync(value, flags, timeout);
     }
     compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset = 0, srcLengthOverride = 0) {
         this._glCheckError('compressedTexSubImage3D');
-        if (typeof srcOffset === 'number') {
-            this.native.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset);
-        }
-        else if (srcData && srcData.buffer) {
-            if (srcData instanceof Uint8Array) {
-                this.native.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, this.toNativeArray(srcData, 'byte'), srcOffset, srcLengthOverride);
-            }
-        }
+        const compressedTexSubImage3D = this._getMethod('compressedTexSubImage3D');
+        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');
-        this.native.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+        const copyBufferSubData = this._getMethod('copyBufferSubData');
+        copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
     }
     copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) {
         this._glCheckError('copyTexSubImage3D');
-        this.native.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+        const copyTexSubImage3D = this._getMethod('copyTexSubImage3D');
+        copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
     }
     createQuery() {
         this._glCheckError('createQuery');
-        return new WebGLQuery(this.native.createQuery());
+        const createQuery = this._getMethod('createQuery');
+        return new WebGLQuery(createQuery());
     }
     createSampler() {
         this._glCheckError('createSampler');
-        return new WebGLSampler(this.native.createSampler());
+        const createSampler = this._getMethod('createSampler');
+        return new WebGLSampler(createSampler());
     }
     createTransformFeedback() {
         this._glCheckError('createTransformFeedback');
-        return new WebGLTransformFeedback(this.native.createTransformFeedback());
+        const createTransformFeedback = this._getMethod('createTransformFeedback');
+        return new WebGLTransformFeedback(createTransformFeedback());
     }
     createVertexArray() {
         this._glCheckError('createVertexArray');
-        return new WebGLVertexArrayObject(this.native.createVertexArray());
-    }
-    deleteQueryWithQuery(query) {
-        this._glCheckError('deleteQueryWithQuery');
-        const value = query ? query.native : 0;
-        this.native.deleteQuery(value);
-    }
-    deleteSamplerWithSampler(sampler) {
-        this._glCheckError('deleteSamplerWithSampler');
-        const value = sampler ? sampler.native : 0;
-        this.native.deleteSampler(value);
-    }
-    deleteSyncWithSync(sync) {
-        this._glCheckError('deleteSyncWithSync');
-        const value = sync ? sync.native : 0;
-        this.native.deleteSync(value);
+        const createVertexArray = this._getMethod('createVertexArray');
+        return new WebGLVertexArrayObject(createVertexArray());
+    }
+    deleteQuery(query) {
+        this._glCheckError('deleteQuery');
+        const deleteQuery = this._getMethod('deleteQuery');
+        const value = query.native;
+        deleteQuery(value);
+    }
+    deleteSampler(sampler) {
+        this._glCheckError('deleteSampler');
+        const deleteSampler = this._getMethod('deleteSampler');
+        const value = sampler.native;
+        deleteSampler(value);
+    }
+    deleteSync(sync) {
+        this._glCheckError('deleteSync');
+        const deleteSync = this._getMethod('deleteSync');
+        const value = sync.native;
+        deleteSync(value);
     }
     deleteTransformFeedback(transformFeedback) {
         this._glCheckError('deleteTransformFeedback');
-        const value = transformFeedback ? transformFeedback.native : 0;
-        this.native.deleteTransformFeedback(value);
+        const deleteTransformFeedback = this._getMethod('deleteTransformFeedback');
+        const value = transformFeedback.native;
+        deleteTransformFeedback(value);
     }
     deleteVertexArray(vertexArray) {
         this._glCheckError('deleteVertexArray');
-        const value = vertexArray ? vertexArray.native : 0;
-        this.native.deleteVertexArray(value);
+        const deleteVertexArray = this._getMethod('deleteVertexArray');
+        const value = vertexArray.native;
+        deleteVertexArray(value);
     }
     drawArraysInstanced(mode, first, count, instanceCount) {
         this._glCheckError('drawArraysInstanced');
-        this.native.drawArraysInstanced(mode, first, count, instanceCount);
+        const drawArraysInstanced = this._getMethod('drawArraysInstanced');
+        drawArraysInstanced(mode, first, count, instanceCount);
     }
     drawBuffers(buffers) {
         this._glCheckError('drawBuffers');
-        this.native.drawBuffers(buffers);
+        const drawBuffers = this._getMethod('drawBuffers');
+        drawBuffers(buffers);
     }
     drawElementsInstanced(mode, count, type, offset, instanceCount) {
         this._glCheckError('drawElementsInstanced');
-        this.native.drawElementsInstanced(mode, count, type, offset, instanceCount);
+        const drawElementsInstanced = this._getMethod('drawElementsInstanced');
+        drawElementsInstanced(mode, count, type, offset, instanceCount);
     }
     drawRangeElements(mode, start, end, count, type, offset) {
         this._glCheckError('drawRangeElements');
-        this.native.drawRangeElements(mode, start, end, count, type, offset);
+        const drawRangeElements = this._getMethod('drawRangeElements');
+        drawRangeElements(mode, start, end, count, type, offset);
     }
     endQuery(target) {
         this._glCheckError('endQuery');
-        this.native.endQuery(target);
+        const endQuery = this._getMethod('endQuery');
+        endQuery(target);
     }
     endTransformFeedback() {
         this._glCheckError('endTransformFeedback');
-        this.native.endTransformFeedback();
+        const endTransformFeedback = this._getMethod('endTransformFeedback');
+        endTransformFeedback();
     }
     fenceSync(condition, flags) {
         this._glCheckError('fenceSync');
-        this.native.fenceSync(condition, flags);
+        const fenceSync = this._getMethod('fenceSync');
+        fenceSync(condition, flags);
     }
     framebufferTextureLayer(target, attachment, texture, level, layer) {
         this._glCheckError('framebufferTextureLayer');
-        const value = texture ? texture.native : 0;
-        this.native.framebufferTextureLayer(target, attachment, value, level, layer);
+        const framebufferTextureLayer = this._getMethod('framebufferTextureLayer');
+        const value = texture.native;
+        framebufferTextureLayer(target, attachment, value, level, layer);
     }
     /* Framebuffers and renderbuffers */
     /* Uniforms */
     getActiveUniformBlockName(program, uniformBlockIndex) {
         this._glCheckError('getActiveUniformBlockName');
-        const value = program ? program.native : 0;
-        return this.native.getActiveUniformBlockName(value, uniformBlockIndex);
+        const getActiveUniformBlockName = this._getMethod('getActiveUniformBlockName');
+        const value = program.native;
+        return getActiveUniformBlockName(value, uniformBlockIndex);
     }
     getActiveUniformBlockParameter(program, uniformBlockIndex, pname) {
         this._glCheckError('getActiveUniformBlockParameter');
-        const value = program ? program.native : 0;
-        const param = this.native.getActiveUniformBlockParameter(value, uniformBlockIndex, pname);
-        if (pname === this.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) {
-            return new Uint32Array(this.getJSArray(param));
-        }
-        return WebGL2RenderingContext.toPrimitive(param);
+        const getActiveUniformBlockParameter = this._getMethod('getActiveUniformBlockParameter');
+        const value = program.native;
+        return getActiveUniformBlockParameter(value, uniformBlockIndex, pname);
     }
     getActiveUniforms(program, uniformIndices, pname) {
         this._glCheckError('getActiveUniforms');
-        const value = program ? program.native : 0;
-        return this.getJSArray(this.native.getActiveUniforms(value, uniformIndices, pname));
+        const getActiveUniforms = this._getMethod('getActiveUniforms');
+        const value = program.native;
+        return getActiveUniforms(value, uniformIndices, pname);
     }
     getBufferSubData(target, srcByteOffset, dstData, dstOffset = 0, length = 0) {
         this._glCheckError('getBufferSubData');
-        this.native.getBufferSubData(target, srcByteOffset, new Uint8Array(dstData.slice(0)), dstOffset, length);
+        const getBufferSubData = this._getMethod('getBufferSubData');
+        getBufferSubData(target, srcByteOffset, dstData, dstOffset, length);
     }
     getFragDataLocation(program, name) {
         this._glCheckError('getFragDataLocation');
-        const value = program ? program.native : 0;
-        const result = this.native.getFragDataLocation(value, name);
+        const getFragDataLocation = this._getMethod('getFragDataLocation');
+        const value = program.native;
+        const result = getFragDataLocation(value, name);
         return result !== -1 ? result : null;
     }
     getIndexedParameter(target, index) {
         this._glCheckError('getIndexedParameter');
-        const param = this.native.getIndexedParameter(target, index);
+        const getIndexedParameter = this._getMethod('getIndexedParameter');
+        const param = getIndexedParameter(target, index);
         if (target === this.TRANSFORM_FEEDBACK_BUFFER_BINDING || target === this.UNIFORM_BUFFER_BINDING) {
             return new WebGLBuffer(param);
         }
-        return WebGL2RenderingContext.toPrimitive(param);
+        return param;
     }
     getInternalformatParameter(target, internalformat, pname) {
         this._glCheckError('getInternalformatParameter');
-        const param = this.native.getInternalformatParameter(target, internalformat, pname);
-        if (pname === this.SAMPLES) {
-            return new Int32Array(this.getJSArray(param));
-        }
-        return WebGL2RenderingContext.toPrimitive(param);
+        const getInternalformatParameter = this._getMethod('getInternalformatParameter');
+        return getInternalformatParameter(target, internalformat, pname);
     }
     getQueryParameter(query, pname) {
         this._glCheckError('getQueryParameter');
-        const value = query ? query.native : 0;
-        const result = this.native.getQueryParameter(value, pname);
+        const getQueryParameter = this._getMethod('getQueryParameter');
+        const value = query.native;
+        const result = getQueryParameter(value, pname);
         if (result === 0) {
             return null;
         }
-        return WebGL2RenderingContext.toPrimitive(result);
+        return result;
     }
     //@ts-ignore
     getParameter(pname) {
         this._glCheckError('getParameter');
-        this._checkArgs('activeTexture', arguments);
-        const value = this.native.getParameter(pname);
+        this._checkArgs('getParameter', arguments);
+        const getParameter = this._getMethod('getParameter');
+        const value = getParameter(pname);
         switch (pname) {
             case this.COPY_READ_BUFFER_BINDING:
             case this.COPY_WRITE_BUFFER_BINDING:
                 if (value) {
-                    new WebGLBuffer(WebGL2RenderingContext.toPrimitive(value));
+                    return new WebGLBuffer(value);
                 }
                 return null;
             case this.DRAW_FRAMEBUFFER_BINDING:
                 if (value) {
-                    return new WebGLFramebuffer(WebGL2RenderingContext.toPrimitive(value));
+                    return new WebGLFramebuffer(value);
                 }
                 return null;
             default:
-                return super.getParameter(pname);
+                return this._handleGetParameter(pname, value);
         }
     }
     getQuery(target, pname) {
         this._glCheckError('getQuery');
-        const query = this.native.getQuery(target, pname);
+        const getQuery = this._getMethod('getQuery');
+        const query = getQuery(target, pname);
         if (query) {
             return new WebGLQuery(query);
         }
@@ -301,368 +297,330 @@ export class WebGL2RenderingContext extends WebGL2RenderingContextBase {
     }
     getSamplerParameter(sampler, pname) {
         this._glCheckError('getSamplerParameter');
-        const value = sampler ? sampler.native : 0;
-        return WebGL2RenderingContext.toPrimitive(this.native.getSamplerParameter(value, pname));
+        const getSamplerParameter = this._getMethod('getSamplerParameter');
+        const value = sampler.native;
+        return getSamplerParameter(value, pname);
     }
     getSyncParameter(sync, pname) {
         this._glCheckError('getSyncParameter');
-        const value = sync ? sync.native : 0;
-        return WebGL2RenderingContext.toPrimitive(this.native.getSyncParameter(value, pname));
+        const getSyncParameter = this._getMethod('getSyncParameter');
+        const value = sync.native;
+        return getSyncParameter(value, pname);
     }
     getTransformFeedbackVarying(program, index) {
         this._glCheckError('getTransformFeedbackVarying');
-        const value = program ? program.native : 0;
-        const info = this.native.getTransformFeedbackVarying(value, index);
+        const value = program.native;
+        const getTransformFeedbackVarying = this._getMethod('getTransformFeedbackVarying');
+        const info = getTransformFeedbackVarying(value, index);
         if (info) {
-            return new WebGLActiveInfo(info.name, info.size, info.size);
+            return new WebGLActiveInfo(info);
         }
         return null;
     }
     getUniformBlockIndex(program, uniformBlockName) {
         this._glCheckError('getUniformBlockIndex');
-        const value = program ? program.native : 0;
-        return this.native.getUniformBlockIndex(value, uniformBlockName);
+        const getUniformBlockIndex = this._getMethod('getUniformBlockIndex');
+        const value = program.native;
+        return getUniformBlockIndex(value, uniformBlockName);
     }
     getUniformIndices(program, uniformNames) {
         this._glCheckError('getUniformIndices');
-        const value = program ? program.native : 0;
-        return this.getJSArray(this.native.getUniformIndices(value, uniformNames));
+        const getUniformIndices = this._getMethod('getUniformIndices');
+        const value = program.native;
+        return getUniformIndices(value, uniformNames);
     }
     invalidateFramebuffer(target, attachments) {
         this._glCheckError('invalidateFramebuffer');
-        this.native.invalidateFramebuffer(target, attachments);
+        const invalidateFramebuffer = this._getMethod('invalidateFramebuffer');
+        invalidateFramebuffer(target, attachments);
     }
     invalidateSubFramebuffer(target, attachments, x, y, width, height) {
         this._glCheckError('invalidateSubFramebuffer');
-        this.native.invalidateSubFramebuffer(target, attachments, x, y, width, height);
+        const invalidateSubFramebuffer = this._getMethod('invalidateSubFramebuffer');
+        invalidateSubFramebuffer(target, attachments, x, y, width, height);
     }
     isQuery(query) {
         this._glCheckError('isQuery');
-        const value = query ? query.native : 0;
-        return this.native.isQuery(value);
+        const isQuery = this._getMethod('isQuery');
+        const value = query.native;
+        return isQuery(value);
     }
     isSampler(sampler) {
         this._glCheckError('isSampler');
-        const value = sampler ? sampler.native : 0;
-        return this.native.isSampler(value);
+        const isSampler = this._getMethod('isSampler');
+        const value = sampler.native;
+        return isSampler(value);
     }
     isSync(sync) {
         this._glCheckError('isSync');
-        const value = sync ? sync.native : 0;
-        return this.native.isSync(value);
+        const isSync = this._getMethod('isSync');
+        const value = sync.native;
+        return isSync(value);
     }
     isTransformFeedback(transformFeedback) {
         this._glCheckError('isTransformFeedback');
-        const value = transformFeedback ? transformFeedback.native : 0;
-        return this.native.isTransformFeedback(value);
+        const isTransformFeedback = this._getMethod('isTransformFeedback');
+        const value = transformFeedback.native;
+        return isTransformFeedback(value);
     }
     isVertexArray(vertexArray) {
         this._glCheckError('isVertexArray');
-        const value = vertexArray ? vertexArray.native : 0;
-        return this.native.isVertexArray(value);
+        const isVertexArray = this._getMethod('isVertexArray');
+        const value = vertexArray.native;
+        return isVertexArray(value);
     }
     pauseTransformFeedback() {
         this._glCheckError('pauseTransformFeedback');
-        this.native.pauseTransformFeedback();
+        const pauseTransformFeedback = this._getMethod('pauseTransformFeedback');
+        pauseTransformFeedback();
     }
     readBuffer(src) {
         this._glCheckError('readBuffer');
-        this.native.readBuffer(src);
+        const readBuffer = this._getMethod('readBuffer');
+        readBuffer(src);
     }
     renderbufferStorageMultisample(target, samples, internalFormat, width, height) {
         this._glCheckError('renderbufferStorageMultisample');
-        this.native.renderbufferStorageMultisample(target, samples, internalFormat, width, height);
+        const renderbufferStorageMultisample = this._getMethod('renderbufferStorageMultisample');
+        renderbufferStorageMultisample(target, samples, internalFormat, width, height);
     }
     resumeTransformFeedback() {
         this._glCheckError('resumeTransformFeedback');
-        this.native.resumeTransformFeedback();
+        const resumeTransformFeedback = this._getMethod('resumeTransformFeedback');
+        resumeTransformFeedback();
     }
     samplerParameterf(sampler, pname, param) {
         this._glCheckError('samplerParameterf');
-        const value = sampler ? sampler.native : 0;
-        this.native.samplerParameterf(value, pname, param);
+        const samplerParameterf = this._getMethod('samplerParameterf');
+        const value = sampler.native;
+        samplerParameterf(value, pname, param);
     }
     /* Uniforms */
     /* Sync objects */
     samplerParameteri(sampler, pname, param) {
         this._glCheckError('samplerParameteri');
-        const value = sampler ? sampler.native : 0;
-        this.native.samplerParameteri(value, pname, param);
+        const samplerParameteri = this._getMethod('samplerParameteri');
+        const value = sampler.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') {
-            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
+            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source && source.buffer) {
-            if (source && source.buffer) {
-                if (source instanceof Uint8Array || source instanceof Uint8ClampedArray) {
-                    this.native.texImage3DByte(target, level, internalformat, width, height, depth, border, format, type, Array.from(source));
-                }
-                else if (source instanceof Uint16Array || source instanceof Int16Array) {
-                    this.native.texImage3DShort(target, level, internalformat, width, height, depth, border, format, type, Array.from(source));
-                }
-                else if (source instanceof Uint32Array || source instanceof Int32Array) {
-                    this.native.texImage3DInt(target, level, internalformat, width, height, depth, border, format, type, Array.from(source));
-                }
-                else if (source instanceof Float32Array) {
-                    this.native.texImage3DFloat(target, level, internalformat, width, height, depth, border, format, type, Array.from(source));
-                }
-                else if (source instanceof Float64Array) {
-                    this.native.texImage3DDouble(target, level, internalformat, width, height, depth, border, format, type, Array.from(source));
-                }
-            }
-            else if (source instanceof ArrayBuffer) {
-                // @ts-ignore
-                if (source.nativeObject) {
-                    // @ts-ignore
-                    this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, 
-                    // @ts-ignore
-                    source.nativeObject);
-                }
-                else {
-                    this.native.texImage3DByte(target, level, internalformat, width, height, depth, border, format, type, Array.from(new Uint8Array(source)));
-                }
-            }
+            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source instanceof android.graphics.Bitmap) {
-            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
+            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source instanceof ImageSource) {
-            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.android);
+            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.android);
         }
         else if (source instanceof ImageAsset) {
-            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
+            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source.native);
         }
-        else if (source instanceof ImageBitmap || source?.native instanceof org.nativescript.canvas.TNSImageBitmap) {
-            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);
         }
         else if (source && typeof source.tagName === 'string' && (source.tagName === 'IMG' || source.tagName === 'IMAGE')) {
             if (source._imageSource instanceof ImageSource) {
-                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._imageSource.android);
+                texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._imageSource.android);
             }
             else if (source._image instanceof android.graphics.Bitmap) {
-                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._image);
+                texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._image);
             }
             else if (source._asset instanceof ImageAsset) {
-                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._asset.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);
-                this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, result ? result.android : null);
+                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) {
-            this.native.texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._canvas.android);
+            texImage3D(target, level, internalformat, width, height, depth, border, format, type, source._canvas.native);
         }
     }
     texStorage2D(target, levels, internalformat, width, height) {
         this._glCheckError('texStorage2D');
-        this.native.texStorage2D(target, levels, internalformat, width, height);
+        const texStorage2D = this._getMethod('texStorage2D');
+        texStorage2D(target, levels, internalformat, width, height);
     }
     texStorage3D(target, levels, internalformat, width, height, depth) {
         this._glCheckError('texStorage3D');
-        this.native.texStorage3D(target, levels, internalformat, width, height, depth);
+        const texStorage3D = this._getMethod('texStorage3D');
+        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') {
-            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
+            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
         }
         else if (srcData && srcData.buffer) {
-            if (srcData instanceof Uint8Array) {
-                if (srcOffset) {
-                    this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, this.toNativeArray(srcData, 'byte'), srcOffset);
-                }
-                else {
-                    this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, this.toNativeArray(srcData, 'byte'));
-                }
-            }
-            if (srcData && srcData.buffer) {
-                if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
-                    this.native.texSubImage3DByte(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, Array.from(srcData), srcOffset);
-                }
-                else if (srcData instanceof Uint16Array || srcData instanceof Int16Array) {
-                    this.native.texSubImage3DShort(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, Array.from(srcData), srcOffset);
-                }
-                else if (srcData instanceof Uint32Array || srcData instanceof Int32Array) {
-                    this.native.texSubImage3DInt(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, Array.from(srcData), srcOffset);
-                }
-                else if (srcData instanceof Float32Array) {
-                    this.native.texSubImage3DFloat(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, Array.from(srcData), srcOffset);
-                }
-                else if (srcData instanceof Float64Array) {
-                    this.native.texSubImage3DDouble(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, Array.from(srcData), srcOffset);
-                }
-            }
-            else if (srcData instanceof ArrayBuffer) {
-                // @ts-ignore
-                if (source.nativeObject) {
-                    this.native.texSubImage3DByte(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, 
-                    // @ts-ignore
-                    source.nativeObject, srcOffset);
-                }
-                else {
-                    this.native.texSubImage3DDouble(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, Array.from(new Uint8Array(srcData)), srcOffset);
-                }
-            }
+            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset);
         }
         else if (srcData instanceof android.graphics.Bitmap) {
-            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
+            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
         }
         else if (srcData instanceof ImageSource) {
-            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.android);
+            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.android);
         }
         else if (srcData instanceof ImageAsset) {
-            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
+            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
         }
-        else if (srcData instanceof ImageBitmap || srcData?.native instanceof org.nativescript.canvas.TNSImageBitmap) {
-            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);
         }
         else if (srcData && typeof srcData.tagName === 'string' && (srcData.tagName === 'IMG' || srcData.tagName === 'IMAGE')) {
             if (srcData._imageSource instanceof ImageSource) {
-                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._imageSource.android);
+                texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._imageSource.android);
             }
             else if (srcData._image instanceof android.graphics.Bitmap) {
-                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._image);
+                texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._image);
             }
             else if (srcData._asset instanceof ImageAsset) {
-                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._asset.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);
-                this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, result ? result.android : null);
+                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) {
-            this.native.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._canvas.android);
+            texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._canvas.native);
         }
     }
     transformFeedbackVaryings(program, varyings, bufferMode) {
         this._glCheckError('transformFeedbackVaryings');
-        const value = program ? program.native : 0;
-        this.native.transformFeedbackVaryings(value, varyings, bufferMode);
+        const transformFeedbackVaryings = this._getMethod('transformFeedbackVaryings');
+        const value = program.native;
+        transformFeedbackVaryings(value, varyings, bufferMode);
     }
     uniform1ui(location, v0) {
         this._glCheckError('uniform1ui');
-        const value = location ? location.native : 0;
-        this.native.uniform1ui(value, v0);
+        const value = location.native;
+        const uniform1ui = this._getMethod('uniform1ui');
+        uniform1ui(value, v0);
     }
     uniform1uiv(location, data) {
         this._glCheckError('uniform1uiv');
-        const value = location ? location.native : 0;
-        this.native.uniform1uiv(value, Array.from(data));
+        const uniform1uiv = this._getMethod('uniform1uiv');
+        const value = location.native;
+        uniform1uiv(value, data);
     }
     uniform2ui(location, v0, v1) {
         this._glCheckError('uniform2ui');
-        const value = location ? location.native : 0;
-        this.native.uniform2ui(value, v0, v1);
+        const uniform2ui = this._getMethod('uniform2ui');
+        const value = location.native;
+        uniform2ui(value, v0, v1);
     }
     uniform2uiv(location, data) {
         this._glCheckError('uniform2uiv');
-        const value = location ? location.native : 0;
-        this.native.uniform2uiv(value, Array.from(data));
+        const uniform2uiv = this._getMethod('uniform2uiv');
+        const value = location.native;
+        uniform2uiv(value, data);
     }
     /* Sync objects */
     /* Miscellaneous constants */
     uniform3ui(location, v0, v1, v2) {
         this._glCheckError('uniform3ui');
-        const value = location ? location.native : 0;
-        this.native.uniform3ui(value, v0, v1, v2);
+        const uniform3ui = this._getMethod('uniform3ui');
+        const value = location.native;
+        uniform3ui(value, v0, v1, v2);
     }
     uniform3uiv(location, data) {
         this._glCheckError('uniform3uiv');
-        const value = location ? location.native : 0;
-        this.native.uniform3uiv(value, Array.from(data));
+        console.log('uniform3uiv');
+        const uniform3uiv = this._getMethod('uniform3uiv');
+        const value = location.native;
+        uniform3uiv(value, data);
     }
     uniform4ui(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4ui');
-        const value = location ? location.native : 0;
-        this.native.uniform4ui(value, v0, v1, v2, v3);
+        const uniform4ui = this._getMethod('uniform4ui');
+        const value = location.native;
+        uniform4ui(value, v0, v1, v2, v3);
     }
     uniform4uiv(location, data) {
         this._glCheckError('uniform4uiv');
-        const value = location ? location.native : 0;
-        this.native.uniform4uiv(value, Array.from(data));
+        console.log('uniform4uiv');
+        const uniform4uiv = this._getMethod('uniform4uiv');
+        const value = location.native;
+        uniform4uiv(value, data);
     }
     uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) {
         this._glCheckError('uniformBlockBinding');
-        const value = program ? program.native : 0;
-        this.native.uniformBlockBinding(value, uniformBlockIndex, uniformBlockBinding);
+        const uniformBlockBindingFunc = this._getMethod('uniformBlockBinding');
+        const value = program.native;
+        uniformBlockBindingFunc(value, uniformBlockIndex, uniformBlockBinding);
     }
     uniformMatrix2x3fv(location, transpose, data) {
-        if (data instanceof Float32Array) {
-            data = Array.from(data); //this.toNativeArray(data as any, 'float');
-        }
         this._glCheckError('uniformMatrix2x3fv');
-        const value = location ? location.native : 0;
-        this.native.uniformMatrix2x3fv(value, transpose, data);
+        const uniformMatrix2x3fv = this._getMethod('uniformMatrix2x3fv');
+        const value = location.native;
+        uniformMatrix2x3fv(value, transpose, data);
     }
     uniformMatrix2x4fv(location, transpose, data) {
-        if (data instanceof Float32Array) {
-            data = Array.from(data); //this.toNativeArray(data as any, 'float');
-        }
         this._glCheckError('uniformMatrix2x4fv');
-        const value = location ? location.native : 0;
-        this.native.uniformMatrix2x4fv(value, transpose, data);
+        const uniformMatrix2x4fv = this._getMethod('uniformMatrix2x4fv');
+        const value = location.native;
+        uniformMatrix2x4fv(value, transpose, data);
     }
     uniformMatrix3x2fv(location, transpose, data) {
-        if (data instanceof Float32Array) {
-            data = Array.from(data); //this.toNativeArray(data as any, 'float');
-        }
         this._glCheckError('uniformMatrix3x2fv');
-        const value = location ? location.native : 0;
-        this.native.uniformMatrix3x2fv(value, transpose, data);
+        const uniformMatrix3x2fv = this._getMethod('uniformMatrix3x2fv');
+        const value = location.native;
+        uniformMatrix3x2fv(value, transpose, data);
     }
     uniformMatrix3x4fv(location, transpose, data) {
-        if (data instanceof Float32Array) {
-            data = Array.from(data); //this.toNativeArray(data as any, 'float');
-        }
         this._glCheckError('uniformMatrix3x4fv');
-        const value = location ? location.native : 0;
-        this.native.uniformMatrix3x4fv(value, transpose, data);
+        const uniformMatrix3x4fv = this._getMethod('uniformMatrix3x4fv');
+        const value = location.native;
+        uniformMatrix3x4fv(value, transpose, data);
     }
     uniformMatrix4x2fv(location, transpose, data) {
-        if (data instanceof Float32Array) {
-            data = Array.from(data); //this.toNativeArray(data as any, 'float');
-        }
         this._glCheckError('uniformMatrix4x2fv');
-        const value = location ? location.native : 0;
-        this.native.uniformMatrix4x2fv(value, transpose, data);
+        const uniformMatrix4x2fv = this._getMethod('uniformMatrix4x2fv');
+        const value = location.native;
+        uniformMatrix4x2fv(value, transpose, data);
     }
     uniformMatrix4x3fv(location, transpose, data) {
-        if (data instanceof Float32Array) {
-            data = Array.from(data); //this.toNativeArray(data as any, 'float');
-        }
         this._glCheckError('uniformMatrix4x3fv');
-        const value = location ? location.native : 0;
-        this.native.uniformMatrix4x3fv(value, transpose, data);
+        const uniformMatrix4x3fv = this._getMethod('uniformMatrix4x3fv');
+        const value = location.native;
+        uniformMatrix4x3fv(value, transpose, data);
     }
     vertexAttribDivisor(index, divisor) {
         this._glCheckError('vertexAttribDivisor');
-        this.native.vertexAttribDivisor(index, divisor);
+        const vertexAttribDivisor = this._getMethod('vertexAttribDivisor');
+        vertexAttribDivisor(index, divisor);
     }
     vertexAttribI4i(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttribI4i');
-        this.native.vertexAttribI4i(index, v0, v1, v2, v3);
+        const vertexAttribI4i = this._getMethod('vertexAttribI4i');
+        vertexAttribI4i(index, v0, v1, v2, v3);
     }
     vertexAttribI4iv(index, value) {
-        if (value instanceof Int32Array) {
-            value = Array.from(value); //this.toNativeArray(value as any, 'int');
-        }
         this._glCheckError('vertexAttribI4iv');
-        this.native.vertexAttribI4uiv(index, value);
+        const vertexAttribI4iv = this._getMethod('vertexAttribI4iv');
+        vertexAttribI4iv(index, value);
     }
     vertexAttribI4ui(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttribI4ui');
-        this.native.vertexAttribI4ui(index, v0, v1, v2, v3);
+        const vertexAttribI4ui = this._getMethod('vertexAttribI4ui');
+        vertexAttribI4ui(index, v0, v1, v2, v3);
     }
     vertexAttribI4uiv(index, value) {
-        if (value instanceof Uint32Array) {
-            value = Array.from(value); //this.toNativeArray(value as any, 'int');
-        }
         this._glCheckError('vertexAttribI4uiv');
-        this.native.vertexAttribI4uiv(index, value);
+        const vertexAttribI4uiv = this._getMethod('vertexAttribI4uiv');
+        vertexAttribI4uiv(index, value);
     }
 }
+(() => {
+    Helpers.initialize();
+    ctor = global.CanvasJSIModule.createWebGL2Context;
+})();
 //# sourceMappingURL=index.android.js.map