EmulatePrecision: Round constructor args only when needed

src/compiler/translator/EmulatePrecision.cpp

@@ -467,7 +467,7 @@ TIntermAggregate *createCompoundAssignmentFunctionCallNode(TIntermTyped *left,
     return createInternalFunctionCallNode(TType(EbtVoid), functionName, arguments);
 }
 
-bool parentUsesResult(TIntermNode *parent, TIntermNode *node)
+bool ParentUsesResult(TIntermNode *parent, TIntermTyped *node)
 {
     if (!parent)
     {
@@ -490,6 +490,24 @@ bool parentUsesResult(TIntermNode *parent, TIntermNode *node)
     return true;
 }
 
+bool ParentConstructorTakesCareOfRounding(TIntermNode *parent, TIntermTyped *node)
+{
+    if (!parent)
+    {
+        return false;
+    }
+    TIntermAggregate *parentConstructor = parent->getAsAggregate();
+    if (!parentConstructor || parentConstructor->getOp() != EOpConstruct)
+    {
+        return false;
+    }
+    if (parentConstructor->getPrecision() != node->getPrecision())
+    {
+        return false;
+    }
+    return canRoundFloat(parentConstructor->getType());
+}
+
 }  // namespace anonymous
 
 EmulatePrecision::EmulatePrecision(const TSymbolTable &symbolTable, int shaderVersion)
@@ -500,7 +518,10 @@ EmulatePrecision::EmulatePrecision(const TSymbolTable &symbolTable, int shaderVe
 
 void EmulatePrecision::visitSymbol(TIntermSymbol *node)
 {
-    if (canRoundFloat(node->getType()) && !mDeclaringVariables && !isLValueRequiredHere())
+    TIntermNode *parent = getParentNode();
+    if (canRoundFloat(node->getType()) && ParentUsesResult(parent, node) &&
+        !ParentConstructorTakesCareOfRounding(parent, node) && !mDeclaringVariables &&
+        !isLValueRequiredHere())
     {
         TIntermNode *replacement = createRoundingFunctionCallNode(node);
         queueReplacement(node, replacement, OriginalNode::BECOMES_CHILD);
@@ -545,7 +566,8 @@ bool EmulatePrecision::visitBinary(Visit visit, TIntermBinary *node)
             case EOpMatrixTimesMatrix:
             {
                 TIntermNode *parent = getParentNode();
-                if (!parentUsesResult(parent, node))
+                if (!ParentUsesResult(parent, node) ||
+                    ParentConstructorTakesCareOfRounding(parent, node))
                 {
                     break;
                 }
@@ -637,7 +659,8 @@ bool EmulatePrecision::visitFunctionPrototype(Visit visit, TIntermFunctionProtot
 
 bool EmulatePrecision::visitAggregate(Visit visit, TIntermAggregate *node)
 {
-    bool visitChildren = true;
+    if (visit != PreVisit)
+        return true;
     switch (node->getOp())
     {
         case EOpCallInternalRawFunction:
@@ -652,15 +675,15 @@ bool EmulatePrecision::visitAggregate(Visit visit, TIntermAggregate *node)
             }
         default:
             TIntermNode *parent = getParentNode();
-            if (canRoundFloat(node->getType()) && visit == PreVisit &&
-                parentUsesResult(parent, node))
+            if (canRoundFloat(node->getType()) && ParentUsesResult(parent, node) &&
+                !ParentConstructorTakesCareOfRounding(parent, node))
             {
                 TIntermNode *replacement = createRoundingFunctionCallNode(node);
                 queueReplacement(node, replacement, OriginalNode::BECOMES_CHILD);
             }
             break;
     }
-    return visitChildren;
+    return true;
 }
 
 bool EmulatePrecision::visitUnary(Visit visit, TIntermUnary *node)

src/tests/compiler_tests/DebugShaderPrecision_test.cpp

@@ -798,7 +798,7 @@ TEST_F(DebugShaderPrecisionTest, ConstructorRounding)
         "precision mediump int;\n"
         "uniform float u1;\n"
         "uniform float u2;\n"
-        "uniform float u3;\n"
+        "uniform lowp float u3;\n"
         "uniform float u4;\n"
         "uniform ivec4 uiv;\n"
         "void main() {\n"
@@ -807,13 +807,10 @@ TEST_F(DebugShaderPrecisionTest, ConstructorRounding)
         "   gl_FragColor = v1 + v2;\n"
         "}\n";
     compile(shaderString);
-    // Note: this is suboptimal for the case taking four floats, but optimizing would be tricky.
-    ASSERT_TRUE(foundInAllGLSLCode(
-        "v1 = angle_frm(vec4(angle_frm(u1), angle_frm(u2), angle_frm(u3), angle_frm(u4)))"));
+    ASSERT_TRUE(foundInAllGLSLCode("v1 = angle_frm(vec4(u1, u2, angle_frl(u3), u4))"));
     ASSERT_TRUE(foundInAllGLSLCode("v2 = angle_frm(vec4(uiv))"));
 
-    ASSERT_TRUE(foundInHLSLCode(
-        "v1 = angle_frm(vec4(angle_frm(_u1), angle_frm(_u2), angle_frm(_u3), angle_frm(_u4)))"));
+    ASSERT_TRUE(foundInHLSLCode("v1 = angle_frm(vec4(_u1, _u2, angle_frl(_u3), _u4))"));
     ASSERT_TRUE(foundInHLSLCode("v2 = angle_frm(vec4(_uiv))"));
 }