/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

'use strict';
goog.provide('framework.referencerenderer.rrVertexAttrib');
goog.require('framework.common.tcuFloat');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.referencerenderer.rrGenericVector');

goog.scope(function() {

var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib;
var deMath = framework.delibs.debase.deMath;
var tcuFloat = framework.common.tcuFloat;
var rrGenericVector = framework.referencerenderer.rrGenericVector;

    var DE_ASSERT = function(x) {
        if (!x)
            throw new Error('Assert failed');
    };

    /**
     * rrVertexAttrib.NormalOrder
     * @enum
     */
    rrVertexAttrib.NormalOrder = {
        T0: 0,
        T1: 1,
        T2: 2,
        T3: 3
    };

    /**
     * rrVertexAttrib.BGRAOrder
     * @enum
     */
    rrVertexAttrib.BGRAOrder = {
        T0: 2,
        T1: 1,
        T2: 0,
        T3: 3
    };

    /**
     * rrVertexAttrib.VertexAttribType enum
     * @enum
     */
    rrVertexAttrib.VertexAttribType = {
        // Can only be rrVertexAttrib.read as floats
        FLOAT: 0,
        HALF: 1,
        FIXED: 2,
        DOUBLE: 3,

        // Can only be rrVertexAttrib.read as floats, will be normalized
        NONPURE_UNORM8: 4,
        NONPURE_UNORM16: 5,
        NONPURE_UNORM32: 6,
        NONPURE_UNORM_2_10_10_10_REV: 7, //!< Packed format, only size = 4 is allowed

        // Clamped formats, GLES3-style conversion: max{c / (2^(b-1) - 1), -1 }
        NONPURE_SNORM8_CLAMP: 8,
        NONPURE_SNORM16_CLAMP: 9,
        NONPURE_SNORM32_CLAMP: 10,
        NONPURE_SNORM_2_10_10_10_REV_CLAMP: 11, //!< Packed format, only size = 4 is allowed

        // Scaled formats, GLES2-style conversion: (2c + 1) / (2^b - 1)
        NONPURE_SNORM8_SCALE: 12,
        NONPURE_SNORM16_SCALE: 13,
        NONPURE_SNORM32_SCALE: 14,
        NONPURE_SNORM_2_10_10_10_REV_SCALE: 15, //!< Packed format, only size = 4 is allowed

        // can only be rrVertexAttrib.read as float, will not be normalized
        NONPURE_UINT8: 16,
        NONPURE_UINT16: 17,
        NONPURE_UINT32: 18,

        NONPURE_INT8: 19,
        NONPURE_INT16: 20,
        NONPURE_INT32: 21,

        NONPURE_UINT_2_10_10_10_REV: 22, //!< Packed format, only size = 4 is allowed
        NONPURE_INT_2_10_10_10_REV: 23, //!< Packed format, only size = 4 is allowed

        // can only be rrVertexAttrib.read as integers
        PURE_UINT8: 24,
        PURE_UINT16: 25,
        PURE_UINT32: 26,

        PURE_INT8: 27,
        PURE_INT16: 28,
        PURE_INT32: 29,

        // reordered formats of gl.ARB_vertex_array_bgra
        NONPURE_UNORM8_BGRA: 30,
        NONPURE_UNORM_2_10_10_10_REV_BGRA: 31,
        NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA: 32,
        NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA: 33,

        // can be rrVertexAttrib.read as anything
        DONT_CARE: 34 //!< Do not enforce type checking when reading GENERIC attribute. Used for current client side attributes.
    };

    /**
     * rrVertexAttrib.VertexAttrib class
     * @constructor
     */
    rrVertexAttrib.VertexAttrib = function() {
        /** @type {rrVertexAttrib.VertexAttribType} */ this.type = rrVertexAttrib.VertexAttribType.FLOAT;
        /** @type {number} */ this.size = 0;
        /** @type {number} */ this.stride = 0;
        /** @type {number} */ this.instanceDivisor = 0;
        /** @type {number} */ this.offset = 0; //Added this property to compensate functionality (not in original dEQP).
        /** @type {ArrayBuffer} */ this.pointer = null;
        /** @type {Array<number>|rrGenericVector.GenericVec4} */ this.generic; //!< Generic attribute, used if pointer is null.
    };

    /**
     * @param {rrVertexAttrib.VertexAttribType} type
     * @return {number}
     */
    rrVertexAttrib.getComponentSize = function(type) {
        switch (type) {
            case rrVertexAttrib.VertexAttribType.FLOAT: return 4;
            case rrVertexAttrib.VertexAttribType.HALF: return 2;
            case rrVertexAttrib.VertexAttribType.FIXED: return 4;
            case rrVertexAttrib.VertexAttribType.DOUBLE: return 8; //sizeof(double);
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8: return 1;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM16: return 2;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM32: return 4;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_CLAMP: return 1;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_CLAMP: return 2;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_CLAMP: return 4;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_SCALE: return 1;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_SCALE: return 2;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_SCALE: return 4;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT8: return 1;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT16: return 2;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT32: return 4;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT8: return 1;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT16: return 2;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT32: return 4;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT_2_10_10_10_REV: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT_2_10_10_10_REV: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.PURE_UINT8: return 1;
            case rrVertexAttrib.VertexAttribType.PURE_UINT16: return 2;
            case rrVertexAttrib.VertexAttribType.PURE_UINT32: return 4;
            case rrVertexAttrib.VertexAttribType.PURE_INT8: return 1;
            case rrVertexAttrib.VertexAttribType.PURE_INT16: return 2;
            case rrVertexAttrib.VertexAttribType.PURE_INT32: return 4;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8_BGRA: return 1;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV_BGRA: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA: return 1; //sizeof(deUint32)/4;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA: return 1; //sizeof(deUint32)/4;
            default:
                throw new Error('rrVertexAttrib.getComponentSize - Invalid type');
        }
    };

    /**
     * rrVertexAttrib.isValidVertexAttrib function
     * @param {rrVertexAttrib.VertexAttrib} vertexAttrib
     * @return {boolean}
     */
    rrVertexAttrib.isValidVertexAttrib = function(vertexAttrib) {
        // Trivial range checks.
        if (!deMath.deInBounds32(vertexAttrib.type, 0, Object.keys(rrVertexAttrib.VertexAttribType).length) ||
            !deMath.deInRange32(vertexAttrib.size, 0, 4) ||
            vertexAttrib.instanceDivisor < 0)
            return false;

        // Generic attributes
        if (!vertexAttrib.pointer && vertexAttrib.type != rrVertexAttrib.VertexAttribType.DONT_CARE)
            return false;

        // Packed formats
        if ((vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_INT_2_10_10_10_REV ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_UINT_2_10_10_10_REV ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV_BGRA ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA ||
            vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA) &&
            vertexAttrib.size != 4)
            return false;

        return true;
    };

    /**
     * rrVertexAttrib.readVertexAttrib function
     * @param {rrVertexAttrib.VertexAttrib} vertexAttrib
     * @param {number} instanceNdx
     * @param {number} vertexNdx
     * @param {rrGenericVector.GenericVecType} genericType
     * @return {goog.NumberArray}
     */
    rrVertexAttrib.readVertexAttrib = function(vertexAttrib, instanceNdx, vertexNdx, genericType) {
        DE_ASSERT(rrVertexAttrib.isValidVertexAttrib(vertexAttrib));
        /** @type {goog.NumberArray} */ var dst;

        var arrayType = null;
        switch (genericType) {
            case rrGenericVector.GenericVecType.INT32:
                arrayType = Int32Array;
                break;
            case rrGenericVector.GenericVecType.UINT32:
                arrayType = Uint32Array;
                break;
            case rrGenericVector.GenericVecType.FLOAT:
                arrayType = Float32Array;
                break;
        }

        if (vertexAttrib.pointer) {
            /** @type {number} */ var elementNdx = (vertexAttrib.instanceDivisor != 0) ? (instanceNdx / vertexAttrib.instanceDivisor) : vertexNdx;
            /** @type {number} */ var compSize = rrVertexAttrib.getComponentSize(vertexAttrib.type);
            /** @type {number} */ var stride = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size * compSize);
            /** @type {number} */ var byteOffset = vertexAttrib.offset + (elementNdx * stride);

            dst = [0, 0, 0, 1]; // defaults

            if (arrayType != null) {
                dst = new arrayType(dst);
            }

            rrVertexAttrib.read(dst, vertexAttrib.type, vertexAttrib.size, new Uint8Array(vertexAttrib.pointer, byteOffset));
        } else {
            dst = new arrayType(/** @type {Array<number>} */ vertexAttrib.generic.data);
        }

        return dst;
    };

    /**
     * rrVertexAttrib.readHalf
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     */
    rrVertexAttrib.readHalf = function(dst, size, ptr) {
        var arraysize16 = 2; //2 bytes

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize16)); //Small buffer copy (max. 8 bytes)
        var aligned = new Uint16Array(ptrclone.buffer);

        //Reinterpret aligned's values into the dst vector.
        dst[0] = tcuFloat.newFloat32From16(aligned[0]).getValue();
        if (size >= 2) dst[1] = tcuFloat.newFloat32From16(aligned[1]).getValue();
        if (size >= 3) dst[2] = tcuFloat.newFloat32From16(aligned[2]).getValue();
        if (size >= 4) dst[3] = tcuFloat.newFloat32From16(aligned[3]).getValue();
    };

    /**
     * rrVertexAttrib.readFixed
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     */
    /*rrVertexAttrib.readFixed = function(dst, size, ptr) {
        var arraysize32 = 4; //4 bytes

        //Reinterpret ptr as a uint16 array,
        //assuming original ptr is 8-bits per element
        var aligned = new Int32Array(ptr.buffer).subarray(
            ptr.byteOffset / arraysize32,
            (ptr.byteOffset + ptr.byteLength) / arraysize32);

        //Reinterpret aligned's values into the dst vector.
        dst[0] = aligned[0] / (1 << 16);
        if (size >= 2) dst[1] = aligned[1] / (1 << 16);
        if (size >= 3) dst[2] = aligned[2] / (1 << 16);
        if (size >= 4) dst[3] = aligned[3] / (1 << 16);
    };*/

    /**
     * TODO: Check 64 bit numbers are handled ok
     * rrVertexAttrib.readDouble
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     */
    /*rrVertexAttrib.readDouble = function(dst, size, ptr) {
        var arraysize64 = 8; //8 bytes

        //Reinterpret 'ptr' into 'aligned' as a float64 array,
        //assuming original ptr is 8-bits per element.
        var aligned = new Float64Array(ptr.buffer).subarray(
            ptr.byteOffset / arraysize64,
            (ptr.byteOffset + ptr.byteLength) / arraysize64);

        //Reinterpret aligned's values into the dst vector.
        dst[0] = aligned[0];
        if (size >= 2) dst[1] = aligned[1];
        if (size >= 3) dst[2] = aligned[2];
        if (size >= 4) dst[3] = aligned[3];
    };*/

    /**
     * extendSign
     * @param {number} integerLen
     * @param {number} integer_ (deUint32)
     * @return {number} (deInt32)
     */
    rrVertexAttrib.extendSign = function(integerLen, integer_) {
        return new Int32Array([
            deMath.binaryOp(
                0 -
                deMath.shiftLeft(
                    deMath.binaryOp(
                        integer_,
                        deMath.shiftLeft(
                            1,
                            (integerLen - 1)
                        ),
                        deMath.BinaryOp.AND
                    ),
                    1
                ) ,

integer_,
                deMath.BinaryOp.OR
            )
        ])[0];
    };

    /**
     * rrVertexAttrib.readUint2101010Rev
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     */
    rrVertexAttrib.readUint2101010Rev = function(dst, size, ptr) {
        var arraysize32 = 4; //4 bytes

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes)
        var aligned = new Uint32Array(ptrclone.buffer)[0];

        dst[0] = deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND);
        if (size >= 2) dst[1] = deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND);
        if (size >= 3) dst[2] = deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND);
        if (size >= 4) dst[3] = deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND);
    };

    /**
     * rrVertexAttrib.readInt2101010Rev
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     */
    rrVertexAttrib.readInt2101010Rev = function(dst, size, ptr) {
        var arraysize32 = 4; //4 bytes

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes)
        var aligned = new Uint32Array(ptrclone.buffer)[0];

        dst[0] = rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND));
        if (size >= 2) dst[1] = rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND));
        if (size >= 3) dst[2] = rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND));
        if (size >= 4) dst[3] = rrVertexAttrib.extendSign(2, deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND));
    };

    /**
     * rrVertexAttrib.readUnorm2101010RevOrder
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order
     */
    rrVertexAttrib.readUnorm2101010RevOrder = function(dst, size, ptr, order) {
        var arraysize32 = 4; //4 bytes

        //Left shift within 32-bit range as 32-bit int.
        var range10 = new Uint32Array([deMath.shiftLeft(1, 10) - 1])[0];
        var range2 = new Uint32Array([deMath.shiftLeft(1, 2) - 1])[0];

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes)
        var aligned = new Uint32Array(ptrclone.buffer)[0];

        dst[order.T0] = deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND) / range10;
        if (size >= 2) dst[order.T1] = deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND) / range10;
        if (size >= 3) dst[order.T2] = deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND) / range10;
        if (size >= 4) dst[order.T3] = deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND) / range2;
    };

    /**
     * rrVertexAttrib.readSnorm2101010RevClampOrder
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order
     */
    rrVertexAttrib.readSnorm2101010RevClampOrder = function(dst, size, ptr, order) {
        var arraysize32 = 4; //4 bytes

        //Left shift within 32-bit range as 32-bit int.
        var range10 = new Uint32Array([deMath.shiftLeft(1, 10 - 1) - 1])[0];
        var range2 = new Uint32Array([deMath.shiftLeft(1, 2 - 1) - 1])[0];

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes)
        var aligned = new Uint32Array(ptrclone.buffer)[0];

        dst[order.T0] = Math.max(-1.0, new Float32Array([rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND))])[0] / range10);
        if (size >= 2) dst[order.T1] = Math.max(-1.0, new Float32Array([rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND))])[0] / range10);
        if (size >= 3) dst[order.T2] = Math.max(-1.0, new Float32Array([rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND))])[0] / range10);
        if (size >= 4) dst[order.T3] = Math.max(-1.0, new Float32Array([rrVertexAttrib.extendSign(2, deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND))])[0] / range2);
    };

    /**
     * rrVertexAttrib.readSnorm2101010RevScaleOrder
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order
     */
    rrVertexAttrib.readSnorm2101010RevScaleOrder = function(dst, size, ptr, order) {
        var arraysize32 = 4; //4 bytes

        //Left shift within 32-bit range as 32-bit int.
        var range10 = new Uint32Array([deMath.shiftLeft(1, 10) - 1])[0];
        var range2 = new Uint32Array([deMath.shiftLeft(1, 2) - 1])[0];

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes)
        var aligned = new Uint32Array(ptrclone.buffer)[0];

        dst[order.T0] = new Float32Array([rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND)) * 2.0 + 1.0])[0] / range10;
        if (size >= 2) dst[order.T1] = new Float32Array([rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND)) * 2.0 + 1.0])[0] / range10;
        if (size >= 3) dst[order.T2] = new Float32Array([rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND)) * 2.0 + 1.0])[0] / range10;
        if (size >= 4) dst[order.T3] = new Float32Array([rrVertexAttrib.extendSign(2, deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND)) * 2.0 + 1.0])[0] / range2;
    };

    /**
     * rrVertexAttrib.readUnormOrder
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order
     * @param readAsTypeArray
     */
    rrVertexAttrib.readUnormOrder = function(dst, size, ptr, order, readAsTypeArray) {
        var arrayelementsize = readAsTypeArray.BYTES_PER_ELEMENT;

        //Left shift within 32-bit range as 32-bit float.
        var range = new Float32Array([deMath.shiftLeft(1, arrayelementsize * 8) - 1])[0];

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arrayelementsize)); //Small buffer copy (max. 16 bytes)
        var aligned = new readAsTypeArray(ptrclone.buffer);

        //Reinterpret aligned's values into the dst vector.
        dst[order.T0] = aligned[0] / range;
        if (size >= 2) dst[order.T1] = aligned[1] / range;
        if (size >= 3) dst[order.T2] = aligned[2] / range;
        if (size >= 4) dst[order.T3] = aligned[3] / range;
    };

    /**
     * rrVertexAttrib.readSnormClamp
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     * @param {function(new:ArrayBufferView,(Array<number>|ArrayBuffer|ArrayBufferView|null|number), number=, number=)} readAsTypeArray
     */
    rrVertexAttrib.readSnormClamp = function(dst, size, ptr, readAsTypeArray) {
        var arrayelementsize = readAsTypeArray.BYTES_PER_ELEMENT;

        //Left shift within 32-bit range as 32-bit float.
        var range = new Float32Array([deMath.shiftLeft(1, arrayelementsize * 8 - 1) - 1])[0];

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arrayelementsize)); //Small buffer copy (max. 16 bytes)
        var aligned = new readAsTypeArray(ptrclone.buffer);

        //Reinterpret aligned's values into the dst vector.
        dst[0] = Math.max(-1, aligned[0] / range);
        if (size >= 2) dst[1] = Math.max(-1, aligned[1] / range);
        if (size >= 3) dst[2] = Math.max(-1, aligned[2] / range);
        if (size >= 4) dst[3] = Math.max(-1, aligned[3] / range);
    };

    /**
     * rrVertexAttrib.readOrder
     * @param {goog.NumberArray} dst
     * @param {number} size
     * @param {Uint8Array} ptr
     * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order NormalOrder or BGRAOrder
     * @param readAsTypeArray Typed Array type
     */
    rrVertexAttrib.readOrder = function(dst, size, ptr, order, readAsTypeArray) {
        var arrayelementsize = readAsTypeArray.BYTES_PER_ELEMENT;

        var ptrclone = new Uint8Array(ptr.subarray(0, size * arrayelementsize)); //Small buffer copy (max. 16 bytes)
        var aligned = new readAsTypeArray(ptrclone.buffer);

        //Reinterpret aligned's values into the dst vector.
        //(automatic in JS typed arrays).
        dst[order.T0] = aligned[0];
        if (size >= 2) dst[order.T1] = aligned[1];
        if (size >= 3) dst[order.T2] = aligned[2];
        if (size >= 4) dst[order.T3] = aligned[3];
    };

    /**
     * TODO: Implement readSNormScale.
     * @param {goog.NumberArray} dst
     * @param {rrVertexAttrib.VertexAttribType} type
     * @param {number} size
     * @param {Uint8Array} ptr
     */
    rrVertexAttrib.read = function(dst, type, size, ptr) {
        var order;

        switch (type) {
            case rrVertexAttrib.VertexAttribType.FLOAT:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Float32Array);
                break;
            case rrVertexAttrib.VertexAttribType.HALF:
                rrVertexAttrib.readHalf(dst, size, ptr);
                break;
            /*case rrVertexAttrib.VertexAttribType.FIXED:
                rrVertexAttrib.readFixed(dst, size, ptr);
                break;
            case rrVertexAttrib.VertexAttribType.DOUBLE:
                rrVertexAttrib.readDouble(dst, size, ptr);
                break;*/
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8:
                rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint8Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM16:
                rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint16Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM32:
                rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint32Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV:
                rrVertexAttrib.readUnorm2101010RevOrder(dst, size, ptr, rrVertexAttrib.NormalOrder);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_CLAMP: //Int8
                rrVertexAttrib.readSnormClamp(dst, size, ptr, Int8Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_CLAMP: //Int16
                rrVertexAttrib.readSnormClamp(dst, size, ptr, Int16Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_CLAMP: //Int32
                rrVertexAttrib.readSnormClamp(dst, size, ptr, Int32Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP:
                rrVertexAttrib.readSnorm2101010RevClampOrder(dst, size, ptr, rrVertexAttrib.NormalOrder);
                break;
            /*case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_SCALE: //Int8
                rrVertexAttrib.readSnormScale(dst, size, ptr, Int8Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_SCALE: //Int16
                rrVertexAttrib.readSnormScale(dst, size, ptr, Int16Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_SCALE: //Int32
                rrVertexAttrib.readSnormScale(dst, size, ptr, Int32Array);
                break;*/
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE:
                rrVertexAttrib.readSnorm2101010RevScaleOrder(dst, size, ptr, rrVertexAttrib.NormalOrder);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT_2_10_10_10_REV:
                rrVertexAttrib.readUint2101010Rev(dst, size, ptr);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT_2_10_10_10_REV:
                rrVertexAttrib.readInt2101010Rev(dst, size, ptr);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8_BGRA:
                rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder, Uint8Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV_BGRA:
                rrVertexAttrib.readUnorm2101010RevOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
                rrVertexAttrib.readSnorm2101010RevClampOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
                rrVertexAttrib.readSnorm2101010RevScaleOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT8:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint8Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT16:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint16Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_UINT32:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint32Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT8:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int8Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT16:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int16Array);
                break;
            case rrVertexAttrib.VertexAttribType.NONPURE_INT32:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int32Array);
                break;
            case rrVertexAttrib.VertexAttribType.PURE_UINT8:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint8Array);
                break;
            case rrVertexAttrib.VertexAttribType.PURE_UINT16:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint16Array);
                break;
            case rrVertexAttrib.VertexAttribType.PURE_UINT32:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint32Array);
                break;
            case rrVertexAttrib.VertexAttribType.PURE_INT8:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int8Array);
                break;
            case rrVertexAttrib.VertexAttribType.PURE_INT16:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int16Array);
                break;
            case rrVertexAttrib.VertexAttribType.PURE_INT32:
                rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int32Array);
                break;

            default:
                throw new Error('rrVertexAttrib.read - Invalid type');
        }
    };

});