Revert "Revert "Add constant folding support for geometric built-ins""

src/compiler/translator/IntermNode.cpp

@@ -168,6 +168,25 @@ void UndefinedConstantFoldingError(const TSourceLoc &loc, TOperator op, TBasicTy
     }
 }
 
+float VectorLength(TConstantUnion *paramArray, size_t paramArraySize)
+{
+    float result = 0.0f;
+    for (size_t i = 0; i < paramArraySize; i++)
+    {
+        float f = paramArray[i].getFConst();
+        result += f * f;
+    }
+    return sqrtf(result);
+}
+
+float VectorDotProduct(TConstantUnion *paramArray1, TConstantUnion *paramArray2, size_t paramArraySize)
+{
+    float result = 0.0f;
+    for (size_t i = 0; i < paramArraySize; i++)
+        result += paramArray1[i].getFConst() * paramArray2[i].getFConst();
+    return result;
+}
+
 }  // namespace anonymous
 
 
@@ -1179,14 +1198,15 @@ TIntermTyped *TIntermConstantUnion::fold(
 
         return tempNode;
     }
-    else if (op == EOpAny || op == EOpAll)
+    else if (op == EOpAny || op == EOpAll || op == EOpLength)
     {
         // Do operations where the return type is different from the operand type.
 
-        TType returnType(EbtBool, EbpUndefined, EvqConst);
+        TType returnType;
         TConstantUnion *tempConstArray = nullptr;
-        if (op == EOpAny)
+        switch (op)
         {
+          case EOpAny:
             if (getType().getBasicType() == EbtBool)
             {
                 tempConstArray = new TConstantUnion();
@@ -1199,17 +1219,16 @@ TIntermTyped *TIntermConstantUnion::fold(
                         break;
                     }
                 }
+                returnType = TType(EbtBool, EbpUndefined, EvqConst);
+                break;
             }
             else
             {
-                infoSink.info.message(
-                    EPrefixInternalError, getLine(),
-                    "Unary operation not folded into constant");
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
                 return nullptr;
             }
-        }
-        else if (op == EOpAll)
-        {
+
+          case EOpAll:
             if (getType().getBasicType() == EbtBool)
             {
                 tempConstArray = new TConstantUnion();
@@ -1222,15 +1241,33 @@ TIntermTyped *TIntermConstantUnion::fold(
                         break;
                     }
                 }
+                returnType = TType(EbtBool, EbpUndefined, EvqConst);
+                break;
             }
             else
             {
-                infoSink.info.message(
-                    EPrefixInternalError, getLine(),
-                    "Unary operation not folded into constant");
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
                 return nullptr;
             }
+
+          case EOpLength:
+            if (getType().getBasicType() == EbtFloat)
+            {
+                tempConstArray = new TConstantUnion();
+                tempConstArray->setFConst(VectorLength(unionArray, objectSize));
+                returnType = TType(EbtFloat, getType().getPrecision(), EvqConst);
+                break;
+            }
+            else
+            {
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
+                return nullptr;
+            }
+
+          default:
+            break;
         }
+
         TIntermConstantUnion *tempNode = new TIntermConstantUnion(tempConstArray, returnType);
         tempNode->setLine(getLine());
         return tempNode;
@@ -1575,6 +1612,20 @@ TIntermTyped *TIntermConstantUnion::fold(
                     "Unary operation not folded into constant");
                 return nullptr;
 
+              case EOpNormalize:
+                if (getType().getBasicType() == EbtFloat)
+                {
+                    float x = unionArray[i].getFConst();
+                    float length = VectorLength(unionArray, objectSize);
+                    if (length)
+                        tempConstArray[i].setFConst(x / length);
+                    else
+                        UndefinedConstantFoldingError(getLine(), op, getType().getBasicType(), infoSink, &tempConstArray[i]);
+                    break;
+                }
+                infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
+                return nullptr;
+
               default:
                 return nullptr;
             }
@@ -1918,6 +1969,70 @@ TIntermTyped *TIntermConstantUnion::FoldAggregateBuiltIn(TOperator op, TIntermAg
             }
             break;
 
