Add constant folding support for matrix built-ins

src/common/matrix_utils_unittest.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// matrix_utils_unittests:
+//   Unit tests for the matrix utils.
+//
+
+#include "matrix_utils.h"
+
+#include <gtest/gtest.h>
+
+using namespace angle;
+
+namespace
+{
+
+const unsigned int minDimensions = 2;
+const unsigned int maxDimensions = 4;
+
+TEST(MatrixUtilsTest, MatrixConstructorTest)
+{
+    for (size_t i = minDimensions; i <= maxDimensions; i++)
+    {
+        for (size_t j = minDimensions; j <= maxDimensions; j++)
+        {
+            unsigned int numElements = i * j;
+            Matrix<float> m(std::vector<float>(numElements, 1.0f), i, j);
+            EXPECT_EQ(m.rows(), i);
+            EXPECT_EQ(m.columns(), j);
+            EXPECT_EQ(m.elements(), std::vector<float>(numElements, 1.0f));
+        }
+    }
+
+    for (size_t i = minDimensions; i <= maxDimensions; i++)
+    {
+        unsigned int numElements = i * i;
+        Matrix<float> m(std::vector<float>(numElements, 1.0f), i);
+        EXPECT_EQ(m.size(), i);
+        EXPECT_EQ(m.columns(), m.columns());
+        EXPECT_EQ(m.elements(), std::vector<float>(numElements, 1.0f));
+    }
+}
+
+TEST(MatrixUtilsTest, MatrixCompMultTest)
+{
+    for (size_t i = minDimensions; i <= maxDimensions; i++)
+    {
+        unsigned int numElements = i * i;
+        Matrix<float> m1(std::vector<float>(numElements, 2.0f), i);
+        Matrix<float> actualResult = m1.compMult(m1);
+        std::vector<float> actualResultElements = actualResult.elements();
+        std::vector<float> expectedResultElements(numElements, 4.0f);
+        EXPECT_EQ(expectedResultElements, actualResultElements);
+    }
+}
+
+TEST(MatrixUtilsTest, MatrixOuterProductTest)
+{
+    for (size_t i = minDimensions; i <= maxDimensions; i++)
+    {
+        for (size_t j = minDimensions; j <= maxDimensions; j++)
+        {
+            unsigned int numElements = i * j;
+            Matrix<float> m1(std::vector<float>(numElements, 2.0f), i, 1);
+            Matrix<float> m2(std::vector<float>(numElements, 2.0f), 1, j);
+            Matrix<float> actualResult = m1.outerProduct(m2);
+            EXPECT_EQ(actualResult.rows(), i);
+            EXPECT_EQ(actualResult.columns(), j);
+            std::vector<float> actualResultElements = actualResult.elements();
+            std::vector<float> expectedResultElements(numElements, 4.0f);
+            EXPECT_EQ(expectedResultElements, actualResultElements);
+        }
+    }
+}
+
+TEST(MatrixUtilsTest, MatrixTransposeTest)
+{
+    for (size_t i = minDimensions; i <= maxDimensions; i++)
+    {
+        for (size_t j = minDimensions; j <= maxDimensions; j++)
+        {
+            unsigned int numElements = i * j;
+            Matrix<float> m1(std::vector<float>(numElements, 2.0f), i, j);
+            Matrix<float> expectedResult = Matrix<float>(std::vector<float>(numElements, 2.0f), j, i);
+            Matrix<float> actualResult = m1.transpose();
+            EXPECT_EQ(expectedResult.elements(), actualResult.elements());
+            EXPECT_EQ(actualResult.rows(), expectedResult.rows());
+            EXPECT_EQ(actualResult.columns(), expectedResult.columns());
+            // transpose(transpose(A)) = A
+            Matrix<float> m2 = actualResult.transpose();
+            EXPECT_EQ(m1.elements(), m2.elements());
+        }
+    }
+}
+
+TEST(MatrixUtilsTest, MatrixDeterminantTest)
+{
+    for (size_t i = minDimensions; i <= maxDimensions; i++)
+    {
+        unsigned int numElements = i * i;
+        Matrix<float> m(std::vector<float>(numElements, 2.0f), i);
+        EXPECT_EQ(m.determinant(), 0.0f);
+    }
+}
+
+TEST(MatrixUtilsTest, 2x2MatrixInverseTest)
+{
+    float inputElements[] =
+    {
+        2.0f, 5.0f,
+        3.0f, 7.0f
+    };
+    unsigned int numElements = 4;
+    std::vector<float> input(inputElements, inputElements + numElements);
+    Matrix<float> inputMatrix(input, 2);
+    float identityElements[] =
+    {
+        1.0f, 0.0f,
+        0.0f, 1.0f
+    };
+    std::vector<float> identityMatrix(identityElements, identityElements + numElements);
+    // A * inverse(A) = I, where I is identity matrix.
+    Matrix<float> result = inputMatrix * inputMatrix.inverse();
+    EXPECT_EQ(identityMatrix, result.elements());
+}
+
+TEST(MatrixUtilsTest, 3x3MatrixInverseTest)
+{
+    float inputElements[] =
+    {
+        11.0f, 23.0f, 37.0f,
+        13.0f, 29.0f, 41.0f,
+        19.0f, 31.0f, 43.0f
+    };
+    unsigned int numElements = 9;
+    std::vector<float> input(inputElements, inputElements + numElements);
+    Matrix<float> inputMatrix(input, 3);
+    float identityElements[] =
+    {
+        1.0f, 0.0f, 0.0f,
+        0.0f, 1.0f, 0.0f,
+        0.0f, 0.0f, 1.0f
+    };
+    std::vector<float> identityMatrix(identityElements, identityElements + numElements);
+    // A * inverse(A) = I, where I is identity matrix.
+    Matrix<float> result = inputMatrix * inputMatrix.inverse();
+    std::vector<float> resultElements = result.elements();
+    const float floatFaultTolarance = 0.000001f;
+    for (size_t i = 0; i < numElements; i++)
+        EXPECT_NEAR(resultElements[i], identityMatrix[i], floatFaultTolarance);
+}
+
+TEST(MatrixUtilsTest, 4x4MatrixInverseTest)
+{
+    float inputElements[] =
+    {
+        29.0f, 43.0f, 61.0f, 79.0f,
+        31.0f, 47.0f, 67.0f, 83.0f,
+        37.0f, 53.0f, 71.0f, 89.0f,
+        41.0f, 59.0f, 73.0f, 97.0f
+    };
+    unsigned int numElements = 16;
+    std::vector<float> input(inputElements, inputElements + numElements);
+    Matrix<float> inputMatrix(input, 4);
+    float identityElements[] =
+    {
+        1.0f, 0.0f, 0.0f, 0.0f,
+        0.0f, 1.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 1.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 1.0f,
+    };
+    std::vector<float> identityMatrix(identityElements, identityElements + numElements);
+    // A * inverse(A) = I, where I is identity matrix.
+    Matrix<float> result = inputMatrix * inputMatrix.inverse();
+    std::vector<float> resultElements = result.elements();
+    const float floatFaultTolarance = 0.00001f;
+    for (size_t i = 0; i < numElements; i++)
+        EXPECT_NEAR(resultElements[i], identityMatrix[i], floatFaultTolarance);
+}
+
+}
+

