Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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');
}
};
});