@nativescript/canvas 1.0.0-alpha.1 → 1.0.0-alpha.10

package/WebGL/WebGLRenderingContext/index.android.js

@@ -13,6 +13,7 @@ import { ANGLE_instanced_arrays, EXT_blend_minmax, EXT_color_buffer_half_float,
 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);
@@ -182,6 +183,9 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
         }
         return [];
     }
+    get _isSupported() {
+        return Utils.IS_SUPPORTED_TYPED_ARRAYS_VERSION;
+    }
     bufferData(target, srcData, usage) {
         this._glCheckError('bufferData');
         this._checkArgs('bufferData', arguments);
@@ -195,7 +199,12 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 this.context.bufferData(target, srcData.nativeObject, usage);
             }
             else {
-                this.context.bufferDataByte(target, Array.from(new Uint8Array(srcData)), usage);
+                if (this._isSupported) {
+                    this.context.bufferDataByteBuffer(target, srcData, usage);
+                }
+                else {
+                    this.context.bufferDataByte(target, Array.from(new Uint8Array(srcData)), usage);
+                }
             }
             //this.context.bufferData(target, this.toNativeArray(new Uint8Array(srcData as any) as any, 'byte'), usage);
         }
@@ -207,20 +216,36 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
             }
             else {
                 if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
-                    //this.context.bufferData(target, this.toNativeArray(srcData as any, 'byte'), usage);
-                    this.context.bufferDataByte(target, Array.from(srcData), usage);
+                    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) {
-                    //this.context.bufferData(target, this.toNativeArray(srcData as any, 'short'), usage);
-                    this.context.bufferDataShort(target, Array.from(srcData), usage);
+                    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) {
-                    //this.context.bufferData(target, this.toNativeArray(srcData as any, 'int'), usage);
-                    this.context.bufferDataInt(target, Array.from(srcData), usage);
+                    if (this._isSupported) {
+                        this.context.bufferDataIntBuffer(target, srcData, usage);
+                    }
+                    else {
+                        this.context.bufferDataInt(target, Array.from(srcData), usage);
+                    }
                 }
                 else if (srcData instanceof Float32Array) {
-                    //this.context.bufferData(target, this.toNativeArray(srcData as any, 'float'), usage);
-                    this.context.bufferDataFloat(target, Array.from(srcData), usage);
+                    if (this._isSupported) {
+                        this.context.bufferDataFloatBuffer(target, srcData, usage);
+                    }
+                    else {
+                        this.context.bufferDataFloat(target, Array.from(srcData), usage);
+                    }
                 }
             }
         }
@@ -239,7 +264,12 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 this.context.bufferSubData(target, offset, srcData.nativeObject);
             }
             else {
-                this.context.bufferSubDataByte(target, offset, Array.from(new Uint8Array(srcData)));
+                if (this._isSupported) {
+                    this.context.bufferSubDataByteBuffer(target, offset, srcData);
+                }
+                else {
+                    this.context.bufferSubDataByte(target, offset, Array.from(new Uint8Array(srcData)));
+                }
             }
         }
         else if (srcData && srcData.buffer instanceof ArrayBuffer) {
@@ -250,20 +280,36 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
             }
             else {
                 if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
-                    //this.context.bufferSubData(target, offset, this.toNativeArray(srcData as any, 'byte'));
-                    this.context.bufferSubDataByte(target, offset, Array.from(srcData));
+                    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) {
-                    // this.context.bufferSubData(target, offset, this.toNativeArray(srcData as any, 'short'));
-                    this.context.bufferSubDataShort(target, offset, Array.from(srcData));
+                    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) {
-                    // this.context.bufferSubData(target, offset, this.toNativeArray(srcData as any, 'int'));
-                    this.context.bufferSubDataInt(target, offset, Array.from(srcData));
+                    if (this._isSupported) {
+                        this.context.bufferSubDataIntBuffer(target, offset, srcData);
+                    }
+                    else {
+                        this.context.bufferSubDataInt(target, offset, Array.from(srcData));
+                    }
                 }
                 else if (srcData instanceof Float32Array) {
-                    // this.context.bufferSubData(target, offset, this.toNativeArray(srcData as any, 'float'));
-                    this.context.bufferSubDataFloat(target, offset, Array.from(srcData));
+                    if (this._isSupported) {
+                        this.context.bufferSubDataFloatBuffer(target, offset, srcData);
+                    }
+                    else {
+                        this.context.bufferSubDataFloat(target, offset, Array.from(srcData));
+                    }
                 }
             }
         }
@@ -907,32 +953,52 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
             }
             else {
                 if (pixels instanceof Uint8Array) {
-                    // this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels as any, 'byte'));
-                    this.context.readPixelsByte(x, y, width, height, format, type, Array.from(pixels));
+                    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) {
-                    // this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels as any, 'short'));
-                    this.context.readPixelsShort(x, y, width, height, format, type, Array.from(pixels));
+                    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) {
-                    // this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels as any, 'int'));
-                    this.context.readPixelsInt(x, y, width, height, format, type, Array.from(pixels));
+                    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) {
-                    // this.context.readPixels(x, y, width, height, format, type, this.toNativeArray(pixels as any, 'float'));
-                    this.context.readPixelsFloat(x, y, width, height, format, type, Array.from(pixels));
+                    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 as any) as any, 'byte'));
             // @ts-ignore
             if (pixels.nativeObject) {
                 // @ts-ignore
                 this.context.readPixels(x, y, width, height, format, type, pixels.nativeObject);
             }
             else {
-                this.context.readPixelsByte(x, y, width, height, format, type, Array.from(new Uint8Array(pixels)));
+                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)));
+                }
             }
         }
     }
