Fix HLSL integer pow workaround

src/compiler/translator/ExpandIntegerPowExpressions.cpp

@@ -72,37 +72,31 @@ bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
 
     const TIntermSequence *sequence = node->getSequence();
     ASSERT(sequence->size() == 2u);
-    const TIntermConstantUnion *constantNode = sequence->at(1)->getAsConstantUnion();
+    const TIntermConstantUnion *constantExponent = sequence->at(1)->getAsConstantUnion();
 
     // Test 1: check for a single constant.
-    if (!constantNode || constantNode->getNominalSize() != 1)
+    if (!constantExponent || constantExponent->getNominalSize() != 1)
     {
         return true;
     }
 
-    const TConstantUnion *constant = constantNode->getUnionArrayPointer();
+    ASSERT(constantExponent->getBasicType() == EbtFloat);
+    float exponentValue = constantExponent->getUnionArrayPointer()->getFConst();
 
-    TConstantUnion asFloat;
-    asFloat.cast(EbtFloat, *constant);
-
-    float value = asFloat.getFConst();
-
-    // Test 2: value is in the problematic range.
-    if (value < -5.0f || value > 9.0f)
+    // Test 2: exponentValue is in the problematic range.
+    if (exponentValue < -5.0f || exponentValue > 9.0f)
     {
         return true;
     }
 
-    // Test 3: value is integer or pretty close to an integer.
-    float absval = std::abs(value);
-    float frac   = absval - std::round(absval);
-    if (frac > 0.0001f)
+    // Test 3: exponentValue is integer or pretty close to an integer.
+    if (std::abs(exponentValue - std::round(exponentValue)) > 0.0001f)
     {
         return true;
     }
 
     // Test 4: skip -1, 0, and 1
-    int exponent = static_cast<int>(value);
+    int exponent = static_cast<int>(std::round(exponentValue));
     int n        = std::abs(exponent);
     if (n < 2)
     {

src/tests/gl_tests/GLSLTest.cpp

@@ -1629,22 +1629,28 @@ std::string GenerateSmallPowShader(double base, double exponent)
 // See http://anglebug.com/851
 TEST_P(GLSLTest, PowOfSmallConstant)
 {
-    std::vector<double> bads;
-    for (int eps = -1; eps <= 1; ++eps)
+    // Test with problematic exponents that are close to an integer.
+    std::vector<double> testExponents;
+    std::array<double, 5> epsilonMultipliers = {-100.0, -1.0, 0.0, 1.0, 100.0};
+    for (double epsilonMultiplier : epsilonMultipliers)
     {
         for (int i = -4; i <= 5; ++i)
         {
             if (i >= -1 && i <= 1)
                 continue;
             const double epsilon = 1.0e-8;
-            double bad           = static_cast<double>(i) + static_cast<double>(eps) * epsilon;
-            bads.push_back(bad);
+            double bad           = static_cast<double>(i) + epsilonMultiplier * epsilon;
+            testExponents.push_back(bad);
         }
     }
 
-    for (double bad : bads)
+    // Also test with a few exponents that are not close to an integer.
+    testExponents.push_back(3.6);
+    testExponents.push_back(3.4);
+
+    for (double testExponent : testExponents)
     {
-        const std::string &fragmentShaderSource = GenerateSmallPowShader(1.0e-6, bad);
+        const std::string &fragmentShaderSource = GenerateSmallPowShader(1.0e-6, testExponent);
 
         ANGLE_GL_PROGRAM(program, mSimpleVSSource, fragmentShaderSource);