@nativescript/canvas 0.9.22-v6 → 1.0.0-alpha.10

package/WebGL/WebGLRenderingContext/index.android.js

@@ -1,48 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("./common");
-var WebGLShader_1 = require("../WebGLShader");
-var WebGLFramebuffer_1 = require("../WebGLFramebuffer");
-var WebGLTexture_1 = require("../WebGLTexture");
-var WebGLProgram_1 = require("../WebGLProgram");
-var WebGLUniformLocation_1 = require("../WebGLUniformLocation");
-var WebGLActiveInfo_1 = require("../WebGLActiveInfo");
-var WebGLRenderbuffer_1 = require("../WebGLRenderbuffer");
-var WebGLShaderPrecisionFormat_1 = require("../WebGLShaderPrecisionFormat");
-var WebGLBuffer_1 = require("../WebGLBuffer");
-var core_1 = require("@nativescript/core");
-var WebGLExtensions_1 = require("../WebGLExtensions");
-var ImageAsset_1 = require("../../ImageAsset");
-var Canvas_1 = require("../../Canvas");
-var WebGLRenderingContext = /** @class */ (function (_super) {
-    __extends(WebGLRenderingContext, _super);
-    function WebGLRenderingContext(context) {
-        var _this = _super.call(this, context) || this;
-        _this.context = context;
-        return _this;
-    }
-    Object.defineProperty(WebGLRenderingContext.prototype, "native", {
-        get: function () {
-            return this.context;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(WebGLRenderingContext.prototype, "drawingBufferHeight", {
-        get: function () {
-            return this.context.getDrawingBufferHeight();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(WebGLRenderingContext.prototype, "drawingBufferWidth", {
-        get: function () {
-            return this.context.getDrawingBufferWidth();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    WebGLRenderingContext.toPrimitive = function (value) {
+import { WebGLRenderingContextBase } from './common';
+import { WebGLShader } from '../WebGLShader';
+import { WebGLFramebuffer } from '../WebGLFramebuffer';
+import { WebGLTexture } from '../WebGLTexture';
+import { WebGLProgram } from '../WebGLProgram';
+import { WebGLUniformLocation } from '../WebGLUniformLocation';
+import { WebGLActiveInfo } from '../WebGLActiveInfo';
+import { WebGLRenderbuffer } from '../WebGLRenderbuffer';
+import { WebGLShaderPrecisionFormat } from '../WebGLShaderPrecisionFormat';
+import { WebGLBuffer } from '../WebGLBuffer';
+import { ImageSource } from '@nativescript/core';
+import { ANGLE_instanced_arrays, EXT_blend_minmax, EXT_color_buffer_half_float, EXT_disjoint_timer_query, EXT_shader_texture_lod, EXT_sRGB, EXT_texture_filter_anisotropic, OES_element_index_uint, OES_standard_derivatives, OES_texture_float, OES_texture_float_linear, OES_texture_half_float, OES_texture_half_float_linear, OES_vertex_array_object, WEBGL_color_buffer_float, WEBGL_compressed_texture_atc, WEBGL_compressed_texture_etc, WEBGL_compressed_texture_etc1, WEBGL_compressed_texture_pvrtc, WEBGL_compressed_texture_s3tc, WEBGL_depth_texture, WEBGL_draw_buffers, WEBGL_lose_context, } from '../WebGLExtensions';
+import { ImageAsset } from '../../ImageAsset';
+import { Canvas } from '../../Canvas';
+import { ImageBitmap } from '../../ImageBitmap';
+import { Utils } from '../../utils';
+export class WebGLRenderingContext extends WebGLRenderingContextBase {
+    constructor(context) {
+        super(context);
+        this._lastTexture = { target: 0, texture: 0 };
+        this.context = context;
+    }
+    get native() {
+        return this.context;
+    }
+    get drawingBufferHeight() {
+        return this.context.getDrawingBufferHeight();
+    }
+    get drawingBufferWidth() {
+        return this.context.getDrawingBufferWidth();
+    }
+    static toPrimitive(value) {
         if (value instanceof java.lang.Integer) {
             return value.intValue();
         }
@@ -68,89 +55,89 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             return value.doubleValue();
         }
         return value;
-    };
-    WebGLRenderingContext.prototype.getJSArray = function (value) {
-        var count = value.length;
-        var array = [];
-        for (var i = 0; i < count; i++) {
+    }
+    getJSArray(value) {
+        const count = value.length;
+        const array = [];
+        for (let i = 0; i < count; i++) {
             array.push(value[i]);
         }
         return array;
-    };
-    WebGLRenderingContext.prototype.activeTexture = function (texture) {
+    }
+    activeTexture(texture) {
         this._glCheckError('activeTexture');
         this._checkArgs('activeTexture', arguments);
         this.context.activeTexture(texture);
-    };
-    WebGLRenderingContext.prototype.attachShader = function (program, shader) {
+    }
+    attachShader(program, shader) {
         this._glCheckError('attachShader');
         this._checkArgs('attachShader', arguments);
-        var value = program ? program.native : 0;
-        var value2 = shader ? shader.native : 0;
+        const value = program ? program.native : 0;
+        const value2 = shader ? shader.native : 0;
         this.context.attachShader(value, value2);
-    };
-    WebGLRenderingContext.prototype.bindAttribLocation = function (program, index, name) {
+    }
+    bindAttribLocation(program, index, name) {
         this._glCheckError('bindAttribLocation');
         this._checkArgs('bindAttribLocation', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.bindAttribLocation(value, index, name);
-    };
-    WebGLRenderingContext.prototype.bindBuffer = function (target, buffer) {
+    }
+    bindBuffer(target, buffer) {
         this._glCheckError('bindBuffer');
         this._checkArgs('bindBuffer', arguments);
-        var value = buffer ? buffer.native : 0;
+        let value = buffer ? buffer.native : 0;
         this.context.bindBuffer(target, value);
-    };
-    WebGLRenderingContext.prototype.bindFramebuffer = function (target, framebuffer) {
+    }
+    bindFramebuffer(target, framebuffer) {
         this._glCheckError('bindFramebuffer');
         this._checkArgs('bindFramebuffer', arguments);
-        var value = framebuffer ? framebuffer.native : 0;
+        const value = framebuffer ? framebuffer.native : 0;
         this.context.bindFramebuffer(target, value);
-    };
-    WebGLRenderingContext.prototype.bindRenderbuffer = function (target, renderbuffer) {
+    }
+    bindRenderbuffer(target, renderbuffer) {
         this._glCheckError('bindRenderbuffer');
         this._checkArgs('bindRenderbuffer', arguments);
-        var value = renderbuffer ? renderbuffer.native : 0;
+        const value = renderbuffer ? renderbuffer.native : 0;
         this.context.bindRenderbuffer(target, value);
-    };
-    WebGLRenderingContext.prototype.bindTexture = function (target, texture) {
+    }
+    bindTexture(target, texture) {
         this._glCheckError('bindTexture');
         this._checkArgs('bindTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
+        if (value > 0) {
+            this._lastTexture = {
+                target,
+                texture: value,
+            };
+        }
         this.context.bindTexture(target, value);
-    };
-    WebGLRenderingContext.prototype.blendColor = function (red, green, blue, alpha) {
+    }
+    blendColor(red, green, blue, alpha) {
         this._glCheckError('blendColor');
         this._checkArgs('blendColor', arguments);
         this.context.blendColor(red, green, blue, alpha);
-    };
-    WebGLRenderingContext.prototype.blendEquationSeparate = function (modeRGB, modeAlpha) {
+    }
+    blendEquationSeparate(modeRGB, modeAlpha) {
         this._glCheckError('blendEquationSeparate');
         this._checkArgs('blendEquationSeparate', arguments);
         this.context.blendEquationSeparate(modeRGB, modeAlpha);
-    };
-    WebGLRenderingContext.prototype.blendEquation = function (mode) {
+    }
+    blendEquation(mode) {
         this._glCheckError('blendEquation');
         this._checkArgs('blendEquation', arguments);
         this.context.blendEquation(mode);
-    };
-    WebGLRenderingContext.prototype.blendFuncSeparate = function (srcRGB, dstRGB, srcAlpha, dstAlpha) {
-        if (srcRGB === void 0) { srcRGB = this.ONE; }
-        if (dstRGB === void 0) { dstRGB = this.ZERO; }
-        if (srcAlpha === void 0) { srcAlpha = this.ONE; }
-        if (dstAlpha === void 0) { dstAlpha = this.ZERO; }
+    }
+    blendFuncSeparate(srcRGB = this.ONE, dstRGB = this.ZERO, srcAlpha = this.ONE, dstAlpha = this.ZERO) {
         this._glCheckError('blendFuncSeparate');
         this._checkArgs('blendFuncSeparate', arguments);
         this.context.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-    };
-    WebGLRenderingContext.prototype.blendFunc = function (sfactor, dfactor) {
-        if (sfactor === void 0) { sfactor = this.ONE; }
-        if (dfactor === void 0) { dfactor = this.ZERO; }
+    }
+    blendFunc(sfactor = this.ONE, dfactor = this.ZERO) {
         this._glCheckError('blendFunc');
         this._checkArgs('blendFunc', arguments);
         this.context.blendFunc(sfactor, dfactor);
-    };
-    WebGLRenderingContext.prototype.toNativeArray = function (value, type) {
+    }
+    toNativeArray(value, type) {
         // if (value && value.length && typeof type === 'string') {
         //     const size = value.length;
         //     const nativeArray = Array.create(type, size);
@@ -159,16 +146,16 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
         //     }
         //     return nativeArray;
         // }
-        var length = 0;
-        if (value instanceof Int8Array || value instanceof Uint8Array || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array) {
+        let length = 0;
+        if (value instanceof Int8Array || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array) {
             length = value.length;
         }
         else if (Array.isArray(value)) {
             length = value.length;
         }
-        if (length && typeof type === 'string') {
-            var array = Array.from(value);
-            var nativeArray = void 0;
+        if (typeof type === 'string') {
+            const array = Array.from(value);
+            let nativeArray;
             switch (type) {
                 case 'byte':
                     nativeArray = java.nio.ByteBuffer.wrap(array).array();
@@ -195,426 +182,541 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             return nativeArray;
         }
         return [];
-    };
-    WebGLRenderingContext.prototype.bufferData = function (target, srcData, usage) {
+    }
+    get _isSupported() {
+        return Utils.IS_SUPPORTED_TYPED_ARRAYS_VERSION;
+    }
+    bufferData(target, srcData, usage) {
         this._glCheckError('bufferData');
         this._checkArgs('bufferData', arguments);
         if (typeof srcData === 'number') {
             this.context.bufferData(target, srcData, usage);
         }
         else if (srcData instanceof ArrayBuffer) {
-            this.context.bufferData(target, this.toNativeArray(new Uint8Array(srcData), 'byte'), usage);
-        }
-        else if (srcData && srcData.buffer instanceof ArrayBuffer) {
-            if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
-                this.context.bufferData(target, this.toNativeArray(srcData, 'byte'), usage);
+            // @ts-ignore
+            if (srcData.nativeObject) {
+                // @ts-ignore
+                this.context.bufferData(target, srcData.nativeObject, usage);
             }
-            else if (srcData instanceof Uint16Array || srcData instanceof Int16Array) {
-                this.context.bufferData(target, this.toNativeArray(srcData, 'short'), usage);
+            else {
+                if (this._isSupported) {
+                    this.context.bufferDataByteBuffer(target, srcData, usage);
+                }
+                else {
+                    this.context.bufferDataByte(target, Array.from(new Uint8Array(srcData)), usage);
+                }
             }
-            else if (srcData instanceof Uint32Array || srcData instanceof Int32Array) {
-                this.context.bufferData(target, this.toNativeArray(srcData, 'int'), usage);
+            //this.context.bufferData(target, this.toNativeArray(new Uint8Array(srcData as any) as any, 'byte'), usage);
+        }
+        else if (srcData && srcData.buffer instanceof ArrayBuffer) {
+            // @ts-ignore
+            if (srcData.buffer.nativeObject) {
+                // @ts-ignore
+                this.context.bufferData(target, offset, srcData.buffer.nativeObject);
             }
-            else if (srcData instanceof Float32Array) {
-                this.context.bufferData(target, this.toNativeArray(srcData, 'float'), usage);
+            else {
+                if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
+                    if (this._isSupported) {
+                        this.context.bufferDataByteBuffer(target, srcData, usage);
+                    }
+                    else {
+                        this.context.bufferDataByte(target, Array.from(srcData), usage);
+                    }
+                }
+                else if (srcData instanceof Uint16Array || srcData instanceof Int16Array) {
+                    if (this._isSupported) {
+                        this.context.bufferDataShortBuffer(target, srcData, usage);
+                    }
+                    else {
+                        this.context.bufferDataShort(target, Array.from(srcData), usage);
+                    }
+                }
+                else if (srcData instanceof Uint32Array || srcData instanceof Int32Array) {
+                    if (this._isSupported) {
+                        this.context.bufferDataIntBuffer(target, srcData, usage);
+                    }
+                    else {
+                        this.context.bufferDataInt(target, Array.from(srcData), usage);
+                    }
+                }
+                else if (srcData instanceof Float32Array) {
+                    if (this._isSupported) {
+                        this.context.bufferDataFloatBuffer(target, srcData, usage);
+                    }
+                    else {
+                        this.context.bufferDataFloat(target, Array.from(srcData), usage);
+                    }
+                }
             }
         }
         else if (arguments.length === 3 && !srcData) {
             this.context.bufferData(target, 0, usage);
         }
-    };
-    WebGLRenderingContext.prototype.bufferSubData = function (target, offset, srcData) {
+    }
+    bufferSubData(target, offset, srcData) {
         this._glCheckError('bufferSubData');
         this._checkArgs('bufferSubData', arguments);
         if (srcData instanceof ArrayBuffer) {
-            this.context.bufferSubData(target, offset, this.toNativeArray(new Uint8Array(srcData), 'byte'));
-        }
-        else if (srcData && srcData.buffer instanceof ArrayBuffer) {
-            if (srcData instanceof Uint8Array) {
-                this.context.bufferSubData(target, offset, this.toNativeArray(srcData, 'byte'));
+            //this.context.bufferSubData(target, offset, this.toNativeArray(new Uint8Array(srcData as any) as any, 'byte'));
+            // @ts-ignore
+            if (srcData.nativeObject) {
+                // @ts-ignore
+                this.context.bufferSubData(target, offset, srcData.nativeObject);
             }
-            else if (srcData instanceof Uint16Array || srcData instanceof Int16Array) {
-                this.context.bufferSubData(target, offset, this.toNativeArray(srcData, 'short'));
+            else {
+                if (this._isSupported) {
+                    this.context.bufferSubDataByteBuffer(target, offset, srcData);
+                }
+                else {
+                    this.context.bufferSubDataByte(target, offset, Array.from(new Uint8Array(srcData)));
+                }
             }
-            else if (srcData instanceof Uint32Array || srcData instanceof Int32Array) {
-                this.context.bufferSubData(target, offset, this.toNativeArray(srcData, 'int'));
+        }
+        else if (srcData && srcData.buffer instanceof ArrayBuffer) {
+            // @ts-ignore
+            if (srcData.buffer.nativeObject) {
+                // @ts-ignore
+                this.context.bufferSubData(target, offset, srcData.buffer.nativeObject);
             }
-            else if (srcData instanceof Float32Array) {
-                this.context.bufferSubData(target, offset, this.toNativeArray(srcData, 'float'));
+            else {
+                if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
+                    if (this._isSupported) {
+                        this.context.bufferSubDataByteBuffer(target, offset, srcData);
+                    }
+                    else {
+                        this.context.bufferSubDataByte(target, offset, Array.from(srcData));
+                    }
+                }
+                else if (srcData instanceof Uint16Array || srcData instanceof Int16Array) {
+                    if (this._isSupported) {
+                        this.context.bufferSubDataShortBuffer(target, offset, srcData);
+                    }
+                    else {
+                        this.context.bufferSubDataShort(target, offset, Array.from(srcData));
+                    }
+                }
+                else if (srcData instanceof Uint32Array || srcData instanceof Int32Array) {
+                    if (this._isSupported) {
+                        this.context.bufferSubDataIntBuffer(target, offset, srcData);
+                    }
+                    else {
+                        this.context.bufferSubDataInt(target, offset, Array.from(srcData));
+                    }
+                }
+                else if (srcData instanceof Float32Array) {
+                    if (this._isSupported) {
+                        this.context.bufferSubDataFloatBuffer(target, offset, srcData);
+                    }
+                    else {
+                        this.context.bufferSubDataFloat(target, offset, Array.from(srcData));
+                    }
+                }
             }
         }
-    };
-    WebGLRenderingContext.prototype.checkFramebufferStatus = function (target) {
+    }
+    checkFramebufferStatus(target) {
         this._glCheckError('checkFramebufferStatus');
         this._checkArgs('checkFramebufferStatus', arguments);
         return this.context.checkFramebufferStatus(target);
-    };
-    WebGLRenderingContext.prototype.clearColor = function (red, green, blue, alpha) {
+    }
+    clearColor(red, green, blue, alpha) {
         this._glCheckError('clearColor');
         this._checkArgs('clearColor', arguments);
         this.context.clearColor(red, green, blue, alpha);
-    };
-    WebGLRenderingContext.prototype.clearDepth = function (depth) {
+    }
+    clearDepth(depth) {
         this._glCheckError('clearDepth');
         this._checkArgs('clearDepth', arguments);
         this.context.clearDepth(depth);
-    };
-    WebGLRenderingContext.prototype.clearStencil = function (stencil) {
+    }
+    clearStencil(stencil) {
         this._glCheckError('clearStencil');
         this._checkArgs('clearStencil', arguments);
         this.context.clearStencil(stencil);
-    };
-    WebGLRenderingContext.prototype.clear = function (mask) {
+    }
+    clear(mask) {
         this._glCheckError('clear');
         this._checkArgs('clear', arguments);
         this.context.clear(mask);
-    };
-    WebGLRenderingContext.prototype.colorMask = function (red, green, blue, alpha) {
+    }
+    colorMask(red, green, blue, alpha) {
         this._glCheckError('colorMask');
         this._checkArgs('colorMask', arguments);
         this.context.colorMask(red, green, blue, alpha);
-    };
-    WebGLRenderingContext.prototype.commit = function () {
+    }
+    commit() {
         // NOOP
         this.context.commit();
-    };
-    WebGLRenderingContext.prototype.compileShader = function (shader) {
+    }
+    compileShader(shader) {
         this._glCheckError('compileShader');
         this._checkArgs('compileShader', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         this.context.compileShader(value);
-    };
-    WebGLRenderingContext.prototype.compressedTexImage2D = function (target, level, internalformat, width, height, border, pixels) {
+    }
+    compressedTexImage2D(target, level, internalformat, width, height, border, pixels) {
         this._glCheckError('compressedTexImage2D');
         this._checkArgs('compressedTexImage2D', arguments);
+        // @ts-ignore
         if (pixels && pixels.buffer instanceof ArrayBuffer) {
-            if (pixels instanceof Uint8Array) {
-                this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels, 'byte'));
-            }
-            else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
-                this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels, 'short'));
+            // @ts-ignore
+            if (pixels.buffer.nativeObject) {
+                // @ts-ignore
+                this.context.compressedTexImage2D(target, level, internalformat, width, height, border, pixels.buffer.nativeObject);
             }
-            else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
-                this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels, 'int'));
-            }
-            else if (pixels instanceof Float32Array) {
-                this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels, 'float'));
+            else {
+                if (pixels instanceof Uint8Array) {
+                    // this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels as any, 'byte'));
+                    this.context.compressedTexImage2DByte(target, level, internalformat, width, height, border, Array.from(pixels));
+                }
+                else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
+                    // this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels as any, 'short'));
+                    this.context.compressedTexImage2DShort(target, level, internalformat, width, height, border, Array.from(pixels));
+                }
+                else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
+                    // this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels as any, 'int'));
+                    this.context.compressedTexImage2DInt(target, level, internalformat, width, height, border, Array.from(pixels));
+                }
+                else if (pixels instanceof Float32Array) {
+                    // this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(pixels as any, 'float'));
+                    this.context.compressedTexImage2DFloat(target, level, internalformat, width, height, border, Array.from(pixels));
+                }
             }
         }
         else if (pixels instanceof ArrayBuffer) {
-            this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(new Uint8Array(pixels), 'byte'));
+            // this.context.compressedTexImage2D(target, level, internalformat, width, height, border, this.toNativeArray(new Uint8Array(pixels as any) as any, 'byte'));
+            // @ts-ignore
+            if (pixels.nativeObject) {
+                // @ts-ignore
+                this.context.compressedTexImage2D(target, level, internalformat, width, height, border, pixels.nativeObject);
+            }
+            else {
+                this.context.compressedTexImage2DByte(target, level, internalformat, width, height, border, Array.from(new Uint8Array(pixels)));
+            }
         }
-    };
-    WebGLRenderingContext.prototype.compressedTexSubImage2D = function (target, level, xoffset, yoffset, width, height, format, pixels) {
+    }
+    compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, pixels) {
         this._glCheckError('compressedTexSubImage2D');
         this._checkArgs('compressedTexSubImage2D', arguments);
         if (pixels && pixels.buffer instanceof ArrayBuffer) {
             if (pixels instanceof Uint8Array) {
-                this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels, 'byte'));
+                // this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels as any, 'byte'));
+                this.context.compressedTexSubImage2DByte(target, level, xoffset, yoffset, width, height, format, Array.from(pixels));
             }
             else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
-                this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels, 'short'));
+                // this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels as any, 'short'));
+                this.context.compressedTexSubImage2DShort(target, level, xoffset, yoffset, width, height, format, Array.from(pixels));
             }
             else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
-                this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels, 'int'));
+                // this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels as any, 'int'));
+                this.context.compressedTexSubImage2DInt(target, level, xoffset, yoffset, width, height, format, Array.from(pixels));
             }
             else if (pixels instanceof Float32Array) {
-                this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels, 'float'));
+                // this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(pixels as any, 'float'));
+                this.context.compressedTexSubImage2DFloat(target, level, xoffset, yoffset, width, height, format, Array.from(pixels));
             }
         }
         else if (pixels instanceof ArrayBuffer) {
-            this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(new Uint8Array(pixels), 'byte'));
+            // this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.toNativeArray(new Uint8Array(pixels as any) as any, 'byte'));
+            // @ts-ignore
+            if (pixels.nativeObject) {
+                // @ts-ignore
+                this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, pixels.nativeObject);
+            }
+            else {
+                this.context.compressedTexSubImage2DByte(target, level, xoffset, yoffset, width, height, format, Array.from(new Uint8Array(pixels)));
+            }
         }
-    };
-    WebGLRenderingContext.prototype.copyTexImage2D = function (target, level, internalformat, x, y, width, height, border) {
+    }
+    copyTexImage2D(target, level, internalformat, x, y, width, height, border) {
         this._glCheckError('copyTexImage2D');
         this._checkArgs('copyTexImage2D', arguments);
         this.context.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
-    };
-    WebGLRenderingContext.prototype.copyTexSubImage2D = function (target, level, xoffset, yoffset, x, y, width, height) {
+    }
+    copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) {
         this._glCheckError('copyTexSubImage2D');
         this._checkArgs('copyTexSubImage2D', arguments);
         this.context.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-    };