@@ -995,10 +1061,6 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     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.buffer.nativeObject) {
@@ -1007,20 +1069,36 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 }
                 else {
                     if (pixels instanceof Uint8Array) {
-                        // this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels as any, 'byte'));
-                        this.context.texImage2DByte(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        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) {
-                        // this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels as any, 'short'));
-                        this.context.texSubImage2DShort(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        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) {
-                        // this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels as any, 'int'));
-                        this.context.texImage2DInt(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        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) {
-                        // this.context.texImage2D(target, level, internalformat, width, height, border, format, type, this.toNativeArray(pixels as any, 'float'));
-                        this.context.texImage2DFloat(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
+                        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));
+                        }
                     }
                 }
             }
@@ -1031,8 +1109,12 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                     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 as any) as any, 'byte'));
-                    this.context.texImage2DByte(target, level, internalformat, width, height, border, format, type, Array.from(new Uint8Array(pixels)));
+                    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 {
@@ -1049,7 +1131,7 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
             else if (border instanceof ImageAsset) {
                 this.context.texImage2D(target, level, internalformat, width, height, border.native);
             }
-            else if (border instanceof ImageBitmap) {
+            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) {
@@ -1076,8 +1158,6 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 this.context.texImage2D(target, level, internalformat, width, height, border._canvas.android);
             }
         }
-        // this.blendFunc(this.SRC_ALPHA, this.ZERO);
-        // this.disable(this.BLEND);
     }
     texParameterf(target, pname, param) {
         this._glCheckError('texParameterf');
@@ -1099,32 +1179,52 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
                 }
                 else {
                     if (pixels instanceof Uint8Array) {
-                        // this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels as any, 'byte'));
-                        this.context.texSubImage2DByte(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        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) {
-                        // this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels as any, 'short'));
-                        this.context.texSubImage2DShort(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        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) {
-                        // this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels as any, 'int'));
-                        this.context.texSubImage2DInt(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        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) {
-                        // this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.toNativeArray(pixels as any, 'float'));
-                        this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
+                        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 as any) as any, 'byte'));
                 // @ts-ignore
                 if (pixels.nativeObject) {
                     // @ts-ignore
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels.nativeObject);
                 }
                 else {
-                    this.context.texSubImage2DByte(target, level, xoffset, yoffset, width, height, format, type, Array.from(new Uint8Array(pixels)));
+                    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)));
+                    }
                 }
             }
         }
@@ -1138,6 +1238,9 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
             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 ImageSource) {
                     this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format._imageSource.android);
@@ -1167,20 +1270,44 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     uniform1iv(location, value) {
         this._glCheckError('uniform1iv');
         this._checkArgs('uniform1iv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform1iv(loc, value);
+        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);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform1fv(loc, value);
+        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');
@@ -1197,20 +1324,44 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     uniform2iv(location, value) {
         this._glCheckError('uniform2iv');
         this._checkArgs('uniform2iv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform2iv(loc, value);
+        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);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform2fv(loc, value);
+        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');
@@ -1227,20 +1378,44 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     uniform3iv(location, value) {
         this._glCheckError('uniform3iv');
         this._checkArgs('uniform3iv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform3iv(loc, value);
+        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);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform3fv(loc, value);
+        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');
@@ -1257,20 +1432,44 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     uniform4iv(location, value) {
         this._glCheckError('uniform4iv');
         this._checkArgs('uniform4iv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform4iv(loc, value);
+        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);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniform4fv(loc, value);
+        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');
@@ -1281,29 +1480,65 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     uniformMatrix2fv(location, transpose, value) {
         this._glCheckError('uniformMatrix2fv');
         this._checkArgs('uniformMatrix2fv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniformMatrix2fv(loc, transpose, value);
+        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);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniformMatrix3fv(loc, transpose, value);
+        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);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
-        }
         const loc = location ? location.native : 0;
-        this.context.uniformMatrix4fv(loc, transpose, value);
+        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');
@@ -1325,10 +1560,22 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     vertexAttrib1fv(index, value) {
         this._glCheckError('vertexAttrib1fv');
         this._checkArgs('vertexAttrib1fv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
+        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);
+            }
         }
-        this.context.vertexAttrib1fv(index, value);
     }
     vertexAttrib2f(index, v0, v1) {
         this._glCheckError('vertexAttrib2f');
@@ -1338,10 +1585,22 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     vertexAttrib2fv(index, value) {
         this._glCheckError('vertexAttrib2fv');
         this._checkArgs('vertexAttrib2fv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
+        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);
+            }
         }
-        this.context.vertexAttrib2fv(index, value);
     }
     vertexAttrib3f(index, v0, v1, v2) {
         this._glCheckError('vertexAttrib3f');
@@ -1351,10 +1610,22 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     vertexAttrib3fv(index, value) {
         this._glCheckError('vertexAttrib3fv');
         this._checkArgs('vertexAttrib3fv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
+        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);
+            }
         }
-        this.context.vertexAttrib3fv(index, value);
     }
     vertexAttrib4f(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttrib4f');
@@ -1364,10 +1635,22 @@ export class WebGLRenderingContext extends WebGLRenderingContextBase {
     vertexAttrib4fv(index, value) {
         this._glCheckError('vertexAttrib4fv');
         this._checkArgs('vertexAttrib4fv', arguments);
-        if (!Array.isArray(value)) {
-            value = Array.from(value);
+        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);
+            }
         }
-        this.context.vertexAttrib4fv(index, value);
     }
     vertexAttribPointer(index, size, type, normalized, stride, offset) {
         this._glCheckError('vertexAttribPointer');