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

package/WebGL2/WebGL2RenderingContext/index.ios.js

@@ -1,91 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var WebGLQuery_1 = require("../WebGLQuery");
-var WebGLSampler_1 = require("../WebGLSampler");
-var WebGLTransformFeedback_1 = require("../WebGLTransformFeedback");
-var WebGLVertexArrayObject_1 = require("../WebGLVertexArrayObject");
-var WebGLActiveInfo_1 = require("../../WebGL/WebGLActiveInfo");
-var WebGLBuffer_1 = require("../../WebGL/WebGLBuffer");
-var core_1 = require("@nativescript/core");
-var ImageAsset_1 = require("../../ImageAsset");
-var common_1 = require("./common");
-var Canvas_1 = require("../../Canvas");
-var WebGL2RenderingContext = /** @class */ (function (_super) {
-    __extends(WebGL2RenderingContext, _super);
-    function WebGL2RenderingContext(context) {
-        return _super.call(this, context) || this;
-    }
-    WebGL2RenderingContext.prototype.beginQuery = function (target, query) {
+import { WebGLQuery } from '../WebGLQuery';
+import { WebGLSampler } from '../WebGLSampler';
+import { WebGLTransformFeedback } from '../WebGLTransformFeedback';
+import { WebGLVertexArrayObject } from '../WebGLVertexArrayObject';
+import { WebGLFramebuffer } from '../../WebGL/WebGLFramebuffer';
+import { WebGLActiveInfo } from '../../WebGL/WebGLActiveInfo';
+import { WebGLBuffer } from '../../WebGL/WebGLBuffer';
+import { ImageSource } from '@nativescript/core';
+import { ImageAsset } from '../../ImageAsset';
+import { WebGL2RenderingContextBase } from "./common";
+import { Canvas } from '../../Canvas';
+import { ImageBitmap } from '../../ImageBitmap';
+export class WebGL2RenderingContext extends WebGL2RenderingContextBase {
+    constructor(context) {
+        super(context);
+    }
+    beginQuery(target, query) {
         this._glCheckError('beginQuery');
-        var value = query ? query.native : 0;
+        const value = query ? query.native : 0;
         this.native.beginQuery(target, value);
-    };
-    WebGL2RenderingContext.prototype.beginTransformFeedback = function (primitiveMode) {
+    }
+    beginTransformFeedback(primitiveMode) {
         this._glCheckError('beginTransformFeedback');
         this.native.beginTransformFeedback(primitiveMode);
-    };
-    WebGL2RenderingContext.prototype.bindBufferBase = function (target, index, buffer) {
+    }
+    bindBufferBase(target, index, buffer) {
         this._glCheckError('bindBufferBase');
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         this.native.bindBufferBase(target, index, value);
-    };
-    WebGL2RenderingContext.prototype.bindBufferRange = function (target, index, buffer, offset, size) {
+    }
+    bindBufferRange(target, index, buffer, offset, size) {
         this._glCheckError('bindBufferRange');
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         this.native.bindBufferRange(target, index, value, offset, size);
-    };
-    WebGL2RenderingContext.prototype.bindSampler = function (unit, sampler) {
+    }
+    bindSampler(unit, sampler) {
         this._glCheckError('bindSampler');
-        var value = sampler ? sampler.native : 0;
+        const value = sampler ? sampler.native : 0;
         this.native.bindSampler(unit, value);
-    };
-    WebGL2RenderingContext.prototype.bindTransformFeedback = function (target, transformFeedback) {
+    }
+    bindTransformFeedback(target, transformFeedback) {
         this._glCheckError('bindTransformFeedback');
-        var value = transformFeedback ? transformFeedback.native : 0;
+        const value = transformFeedback ? transformFeedback.native : 0;
         this.native.bindTransformFeedback(target, value);
-    };
-    WebGL2RenderingContext.prototype.bindVertexArray = function (vertexArray) {
+    }
+    bindVertexArray(vertexArray) {
         this._glCheckError('bindVertexArray');
-        var value = vertexArray ? vertexArray.native : 0;
+        const value = vertexArray ? vertexArray.native : 0;
         this.native.bindVertexArray(value);
-    };
-    WebGL2RenderingContext.prototype.blitFramebuffer = function (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) {
+    }
+    blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) {
         this._glCheckError('blitFramebuffer');
         this.native.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-    };
-    WebGL2RenderingContext.prototype.clearBufferfi = function (buffer, drawbuffer, depth, stencil) {
+    }
+    clearBufferfi(buffer, drawbuffer, depth, stencil) {
         this._glCheckError('clearBufferfi');
         this.native.clearBufferfi(buffer.native, drawbuffer, depth, stencil);
-    };
-    WebGL2RenderingContext.prototype.clearBufferfv = function (buffer, drawbuffer, values) {
+    }
+    clearBufferfv(buffer, drawbuffer, values) {
         this._glCheckError('clearBufferfv');
-        this.native.clearBufferfv(buffer.native, drawbuffer, Array.from(values));
-    };
-    WebGL2RenderingContext.prototype.clearBufferiv = function (buffer, drawbuffer, values) {
-        this._glCheckError('clearBufferiv');
-        if (values instanceof Int32Array) {
-            this.native.clearBufferiv(buffer.native, drawbuffer, Array.from(values));
+        if (!(values instanceof Float32Array)) {
+            values = new Float32Array(values);
         }
-        else {
-            this.native.clearBufferiv(buffer.native, drawbuffer, values);
+        this.native.clearBufferfvOffset(buffer.native, drawbuffer, values, values.byteOffset);
+    }
+    clearBufferiv(buffer, drawbuffer, values) {
+        this._glCheckError('clearBufferiv');
+        if (!(values instanceof Int32Array)) {
+            values = new Int32Array(values);
         }
-    };
-    WebGL2RenderingContext.prototype.clearBufferuiv = function (buffer, drawbuffer, values) {
+        this.native.clearBufferivOffset(buffer.native, drawbuffer, values, values.byteOffset);
+    }
+    clearBufferuiv(buffer, drawbuffer, values) {
         this._glCheckError('clearBufferuiv');
-        if (values instanceof Uint32Array) {
-            this.native.clearBufferuiv(buffer.native, drawbuffer, Array.from(values));
-        }
-        else {
-            this.native.clearBufferuiv(buffer.native, drawbuffer, values);
+        if (!(values instanceof Uint32Array)) {
+            values = new Uint32Array(values);
         }
-    };
-    WebGL2RenderingContext.prototype.clientWaitSync = function (sync, flags, timeout) {
+        this.native.clearBufferuivOffset(buffer.native, drawbuffer, values, values.byteOffset);
+    }
+    clientWaitSync(sync, flags, timeout) {
         this._glCheckError('clientWaitSync');
         return this.native.clientWaitSync(sync.native, flags, timeout);
-    };
-    WebGL2RenderingContext.prototype.compressedTexSubImage3D = function (target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset, srcLengthOverride) {
-        if (srcOffset === void 0) { srcOffset = 0; }
-        if (srcLengthOverride === void 0) { srcLengthOverride = 0; }
+    }
+    compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset = 0, srcLengthOverride = 0) {
         this._glCheckError('compressedTexSubImage3D');
         if (typeof srcOffset === 'number') {
             this.native.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, srcData, srcOffset);
@@ -119,234 +115,258 @@ var WebGL2RenderingContext = /** @class */ (function (_super) {
                 this.native.compressedTexSubImage3DF64(target, level, xoffset, yoffset, zoffset, width, height, depth, format, Array.from(srcData), srcOffset, srcLengthOverride);
             }
         }
-    };
+    }
     /* Transform feedback */
     /* Framebuffers and renderbuffers */
-    WebGL2RenderingContext.prototype.copyBufferSubData = function (readTarget, writeTarget, readOffset, writeOffset, size) {
+    copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) {
         this._glCheckError('copyBufferSubData');
         this.native.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-    };
-    WebGL2RenderingContext.prototype.copyTexSubImage3D = function (target, level, xoffset, yoffset, zoffset, x, y, width, height) {
+    }
+    copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) {
         this._glCheckError('copyTexSubImage3D');
         this.native.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-    };
-    WebGL2RenderingContext.prototype.createQuery = function () {
+    }
+    createQuery() {
         this._glCheckError('createQuery');
-        return new WebGLQuery_1.WebGLQuery(this.native.createQuery());
-    };
-    WebGL2RenderingContext.prototype.createSampler = function () {
+        return new WebGLQuery(this.native.createQuery());
+    }
+    createSampler() {
         this._glCheckError('createSampler');
-        return new WebGLSampler_1.WebGLSampler(this.native.createSampler());
-    };
-    WebGL2RenderingContext.prototype.createTransformFeedback = function () {
+        return new WebGLSampler(this.native.createSampler());
+    }
+    createTransformFeedback() {
         this._glCheckError('createTransformFeedback');
-        return new WebGLTransformFeedback_1.WebGLTransformFeedback(this.native.createTransformFeedback());
-    };
-    WebGL2RenderingContext.prototype.createVertexArray = function () {
+        return new WebGLTransformFeedback(this.native.createTransformFeedback());
+    }
+    createVertexArray() {
         this._glCheckError('createVertexArray');
-        return new WebGLVertexArrayObject_1.WebGLVertexArrayObject(this.native.createVertexArray());
-    };
-    WebGL2RenderingContext.prototype.deleteQuery = function (query) {
+        return new WebGLVertexArrayObject(this.native.createVertexArray());
+    }
+    deleteQuery(query) {
         this._glCheckError('deleteQueryWithQuery');
         this.native.deleteQuery(query.native);
-    };
-    WebGL2RenderingContext.prototype.deleteSampler = function (sampler) {
+    }
+    deleteSampler(sampler) {
         this._glCheckError('deleteSamplerWithSampler');
         this.native.deleteSampler(sampler.native);
-    };
-    WebGL2RenderingContext.prototype.deleteSync = function (sync) {
+    }
+    deleteSync(sync) {
         this._glCheckError('deleteSyncWithSync');
         this.native.deleteSync(sync.native);
-    };
-    WebGL2RenderingContext.prototype.deleteTransformFeedback = function (transformFeedback) {
+    }
+    deleteTransformFeedback(transformFeedback) {
         this._glCheckError('deleteTransformFeedback');
         this.native.deleteTransformFeedback(transformFeedback.native);
-    };
-    WebGL2RenderingContext.prototype.deleteVertexArray = function (vertexArray) {
+    }
+    deleteVertexArray(vertexArray) {
         this._glCheckError('deleteVertexArray');
         this.native.deleteVertexArray(vertexArray.native);
-    };
-    WebGL2RenderingContext.prototype.drawArraysInstanced = function (mode, first, count, instanceCount) {
+    }
+    drawArraysInstanced(mode, first, count, instanceCount) {
         this._glCheckError('drawArraysInstanced');
         this.native.drawArraysInstanced(mode, first, count, instanceCount);
-    };
-    WebGL2RenderingContext.prototype.drawBuffers = function (buffers) {
+    }
+    drawBuffers(buffers) {
         this._glCheckError('drawBuffers');
         this.native.drawBuffers(buffers);
-    };
-    WebGL2RenderingContext.prototype.drawElementsInstanced = function (mode, count, type, offset, instanceCount) {
+    }
+    drawElementsInstanced(mode, count, type, offset, instanceCount) {
         this._glCheckError('drawElementsInstanced');
         this.native.drawElementsInstanced(mode, count, type, offset, instanceCount);
-    };
-    WebGL2RenderingContext.prototype.drawRangeElements = function (mode, start, end, count, type, offset) {
+    }
+    drawRangeElements(mode, start, end, count, type, offset) {
         this._glCheckError('drawRangeElements');
         this.native.drawRangeElements(mode, start, end, count, type, offset);
-    };
-    WebGL2RenderingContext.prototype.endQuery = function (target) {
+    }
+    endQuery(target) {
         this._glCheckError('endQuery');
         this.native.endQuery(target);
-    };
-    WebGL2RenderingContext.prototype.endTransformFeedback = function () {
+    }
+    endTransformFeedback() {
         this._glCheckError('endTransformFeedback');
         this.native.endTransformFeedback();
-    };
-    WebGL2RenderingContext.prototype.fenceSync = function (condition, flags) {
+    }
+    fenceSync(condition, flags) {
         this._glCheckError('fenceSync');
         this.native.fenceSync(condition, flags);
-    };
-    WebGL2RenderingContext.prototype.framebufferTextureLayer = function (target, attachment, texture, level, layer) {
+    }
+    framebufferTextureLayer(target, attachment, texture, level, layer) {
         this._glCheckError('framebufferTextureLayer');
         this.native.framebufferTextureLayer(target, attachment, texture.native, level, layer);
-    };
+    }
     /* Framebuffers and renderbuffers */
     /* Uniforms */
-    WebGL2RenderingContext.prototype.getActiveUniformBlockName = function (program, uniformBlockIndex) {
+    getActiveUniformBlockName(program, uniformBlockIndex) {
         this._glCheckError('getActiveUniformBlockName');
         return this.native.getActiveUniformBlockName(program.native, uniformBlockIndex);
-    };
-    WebGL2RenderingContext.prototype.getActiveUniformBlockParameter = function (program, uniformBlockIndex, pname) {
+    }
+    getActiveUniformBlockParameter(program, uniformBlockIndex, pname) {
         this._glCheckError('getActiveUniformBlockParameter');
-        var param = this.native.getActiveUniformBlockParameter(program.native, uniformBlockIndex, pname);
+        const param = this.native.getActiveUniformBlockParameter(program.native, uniformBlockIndex, pname);
         if (pname === this.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) {
             return new Uint32Array(this.getJSArray(param));
         }
         return param;
-    };
-    WebGL2RenderingContext.prototype.getActiveUniforms = function (program, uniformIndices, pname) {
+    }
+    getActiveUniforms(program, uniformIndices, pname) {
         this._glCheckError('getActiveUniforms');
         return this.getJSArray(this.native.getActiveUniforms(program.native, uniformIndices, pname));
-    };
-    WebGL2RenderingContext.prototype.getBufferSubData = function (target, srcByteOffset, dstData, dstOffset, length) {
-        if (dstOffset === void 0) { dstOffset = 0; }
-        if (length === void 0) { length = 0; }
+    }
+    getBufferSubData(target, srcByteOffset, dstData, dstOffset = 0, length = 0) {
         this._glCheckError('getBufferSubData');
         if (dstData instanceof ArrayBuffer) {
-            this.native.getBufferSubData(target, srcByteOffset, NSData.dataWithData(dstData), dstOffset, length);
+            this.native.getBufferSubDataSize(target, srcByteOffset, dstData, dstData.byteLength, dstOffset, length);
         }
-    };
-    WebGL2RenderingContext.prototype.getFragDataLocation = function (program, name) {
+    }
+    getFragDataLocation(program, name) {
         this._glCheckError('getFragDataLocation');
-        var result = this.native.getFragDataLocation(program.native, name);
+        const result = this.native.getFragDataLocation(program.native, name);
         return result !== -1 ? result : null;
-    };
-    WebGL2RenderingContext.prototype.getIndexedParameter = function (target, index) {
+    }
+    getIndexedParameter(target, index) {
         this._glCheckError('getIndexedParameter');
-        var param = this.native.getIndexedParameter(target, index);
+        const param = this.native.getIndexedParameter(target, index);
         if (target === this.TRANSFORM_FEEDBACK_BUFFER_BINDING || target === this.UNIFORM_BUFFER_BINDING) {
-            return new WebGLBuffer_1.WebGLBuffer(param);
+            return new WebGLBuffer(param);
         }
         return param;
-    };
-    WebGL2RenderingContext.prototype.getInternalformatParameter = function (target, internalformat, pname) {
+    }
+    getInternalformatParameter(target, internalformat, pname) {
         this._glCheckError('getInternalformatParameter');
-        var param = this.native.getInternalformatParameter(target, internalformat, pname);
+        const param = this.native.getInternalformatParameter(target, internalformat, pname);
         if (pname === this.SAMPLES) {
             return new Int32Array(this.getJSArray(param));
         }
         return param;
-    };
-    WebGL2RenderingContext.prototype.getQueryParameter = function (query, pname) {
+    }
+    getQueryParameter(query, pname) {
         this._glCheckError('getQueryParameter');
-        var result = this.native.getQueryParameter(query.native, pname);
+        const result = this.native.getQueryParameter(query.native, pname);
         if (result === 0) {
             return null;
         }
         return result;
-    };
-    WebGL2RenderingContext.prototype.getQuery = function (target, pname) {
+    }
+    //@ts-ignore
+    getParameter(pname) {
+        this._glCheckError('getParameter');
+        this._checkArgs('getParameter', arguments);
+        const value = this.native.getParameter(pname);
+        switch (pname) {
+            case this.COPY_READ_BUFFER_BINDING:
+            case this.COPY_WRITE_BUFFER_BINDING:
+                if (value) {
+                    new WebGLBuffer(value);
+                }
+                return null;
+            case this.DRAW_FRAMEBUFFER_BINDING:
+                if (value) {
+                    return new WebGLFramebuffer(value);
+                }
+                return null;
+            default:
+                return super.getParameter(pname);
+        }
+    }
+    getQuery(target, pname) {
         this._glCheckError('getQuery');
-        var query = this.native.getQuery(target, pname);
+        const query = this.native.getQuery(target, pname);
         if (query) {
-            return new WebGLQuery_1.WebGLQuery(query);
+            return new WebGLQuery(query);
         }
         return null;
-    };
-    WebGL2RenderingContext.prototype.getSamplerParameter = function (sampler, pname) {
+    }
+    getSamplerParameter(sampler, pname) {
         this._glCheckError('getSamplerParameter');
         return this.native.getSamplerParameter(sampler.native, pname);
-    };
-    WebGL2RenderingContext.prototype.getSyncParameter = function (sync, pname) {
+    }
+    getSyncParameter(sync, pname) {
         this._glCheckError('getSyncParameter');
         return this.native.getSyncParameter(sync.native, pname);
-    };
-    WebGL2RenderingContext.prototype.getTransformFeedbackVarying = function (program, index) {
+    }
+    getTransformFeedbackVarying(program, index) {
         this._glCheckError('getTransformFeedbackVarying');
-        var info = this.native.getTransformFeedbackVarying(program.native, index);
+        const info = this.native.getTransformFeedbackVarying(program.native, index);
         if (info) {
-            return new WebGLActiveInfo_1.WebGLActiveInfo(info.name, info.size, info.size);
+            return new WebGLActiveInfo(info.name, info.size, info.size);
         }
         return null;
-    };
-    WebGL2RenderingContext.prototype.getUniformBlockIndex = function (program, uniformBlockName) {
+    }
+    getUniformBlockIndex(program, uniformBlockName) {
         this._glCheckError('getUniformBlockIndex');
         return this.native.getUniformBlockIndex(program.native, uniformBlockName);
-    };
-    WebGL2RenderingContext.prototype.getUniformIndices = function (program, uniformNames) {
+    }
+    getUniformIndices(program, uniformNames) {
         this._glCheckError('getUniformIndices');
         return this.getJSArray(this.native.getUniformIndices(program.native, uniformNames));
-    };
-    WebGL2RenderingContext.prototype.invalidateFramebuffer = function (target, attachments) {
+    }
+    invalidateFramebuffer(target, attachments) {
         this._glCheckError('invalidateFramebuffer');
         this.native.invalidateFramebuffer(target, attachments);
-    };
-    WebGL2RenderingContext.prototype.invalidateSubFramebuffer = function (target, attachments, x, y, width, height) {
+    }
+    invalidateSubFramebuffer(target, attachments, x, y, width, height) {
         this._glCheckError('invalidateSubFramebuffer');
         this.native.invalidateSubFramebuffer(target, attachments, x, y, width, height);
-    };
-    WebGL2RenderingContext.prototype.isQuery = function (query) {
+    }
+    isQuery(query) {
         this._glCheckError('isQuery');
         return this.native.isQuery(query.native);
-    };
-    WebGL2RenderingContext.prototype.isSampler = function (sampler) {
+    }
+    isSampler(sampler) {
         this._glCheckError('isSampler');
         return this.native.isSampler(sampler.native);
-    };
-    WebGL2RenderingContext.prototype.isSync = function (sync) {
+    }
+    isSync(sync) {
         this._glCheckError('isSync');
         return this.native.isSync(sync.native);
-    };
-    WebGL2RenderingContext.prototype.isTransformFeedback = function (transformFeedback) {
+    }
+    isTransformFeedback(transformFeedback) {
         this._glCheckError('isTransformFeedback');
         return this.native.isTransformFeedback(transformFeedback.native);
-    };
-    WebGL2RenderingContext.prototype.isVertexArray = function (vertexArray) {
+    }
+    isVertexArray(vertexArray) {
         this._glCheckError('isVertexArray');
         return this.native.isVertexArray(vertexArray.native);
-    };
-    WebGL2RenderingContext.prototype.pauseTransformFeedback = function () {
+    }
+    pauseTransformFeedback() {
         this._glCheckError('pauseTransformFeedback');
         this.native.pauseTransformFeedback();
-    };
-    WebGL2RenderingContext.prototype.readBuffer = function (src) {
+    }
+    readBuffer(src) {
         this._glCheckError('readBuffer');
         this.native.readBuffer(src);
-    };
-    WebGL2RenderingContext.prototype.renderbufferStorageMultisample = function (target, samples, internalFormat, width, height) {
+    }
+    renderbufferStorageMultisample(target, samples, internalFormat, width, height) {
         this._glCheckError('renderbufferStorageMultisample');
         this.native.renderbufferStorageMultisample(target, samples, internalFormat, width, height);
-    };
-    WebGL2RenderingContext.prototype.resumeTransformFeedback = function () {
+    }
+    resumeTransformFeedback() {
         this._glCheckError('resumeTransformFeedback');
         this.native.resumeTransformFeedback();
-    };
-    WebGL2RenderingContext.prototype.samplerParameterf = function (sampler, pname, param) {
+    }
+    samplerParameterf(sampler, pname, param) {
         this._glCheckError('samplerParameterf');
         this.native.samplerParameterf(sampler.native, pname, param);
-    };
+    }
     /* Uniforms */
     /* Sync objects */
-    WebGL2RenderingContext.prototype.samplerParameteri = function (sampler, pname, param) {
+    samplerParameteri(sampler, pname, param) {
         this._glCheckError('samplerParameteri');
         this.native.samplerParameteri(sampler.native, pname, param);
-    };
-    WebGL2RenderingContext.prototype.texImage3D = function (target, level, internalformat, width, height, depth, border, format, type, source, srcOffset) {
-        if (srcOffset === void 0) { srcOffset = 0; }
+    }
+    texImage3D(target, level, internalformat, width, height, depth, border, format, type, source, srcOffset = 0) {
         this._glCheckError('texImage3D');
         if (typeof source === 'number') {
             this.native.texImage3DOffset(target, level, internalformat, width, height, depth, border, format, type, source);
         }
         else if (source instanceof ArrayBuffer) {
-            this.native.texImage3DU8(target, level, internalformat, width, height, depth, border, format, type, source, srcOffset);
+            const data = NSData.dataWithData(source);
+            if (data) {
+                this.native.texImage3DData(target, level, internalformat, width, height, depth, border, format, type, data, srcOffset);
+            }
+            else {
+                this.native.texImage3DU8(target, level, internalformat, width, height, depth, border, format, type, source, srcOffset);
+            }
         }
         else if (source && source.buffer) {
             if (source instanceof Int8Array) {
@@ -377,51 +397,59 @@ var WebGL2RenderingContext = /** @class */ (function (_super) {
         else if (source instanceof UIImage) {
             this.native.texImage3DSource(target, level, internalformat, width, height, depth, border, format, type, source);
         }
-        else if (source instanceof core_1.ImageSource) {
+        else if (source instanceof ImageSource) {
             this.native.texImage3DSource(target, level, internalformat, width, height, depth, border, format, type, source.ios);
         }
-        else if (source instanceof ImageAsset_1.ImageAsset) {
+        else if (source instanceof ImageAsset) {
             this.native.texImage3DAsset(target, level, internalformat, width, height, depth, border, format, type, source.native);
         }
+        else if (source instanceof ImageBitmap) {
+            this.native.texImage3DBitmap(target, level, internalformat, width, height, depth, border, format, type, source.native);
+        }
         else if (source &&
             typeof source.tagName === 'string' &&
             (source.tagName === 'IMG' || source.tagName === 'IMAGE')) {
-            if (source._imageSource instanceof core_1.ImageSource) {
+            if (source._imageSource instanceof ImageSource) {
                 this.native.texImage3DSource(target, level, internalformat, width, height, depth, border, format, type, source._imageSource.ios);
             }
             else if (source._image instanceof UIImage) {
                 this.native.texImage3DSource(target, level, internalformat, width, height, depth, border, format, type, source._image);
             }
-            else if (source._asset instanceof ImageAsset_1.ImageAsset) {
+            else if (source._asset instanceof ImageAsset) {
                 this.native.texImage3DAsset(target, level, internalformat, width, height, depth, border, format, type, source._asset.native);
             }
             else if (typeof source.src === 'string') {
-                var result = core_1.ImageSource.fromFileSync(source.src);
+                const result = ImageSource.fromFileSync(source.src);
                 this.native.texImage3DSource(target, level, internalformat, width, height, depth, border, format, type, result ? result.ios : null);
             }
         }
         else if (source &&
             typeof source.tagName === 'string' &&
-            source.tagName === 'CANVAS' && source._canvas instanceof Canvas_1.Canvas) {
+            source.tagName === 'CANVAS' && source._canvas instanceof Canvas) {
             this.native.texImage3DSource(target, level, internalformat, width, height, depth, border, format, type, source._canvas.ios);
         }
-    };
-    WebGL2RenderingContext.prototype.texStorage2D = function (target, levels, internalformat, width, height) {
+    }
+    texStorage2D(target, levels, internalformat, width, height) {
         this._glCheckError('texStorage2D');
         this.native.texStorage2D(target, levels, internalformat, width, height);
-    };
-    WebGL2RenderingContext.prototype.texStorage3D = function (target, levels, internalformat, width, height, depth) {
+    }
+    texStorage3D(target, levels, internalformat, width, height, depth) {
         this._glCheckError('texStorage3D');
         this.native.texStorage3D(target, levels, internalformat, width, height, depth);
-    };
-    WebGL2RenderingContext.prototype.texSubImage3D = function (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset) {
-        if (srcOffset === void 0) { srcOffset = 0; }
+    }
+    texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset = 0) {
         this._glCheckError('texSubImage3D');
         if (typeof srcData === 'number') {
             this.native.texSubImage3DOffset(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
         }
         else if (srcData instanceof ArrayBuffer) {
-            this.native.texSubImage3DU8(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset);
+            const data = NSData.dataWithData(srcData);
+            if (data) {
+                this.native.texSubImage3DData(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data, srcOffset);
+            }
+            else {
+                this.native.texSubImage3DU8(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData, srcOffset);
+            }
         }
         else if (srcData && srcData.buffer) {
             if (srcData instanceof Int8Array) {
@@ -452,128 +480,129 @@ var WebGL2RenderingContext = /** @class */ (function (_super) {
         else if (srcData instanceof UIImage) {
             this.native.texSubImage3DSrcData(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData);
         }
-        else if (srcData instanceof core_1.ImageSource) {
+        else if (srcData instanceof ImageSource) {
             this.native.texSubImage3DSrcData(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.ios);
         }
-        else if (srcData instanceof ImageAsset_1.ImageAsset) {
+        else if (srcData instanceof ImageAsset) {
             this.native.texSubImage3DAsset(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
         }
+        else if (srcData instanceof ImageBitmap) {
+            this.native.texSubImage3DBitmap(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData.native);
+        }
         else if (srcData &&
             typeof srcData.tagName === 'string' &&
             (srcData.tagName === 'IMG' || srcData.tagName === 'IMAGE')) {
-            if (srcData._imageSource instanceof core_1.ImageSource) {
+            if (srcData._imageSource instanceof ImageSource) {
                 this.native.texSubImage3DSrcData(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._imageSource.ios);
             }
             else if (srcData._image instanceof UIImage) {
                 this.native.texSubImage3DSrcData(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._image);
             }
-            else if (srcData._asset instanceof ImageAsset_1.ImageAsset) {
+            else if (srcData._asset instanceof ImageAsset) {
                 this.native.texSubImage3DAsset(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._asset.native);
             }
             else if (typeof srcData.src === 'string') {
-                var result = core_1.ImageSource.fromFileSync(srcData.src);
+                const result = ImageSource.fromFileSync(srcData.src);
                 this.native.texSubImage3DSrcData(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, result ? result.ios : null);
             }
         }
         else if (srcData &&
             typeof srcData.tagName === 'string' &&
-            srcData.tagName === 'CANVAS' && srcData._canvas instanceof Canvas_1.Canvas) {
+            srcData.tagName === 'CANVAS' && srcData._canvas instanceof Canvas) {
             this.native.texSubImage3DAsset(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, srcData._canvas.ios);
         }
-    };
-    WebGL2RenderingContext.prototype.transformFeedbackVaryings = function (program, varyings, bufferMode) {
+    }
+    transformFeedbackVaryings(program, varyings, bufferMode) {
         this._glCheckError('transformFeedbackVaryings');
         this.native.transformFeedbackVaryings(program.native, varyings, bufferMode);
-    };
-    WebGL2RenderingContext.prototype.uniform1ui = function (location, v0) {
+    }
+    uniform1ui(location, v0) {
         this._glCheckError('uniform1ui');
         this.native.uniform1ui(location, v0);
-    };
-    WebGL2RenderingContext.prototype.uniform1uiv = function (location, data) {
+    }
+    uniform1uiv(location, data) {
         this._glCheckError('uniform1uiv');
-        this.native.uniform1uiv(location, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniform2ui = function (location, v0, v1) {
+        this.native.uniform1uivOffset(location, data, data.length, data.byteOffset);
+    }
+    uniform2ui(location, v0, v1) {
         this._glCheckError('uniform2ui');
         this.native.uniform2ui(location, v0, v1);
-    };
-    WebGL2RenderingContext.prototype.uniform2uiv = function (location, data) {
+    }
+    uniform2uiv(location, data) {
         this._glCheckError('uniform2uiv');
-        this.native.uniform2uiv(location, Array.from(data));
-    };
+        this.native.uniform2uivOffset(location, data, data.length, data.byteOffset);
+    }
     /* Sync objects */
     /* Miscellaneous constants */
-    WebGL2RenderingContext.prototype.uniform3ui = function (location, v0, v1, v2) {
+    uniform3ui(location, v0, v1, v2) {
         this._glCheckError('uniform3ui');
         this.native.uniform3ui(location, v0, v1, v2);
-    };
-    WebGL2RenderingContext.prototype.uniform3uiv = function (location, data) {
+    }
+    uniform3uiv(location, data) {
         this._glCheckError('uniform3uiv');
-        this.native.uniform3uiv(location, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniform4ui = function (location, v0, v1, v2, v3) {
+        this.native.uniform3uivOffset(location, data, data.length, data.byteOffset);
+    }
+    uniform4ui(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4ui');
         this.native.uniform4ui(location, v0, v1, v2, v3);
-    };
-    WebGL2RenderingContext.prototype.uniform4uiv = function (location, data) {
+    }
+    uniform4uiv(location, data) {
         this._glCheckError('uniform4uiv');
-        this.native.uniform4uiv(location, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniformBlockBinding = function (program, uniformBlockIndex, uniformBlockBinding) {
+        this.native.uniform4uivOffset(location, data, data.length, data.byteOffset);
+    }
+    uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) {
         this._glCheckError('uniformBlockBinding');
         this.native.uniformBlockBinding(program.native, uniformBlockIndex, uniformBlockBinding);
-    };
-    WebGL2RenderingContext.prototype.uniformMatrix2x3fv = function (location, transpose, data) {
+    }
+    uniformMatrix2x3fv(location, transpose, data) {
         this._glCheckError('uniformMatrix2x3fv');
-        this.native.uniformMatrix2x3fv(location.native, transpose, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniformMatrix2x4fv = function (location, transpose, data) {
+        this.native.uniformMatrix2x3fvOffset(location.native, transpose, data, data.length, data.byteOffset);
+    }
+    uniformMatrix2x4fv(location, transpose, data) {
         this._glCheckError('uniformMatrix2x4fv');
-        this.native.uniformMatrix2x4fv(location.native, transpose, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniformMatrix3x2fv = function (location, transpose, data) {
+        this.native.uniformMatrix2x4fvOffset(location.native, transpose, data, data.length, data.byteOffset);
+    }
+    uniformMatrix3x2fv(location, transpose, data) {
         this._glCheckError('uniformMatrix3x2fv');
-        this.native.uniformMatrix3x2fv(location.native, transpose, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniformMatrix3x4fv = function (location, transpose, data) {
+        this.native.uniformMatrix3x2fvOffset(location.native, transpose, data, data.length, data.byteOffset);
+    }
+    uniformMatrix3x4fv(location, transpose, data) {
         this._glCheckError('uniformMatrix3x4fv');
-        this.native.uniformMatrix3x4fv(location.native, transpose, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniformMatrix4x2fv = function (location, transpose, data) {
+        this.native.uniformMatrix3x4fvOffset(location.native, transpose, data, data.length, data.byteOffset);
+    }
+    uniformMatrix4x2fv(location, transpose, data) {
         this._glCheckError('uniformMatrix4x2fv');
-        this.native.uniformMatrix4x2fv(location.native, transpose, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.uniformMatrix4x3fv = function (location, transpose, data) {
+        this.native.uniformMatrix4x2fv(location.native, transpose, data, data.length);
+    }
+    uniformMatrix4x3fv(location, transpose, data) {
         this._glCheckError('uniformMatrix4x3fv');
-        this.native.uniformMatrix4x3fv(location.native, transpose, Array.from(data));
-    };
-    WebGL2RenderingContext.prototype.vertexAttribDivisor = function (index, divisor) {
+        this.native.uniformMatrix4x3fvOffset(location.native, transpose, data, data.length, data.byteOffset);
+    }
+    vertexAttribDivisor(index, divisor) {
         this._glCheckError('vertexAttribDivisor');
         this.native.vertexAttribDivisor(index, divisor);
-    };
-    WebGL2RenderingContext.prototype.vertexAttribI4i = function (index, v0, v1, v2, v3) {
+    }
+    vertexAttribI4i(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttribI4i');
         this.native.vertexAttribI4i(index, v0, v1, v2, v3);
-    };
-    WebGL2RenderingContext.prototype.vertexAttribI4iv = function (index, value) {
+    }
+    vertexAttribI4iv(index, value) {
         this._glCheckError('vertexAttribI4iv');
-        this.native.vertexAttribI4iv(index, Array.from(value));
-    };
-    WebGL2RenderingContext.prototype.vertexAttribI4ui = function (index, v0, v1, v2, v3) {
+        if (!(value instanceof Int32Array)) {
+            value = new Int32Array(value);
+        }
+        this.native.vertexAttribI4ivOffset(index, value, value.byteOffset);
+    }
+    vertexAttribI4ui(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttribI4ui');
         this.native.vertexAttribI4ui(index, v0, v1, v2, v3);
-    };
-    WebGL2RenderingContext.prototype.vertexAttribI4uiv = function (index, value) {
+    }
+    vertexAttribI4uiv(index, value) {
         this._glCheckError('vertexAttribI4uiv');
-        this.native.vertexAttribI4uiv(index, Array.from(value));
-    };
-    WebGL2RenderingContext.prototype._glCheckError = function (message) {
-        if (!WebGL2RenderingContext.isDebug) {
-            return;
-        }
-        console.log(message, this.getError());
-    };
-    return WebGL2RenderingContext;
-}(common_1.WebGL2RenderingContextBase));
-exports.WebGL2RenderingContext = WebGL2RenderingContext;
+        if (!(value instanceof Uint32Array)) {
+            value = new Uint32Array(value);
+        }
+        this.native.vertexAttribI4uivOffset(index, value, value.byteOffset);
+    }
+}
 //# sourceMappingURL=index.ios.js.map