-    WebGLRenderingContext.prototype.createBuffer = function () {
+    }
+    createBuffer() {
         this._glCheckError('createBuffer');
         this._checkArgs('createBuffer', arguments);
-        var id = this.context.createBuffer();
-        return new WebGLBuffer_1.WebGLBuffer(id);
-    };
-    WebGLRenderingContext.prototype.createFramebuffer = function () {
+        const id = this.context.createBuffer();
+        return new WebGLBuffer(id);
+    }
+    createFramebuffer() {
         this._glCheckError('createFramebuffer');
         this._checkArgs('createFramebuffer', arguments);
-        return new WebGLFramebuffer_1.WebGLFramebuffer(this.context.createFramebuffer());
-    };
-    WebGLRenderingContext.prototype.createProgram = function () {
+        return new WebGLFramebuffer(this.context.createFramebuffer());
+    }
+    createProgram() {
         this._glCheckError('createProgram');
         this._checkArgs('createProgram', arguments);
-        return new WebGLProgram_1.WebGLProgram(this.context.createProgram());
-    };
-    WebGLRenderingContext.prototype.createRenderbuffer = function () {
+        return new WebGLProgram(this.context.createProgram());
+    }
+    createRenderbuffer() {
         this._glCheckError('createRenderbuffer');
         this._checkArgs('createRenderbuffer', arguments);
-        return new WebGLRenderbuffer_1.WebGLRenderbuffer(this.context.createRenderbuffer());
-    };
-    WebGLRenderingContext.prototype.createShader = function (type) {
+        return new WebGLRenderbuffer(this.context.createRenderbuffer());
+    }
+    createShader(type) {
         this._glCheckError('createShader');
         this._checkArgs('createShader', arguments);
-        return new WebGLShader_1.WebGLShader(this.context.createShader(type));
-    };
-    WebGLRenderingContext.prototype.createTexture = function () {
+        return new WebGLShader(this.context.createShader(type));
+    }
+    createTexture() {
         this._glCheckError('createTexture');
         this._checkArgs('createTexture', arguments);
-        return new WebGLTexture_1.WebGLTexture(this.context.createTexture());
-    };
-    WebGLRenderingContext.prototype.cullFace = function (mode) {
+        return new WebGLTexture(this.context.createTexture());
+    }
+    cullFace(mode) {
         this._glCheckError('cullFace');
         this._checkArgs('cullFace', arguments);
         this.context.cullFace(mode);
-    };
-    WebGLRenderingContext.prototype.deleteBuffer = function (buffer) {
+    }
+    deleteBuffer(buffer) {
         this._glCheckError('deleteBuffer');
         this._checkArgs('deleteBuffer', arguments);
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         this.context.deleteBuffer(value);
-    };
-    WebGLRenderingContext.prototype.deleteFramebuffer = function (frameBuffer) {
+    }
+    deleteFramebuffer(frameBuffer) {
         this._glCheckError('deleteFramebuffer');
         this._checkArgs('deleteFramebuffer', arguments);
-        var value = frameBuffer ? frameBuffer.native : 0;
+        const value = frameBuffer ? frameBuffer.native : 0;
         this.context.deleteFramebuffer(value);
-    };
-    WebGLRenderingContext.prototype.deleteProgram = function (program) {
+    }
+    deleteProgram(program) {
         this._glCheckError('deleteProgram');
         this._checkArgs('deleteProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.deleteProgram(value);
-    };
-    WebGLRenderingContext.prototype.deleteRenderbuffer = function (renderBuffer) {
+    }
+    deleteRenderbuffer(renderBuffer) {
         this._glCheckError('deleteRenderbuffer');
         this._checkArgs('deleteRenderbuffer', arguments);
-        var value = renderBuffer ? renderBuffer.native : 0;
+        const value = renderBuffer ? renderBuffer.native : 0;
         this.context.deleteRenderbuffer(value);
-    };
-    WebGLRenderingContext.prototype.deleteShader = function (shader) {
+    }
+    deleteShader(shader) {
         this._glCheckError('deleteShader');
         this._checkArgs('deleteShader', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         this.context.deleteShader(value);
-    };
-    WebGLRenderingContext.prototype.deleteTexture = function (texture) {
+    }
+    deleteTexture(texture) {
         this._glCheckError('deleteTexture');
         this._checkArgs('deleteTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         this.context.deleteTexture(value);
-    };
-    WebGLRenderingContext.prototype.depthFunc = function (func) {
+    }
+    depthFunc(func) {
         this._glCheckError('depthFunc');
         this._checkArgs('depthFunc', arguments);
         this.context.depthFunc(func);
-    };
-    WebGLRenderingContext.prototype.depthMask = function (flag) {
+    }
+    depthMask(flag) {
         this._glCheckError('depthMask');
         this._checkArgs('depthMask', arguments);
         this.context.depthMask(flag);
-    };
-    WebGLRenderingContext.prototype.depthRange = function (zNear, zFar) {
+    }
+    depthRange(zNear, zFar) {
         this._glCheckError('depthRange');
         this._checkArgs('depthRange', arguments);
         this.context.depthRange(zNear, zFar);
-    };
-    WebGLRenderingContext.prototype.detachShader = function (program, shader) {
+    }
+    detachShader(program, shader) {
         this._glCheckError('detachShader');
         this._checkArgs('detachShader', arguments);
-        var value = program ? program.native : 0;
-        var value2 = shader ? shader.native : 0;
+        const value = program ? program.native : 0;
+        const value2 = shader ? shader.native : 0;
         this.context.detachShader(value, value2);
-    };
-    WebGLRenderingContext.prototype.disableVertexAttribArray = function (index) {
+    }
+    disableVertexAttribArray(index) {
         this._glCheckError('disableVertexAttribArray');
         this._checkArgs('disableVertexAttribArray', arguments);
         this.context.disableVertexAttribArray(index);
-    };
-    WebGLRenderingContext.prototype.disable = function (cap) {
+    }
+    disable(cap) {
         this._glCheckError('disable');
         this._checkArgs('disable', arguments);
         this.context.disable(cap);
-    };
-    WebGLRenderingContext.prototype.drawArrays = function (mode, first, count) {
+    }
+    drawArrays(mode, first, count) {
         this._glCheckError('drawArrays');
         this._checkArgs('drawArrays', arguments);
         this.context.drawArrays(mode, first, count);
-    };
-    WebGLRenderingContext.prototype.drawElements = function (mode, count, type, offset) {
+    }
+    drawElements(mode, count, type, offset) {
         this._glCheckError('drawElements');
         this._checkArgs('drawElements', arguments);
         this.context.drawElements(mode, count, type, offset);
-    };
-    WebGLRenderingContext.prototype.enableVertexAttribArray = function (index) {
+    }
+    enableVertexAttribArray(index) {
         this._glCheckError('enableVertexAttribArray');
         this._checkArgs('enableVertexAttribArray', arguments);
         this.context.enableVertexAttribArray(index);
-    };
-    WebGLRenderingContext.prototype.enable = function (cap) {
+    }
+    enable(cap) {
         this._glCheckError('enable');
         this._checkArgs('enable', arguments);
         this.context.enable(cap);
-    };
-    WebGLRenderingContext.prototype.finish = function () {
+    }
+    finish() {
         this._glCheckError('finish');
         this.context.finish();
-    };
-    WebGLRenderingContext.prototype.flush = function () {
+    }
+    flush() {
         this._glCheckError('flush');
         this.context.flush();
-    };
-    WebGLRenderingContext.prototype.framebufferRenderbuffer = function (target, attachment, renderbuffertarget, renderbuffer) {
+    }
+    framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
         this._glCheckError('framebufferRenderbuffer');
         this._checkArgs('framebufferRenderbuffer', arguments);
-        var value = renderbuffer ? renderbuffer.native : 0;
+        const value = renderbuffer ? renderbuffer.native : 0;
         this.context.framebufferRenderbuffer(target, attachment, renderbuffertarget, value);
-    };
-    WebGLRenderingContext.prototype.framebufferTexture2D = function (target, attachment, textarget, texture, level) {
+    }
+    framebufferTexture2D(target, attachment, textarget, texture, level) {
         this._glCheckError('framebufferTexture2D');
         this._checkArgs('activeTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         this.context.framebufferTexture2D(target, attachment, textarget, value, level);
-    };
-    WebGLRenderingContext.prototype.frontFace = function (mode) {
+    }
+    frontFace(mode) {
         this._checkArgs('activeTexture', arguments);
         this._glCheckError('activeTexture');
         this.context.frontFace(mode);
-    };
-    WebGLRenderingContext.prototype.generateMipmap = function (target) {
+    }
+    generateMipmap(target) {
         this._checkArgs('activeTexture', arguments);
         this._glCheckError('activeTexture');
         this.context.generateMipmap(target);
-    };
-    WebGLRenderingContext.prototype.getActiveAttrib = function (program, index) {
+    }
+    getActiveAttrib(program, index) {
         this._glCheckError('getActiveAttrib');
         this._checkArgs('getActiveAttrib', arguments);
-        var value = program ? program.native : 0;
-        var attrib = this.context.getActiveAttrib(value, index);
-        return new WebGLActiveInfo_1.WebGLActiveInfo(attrib.getName(), attrib.getSize(), attrib.getType());
-    };
-    WebGLRenderingContext.prototype.getActiveUniform = function (program, index) {
+        const value = program ? program.native : 0;
+        const attrib = this.context.getActiveAttrib(value, index);
+        return new WebGLActiveInfo(attrib.getName(), attrib.getSize(), attrib.getType());
+    }
+    getActiveUniform(program, index) {
         this._glCheckError('getActiveUniform');
         this._checkArgs('getActiveUniform', arguments);
-        var value = program ? program.native : 0;
-        var uniform = this.context.getActiveUniform(value, index);
-        return new WebGLActiveInfo_1.WebGLActiveInfo(uniform.getName(), uniform.getSize(), uniform.getType());
-    };
-    WebGLRenderingContext.prototype.getAttachedShaders = function (program) {
+        const value = program ? program.native : 0;
+        const uniform = this.context.getActiveUniform(value, index);
+        return new WebGLActiveInfo(uniform.getName(), uniform.getSize(), uniform.getType());
+    }
+    getAttachedShaders(program) {
         this._glCheckError('getAttachedShaders');
         this._checkArgs('getAttachedShaders', arguments);
-        var value = program ? program.native : 0;
-        return this.getJSArray(this.context.getAttachedShaders(value)).map(function (shader) { return new WebGLShader_1.WebGLShader(shader); });
-    };
-    WebGLRenderingContext.prototype.getAttribLocation = function (program, name) {
+        const value = program ? program.native : 0;
+        return this.getJSArray(this.context.getAttachedShaders(value)).map((shader) => new WebGLShader(shader));
+    }
+    getAttribLocation(program, name) {
         this._glCheckError('getAttribLocation');
         this._checkArgs('getAttribLocation', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.getAttribLocation(value, name);
-    };
-    WebGLRenderingContext.prototype.getBufferParameter = function (target, pname) {
+    }
+    getBufferParameter(target, pname) {
         this._glCheckError('getBufferParameter');
         this._checkArgs('getBufferParameter', arguments);
         return this.context.getBufferParameter(target, pname);
-    };
-    WebGLRenderingContext.prototype.getContextAttributes = function () {
-        var attributes = this.context.getContextAttributes();
+    }
+    getContextAttributes() {
+        const attributes = this.context.getContextAttributes();
         if (!attributes) {
             return null;
         }
-        var keys = attributes.keySet().toArray();
-        var length = keys.length;
-        var contextAttributes = {};
-        for (var i = 0; i < length; i++) {
-            var key = keys[i];
+        const keys = attributes.keySet().toArray();
+        const length = keys.length;
+        const contextAttributes = {};
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
             contextAttributes[key] = attributes.get(key);
         }
         return contextAttributes;
-    };
-    WebGLRenderingContext.prototype.getError = function () {
+    }
+    getError() {
         return this.context.getError();
-    };
-    WebGLRenderingContext.prototype.getExtension = function (name) {
+    }
+    getExtension(name) {
         this._glCheckError('getExtension');
         this._checkArgs('getExtension', arguments);
         if (name === 'EXT_disjoint_timer_query_webgl2') {
             return null;
         }
-        var ext = this.context.getExtension(name);
+        const ext = this.context.getExtension(name);
         if (ext) {
-            var clazz = ext && ext.getClass();
-            var classObjName = clazz && clazz.getName();
+            const clazz = ext && ext.getClass();
+            const classObjName = clazz && clazz.getName();
             switch (classObjName) {
                 case 'org.nativescript.canvas.extensions.ANGLE_instanced_arrays':
-                    return new WebGLExtensions_1.ANGLE_instanced_arrays(ext);
+                    return new ANGLE_instanced_arrays(ext);
                 case 'org.nativescript.canvas.extensions.EXT_blend_minmax':
-                    return new WebGLExtensions_1.EXT_blend_minmax(ext);
+                    return new EXT_blend_minmax(ext);
                 case 'org.nativescript.canvas.extensions.EXT_color_buffer_half_float':
-                    return new WebGLExtensions_1.EXT_color_buffer_half_float(ext);
+                    return new EXT_color_buffer_half_float(ext);
                 case 'org.nativescript.canvas.extensions.EXT_disjoint_timer_query':
-                    return new WebGLExtensions_1.EXT_disjoint_timer_query(ext);
+                    return new EXT_disjoint_timer_query(ext);
                 case 'org.nativescript.canvas.extensions.EXT_sRGB':
-                    return new WebGLExtensions_1.EXT_sRGB(ext);
+                    return new EXT_sRGB(ext);
                 case 'org.nativescript.canvas.extensions.EXT_shader_texture_lod':
-                    return new WebGLExtensions_1.EXT_shader_texture_lod(ext);
+                    return new EXT_shader_texture_lod(ext);
                 case 'org.nativescript.canvas.extensions.EXT_texture_filter_anisotropic':
-                    return new WebGLExtensions_1.EXT_texture_filter_anisotropic(ext);
+                    return new EXT_texture_filter_anisotropic(ext);
                 case 'org.nativescript.canvas.extensions.OES_element_index_uint':
-                    return new WebGLExtensions_1.OES_element_index_uint(ext);
+                    return new OES_element_index_uint(ext);
                 case 'org.nativescript.canvas.extensions.OES_standard_derivatives':
-                    return new WebGLExtensions_1.OES_standard_derivatives(ext);
+                    return new OES_standard_derivatives(ext);
                 case 'org.nativescript.canvas.extensions.OES_texture_float':
-                    return new WebGLExtensions_1.OES_texture_float(ext);
+                    return new OES_texture_float(ext);
                 case 'org.nativescript.canvas.extensions.OES_texture_float_linear':
-                    return new WebGLExtensions_1.OES_texture_float_linear(ext);
+                    return new OES_texture_float_linear(ext);
                 case 'org.nativescript.canvas.extensions.OES_texture_half_float':
-                    return new WebGLExtensions_1.OES_texture_half_float(ext);
+                    return new OES_texture_half_float(ext);
                 case 'org.nativescript.canvas.extensions.OES_texture_half_float_linear':
-                    return new WebGLExtensions_1.OES_texture_half_float_linear(ext);
+                    return new OES_texture_half_float_linear(ext);
                 case 'org.nativescript.canvas.extensions.OES_vertex_array_object':
-                    return new WebGLExtensions_1.OES_vertex_array_object(ext);
+                    return new OES_vertex_array_object(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_color_buffer_float':
-                    return new WebGLExtensions_1.WEBGL_color_buffer_float(ext);
+                    return new WEBGL_color_buffer_float(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_compressed_texture_atc':
-                    return new WebGLExtensions_1.WEBGL_compressed_texture_atc(ext);
+                    return new WEBGL_compressed_texture_atc(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_compressed_texture_etc':
-                    return new WebGLExtensions_1.WEBGL_compressed_texture_etc(ext);
+                    return new WEBGL_compressed_texture_etc(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_compressed_texture_etc1':
-                    return new WebGLExtensions_1.WEBGL_compressed_texture_etc1(ext);
+                    return new WEBGL_compressed_texture_etc1(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_compressed_texture_pvrtc':
-                    return new WebGLExtensions_1.WEBGL_compressed_texture_pvrtc(ext);
+                    return new WEBGL_compressed_texture_pvrtc(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_compressed_texture_s3tc':
-                    return new WebGLExtensions_1.WEBGL_compressed_texture_s3tc(ext);
+                    return new WEBGL_compressed_texture_s3tc(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_lose_context':
-                    return new WebGLExtensions_1.WEBGL_lose_context(ext);
+                    return new WEBGL_lose_context(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_depth_texture':
-                    return new WebGLExtensions_1.WEBGL_depth_texture(ext);
+                    return new WEBGL_depth_texture(ext);
                 case 'org.nativescript.canvas.extensions.WEBGL_draw_buffers':
-                    return new WebGLExtensions_1.WEBGL_draw_buffers(ext);
+                    return new WEBGL_draw_buffers(ext);
             }
         }
         return null;
-    };
-    WebGLRenderingContext.prototype.getFramebufferAttachmentParameter = function (target, attachment, pname) {
+    }
+    getFramebufferAttachmentParameter(target, attachment, pname) {
         this._glCheckError('getFramebufferAttachmentParameter');
         this._checkArgs('getFramebufferAttachmentParameter', arguments);
-        var param = this.context.getFramebufferAttachmentParameter(target, attachment, pname);
+        const param = this.context.getFramebufferAttachmentParameter(target, attachment, pname);
         if (param.isRenderbuffer()) {
-            return new WebGLRenderbuffer_1.WebGLRenderbuffer(param.getValue());
+            return new WebGLRenderbuffer(param.getValue());
         }
         else if (param.isTexture()) {
-            return new WebGLTexture_1.WebGLTexture(param.getValue());
+            return new WebGLTexture(param.getValue());
         }
         return WebGLRenderingContext.toPrimitive(param.getValue());
-    };
-    WebGLRenderingContext.prototype.getParameter = function (pname) {
+    }
+    getParameter(pname) {
         this._glCheckError('getParameter');
         this._checkArgs('activeTexture', arguments);
-        var value = this.context.getParameter(pname);
+        const value = this.context.getParameter(pname);
         switch (pname) {
             case this.COLOR_WRITEMASK:
             case this.COLOR_CLEAR_VALUE:
@@ -625,16 +727,25 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
                 return new Float32Array(this.getJSArray(value));
             case this.ARRAY_BUFFER_BINDING:
             case this.ELEMENT_ARRAY_BUFFER_BINDING:
-                return new WebGLBuffer_1.WebGLBuffer(WebGLRenderingContext.toPrimitive(value));
+                if (value) {
+                    new WebGLBuffer(WebGLRenderingContext.toPrimitive(value));
+                }
+                return null;
             case this.CURRENT_PROGRAM:
-                return new WebGLProgram_1.WebGLProgram(WebGLRenderingContext.toPrimitive(value));
+                if (value) {
+                    return new WebGLProgram(WebGLRenderingContext.toPrimitive(value));
+                }
+                return null;
             case this.COMPRESSED_TEXTURE_FORMATS:
                 return new Uint32Array(this.getJSArray(value));
             case this.RENDERBUFFER_BINDING:
-                return new WebGLRenderbuffer_1.WebGLRenderbuffer(WebGLRenderingContext.toPrimitive(value));
+                if (value) {
+                    return new WebGLRenderbuffer(WebGLRenderingContext.toPrimitive(value));
+                }
+                return null;
             case this.FRAMEBUFFER_BINDING:
                 if (value) {
-                    return new WebGLFramebuffer_1.WebGLFramebuffer(WebGLRenderingContext.toPrimitive(value));
+                    return new WebGLFramebuffer(WebGLRenderingContext.toPrimitive(value));
                 }
                 return null;
             case this.VIEWPORT:
@@ -644,7 +755,7 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             case this.TEXTURE_BINDING_CUBE_MAP:
             case this.TEXTURE_BINDING_2D:
                 if (value) {
-                    return new WebGLTexture_1.WebGLTexture(WebGLRenderingContext.toPrimitive(value));
+                    return new WebGLTexture(WebGLRenderingContext.toPrimitive(value));
                 }
                 return null;
             case this.VERSION:
@@ -657,156 +768,156 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             default:
                 return WebGLRenderingContext.toPrimitive(value);
         }
-    };
-    WebGLRenderingContext.prototype.getProgramInfoLog = function (program) {
+    }
+    getProgramInfoLog(program) {
         this._glCheckError('getProgramInfoLog');
         this._checkArgs('getProgramInfoLog', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.getProgramInfoLog(value);
-    };
-    WebGLRenderingContext.prototype.getProgramParameter = function (program, pname) {
+    }
+    getProgramParameter(program, pname) {
         this._glCheckError('getProgramParameter');
         this._checkArgs('getProgramParameter', arguments);
-        var value = program ? program.native : 0;
-        var result = this.context.getProgramParameter(value, pname);
+        const value = program ? program.native : 0;
+        const result = this.context.getProgramParameter(value, pname);
         return WebGLRenderingContext.toPrimitive(result);
-    };
-    WebGLRenderingContext.prototype.getRenderbufferParameter = function (target, pname) {
+    }
+    getRenderbufferParameter(target, pname) {
         this._glCheckError('getRenderbufferParameter');
         this._checkArgs('getRenderbufferParameter', arguments);
         return this.context.getRenderbufferParameter(target, pname);
-    };
-    WebGLRenderingContext.prototype.getShaderInfoLog = function (shader) {
+    }
+    getShaderInfoLog(shader) {
         this._glCheckError('getShaderInfoLog');
         this._checkArgs('getShaderInfoLog', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.getShaderInfoLog(value);
-    };
-    WebGLRenderingContext.prototype.getShaderParameter = function (shader, pname) {
+    }
+    getShaderParameter(shader, pname) {
         this._glCheckError('getShaderParameter');
         this._checkArgs('getShaderParameter', arguments);
-        var value = shader ? shader.native : 0;
-        var result = this.context.getShaderParameter(value, pname);
+        const value = shader ? shader.native : 0;
+        const result = this.context.getShaderParameter(value, pname);
         return WebGLRenderingContext.toPrimitive(result);
-    };
-    WebGLRenderingContext.prototype.getShaderPrecisionFormat = function (shaderType, precisionType) {
+    }
+    getShaderPrecisionFormat(shaderType, precisionType) {
         this._glCheckError('getShaderPrecisionFormat');
         this._checkArgs('getShaderPrecisionFormat', arguments);
-        var precision = this.context.getShaderPrecisionFormat(shaderType, precisionType);
-        return new WebGLShaderPrecisionFormat_1.WebGLShaderPrecisionFormat(precision.getRangeMin(), precision.getRangeMax(), precision.getPrecision());
-    };
-    WebGLRenderingContext.prototype.getShaderSource = function (shader) {
+        const precision = this.context.getShaderPrecisionFormat(shaderType, precisionType);
+        return new WebGLShaderPrecisionFormat(precision.getRangeMin(), precision.getRangeMax(), precision.getPrecision());
+    }
+    getShaderSource(shader) {
         this._glCheckError('getShaderSource');
         this._checkArgs('getShaderSource', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.getShaderSource(value);
-    };
-    WebGLRenderingContext.prototype.getSupportedExtensions = function () {
+    }
+    getSupportedExtensions() {
         this._glCheckError('getSupportedExtensions');
         return this.getJSArray(this.context.getSupportedExtensions());
-    };
-    WebGLRenderingContext.prototype.getTexParameter = function (target, pname) {
+    }
+    getTexParameter(target, pname) {
         this._glCheckError('getTexParameter');
         this._checkArgs('getTexParameter', arguments);
         return this.context.getTexParameter(target, pname);
-    };
-    WebGLRenderingContext.prototype.getUniformLocation = function (program, name) {
+    }
+    getUniformLocation(program, name) {
         this._glCheckError('getUniformLocation');
         this._checkArgs('getUniformLocation', arguments);
-        var value = program ? program.native : 0;
-        var id = this.context.getUniformLocation(value, name);
+        const value = program ? program.native : 0;
+        const id = this.context.getUniformLocation(value, name);
         if (id === -1) {
             return null;
         }
-        return new WebGLUniformLocation_1.WebGLUniformLocation(id);
-    };
-    WebGLRenderingContext.prototype.getUniform = function (program, location) {
+        return new WebGLUniformLocation(id);
+    }
+    getUniform(program, location) {
         this._glCheckError('getUniform');
         this._checkArgs('getUniform', arguments);
-        var value = program ? program.native : 0;
-        var value2 = location ? location.native : 0;
-        var uniform = this.context.getUniform(value, value2);
+        const value = program ? program.native : 0;
+        const value2 = location ? location.native : 0;
+        const uniform = this.context.getUniform(value, value2);
         if (uniform && uniform.length) {
             return this.getJSArray(uniform);
         }
         return WebGLRenderingContext.toPrimitive(uniform);
-    };
-    WebGLRenderingContext.prototype.getVertexAttribOffset = function (index, pname) {
+    }
+    getVertexAttribOffset(index, pname) {
         this._glCheckError('getVertexAttribOffset');
         this._checkArgs('getVertexAttribOffset', arguments);
         return this.context.getVertexAttribOffset(index, pname);
-    };
-    WebGLRenderingContext.prototype.getVertexAttrib = function (index, pname) {
+    }
+    getVertexAttrib(index, pname) {
         this._glCheckError('getVertexAttrib');
         this._checkArgs('getVertexAttrib', arguments);
-        var value = this.context.getVertexAttrib(index, pname);
+        const value = this.context.getVertexAttrib(index, pname);
         if (pname === this.CURRENT_VERTEX_ATTRIB) {
             return new Float32Array(this.getJSArray(value));
         }
         return WebGLRenderingContext.toPrimitive(value);
-    };
-    WebGLRenderingContext.prototype.hint = function (target, mode) {
+    }
+    hint(target, mode) {
         this._glCheckError('hint');
         this._checkArgs('hint', arguments);
         this.context.hint(target, mode);
-    };
-    WebGLRenderingContext.prototype.isBuffer = function (buffer) {
+    }
+    isBuffer(buffer) {
         this._glCheckError('isBuffer');
         this._checkArgs('isBuffer', arguments);
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         return this.context.isBuffer(value);
-    };
-    WebGLRenderingContext.prototype.isContextLost = function () {
+    }
+    isContextLost() {
         this._glCheckError('isContextLost');
         return this.context.isContextLost();
-    };
-    WebGLRenderingContext.prototype.isEnabled = function (cap) {
+    }
+    isEnabled(cap) {
         this._glCheckError('isEnabled');
         this._checkArgs('isEnabled', arguments);
         return this.context.isEnabled(cap);
-    };
-    WebGLRenderingContext.prototype.isFramebuffer = function (framebuffer) {
+    }
+    isFramebuffer(framebuffer) {
         this._glCheckError('isFramebuffer');
         this._checkArgs('isFramebuffer', arguments);
-        var value = framebuffer ? framebuffer.native : 0;
+        const value = framebuffer ? framebuffer.native : 0;
         return this.context.isFramebuffer(value);
-    };
-    WebGLRenderingContext.prototype.isProgram = function (program) {
+    }
+    isProgram(program) {
         this._glCheckError('isProgram');
         this._checkArgs('isProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.isProgram(value);
-    };
-    WebGLRenderingContext.prototype.isRenderbuffer = function (renderbuffer) {
+    }
+    isRenderbuffer(renderbuffer) {
         this._glCheckError('isRenderbuffer');
         this._checkArgs('isRenderbuffer', arguments);
-        var value = renderbuffer ? renderbuffer.native : 0;
+        const value = renderbuffer ? renderbuffer.native : 0;
         return this.context.isRenderbuffer(value);
-    };
-    WebGLRenderingContext.prototype.isShader = function (shader) {
+    }
+    isShader(shader) {
         this._glCheckError('isShader');
         this._checkArgs('isShader', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.isShader(value);
-    };
-    WebGLRenderingContext.prototype.isTexture = function (texture) {
+    }
+    isTexture(texture) {
         this._glCheckError('isTexture');
         this._checkArgs('isTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         return this.context.isTexture(value);
-    };
-    WebGLRenderingContext.prototype.lineWidth = function (width) {
+    }
+    lineWidth(width) {
         this._glCheckError('lineWidth');
         this._checkArgs('lineWidth', arguments);
         this.context.lineWidth(width);
-    };
-    WebGLRenderingContext.prototype.linkProgram = function (program) {
+    }
+    linkProgram(program) {
         this._glCheckError('linkProgram');
         this._checkArgs('linkProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.linkProgram(value);
-    };
-    WebGLRenderingContext.prototype.pixelStorei = function (pname, param) {
+    }
+    pixelStorei(pname, param) {
         this._glCheckError('pixelStorei');
         this._checkArgs('pixelStorei', arguments);
         if (pname === this.UNPACK_FLIP_Y_WEBGL || pname === this.UNPACK_PREMULTIPLY_ALPHA_WEBGL) {
@@ -824,34 +935,74 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
         else {
             this.context.pixelStorei(pname, param);
         }
-    };
-    WebGLRenderingContext.prototype.polygonOffset = function (factor, units) {
+    }
+    polygonOffset(factor, units) {
         this._glCheckError('polygonOffset');
         this._checkArgs('polygonOffset', arguments);
         this.context.polygonOffset(factor, units);
-    };
-    WebGLRenderingContext.prototype.readPixels = function (x, y, width, height, format, type, pixels) {
+    }
+    readPixels(x, y, width, height, format, type, pixels) {
         this._glCheckError('readPixels');
         this._checkArgs('readPixels', arguments);
+        // @ts-ignore
         if (pixels && pixels.buffer instanceof ArrayBuffer) {
-            if (pixels instanceof Uint8Array) {
-                this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels, 'byte'));
-            }
-            else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
-                this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels, 'short'));
+            // @ts-ignore
+            if (pixels.buffer.nativeObject) {
+                // @ts-ignore
+                this.context.readPixels(x, y, width, height, format, type, pixels.buffer.nativeObject);
             }
-            else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
-                this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels, 'int'));
-            }
-            else if (pixels instanceof Float32Array) {
-                this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels, 'float'));
+            else {
+                if (pixels instanceof Uint8Array) {
+                    if (this._isSupported) {
+                        this.context.readPixelsByteBuffer(x, y, width, height, format, type, pixels);
+                    }
+                    else {
+                        this.context.readPixelsByte(x, y, width, height, format, type, Array.from(pixels));
+                    }
+                }
+                else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
+                    if (this._isSupported) {
+                        this.context.readPixelsShortBuffer(x, y, width, height, format, type, pixels);
+                    }
+                    else {
+                        this.context.readPixelsShort(x, y, width, height, format, type, Array.from(pixels));
+                    }
+                }
+                else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
+                    if (this._isSupported) {
+                        this.context.readPixelsIntBuffer(x, y, width, height, format, type, pixels);
+                    }
+                    else {
+                        this.context.readPixelsInt(x, y, width, height, format, type, Array.from(pixels));
+                    }
+                }
+                else if (pixels instanceof Float32Array) {
+                    if (this._isSupported) {
+                        this.context.readPixelsFloatBuffer(x, y, width, height, format, type, pixels);
+                    }
+                    else {
+                        this.context.readPixelsFloat(x, y, width, height, format, type, Array.from(pixels));
+                    }
+                }
             }
         }
         else if (pixels instanceof ArrayBuffer) {
-            this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(new Uint8Array(pixels), 'byte'));
+            // @ts-ignore
+            if (pixels.nativeObject) {
+                // @ts-ignore
+                this.context.readPixels(x, y, width, height, format, type, pixels.nativeObject);
+            }
+            else {
+                if (this._isSupported) {
+                    this.context.readPixelsByteBuffer(x, y, width, height, format, type, pixels);
+                }
+                else {
+                    this.context.readPixelsByte(x, y, width, height, format, type, Array.from(new Uint8Array(pixels)));
+                }
+            }
         }
-    };
-    WebGLRenderingContext.prototype.renderbufferStorage = function (target, internalFormat, width, height) {
+    }
+    renderbufferStorage(target, internalFormat, width, height) {
         this._glCheckError('renderbufferStorage');
         this._checkArgs('renderbufferStorage', arguments);
         if (internalFormat === this.DEPTH_STENCIL) {
@@ -860,73 +1011,95 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             internalFormat = 0x88f0;
         }
         this.context.renderbufferStorage(target, internalFormat, width, height);
-    };
-    WebGLRenderingContext.prototype.sampleCoverage = function (value, invert) {
+    }
+    sampleCoverage(value, invert) {
         this._glCheckError('sampleCoverage');
         this._checkArgs('sampleCoverage', arguments);
         this.context.sampleCoverage(value, invert);
-    };
-    WebGLRenderingContext.prototype.scissor = function (x, y, width, height) {
+    }
+    scissor(x, y, width, height) {
         this._glCheckError('scissor');
         this._checkArgs('scissor', arguments);
         this.context.scissor(x, y, width, height);
-    };
-    WebGLRenderingContext.prototype.shaderSource = function (shader, source) {
+    }
+    shaderSource(shader, source) {
         this._glCheckError('shaderSource');
         this._checkArgs('shaderSource', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         this.context.shaderSource(value, source);
-    };
-    WebGLRenderingContext.prototype.stencilFuncSeparate = function (face, func, ref, mask) {
+    }
+    stencilFuncSeparate(face, func, ref, mask) {
         this._glCheckError('stencilFuncSeparate');
         this._checkArgs('stencilFuncSeparate', arguments);
         this.context.stencilFuncSeparate(face, func, ref, mask);
-    };
-    WebGLRenderingContext.prototype.stencilFunc = function (func, ref, mask) {
+    }
+    stencilFunc(func, ref, mask) {
         this._glCheckError('stencilFunc');
         this._checkArgs('stencilFunc', arguments);
         this.context.stencilFunc(func, ref, mask);
-    };
-    WebGLRenderingContext.prototype.stencilMaskSeparate = function (face, mask) {
+    }
+    stencilMaskSeparate(face, mask) {
         this._glCheckError('stencilMaskSeparate');
         this._checkArgs('stencilMaskSeparate', arguments);
         this.context.stencilMaskSeparate(face, mask);
-    };
-    WebGLRenderingContext.prototype.stencilMask = function (mask) {
+    }
+    stencilMask(mask) {
         this._glCheckError('stencilMask');
         this._checkArgs('stencilMask', arguments);
         this.context.stencilMask(mask);
-    };
-    WebGLRenderingContext.prototype.stencilOpSeparate = function (face, fail, zfail, zpass) {
+    }
+    stencilOpSeparate(face, fail, zfail, zpass) {
         this._glCheckError('stencilOpSeparate');
         this._checkArgs('stencilOpSeparate', arguments);
         this.context.stencilOpSeparate(face, fail, zfail, zpass);
-    };
-    WebGLRenderingContext.prototype.stencilOp = function (fail, zfail, zpass) {
+    }
+    stencilOp(fail, zfail, zpass) {
         this._glCheckError('stencilOp');
         this._checkArgs('stencilOp', arguments);
         this.context.stencilOp(fail, zfail, zpass);
-    };
-    WebGLRenderingContext.prototype.texImage2D = function (target, level, internalformat, width, height, border, format, type, pixels) {
+    }
+    texImage2D(target, level, internalformat, width, height, border, format, type, pixels) {
         this._glCheckError('texImage2D');
         this._checkArgs('texImage2D', arguments);
-        /* TODO */
-        // this.blendFunc(this.SRC_ALPHA, this.ONE_MINUS_SRC_ALPHA);
-        // this.enable(this.BLEND);
-        /* TODO */
         if (arguments.length === 9) {
             if (pixels && pixels.buffer instanceof ArrayBuffer) {
-                if (pixels instanceof Uint8Array) {
-                    this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels, 'byte'));
-                }
-                else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
-                    this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels, 'short'));
-                }
-                else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
-                    this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels, 'int'));
+                if (pixels.buffer.nativeObject) {
+                    // @ts-ignore
+                    this.context.texImage2D(target, level, internalformat, width, height, border, format, type, pixels.buffer.nativeObject);
                 }
-                else if (pixels instanceof Float32Array) {
-                    this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels, 'float'));
+                else {
+                    if (pixels instanceof Uint8Array) {
+                        if (this._isSupported) {
+                            this.context.texImage2DByteBuffer(target, level, internalformat, width, height, border, format, type, pixels);
+                        }
+                        else {
+                            this.context.texImage2DByte(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        }
+                    }
+                    else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
+                        if (this._isSupported) {
+                            this.context.texSubImage2DShortBuffer(target, level, internalformat, width, height, border, format, type, pixels);
+                        }
+                        else {
+                            this.context.texSubImage2DShort(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        }
+                    }
+                    else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
+                        if (this._isSupported) {
+                            this.context.texImage2DIntBuffer(target, level, internalformat, width, height, border, format, type, pixels);
+                        }
+                        else {
+                            this.context.texImage2DInt(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        }
+                    }
+                    else if (pixels instanceof Float32Array) {
+                        if (this._isSupported) {
+                            this.context.texImage2DFloatBuffer(target, level, internalformat, width, height, border, format, type, pixels);
+                        }
+                        else {
+                            this.context.texImage2DFloat(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        }
+                    }
                 }
             }
             else if (pixels instanceof ArrayBuffer) {
@@ -936,7 +1109,12 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
                     this.context.texImage2D(target, level, internalformat, width, height, border, format, type, pixels.nativeObject);
                 }
                 else {
-                    this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(new Uint8Array(pixels), 'byte'));
+                    if (this._isSupported) {
+                        this.context.texImage2DByteBuffer(target, level, internalformat, width, height, border, format, type, pixels);
+                    }
+                    else {
+                        this.context.texImage2DByte(target, level, internalformat, width, height, border, format, type, Array.from(new Uint8Array(pixels)));
+                    }
                 }
             }
             else {
@@ -944,304 +1122,555 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             }
         }
         else if (arguments.length === 6) {
-            if (border && typeof border.tagName === 'string' && (border.tagName === 'VID' || border.tagName === 'VIDEO') && typeof border._video && typeof border._video.getCurrentFrame === 'function') {
+            if (border && typeof border.tagName === 'string' && (border.tagName === 'VID' || border.tagName === 'VIDEO') && border._video && typeof border._video.getCurrentFrame === 'function') {
                 border._video.getCurrentFrame(this.context, this, target, level, internalformat, width, height);
             }
             else if (border && typeof border.getCurrentFrame === 'function') {
                 border.getCurrentFrame(this.context, this, target, level, internalformat, width, height);
             }
-            else if (border instanceof ImageAsset_1.ImageAsset) {
+            else if (border instanceof ImageAsset) {
+                this.context.texImage2D(target, level, internalformat, width, height, border.native);
+            }
+            else if (border instanceof ImageBitmap || (border === null || border === void 0 ? void 0 : border.native) instanceof org.nativescript.canvas.TNSImageBitmap) {
                 this.context.texImage2D(target, level, internalformat, width, height, border.native);
             }
             else if (border instanceof android.graphics.Bitmap) {
                 this.context.texImage2D(target, level, internalformat, width, height, border);
             }
-            else if (border instanceof core_1.ImageSource) {
+            else if (border instanceof ImageSource) {
                 this.context.texImage2D(target, level, internalformat, width, height, border.android);
             }
             else if (border && typeof border.tagName === 'string' && (border.tagName === 'IMG' || border.tagName === 'IMAGE')) {
-                if (border._asset instanceof ImageAsset_1.ImageAsset) {
+                if (border._asset instanceof ImageAsset) {
                     this.context.texImage2D(target, level, internalformat, width, height, border._asset.native);
                 }
-                else if (border._imageSource instanceof core_1.ImageSource) {
+                else if (border._imageSource instanceof ImageSource) {
                     this.context.texImage2D(target, level, internalformat, width, height, border._imageSource.android);
                 }
                 else if (border._image instanceof android.graphics.Bitmap) {
                     this.context.texImage2D(target, level, internalformat, width, height, border._image);
                 }
                 else if (typeof border.src === 'string') {
-                    this.context.texImage2D(target, level, internalformat, width, height, core_1.ImageSource.fromFileSync(border.src).android);
+                    this.context.texImage2D(target, level, internalformat, width, height, ImageSource.fromFileSync(border.src).android);
                 }
             }
-            else if (border && typeof border.tagName === 'string' && border.tagName === 'CANVAS' && border._canvas instanceof Canvas_1.Canvas) {
+            else if (border && typeof border.tagName === 'string' && border.tagName === 'CANVAS' && border._canvas instanceof Canvas) {
                 this.context.texImage2D(target, level, internalformat, width, height, border._canvas.android);
             }
         }
-        // this.blendFunc(this.SRC_ALPHA, this.ZERO);
-        // this.disable(this.BLEND);
-    };
-    WebGLRenderingContext.prototype.texParameterf = function (target, pname, param) {
+    }
+    texParameterf(target, pname, param) {
         this._glCheckError('texParameterf');
         this._checkArgs('texParameterf', arguments);
         this.context.texParameterf(target, pname, param);
-    };
-    WebGLRenderingContext.prototype.texParameteri = function (target, pname, param) {
+    }
+    texParameteri(target, pname, param) {
         this._glCheckError('texParameteri');
         this._checkArgs('texParameteri', arguments);
         this.context.texParameteri(target, pname, param);
-    };
-    WebGLRenderingContext.prototype.texSubImage2D = function (target, level, xoffset, yoffset, width, height, format, type, pixels) {
+    }
+    texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
         this._glCheckError('texSubImage2D');
         this._checkArgs('texSubImage2D', arguments);
         if (arguments.length === 9) {
             if (pixels && pixels.buffer) {
-                if (pixels instanceof Uint8Array) {
-                    this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels, 'byte'));
-                }
-                else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
-                    this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels, 'short'));
+                if (pixels.buffer.nativeObject) {
+                    this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels.buffer.nativeObject);
                 }
-                else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
-                    this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels, 'int'));
-                }
-                else if (pixels instanceof Float32Array) {
-                    this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels, 'float'));
+                else {
+                    if (pixels instanceof Uint8Array) {
+                        if (this._isSupported) {
+                            this.context.texSubImage2DByteBuffer(target, level, xoffset, yoffset, width, height, format, type, pixels);
+                        }
+                        else {
+                            this.context.texSubImage2DByte(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        }
+                    }
+                    else if (pixels instanceof Uint16Array || pixels instanceof Int16Array) {
+                        if (this._isSupported) {
+                            this.context.texSubImage2DShortBuffer(target, level, xoffset, yoffset, width, height, format, type, pixels);
+                        }
+                        else {
+                            this.context.texSubImage2DShort(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        }
+                    }
+                    else if (pixels instanceof Uint32Array || pixels instanceof Int32Array) {
+                        if (this._isSupported) {
+                            this.context.texSubImage2DIntBuffer(target, level, xoffset, yoffset, width, height, format, type, pixels);
+                        }
+                        else {
+                            this.context.texSubImage2DInt(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        }
+                    }
+                    else if (pixels instanceof Float32Array) {
+                        if (this._isSupported) {
+                            this.context.texSubImage2DByte(target, level, xoffset, yoffset, width, height, format, type, pixels);
+                        }
+                        else {
+                            this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        }
+                    }
                 }
             }
             else if (pixels instanceof ArrayBuffer) {
-                this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(new Uint8Array(pixels), 'byte'));
+                // @ts-ignore
+                if (pixels.nativeObject) {
+                    // @ts-ignore
+                    this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels.nativeObject);
+                }
+                else {
+                    if (this._isSupported) {
+                        this.context.texSubImage2DByteBuffer(target, level, xoffset, yoffset, width, height, format, type, pixels);
+                    }
+                    else {
+                        this.context.texSubImage2DByte(target, level, xoffset, yoffset, width, height, format, type, Array.from(new Uint8Array(pixels)));
+                    }
+                }
             }
         }
         else if (arguments.length === 7) {
             if (format instanceof android.graphics.Bitmap) {
                 this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format);
             }
