rrVertexAttrib.js (30422B)
1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES Utilities 3 * ------------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ 20 21 'use strict'; 22 goog.provide('framework.referencerenderer.rrVertexAttrib'); 23 goog.require('framework.common.tcuFloat'); 24 goog.require('framework.delibs.debase.deMath'); 25 goog.require('framework.referencerenderer.rrGenericVector'); 26 27 goog.scope(function() { 28 29 var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib; 30 var deMath = framework.delibs.debase.deMath; 31 var tcuFloat = framework.common.tcuFloat; 32 var rrGenericVector = framework.referencerenderer.rrGenericVector; 33 34 var DE_ASSERT = function(x) { 35 if (!x) 36 throw new Error('Assert failed'); 37 }; 38 39 /** 40 * rrVertexAttrib.NormalOrder 41 * @enum 42 */ 43 rrVertexAttrib.NormalOrder = { 44 T0: 0, 45 T1: 1, 46 T2: 2, 47 T3: 3 48 }; 49 50 /** 51 * rrVertexAttrib.BGRAOrder 52 * @enum 53 */ 54 rrVertexAttrib.BGRAOrder = { 55 T0: 2, 56 T1: 1, 57 T2: 0, 58 T3: 3 59 }; 60 61 /** 62 * rrVertexAttrib.VertexAttribType enum 63 * @enum 64 */ 65 rrVertexAttrib.VertexAttribType = { 66 // Can only be rrVertexAttrib.read as floats 67 FLOAT: 0, 68 HALF: 1, 69 FIXED: 2, 70 DOUBLE: 3, 71 72 // Can only be rrVertexAttrib.read as floats, will be normalized 73 NONPURE_UNORM8: 4, 74 NONPURE_UNORM16: 5, 75 NONPURE_UNORM32: 6, 76 NONPURE_UNORM_2_10_10_10_REV: 7, //!< Packed format, only size = 4 is allowed 77 78 // Clamped formats, GLES3-style conversion: max{c / (2^(b-1) - 1), -1 } 79 NONPURE_SNORM8_CLAMP: 8, 80 NONPURE_SNORM16_CLAMP: 9, 81 NONPURE_SNORM32_CLAMP: 10, 82 NONPURE_SNORM_2_10_10_10_REV_CLAMP: 11, //!< Packed format, only size = 4 is allowed 83 84 // Scaled formats, GLES2-style conversion: (2c + 1) / (2^b - 1) 85 NONPURE_SNORM8_SCALE: 12, 86 NONPURE_SNORM16_SCALE: 13, 87 NONPURE_SNORM32_SCALE: 14, 88 NONPURE_SNORM_2_10_10_10_REV_SCALE: 15, //!< Packed format, only size = 4 is allowed 89 90 // can only be rrVertexAttrib.read as float, will not be normalized 91 NONPURE_UINT8: 16, 92 NONPURE_UINT16: 17, 93 NONPURE_UINT32: 18, 94 95 NONPURE_INT8: 19, 96 NONPURE_INT16: 20, 97 NONPURE_INT32: 21, 98 99 NONPURE_UINT_2_10_10_10_REV: 22, //!< Packed format, only size = 4 is allowed 100 NONPURE_INT_2_10_10_10_REV: 23, //!< Packed format, only size = 4 is allowed 101 102 // can only be rrVertexAttrib.read as integers 103 PURE_UINT8: 24, 104 PURE_UINT16: 25, 105 PURE_UINT32: 26, 106 107 PURE_INT8: 27, 108 PURE_INT16: 28, 109 PURE_INT32: 29, 110 111 // reordered formats of gl.ARB_vertex_array_bgra 112 NONPURE_UNORM8_BGRA: 30, 113 NONPURE_UNORM_2_10_10_10_REV_BGRA: 31, 114 NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA: 32, 115 NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA: 33, 116 117 // can be rrVertexAttrib.read as anything 118 DONT_CARE: 34 //!< Do not enforce type checking when reading GENERIC attribute. Used for current client side attributes. 119 }; 120 121 /** 122 * rrVertexAttrib.VertexAttrib class 123 * @constructor 124 */ 125 rrVertexAttrib.VertexAttrib = function() { 126 /** @type {rrVertexAttrib.VertexAttribType} */ this.type = rrVertexAttrib.VertexAttribType.FLOAT; 127 /** @type {number} */ this.size = 0; 128 /** @type {number} */ this.stride = 0; 129 /** @type {number} */ this.instanceDivisor = 0; 130 /** @type {number} */ this.offset = 0; //Added this property to compensate functionality (not in original dEQP). 131 /** @type {ArrayBuffer} */ this.pointer = null; 132 /** @type {Array<number>|rrGenericVector.GenericVec4} */ this.generic; //!< Generic attribute, used if pointer is null. 133 }; 134 135 /** 136 * @param {rrVertexAttrib.VertexAttribType} type 137 * @return {number} 138 */ 139 rrVertexAttrib.getComponentSize = function(type) { 140 switch (type) { 141 case rrVertexAttrib.VertexAttribType.FLOAT: return 4; 142 case rrVertexAttrib.VertexAttribType.HALF: return 2; 143 case rrVertexAttrib.VertexAttribType.FIXED: return 4; 144 case rrVertexAttrib.VertexAttribType.DOUBLE: return 8; //sizeof(double); 145 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8: return 1; 146 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM16: return 2; 147 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM32: return 4; 148 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV: return 1; //sizeof(deUint32)/4; 149 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_CLAMP: return 1; 150 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_CLAMP: return 2; 151 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_CLAMP: return 4; 152 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP: return 1; //sizeof(deUint32)/4; 153 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_SCALE: return 1; 154 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_SCALE: return 2; 155 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_SCALE: return 4; 156 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE: return 1; //sizeof(deUint32)/4; 157 case rrVertexAttrib.VertexAttribType.NONPURE_UINT8: return 1; 158 case rrVertexAttrib.VertexAttribType.NONPURE_UINT16: return 2; 159 case rrVertexAttrib.VertexAttribType.NONPURE_UINT32: return 4; 160 case rrVertexAttrib.VertexAttribType.NONPURE_INT8: return 1; 161 case rrVertexAttrib.VertexAttribType.NONPURE_INT16: return 2; 162 case rrVertexAttrib.VertexAttribType.NONPURE_INT32: return 4; 163 case rrVertexAttrib.VertexAttribType.NONPURE_UINT_2_10_10_10_REV: return 1; //sizeof(deUint32)/4; 164 case rrVertexAttrib.VertexAttribType.NONPURE_INT_2_10_10_10_REV: return 1; //sizeof(deUint32)/4; 165 case rrVertexAttrib.VertexAttribType.PURE_UINT8: return 1; 166 case rrVertexAttrib.VertexAttribType.PURE_UINT16: return 2; 167 case rrVertexAttrib.VertexAttribType.PURE_UINT32: return 4; 168 case rrVertexAttrib.VertexAttribType.PURE_INT8: return 1; 169 case rrVertexAttrib.VertexAttribType.PURE_INT16: return 2; 170 case rrVertexAttrib.VertexAttribType.PURE_INT32: return 4; 171 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8_BGRA: return 1; 172 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV_BGRA: return 1; //sizeof(deUint32)/4; 173 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA: return 1; //sizeof(deUint32)/4; 174 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA: return 1; //sizeof(deUint32)/4; 175 default: 176 throw new Error('rrVertexAttrib.getComponentSize - Invalid type'); 177 } 178 }; 179 180 /** 181 * rrVertexAttrib.isValidVertexAttrib function 182 * @param {rrVertexAttrib.VertexAttrib} vertexAttrib 183 * @return {boolean} 184 */ 185 rrVertexAttrib.isValidVertexAttrib = function(vertexAttrib) { 186 // Trivial range checks. 187 if (!deMath.deInBounds32(vertexAttrib.type, 0, Object.keys(rrVertexAttrib.VertexAttribType).length) || 188 !deMath.deInRange32(vertexAttrib.size, 0, 4) || 189 vertexAttrib.instanceDivisor < 0) 190 return false; 191 192 // Generic attributes 193 if (!vertexAttrib.pointer && vertexAttrib.type != rrVertexAttrib.VertexAttribType.DONT_CARE) 194 return false; 195 196 // Packed formats 197 if ((vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_INT_2_10_10_10_REV || 198 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_UINT_2_10_10_10_REV || 199 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV || 200 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP || 201 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE || 202 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV_BGRA || 203 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA || 204 vertexAttrib.type == rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA) && 205 vertexAttrib.size != 4) 206 return false; 207 208 return true; 209 }; 210 211 /** 212 * rrVertexAttrib.readVertexAttrib function 213 * @param {rrVertexAttrib.VertexAttrib} vertexAttrib 214 * @param {number} instanceNdx 215 * @param {number} vertexNdx 216 * @param {rrGenericVector.GenericVecType} genericType 217 * @return {goog.NumberArray} 218 */ 219 rrVertexAttrib.readVertexAttrib = function(vertexAttrib, instanceNdx, vertexNdx, genericType) { 220 DE_ASSERT(rrVertexAttrib.isValidVertexAttrib(vertexAttrib)); 221 /** @type {goog.NumberArray} */ var dst; 222 223 var arrayType = null; 224 switch (genericType) { 225 case rrGenericVector.GenericVecType.INT32: 226 arrayType = Int32Array; 227 break; 228 case rrGenericVector.GenericVecType.UINT32: 229 arrayType = Uint32Array; 230 break; 231 case rrGenericVector.GenericVecType.FLOAT: 232 arrayType = Float32Array; 233 break; 234 } 235 236 if (vertexAttrib.pointer) { 237 /** @type {number} */ var elementNdx = (vertexAttrib.instanceDivisor != 0) ? (instanceNdx / vertexAttrib.instanceDivisor) : vertexNdx; 238 /** @type {number} */ var compSize = rrVertexAttrib.getComponentSize(vertexAttrib.type); 239 /** @type {number} */ var stride = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size * compSize); 240 /** @type {number} */ var byteOffset = vertexAttrib.offset + (elementNdx * stride); 241 242 dst = [0, 0, 0, 1]; // defaults 243 244 if (arrayType != null) { 245 dst = new arrayType(dst); 246 } 247 248 rrVertexAttrib.read(dst, vertexAttrib.type, vertexAttrib.size, new Uint8Array(vertexAttrib.pointer, byteOffset)); 249 } else { 250 dst = new arrayType(/** @type {Array<number>} */ vertexAttrib.generic.data); 251 } 252 253 return dst; 254 }; 255 256 /** 257 * rrVertexAttrib.readHalf 258 * @param {goog.NumberArray} dst 259 * @param {number} size 260 * @param {Uint8Array} ptr 261 */ 262 rrVertexAttrib.readHalf = function(dst, size, ptr) { 263 var arraysize16 = 2; //2 bytes 264 265 var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize16)); //Small buffer copy (max. 8 bytes) 266 var aligned = new Uint16Array(ptrclone.buffer); 267 268 //Reinterpret aligned's values into the dst vector. 269 dst[0] = tcuFloat.newFloat32From16(aligned[0]).getValue(); 270 if (size >= 2) dst[1] = tcuFloat.newFloat32From16(aligned[1]).getValue(); 271 if (size >= 3) dst[2] = tcuFloat.newFloat32From16(aligned[2]).getValue(); 272 if (size >= 4) dst[3] = tcuFloat.newFloat32From16(aligned[3]).getValue(); 273 }; 274 275 /** 276 * rrVertexAttrib.readFixed 277 * @param {goog.NumberArray} dst 278 * @param {number} size 279 * @param {Uint8Array} ptr 280 */ 281 /*rrVertexAttrib.readFixed = function(dst, size, ptr) { 282 var arraysize32 = 4; //4 bytes 283 284 //Reinterpret ptr as a uint16 array, 285 //assuming original ptr is 8-bits per element 286 var aligned = new Int32Array(ptr.buffer).subarray( 287 ptr.byteOffset / arraysize32, 288 (ptr.byteOffset + ptr.byteLength) / arraysize32); 289 290 //Reinterpret aligned's values into the dst vector. 291 dst[0] = aligned[0] / (1 << 16); 292 if (size >= 2) dst[1] = aligned[1] / (1 << 16); 293 if (size >= 3) dst[2] = aligned[2] / (1 << 16); 294 if (size >= 4) dst[3] = aligned[3] / (1 << 16); 295 };*/ 296 297 /** 298 * TODO: Check 64 bit numbers are handled ok 299 * rrVertexAttrib.readDouble 300 * @param {goog.NumberArray} dst 301 * @param {number} size 302 * @param {Uint8Array} ptr 303 */ 304 /*rrVertexAttrib.readDouble = function(dst, size, ptr) { 305 var arraysize64 = 8; //8 bytes 306 307 //Reinterpret 'ptr' into 'aligned' as a float64 array, 308 //assuming original ptr is 8-bits per element. 309 var aligned = new Float64Array(ptr.buffer).subarray( 310 ptr.byteOffset / arraysize64, 311 (ptr.byteOffset + ptr.byteLength) / arraysize64); 312 313 //Reinterpret aligned's values into the dst vector. 314 dst[0] = aligned[0]; 315 if (size >= 2) dst[1] = aligned[1]; 316 if (size >= 3) dst[2] = aligned[2]; 317 if (size >= 4) dst[3] = aligned[3]; 318 };*/ 319 320 /** 321 * extendSign 322 * @param {number} integerLen 323 * @param {number} integer_ (deUint32) 324 * @return {number} (deInt32) 325 */ 326 rrVertexAttrib.extendSign = function(integerLen, integer_) { 327 return new Int32Array([ 328 deMath.binaryOp( 329 0 - 330 deMath.shiftLeft( 331 deMath.binaryOp( 332 integer_, 333 deMath.shiftLeft( 334 1, 335 (integerLen - 1) 336 ), 337 deMath.BinaryOp.AND 338 ), 339 1 340 ) , 341 342 integer_, 343 deMath.BinaryOp.OR 344 ) 345 ])[0]; 346 }; 347 348 /** 349 * rrVertexAttrib.readUint2101010Rev 350 * @param {goog.NumberArray} dst 351 * @param {number} size 352 * @param {Uint8Array} ptr 353 */ 354 rrVertexAttrib.readUint2101010Rev = function(dst, size, ptr) { 355 var arraysize32 = 4; //4 bytes 356 357 var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes) 358 var aligned = new Uint32Array(ptrclone.buffer)[0]; 359 360 dst[0] = deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND); 361 if (size >= 2) dst[1] = deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND); 362 if (size >= 3) dst[2] = deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND); 363 if (size >= 4) dst[3] = deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND); 364 }; 365 366 /** 367 * rrVertexAttrib.readInt2101010Rev 368 * @param {goog.NumberArray} dst 369 * @param {number} size 370 * @param {Uint8Array} ptr 371 */ 372 rrVertexAttrib.readInt2101010Rev = function(dst, size, ptr) { 373 var arraysize32 = 4; //4 bytes 374 375 var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes) 376 var aligned = new Uint32Array(ptrclone.buffer)[0]; 377 378 dst[0] = rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND)); 379 if (size >= 2) dst[1] = rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND)); 380 if (size >= 3) dst[2] = rrVertexAttrib.extendSign(10, deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND)); 381 if (size >= 4) dst[3] = rrVertexAttrib.extendSign(2, deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND)); 382 }; 383 384 /** 385 * rrVertexAttrib.readUnorm2101010RevOrder 386 * @param {goog.NumberArray} dst 387 * @param {number} size 388 * @param {Uint8Array} ptr 389 * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order 390 */ 391 rrVertexAttrib.readUnorm2101010RevOrder = function(dst, size, ptr, order) { 392 var arraysize32 = 4; //4 bytes 393 394 //Left shift within 32-bit range as 32-bit int. 395 var range10 = new Uint32Array([deMath.shiftLeft(1, 10) - 1])[0]; 396 var range2 = new Uint32Array([deMath.shiftLeft(1, 2) - 1])[0]; 397 398 var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes) 399 var aligned = new Uint32Array(ptrclone.buffer)[0]; 400 401 dst[order.T0] = deMath.binaryOp(deMath.shiftRight(aligned, 0), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND) / range10; 402 if (size >= 2) dst[order.T1] = deMath.binaryOp(deMath.shiftRight(aligned, 10), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND) / range10; 403 if (size >= 3) dst[order.T2] = deMath.binaryOp(deMath.shiftRight(aligned, 20), deMath.shiftLeft(1, 10) - 1, deMath.BinaryOp.AND) / range10; 404 if (size >= 4) dst[order.T3] = deMath.binaryOp(deMath.shiftRight(aligned, 30), deMath.shiftLeft(1, 2) - 1, deMath.BinaryOp.AND) / range2; 405 }; 406 407 /** 408 * rrVertexAttrib.readSnorm2101010RevClampOrder 409 * @param {goog.NumberArray} dst 410 * @param {number} size 411 * @param {Uint8Array} ptr 412 * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order 413 */ 414 rrVertexAttrib.readSnorm2101010RevClampOrder = function(dst, size, ptr, order) { 415 var arraysize32 = 4; //4 bytes 416 417 //Left shift within 32-bit range as 32-bit int. 418 var range10 = new Uint32Array([deMath.shiftLeft(1, 10 - 1) - 1])[0]; 419 var range2 = new Uint32Array([deMath.shiftLeft(1, 2 - 1) - 1])[0]; 420 421 var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes) 422 var aligned = new Uint32Array(ptrclone.buffer)[0]; 423 424 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); 425 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); 426 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); 427 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); 428 }; 429 430 /** 431 * rrVertexAttrib.readSnorm2101010RevScaleOrder 432 * @param {goog.NumberArray} dst 433 * @param {number} size 434 * @param {Uint8Array} ptr 435 * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order 436 */ 437 rrVertexAttrib.readSnorm2101010RevScaleOrder = function(dst, size, ptr, order) { 438 var arraysize32 = 4; //4 bytes 439 440 //Left shift within 32-bit range as 32-bit int. 441 var range10 = new Uint32Array([deMath.shiftLeft(1, 10) - 1])[0]; 442 var range2 = new Uint32Array([deMath.shiftLeft(1, 2) - 1])[0]; 443 444 var ptrclone = new Uint8Array(ptr.subarray(0, size * arraysize32)); //Small buffer copy (max. 16 bytes) 445 var aligned = new Uint32Array(ptrclone.buffer)[0]; 446 447 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; 448 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; 449 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; 450 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; 451 }; 452 453 /** 454 * rrVertexAttrib.readUnormOrder 455 * @param {goog.NumberArray} dst 456 * @param {number} size 457 * @param {Uint8Array} ptr 458 * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order 459 * @param readAsTypeArray 460 */ 461 rrVertexAttrib.readUnormOrder = function(dst, size, ptr, order, readAsTypeArray) { 462 var arrayelementsize = readAsTypeArray.BYTES_PER_ELEMENT; 463 464 //Left shift within 32-bit range as 32-bit float. 465 var range = new Float32Array([deMath.shiftLeft(1, arrayelementsize * 8) - 1])[0]; 466 467 var ptrclone = new Uint8Array(ptr.subarray(0, size * arrayelementsize)); //Small buffer copy (max. 16 bytes) 468 var aligned = new readAsTypeArray(ptrclone.buffer); 469 470 //Reinterpret aligned's values into the dst vector. 471 dst[order.T0] = aligned[0] / range; 472 if (size >= 2) dst[order.T1] = aligned[1] / range; 473 if (size >= 3) dst[order.T2] = aligned[2] / range; 474 if (size >= 4) dst[order.T3] = aligned[3] / range; 475 }; 476 477 /** 478 * rrVertexAttrib.readSnormClamp 479 * @param {goog.NumberArray} dst 480 * @param {number} size 481 * @param {Uint8Array} ptr 482 * @param {function(new:ArrayBufferView,(Array<number>|ArrayBuffer|ArrayBufferView|null|number), number=, number=)} readAsTypeArray 483 */ 484 rrVertexAttrib.readSnormClamp = function(dst, size, ptr, readAsTypeArray) { 485 var arrayelementsize = readAsTypeArray.BYTES_PER_ELEMENT; 486 487 //Left shift within 32-bit range as 32-bit float. 488 var range = new Float32Array([deMath.shiftLeft(1, arrayelementsize * 8 - 1) - 1])[0]; 489 490 var ptrclone = new Uint8Array(ptr.subarray(0, size * arrayelementsize)); //Small buffer copy (max. 16 bytes) 491 var aligned = new readAsTypeArray(ptrclone.buffer); 492 493 //Reinterpret aligned's values into the dst vector. 494 dst[0] = Math.max(-1, aligned[0] / range); 495 if (size >= 2) dst[1] = Math.max(-1, aligned[1] / range); 496 if (size >= 3) dst[2] = Math.max(-1, aligned[2] / range); 497 if (size >= 4) dst[3] = Math.max(-1, aligned[3] / range); 498 }; 499 500 /** 501 * rrVertexAttrib.readOrder 502 * @param {goog.NumberArray} dst 503 * @param {number} size 504 * @param {Uint8Array} ptr 505 * @param {Object<rrVertexAttrib.NormalOrder|rrVertexAttrib.BGRAOrder>} order NormalOrder or BGRAOrder 506 * @param readAsTypeArray Typed Array type 507 */ 508 rrVertexAttrib.readOrder = function(dst, size, ptr, order, readAsTypeArray) { 509 var arrayelementsize = readAsTypeArray.BYTES_PER_ELEMENT; 510 511 var ptrclone = new Uint8Array(ptr.subarray(0, size * arrayelementsize)); //Small buffer copy (max. 16 bytes) 512 var aligned = new readAsTypeArray(ptrclone.buffer); 513 514 //Reinterpret aligned's values into the dst vector. 515 //(automatic in JS typed arrays). 516 dst[order.T0] = aligned[0]; 517 if (size >= 2) dst[order.T1] = aligned[1]; 518 if (size >= 3) dst[order.T2] = aligned[2]; 519 if (size >= 4) dst[order.T3] = aligned[3]; 520 }; 521 522 /** 523 * TODO: Implement readSNormScale. 524 * @param {goog.NumberArray} dst 525 * @param {rrVertexAttrib.VertexAttribType} type 526 * @param {number} size 527 * @param {Uint8Array} ptr 528 */ 529 rrVertexAttrib.read = function(dst, type, size, ptr) { 530 var order; 531 532 switch (type) { 533 case rrVertexAttrib.VertexAttribType.FLOAT: 534 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Float32Array); 535 break; 536 case rrVertexAttrib.VertexAttribType.HALF: 537 rrVertexAttrib.readHalf(dst, size, ptr); 538 break; 539 /*case rrVertexAttrib.VertexAttribType.FIXED: 540 rrVertexAttrib.readFixed(dst, size, ptr); 541 break; 542 case rrVertexAttrib.VertexAttribType.DOUBLE: 543 rrVertexAttrib.readDouble(dst, size, ptr); 544 break;*/ 545 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8: 546 rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint8Array); 547 break; 548 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM16: 549 rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint16Array); 550 break; 551 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM32: 552 rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint32Array); 553 break; 554 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV: 555 rrVertexAttrib.readUnorm2101010RevOrder(dst, size, ptr, rrVertexAttrib.NormalOrder); 556 break; 557 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_CLAMP: //Int8 558 rrVertexAttrib.readSnormClamp(dst, size, ptr, Int8Array); 559 break; 560 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_CLAMP: //Int16 561 rrVertexAttrib.readSnormClamp(dst, size, ptr, Int16Array); 562 break; 563 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_CLAMP: //Int32 564 rrVertexAttrib.readSnormClamp(dst, size, ptr, Int32Array); 565 break; 566 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP: 567 rrVertexAttrib.readSnorm2101010RevClampOrder(dst, size, ptr, rrVertexAttrib.NormalOrder); 568 break; 569 /*case rrVertexAttrib.VertexAttribType.NONPURE_SNORM8_SCALE: //Int8 570 rrVertexAttrib.readSnormScale(dst, size, ptr, Int8Array); 571 break; 572 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM16_SCALE: //Int16 573 rrVertexAttrib.readSnormScale(dst, size, ptr, Int16Array); 574 break; 575 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM32_SCALE: //Int32 576 rrVertexAttrib.readSnormScale(dst, size, ptr, Int32Array); 577 break;*/ 578 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE: 579 rrVertexAttrib.readSnorm2101010RevScaleOrder(dst, size, ptr, rrVertexAttrib.NormalOrder); 580 break; 581 case rrVertexAttrib.VertexAttribType.NONPURE_UINT_2_10_10_10_REV: 582 rrVertexAttrib.readUint2101010Rev(dst, size, ptr); 583 break; 584 case rrVertexAttrib.VertexAttribType.NONPURE_INT_2_10_10_10_REV: 585 rrVertexAttrib.readInt2101010Rev(dst, size, ptr); 586 break; 587 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM8_BGRA: 588 rrVertexAttrib.readUnormOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder, Uint8Array); 589 break; 590 case rrVertexAttrib.VertexAttribType.NONPURE_UNORM_2_10_10_10_REV_BGRA: 591 rrVertexAttrib.readUnorm2101010RevOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder); 592 break; 593 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA: 594 rrVertexAttrib.readSnorm2101010RevClampOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder); 595 break; 596 case rrVertexAttrib.VertexAttribType.NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA: 597 rrVertexAttrib.readSnorm2101010RevScaleOrder(dst, size, ptr, rrVertexAttrib.BGRAOrder); 598 break; 599 case rrVertexAttrib.VertexAttribType.NONPURE_UINT8: 600 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint8Array); 601 break; 602 case rrVertexAttrib.VertexAttribType.NONPURE_UINT16: 603 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint16Array); 604 break; 605 case rrVertexAttrib.VertexAttribType.NONPURE_UINT32: 606 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint32Array); 607 break; 608 case rrVertexAttrib.VertexAttribType.NONPURE_INT8: 609 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int8Array); 610 break; 611 case rrVertexAttrib.VertexAttribType.NONPURE_INT16: 612 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int16Array); 613 break; 614 case rrVertexAttrib.VertexAttribType.NONPURE_INT32: 615 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int32Array); 616 break; 617 case rrVertexAttrib.VertexAttribType.PURE_UINT8: 618 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint8Array); 619 break; 620 case rrVertexAttrib.VertexAttribType.PURE_UINT16: 621 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint16Array); 622 break; 623 case rrVertexAttrib.VertexAttribType.PURE_UINT32: 624 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Uint32Array); 625 break; 626 case rrVertexAttrib.VertexAttribType.PURE_INT8: 627 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int8Array); 628 break; 629 case rrVertexAttrib.VertexAttribType.PURE_INT16: 630 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int16Array); 631 break; 632 case rrVertexAttrib.VertexAttribType.PURE_INT32: 633 rrVertexAttrib.readOrder(dst, size, ptr, rrVertexAttrib.NormalOrder, Int32Array); 634 break; 635 636 default: 637 throw new Error('rrVertexAttrib.read - Invalid type'); 638 } 639 }; 640 641 });