es3fShaderMatrixTest.js (95066B)
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 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 'use strict'; 19 goog.provide('functional.gles3.es3fShaderMatrixTest'); 20 goog.require('framework.opengl.gluShaderUtil'); 21 goog.require('modules.shared.glsShaderRenderCase'); 22 goog.require('framework.common.tcuMatrix'); 23 goog.require('framework.delibs.debase.deMath'); 24 goog.require('framework.common.tcuTestCase'); 25 26 goog.scope(function() { 27 28 var es3fShaderMatrixTest= functional.gles3.es3fShaderMatrixTest; 29 var gluShaderUtil = framework.opengl.gluShaderUtil; 30 var glsShaderRenderCase = modules.shared.glsShaderRenderCase; 31 var tcuMatrix = framework.common.tcuMatrix; 32 var deMath = framework.delibs.debase.deMath; 33 var tcuTestCase = framework.common.tcuTestCase; 34 35 36 /** @const {Array<number>}*/ var s_constInFloat = [0.5, -0.2]; 37 /** @const {Array<Array<number>>}*/ var s_constInVec2 = [[1.2, 0.5], [0.5, 1.0]]; 38 /** @const {Array<Array<number>>}*/ var s_constInVec3 = [[1.1, 0.1, 0.5], [-0.2, 0.5, 0.8]]; 39 /** @const {Array<Array<number>>}*/ var s_constInVec4 = [[1.4, 0.2, -0.5, 0.7], [0.2, -1.0, 0.5, 0.8]]; 40 41 /** @typedef {function(glsShaderRenderCase.ShaderEvalContext)} */ es3fShaderMatrixTest.MatrixShaderEvalFunc; 42 43 /** @const {Array<Array<number>>}*/ var s_constInMat2x2 = [ 44 [-0.1, 1.0, -0.2, 0.0], 45 [0.8, 0.1, 0.5, -0.9] 46 ]; 47 /** @const {Array<Array<number>>}*/ var s_constInMat3x2 = [ 48 [0.8, -0.3, 0.3, 1.0, 1.2, -1.2], 49 [1.2, -1.0, 0.5, -0.8, 1.1, 0.3] 50 ]; 51 52 /** @const {Array<Array<number>>}*/ var s_constInMat4x2 = [ 53 [-0.2, 0.5, 0.0, -1.0, 1.2, -0.5, 0.3, -0.9], 54 [1.0, 0.1, -1.1, 0.6, 0.8, -1.2, -1.1, 0.7] 55 ]; 56 57 /** @const {Array<Array<number>>}*/ var s_constInMat2x3 = [ 58 [-0.6, -0.1, -0.7, -1.2, -0.2, 0.0], 59 [1.1, 0.6, 0.8, 1.0, 0.7, 0.1] 60 ]; 61 62 /** @const {Array<Array<number>>}*/ var s_constInMat3x3 = [ 63 [-0.2, 1.1, 1.2, -1.0, 1.2, 0.5, 0.7, -0.2, 1.0], 64 [-0.1, -0.1, 0.1, -0.1, -0.2, 1.0, -0.5, 0.1, -0.4] 65 ]; 66 67 /** @const {Array<Array<number>>}*/ var s_constInMat4x3 = [ 68 [-0.9, 0.0, 0.6, 0.2, 0.9, -0.1, -0.3, -0.7, -0.1, 0.1, 1.0, 0.0], 69 [0.5, 0.7, 0.7, 1.2, 1.1, 0.1, 1.0, -1.0, -0.2, -0.2, -0.3, -0.5] 70 ]; 71 72 /** @const {Array<Array<number>>}*/ var s_constInMat2x4 = [ 73 [-0.6, -1.1, -0.6, -0.6, -0.2, -0.6, -0.1, -0.1], 74 [-1.2, -1.0, 0.7, -1.0, 0.7, 0.7, -0.4, -0.3] 75 ]; 76 77 /** @const {Array<Array<number>>}*/ var s_constInMat3x4 = [ 78 [0.6, -0.4, 1.2, 0.9, 0.8, 0.4, 1.1, 0.3, 0.5, -0.2, 0.0, 1.1], 79 [-0.8, 1.2, -0.2, -1.1, -0.9, -0.5, -1.2, 1.0, 1.2, 0.1, -0.7, -0.5] 80 ]; 81 82 /** @const {Array<Array<number>>}*/ var s_constInMat4x4 = [ 83 [0.3, 0.9, -0.2, 1.0, -0.4, -0.6, 0.6, -1.0, -0.9, -0.1, 0.3, -0.2, -0.3, -0.9, 1.0, 0.1], 84 [0.4, -0.7, -0.8, 0.7, -0.4, -0.8, 0.6, -0.3, 0.7, -1.0, 0.1, -0.3, 0.2, 0.6, 0.4, -1.0] 85 ]; 86 87 // Operation info 88 89 /** 90 * @enum 91 */ 92 es3fShaderMatrixTest.OperationType = { 93 OPERATIONTYPE_BINARY_OPERATOR: 0, 94 OPERATIONTYPE_BINARY_FUNCTION: 1, 95 OPERATIONTYPE_UNARY_PREFIX_OPERATOR: 2, 96 OPERATIONTYPE_UNARY_POSTFIX_OPERATOR: 3, 97 OPERATIONTYPE_UNARY_FUNCTION: 4, 98 OPERATIONTYPE_ASSIGNMENT: 5 99 }; 100 101 /** 102 * @param {es3fShaderMatrixTest.MatrixOp} op 103 * @return {string} 104 */ 105 es3fShaderMatrixTest.getOperationName = function(op) { 106 switch (op) { 107 case es3fShaderMatrixTest.MatrixOp.OP_ADD: return '+'; 108 case es3fShaderMatrixTest.MatrixOp.OP_SUB: return '-'; 109 case es3fShaderMatrixTest.MatrixOp.OP_MUL: return '*'; 110 case es3fShaderMatrixTest.MatrixOp.OP_DIV: return '/'; 111 case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: return 'matrixCompMult'; 112 case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: return 'outerProduct'; 113 case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: return 'transpose'; 114 case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: return 'inverse'; 115 case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: return 'determinant'; 116 case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: return '+'; 117 case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: return '-'; 118 case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: return '++'; 119 case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: return '--'; 120 case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: return '++'; 121 case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: return '--'; 122 case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: return '+='; 123 case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: return '-='; 124 case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: return '*='; 125 case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: return '/='; 126 default: 127 throw new Error('Error invalid Matrix Operation'); 128 } 129 }; 130 131 /** 132 * @param {es3fShaderMatrixTest.MatrixOp} op 133 * @return {es3fShaderMatrixTest.OperationType} 134 */ 135 es3fShaderMatrixTest.getOperationType = function (op) { 136 switch (op) 137 { 138 case es3fShaderMatrixTest.MatrixOp.OP_ADD: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; 139 case es3fShaderMatrixTest.MatrixOp.OP_SUB: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; 140 case es3fShaderMatrixTest.MatrixOp.OP_MUL: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; 141 case es3fShaderMatrixTest.MatrixOp.OP_DIV: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; 142 case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION; 143 case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION; 144 case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION; 145 case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION; 146 case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION; 147 case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; 148 case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; 149 case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; 150 case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; 151 case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR; 152 case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR; 153 case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; 154 case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; 155 case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; 156 case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; 157 default: 158 throw new Error('Error invalid Matrix Operation'); 159 } 160 }; 161 162 /** 163 * @enum 164 */ 165 es3fShaderMatrixTest.MatrixType = { 166 TESTMATRIXTYPE_DEFAULT: 0, 167 TESTMATRIXTYPE_NEGATED: 1, 168 TESTMATRIXTYPE_INCREMENTED: 2, 169 TESTMATRIXTYPE_DECREMENTED: 3, 170 TESTMATRIXTYPE_NEGATED_INCREMENTED: 4, 171 TESTMATRIXTYPE_INCREMENTED_LESS: 5 172 }; 173 174 /** 175 * @param {es3fShaderMatrixTest.MatrixOp} op 176 * @return {es3fShaderMatrixTest.MatrixType} 177 */ 178 es3fShaderMatrixTest.getOperationTestMatrixType = function (op) { 179 switch(op) { 180 case es3fShaderMatrixTest.MatrixOp.OP_ADD: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 181 case es3fShaderMatrixTest.MatrixOp.OP_SUB: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 182 case es3fShaderMatrixTest.MatrixOp.OP_MUL: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 183 case es3fShaderMatrixTest.MatrixOp.OP_DIV: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 184 case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 185 case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 186 case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 187 case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 188 case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 189 case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DECREMENTED; 190 case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED_INCREMENTED; 191 case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED; 192 case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED; 193 case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED; 194 case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 195 case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; 196 case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED_LESS; 197 case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED; 198 case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DECREMENTED; 199 default: 200 throw new Error('Error invalid Matrix Operation'); 201 } 202 }; 203 204 /** 205 * @param {es3fShaderMatrixTest.MatrixOp} op 206 * @return {boolean} 207 */ 208 es3fShaderMatrixTest.isOperationBinary = function (op) { 209 return es3fShaderMatrixTest.getOperationType(op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR || 210 es3fShaderMatrixTest.getOperationType(op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION || 211 es3fShaderMatrixTest.getOperationType(op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; 212 }; 213 214 /** 215 * @param {es3fShaderMatrixTest.MatrixOp} op 216 * @return {boolean} 217 */ 218 es3fShaderMatrixTest.isOperationMatrixScalar = function (op) { 219 return op == es3fShaderMatrixTest.MatrixOp.OP_ADD || 220 op == es3fShaderMatrixTest.MatrixOp.OP_SUB || 221 op == es3fShaderMatrixTest.MatrixOp.OP_MUL || 222 op == es3fShaderMatrixTest.MatrixOp.OP_DIV; 223 }; 224 225 /** 226 * @param {es3fShaderMatrixTest.MatrixOp} op 227 * @return {boolean} 228 */ 229 es3fShaderMatrixTest.isOperationMatrixVector = function (op) { 230 return op == es3fShaderMatrixTest.MatrixOp.OP_MUL; 231 }; 232 233 234 /** 235 * @param {es3fShaderMatrixTest.MatrixOp} op 236 * @return {boolean} 237 */ 238 es3fShaderMatrixTest.isOperationArithmeticMatrixMatrix = function (op) { 239 return op == es3fShaderMatrixTest.MatrixOp.OP_MUL; 240 }; 241 242 /** 243 * @param {es3fShaderMatrixTest.MatrixOp} op 244 * @return {boolean} 245 */ 246 es3fShaderMatrixTest.isOperationComponentwiseMatrixMatrix = function (op) { 247 return op == es3fShaderMatrixTest.MatrixOp.OP_ADD || 248 op == es3fShaderMatrixTest.MatrixOp.OP_SUB || 249 op == es3fShaderMatrixTest.MatrixOp.OP_MUL || 250 op == es3fShaderMatrixTest.MatrixOp.OP_DIV || 251 op == es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL; 252 }; 253 254 /** 255 * @param {es3fShaderMatrixTest.MatrixOp} op 256 * @return {boolean} 257 */ 258 es3fShaderMatrixTest.isOperationVectorVector = function (op) { 259 return op == es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT; 260 }; 261 262 /** 263 * @param {es3fShaderMatrixTest.MatrixOp} op 264 * @return {boolean} 265 */ 266 es3fShaderMatrixTest.isOperationUnaryAnyMatrix = function (op) { 267 return op == es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE || 268 op == es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS || 269 op == es3fShaderMatrixTest.MatrixOp.OP_NEGATION || 270 op == es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT || 271 op == es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT || 272 op == es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT || 273 op == es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT; 274 }; 275 276 /** 277 * @param {es3fShaderMatrixTest.MatrixOp} op 278 * @return {boolean} 279 */ 280 es3fShaderMatrixTest.isOperationUnarySymmetricMatrix = function (op) { 281 return op == es3fShaderMatrixTest.MatrixOp.OP_INVERSE || 282 op == es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT; 283 }; 284 285 /** 286 * @param {es3fShaderMatrixTest.MatrixOp} op 287 * @return {boolean} 288 */ 289 es3fShaderMatrixTest.isOperationValueModifying = function (op) { 290 return op == es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT || 291 op == es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT || 292 op == es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT || 293 op == es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT; 294 }; 295 296 /** 297 * @param {es3fShaderMatrixTest.MatrixOp} op 298 * @return {boolean} 299 */ 300 es3fShaderMatrixTest.isOperationAssignment = function(op) { 301 return op == es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO || 302 op == es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM || 303 op == es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO || 304 op == es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO; 305 }; 306 307 /** 308 * @param {es3fShaderMatrixTest.MatrixOp} op 309 * @return {boolean} 310 */ 311 es3fShaderMatrixTest.isOperationAssignmentAnyMatrix = function(op) { 312 return op == es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO || 313 op == es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM || 314 op == es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO; 315 }; 316 317 /** 318 * @param {es3fShaderMatrixTest.MatrixOp} op 319 * @return {boolean} 320 */ 321 es3fShaderMatrixTest.isOperationAssignmentSymmetricMatrix = function(op) { 322 return op == es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO; 323 }; 324 325 // Operation nature 326 327 /** 328 * @enum 329 */ 330 es3fShaderMatrixTest.OperationNature = { 331 OPERATIONNATURE_PURE: 0, 332 OPERATIONNATURE_MUTATING: 1, 333 OPERATIONNATURE_ASSIGNMENT: 2 334 }; 335 336 /** 337 * @param {es3fShaderMatrixTest.MatrixOp} op 338 * @return {es3fShaderMatrixTest.OperationNature} 339 */ 340 es3fShaderMatrixTest.getOperationNature = function (op) { 341 if (es3fShaderMatrixTest.isOperationAssignment(op)) 342 return es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_ASSIGNMENT; 343 if (es3fShaderMatrixTest.isOperationValueModifying(op)) 344 return es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_MUTATING; 345 return es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_PURE; 346 }; 347 348 // Input value loader. 349 /** 350 * @param {es3fShaderMatrixTest.InputType} inputType 351 * @param {gluShaderUtil.DataType} typeFormat 352 * @param {glsShaderRenderCase.ShaderEvalContext} evalCtx 353 * @param {number} inputNdx 354 * @return {Array<number>|tcuMatrix.Matrix|number} 355 */ 356 es3fShaderMatrixTest.getInputValue = function (inputType, typeFormat, evalCtx, inputNdx) { 357 if (inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_CONST) { 358 switch (typeFormat) { 359 case gluShaderUtil.DataType.FLOAT: 360 return s_constInFloat[inputNdx]; 361 case gluShaderUtil.DataType.FLOAT_VEC2: 362 return s_constInVec2[inputNdx]; 363 case gluShaderUtil.DataType.FLOAT_VEC3: 364 return s_constInVec3[inputNdx]; 365 case gluShaderUtil.DataType.FLOAT_VEC4: 366 return s_constInVec4[inputNdx]; 367 case gluShaderUtil.DataType.FLOAT_MAT2: 368 return tcuMatrix.matrixFromDataArray(2, 2, s_constInMat2x2[inputNdx]); 369 case gluShaderUtil.DataType.FLOAT_MAT2X3: 370 return tcuMatrix.matrixFromDataArray(3, 2, s_constInMat2x3[inputNdx]); 371 case gluShaderUtil.DataType.FLOAT_MAT2X4: 372 return tcuMatrix.matrixFromDataArray(4, 2, s_constInMat2x4[inputNdx]); 373 case gluShaderUtil.DataType.FLOAT_MAT3X2: 374 return tcuMatrix.matrixFromDataArray(2, 3, s_constInMat3x2[inputNdx]); 375 case gluShaderUtil.DataType.FLOAT_MAT3: 376 return tcuMatrix.matrixFromDataArray(3, 3, s_constInMat3x3[inputNdx]); 377 case gluShaderUtil.DataType.FLOAT_MAT3X4: 378 return tcuMatrix.matrixFromDataArray(4, 3, s_constInMat3x4[inputNdx]); 379 case gluShaderUtil.DataType.FLOAT_MAT4X2: 380 return tcuMatrix.matrixFromDataArray(2, 4, s_constInMat4x2[inputNdx]); 381 case gluShaderUtil.DataType.FLOAT_MAT4X3: 382 return tcuMatrix.matrixFromDataArray(3, 4, s_constInMat4x3[inputNdx]); 383 case gluShaderUtil.DataType.FLOAT_MAT4: 384 return tcuMatrix.matrixFromDataArray(4, 4, s_constInMat4x4[inputNdx]); 385 } 386 } else if (inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) { 387 switch (typeFormat) { 388 case gluShaderUtil.DataType.FLOAT: 389 return evalCtx.coords[0]; 390 case gluShaderUtil.DataType.FLOAT_VEC2: 391 return deMath.swizzle(evalCtx.coords, [0, 1]); 392 case gluShaderUtil.DataType.FLOAT_VEC3: 393 return deMath.swizzle(evalCtx.coords, [0, 1, 2]); 394 case gluShaderUtil.DataType.FLOAT_VEC4: 395 return deMath.swizzle(evalCtx.coords, [0, 1, 2, 3]); 396 case gluShaderUtil.DataType.FLOAT_MAT2: 397 var m = new tcuMatrix.Matrix(2, 2); 398 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1])); 399 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1])); 400 return m; 401 case gluShaderUtil.DataType.FLOAT_MAT2X3: 402 var m = new tcuMatrix.Matrix(3, 2); 403 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2])); 404 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2])); 405 return m; 406 case gluShaderUtil.DataType.FLOAT_MAT2X4: 407 var m = new tcuMatrix.Matrix(4, 2); 408 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2, 3])); 409 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2, 3])); 410 return m; 411 case gluShaderUtil.DataType.FLOAT_MAT3X2: 412 var m = new tcuMatrix.Matrix(2, 3); 413 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1])); 414 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1])); 415 m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1])); 416 return m; 417 case gluShaderUtil.DataType.FLOAT_MAT3: 418 var m = new tcuMatrix.Matrix(3, 3); 419 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2])); 420 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2])); 421 m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1, 2])); 422 return m; 423 case gluShaderUtil.DataType.FLOAT_MAT3X4: 424 var m = new tcuMatrix.Matrix(4, 3); 425 m.setCol(0, evalCtx.in_[0]); 426 m.setCol(1, evalCtx.in_[1]); 427 m.setCol(2, evalCtx.in_[2]); 428 return m; 429 case gluShaderUtil.DataType.FLOAT_MAT4X2: 430 var m = new tcuMatrix.Matrix(2, 4); 431 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1])); 432 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1])); 433 m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1])); 434 m.setCol(3, deMath.swizzle(evalCtx.in_[3], [0, 1])); 435 return m; 436 case gluShaderUtil.DataType.FLOAT_MAT4X3: 437 var m = new tcuMatrix.Matrix(3, 4); 438 m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2])); 439 m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2])); 440 m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1, 2])); 441 m.setCol(3, deMath.swizzle(evalCtx.in_[3], [0, 1, 2])); 442 return m; 443 case gluShaderUtil.DataType.FLOAT_MAT4: 444 var m = new tcuMatrix.Matrix(4, 4); 445 m.setCol(0, evalCtx.in_[0]); 446 m.setCol(1, evalCtx.in_[1]); 447 m.setCol(2, evalCtx.in_[2]); 448 m.setCol(3, evalCtx.in_[3]); 449 return m; 450 } 451 } 452 throw new Error('Invalid input type'); 453 }; 454 455 /** 456 * @param {Array<number>} value 457 * @return {Array<number>} 458 */ 459 es3fShaderMatrixTest.reduceVecToVec3 = function (value) { 460 if (value.length == 3) { 461 return value; 462 } else if (value.length == 2) { 463 return deMath.swizzle(value, [0, 1, 0]) 464 } else { 465 return [value[0], value[1], value[2] + value[3]]; 466 } 467 }; 468 469 /** 470 * @param {tcuMatrix.Matrix} value 471 * @return {Array<number>} 472 */ 473 es3fShaderMatrixTest.reduceMatToVec3 = function (value) { 474 if (value.cols == 2) { 475 if (value.rows == 2) { 476 // mat2 477 return [value.get(0, 0), value.get(0, 1), value.get(1, 0) + value.get(1, 1)]; 478 } else if (value.rows == 3){ 479 //mat2x3 480 return deMath.add(value.getColumn(0), value.getColumn(1)); 481 } else { 482 //mat2x4 483 return deMath.add(deMath.swizzle(value.getColumn(0), [0, 1, 2]), deMath.swizzle(value.getColumn(1), [1, 2, 3])); 484 } 485 } else if (value.cols == 3) { 486 if (value.rows == 2) { 487 return [value.get(0, 0) + value.get(1, 0), value.get(0, 1) + value.get(1, 1), value.get(0, 2) + value.get(1, 2)]; 488 } else if (value.rows == 3) { 489 return deMath.add(deMath.add(value.getColumn(0), value.getColumn(1)), value.getColumn(2)); 490 } else { 491 return deMath.add(deMath.add(deMath.swizzle(value.getColumn(0), [0, 1, 2]), deMath.swizzle(value.getColumn(1), [1, 2, 3])), deMath.swizzle(value.getColumn(2), [2, 3, 0])) 492 } 493 } else { 494 if (value.rows == 2) { 495 return [value.get(0, 0) + value.get(1, 0) + value.get(0, 3), value.get(0, 1) + value.get(1, 1) + value.get(1, 3), value.get(0, 2) + value.get(1, 2)]; 496 } else if (value.rows == 3) { 497 return deMath.add(deMath.add(deMath.add(value.getColumn(0), value.getColumn(1)), value.getColumn(2)), value.getColumn(3)); 498 } else { 499 return deMath.add(deMath.add(deMath.add(deMath.swizzle(value.getColumn(0), [0, 1, 2]), deMath.swizzle(value.getColumn(1), [1, 2, 3])), deMath.swizzle(value.getColumn(2), [2, 3, 0])), deMath.swizzle(value.getColumn(3), [3, 0, 1])); 500 } 501 } 502 }; 503 504 /** 505 * @param {Array<number>|tcuMatrix.Matrix|number} value 506 * @return {Array<number>} 507 */ 508 es3fShaderMatrixTest.reduceToVec3 = function (value) { 509 if (value instanceof tcuMatrix.Matrix) 510 return es3fShaderMatrixTest.reduceMatToVec3(value); 511 else if (value instanceof Array) 512 return es3fShaderMatrixTest.reduceVecToVec3(value); 513 else 514 throw new Error('Impossible case'); 515 }; 516 517 es3fShaderMatrixTest.add = function (a, b) { 518 if (a instanceof tcuMatrix.Matrix) { 519 if (b instanceof tcuMatrix.Matrix) 520 return tcuMatrix.add(a, b); 521 else if (b instanceof Array) 522 throw new Error('Unimplemented'); 523 else 524 return tcuMatrix.addMatScal(a, b); 525 } 526 else { 527 if (b instanceof tcuMatrix.Matrix) 528 throw new Error('Unimplemented'); 529 else 530 return deMath.add(a, b); 531 } 532 }; 533 534 es3fShaderMatrixTest.subtract = function (a, b) { 535 if (a instanceof tcuMatrix.Matrix) { 536 if (b instanceof tcuMatrix.Matrix) 537 return tcuMatrix.subtract(a, b); 538 else if (b instanceof Array) 539 throw new Error('Unimplemented'); 540 else 541 return tcuMatrix.subtractMatScal(a, b); 542 } 543 else { 544 if (b instanceof tcuMatrix.Matrix) 545 throw new Error('Unimplemented'); 546 else 547 return deMath.subtract(a, b); 548 } 549 }; 550 551 es3fShaderMatrixTest.multiply = function (a, b) { 552 if (a instanceof tcuMatrix.Matrix) { 553 if (b instanceof tcuMatrix.Matrix) 554 return tcuMatrix.multiply(a, b); 555 else if (b instanceof Array) 556 return tcuMatrix.multiplyMatVec(a, b); 557 else 558 return tcuMatrix.multiplyMatScal(a, b); 559 } else { 560 if (b instanceof tcuMatrix.Matrix) 561 return tcuMatrix.multiplyVecMat(a, b); 562 else 563 return deMath.multiply(a, b); 564 } 565 }; 566 567 es3fShaderMatrixTest.divide = function (a, b) { 568 if (a instanceof tcuMatrix.Matrix) { 569 if (b instanceof tcuMatrix.Matrix) 570 return tcuMatrix.divide(a, b); 571 else if (b instanceof Array) 572 throw new Error('Unimplemented'); 573 else 574 return tcuMatrix.divideMatScal(a, b); 575 } 576 else { 577 if (b instanceof tcuMatrix.Matrix) 578 throw new Error('Unimplemented'); 579 else 580 return deMath.divide(a, b); 581 } 582 }; 583 584 585 /** 586 * @param {tcuMatrix.Matrix} a 587 * @param {tcuMatrix.Matrix} b 588 * @return {tcuMatrix.Matrix} 589 */ 590 es3fShaderMatrixTest.matrixCompMult = function (a, b) { 591 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(a.rows, a.cols); 592 593 for (var r = 0; r < a.rows; ++r) { 594 for (var c = 0; c < a.cols; ++c) { 595 retVal.set(r, c, a.get(r, c) * b.get(r, c)); 596 } 597 } 598 return retVal; 599 }; 600 601 /** 602 * @param {tcuMatrix.Matrix} mat 603 * @return {tcuMatrix.Matrix} 604 */ 605 es3fShaderMatrixTest.transpose = function (mat) { 606 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.cols, mat.rows); 607 608 for (var r = 0; r < mat.rows; ++r) { 609 for (var c = 0; c < mat.cols; ++c) { 610 retVal.set(c, r, mat.get(r, c)); 611 } 612 } 613 614 return retVal; 615 }; 616 617 /** 618 * @param {tcuMatrix.Matrix} mat 619 * @return {number} 620 */ 621 es3fShaderMatrixTest.determinantMat2 = function (mat) { 622 return mat.get(0, 0) * mat.get(1, 1) - mat.get(1, 0) * mat.get(0,1); 623 }; 624 625 /** 626 * @param {tcuMatrix.Matrix} mat 627 * @return {number} 628 */ 629 es3fShaderMatrixTest.determinantMat3 = function (mat) { 630 return + mat.get(0, 0) * mat.get(1, 1) * mat.get(2, 2) 631 + mat.get(0, 1) * mat.get(1, 2) * mat.get(2, 0) 632 + mat.get(0, 2) * mat.get(1, 0) * mat.get(2, 1) 633 - mat.get(0, 0) * mat.get(1, 2) * mat.get(2, 1) 634 - mat.get(0, 1) * mat.get(1, 0) * mat.get(2, 2) 635 - mat.get(0, 2) * mat.get(1, 1) * mat.get(2, 0); 636 }; 637 638 /** 639 * @param {tcuMatrix.Matrix} mat 640 * @return {number} 641 */ 642 es3fShaderMatrixTest.determinantMat4 = function (mat) { 643 /** @type {Array<Array<number>>} */ var minorMatrices = [ 644 [ 645 mat.get(1, 1), mat.get(2, 1), mat.get(3, 1), 646 mat.get(1, 2), mat.get(2, 2), mat.get(3, 2), 647 mat.get(1, 3), mat.get(2, 3), mat.get(3, 3) 648 ], 649 [ 650 mat.get(1, 0), mat.get(2, 0), mat.get(3, 0), 651 mat.get(1, 2), mat.get(2, 2), mat.get(3, 2), 652 mat.get(1, 3), mat.get(2, 3), mat.get(3, 3) 653 ], 654 [ 655 mat.get(1, 0), mat.get(2, 0), mat.get(3, 0), 656 mat.get(1, 1), mat.get(2, 1), mat.get(3, 1), 657 mat.get(1, 3), mat.get(2, 3), mat.get(3, 3) 658 ], 659 [ 660 mat.get(1, 0), mat.get(2, 0), mat.get(3, 0), 661 mat.get(1, 1), mat.get(2, 1), mat.get(3, 1), 662 mat.get(1, 2), mat.get(2, 2), mat.get(3, 2) 663 ] 664 ]; 665 666 return + mat.get(0, 0) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[0])) 667 - mat.get(0, 1) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[1])) 668 + mat.get(0, 2) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[2])) 669 - mat.get(0, 3) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[3])); 670 }; 671 672 /** 673 * @param {tcuMatrix.Matrix} mat 674 * @return {number} 675 */ 676 es3fShaderMatrixTest.determinant = function (mat) { 677 if (mat.rows == 2) { 678 return es3fShaderMatrixTest.determinantMat2(mat); 679 } else if (mat.rows == 3) { 680 return es3fShaderMatrixTest.determinantMat3(mat); 681 } else { 682 return es3fShaderMatrixTest.determinantMat4(mat); 683 } 684 }; 685 686 /** 687 * @param {tcuMatrix.Matrix} mat 688 * @return {tcuMatrix.Matrix} 689 */ 690 es3fShaderMatrixTest.inverseMat2 = function (mat) { 691 /** @type {number} */ var det = es3fShaderMatrixTest.determinant(mat); 692 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Mat2(); 693 694 if (det == 0.0) { 695 throw new Error('Wrong determinant') 696 } 697 698 retVal.set(0, 0, mat.get(1, 1) / det); 699 retVal.set(0, 1, -mat.get(0, 1) / det); 700 retVal.set(1, 0, -mat.get(1, 0) / det); 701 retVal.set(1, 1, mat.get(0, 0) / det); 702 703 return retVal; 704 }; 705 706 /** 707 * @param {tcuMatrix.Matrix} mat 708 * @return {tcuMatrix.Matrix} 709 */ 710 es3fShaderMatrixTest.inverseMat3 = function (mat) { 711 if (es3fShaderMatrixTest.determinant(mat) == 0.0) { 712 throw new Error('Wrong determinant') 713 } 714 715 /** @type {Array<number>} */ var areaA = [mat.get(0, 0), mat.get(0, 1), mat.get(1, 0), mat.get(1,1)]; 716 /** @type {Array<number>} */ var areaB = [mat.get(0, 2), mat.get(1, 2)]; 717 /** @type {Array<number>} */ var areaC = [mat.get(2, 0), mat.get(2, 1)]; 718 /** @type {Array<number>} */ var areaD = [mat.get(2,2)]; 719 720 /** @type {tcuMatrix.Matrix} */ var invA = es3fShaderMatrixTest.inverse(tcuMatrix.matrixFromDataArray(2, 2, areaA)); 721 /** @type {tcuMatrix.Matrix} */ var matB = tcuMatrix.matrixFromDataArray(2, 1, areaB); 722 /** @type {tcuMatrix.Matrix} */ var matC = tcuMatrix.matrixFromDataArray(1, 2, areaC); 723 /** @type {tcuMatrix.Matrix} */ var matD = tcuMatrix.matrixFromDataArray(1, 1, areaD); 724 725 /** @type {tcuMatrix.Matrix} */ var tmp = tcuMatrix.subtract(matD, tcuMatrix.multiply(matC, tcuMatrix.multiply(invA, matB))); 726 /** @type {number} */ var schurComplement = 1.0 / tmp.get(0, 0); 727 /** @type {tcuMatrix.Matrix} */ var zeroMat = new tcuMatrix.Matrix(2, 2, 0); 728 729 /** @type {tcuMatrix.Matrix} */ var blockA = tcuMatrix.add(invA, tcuMatrix.multiply(tcuMatrix.multiply(invA, tcuMatrix.multiply(tcuMatrix.multiplyMatScal(matB, schurComplement), matC)), invA)); 730 /** @type {tcuMatrix.Matrix} */ var blockB = tcuMatrix.multiplyMatScal(tcuMatrix.multiply(tcuMatrix.subtract(zeroMat, invA), matB), schurComplement); 731 /** @type {tcuMatrix.Matrix} */ var blockC = tcuMatrix.multiply(matC, tcuMatrix.multiplyMatScal(invA, - schurComplement)); 732 /** @type {number} */ var blockD = schurComplement; 733 734 /** @type {Array<number>} */ var result = [ 735 blockA.get(0, 0), blockA.get(0, 1), blockB.get(0, 0), 736 blockA.get(1, 0), blockA.get(1, 1), blockB.get(1, 0), 737 blockC.get(0, 0), blockC.get(0, 1), blockD 738 ]; 739 740 return tcuMatrix.matrixFromDataArray(3, 3, result); 741 } 742 743 /** 744 * @param {tcuMatrix.Matrix} mat 745 * @return {tcuMatrix.Matrix} 746 */ 747 es3fShaderMatrixTest.inverseMat4 = function (mat) { 748 // Blockwise inversion 749 if (es3fShaderMatrixTest.determinant(mat) == 0.0) { 750 throw new Error('Wrong determinant') 751 } 752 753 /** @type {Array<number>} */ var areaA = [ 754 mat.get(0, 0), mat.get(0, 1), 755 mat.get(1, 0), mat.get(1, 1) 756 ]; 757 /** @type {Array<number>} */ var areaB = [ 758 mat.get(0, 2), mat.get(0, 3), 759 mat.get(1, 2), mat.get(1, 3) 760 ]; 761 /** @type {Array<number>} */ var areaC = [ 762 mat.get(2, 0), mat.get(2, 1), 763 mat.get(3, 0), mat.get(3, 1) 764 ]; 765 /** @type {Array<number>} */ var areaD = [ 766 mat.get(2, 2), mat.get(2, 3), 767 mat.get(3, 2), mat.get(3, 3) 768 ]; 769 770 /** @type {tcuMatrix.Matrix} */ var invA = es3fShaderMatrixTest.inverse(tcuMatrix.matrixFromDataArray(2, 2, areaA)); 771 /** @type {tcuMatrix.Matrix} */ var matB = tcuMatrix.matrixFromDataArray(2, 2, areaB); 772 /** @type {tcuMatrix.Matrix} */ var matC = tcuMatrix.matrixFromDataArray(2, 2, areaC); 773 /** @type {tcuMatrix.Matrix} */ var matD = tcuMatrix.matrixFromDataArray(2, 2, areaD); 774 775 /** @type {tcuMatrix.Matrix} */ var schurComplement = es3fShaderMatrixTest.inverse(tcuMatrix.subtract(matD, (tcuMatrix.multiply(matC, tcuMatrix.multiply(invA, matB))))); 776 /** @type {tcuMatrix.Matrix} */ var zeroMat = new tcuMatrix.Matrix(2, 2, 0); 777 778 /** @type {tcuMatrix.Matrix} */ var blockA = tcuMatrix.add(invA, tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.multiply(invA, matB), schurComplement), matC), invA)); 779 /** @type {tcuMatrix.Matrix} */ var blockB = tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.subtract(zeroMat, invA), matB), schurComplement); 780 /** @type {tcuMatrix.Matrix} */ var blockC = tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.subtract(zeroMat, schurComplement),matC), invA); 781 /** @type {tcuMatrix.Matrix} */ var blockD = schurComplement; 782 783 /** @type {Array<number>} */ var result = [ 784 blockA.get(0, 0), blockA.get(0, 1), blockB.get(0, 0), blockB.get(0, 1), 785 blockA.get(1, 0), blockA.get(1, 1), blockB.get(1, 0), blockB.get(1, 1), 786 blockC.get(0, 0), blockC.get(0, 1), blockD.get(0, 0), blockD.get(0, 1), 787 blockC.get(1, 0), blockC.get(1, 1), blockD.get(1, 0), blockD.get(1, 1) 788 ]; 789 790 return tcuMatrix.matrixFromDataArray(4, 4, result); 791 }; 792 793 /** 794 * @param {tcuMatrix.Matrix} mat 795 * @return {tcuMatrix.Matrix} 796 */ 797 es3fShaderMatrixTest.inverse = function (mat) { 798 if (mat.cols == 2) { 799 return es3fShaderMatrixTest.inverseMat2(mat) 800 } else if (mat.cols == 3) { 801 return es3fShaderMatrixTest.inverseMat3(mat) 802 } else { 803 return es3fShaderMatrixTest.inverseMat4(mat) 804 } 805 }; 806 807 /** 808 * @param {tcuMatrix.Matrix} mat 809 * @return {tcuMatrix.Matrix} 810 */ 811 es3fShaderMatrixTest.negate = function (mat) { 812 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.rows, mat.cols); 813 814 for (var r = 0; r < mat.rows; ++r) 815 for (var c = 0; c < mat.cols; ++c) 816 retVal.set(r,c, -mat.get(r, c)); 817 818 return retVal; 819 }; 820 821 /** 822 * @param {tcuMatrix.Matrix} mat 823 * @return {tcuMatrix.Matrix} 824 */ 825 es3fShaderMatrixTest.increment = function (mat) { 826 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.rows, mat.cols); 827 828 for (var r = 0; r < mat.rows; ++r) 829 for (var c = 0; c < mat.cols; ++c) 830 retVal.set(r,c, mat.get(r, c) + 1.0); 831 832 return retVal; 833 }; 834 835 /** 836 * @param {tcuMatrix.Matrix} mat 837 * @return {tcuMatrix.Matrix} 838 */ 839 es3fShaderMatrixTest.decrement = function (mat) { 840 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.rows, mat.cols); 841 842 for (var r = 0; r < mat.rows; ++r) 843 for (var c = 0; c < mat.cols; ++c) 844 retVal.set(r,c, mat.get(r, c) - 1.0); 845 846 return retVal; 847 }; 848 849 /** 850 * @param {Array<number>} a 851 * @param {Array<number>} b 852 * @return {tcuMatrix.Matrix} 853 */ 854 es3fShaderMatrixTest.outerProduct = function (a, b) { 855 /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(b.length, a.length); 856 857 for (var r = 0; r < b.length; ++r) { 858 for (var c = 0; c < a.length; ++c) { 859 retVal.set(r, c, a[c] * b[r]); 860 } 861 } 862 863 return es3fShaderMatrixTest.transpose(retVal); 864 }; 865 866 /** 867 * @enum 868 */ 869 es3fShaderMatrixTest.InputType = { 870 INPUTTYPE_CONST: 0, 871 INPUTTYPE_UNIFORM: 1, 872 INPUTTYPE_DYNAMIC: 2 873 }; 874 875 /** 876 * @enum 877 */ 878 es3fShaderMatrixTest.MatrixOp = { 879 OP_ADD: 0, 880 OP_SUB: 1, 881 OP_MUL: 2, 882 OP_DIV: 3, 883 OP_COMP_MUL: 4, 884 OP_OUTER_PRODUCT: 5, 885 OP_TRANSPOSE: 6, 886 OP_INVERSE: 7, 887 OP_DETERMINANT: 8, 888 OP_UNARY_PLUS: 9, 889 OP_NEGATION: 10, 890 OP_PRE_INCREMENT: 11, 891 OP_PRE_DECREMENT: 12, 892 OP_POST_INCREMENT: 13, 893 OP_POST_DECREMENT: 14, 894 OP_ADD_INTO: 15, 895 OP_SUBTRACT_FROM: 16, 896 OP_MULTIPLY_INTO: 17, 897 OP_DIVIDE_INTO: 18, 898 OP_LAST: 19 899 }; 900 901 /** 902 * @constructor 903 * @param {es3fShaderMatrixTest.InputType=} inputType_ 904 * @param {gluShaderUtil.DataType=} dataType_ 905 * @param {gluShaderUtil.precision=} precision_ 906 * @struct 907 */ 908 es3fShaderMatrixTest.ShaderInput = function (inputType_, dataType_, precision_){ 909 this.inputType = inputType_ || es3fShaderMatrixTest.InputType.INPUTTYPE_CONST; 910 this.dataType = dataType_ || gluShaderUtil.DataType.INVALID; 911 this.precision = precision_ || gluShaderUtil.precision.PRECISION_LOWP; 912 }; 913 914 /** 915 * @param {es3fShaderMatrixTest.ShaderInput} in0 916 * @param {es3fShaderMatrixTest.ShaderInput} in1 917 * @param {es3fShaderMatrixTest.MatrixOp} op 918 */ 919 es3fShaderMatrixTest.getEvalFunc = function (in0, in1, op) { 920 var setColor = function(evalCtx, src) { 921 for (var i = 0; i < 3; i++) 922 evalCtx.color[i] = src[i]; 923 }; 924 switch(op){ 925 case es3fShaderMatrixTest.MatrixOp.OP_ADD: 926 return function (evalCtx) { 927 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 928 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 929 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 930 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 931 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 932 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 933 934 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.add(in0_, in1_))); 935 }; 936 case es3fShaderMatrixTest.MatrixOp.OP_SUB: 937 return function (evalCtx) { 938 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 939 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 940 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 941 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 942 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 943 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 944 945 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.subtract(in0_, in1_))); 946 }; 947 case es3fShaderMatrixTest.MatrixOp.OP_MUL: 948 return function (evalCtx) { 949 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 950 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 951 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 952 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 953 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 954 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 955 956 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.multiply(in0_, in1_))); 957 }; 958 case es3fShaderMatrixTest.MatrixOp.OP_DIV: 959 return function (evalCtx) { 960 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 961 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 962 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 963 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 964 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 965 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 966 967 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.divide(in0_, in1_))); 968 }; 969 case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: 970 return function (evalCtx) { 971 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 972 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 973 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 974 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 975 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 976 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 977 978 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.matrixCompMult(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); 979 }; 980 case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: 981 return function (evalCtx) { 982 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 983 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 984 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 985 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 986 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 987 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 988 989 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.outerProduct(/** @type {Array<number>} */(in0_), /** @type {Array<number>} */(in1_)))); 990 }; 991 case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: 992 return function (evalCtx) { 993 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 994 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 995 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 996 997 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.transpose(/** @type {tcuMatrix.Matrix} */(in0_)))); 998 }; 999 case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: 1000 return function (evalCtx) { 1001 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1002 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1003 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1004 1005 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.inverse(/** @type {tcuMatrix.Matrix} */(in0_)))); 1006 }; 1007 case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: 1008 return function (evalCtx) { 1009 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1010 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1011 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1012 1013 var det = es3fShaderMatrixTest.determinant(/** @type {tcuMatrix.Matrix} */(in0_)); 1014 setColor(evalCtx, [det, det, det]); 1015 }; 1016 case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: 1017 return function (evalCtx) { 1018 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1019 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1020 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1021 1022 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(/** @type {tcuMatrix.Matrix} */(in0_))); 1023 }; 1024 case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: 1025 return function (evalCtx) { 1026 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1027 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1028 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1029 1030 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.negate(/** @type {tcuMatrix.Matrix} */(in0_)))); 1031 }; 1032 case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: 1033 return function (evalCtx) { 1034 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1035 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1036 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1037 1038 var val0 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.increment(/** @type {tcuMatrix.Matrix} */(in0_))); 1039 var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.increment(/** @type {tcuMatrix.Matrix} */(in0_))); 1040 setColor(evalCtx, deMath.add(val0, val1)); 1041 }; 1042 case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: 1043 return function (evalCtx) { 1044 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1045 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1046 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1047 1048 var val0 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.decrement(/** @type {tcuMatrix.Matrix} */(in0_))); 1049 var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.decrement(/** @type {tcuMatrix.Matrix} */(in0_))); 1050 setColor(evalCtx, deMath.add(val0, val1)); 1051 }; 1052 case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: 1053 return function (evalCtx) { 1054 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1055 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1056 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1057 1058 var val0 = es3fShaderMatrixTest.reduceToVec3((in0_)); 1059 var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.increment(/** @type {tcuMatrix.Matrix} */(in0_))); 1060 setColor(evalCtx, deMath.add(val0, val1)); 1061 }; 1062 case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: 1063 return function (evalCtx) { 1064 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1065 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1066 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1067 1068 var val0 = es3fShaderMatrixTest.reduceToVec3((in0_)); 1069 var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.decrement(/** @type {tcuMatrix.Matrix} */(in0_))); 1070 setColor(evalCtx, deMath.add(val0, val1)); 1071 }; 1072 case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: 1073 return function (evalCtx) { 1074 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1075 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1076 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1077 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1078 es3fShaderMatrixTest.getInputValue(in1.inputType, in0.dataType, evalCtx, 1) 1079 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 1080 1081 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.add(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); 1082 }; 1083 case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: 1084 return function (evalCtx) { 1085 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1086 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1087 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1088 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1089 es3fShaderMatrixTest.getInputValue(in1.inputType, in0.dataType, evalCtx, 1) 1090 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 1091 1092 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.subtract(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); 1093 }; 1094 case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: 1095 return function (evalCtx) { 1096 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1097 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1098 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1099 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1100 es3fShaderMatrixTest.getInputValue(in1.inputType, in0.dataType, evalCtx, 1) 1101 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 1102 1103 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.multiply(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); 1104 }; 1105 case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: 1106 return function (evalCtx) { 1107 var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1108 es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) 1109 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); 1110 var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? 1111 es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) 1112 : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); 1113 1114 setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.divide(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); 1115 }; 1116 } 1117 }; 1118 1119 /** 1120 * @constructor 1121 * @param {es3fShaderMatrixTest.MatrixShaderEvalFunc} evalFunc 1122 * @param {es3fShaderMatrixTest.InputType} inType0 1123 * @param {es3fShaderMatrixTest.InputType} inType1 1124 * @extends {glsShaderRenderCase.ShaderEvaluator} 1125 */ 1126 es3fShaderMatrixTest.MatrixShaderEvaluator = function(evalFunc, inType0, inType1) { 1127 glsShaderRenderCase.ShaderEvaluator.call(this); 1128 this.m_matEvalFunc = evalFunc; 1129 this.m_inType0 = inType0; 1130 this.m_inType1 = inType1; 1131 }; 1132 1133 es3fShaderMatrixTest.MatrixShaderEvaluator.prototype = Object.create(glsShaderRenderCase.ShaderEvaluator); 1134 es3fShaderMatrixTest.MatrixShaderEvaluator.prototype.constructor = es3fShaderMatrixTest.MatrixShaderEvaluator; 1135 1136 /** 1137 * @param {glsShaderRenderCase.ShaderEvalContext} evalCtx 1138 */ 1139 es3fShaderMatrixTest.MatrixShaderEvaluator.prototype.evaluate = function (evalCtx) { 1140 this.m_matEvalFunc(evalCtx); 1141 } 1142 1143 /** 1144 * @param {Array<number>} v 1145 * @param {number} size 1146 */ 1147 es3fShaderMatrixTest.writeVectorConstructor = function (v, size) { 1148 var str = 'vec' + size + ''; 1149 for (var ndx = 0; ndx < size; ndx++) { 1150 if (ndx != 0) 1151 str += ', '; 1152 str += v[ndx].toString; 1153 } 1154 str += ')'; 1155 return str; 1156 } 1157 1158 /** 1159 * @param {tcuMatrix.Matrix} m 1160 */ 1161 es3fShaderMatrixTest.writeMatrixConstructor = function (m) { 1162 var str = ''; 1163 if (m.rows == m.cols) 1164 str += 'mat' + m.cols; 1165 else 1166 str += 'mat' + m.cols + 'x' + m.rows; 1167 1168 str += '('; 1169 for (var colNdx = 0; colNdx < m.cols; colNdx++) { 1170 for (var rowNdx = 0; rowNdx < m.rows; rowNdx++) { 1171 if (rowNdx > 0 || colNdx > 0) 1172 str += ', '; 1173 str += m.get(rowNdx, colNdx).toString(); 1174 } 1175 } 1176 str += ')'; 1177 return str; 1178 }; 1179 1180 /** 1181 * @constructor 1182 * @param {string} name 1183 * @param {string} desc 1184 * @param {es3fShaderMatrixTest.ShaderInput} in0 1185 * @param {es3fShaderMatrixTest.ShaderInput} in1 1186 * @param {es3fShaderMatrixTest.MatrixOp} op 1187 * @param {boolean} isVertexCase 1188 * @extends {glsShaderRenderCase.ShaderRenderCase} 1189 */ 1190 es3fShaderMatrixTest.ShaderMatrixCase = function(name, desc, in0, in1, op, isVertexCase) { 1191 var evalFunc = es3fShaderMatrixTest.getEvalFunc(in0, in1, op); 1192 glsShaderRenderCase.ShaderRenderCase.call(this, name, desc, isVertexCase, evalFunc); 1193 this.m_in0 = in0; 1194 this.m_in1 = in1; 1195 this.m_op = op; 1196 this.m_evaluator = new es3fShaderMatrixTest.MatrixShaderEvaluator(evalFunc, in0.inputType, in1.inputType); 1197 }; 1198 1199 es3fShaderMatrixTest.ShaderMatrixCase.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype); 1200 es3fShaderMatrixTest.ShaderMatrixCase.prototype.constructor = es3fShaderMatrixTest.ShaderMatrixCase; 1201 1202 1203 es3fShaderMatrixTest.ShaderMatrixCase.prototype.init = function () { 1204 var shaderSources = [ '', '' ]; 1205 var vtx = 0; 1206 var frag = 1; 1207 var op = this.m_isVertexCase ? vtx : frag; 1208 1209 /** @type {boolean} */ var isInDynMat0 = gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) && this.m_in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC; 1210 /** @type {boolean} */ var isInDynMat1 = gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType) && this.m_in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC; 1211 /** @type {Array<string>} */ var inValues = []; 1212 /** @type {gluShaderUtil.DataType} */ var resultType; 1213 /** @type {gluShaderUtil.precision} */ var resultPrec = this.m_in0.precision; 1214 /** @type {Array<string>} */ var passVars = []; 1215 /** @type {number} */ var numInputs = (es3fShaderMatrixTest.isOperationBinary(this.m_op)) ? (2) : (1); 1216 1217 /** @type {string} */ var operationValue0 = ''; 1218 /** @type {string} */ var operationValue1 = ''; 1219 1220 if (isInDynMat0 && isInDynMat1) { 1221 throw new Error ('Only single dynamic matrix input is allowed.'); 1222 } 1223 1224 if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_MUL && gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) && gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType)) { 1225 resultType = gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeMatrixNumColumns(this.m_in1.dataType), gluShaderUtil.getDataTypeMatrixNumRows(this.m_in0.dataType)); 1226 } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT) { 1227 resultType = gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeScalarSize(this.m_in1.dataType), gluShaderUtil.getDataTypeScalarSize(this.m_in0.dataType)); 1228 } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE) { 1229 resultType = gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeMatrixNumRows(this.m_in0.dataType), gluShaderUtil.getDataTypeMatrixNumColumns(this.m_in0.dataType)); 1230 } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_INVERSE) { 1231 resultType = this.m_in0.dataType; 1232 } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT) { 1233 resultType = gluShaderUtil.DataType.FLOAT; 1234 } else if (es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR || 1235 es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR) { 1236 resultType = this.m_in0.dataType; 1237 } else if (gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) && gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType)) { 1238 if (this.m_in0.dataType !== this.m_in1.dataType) { 1239 throw new Error ('Incompatible data types'); 1240 } 1241 resultType = this.m_in0.dataType; 1242 } else if (gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) || gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType)) { 1243 /** @type {number} */ var matNdx = gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) ? 0 : 1; 1244 /** @type {gluShaderUtil.DataType} */ var matrixType = matNdx == 0 ? this.m_in0.dataType : this.m_in1.dataType; 1245 /** @type {gluShaderUtil.DataType} */ var otherType = matNdx == 0 ? this.m_in1.dataType : this.m_in0.dataType; 1246 1247 if (otherType == gluShaderUtil.DataType.FLOAT) 1248 resultType = matrixType; 1249 else { 1250 if (!gluShaderUtil.isDataTypeVector(otherType)) { 1251 throw new Error ('Is not data type vector'); 1252 } 1253 resultType = gluShaderUtil.getDataTypeFloatVec(matNdx == 0 ? gluShaderUtil.getDataTypeMatrixNumRows(matrixType) : gluShaderUtil.getDataTypeMatrixNumColumns(matrixType)); 1254 } 1255 } else { 1256 throw new Error ('Error'); 1257 } 1258 1259 shaderSources[vtx] += '#version 300 es\n'; 1260 shaderSources[frag] += '#version 300 es\n'; 1261 1262 shaderSources[vtx] += 'in highp vec4 a_position;\n'; 1263 shaderSources[frag] += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n'; 1264 if (this.m_isVertexCase) { 1265 shaderSources[vtx] += 'out mediump vec4 v_color;\n'; 1266 shaderSources[frag] += 'in mediump vec4 v_color;\n'; 1267 } 1268 1269 // Input declarations. 1270 for (var inNdx = 0; inNdx < numInputs; inNdx++) { 1271 /** @type {es3fShaderMatrixTest.ShaderInput} */ var ind = inNdx > 0 ? this.m_in1 : this.m_in0; 1272 /** @type {string} */ var precName = gluShaderUtil.getPrecisionName(ind.precision); 1273 /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(ind.dataType); 1274 /** @type {number} */ var inValueNdx = inNdx > 0 ? 1 : 0; 1275 1276 if (ind.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) { 1277 shaderSources[vtx] += 'in ' + precName + ' ' + typeName + ' a_'; 1278 1279 if (gluShaderUtil.isDataTypeMatrix(ind.dataType)) { 1280 // a_matN, v_matN 1281 shaderSources[vtx] += typeName + ';\n'; 1282 if (!this.m_isVertexCase) { 1283 shaderSources[vtx] += 'out ' + precName + ' ' + typeName + ' v_' + typeName + ';\n'; 1284 shaderSources[frag] += 'in ' + precName + ' ' + typeName + ' v_' + typeName + ';\n'; 1285 passVars.push(typeName); 1286 } 1287 1288 inValues[inValueNdx] = (this.m_isVertexCase ? 'a_' : 'v_') + gluShaderUtil.getDataTypeName(ind.dataType); 1289 } else { 1290 // a_coords, v_coords 1291 shaderSources[vtx] += 'coords;\n'; 1292 if (!this.m_isVertexCase) { 1293 shaderSources[vtx] += 'out ' + precName + ' ' + typeName + ' v_coords;\n'; 1294 shaderSources[frag] += 'in ' + precName + ' ' + typeName + ' v_coords;\n'; 1295 passVars.push('coords'); 1296 } 1297 1298 inValues[inValueNdx] = this.m_isVertexCase ? 'a_coords' : 'v_coords'; 1299 } 1300 } else if (ind.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM) { 1301 shaderSources[op] += 'uniform ' + precName + ' ' + typeName + ' u_in' + inNdx + ';\n'; 1302 inValues[inValueNdx] = 'u_in' + inNdx.toString(); 1303 } else if (ind.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_CONST) { 1304 shaderSources[op] += 'const ' + precName + ' ' + typeName + ' in' + inNdx + ' = '; 1305 1306 // Generate declaration. 1307 switch (ind.dataType) { 1308 case gluShaderUtil.DataType.FLOAT: 1309 shaderSources[op] += s_constInFloat[inNdx].toString(); 1310 break; 1311 case gluShaderUtil.DataType.FLOAT_VEC2: 1312 shaderSources[op] += es3fShaderMatrixTest.writeVectorConstructor( s_constInVec2[inNdx], 2); 1313 break; 1314 case gluShaderUtil.DataType.FLOAT_VEC3: 1315 shaderSources[op] += es3fShaderMatrixTest.writeVectorConstructor( s_constInVec3[inNdx], 3); 1316 break; 1317 case gluShaderUtil.DataType.FLOAT_VEC4: 1318 shaderSources[op] += es3fShaderMatrixTest.writeVectorConstructor( s_constInVec4[inNdx], 4); 1319 break; 1320 case gluShaderUtil.DataType.FLOAT_MAT2: 1321 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(2, 2, s_constInMat2x2[inNdx])); 1322 break; 1323 case gluShaderUtil.DataType.FLOAT_MAT2X3: 1324 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(3, 2, s_constInMat2x3[inNdx])); 1325 break; 1326 case gluShaderUtil.DataType.FLOAT_MAT2X4: 1327 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(4, 2, s_constInMat2x4[inNdx])); 1328 break; 1329 case gluShaderUtil.DataType.FLOAT_MAT3X2: 1330 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(2, 3, s_constInMat3x2[inNdx])); 1331 break; 1332 case gluShaderUtil.DataType.FLOAT_MAT3: 1333 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(3, 3, s_constInMat3x3[inNdx])); 1334 break; 1335 case gluShaderUtil.DataType.FLOAT_MAT3X4: 1336 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(4, 3, s_constInMat3x4[inNdx])); 1337 break; 1338 case gluShaderUtil.DataType.FLOAT_MAT4X2: 1339 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(2, 4, s_constInMat4x2[inNdx])); 1340 break; 1341 case gluShaderUtil.DataType.FLOAT_MAT4X3: 1342 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(3, 4, s_constInMat4x3[inNdx])); 1343 break; 1344 case gluShaderUtil.DataType.FLOAT_MAT4: 1345 shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(4, 4, s_constInMat4x4[inNdx])); 1346 break; 1347 1348 default: 1349 throw new Error('Data type error'); 1350 } 1351 1352 shaderSources[op] += ';\n'; 1353 1354 inValues[inValueNdx] = 'in' + inNdx.toString(); 1355 } 1356 } 1357 1358 shaderSources[vtx] += '\n' 1359 + 'void main (void)\n' 1360 + '{\n' 1361 + ' gl_Position = a_position;\n'; 1362 shaderSources[frag] += '\n' 1363 + 'void main (void)\n' 1364 + '{\n'; 1365 1366 if (this.m_isVertexCase) 1367 shaderSources[frag] += ' dEQP_FragColor = v_color;\n'; 1368 else { 1369 for (var i = 0; i != passVars.length; i++) 1370 shaderSources[vtx] += ' v_' + passVars[i] + ' = ' + 'a_' + passVars[i] + ';\n'; 1371 } 1372 1373 // Operation. 1374 1375 switch (es3fShaderMatrixTest.getOperationNature(this.m_op)) { 1376 case es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_PURE: 1377 if (es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT) 1378 throw new Error('Wrong operation type'); 1379 1380 operationValue0 = inValues[0]; 1381 operationValue1 = inValues[1]; 1382 break; 1383 1384 case es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_MUTATING: 1385 if (es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT) 1386 throw new Error('Wrong operation type'); 1387 1388 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' + gluShaderUtil.getDataTypeName(resultType) + ' tmpValue = ' + inValues[0] + ';\n'; 1389 1390 operationValue0 = 'tmpValue'; 1391 operationValue1 = inValues[1]; 1392 break; 1393 1394 case es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_ASSIGNMENT: 1395 if (es3fShaderMatrixTest.getOperationType(this.m_op) != es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT) 1396 throw new Error('Wrong operation type'); 1397 1398 operationValue0 = inValues[0]; 1399 operationValue1 = inValues[1]; 1400 break; 1401 1402 default: 1403 throw new Error('Wrong operation nature'); 1404 } 1405 1406 switch (es3fShaderMatrixTest.getOperationType(this.m_op)) { 1407 case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR: 1408 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' 1409 + gluShaderUtil.getDataTypeName(resultType) 1410 + ' res = ' + operationValue0 + ' ' 1411 + es3fShaderMatrixTest.getOperationName(this.m_op) + ' ' 1412 + operationValue1 + ';\n'; 1413 break; 1414 case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR: 1415 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' 1416 + gluShaderUtil.getDataTypeName(resultType) 1417 + ' res = ' + es3fShaderMatrixTest.getOperationName(this.m_op) 1418 + operationValue0 + ';\n'; 1419 break; 1420 case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR: 1421 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' 1422 + gluShaderUtil.getDataTypeName(resultType) 1423 + ' res = ' + operationValue0 1424 + es3fShaderMatrixTest.getOperationName(this.m_op) + ';\n'; 1425 break; 1426 case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION: 1427 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) 1428 + ' ' + gluShaderUtil.getDataTypeName(resultType) 1429 + ' res = ' + es3fShaderMatrixTest.getOperationName(this.m_op) 1430 + '(' + operationValue0 1431 + ', ' + operationValue1 + ');\n'; 1432 break; 1433 case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION: 1434 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) 1435 + ' ' + gluShaderUtil.getDataTypeName(resultType) 1436 + ' res = ' + es3fShaderMatrixTest.getOperationName(this.m_op) 1437 + '(' + operationValue0 + ');\n'; 1438 break; 1439 case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT: 1440 shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) 1441 + ' ' + gluShaderUtil.getDataTypeName(resultType) 1442 + ' res = ' + operationValue0 + ';\n'; 1443 shaderSources[op] += ' res ' + es3fShaderMatrixTest.getOperationName(this.m_op) 1444 + ' ' + operationValue1 + ';\n'; 1445 break; 1446 default: 1447 throw new Error('Wrong operation type'); 1448 } 1449 1450 // Reduction to vec3 (rgb). Check the used value too if it was modified 1451 shaderSources[op] += ' ' + (this.m_isVertexCase ? 'v_color' : 'dEQP_FragColor') + ' = '; 1452 1453 if (es3fShaderMatrixTest.isOperationValueModifying(this.m_op)) 1454 shaderSources[op] += 'vec4(' + this.genGLSLMatToVec3Reduction(resultType, 'res') 1455 + ', 1.0) + vec4(' + this.genGLSLMatToVec3Reduction(resultType, 'tmpValue') 1456 + ', 0.0);\n'; 1457 else 1458 shaderSources[op] += 'vec4(' + this.genGLSLMatToVec3Reduction(resultType, 'res') 1459 + ', 1.0);\n'; 1460 1461 shaderSources[vtx] += '}\n'; 1462 shaderSources[frag] += '}\n'; 1463 1464 this.m_vertShaderSource = shaderSources[vtx]; 1465 this.m_fragShaderSource = shaderSources[frag]; 1466 1467 // \todo [2012-02-14 pyry] Compute better values for matrix tests. 1468 for (var attribNdx = 0; attribNdx < 4; attribNdx++) { 1469 this.m_userAttribTransforms[attribNdx] = new tcuMatrix.Matrix(4, 4, 0); 1470 this.m_userAttribTransforms[attribNdx].set(0, 3, 0.2);// !< prevent matrix*vec from going into zero (assuming vec.w != 0) 1471 this.m_userAttribTransforms[attribNdx].set(1, 3, 0.1);// !< 1472 this.m_userAttribTransforms[attribNdx].set(2, 3, 0.4 + 0.15 * attribNdx);// !< 1473 this.m_userAttribTransforms[attribNdx].set(3, 3, 0.7);// !< 1474 this.m_userAttribTransforms[attribNdx].set((0 + attribNdx) % 4, 0, 1.0); 1475 this.m_userAttribTransforms[attribNdx].set((1 + attribNdx) % 4, 1, 1.0); 1476 this.m_userAttribTransforms[attribNdx].set((2 + attribNdx) % 4, 2, 1.0); 1477 this.m_userAttribTransforms[attribNdx].set((3 + attribNdx) % 4, 3, 1.0); 1478 } 1479 1480 // prevent bad reference cases such as black result images by fine-tuning used matrices 1481 if (es3fShaderMatrixTest.getOperationTestMatrixType(this.m_op) != es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT) { 1482 for (var attribNdx = 0; attribNdx < 4; attribNdx++) { 1483 for (var row = 0; row < 4; row++) 1484 for (var col = 0; col < 4; col++) { 1485 switch (es3fShaderMatrixTest.getOperationTestMatrixType(this.m_op)) { 1486 case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED: 1487 this.m_userAttribTransforms[attribNdx].set(row, col, -this.m_userAttribTransforms[attribNdx].get(row, col)); 1488 break; 1489 case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED: 1490 this.m_userAttribTransforms[attribNdx].set(row, col, this.m_userAttribTransforms[attribNdx].get(row, col) + 0.3); 1491 break; 1492 case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DECREMENTED: 1493 this.m_userAttribTransforms[attribNdx].set(row, col, this.m_userAttribTransforms[attribNdx].get(row, col) - 0.3); 1494 break; 1495 case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED_INCREMENTED: 1496 this.m_userAttribTransforms[attribNdx].set(row, col, -(this.m_userAttribTransforms[attribNdx].get(row, col) + 0.3)); 1497 break; 1498 case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED_LESS: 1499 this.m_userAttribTransforms[attribNdx].set(row, col, this.m_userAttribTransforms[attribNdx].get(row, col) - 0.1); 1500 break; 1501 default: 1502 throw new Error('Wrong Matrix type'); 1503 } 1504 } 1505 } 1506 } 1507 1508 glsShaderRenderCase.ShaderRenderCase.prototype.init.call(this); 1509 }; 1510 1511 1512 es3fShaderMatrixTest.ShaderMatrixCase.prototype.setupUniforms = function(programId, constCoords) { 1513 for (var inNdx = 0; inNdx < 2; inNdx++) 1514 { 1515 var input = inNdx > 0 ? this.m_in1 : this.m_in0; 1516 1517 if (input.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM) 1518 { 1519 var loc = gl.getUniformLocation(programId, "u_in" + inNdx); 1520 1521 if (!loc) 1522 continue; 1523 1524 switch (input.dataType) 1525 { 1526 case gluShaderUtil.DataType.FLOAT: gl.uniform1f(loc, s_constInFloat[inNdx]); break; 1527 case gluShaderUtil.DataType.FLOAT_VEC2: gl.uniform2fv(loc, s_constInVec2[inNdx]); break; 1528 case gluShaderUtil.DataType.FLOAT_VEC3: gl.uniform3fv(loc, s_constInVec3[inNdx]); break; 1529 case gluShaderUtil.DataType.FLOAT_VEC4: gl.uniform4fv(loc, s_constInVec4[inNdx]); break; 1530 // \note GLES3 supports transpose in matrix upload. 1531 case gluShaderUtil.DataType.FLOAT_MAT2: gl.uniformMatrix2fv (loc, true, s_constInMat2x2[inNdx]); break; 1532 case gluShaderUtil.DataType.FLOAT_MAT2X3: gl.uniformMatrix2x3fv(loc, true, s_constInMat2x3[inNdx]); break; 1533 case gluShaderUtil.DataType.FLOAT_MAT2X4: gl.uniformMatrix2x4fv(loc, true, s_constInMat2x4[inNdx]); break; 1534 case gluShaderUtil.DataType.FLOAT_MAT3X2: gl.uniformMatrix3x2fv(loc, true, s_constInMat3x2[inNdx]); break; 1535 case gluShaderUtil.DataType.FLOAT_MAT3: gl.uniformMatrix3fv (loc, true, s_constInMat3x3[inNdx]); break; 1536 case gluShaderUtil.DataType.FLOAT_MAT3X4: gl.uniformMatrix3x4fv(loc, true, s_constInMat3x4[inNdx]); break; 1537 case gluShaderUtil.DataType.FLOAT_MAT4X2: gl.uniformMatrix4x2fv(loc, true, s_constInMat4x2[inNdx]); break; 1538 case gluShaderUtil.DataType.FLOAT_MAT4X3: gl.uniformMatrix4x3fv(loc, true, s_constInMat4x3[inNdx]); break; 1539 case gluShaderUtil.DataType.FLOAT_MAT4: gl.uniformMatrix4fv (loc, true, s_constInMat4x4[inNdx]); break; 1540 default: 1541 throw new Error('Invalid datatype' + input.dataType); 1542 } 1543 } 1544 } 1545 }; 1546 1547 1548 1549 /** 1550 * @param {gluShaderUtil.DataType} matType 1551 * @param {string} varName 1552 * @return {string} 1553 */ 1554 es3fShaderMatrixTest.ShaderMatrixCase.prototype.genGLSLMatToVec3Reduction = function (matType, varName) { 1555 /** @type {string} */ var op = ''; 1556 1557 switch (matType) { 1558 case gluShaderUtil.DataType.FLOAT: 1559 op += varName + ', ' 1560 + varName + ', ' 1561 + varName + ''; 1562 break; 1563 case gluShaderUtil.DataType.FLOAT_VEC2: 1564 op += varName + '.x, ' 1565 + varName + '.y, ' 1566 + varName + '.x'; 1567 break; 1568 case gluShaderUtil.DataType.FLOAT_VEC3: 1569 op += varName + ''; 1570 break; 1571 case gluShaderUtil.DataType.FLOAT_VEC4: 1572 op += varName + '.x, ' 1573 + varName + '.y, ' 1574 + varName + '.z+' 1575 + varName + '.w'; 1576 break; 1577 case gluShaderUtil.DataType.FLOAT_MAT2: 1578 op += varName + '[0][0], ' 1579 + varName + '[1][0], ' 1580 + varName + '[0][1]+' 1581 + varName + '[1][1]'; 1582 break; 1583 case gluShaderUtil.DataType.FLOAT_MAT2X3: 1584 op += varName + '[0] + ' 1585 + varName + '[1]'; 1586 break; 1587 case gluShaderUtil.DataType.FLOAT_MAT2X4: 1588 op += varName + '[0].xyz + ' 1589 + varName + '[1].yzw'; 1590 break; 1591 case gluShaderUtil.DataType.FLOAT_MAT3X2: 1592 op += varName + '[0][0]+' 1593 + varName + '[0][1], ' 1594 + varName + '[1][0]+' 1595 + varName + '[1][1], ' 1596 + varName + '[2][0]+' 1597 + varName + '[2][1]'; 1598 break; 1599 case gluShaderUtil.DataType.FLOAT_MAT3: 1600 op += varName + '[0] + ' 1601 + varName + '[1] + ' 1602 + varName + '[2]'; 1603 break; 1604 case gluShaderUtil.DataType.FLOAT_MAT3X4: 1605 op += varName + '[0].xyz + ' 1606 + varName + '[1].yzw + ' 1607 + varName + '[2].zwx'; 1608 break; 1609 case gluShaderUtil.DataType.FLOAT_MAT4X2: 1610 op += varName + '[0][0]+' 1611 + varName + '[0][1]+' 1612 + varName + '[3][0], ' 1613 + varName + '[1][0]+' 1614 + varName + '[1][1]+' 1615 + varName + '[3][1], ' 1616 + varName + '[2][0]+' 1617 + varName + '[2][1]'; 1618 break; 1619 case gluShaderUtil.DataType.FLOAT_MAT4X3: 1620 op += varName + '[0] + ' 1621 + varName + '[1] + ' 1622 + varName + '[2] + ' 1623 + varName + '[3]'; 1624 break; 1625 case gluShaderUtil.DataType.FLOAT_MAT4: 1626 op += varName + '[0].xyz+' 1627 + varName + '[1].yzw+' 1628 + varName + '[2].zwx+' 1629 + varName + '[3].wxy'; 1630 break; 1631 1632 default: 1633 throw new Error('Wrong data type'); 1634 } 1635 1636 return op; 1637 } 1638 1639 /** 1640 * @constructor 1641 * @param {string} name 1642 * @param {string} desc 1643 * @param {es3fShaderMatrixTest.MatrixOp} op 1644 * @param {boolean} extendedInputTypeCases 1645 * @param {boolean} createInputTypeGroup 1646 */ 1647 es3fShaderMatrixTest.ops = function (name, desc, op, extendedInputTypeCases, createInputTypeGroup) { 1648 this.name = name; 1649 this.desc = desc; 1650 this.op = op; 1651 this.extendedInputTypeCases = extendedInputTypeCases; 1652 this.createInputTypeGroup = createInputTypeGroup; 1653 }; 1654 1655 /** 1656 * @constructor 1657 * @param {string} name 1658 * @param {string} desc 1659 * @param {es3fShaderMatrixTest.InputType} type 1660 */ 1661 es3fShaderMatrixTest.InputTypeSpec = function (name, desc, type) { 1662 this.name = name; 1663 this.desc = desc; 1664 this.type = type; 1665 }; 1666 1667 es3fShaderMatrixTest.init = function () { 1668 var state = tcuTestCase.runner; 1669 1670 var ops = [ 1671 new es3fShaderMatrixTest.ops('add', 'Matrix addition tests', es3fShaderMatrixTest.MatrixOp.OP_ADD, true, true), 1672 new es3fShaderMatrixTest.ops('sub', 'Matrix subtraction tests', es3fShaderMatrixTest.MatrixOp.OP_SUB, true, true), 1673 new es3fShaderMatrixTest.ops('mul', 'Matrix multiplication tests', es3fShaderMatrixTest.MatrixOp.OP_MUL, true, true), 1674 new es3fShaderMatrixTest.ops('div', 'Matrix division tests', es3fShaderMatrixTest.MatrixOp.OP_DIV, true, true), 1675 new es3fShaderMatrixTest.ops('matrixcompmult', 'Matrix component-wise multiplication tests', es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL, false, true), 1676 new es3fShaderMatrixTest.ops('outerproduct', 'Matrix outerProduct() tests', es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT, false, true), 1677 new es3fShaderMatrixTest.ops('transpose', 'Matrix transpose() tests', es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE, false, true), 1678 new es3fShaderMatrixTest.ops('determinant', 'Matrix determinant() tests', es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT, false, true), 1679 new es3fShaderMatrixTest.ops('inverse', 'Matrix inverse() tests', es3fShaderMatrixTest.MatrixOp.OP_INVERSE, false, true), 1680 new es3fShaderMatrixTest.ops('unary_addition', 'Matrix unary addition tests', es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS, false, false), 1681 new es3fShaderMatrixTest.ops('negation', 'Matrix negation tests', es3fShaderMatrixTest.MatrixOp.OP_NEGATION, false, false), 1682 new es3fShaderMatrixTest.ops('pre_increment', 'Matrix prefix increment tests', es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT, false, false), 1683 new es3fShaderMatrixTest.ops('pre_decrement', 'Matrix prefix decrement tests', es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT, false, false), 1684 new es3fShaderMatrixTest.ops('post_increment', 'Matrix postfix increment tests', es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT, false, false), 1685 new es3fShaderMatrixTest.ops('post_decrement', 'Matrix postfix decrement tests', es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT, false, false), 1686 new es3fShaderMatrixTest.ops('add_assign', 'Matrix add into tests', es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO, false, false), 1687 new es3fShaderMatrixTest.ops('sub_assign', 'Matrix subtract from tests', es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM,false, false), 1688 new es3fShaderMatrixTest.ops('mul_assign', 'Matrix multiply into tests', es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO,false, false), 1689 new es3fShaderMatrixTest.ops('div_assign', 'Matrix divide into tests', es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO,false, false) 1690 ]; 1691 1692 var extendedInputTypes = [ 1693 new es3fShaderMatrixTest.InputTypeSpec('const', 'Constant matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_CONST), 1694 new es3fShaderMatrixTest.InputTypeSpec('uniform', 'Uniform matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM), 1695 new es3fShaderMatrixTest.InputTypeSpec('dynamic', 'Dynamic matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) 1696 ]; 1697 1698 var reducedInputTypes = [ 1699 new es3fShaderMatrixTest.InputTypeSpec('dynamic', 'Dynamic matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) 1700 ]; 1701 1702 /** @type {Array<gluShaderUtil.DataType>} */ var matrixTypes = [ 1703 gluShaderUtil.DataType.FLOAT_MAT2, 1704 gluShaderUtil.DataType.FLOAT_MAT2X3, 1705 gluShaderUtil.DataType.FLOAT_MAT2X4, 1706 gluShaderUtil.DataType.FLOAT_MAT3X2, 1707 gluShaderUtil.DataType.FLOAT_MAT3, 1708 gluShaderUtil.DataType.FLOAT_MAT3X4, 1709 gluShaderUtil.DataType.FLOAT_MAT4X2, 1710 gluShaderUtil.DataType.FLOAT_MAT4X3, 1711 gluShaderUtil.DataType.FLOAT_MAT4 1712 ]; 1713 1714 /** @type {Array<gluShaderUtil.precision>} */ var precisions = [ 1715 gluShaderUtil.precision.PRECISION_LOWP, 1716 gluShaderUtil.precision.PRECISION_MEDIUMP, 1717 gluShaderUtil.precision.PRECISION_HIGHP 1718 ]; 1719 1720 for (var opNdx = 0; opNdx < ops.length; opNdx++) { 1721 var inTypeList = ops[opNdx].extendedInputTypeCases ? extendedInputTypes : reducedInputTypes; 1722 var inTypeListSize = ops[opNdx].extendedInputTypeCases ? extendedInputTypes.length : reducedInputTypes.length; 1723 var op = ops[opNdx].op; 1724 1725 for (var inTypeNdx = 0; inTypeNdx < inTypeListSize; inTypeNdx++) { 1726 var inputType = inTypeList[inTypeNdx].type; 1727 var group = []; 1728 1729 if (ops[opNdx].name != 'mul') { 1730 if (ops[opNdx].createInputTypeGroup) { 1731 group[0] = tcuTestCase.newTest(ops[opNdx].name + '.' + inTypeList[inTypeNdx].name, inTypeList[inTypeNdx].desc); 1732 } else { 1733 group[0] = tcuTestCase.newTest(ops[opNdx].name, ops[opNdx].desc); 1734 } 1735 state.testCases.addChild(group[0]); 1736 } else { 1737 for (var ii = 0; ii < precisions.length; ++ii) { 1738 group[ii] = tcuTestCase.newTest(ops[opNdx].name + '.' + inTypeList[inTypeNdx].name, inTypeList[inTypeNdx].desc); 1739 state.testCases.addChild(group[ii]); 1740 } 1741 } 1742 1743 for (var matTypeNdx = 0; matTypeNdx < matrixTypes.length; matTypeNdx++) { 1744 var matType = matrixTypes[matTypeNdx]; 1745 var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(matType); 1746 var numRows = gluShaderUtil.getDataTypeMatrixNumRows(matType); 1747 var matTypeName = gluShaderUtil.getDataTypeName(matType); 1748 1749 for (var precNdx = 0; precNdx < precisions.length; precNdx++) { 1750 var inGroup; 1751 if (ops[opNdx].name != 'mul') { 1752 inGroup = group[0]; 1753 } else { 1754 inGroup = group[precNdx]; 1755 } 1756 1757 var precision = precisions[precNdx]; 1758 var precName = gluShaderUtil.getPrecisionName(precision); 1759 var baseName = precName + '_' + matTypeName + '_'; 1760 var matIn = new es3fShaderMatrixTest.ShaderInput(inputType, matType, precision); 1761 1762 if (es3fShaderMatrixTest.isOperationMatrixScalar(op)) { 1763 // Matrix-scalar \note For div cases we use uniform input. 1764 var scalarIn = new es3fShaderMatrixTest.ShaderInput(op == es3fShaderMatrixTest.MatrixOp.OP_DIV ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC, gluShaderUtil.DataType.FLOAT, precision); 1765 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Matrix-scalar case', matIn, scalarIn, op, true)); 1766 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Matrix-scalar case', matIn, scalarIn, op, false)); 1767 } 1768 1769 if (es3fShaderMatrixTest.isOperationMatrixVector(op)) { 1770 // Matrix-vector. 1771 var colVecType = gluShaderUtil.getDataTypeFloatVec(numCols); 1772 var colVecIn = new es3fShaderMatrixTest.ShaderInput(op == es3fShaderMatrixTest.MatrixOp.OP_DIV ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC, colVecType, precision); 1773 1774 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(colVecType) + '_vertex', 'Matrix-vector case', matIn, colVecIn, op, true)); 1775 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(colVecType) + '_fragment', 'Matrix-vector case', matIn, colVecIn, op, false)); 1776 1777 // Vector-matrix. 1778 var rowVecType = gluShaderUtil.getDataTypeFloatVec(numRows); 1779 var rowVecIn = new es3fShaderMatrixTest.ShaderInput(op == es3fShaderMatrixTest.MatrixOp.OP_DIV ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC, rowVecType, precision); 1780 var vecMatName = precName + '_' + gluShaderUtil.getDataTypeName(rowVecType) + '_' + matTypeName; 1781 1782 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(vecMatName + '_vertex', 'Vector-matrix case', rowVecIn, matIn, op, true)); 1783 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(vecMatName + '_fragment', 'Vector-matrix case', rowVecIn, matIn, op, false)); 1784 } 1785 1786 if (es3fShaderMatrixTest.isOperationArithmeticMatrixMatrix(op)) { 1787 // Arithmetic matrix-matrix multiplication. 1788 for (var otherCols = 2; otherCols <= 4; otherCols++) { 1789 var otherMatIn = new es3fShaderMatrixTest.ShaderInput(inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, gluShaderUtil.getDataTypeMatrix(otherCols, numCols), precision); 1790 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(otherMatIn.dataType) + '_vertex', 'Matrix-matrix case', matIn, otherMatIn, op, true)); 1791 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(otherMatIn.dataType) + '_fragment', 'Matrix-matrix case', matIn, otherMatIn, op, false)); 1792 } 1793 } else if (es3fShaderMatrixTest.isOperationComponentwiseMatrixMatrix(op)) { 1794 // Component-wise. 1795 var otherMatIn = new es3fShaderMatrixTest.ShaderInput(inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, matType, precision); 1796 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + matTypeName + '_vertex', 'Matrix-matrix case', matIn, otherMatIn, op, true)); 1797 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + matTypeName + '_fragment', 'Matrix-matrix case', matIn, otherMatIn, op, false)); 1798 } 1799 1800 if (es3fShaderMatrixTest.isOperationVectorVector(op)) { 1801 var vec1In = new es3fShaderMatrixTest.ShaderInput(inputType, gluShaderUtil.getDataTypeFloatVec(numRows), precision); 1802 var vec2In = new es3fShaderMatrixTest.ShaderInput((inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, gluShaderUtil.getDataTypeFloatVec(numCols), precision); 1803 1804 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Vector-vector case', vec1In, vec2In, op, true)); 1805 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Vector-vector case', vec1In, vec2In, op, false)); 1806 } 1807 1808 if (es3fShaderMatrixTest.isOperationUnaryAnyMatrix(op) || (es3fShaderMatrixTest.isOperationUnarySymmetricMatrix(op) && numCols == numRows)) { 1809 var voidInput = new es3fShaderMatrixTest.ShaderInput(); 1810 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Matrix case', matIn, voidInput, op, true)); 1811 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Matrix case', matIn, voidInput, op, false)); 1812 } 1813 1814 if (es3fShaderMatrixTest.isOperationAssignmentAnyMatrix(op) || (es3fShaderMatrixTest.isOperationAssignmentSymmetricMatrix(op) && numCols == numRows)) { 1815 var otherMatIn = new es3fShaderMatrixTest.ShaderInput(inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, matType, precision); 1816 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Matrix assignment case', matIn, otherMatIn, op, true)); 1817 inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Matrix assignment case', matIn, otherMatIn, op, false)); 1818 } 1819 } 1820 } 1821 } 1822 } 1823 } 1824 1825 es3fShaderMatrixTest.run = function(context, range) { 1826 gl = context; 1827 //Set up Test Root parameters 1828 var testName = 'shader_matrix'; 1829 var testDescription = 'Shader Matrix Test'; 1830 var state = tcuTestCase.runner; 1831 1832 state.testName = testName; 1833 state.testCases = tcuTestCase.newTest(testName, testDescription, null); 1834 1835 //Set up name and description of this test series. 1836 setCurrentTestName(testName); 1837 description(testDescription); 1838 1839 try { 1840 //Create test cases 1841 es3fShaderMatrixTest.init(); 1842 if (range) 1843 state.setRange(range); 1844 //Run test cases 1845 tcuTestCase.runTestCases(); 1846 } 1847 catch (err) { 1848 bufferedLogToConsole(err); 1849 tcuTestCase.runner.terminate(); 1850 } 1851 }; 1852 });