src/compiler/translator/IntermNode.cpp

@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "common/mathutil.h"
+#include "common/matrix_utils.h"
 #include "compiler/translator/HashNames.h"
 #include "compiler/translator/IntermNode.h"
 #include "compiler/translator/SymbolTable.h"
@@ -199,6 +200,36 @@ TIntermTyped *CreateFoldedNode(TConstantUnion *constArray, const TIntermTyped *o
     return folded;
 }
 
+angle::Matrix<float> GetMatrix(TConstantUnion *paramArray, const unsigned int &rows, const unsigned int &cols)
+{
+    std::vector<float> elements;
+    for (size_t i = 0; i < rows * cols; i++)
+        elements.push_back(paramArray[i].getFConst());
+    // Transpose is used since the Matrix constructor expects arguments in row-major order,
+    // whereas the paramArray is in column-major order.
+    return angle::Matrix<float>(elements, rows, cols).transpose();
+}
+
+angle::Matrix<float> GetMatrix(TConstantUnion *paramArray, const unsigned int &size)
+{
+    std::vector<float> elements;
+    for (size_t i = 0; i < size * size; i++)
+        elements.push_back(paramArray[i].getFConst());
+    // Transpose is used since the Matrix constructor expects arguments in row-major order,
+    // whereas the paramArray is in column-major order.
+    return angle::Matrix<float>(elements, size).transpose();
+}
+
+void SetUnionArrayFromMatrix(const angle::Matrix<float> &m, TConstantUnion *resultArray)
+{
+    // Transpose is used since the input Matrix is in row-major order,
+    // whereas the actual result should be in column-major order.
+    angle::Matrix<float> result = m.transpose();
+    std::vector<float> resultElements = result.elements();
+    for (size_t i = 0; i < resultElements.size(); i++)
+        resultArray[i].setFConst(resultElements[i]);
+}
+
 }  // namespace anonymous
 
 
@@ -1156,7 +1187,8 @@ TConstantUnion *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSin
 
     size_t objectSize = getType().getObjectSize();
 
-    if (op == EOpAny || op == EOpAll || op == EOpLength)
+    if (op == EOpAny || op == EOpAll || op == EOpLength || op == EOpTranspose || op == EOpDeterminant ||
+        op == EOpInverse)
     {
         // Do operations where the return type has a different number of components compared to the operand type.
         TConstantUnion *resultArray = nullptr;
@@ -1218,6 +1250,52 @@ TConstantUnion *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSin
                 return nullptr;
             }
 
