| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| 'use strict'; |
| goog.provide('functional.gles3.es3fShaderMatrixTest'); |
| goog.require('framework.opengl.gluShaderUtil'); |
| goog.require('modules.shared.glsShaderRenderCase'); |
| goog.require('framework.common.tcuMatrix'); |
| goog.require('framework.delibs.debase.deMath'); |
| goog.require('framework.common.tcuTestCase'); |
| |
| goog.scope(function() { |
| |
| var es3fShaderMatrixTest= functional.gles3.es3fShaderMatrixTest; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| var glsShaderRenderCase = modules.shared.glsShaderRenderCase; |
| var tcuMatrix = framework.common.tcuMatrix; |
| var deMath = framework.delibs.debase.deMath; |
| var tcuTestCase = framework.common.tcuTestCase; |
| |
| |
| /** @const {Array<number>}*/ var s_constInFloat = [0.5, -0.2]; |
| /** @const {Array<Array<number>>}*/ var s_constInVec2 = [[1.2, 0.5], [0.5, 1.0]]; |
| /** @const {Array<Array<number>>}*/ var s_constInVec3 = [[1.1, 0.1, 0.5], [-0.2, 0.5, 0.8]]; |
| /** @const {Array<Array<number>>}*/ var s_constInVec4 = [[1.4, 0.2, -0.5, 0.7], [0.2, -1.0, 0.5, 0.8]]; |
| |
| /** @typedef {function(glsShaderRenderCase.ShaderEvalContext)} */ es3fShaderMatrixTest.MatrixShaderEvalFunc; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat2x2 = [ |
| [-0.1, 1.0, -0.2, 0.0], |
| [0.8, 0.1, 0.5, -0.9] |
| ]; |
| /** @const {Array<Array<number>>}*/ var s_constInMat3x2 = [ |
| [0.8, -0.3, 0.3, 1.0, 1.2, -1.2], |
| [1.2, -1.0, 0.5, -0.8, 1.1, 0.3] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat4x2 = [ |
| [-0.2, 0.5, 0.0, -1.0, 1.2, -0.5, 0.3, -0.9], |
| [1.0, 0.1, -1.1, 0.6, 0.8, -1.2, -1.1, 0.7] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat2x3 = [ |
| [-0.6, -0.1, -0.7, -1.2, -0.2, 0.0], |
| [1.1, 0.6, 0.8, 1.0, 0.7, 0.1] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat3x3 = [ |
| [-0.2, 1.1, 1.2, -1.0, 1.2, 0.5, 0.7, -0.2, 1.0], |
| [-0.1, -0.1, 0.1, -0.1, -0.2, 1.0, -0.5, 0.1, -0.4] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat4x3 = [ |
| [-0.9, 0.0, 0.6, 0.2, 0.9, -0.1, -0.3, -0.7, -0.1, 0.1, 1.0, 0.0], |
| [0.5, 0.7, 0.7, 1.2, 1.1, 0.1, 1.0, -1.0, -0.2, -0.2, -0.3, -0.5] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat2x4 = [ |
| [-0.6, -1.1, -0.6, -0.6, -0.2, -0.6, -0.1, -0.1], |
| [-1.2, -1.0, 0.7, -1.0, 0.7, 0.7, -0.4, -0.3] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat3x4 = [ |
| [0.6, -0.4, 1.2, 0.9, 0.8, 0.4, 1.1, 0.3, 0.5, -0.2, 0.0, 1.1], |
| [-0.8, 1.2, -0.2, -1.1, -0.9, -0.5, -1.2, 1.0, 1.2, 0.1, -0.7, -0.5] |
| ]; |
| |
| /** @const {Array<Array<number>>}*/ var s_constInMat4x4 = [ |
| [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], |
| [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] |
| ]; |
| |
| // Operation info |
| |
| /** |
| * @enum |
| */ |
| es3fShaderMatrixTest.OperationType = { |
| OPERATIONTYPE_BINARY_OPERATOR: 0, |
| OPERATIONTYPE_BINARY_FUNCTION: 1, |
| OPERATIONTYPE_UNARY_PREFIX_OPERATOR: 2, |
| OPERATIONTYPE_UNARY_POSTFIX_OPERATOR: 3, |
| OPERATIONTYPE_UNARY_FUNCTION: 4, |
| OPERATIONTYPE_ASSIGNMENT: 5 |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {string} |
| */ |
| es3fShaderMatrixTest.getOperationName = function(op) { |
| switch (op) { |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD: return '+'; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUB: return '-'; |
| case es3fShaderMatrixTest.MatrixOp.OP_MUL: return '*'; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIV: return '/'; |
| case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: return 'matrixCompMult'; |
| case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: return 'outerProduct'; |
| case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: return 'transpose'; |
| case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: return 'inverse'; |
| case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: return 'determinant'; |
| case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: return '+'; |
| case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: return '-'; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: return '++'; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: return '--'; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: return '++'; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: return '--'; |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: return '+='; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: return '-='; |
| case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: return '*='; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: return '/='; |
| default: |
| throw new Error('Error invalid Matrix Operation'); |
| } |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {es3fShaderMatrixTest.OperationType} |
| */ |
| es3fShaderMatrixTest.getOperationType = function (op) { |
| switch (op) |
| { |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUB: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_MUL: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIV: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION; |
| case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION; |
| case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION; |
| case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION; |
| case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION; |
| case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR; |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; |
| case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: return es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; |
| default: |
| throw new Error('Error invalid Matrix Operation'); |
| } |
| }; |
| |
| /** |
| * @enum |
| */ |
| es3fShaderMatrixTest.MatrixType = { |
| TESTMATRIXTYPE_DEFAULT: 0, |
| TESTMATRIXTYPE_NEGATED: 1, |
| TESTMATRIXTYPE_INCREMENTED: 2, |
| TESTMATRIXTYPE_DECREMENTED: 3, |
| TESTMATRIXTYPE_NEGATED_INCREMENTED: 4, |
| TESTMATRIXTYPE_INCREMENTED_LESS: 5 |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {es3fShaderMatrixTest.MatrixType} |
| */ |
| es3fShaderMatrixTest.getOperationTestMatrixType = function (op) { |
| switch(op) { |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUB: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_MUL: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIV: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DECREMENTED; |
| case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED_INCREMENTED; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED_LESS; |
| case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: return es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DECREMENTED; |
| default: |
| throw new Error('Error invalid Matrix Operation'); |
| } |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationBinary = function (op) { |
| return es3fShaderMatrixTest.getOperationType(op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR || |
| es3fShaderMatrixTest.getOperationType(op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION || |
| es3fShaderMatrixTest.getOperationType(op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationMatrixScalar = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_ADD || |
| op == es3fShaderMatrixTest.MatrixOp.OP_SUB || |
| op == es3fShaderMatrixTest.MatrixOp.OP_MUL || |
| op == es3fShaderMatrixTest.MatrixOp.OP_DIV; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationMatrixVector = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_MUL; |
| }; |
| |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationArithmeticMatrixMatrix = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_MUL; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationComponentwiseMatrixMatrix = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_ADD || |
| op == es3fShaderMatrixTest.MatrixOp.OP_SUB || |
| op == es3fShaderMatrixTest.MatrixOp.OP_MUL || |
| op == es3fShaderMatrixTest.MatrixOp.OP_DIV || |
| op == es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationVectorVector = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationUnaryAnyMatrix = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE || |
| op == es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS || |
| op == es3fShaderMatrixTest.MatrixOp.OP_NEGATION || |
| op == es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT || |
| op == es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT || |
| op == es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT || |
| op == es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationUnarySymmetricMatrix = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_INVERSE || |
| op == es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationValueModifying = function (op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT || |
| op == es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT || |
| op == es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT || |
| op == es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationAssignment = function(op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO || |
| op == es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM || |
| op == es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO || |
| op == es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationAssignmentAnyMatrix = function(op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO || |
| op == es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM || |
| op == es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {boolean} |
| */ |
| es3fShaderMatrixTest.isOperationAssignmentSymmetricMatrix = function(op) { |
| return op == es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO; |
| }; |
| |
| // Operation nature |
| |
| /** |
| * @enum |
| */ |
| es3fShaderMatrixTest.OperationNature = { |
| OPERATIONNATURE_PURE: 0, |
| OPERATIONNATURE_MUTATING: 1, |
| OPERATIONNATURE_ASSIGNMENT: 2 |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @return {es3fShaderMatrixTest.OperationNature} |
| */ |
| es3fShaderMatrixTest.getOperationNature = function (op) { |
| if (es3fShaderMatrixTest.isOperationAssignment(op)) |
| return es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_ASSIGNMENT; |
| if (es3fShaderMatrixTest.isOperationValueModifying(op)) |
| return es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_MUTATING; |
| return es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_PURE; |
| }; |
| |
| // Input value loader. |
| /** |
| * @param {es3fShaderMatrixTest.InputType} inputType |
| * @param {gluShaderUtil.DataType} typeFormat |
| * @param {glsShaderRenderCase.ShaderEvalContext} evalCtx |
| * @param {number} inputNdx |
| * @return {Array<number>|tcuMatrix.Matrix|number} |
| */ |
| es3fShaderMatrixTest.getInputValue = function (inputType, typeFormat, evalCtx, inputNdx) { |
| if (inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_CONST) { |
| switch (typeFormat) { |
| case gluShaderUtil.DataType.FLOAT: |
| return s_constInFloat[inputNdx]; |
| case gluShaderUtil.DataType.FLOAT_VEC2: |
| return s_constInVec2[inputNdx]; |
| case gluShaderUtil.DataType.FLOAT_VEC3: |
| return s_constInVec3[inputNdx]; |
| case gluShaderUtil.DataType.FLOAT_VEC4: |
| return s_constInVec4[inputNdx]; |
| case gluShaderUtil.DataType.FLOAT_MAT2: |
| return tcuMatrix.matrixFromDataArray(2, 2, s_constInMat2x2[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT2X3: |
| return tcuMatrix.matrixFromDataArray(3, 2, s_constInMat2x3[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT2X4: |
| return tcuMatrix.matrixFromDataArray(4, 2, s_constInMat2x4[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT3X2: |
| return tcuMatrix.matrixFromDataArray(2, 3, s_constInMat3x2[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT3: |
| return tcuMatrix.matrixFromDataArray(3, 3, s_constInMat3x3[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT3X4: |
| return tcuMatrix.matrixFromDataArray(4, 3, s_constInMat3x4[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT4X2: |
| return tcuMatrix.matrixFromDataArray(2, 4, s_constInMat4x2[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT4X3: |
| return tcuMatrix.matrixFromDataArray(3, 4, s_constInMat4x3[inputNdx]); |
| case gluShaderUtil.DataType.FLOAT_MAT4: |
| return tcuMatrix.matrixFromDataArray(4, 4, s_constInMat4x4[inputNdx]); |
| } |
| } else if (inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) { |
| switch (typeFormat) { |
| case gluShaderUtil.DataType.FLOAT: |
| return evalCtx.coords[0]; |
| case gluShaderUtil.DataType.FLOAT_VEC2: |
| return deMath.swizzle(evalCtx.coords, [0, 1]); |
| case gluShaderUtil.DataType.FLOAT_VEC3: |
| return deMath.swizzle(evalCtx.coords, [0, 1, 2]); |
| case gluShaderUtil.DataType.FLOAT_VEC4: |
| return deMath.swizzle(evalCtx.coords, [0, 1, 2, 3]); |
| case gluShaderUtil.DataType.FLOAT_MAT2: |
| var m = new tcuMatrix.Matrix(2, 2); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT2X3: |
| var m = new tcuMatrix.Matrix(3, 2); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT2X4: |
| var m = new tcuMatrix.Matrix(4, 2); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2, 3])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2, 3])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT3X2: |
| var m = new tcuMatrix.Matrix(2, 3); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1])); |
| m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT3: |
| var m = new tcuMatrix.Matrix(3, 3); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2])); |
| m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1, 2])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT3X4: |
| var m = new tcuMatrix.Matrix(4, 3); |
| m.setCol(0, evalCtx.in_[0]); |
| m.setCol(1, evalCtx.in_[1]); |
| m.setCol(2, evalCtx.in_[2]); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT4X2: |
| var m = new tcuMatrix.Matrix(2, 4); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1])); |
| m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1])); |
| m.setCol(3, deMath.swizzle(evalCtx.in_[3], [0, 1])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT4X3: |
| var m = new tcuMatrix.Matrix(3, 4); |
| m.setCol(0, deMath.swizzle(evalCtx.in_[0], [0, 1, 2])); |
| m.setCol(1, deMath.swizzle(evalCtx.in_[1], [0, 1, 2])); |
| m.setCol(2, deMath.swizzle(evalCtx.in_[2], [0, 1, 2])); |
| m.setCol(3, deMath.swizzle(evalCtx.in_[3], [0, 1, 2])); |
| return m; |
| case gluShaderUtil.DataType.FLOAT_MAT4: |
| var m = new tcuMatrix.Matrix(4, 4); |
| m.setCol(0, evalCtx.in_[0]); |
| m.setCol(1, evalCtx.in_[1]); |
| m.setCol(2, evalCtx.in_[2]); |
| m.setCol(3, evalCtx.in_[3]); |
| return m; |
| } |
| } |
| throw new Error('Invalid input type'); |
| }; |
| |
| /** |
| * @param {Array<number>} value |
| * @return {Array<number>} |
| */ |
| es3fShaderMatrixTest.reduceVecToVec3 = function (value) { |
| if (value.length == 3) { |
| return value; |
| } else if (value.length == 2) { |
| return deMath.swizzle(value, [0, 1, 0]) |
| } else { |
| return [value[0], value[1], value[2] + value[3]]; |
| } |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} value |
| * @return {Array<number>} |
| */ |
| es3fShaderMatrixTest.reduceMatToVec3 = function (value) { |
| if (value.cols == 2) { |
| if (value.rows == 2) { |
| // mat2 |
| return [value.get(0, 0), value.get(0, 1), value.get(1, 0) + value.get(1, 1)]; |
| } else if (value.rows == 3){ |
| //mat2x3 |
| return deMath.add(value.getColumn(0), value.getColumn(1)); |
| } else { |
| //mat2x4 |
| return deMath.add(deMath.swizzle(value.getColumn(0), [0, 1, 2]), deMath.swizzle(value.getColumn(1), [1, 2, 3])); |
| } |
| } else if (value.cols == 3) { |
| if (value.rows == 2) { |
| 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)]; |
| } else if (value.rows == 3) { |
| return deMath.add(deMath.add(value.getColumn(0), value.getColumn(1)), value.getColumn(2)); |
| } else { |
| 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])) |
| } |
| } else { |
| if (value.rows == 2) { |
| 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)]; |
| } else if (value.rows == 3) { |
| return deMath.add(deMath.add(deMath.add(value.getColumn(0), value.getColumn(1)), value.getColumn(2)), value.getColumn(3)); |
| } else { |
| 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])); |
| } |
| } |
| }; |
| |
| /** |
| * @param {Array<number>|tcuMatrix.Matrix|number} value |
| * @return {Array<number>} |
| */ |
| es3fShaderMatrixTest.reduceToVec3 = function (value) { |
| if (value instanceof tcuMatrix.Matrix) |
| return es3fShaderMatrixTest.reduceMatToVec3(value); |
| else if (value instanceof Array) |
| return es3fShaderMatrixTest.reduceVecToVec3(value); |
| else |
| throw new Error('Impossible case'); |
| }; |
| |
| es3fShaderMatrixTest.add = function (a, b) { |
| if (a instanceof tcuMatrix.Matrix) { |
| if (b instanceof tcuMatrix.Matrix) |
| return tcuMatrix.add(a, b); |
| else if (b instanceof Array) |
| throw new Error('Unimplemented'); |
| else |
| return tcuMatrix.addMatScal(a, b); |
| } |
| else { |
| if (b instanceof tcuMatrix.Matrix) |
| throw new Error('Unimplemented'); |
| else |
| return deMath.add(a, b); |
| } |
| }; |
| |
| es3fShaderMatrixTest.subtract = function (a, b) { |
| if (a instanceof tcuMatrix.Matrix) { |
| if (b instanceof tcuMatrix.Matrix) |
| return tcuMatrix.subtract(a, b); |
| else if (b instanceof Array) |
| throw new Error('Unimplemented'); |
| else |
| return tcuMatrix.subtractMatScal(a, b); |
| } |
| else { |
| if (b instanceof tcuMatrix.Matrix) |
| throw new Error('Unimplemented'); |
| else |
| return deMath.subtract(a, b); |
| } |
| }; |
| |
| es3fShaderMatrixTest.multiply = function (a, b) { |
| if (a instanceof tcuMatrix.Matrix) { |
| if (b instanceof tcuMatrix.Matrix) |
| return tcuMatrix.multiply(a, b); |
| else if (b instanceof Array) |
| return tcuMatrix.multiplyMatVec(a, b); |
| else |
| return tcuMatrix.multiplyMatScal(a, b); |
| } else { |
| if (b instanceof tcuMatrix.Matrix) |
| return tcuMatrix.multiplyVecMat(a, b); |
| else |
| return deMath.multiply(a, b); |
| } |
| }; |
| |
| es3fShaderMatrixTest.divide = function (a, b) { |
| if (a instanceof tcuMatrix.Matrix) { |
| if (b instanceof tcuMatrix.Matrix) |
| return tcuMatrix.divide(a, b); |
| else if (b instanceof Array) |
| throw new Error('Unimplemented'); |
| else |
| return tcuMatrix.divideMatScal(a, b); |
| } |
| else { |
| if (b instanceof tcuMatrix.Matrix) |
| throw new Error('Unimplemented'); |
| else |
| return deMath.divide(a, b); |
| } |
| }; |
| |
| |
| /** |
| * @param {tcuMatrix.Matrix} a |
| * @param {tcuMatrix.Matrix} b |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.matrixCompMult = function (a, b) { |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(a.rows, a.cols); |
| |
| for (var r = 0; r < a.rows; ++r) { |
| for (var c = 0; c < a.cols; ++c) { |
| retVal.set(r, c, a.get(r, c) * b.get(r, c)); |
| } |
| } |
| return retVal; |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.transpose = function (mat) { |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.cols, mat.rows); |
| |
| for (var r = 0; r < mat.rows; ++r) { |
| for (var c = 0; c < mat.cols; ++c) { |
| retVal.set(c, r, mat.get(r, c)); |
| } |
| } |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {number} |
| */ |
| es3fShaderMatrixTest.determinantMat2 = function (mat) { |
| return mat.get(0, 0) * mat.get(1, 1) - mat.get(1, 0) * mat.get(0,1); |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {number} |
| */ |
| es3fShaderMatrixTest.determinantMat3 = function (mat) { |
| return + mat.get(0, 0) * mat.get(1, 1) * mat.get(2, 2) |
| + mat.get(0, 1) * mat.get(1, 2) * mat.get(2, 0) |
| + mat.get(0, 2) * mat.get(1, 0) * mat.get(2, 1) |
| - mat.get(0, 0) * mat.get(1, 2) * mat.get(2, 1) |
| - mat.get(0, 1) * mat.get(1, 0) * mat.get(2, 2) |
| - mat.get(0, 2) * mat.get(1, 1) * mat.get(2, 0); |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {number} |
| */ |
| es3fShaderMatrixTest.determinantMat4 = function (mat) { |
| /** @type {Array<Array<number>>} */ var minorMatrices = [ |
| [ |
| mat.get(1, 1), mat.get(2, 1), mat.get(3, 1), |
| mat.get(1, 2), mat.get(2, 2), mat.get(3, 2), |
| mat.get(1, 3), mat.get(2, 3), mat.get(3, 3) |
| ], |
| [ |
| mat.get(1, 0), mat.get(2, 0), mat.get(3, 0), |
| mat.get(1, 2), mat.get(2, 2), mat.get(3, 2), |
| mat.get(1, 3), mat.get(2, 3), mat.get(3, 3) |
| ], |
| [ |
| mat.get(1, 0), mat.get(2, 0), mat.get(3, 0), |
| mat.get(1, 1), mat.get(2, 1), mat.get(3, 1), |
| mat.get(1, 3), mat.get(2, 3), mat.get(3, 3) |
| ], |
| [ |
| mat.get(1, 0), mat.get(2, 0), mat.get(3, 0), |
| mat.get(1, 1), mat.get(2, 1), mat.get(3, 1), |
| mat.get(1, 2), mat.get(2, 2), mat.get(3, 2) |
| ] |
| ]; |
| |
| return + mat.get(0, 0) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[0])) |
| - mat.get(0, 1) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[1])) |
| + mat.get(0, 2) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[2])) |
| - mat.get(0, 3) * es3fShaderMatrixTest.determinant(tcuMatrix.matrixFromDataArray(3, 3, minorMatrices[3])); |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {number} |
| */ |
| es3fShaderMatrixTest.determinant = function (mat) { |
| if (mat.rows == 2) { |
| return es3fShaderMatrixTest.determinantMat2(mat); |
| } else if (mat.rows == 3) { |
| return es3fShaderMatrixTest.determinantMat3(mat); |
| } else { |
| return es3fShaderMatrixTest.determinantMat4(mat); |
| } |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.inverseMat2 = function (mat) { |
| /** @type {number} */ var det = es3fShaderMatrixTest.determinant(mat); |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Mat2(); |
| |
| if (det == 0.0) { |
| throw new Error('Wrong determinant') |
| } |
| |
| retVal.set(0, 0, mat.get(1, 1) / det); |
| retVal.set(0, 1, -mat.get(0, 1) / det); |
| retVal.set(1, 0, -mat.get(1, 0) / det); |
| retVal.set(1, 1, mat.get(0, 0) / det); |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.inverseMat3 = function (mat) { |
| if (es3fShaderMatrixTest.determinant(mat) == 0.0) { |
| throw new Error('Wrong determinant') |
| } |
| |
| /** @type {Array<number>} */ var areaA = [mat.get(0, 0), mat.get(0, 1), mat.get(1, 0), mat.get(1,1)]; |
| /** @type {Array<number>} */ var areaB = [mat.get(0, 2), mat.get(1, 2)]; |
| /** @type {Array<number>} */ var areaC = [mat.get(2, 0), mat.get(2, 1)]; |
| /** @type {Array<number>} */ var areaD = [mat.get(2,2)]; |
| |
| /** @type {tcuMatrix.Matrix} */ var invA = es3fShaderMatrixTest.inverse(tcuMatrix.matrixFromDataArray(2, 2, areaA)); |
| /** @type {tcuMatrix.Matrix} */ var matB = tcuMatrix.matrixFromDataArray(2, 1, areaB); |
| /** @type {tcuMatrix.Matrix} */ var matC = tcuMatrix.matrixFromDataArray(1, 2, areaC); |
| /** @type {tcuMatrix.Matrix} */ var matD = tcuMatrix.matrixFromDataArray(1, 1, areaD); |
| |
| /** @type {tcuMatrix.Matrix} */ var tmp = tcuMatrix.subtract(matD, tcuMatrix.multiply(matC, tcuMatrix.multiply(invA, matB))); |
| /** @type {number} */ var schurComplement = 1.0 / tmp.get(0, 0); |
| /** @type {tcuMatrix.Matrix} */ var zeroMat = new tcuMatrix.Matrix(2, 2, 0); |
| |
| /** @type {tcuMatrix.Matrix} */ var blockA = tcuMatrix.add(invA, tcuMatrix.multiply(tcuMatrix.multiply(invA, tcuMatrix.multiply(tcuMatrix.multiplyMatScal(matB, schurComplement), matC)), invA)); |
| /** @type {tcuMatrix.Matrix} */ var blockB = tcuMatrix.multiplyMatScal(tcuMatrix.multiply(tcuMatrix.subtract(zeroMat, invA), matB), schurComplement); |
| /** @type {tcuMatrix.Matrix} */ var blockC = tcuMatrix.multiply(matC, tcuMatrix.multiplyMatScal(invA, - schurComplement)); |
| /** @type {number} */ var blockD = schurComplement; |
| |
| /** @type {Array<number>} */ var result = [ |
| blockA.get(0, 0), blockA.get(0, 1), blockB.get(0, 0), |
| blockA.get(1, 0), blockA.get(1, 1), blockB.get(1, 0), |
| blockC.get(0, 0), blockC.get(0, 1), blockD |
| ]; |
| |
| return tcuMatrix.matrixFromDataArray(3, 3, result); |
| } |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.inverseMat4 = function (mat) { |
| // Blockwise inversion |
| if (es3fShaderMatrixTest.determinant(mat) == 0.0) { |
| throw new Error('Wrong determinant') |
| } |
| |
| /** @type {Array<number>} */ var areaA = [ |
| mat.get(0, 0), mat.get(0, 1), |
| mat.get(1, 0), mat.get(1, 1) |
| ]; |
| /** @type {Array<number>} */ var areaB = [ |
| mat.get(0, 2), mat.get(0, 3), |
| mat.get(1, 2), mat.get(1, 3) |
| ]; |
| /** @type {Array<number>} */ var areaC = [ |
| mat.get(2, 0), mat.get(2, 1), |
| mat.get(3, 0), mat.get(3, 1) |
| ]; |
| /** @type {Array<number>} */ var areaD = [ |
| mat.get(2, 2), mat.get(2, 3), |
| mat.get(3, 2), mat.get(3, 3) |
| ]; |
| |
| /** @type {tcuMatrix.Matrix} */ var invA = es3fShaderMatrixTest.inverse(tcuMatrix.matrixFromDataArray(2, 2, areaA)); |
| /** @type {tcuMatrix.Matrix} */ var matB = tcuMatrix.matrixFromDataArray(2, 2, areaB); |
| /** @type {tcuMatrix.Matrix} */ var matC = tcuMatrix.matrixFromDataArray(2, 2, areaC); |
| /** @type {tcuMatrix.Matrix} */ var matD = tcuMatrix.matrixFromDataArray(2, 2, areaD); |
| |
| /** @type {tcuMatrix.Matrix} */ var schurComplement = es3fShaderMatrixTest.inverse(tcuMatrix.subtract(matD, (tcuMatrix.multiply(matC, tcuMatrix.multiply(invA, matB))))); |
| /** @type {tcuMatrix.Matrix} */ var zeroMat = new tcuMatrix.Matrix(2, 2, 0); |
| |
| /** @type {tcuMatrix.Matrix} */ var blockA = tcuMatrix.add(invA, tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.multiply(invA, matB), schurComplement), matC), invA)); |
| /** @type {tcuMatrix.Matrix} */ var blockB = tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.subtract(zeroMat, invA), matB), schurComplement); |
| /** @type {tcuMatrix.Matrix} */ var blockC = tcuMatrix.multiply(tcuMatrix.multiply(tcuMatrix.subtract(zeroMat, schurComplement),matC), invA); |
| /** @type {tcuMatrix.Matrix} */ var blockD = schurComplement; |
| |
| /** @type {Array<number>} */ var result = [ |
| blockA.get(0, 0), blockA.get(0, 1), blockB.get(0, 0), blockB.get(0, 1), |
| blockA.get(1, 0), blockA.get(1, 1), blockB.get(1, 0), blockB.get(1, 1), |
| blockC.get(0, 0), blockC.get(0, 1), blockD.get(0, 0), blockD.get(0, 1), |
| blockC.get(1, 0), blockC.get(1, 1), blockD.get(1, 0), blockD.get(1, 1) |
| ]; |
| |
| return tcuMatrix.matrixFromDataArray(4, 4, result); |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.inverse = function (mat) { |
| if (mat.cols == 2) { |
| return es3fShaderMatrixTest.inverseMat2(mat) |
| } else if (mat.cols == 3) { |
| return es3fShaderMatrixTest.inverseMat3(mat) |
| } else { |
| return es3fShaderMatrixTest.inverseMat4(mat) |
| } |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.negate = function (mat) { |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.rows, mat.cols); |
| |
| for (var r = 0; r < mat.rows; ++r) |
| for (var c = 0; c < mat.cols; ++c) |
| retVal.set(r,c, -mat.get(r, c)); |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.increment = function (mat) { |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.rows, mat.cols); |
| |
| for (var r = 0; r < mat.rows; ++r) |
| for (var c = 0; c < mat.cols; ++c) |
| retVal.set(r,c, mat.get(r, c) + 1.0); |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {tcuMatrix.Matrix} mat |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.decrement = function (mat) { |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(mat.rows, mat.cols); |
| |
| for (var r = 0; r < mat.rows; ++r) |
| for (var c = 0; c < mat.cols; ++c) |
| retVal.set(r,c, mat.get(r, c) - 1.0); |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {Array<number>} a |
| * @param {Array<number>} b |
| * @return {tcuMatrix.Matrix} |
| */ |
| es3fShaderMatrixTest.outerProduct = function (a, b) { |
| /** @type {tcuMatrix.Matrix} */ var retVal = new tcuMatrix.Matrix(b.length, a.length); |
| |
| for (var r = 0; r < b.length; ++r) { |
| for (var c = 0; c < a.length; ++c) { |
| retVal.set(r, c, a[c] * b[r]); |
| } |
| } |
| |
| return es3fShaderMatrixTest.transpose(retVal); |
| }; |
| |
| /** |
| * @enum |
| */ |
| es3fShaderMatrixTest.InputType = { |
| INPUTTYPE_CONST: 0, |
| INPUTTYPE_UNIFORM: 1, |
| INPUTTYPE_DYNAMIC: 2 |
| }; |
| |
| /** |
| * @enum |
| */ |
| es3fShaderMatrixTest.MatrixOp = { |
| OP_ADD: 0, |
| OP_SUB: 1, |
| OP_MUL: 2, |
| OP_DIV: 3, |
| OP_COMP_MUL: 4, |
| OP_OUTER_PRODUCT: 5, |
| OP_TRANSPOSE: 6, |
| OP_INVERSE: 7, |
| OP_DETERMINANT: 8, |
| OP_UNARY_PLUS: 9, |
| OP_NEGATION: 10, |
| OP_PRE_INCREMENT: 11, |
| OP_PRE_DECREMENT: 12, |
| OP_POST_INCREMENT: 13, |
| OP_POST_DECREMENT: 14, |
| OP_ADD_INTO: 15, |
| OP_SUBTRACT_FROM: 16, |
| OP_MULTIPLY_INTO: 17, |
| OP_DIVIDE_INTO: 18, |
| OP_LAST: 19 |
| }; |
| |
| /** |
| * @constructor |
| * @param {es3fShaderMatrixTest.InputType=} inputType_ |
| * @param {gluShaderUtil.DataType=} dataType_ |
| * @param {gluShaderUtil.precision=} precision_ |
| * @struct |
| */ |
| es3fShaderMatrixTest.ShaderInput = function (inputType_, dataType_, precision_){ |
| this.inputType = inputType_ || es3fShaderMatrixTest.InputType.INPUTTYPE_CONST; |
| this.dataType = dataType_ || gluShaderUtil.DataType.INVALID; |
| this.precision = precision_ || gluShaderUtil.precision.PRECISION_LOWP; |
| }; |
| |
| /** |
| * @param {es3fShaderMatrixTest.ShaderInput} in0 |
| * @param {es3fShaderMatrixTest.ShaderInput} in1 |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| */ |
| es3fShaderMatrixTest.getEvalFunc = function (in0, in1, op) { |
| var setColor = function(evalCtx, src) { |
| for (var i = 0; i < 3; i++) |
| evalCtx.color[i] = src[i]; |
| }; |
| switch(op){ |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.add(in0_, in1_))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUB: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.subtract(in0_, in1_))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_MUL: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.multiply(in0_, in1_))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIV: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.divide(in0_, in1_))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.matrixCompMult(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.outerProduct(/** @type {Array<number>} */(in0_), /** @type {Array<number>} */(in1_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.transpose(/** @type {tcuMatrix.Matrix} */(in0_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_INVERSE: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.inverse(/** @type {tcuMatrix.Matrix} */(in0_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| var det = es3fShaderMatrixTest.determinant(/** @type {tcuMatrix.Matrix} */(in0_)); |
| setColor(evalCtx, [det, det, det]); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(/** @type {tcuMatrix.Matrix} */(in0_))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_NEGATION: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.negate(/** @type {tcuMatrix.Matrix} */(in0_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| var val0 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.increment(/** @type {tcuMatrix.Matrix} */(in0_))); |
| var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.increment(/** @type {tcuMatrix.Matrix} */(in0_))); |
| setColor(evalCtx, deMath.add(val0, val1)); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| var val0 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.decrement(/** @type {tcuMatrix.Matrix} */(in0_))); |
| var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.decrement(/** @type {tcuMatrix.Matrix} */(in0_))); |
| setColor(evalCtx, deMath.add(val0, val1)); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| var val0 = es3fShaderMatrixTest.reduceToVec3((in0_)); |
| var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.increment(/** @type {tcuMatrix.Matrix} */(in0_))); |
| setColor(evalCtx, deMath.add(val0, val1)); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| |
| var val0 = es3fShaderMatrixTest.reduceToVec3((in0_)); |
| var val1 = es3fShaderMatrixTest.reduceToVec3(es3fShaderMatrixTest.decrement(/** @type {tcuMatrix.Matrix} */(in0_))); |
| setColor(evalCtx, deMath.add(val0, val1)); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in0.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.add(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in0.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.subtract(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in0.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.multiply(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); |
| }; |
| case es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO: |
| return function (evalCtx) { |
| var in0_ = in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in0.inputType, in0.dataType, evalCtx, 0) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in0.dataType, evalCtx, 0); |
| var in1_ = in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? |
| es3fShaderMatrixTest.getInputValue(in1.inputType, in1.dataType, evalCtx, 1) |
| : es3fShaderMatrixTest.getInputValue(es3fShaderMatrixTest.InputType.INPUTTYPE_CONST, in1.dataType, evalCtx, 1); |
| |
| setColor(evalCtx, es3fShaderMatrixTest.reduceToVec3(tcuMatrix.divide(/** @type {tcuMatrix.Matrix} */(in0_), /** @type {tcuMatrix.Matrix} */(in1_)))); |
| }; |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @param {es3fShaderMatrixTest.MatrixShaderEvalFunc} evalFunc |
| * @param {es3fShaderMatrixTest.InputType} inType0 |
| * @param {es3fShaderMatrixTest.InputType} inType1 |
| * @extends {glsShaderRenderCase.ShaderEvaluator} |
| */ |
| es3fShaderMatrixTest.MatrixShaderEvaluator = function(evalFunc, inType0, inType1) { |
| glsShaderRenderCase.ShaderEvaluator.call(this); |
| this.m_matEvalFunc = evalFunc; |
| this.m_inType0 = inType0; |
| this.m_inType1 = inType1; |
| }; |
| |
| es3fShaderMatrixTest.MatrixShaderEvaluator.prototype = Object.create(glsShaderRenderCase.ShaderEvaluator); |
| es3fShaderMatrixTest.MatrixShaderEvaluator.prototype.constructor = es3fShaderMatrixTest.MatrixShaderEvaluator; |
| |
| /** |
| * @param {glsShaderRenderCase.ShaderEvalContext} evalCtx |
| */ |
| es3fShaderMatrixTest.MatrixShaderEvaluator.prototype.evaluate = function (evalCtx) { |
| this.m_matEvalFunc(evalCtx); |
| } |
| |
| /** |
| * @param {Array<number>} v |
| * @param {number} size |
| */ |
| es3fShaderMatrixTest.writeVectorConstructor = function (v, size) { |
| var str = 'vec' + size + ''; |
| for (var ndx = 0; ndx < size; ndx++) { |
| if (ndx != 0) |
| str += ', '; |
| str += v[ndx].toString; |
| } |
| str += ')'; |
| return str; |
| } |
| |
| /** |
| * @param {tcuMatrix.Matrix} m |
| */ |
| es3fShaderMatrixTest.writeMatrixConstructor = function (m) { |
| var str = ''; |
| if (m.rows == m.cols) |
| str += 'mat' + m.cols; |
| else |
| str += 'mat' + m.cols + 'x' + m.rows; |
| |
| str += '('; |
| for (var colNdx = 0; colNdx < m.cols; colNdx++) { |
| for (var rowNdx = 0; rowNdx < m.rows; rowNdx++) { |
| if (rowNdx > 0 || colNdx > 0) |
| str += ', '; |
| str += m.get(rowNdx, colNdx).toString(); |
| } |
| } |
| str += ')'; |
| return str; |
| }; |
| |
| /** |
| * @constructor |
| * @param {string} name |
| * @param {string} desc |
| * @param {es3fShaderMatrixTest.ShaderInput} in0 |
| * @param {es3fShaderMatrixTest.ShaderInput} in1 |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @param {boolean} isVertexCase |
| * @extends {glsShaderRenderCase.ShaderRenderCase} |
| */ |
| es3fShaderMatrixTest.ShaderMatrixCase = function(name, desc, in0, in1, op, isVertexCase) { |
| var evalFunc = es3fShaderMatrixTest.getEvalFunc(in0, in1, op); |
| glsShaderRenderCase.ShaderRenderCase.call(this, name, desc, isVertexCase, evalFunc); |
| this.m_in0 = in0; |
| this.m_in1 = in1; |
| this.m_op = op; |
| this.m_evaluator = new es3fShaderMatrixTest.MatrixShaderEvaluator(evalFunc, in0.inputType, in1.inputType); |
| }; |
| |
| es3fShaderMatrixTest.ShaderMatrixCase.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype); |
| es3fShaderMatrixTest.ShaderMatrixCase.prototype.constructor = es3fShaderMatrixTest.ShaderMatrixCase; |
| |
| |
| es3fShaderMatrixTest.ShaderMatrixCase.prototype.init = function () { |
| var shaderSources = [ '', '' ]; |
| var vtx = 0; |
| var frag = 1; |
| var op = this.m_isVertexCase ? vtx : frag; |
| |
| /** @type {boolean} */ var isInDynMat0 = gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) && this.m_in0.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC; |
| /** @type {boolean} */ var isInDynMat1 = gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType) && this.m_in1.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC; |
| /** @type {Array<string>} */ var inValues = []; |
| /** @type {gluShaderUtil.DataType} */ var resultType; |
| /** @type {gluShaderUtil.precision} */ var resultPrec = this.m_in0.precision; |
| /** @type {Array<string>} */ var passVars = []; |
| /** @type {number} */ var numInputs = (es3fShaderMatrixTest.isOperationBinary(this.m_op)) ? (2) : (1); |
| |
| /** @type {string} */ var operationValue0 = ''; |
| /** @type {string} */ var operationValue1 = ''; |
| |
| if (isInDynMat0 && isInDynMat1) { |
| throw new Error ('Only single dynamic matrix input is allowed.'); |
| } |
| |
| if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_MUL && gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) && gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType)) { |
| resultType = gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeMatrixNumColumns(this.m_in1.dataType), gluShaderUtil.getDataTypeMatrixNumRows(this.m_in0.dataType)); |
| } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT) { |
| resultType = gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeScalarSize(this.m_in1.dataType), gluShaderUtil.getDataTypeScalarSize(this.m_in0.dataType)); |
| } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE) { |
| resultType = gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeMatrixNumRows(this.m_in0.dataType), gluShaderUtil.getDataTypeMatrixNumColumns(this.m_in0.dataType)); |
| } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_INVERSE) { |
| resultType = this.m_in0.dataType; |
| } else if (this.m_op == es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT) { |
| resultType = gluShaderUtil.DataType.FLOAT; |
| } else if (es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR || |
| es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR) { |
| resultType = this.m_in0.dataType; |
| } else if (gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) && gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType)) { |
| if (this.m_in0.dataType !== this.m_in1.dataType) { |
| throw new Error ('Incompatible data types'); |
| } |
| resultType = this.m_in0.dataType; |
| } else if (gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) || gluShaderUtil.isDataTypeMatrix(this.m_in1.dataType)) { |
| /** @type {number} */ var matNdx = gluShaderUtil.isDataTypeMatrix(this.m_in0.dataType) ? 0 : 1; |
| /** @type {gluShaderUtil.DataType} */ var matrixType = matNdx == 0 ? this.m_in0.dataType : this.m_in1.dataType; |
| /** @type {gluShaderUtil.DataType} */ var otherType = matNdx == 0 ? this.m_in1.dataType : this.m_in0.dataType; |
| |
| if (otherType == gluShaderUtil.DataType.FLOAT) |
| resultType = matrixType; |
| else { |
| if (!gluShaderUtil.isDataTypeVector(otherType)) { |
| throw new Error ('Is not data type vector'); |
| } |
| resultType = gluShaderUtil.getDataTypeFloatVec(matNdx == 0 ? gluShaderUtil.getDataTypeMatrixNumRows(matrixType) : gluShaderUtil.getDataTypeMatrixNumColumns(matrixType)); |
| } |
| } else { |
| throw new Error ('Error'); |
| } |
| |
| shaderSources[vtx] += '#version 300 es\n'; |
| shaderSources[frag] += '#version 300 es\n'; |
| |
| shaderSources[vtx] += 'in highp vec4 a_position;\n'; |
| shaderSources[frag] += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n'; |
| if (this.m_isVertexCase) { |
| shaderSources[vtx] += 'out mediump vec4 v_color;\n'; |
| shaderSources[frag] += 'in mediump vec4 v_color;\n'; |
| } |
| |
| // Input declarations. |
| for (var inNdx = 0; inNdx < numInputs; inNdx++) { |
| /** @type {es3fShaderMatrixTest.ShaderInput} */ var ind = inNdx > 0 ? this.m_in1 : this.m_in0; |
| /** @type {string} */ var precName = gluShaderUtil.getPrecisionName(ind.precision); |
| /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(ind.dataType); |
| /** @type {number} */ var inValueNdx = inNdx > 0 ? 1 : 0; |
| |
| if (ind.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) { |
| shaderSources[vtx] += 'in ' + precName + ' ' + typeName + ' a_'; |
| |
| if (gluShaderUtil.isDataTypeMatrix(ind.dataType)) { |
| // a_matN, v_matN |
| shaderSources[vtx] += typeName + ';\n'; |
| if (!this.m_isVertexCase) { |
| shaderSources[vtx] += 'out ' + precName + ' ' + typeName + ' v_' + typeName + ';\n'; |
| shaderSources[frag] += 'in ' + precName + ' ' + typeName + ' v_' + typeName + ';\n'; |
| passVars.push(typeName); |
| } |
| |
| inValues[inValueNdx] = (this.m_isVertexCase ? 'a_' : 'v_') + gluShaderUtil.getDataTypeName(ind.dataType); |
| } else { |
| // a_coords, v_coords |
| shaderSources[vtx] += 'coords;\n'; |
| if (!this.m_isVertexCase) { |
| shaderSources[vtx] += 'out ' + precName + ' ' + typeName + ' v_coords;\n'; |
| shaderSources[frag] += 'in ' + precName + ' ' + typeName + ' v_coords;\n'; |
| passVars.push('coords'); |
| } |
| |
| inValues[inValueNdx] = this.m_isVertexCase ? 'a_coords' : 'v_coords'; |
| } |
| } else if (ind.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM) { |
| shaderSources[op] += 'uniform ' + precName + ' ' + typeName + ' u_in' + inNdx + ';\n'; |
| inValues[inValueNdx] = 'u_in' + inNdx.toString(); |
| } else if (ind.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_CONST) { |
| shaderSources[op] += 'const ' + precName + ' ' + typeName + ' in' + inNdx + ' = '; |
| |
| // Generate declaration. |
| switch (ind.dataType) { |
| case gluShaderUtil.DataType.FLOAT: |
| shaderSources[op] += s_constInFloat[inNdx].toString(); |
| break; |
| case gluShaderUtil.DataType.FLOAT_VEC2: |
| shaderSources[op] += es3fShaderMatrixTest.writeVectorConstructor( s_constInVec2[inNdx], 2); |
| break; |
| case gluShaderUtil.DataType.FLOAT_VEC3: |
| shaderSources[op] += es3fShaderMatrixTest.writeVectorConstructor( s_constInVec3[inNdx], 3); |
| break; |
| case gluShaderUtil.DataType.FLOAT_VEC4: |
| shaderSources[op] += es3fShaderMatrixTest.writeVectorConstructor( s_constInVec4[inNdx], 4); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT2: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(2, 2, s_constInMat2x2[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT2X3: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(3, 2, s_constInMat2x3[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT2X4: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(4, 2, s_constInMat2x4[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT3X2: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(2, 3, s_constInMat3x2[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT3: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(3, 3, s_constInMat3x3[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT3X4: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(4, 3, s_constInMat3x4[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT4X2: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(2, 4, s_constInMat4x2[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT4X3: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(3, 4, s_constInMat4x3[inNdx])); |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT4: |
| shaderSources[op] += es3fShaderMatrixTest.writeMatrixConstructor( tcuMatrix.matrixFromDataArray(4, 4, s_constInMat4x4[inNdx])); |
| break; |
| |
| default: |
| throw new Error('Data type error'); |
| } |
| |
| shaderSources[op] += ';\n'; |
| |
| inValues[inValueNdx] = 'in' + inNdx.toString(); |
| } |
| } |
| |
| shaderSources[vtx] += '\n' |
| + 'void main (void)\n' |
| + '{\n' |
| + ' gl_Position = a_position;\n'; |
| shaderSources[frag] += '\n' |
| + 'void main (void)\n' |
| + '{\n'; |
| |
| if (this.m_isVertexCase) |
| shaderSources[frag] += ' dEQP_FragColor = v_color;\n'; |
| else { |
| for (var i = 0; i != passVars.length; i++) |
| shaderSources[vtx] += ' v_' + passVars[i] + ' = ' + 'a_' + passVars[i] + ';\n'; |
| } |
| |
| // Operation. |
| |
| switch (es3fShaderMatrixTest.getOperationNature(this.m_op)) { |
| case es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_PURE: |
| if (es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT) |
| throw new Error('Wrong operation type'); |
| |
| operationValue0 = inValues[0]; |
| operationValue1 = inValues[1]; |
| break; |
| |
| case es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_MUTATING: |
| if (es3fShaderMatrixTest.getOperationType(this.m_op) == es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT) |
| throw new Error('Wrong operation type'); |
| |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' + gluShaderUtil.getDataTypeName(resultType) + ' tmpValue = ' + inValues[0] + ';\n'; |
| |
| operationValue0 = 'tmpValue'; |
| operationValue1 = inValues[1]; |
| break; |
| |
| case es3fShaderMatrixTest.OperationNature.OPERATIONNATURE_ASSIGNMENT: |
| if (es3fShaderMatrixTest.getOperationType(this.m_op) != es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT) |
| throw new Error('Wrong operation type'); |
| |
| operationValue0 = inValues[0]; |
| operationValue1 = inValues[1]; |
| break; |
| |
| default: |
| throw new Error('Wrong operation nature'); |
| } |
| |
| switch (es3fShaderMatrixTest.getOperationType(this.m_op)) { |
| case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_OPERATOR: |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' |
| + gluShaderUtil.getDataTypeName(resultType) |
| + ' res = ' + operationValue0 + ' ' |
| + es3fShaderMatrixTest.getOperationName(this.m_op) + ' ' |
| + operationValue1 + ';\n'; |
| break; |
| case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_PREFIX_OPERATOR: |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' |
| + gluShaderUtil.getDataTypeName(resultType) |
| + ' res = ' + es3fShaderMatrixTest.getOperationName(this.m_op) |
| + operationValue0 + ';\n'; |
| break; |
| case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_POSTFIX_OPERATOR: |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) + ' ' |
| + gluShaderUtil.getDataTypeName(resultType) |
| + ' res = ' + operationValue0 |
| + es3fShaderMatrixTest.getOperationName(this.m_op) + ';\n'; |
| break; |
| case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_BINARY_FUNCTION: |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) |
| + ' ' + gluShaderUtil.getDataTypeName(resultType) |
| + ' res = ' + es3fShaderMatrixTest.getOperationName(this.m_op) |
| + '(' + operationValue0 |
| + ', ' + operationValue1 + ');\n'; |
| break; |
| case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_UNARY_FUNCTION: |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) |
| + ' ' + gluShaderUtil.getDataTypeName(resultType) |
| + ' res = ' + es3fShaderMatrixTest.getOperationName(this.m_op) |
| + '(' + operationValue0 + ');\n'; |
| break; |
| case es3fShaderMatrixTest.OperationType.OPERATIONTYPE_ASSIGNMENT: |
| shaderSources[op] += ' ' + gluShaderUtil.getPrecisionName(resultPrec) |
| + ' ' + gluShaderUtil.getDataTypeName(resultType) |
| + ' res = ' + operationValue0 + ';\n'; |
| shaderSources[op] += ' res ' + es3fShaderMatrixTest.getOperationName(this.m_op) |
| + ' ' + operationValue1 + ';\n'; |
| break; |
| default: |
| throw new Error('Wrong operation type'); |
| } |
| |
| // Reduction to vec3 (rgb). Check the used value too if it was modified |
| shaderSources[op] += ' ' + (this.m_isVertexCase ? 'v_color' : 'dEQP_FragColor') + ' = '; |
| |
| if (es3fShaderMatrixTest.isOperationValueModifying(this.m_op)) |
| shaderSources[op] += 'vec4(' + this.genGLSLMatToVec3Reduction(resultType, 'res') |
| + ', 1.0) + vec4(' + this.genGLSLMatToVec3Reduction(resultType, 'tmpValue') |
| + ', 0.0);\n'; |
| else |
| shaderSources[op] += 'vec4(' + this.genGLSLMatToVec3Reduction(resultType, 'res') |
| + ', 1.0);\n'; |
| |
| shaderSources[vtx] += '}\n'; |
| shaderSources[frag] += '}\n'; |
| |
| this.m_vertShaderSource = shaderSources[vtx]; |
| this.m_fragShaderSource = shaderSources[frag]; |
| |
| // \todo [2012-02-14 pyry] Compute better values for matrix tests. |
| for (var attribNdx = 0; attribNdx < 4; attribNdx++) { |
| this.m_userAttribTransforms[attribNdx] = new tcuMatrix.Matrix(4, 4, 0); |
| this.m_userAttribTransforms[attribNdx].set(0, 3, 0.2);// !< prevent matrix*vec from going into zero (assuming vec.w != 0) |
| this.m_userAttribTransforms[attribNdx].set(1, 3, 0.1);// !< |
| this.m_userAttribTransforms[attribNdx].set(2, 3, 0.4 + 0.15 * attribNdx);// !< |
| this.m_userAttribTransforms[attribNdx].set(3, 3, 0.7);// !< |
| this.m_userAttribTransforms[attribNdx].set((0 + attribNdx) % 4, 0, 1.0); |
| this.m_userAttribTransforms[attribNdx].set((1 + attribNdx) % 4, 1, 1.0); |
| this.m_userAttribTransforms[attribNdx].set((2 + attribNdx) % 4, 2, 1.0); |
| this.m_userAttribTransforms[attribNdx].set((3 + attribNdx) % 4, 3, 1.0); |
| } |
| |
| // prevent bad reference cases such as black result images by fine-tuning used matrices |
| if (es3fShaderMatrixTest.getOperationTestMatrixType(this.m_op) != es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DEFAULT) { |
| for (var attribNdx = 0; attribNdx < 4; attribNdx++) { |
| for (var row = 0; row < 4; row++) |
| for (var col = 0; col < 4; col++) { |
| switch (es3fShaderMatrixTest.getOperationTestMatrixType(this.m_op)) { |
| case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED: |
| this.m_userAttribTransforms[attribNdx].set(row, col, -this.m_userAttribTransforms[attribNdx].get(row, col)); |
| break; |
| case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED: |
| this.m_userAttribTransforms[attribNdx].set(row, col, this.m_userAttribTransforms[attribNdx].get(row, col) + 0.3); |
| break; |
| case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_DECREMENTED: |
| this.m_userAttribTransforms[attribNdx].set(row, col, this.m_userAttribTransforms[attribNdx].get(row, col) - 0.3); |
| break; |
| case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_NEGATED_INCREMENTED: |
| this.m_userAttribTransforms[attribNdx].set(row, col, -(this.m_userAttribTransforms[attribNdx].get(row, col) + 0.3)); |
| break; |
| case es3fShaderMatrixTest.MatrixType.TESTMATRIXTYPE_INCREMENTED_LESS: |
| this.m_userAttribTransforms[attribNdx].set(row, col, this.m_userAttribTransforms[attribNdx].get(row, col) - 0.1); |
| break; |
| default: |
| throw new Error('Wrong Matrix type'); |
| } |
| } |
| } |
| } |
| |
| glsShaderRenderCase.ShaderRenderCase.prototype.init.call(this); |
| }; |
| |
| |
| es3fShaderMatrixTest.ShaderMatrixCase.prototype.setupUniforms = function(programId, constCoords) { |
| for (var inNdx = 0; inNdx < 2; inNdx++) |
| { |
| var input = inNdx > 0 ? this.m_in1 : this.m_in0; |
| |
| if (input.inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM) |
| { |
| var loc = gl.getUniformLocation(programId, "u_in" + inNdx); |
| |
| if (!loc) |
| continue; |
| |
| switch (input.dataType) |
| { |
| case gluShaderUtil.DataType.FLOAT: gl.uniform1f(loc, s_constInFloat[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_VEC2: gl.uniform2fv(loc, s_constInVec2[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_VEC3: gl.uniform3fv(loc, s_constInVec3[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_VEC4: gl.uniform4fv(loc, s_constInVec4[inNdx]); break; |
| // \note GLES3 supports transpose in matrix upload. |
| case gluShaderUtil.DataType.FLOAT_MAT2: gl.uniformMatrix2fv (loc, true, s_constInMat2x2[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT2X3: gl.uniformMatrix2x3fv(loc, true, s_constInMat2x3[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT2X4: gl.uniformMatrix2x4fv(loc, true, s_constInMat2x4[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT3X2: gl.uniformMatrix3x2fv(loc, true, s_constInMat3x2[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT3: gl.uniformMatrix3fv (loc, true, s_constInMat3x3[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT3X4: gl.uniformMatrix3x4fv(loc, true, s_constInMat3x4[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT4X2: gl.uniformMatrix4x2fv(loc, true, s_constInMat4x2[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT4X3: gl.uniformMatrix4x3fv(loc, true, s_constInMat4x3[inNdx]); break; |
| case gluShaderUtil.DataType.FLOAT_MAT4: gl.uniformMatrix4fv (loc, true, s_constInMat4x4[inNdx]); break; |
| default: |
| throw new Error('Invalid datatype' + input.dataType); |
| } |
| } |
| } |
| }; |
| |
| |
| |
| /** |
| * @param {gluShaderUtil.DataType} matType |
| * @param {string} varName |
| * @return {string} |
| */ |
| es3fShaderMatrixTest.ShaderMatrixCase.prototype.genGLSLMatToVec3Reduction = function (matType, varName) { |
| /** @type {string} */ var op = ''; |
| |
| switch (matType) { |
| case gluShaderUtil.DataType.FLOAT: |
| op += varName + ', ' |
| + varName + ', ' |
| + varName + ''; |
| break; |
| case gluShaderUtil.DataType.FLOAT_VEC2: |
| op += varName + '.x, ' |
| + varName + '.y, ' |
| + varName + '.x'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_VEC3: |
| op += varName + ''; |
| break; |
| case gluShaderUtil.DataType.FLOAT_VEC4: |
| op += varName + '.x, ' |
| + varName + '.y, ' |
| + varName + '.z+' |
| + varName + '.w'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT2: |
| op += varName + '[0][0], ' |
| + varName + '[1][0], ' |
| + varName + '[0][1]+' |
| + varName + '[1][1]'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT2X3: |
| op += varName + '[0] + ' |
| + varName + '[1]'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT2X4: |
| op += varName + '[0].xyz + ' |
| + varName + '[1].yzw'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT3X2: |
| op += varName + '[0][0]+' |
| + varName + '[0][1], ' |
| + varName + '[1][0]+' |
| + varName + '[1][1], ' |
| + varName + '[2][0]+' |
| + varName + '[2][1]'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT3: |
| op += varName + '[0] + ' |
| + varName + '[1] + ' |
| + varName + '[2]'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT3X4: |
| op += varName + '[0].xyz + ' |
| + varName + '[1].yzw + ' |
| + varName + '[2].zwx'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT4X2: |
| op += varName + '[0][0]+' |
| + varName + '[0][1]+' |
| + varName + '[3][0], ' |
| + varName + '[1][0]+' |
| + varName + '[1][1]+' |
| + varName + '[3][1], ' |
| + varName + '[2][0]+' |
| + varName + '[2][1]'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT4X3: |
| op += varName + '[0] + ' |
| + varName + '[1] + ' |
| + varName + '[2] + ' |
| + varName + '[3]'; |
| break; |
| case gluShaderUtil.DataType.FLOAT_MAT4: |
| op += varName + '[0].xyz+' |
| + varName + '[1].yzw+' |
| + varName + '[2].zwx+' |
| + varName + '[3].wxy'; |
| break; |
| |
| default: |
| throw new Error('Wrong data type'); |
| } |
| |
| return op; |
| } |
| |
| /** |
| * @constructor |
| * @param {string} name |
| * @param {string} desc |
| * @param {es3fShaderMatrixTest.MatrixOp} op |
| * @param {boolean} extendedInputTypeCases |
| * @param {boolean} createInputTypeGroup |
| */ |
| es3fShaderMatrixTest.ops = function (name, desc, op, extendedInputTypeCases, createInputTypeGroup) { |
| this.name = name; |
| this.desc = desc; |
| this.op = op; |
| this.extendedInputTypeCases = extendedInputTypeCases; |
| this.createInputTypeGroup = createInputTypeGroup; |
| }; |
| |
| /** |
| * @constructor |
| * @param {string} name |
| * @param {string} desc |
| * @param {es3fShaderMatrixTest.InputType} type |
| */ |
| es3fShaderMatrixTest.InputTypeSpec = function (name, desc, type) { |
| this.name = name; |
| this.desc = desc; |
| this.type = type; |
| }; |
| |
| es3fShaderMatrixTest.init = function () { |
| var state = tcuTestCase.runner; |
| |
| var ops = [ |
| new es3fShaderMatrixTest.ops('add', 'Matrix addition tests', es3fShaderMatrixTest.MatrixOp.OP_ADD, true, true), |
| new es3fShaderMatrixTest.ops('sub', 'Matrix subtraction tests', es3fShaderMatrixTest.MatrixOp.OP_SUB, true, true), |
| new es3fShaderMatrixTest.ops('mul', 'Matrix multiplication tests', es3fShaderMatrixTest.MatrixOp.OP_MUL, true, true), |
| new es3fShaderMatrixTest.ops('div', 'Matrix division tests', es3fShaderMatrixTest.MatrixOp.OP_DIV, true, true), |
| new es3fShaderMatrixTest.ops('matrixcompmult', 'Matrix component-wise multiplication tests', es3fShaderMatrixTest.MatrixOp.OP_COMP_MUL, false, true), |
| new es3fShaderMatrixTest.ops('outerproduct', 'Matrix outerProduct() tests', es3fShaderMatrixTest.MatrixOp.OP_OUTER_PRODUCT, false, true), |
| new es3fShaderMatrixTest.ops('transpose', 'Matrix transpose() tests', es3fShaderMatrixTest.MatrixOp.OP_TRANSPOSE, false, true), |
| new es3fShaderMatrixTest.ops('determinant', 'Matrix determinant() tests', es3fShaderMatrixTest.MatrixOp.OP_DETERMINANT, false, true), |
| new es3fShaderMatrixTest.ops('inverse', 'Matrix inverse() tests', es3fShaderMatrixTest.MatrixOp.OP_INVERSE, false, true), |
| new es3fShaderMatrixTest.ops('unary_addition', 'Matrix unary addition tests', es3fShaderMatrixTest.MatrixOp.OP_UNARY_PLUS, false, false), |
| new es3fShaderMatrixTest.ops('negation', 'Matrix negation tests', es3fShaderMatrixTest.MatrixOp.OP_NEGATION, false, false), |
| new es3fShaderMatrixTest.ops('pre_increment', 'Matrix prefix increment tests', es3fShaderMatrixTest.MatrixOp.OP_PRE_INCREMENT, false, false), |
| new es3fShaderMatrixTest.ops('pre_decrement', 'Matrix prefix decrement tests', es3fShaderMatrixTest.MatrixOp.OP_PRE_DECREMENT, false, false), |
| new es3fShaderMatrixTest.ops('post_increment', 'Matrix postfix increment tests', es3fShaderMatrixTest.MatrixOp.OP_POST_INCREMENT, false, false), |
| new es3fShaderMatrixTest.ops('post_decrement', 'Matrix postfix decrement tests', es3fShaderMatrixTest.MatrixOp.OP_POST_DECREMENT, false, false), |
| new es3fShaderMatrixTest.ops('add_assign', 'Matrix add into tests', es3fShaderMatrixTest.MatrixOp.OP_ADD_INTO, false, false), |
| new es3fShaderMatrixTest.ops('sub_assign', 'Matrix subtract from tests', es3fShaderMatrixTest.MatrixOp.OP_SUBTRACT_FROM,false, false), |
| new es3fShaderMatrixTest.ops('mul_assign', 'Matrix multiply into tests', es3fShaderMatrixTest.MatrixOp.OP_MULTIPLY_INTO,false, false), |
| new es3fShaderMatrixTest.ops('div_assign', 'Matrix divide into tests', es3fShaderMatrixTest.MatrixOp.OP_DIVIDE_INTO,false, false) |
| ]; |
| |
| var extendedInputTypes = [ |
| new es3fShaderMatrixTest.InputTypeSpec('const', 'Constant matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_CONST), |
| new es3fShaderMatrixTest.InputTypeSpec('uniform', 'Uniform matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM), |
| new es3fShaderMatrixTest.InputTypeSpec('dynamic', 'Dynamic matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) |
| ]; |
| |
| var reducedInputTypes = [ |
| new es3fShaderMatrixTest.InputTypeSpec('dynamic', 'Dynamic matrix input', es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) |
| ]; |
| |
| /** @type {Array<gluShaderUtil.DataType>} */ var matrixTypes = [ |
| gluShaderUtil.DataType.FLOAT_MAT2, |
| gluShaderUtil.DataType.FLOAT_MAT2X3, |
| gluShaderUtil.DataType.FLOAT_MAT2X4, |
| gluShaderUtil.DataType.FLOAT_MAT3X2, |
| gluShaderUtil.DataType.FLOAT_MAT3, |
| gluShaderUtil.DataType.FLOAT_MAT3X4, |
| gluShaderUtil.DataType.FLOAT_MAT4X2, |
| gluShaderUtil.DataType.FLOAT_MAT4X3, |
| gluShaderUtil.DataType.FLOAT_MAT4 |
| ]; |
| |
| /** @type {Array<gluShaderUtil.precision>} */ var precisions = [ |
| gluShaderUtil.precision.PRECISION_LOWP, |
| gluShaderUtil.precision.PRECISION_MEDIUMP, |
| gluShaderUtil.precision.PRECISION_HIGHP |
| ]; |
| |
| for (var opNdx = 0; opNdx < ops.length; opNdx++) { |
| var inTypeList = ops[opNdx].extendedInputTypeCases ? extendedInputTypes : reducedInputTypes; |
| var inTypeListSize = ops[opNdx].extendedInputTypeCases ? extendedInputTypes.length : reducedInputTypes.length; |
| var op = ops[opNdx].op; |
| |
| for (var inTypeNdx = 0; inTypeNdx < inTypeListSize; inTypeNdx++) { |
| var inputType = inTypeList[inTypeNdx].type; |
| var group = []; |
| |
| if (ops[opNdx].name != 'mul') { |
| if (ops[opNdx].createInputTypeGroup) { |
| group[0] = tcuTestCase.newTest(ops[opNdx].name + '.' + inTypeList[inTypeNdx].name, inTypeList[inTypeNdx].desc); |
| } else { |
| group[0] = tcuTestCase.newTest(ops[opNdx].name, ops[opNdx].desc); |
| } |
| state.testCases.addChild(group[0]); |
| } else { |
| for (var ii = 0; ii < precisions.length; ++ii) { |
| group[ii] = tcuTestCase.newTest(ops[opNdx].name + '.' + inTypeList[inTypeNdx].name, inTypeList[inTypeNdx].desc); |
| state.testCases.addChild(group[ii]); |
| } |
| } |
| |
| for (var matTypeNdx = 0; matTypeNdx < matrixTypes.length; matTypeNdx++) { |
| var matType = matrixTypes[matTypeNdx]; |
| var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(matType); |
| var numRows = gluShaderUtil.getDataTypeMatrixNumRows(matType); |
| var matTypeName = gluShaderUtil.getDataTypeName(matType); |
| |
| for (var precNdx = 0; precNdx < precisions.length; precNdx++) { |
| var inGroup; |
| if (ops[opNdx].name != 'mul') { |
| inGroup = group[0]; |
| } else { |
| inGroup = group[precNdx]; |
| } |
| |
| var precision = precisions[precNdx]; |
| var precName = gluShaderUtil.getPrecisionName(precision); |
| var baseName = precName + '_' + matTypeName + '_'; |
| var matIn = new es3fShaderMatrixTest.ShaderInput(inputType, matType, precision); |
| |
| if (es3fShaderMatrixTest.isOperationMatrixScalar(op)) { |
| // Matrix-scalar \note For div cases we use uniform input. |
| var scalarIn = new es3fShaderMatrixTest.ShaderInput(op == es3fShaderMatrixTest.MatrixOp.OP_DIV ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC, gluShaderUtil.DataType.FLOAT, precision); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Matrix-scalar case', matIn, scalarIn, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Matrix-scalar case', matIn, scalarIn, op, false)); |
| } |
| |
| if (es3fShaderMatrixTest.isOperationMatrixVector(op)) { |
| // Matrix-vector. |
| var colVecType = gluShaderUtil.getDataTypeFloatVec(numCols); |
| var colVecIn = new es3fShaderMatrixTest.ShaderInput(op == es3fShaderMatrixTest.MatrixOp.OP_DIV ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC, colVecType, precision); |
| |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(colVecType) + '_vertex', 'Matrix-vector case', matIn, colVecIn, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(colVecType) + '_fragment', 'Matrix-vector case', matIn, colVecIn, op, false)); |
| |
| // Vector-matrix. |
| var rowVecType = gluShaderUtil.getDataTypeFloatVec(numRows); |
| var rowVecIn = new es3fShaderMatrixTest.ShaderInput(op == es3fShaderMatrixTest.MatrixOp.OP_DIV ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC, rowVecType, precision); |
| var vecMatName = precName + '_' + gluShaderUtil.getDataTypeName(rowVecType) + '_' + matTypeName; |
| |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(vecMatName + '_vertex', 'Vector-matrix case', rowVecIn, matIn, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(vecMatName + '_fragment', 'Vector-matrix case', rowVecIn, matIn, op, false)); |
| } |
| |
| if (es3fShaderMatrixTest.isOperationArithmeticMatrixMatrix(op)) { |
| // Arithmetic matrix-matrix multiplication. |
| for (var otherCols = 2; otherCols <= 4; otherCols++) { |
| var otherMatIn = new es3fShaderMatrixTest.ShaderInput(inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, gluShaderUtil.getDataTypeMatrix(otherCols, numCols), precision); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(otherMatIn.dataType) + '_vertex', 'Matrix-matrix case', matIn, otherMatIn, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + gluShaderUtil.getDataTypeName(otherMatIn.dataType) + '_fragment', 'Matrix-matrix case', matIn, otherMatIn, op, false)); |
| } |
| } else if (es3fShaderMatrixTest.isOperationComponentwiseMatrixMatrix(op)) { |
| // Component-wise. |
| var otherMatIn = new es3fShaderMatrixTest.ShaderInput(inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, matType, precision); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + matTypeName + '_vertex', 'Matrix-matrix case', matIn, otherMatIn, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + matTypeName + '_fragment', 'Matrix-matrix case', matIn, otherMatIn, op, false)); |
| } |
| |
| if (es3fShaderMatrixTest.isOperationVectorVector(op)) { |
| var vec1In = new es3fShaderMatrixTest.ShaderInput(inputType, gluShaderUtil.getDataTypeFloatVec(numRows), precision); |
| var vec2In = new es3fShaderMatrixTest.ShaderInput((inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC) ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, gluShaderUtil.getDataTypeFloatVec(numCols), precision); |
| |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Vector-vector case', vec1In, vec2In, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Vector-vector case', vec1In, vec2In, op, false)); |
| } |
| |
| if (es3fShaderMatrixTest.isOperationUnaryAnyMatrix(op) || (es3fShaderMatrixTest.isOperationUnarySymmetricMatrix(op) && numCols == numRows)) { |
| var voidInput = new es3fShaderMatrixTest.ShaderInput(); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Matrix case', matIn, voidInput, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Matrix case', matIn, voidInput, op, false)); |
| } |
| |
| if (es3fShaderMatrixTest.isOperationAssignmentAnyMatrix(op) || (es3fShaderMatrixTest.isOperationAssignmentSymmetricMatrix(op) && numCols == numRows)) { |
| var otherMatIn = new es3fShaderMatrixTest.ShaderInput(inputType == es3fShaderMatrixTest.InputType.INPUTTYPE_DYNAMIC ? es3fShaderMatrixTest.InputType.INPUTTYPE_UNIFORM : inputType, matType, precision); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_vertex', 'Matrix assignment case', matIn, otherMatIn, op, true)); |
| inGroup.addChild(new es3fShaderMatrixTest.ShaderMatrixCase(baseName + 'float_fragment', 'Matrix assignment case', matIn, otherMatIn, op, false)); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| es3fShaderMatrixTest.run = function(context, range) { |
| gl = context; |
| //Set up Test Root parameters |
| var testName = 'shader_matrix'; |
| var testDescription = 'Shader Matrix Test'; |
| var state = tcuTestCase.runner; |
| |
| state.testName = testName; |
| state.testCases = tcuTestCase.newTest(testName, testDescription, null); |
| |
| //Set up name and description of this test series. |
| setCurrentTestName(testName); |
| description(testDescription); |
| |
| try { |
| //Create test cases |
| es3fShaderMatrixTest.init(); |
| if (range) |
| state.setRange(range); |
| //Run test cases |
| tcuTestCase.runTestCases(); |
| } |
| catch (err) { |
| bufferedLogToConsole(err); |
| tcuTestCase.runner.terminate(); |
| } |
| }; |
| }); |