-            else if (format instanceof core_1.ImageSource) {
+            else if (format instanceof ImageSource) {
                 this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format.android);
             }
-            else if (format instanceof ImageAsset_1.ImageAsset) {
+            else if (format instanceof ImageAsset) {
+                this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format.native);
+            }
+            else if (format instanceof ImageBitmap || (format === null || format === void 0 ? void 0 : format.native) instanceof org.nativescript.canvas.TNSImageBitmap) {
                 this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format.native);
             }
             else if (format && typeof format.tagName === 'string' && (format.tagName === 'IMG' || format.tagName === 'IMAGE')) {
-                if (format._imageSource instanceof core_1.ImageSource) {
+                if (format._imageSource instanceof ImageSource) {
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format._imageSource.android);
                 }
                 else if (format._image instanceof android.graphics.Bitmap) {
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format._image);
                 }
-                else if (format._asset instanceof ImageAsset_1.ImageAsset) {
+                else if (format._asset instanceof ImageAsset) {
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format._asset.native);
                 }
                 else if (typeof format.src === 'string') {
-                    var result = core_1.ImageSource.fromFileSync(format.src);
+                    const result = ImageSource.fromFileSync(format.src);
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, result ? result.android : null);
                 }
-                else if (format && typeof format.tagName === 'string' && format.tagName === 'CANVAS' && format._canvas instanceof Canvas_1.Canvas) {
+                else if (format && typeof format.tagName === 'string' && format.tagName === 'CANVAS' && format._canvas instanceof Canvas) {
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format._canvas.android);
                 }
             }
         }
