diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/framework/referencerenderer/rrVertexAttrib.js | 641 |
1 files changed, 641 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/framework/referencerenderer/rrVertexAttrib.js b/dom/canvas/test/webgl-conf/checkout/deqp/framework/referencerenderer/rrVertexAttrib.js new file mode 100644 index 0000000000..f6095e2cc9 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/framework/referencerenderer/rrVertexAttrib.js @@ -0,0 +1,641 @@ +/*------------------------------------------------------------------------- + * 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'); + } + }; + +}); |