+          case EOpDistance:
+            if (basicType == EbtFloat)
+            {
+                TConstantUnion *distanceArray = new TConstantUnion[maxObjectSize];
+                tempConstArray = new TConstantUnion();
+                for (size_t i = 0; i < maxObjectSize; i++)
+                {
+                    float x = unionArrays[0][i].getFConst();
+                    float y = unionArrays[1][i].getFConst();
+                    distanceArray[i].setFConst(x - y);
+                }
+                tempConstArray->setFConst(VectorLength(distanceArray, maxObjectSize));
+            }
+            else
+                UNREACHABLE();
+            break;
+
+          case EOpDot:
+            if (basicType == EbtFloat)
+            {
+                tempConstArray = new TConstantUnion();
+                tempConstArray->setFConst(VectorDotProduct(unionArrays[0], unionArrays[1], maxObjectSize));
+            }
+            else
+                UNREACHABLE();
+            break;
+
+          case EOpCross:
+            if (basicType == EbtFloat && maxObjectSize == 3)
+            {
+                tempConstArray = new TConstantUnion[maxObjectSize];
+                float x0 = unionArrays[0][0].getFConst();
+                float x1 = unionArrays[0][1].getFConst();
+                float x2 = unionArrays[0][2].getFConst();
+                float y0 = unionArrays[1][0].getFConst();
+                float y1 = unionArrays[1][1].getFConst();
+                float y2 = unionArrays[1][2].getFConst();
+                tempConstArray[0].setFConst(x1 * y2 - y1 * x2);
+                tempConstArray[1].setFConst(x2 * y0 - y2 * x0);
+                tempConstArray[2].setFConst(x0 * y1 - y0 * x1);
+            }
+            else
+                UNREACHABLE();
+            break;
+
+          case EOpReflect:
+            if (basicType == EbtFloat)
+            {
+                // genType reflect (genType I, genType N) :
+                //     For the incident vector I and surface orientation N, returns the reflection direction:
+                //     I - 2 * dot(N, I) * N.
+                tempConstArray = new TConstantUnion[maxObjectSize];
+                float dotProduct = VectorDotProduct(unionArrays[1], unionArrays[0], maxObjectSize);
+                for (size_t i = 0; i < maxObjectSize; i++)
+                {
+                    float result = unionArrays[0][i].getFConst() -
+                                   2.0f * dotProduct * unionArrays[1][i].getFConst();
+                    tempConstArray[i].setFConst(result);
+                }
+            }
+            else
+                UNREACHABLE();
+            break;
+
           default:
             UNREACHABLE();
             // TODO: Add constant folding support for other built-in operations that take 2 parameters and not handled above.
@@ -2043,6 +2158,53 @@ TIntermTyped *TIntermConstantUnion::FoldAggregateBuiltIn(TOperator op, TIntermAg
             }
             break;
 
+          case EOpFaceForward:
+            if (basicType == EbtFloat)
+            {
+                // genType faceforward(genType N, genType I, genType Nref) :
+                //     If dot(Nref, I) < 0 return N, otherwise return -N.
+                tempConstArray = new TConstantUnion[maxObjectSize];
+                float dotProduct = VectorDotProduct(unionArrays[2], unionArrays[1], maxObjectSize);
+                for (size_t i = 0; i < maxObjectSize; i++)
+                {
+                    if (dotProduct < 0)
+                        tempConstArray[i].setFConst(unionArrays[0][i].getFConst());
+                    else
+                        tempConstArray[i].setFConst(-unionArrays[0][i].getFConst());
+                }
+            }
+            else
+                UNREACHABLE();
+            break;
+
+          case EOpRefract:
+            if (basicType == EbtFloat)
+            {
+                // genType refract(genType I, genType N, float eta) :
+                //     For the incident vector I and surface normal N, and the ratio of indices of refraction eta,
+                //     return the refraction vector. The result is computed by
+                //         k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I))
+                //         if (k < 0.0)
+                //             return genType(0.0)
+                //         else
+                //             return eta * I - (eta * dot(N, I) + sqrt(k)) * N
+                tempConstArray = new TConstantUnion[maxObjectSize];
+                float dotProduct = VectorDotProduct(unionArrays[1], unionArrays[0], maxObjectSize);
+                for (size_t i = 0; i < maxObjectSize; i++)
+                {
+                    float eta = unionArrays[2][i].getFConst();
+                    float k = 1.0f - eta * eta * (1.0f - dotProduct * dotProduct);
+                    if (k < 0.0f)
+                        tempConstArray[i].setFConst(0.0f);
+                    else
+                        tempConstArray[i].setFConst(eta * unionArrays[0][i].getFConst() -
+                                                    (eta * dotProduct + sqrtf(k)) * unionArrays[1][i].getFConst());
+                }
+            }
+            else
+                UNREACHABLE();
+            break;
+
           default:
             UNREACHABLE();
             // TODO: Add constant folding support for other built-in operations that take 3 parameters and not handled above.