+          case EOpTranspose:
+            if (getType().getBasicType() == EbtFloat)
+            {
+                resultArray = new TConstantUnion[objectSize];
+                angle::Matrix<float> result =
+                    GetMatrix(operandArray, getType().getNominalSize(), getType().getSecondarySize()).transpose();
+                SetUnionArrayFromMatrix(result, resultArray);
+                break;
+            }
+            else
+            {
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
+                return nullptr;
+            }
+
+          case EOpDeterminant:
+            if (getType().getBasicType() == EbtFloat)
+            {
+                unsigned int size = getType().getNominalSize();
+                ASSERT(size >= 2 && size <= 4);
+                resultArray = new TConstantUnion();
+                resultArray->setFConst(GetMatrix(operandArray, size).determinant());
+                break;
+            }
+            else
+            {
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
+                return nullptr;
+            }
+
+          case EOpInverse:
+            if (getType().getBasicType() == EbtFloat)
+            {
+                unsigned int size = getType().getNominalSize();
+                ASSERT(size >= 2 && size <= 4);
+                resultArray = new TConstantUnion[objectSize];
+                angle::Matrix<float> result = GetMatrix(operandArray, size).inverse();
+                SetUnionArrayFromMatrix(result, resultArray);
+                break;
+            }
+            else
+            {
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
+                return nullptr;
+            }
+
           default:
             break;
         }
@@ -1630,9 +1708,12 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
             maxObjectSize = objectSizes[i];
     }
 
-    for (unsigned int i = 0; i < paramsCount; i++)
-        if (objectSizes[i] != maxObjectSize)
-            unionArrays[i] = Vectorize(*unionArrays[i], maxObjectSize);
+    if (!(*sequence)[0]->getAsTyped()->isMatrix())
+    {
+        for (unsigned int i = 0; i < paramsCount; i++)
+            if (objectSizes[i] != maxObjectSize)
+                unionArrays[i] = Vectorize(*unionArrays[i], maxObjectSize);
+    }
 
     TConstantUnion *resultArray = nullptr;
     if (paramsCount == 2)
@@ -1980,6 +2061,35 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
                 UNREACHABLE();
             break;
 
+          case EOpMul:
+            if (basicType == EbtFloat && (*sequence)[0]->getAsTyped()->isMatrix() &&
+                (*sequence)[1]->getAsTyped()->isMatrix())
+            {
+                // Perform component-wise matrix multiplication.
+                resultArray = new TConstantUnion[maxObjectSize];
+                size_t size = (*sequence)[0]->getAsTyped()->getNominalSize();
+                angle::Matrix<float> result =
+                    GetMatrix(unionArrays[0], size).compMult(GetMatrix(unionArrays[1], size));
+                SetUnionArrayFromMatrix(result, resultArray);
+            }
+            else
+                UNREACHABLE();
+            break;
+
+          case EOpOuterProduct:
+            if (basicType == EbtFloat)
+            {
+                size_t numRows = (*sequence)[0]->getAsTyped()->getType().getObjectSize();
+                size_t numCols = (*sequence)[1]->getAsTyped()->getType().getObjectSize();
+                resultArray = new TConstantUnion[numRows * numCols];
+                angle::Matrix<float> result =
+                    GetMatrix(unionArrays[0], 1, numCols).outerProduct(GetMatrix(unionArrays[1], numRows, 1));
+                SetUnionArrayFromMatrix(result, resultArray);
+            }
+            else
+                UNREACHABLE();
+            break;
+
           default:
             UNREACHABLE();
             // TODO: Add constant folding support for other built-in operations that take 2 parameters and not handled above.

src/compiler/translator/Intermediate.cpp

@@ -454,6 +454,8 @@ TIntermTyped *TIntermediate::foldAggregateBuiltIn(TIntermAggregate *aggregate)
       case EOpMix:
       case EOpStep:
       case EOpSmoothStep:
+      case EOpMul:
+      case EOpOuterProduct:
       case EOpLessThan:
       case EOpLessThanEqual:
       case EOpGreaterThan:

src/libGLESv2.gypi

@@ -17,6 +17,7 @@
             'common/debug.h',
             'common/mathutil.cpp',
             'common/mathutil.h',
+            'common/matrix_utils.h',
             'common/platform.h',
             'common/string_utils.cpp',
             'common/string_utils.h',

src/tests/angle_unittests.gypi

@@ -16,6 +16,7 @@
         'angle_unittests_sources':
         [
             '<(angle_path)/src/common/Optional_unittest.cpp',
+            '<(angle_path)/src/common/matrix_utils_unittest.cpp',
             '<(angle_path)/src/common/string_utils_unittest.cpp',
             '<(angle_path)/src/common/utilities_unittest.cpp',
             '<(angle_path)/src/libANGLE/Config_unittest.cpp',