Output infinity and NaN literals correctly in shaders

src/compiler/translator/OutputGLSLBase.cpp

@@ -7,6 +7,7 @@
 #include "compiler/translator/OutputGLSLBase.h"
 
 #include "common/debug.h"
+#include "common/mathutil.h"
 
 #include <cfloat>
 
@@ -112,6 +113,18 @@ void TOutputGLSLBase::writeInvariantQualifier(const TType &type)
     }
 }
 
+void TOutputGLSLBase::writeFloat(TInfoSinkBase &out, float f)
+{
+    if ((gl::isInf(f) || gl::isNaN(f)) && mShaderVersion >= 300)
+    {
+        out << "uintBitsToFloat(" << gl::bitCast<uint32_t>(f) << "u)";
+    }
+    else
+    {
+        out << std::min(FLT_MAX, std::max(-FLT_MAX, f));
+    }
+}
+
 void TOutputGLSLBase::writeTriplet(
     Visit visit, const char *preStr, const char *inStr, const char *postStr)
 {
@@ -329,8 +342,8 @@ const TConstantUnion *TOutputGLSLBase::writeConstantUnion(
             switch (pConstUnion->getType())
             {
               case EbtFloat:
-                out << std::min(FLT_MAX, std::max(-FLT_MAX, pConstUnion->getFConst()));
-                break;
+                  writeFloat(out, pConstUnion->getFConst());
+                  break;
               case EbtInt:
                 out << pConstUnion->getIConst();
                 break;

src/compiler/translator/OutputGLSLBase.h

@@ -35,6 +35,7 @@ class TOutputGLSLBase : public TIntermTraverser
 
   protected:
     TInfoSinkBase &objSink() { return mObjSink; }
+    void writeFloat(TInfoSinkBase &out, float f);
     void writeTriplet(Visit visit, const char *preStr, const char *inStr, const char *postStr);
     void writeLayoutQualifier(const TType &type);
     void writeInvariantQualifier(const TType &type);

src/compiler/translator/OutputHLSL.cpp

@@ -31,16 +31,28 @@
 namespace sh
 {
 
-namespace
+void OutputHLSL::writeFloat(TInfoSinkBase &out, float f)
 {
+    // This is known not to work for NaN on all drivers but make the best effort to output NaNs
+    // regardless.
+    if ((gl::isInf(f) || gl::isNaN(f)) && mShaderVersion >= 300 &&
+        mOutputType == SH_HLSL_4_1_OUTPUT)
+    {
+        out << "asfloat(" << gl::bitCast<uint32_t>(f) << "u)";
+    }
+    else
+    {
+        out << std::min(FLT_MAX, std::max(-FLT_MAX, f));
+    }
+}
 
-void WriteSingleConstant(TInfoSinkBase &out, const TConstantUnion *const constUnion)
+void OutputHLSL::writeSingleConstant(TInfoSinkBase &out, const TConstantUnion *const constUnion)
 {
     ASSERT(constUnion != nullptr);
     switch (constUnion->getType())
     {
         case EbtFloat:
-            out << std::min(FLT_MAX, std::max(-FLT_MAX, constUnion->getFConst()));
+            writeFloat(out, constUnion->getFConst());
             break;
         case EbtInt:
             out << constUnion->getIConst();
@@ -56,14 +68,14 @@ void WriteSingleConstant(TInfoSinkBase &out, const TConstantUnion *const constUn
     }
 }
 
-const TConstantUnion *WriteConstantUnionArray(TInfoSinkBase &out,
-                                              const TConstantUnion *const constUnion,
-                                              const size_t size)
+const TConstantUnion *OutputHLSL::writeConstantUnionArray(TInfoSinkBase &out,
+                                                          const TConstantUnion *const constUnion,
+                                                          const size_t size)
 {
     const TConstantUnion *constUnionIterated = constUnion;
     for (size_t i = 0; i < size; i++, constUnionIterated++)
     {
-        WriteSingleConstant(out, constUnionIterated);
+        writeSingleConstant(out, constUnionIterated);
 
         if (i != size - 1)
         {
@@ -73,8 +85,6 @@ const TConstantUnion *WriteConstantUnionArray(TInfoSinkBase &out,
     return constUnionIterated;
 }
 
-} // namespace
-
 OutputHLSL::OutputHLSL(sh::GLenum shaderType,
                        int shaderVersion,
                        const TExtensionBehavior &extensionBehavior,
@@ -2571,7 +2581,7 @@ const TConstantUnion *OutputHLSL::writeConstantUnion(TInfoSinkBase &out,
         {
             out << TypeString(type) << "(";
         }
-        constUnionIterated = WriteConstantUnionArray(out, constUnionIterated, size);
+        constUnionIterated = writeConstantUnionArray(out, constUnionIterated, size);
         if (writeType)
         {
             out << ")";
@@ -2632,7 +2642,7 @@ bool OutputHLSL::writeConstantInitialization(TInfoSinkBase &out,
         {
             TIntermConstantUnion *nodeConst  = expression->getAsConstantUnion();
             const TConstantUnion *constUnion = nodeConst->getUnionArrayPointer();
-            WriteConstantUnionArray(out, constUnion, nodeConst->getType().getObjectSize());
+            writeConstantUnionArray(out, constUnion, nodeConst->getType().getObjectSize());
         }
         else
         {
@@ -2643,7 +2653,7 @@ bool OutputHLSL::writeConstantInitialization(TInfoSinkBase &out,
                 TIntermConstantUnion *nodeConst = node->getAsConstantUnion();
                 ASSERT(nodeConst);
                 const TConstantUnion *constUnion = nodeConst->getUnionArrayPointer();
-                WriteConstantUnionArray(out, constUnion, nodeConst->getType().getObjectSize());
+                writeConstantUnionArray(out, constUnion, nodeConst->getType().getObjectSize());
                 if (node != constructor->getSequence()->back())
                 {
                     out << ", ";

src/compiler/translator/OutputHLSL.h

@@ -55,6 +55,12 @@ class OutputHLSL : public TIntermTraverser
   protected:
     void header(TInfoSinkBase &out, const BuiltInFunctionEmulator *builtInFunctionEmulator);
 
+    void writeFloat(TInfoSinkBase &out, float f);
+    void writeSingleConstant(TInfoSinkBase &out, const TConstantUnion *const constUnion);
+    const TConstantUnion *writeConstantUnionArray(TInfoSinkBase &out,
+                                                  const TConstantUnion *const constUnion,
+                                                  const size_t size);
+
     // Visit AST nodes and output their code to the body stream
     void visitSymbol(TIntermSymbol*);
     void visitRaw(TIntermRaw*);

src/tests/gl_tests/GLSLTest.cpp

@@ -2353,6 +2353,48 @@ TEST_P(GLSLTest_ES3, FoldedInvalidLeftShift)
     glDeleteProgram(program);
 }
 
+// Test that literal infinity can be written out from the shader translator.
+// A similar test can't be made for NaNs, since ESSL 3.00.6 requirements for NaNs are very loose.
+TEST_P(GLSLTest_ES3, LiteralInfinityOutput)
+{
+    const std::string &fragmentShader =
+        "#version 300 es\n"
+        "precision highp float;\n"
+        "out vec4 out_color;\n"
+        "uniform float u;\n"
+        "void main()\n"
+        "{\n"
+        "   float infVar = 1.0e40 - u;\n"
+        "   bool correct = isinf(infVar) && infVar > 0.0;\n"
+        "   out_color = correct ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);\n"
+        "}\n";
+
+    ANGLE_GL_PROGRAM(program, mSimpleVSSource, fragmentShader);
+    drawQuad(program.get(), "inputAttribute", 0.5f);
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
+}
+
+// Test that literal negative infinity can be written out from the shader translator.
+// A similar test can't be made for NaNs, since ESSL 3.00.6 requirements for NaNs are very loose.
+TEST_P(GLSLTest_ES3, LiteralNegativeInfinityOutput)
+{
+    const std::string &fragmentShader =
+        "#version 300 es\n"
+        "precision highp float;\n"
+        "out vec4 out_color;\n"
+        "uniform float u;\n"
+        "void main()\n"
+        "{\n"
+        "   float infVar = -1.0e40 + u;\n"
+        "   bool correct = isinf(infVar) && infVar < 0.0;\n"
+        "   out_color = correct ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);\n"
+        "}\n";
+
+    ANGLE_GL_PROGRAM(program, mSimpleVSSource, fragmentShader);
+    drawQuad(program.get(), "inputAttribute", 0.5f);
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
+}
+
 }  // anonymous namespace
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.