src/compiler/translator/Intermediate.cpp

@@ -477,6 +477,12 @@ TIntermTyped *TIntermediate::foldAggregateBuiltIn(TOperator op, TIntermAggregate
       case EOpGreaterThanEqual:
       case EOpVectorEqual:
       case EOpVectorNotEqual:
+      case EOpDistance:
+      case EOpDot:
+      case EOpCross:
+      case EOpFaceForward:
+      case EOpReflect:
+      case EOpRefract:
         return TIntermConstantUnion::FoldAggregateBuiltIn(op, aggregate, mInfoSink);
       default:
         // Constant folding not supported for the built-in.

src/tests/compiler_tests/ConstantFolding_test.cpp

@@ -7,32 +7,53 @@
 //   Tests for constant folding
 //
 
+#include <vector>
+
 #include "angle_gl.h"
 #include "gtest/gtest.h"
 #include "GLSLANG/ShaderLang.h"
 #include "compiler/translator/PoolAlloc.h"
 #include "compiler/translator/TranslatorESSL.h"
 
+template <typename T>
 class ConstantFinder : public TIntermTraverser
 {
   public:
-    ConstantFinder(TConstantUnion constToFind)
-        : mConstToFind(constToFind),
+    ConstantFinder(const std::vector<T> &constantVector)
+        : mConstantVector(constantVector),
           mFound(false)
     {}
 
-    virtual void visitConstantUnion(TIntermConstantUnion *node)
+    ConstantFinder(const T &value)
+        : mFound(false)
+    {
+        mConstantVector.push_back(value);
+    }
+
+    void visitConstantUnion(TIntermConstantUnion *node)
     {
-        if (node->getUnionArrayPointer()[0] == mConstToFind)
+        if (node->getType().getObjectSize() == mConstantVector.size())
         {
-            mFound = true;
+            bool found = true;
+            for (size_t i = 0; i < mConstantVector.size(); i++)
+            {
+                if (node->getUnionArrayPointer()[i] != mConstantVector[i])
+                {
+                    found = false;
+                    break;
+                }
+            }
+            if (found)
+            {
+                mFound = found;
+            }
         }
     }
 
     bool found() const { return mFound; }
 
   private:
-    TConstantUnion mConstToFind;
+    std::vector<T> mConstantVector;
     bool mFound;
 };
 
@@ -72,18 +93,20 @@ class ConstantFoldingTest : public testing::Test
         }
     }
 
-    bool constantFoundInAST(TConstantUnion c)
+    template <typename T>
+    bool constantFoundInAST(T constant)
     {
-        ConstantFinder finder(c);
+        ConstantFinder<T> finder(constant);
         mASTRoot->traverse(&finder);
         return finder.found();
     }
 
-    bool constantFoundInAST(int i)
+    template <typename T>
+    bool constantVectorFoundInAST(const std::vector<T> &constantVector)
     {
-        TConstantUnion c;
-        c.setIConst(i);
-        return constantFoundInAST(c);
+        ConstantFinder<T> finder(constantVector);
+        mASTRoot->traverse(&finder);
+        return finder.found();
     }
 
   private:
@@ -173,3 +196,28 @@ TEST_F(ConstantFoldingTest, FoldIntegerModulus)
     ASSERT_FALSE(constantFoundInAST(5));
     ASSERT_TRUE(constantFoundInAST(4));
 }
+
+TEST_F(ConstantFoldingTest, FoldVectorCrossProduct)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "out vec3 my_Vec3;"
+        "void main() {\n"
+        "   const vec3 v3 = cross(vec3(1.0f, 1.0f, 1.0f), vec3(1.0f, -1.0f, 1.0f));\n"
+        "   my_Vec3 = v3;\n"
+        "}\n";
+    compile(shaderString);
+    std::vector<float> input1(3, 1.0f);
+    ASSERT_FALSE(constantVectorFoundInAST(input1));
+    std::vector<float> input2;
+    input2.push_back(1.0f);
+    input2.push_back(-1.0f);
+    input2.push_back(1.0f);
+    ASSERT_FALSE(constantVectorFoundInAST(input2));
+    std::vector<float> result;
+    result.push_back(2.0f);
+    result.push_back(0.0f);
+    result.push_back(-2.0f);
+    ASSERT_TRUE(constantVectorFoundInAST(result));
+}