-    };
-    WebGLRenderingContext.prototype.uniform1f = function (location, v0) {
+    }
+    uniform1f(location, v0) {
         this._glCheckError('uniform1f');
         this._checkArgs('uniform1f', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform1f(loc, v0);
-    };
-    WebGLRenderingContext.prototype.uniform1iv = function (location, value) {
+    }
+    uniform1iv(location, value) {
         this._glCheckError('uniform1iv');
         this._checkArgs('uniform1iv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'int');
-        var loc = location ? location.native : 0;
-        this.context.uniform1iv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform1fv = function (location, value) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform1ivBuffer(loc, value);
+            }
+            else {
+                this.context.uniform1iv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform1iv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform1iv(loc, value);
+            }
+        }
+    }
+    uniform1fv(location, value) {
         this._glCheckError('uniform1fv');
         this._checkArgs('uniform1fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniform1fv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform1i = function (location, v0) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform1fvBuffer(loc, value);
+            }
+            else {
+                this.context.uniform1fv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform1fv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform1fv(loc, value);
+            }
+        }
+    }
+    uniform1i(location, v0) {
         this._glCheckError('uniform1i');
         this._checkArgs('uniform1i', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform1i(loc, Number(v0));
-    };
-    WebGLRenderingContext.prototype.uniform2f = function (location, v0, v1) {
+    }
+    uniform2f(location, v0, v1) {
         this._glCheckError('uniform2f');
         this._checkArgs('uniform2f', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform2f(loc, v0, v1);
-    };
-    WebGLRenderingContext.prototype.uniform2iv = function (location, value) {
+    }
+    uniform2iv(location, value) {
         this._glCheckError('uniform2iv');
         this._checkArgs('uniform2iv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'int');
-        var loc = location ? location.native : 0;
-        this.context.uniform2iv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform2fv = function (location, value) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform2ivBuffer(loc, value);
+            }
+            else {
+                this.context.uniform2iv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform2iv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform2iv(loc, value);
+            }
+        }
+    }
+    uniform2fv(location, value) {
         this._glCheckError('uniform2fv');
         this._checkArgs('uniform2fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniform2fv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform2i = function (location, v0, v1) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform2fvBuffer(loc, value);
+            }
+            else {
+                this.context.uniform2fv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform2fv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform2fv(loc, value);
+            }
+        }
+    }
+    uniform2i(location, v0, v1) {
         this._glCheckError('uniform2i');
         this._checkArgs('uniform2i', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform2i(loc, v0, v1);
-    };
-    WebGLRenderingContext.prototype.uniform3f = function (location, v0, v1, v2) {
+    }
+    uniform3f(location, v0, v1, v2) {
         this._glCheckError('uniform3f');
         this._checkArgs('uniform3f', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform3f(loc, v0, v1, v2);
-    };
-    WebGLRenderingContext.prototype.uniform3iv = function (location, value) {
+    }
+    uniform3iv(location, value) {
         this._glCheckError('uniform3iv');
         this._checkArgs('uniform3iv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'int');
-        var loc = location ? location.native : 0;
-        this.context.uniform3iv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform3fv = function (location, value) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform3ivBuffer(loc, value);
+            }
+            else {
+                this.context.uniform3iv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform3iv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform3iv(loc, value);
+            }
+        }
+    }
+    uniform3fv(location, value) {
         this._glCheckError('uniform3fv');
         this._checkArgs('uniform3fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniform3fv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform3i = function (location, v0, v1, v2) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform3fvBuffer(loc, value);
+            }
+            else {
+                this.context.uniform3fv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform3fv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform3fv(loc, value);
+            }
+        }
+    }
+    uniform3i(location, v0, v1, v2) {
         this._glCheckError('uniform3i');
         this._checkArgs('uniform3i', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform3i(loc, v0, v1, v2);
-    };
-    WebGLRenderingContext.prototype.uniform4f = function (location, v0, v1, v2, v3) {
+    }
+    uniform4f(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4f');
         this._checkArgs('uniform4f', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform4f(loc, v0, v1, v2, v3);
-    };
-    WebGLRenderingContext.prototype.uniform4iv = function (location, value) {
+    }
+    uniform4iv(location, value) {
         this._glCheckError('uniform4iv');
         this._checkArgs('uniform4iv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'int');
-        var loc = location ? location.native : 0;
-        this.context.uniform4iv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform4fv = function (location, value) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform4ivBuffer(loc, value);
+            }
+            else {
+                this.context.uniform4iv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform4iv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform4iv(loc, value);
+            }
+        }
+    }
+    uniform4fv(location, value) {
         this._glCheckError('uniform4fv');
         this._checkArgs('uniform4fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniform4fv(loc, value);
-    };
-    WebGLRenderingContext.prototype.uniform4i = function (location, v0, v1, v2, v3) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniform4fvBuffer(loc, value);
+            }
+            else {
+                this.context.uniform4fv(loc, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniform4fv(loc, Array.from(value));
+            }
+            else {
+                this.context.uniform4fv(loc, value);
+            }
+        }
+    }
+    uniform4i(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4i');
         this._checkArgs('uniform4i', arguments);
-        var loc = location ? location.native : 0;
+        const loc = location ? location.native : 0;
         this.context.uniform4i(loc, v0, v1, v2, v3);
-    };
-    WebGLRenderingContext.prototype.uniformMatrix2fv = function (location, transpose, value) {
+    }
+    uniformMatrix2fv(location, transpose, value) {
         this._glCheckError('uniformMatrix2fv');
         this._checkArgs('uniformMatrix2fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniformMatrix2fv(loc, transpose, value);
-    };
-    WebGLRenderingContext.prototype.uniformMatrix3fv = function (location, transpose, value) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniformMatrix2fvBuffer(loc, transpose, value);
+            }
+            else {
+                this.context.uniformMatrix2fv(loc, transpose, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniformMatrix2fv(loc, transpose, Array.from(value));
+            }
+            else {
+                this.context.uniformMatrix2fv(loc, transpose, value);
+            }
+        }
+    }
+    uniformMatrix3fv(location, transpose, value) {
         this._glCheckError('uniformMatrix3fv');
         this._checkArgs('uniformMatrix3fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniformMatrix3fv(loc, transpose, value);
-    };
-    WebGLRenderingContext.prototype.uniformMatrix4fv = function (location, transpose, value) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniformMatrix3fvBuffer(loc, transpose, value);
+            }
+            else {
+                this.context.uniformMatrix3fv(loc, transpose, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniformMatrix3fv(loc, transpose, Array.from(value));
+            }
+            else {
+                this.context.uniformMatrix3fv(loc, transpose, value);
+            }
+        }
+    }
+    uniformMatrix4fv(location, transpose, value) {
         this._glCheckError('uniformMatrix4fv');
         this._checkArgs('uniformMatrix4fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        var loc = location ? location.native : 0;
-        this.context.uniformMatrix4fv(loc, transpose, value);
-    };
-    WebGLRenderingContext.prototype.useProgram = function (program) {
+        const loc = location ? location.native : 0;
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.uniformMatrix4fvBuffer(loc, transpose, value);
+            }
+            else {
+                this.context.uniformMatrix4fv(loc, transpose, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.uniformMatrix4fv(loc, transpose, Array.from(value));
+            }
+            else {
+                this.context.uniformMatrix4fv(loc, transpose, value);
+            }
+        }
+    }
+    useProgram(program) {
         this._glCheckError('useProgram');
         this._checkArgs('useProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.useProgram(value);
-    };
-    WebGLRenderingContext.prototype.validateProgram = function (program) {
+    }
+    validateProgram(program) {
         this._glCheckError('validateProgram');
         this._checkArgs('validateProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.validateProgram(value);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib1f = function (index, v0) {
+    }
+    vertexAttrib1f(index, v0) {
         this._glCheckError('vertexAttrib1f');
         this._checkArgs('vertexAttrib1f', arguments);
         this.context.vertexAttrib1f(index, v0);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib1fv = function (index, value) {
+    }
+    vertexAttrib1fv(index, value) {
         this._glCheckError('vertexAttrib1fv');
         this._checkArgs('vertexAttrib1fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        this.context.vertexAttrib1fv(index, value);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib2f = function (index, v0, v1) {
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib1fvBuffer(index, value);
+            }
+            else {
+                this.context.vertexAttrib1fv(index, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib1fv(index, Array.from(value));
+            }
+            else {
+                this.context.vertexAttrib1fv(index, value);
+            }
+        }
+    }
+    vertexAttrib2f(index, v0, v1) {
         this._glCheckError('vertexAttrib2f');
         this._checkArgs('vertexAttrib2f', arguments);
         this.context.vertexAttrib2f(index, v0, v1);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib2fv = function (index, value) {
+    }
+    vertexAttrib2fv(index, value) {
         this._glCheckError('vertexAttrib2fv');
         this._checkArgs('vertexAttrib2fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        this.context.vertexAttrib2fv(index, value);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib3f = function (index, v0, v1, v2) {
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib2fvBuffer(index, value);
+            }
+            else {
+                this.context.vertexAttrib2fv(index, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib2fv(index, Array.from(value));
+            }
+            else {
+                this.context.vertexAttrib2fv(index, value);
+            }
+        }
+    }
+    vertexAttrib3f(index, v0, v1, v2) {
         this._glCheckError('vertexAttrib3f');
         this._checkArgs('vertexAttrib3f', arguments);
         this.context.vertexAttrib3f(index, v0, v1, v2);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib3fv = function (index, value) {
+    }
+    vertexAttrib3fv(index, value) {
         this._glCheckError('vertexAttrib3fv');
         this._checkArgs('vertexAttrib3fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        this.context.vertexAttrib3fv(index, value);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib4f = function (index, v0, v1, v2, v3) {
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib3fvBuffer(index, value);
+            }
+            else {
+                this.context.vertexAttrib3fv(index, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib3fv(index, Array.from(value));
+            }
+            else {
+                this.context.vertexAttrib3fv(index, value);
+            }
+        }
+    }
+    vertexAttrib4f(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttrib4f');
         this._checkArgs('vertexAttrib4f', arguments);
         this.context.vertexAttrib4f(index, v0, v1, v2, v3);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib4fv = function (index, value) {
+    }
+    vertexAttrib4fv(index, value) {
         this._glCheckError('vertexAttrib4fv');
         this._checkArgs('vertexAttrib4fv', arguments);
-        value = Array.from(value); // this.toNativeArray(value, 'float');
-        this.context.vertexAttrib4fv(index, value);
-    };
-    WebGLRenderingContext.prototype.vertexAttribPointer = function (index, size, type, normalized, stride, offset) {
+        if (this._isSupported) {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib4fvBuffer(index, value);
+            }
+            else {
+                this.context.vertexAttrib4fv(index, value);
+            }
+        }
+        else {
+            if (!Array.isArray(value)) {
+                this.context.vertexAttrib4fv(index, Array.from(value));
+            }
+            else {
+                this.context.vertexAttrib4fv(index, value);
+            }
+        }
+    }
+    vertexAttribPointer(index, size, type, normalized, stride, offset) {
         this._glCheckError('vertexAttribPointer');
         this._checkArgs('vertexAttribPointer', arguments);
         this.context.vertexAttribPointer(index, size, type, normalized, stride, offset);
-    };
-    WebGLRenderingContext.prototype.viewport = function (x, y, width, height) {
+    }
+    viewport(x, y, width, height) {
         this._glCheckError('viewport');
         this._checkArgs('viewport', arguments);
         this.context.viewport(x, y, width, height);
-    };
-    WebGLRenderingContext.prototype._glCheckError = function (message) {
+    }
+    _glCheckError(message) {
         if (!WebGLRenderingContext.isDebug) {
             return;
         }
         if (WebGLRenderingContext.filter === 'both' || WebGLRenderingContext.filter === 'error') {
             console.log(message, this.getError());
         }
-    };
-    WebGLRenderingContext.prototype._checkArgs = function (message, args) {
+    }
+    _checkArgs(message, args) {
         if (!WebGLRenderingContext.isDebug) {
             return;
         }
@@ -1250,10 +1679,8 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             console.dir(args);
             console.log('/**** ', message, ' ****/');
         }
-    };
-    WebGLRenderingContext.isDebug = false;
-    WebGLRenderingContext.filter = 'both';
-    return WebGLRenderingContext;
-}(common_1.WebGLRenderingContextBase));
-exports.WebGLRenderingContext = WebGLRenderingContext;
+    }
+}
+WebGLRenderingContext.isDebug = false;
+WebGLRenderingContext.filter = 'both';
 //# sourceMappingURL=index.android.js.map