Emulate the pack/unpack functions for unorms.

src/compiler/translator/BuiltInFunctionEmulatorGLSL.cpp

@@ -41,6 +41,29 @@ void InitBuiltInFunctionEmulatorForGLSLWorkarounds(BuiltInFunctionEmulator *emu,
 void InitBuiltInFunctionEmulatorForGLSLMissingFunctions(BuiltInFunctionEmulator *emu, sh::GLenum shaderType,
                                                         int targetGLSLVersion)
 {
+    // Emulate packUnorm2x16 and unpackUnorm2x16 (GLSL 4.10)
+    if (targetGLSLVersion < GLSL_VERSION_410)
+    {
+        TType *float2 = new TType(EbtFloat, 2);
+        TType *uint1 = new TType(EbtUInt);
+
+        emu->addEmulatedFunction(EOpPackUnorm2x16, float2,
+            "uint webgl_packUnorm2x16_emu(vec2 v)\n"
+            "{\n"
+            "    int x = int(round(clamp(v.x, 0.0, 1.0) * 65535.0));\n"
+            "    int y = int(round(clamp(v.y, 0.0, 1.0) * 65535.0));\n"
+            "    return uint((y << 16) | (x & 0xFFFF));\n"
+            "}\n");
+
+        emu->addEmulatedFunction(EOpUnpackUnorm2x16, uint1,
+            "vec2 webgl_unpackUnorm2x16_emu(uint u)\n"
+            "{\n"
+            "    float x = float(u & 0xFFFFu) / 65535.0;\n"
+            "    float y = float(u >> 16) / 65535.0;\n"
+            "    return vec2(x, y);\n"
+            "}\n");
+    }
+
     // Emulate packSnorm2x16, packHalf2x16, unpackSnorm2x16, and unpackHalf2x16 (GLSL 4.20)
     // by using floatBitsToInt, floatBitsToUint, intBitsToFloat, and uintBitsToFloat (GLSL 3.30).
     if (targetGLSLVersion >= GLSL_VERSION_330 && targetGLSLVersion < GLSL_VERSION_420)

src/tests/compiler_tests/Pack_Unpack_test.cpp

@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 // Pack_Unpack_test.cpp:
-//   Tests for the emulating pack_unpack functions for GLSL 4.1.
+//   Tests for the emulating pack_unpack functions for GLSL.
 //
 
 #include "angle_gl.h"
@@ -15,7 +15,7 @@
 namespace
 {
 
-class PackUnpackTest : public testing::Test
+class PackUnpackTest : public testing::TestWithParam<ShShaderOutput>
 {
   public:
     PackUnpackTest() {}
@@ -25,15 +25,15 @@ class PackUnpackTest : public testing::Test
     {
         std::string infoLog;
         bool compilationSuccess = compileTestShader(GL_FRAGMENT_SHADER, SH_GLES3_SPEC,
-                                                    SH_GLSL_410_CORE_OUTPUT,
+                                                    GetParam(),
                                                     shaderString, &mGLSLCode, &infoLog);
         if (!compilationSuccess)
         {
-            FAIL() << "Shader compilation into GLSL 4.1 failed " << infoLog;
+            FAIL() << "Shader compilation into GLSL failed " << infoLog;
         }
     }
 
-    bool foundInGLSLCode(const char* stringToFind)
+    bool foundInGLSLCode(const char* stringToFind) const
     {
         return mGLSLCode.find(stringToFind) != std::string::npos;
     }
@@ -42,8 +42,8 @@ class PackUnpackTest : public testing::Test
     std::string mGLSLCode;
 };
 
-//Check if PackSnorm2x16 Emulation for GLSL 4.1 compile correctly.
-TEST_F(PackUnpackTest, PackSnorm2x16Emulation)
+//Check if PackSnorm2x16 Emulation for GLSL < 4.2 compile correctly.
+TEST_P(PackUnpackTest, PackSnorm2x16Emulation)
 {
     const std::string &shaderString =
         "#version 300 es\n"
@@ -55,11 +55,11 @@ TEST_F(PackUnpackTest, PackSnorm2x16Emulation)
         "   fragColor = vec4(0.0);\n"
         "}\n";
     compile(shaderString);
-    ASSERT_TRUE(foundInGLSLCode("uint webgl_packSnorm2x16_emu(vec2 v)"));
+    ASSERT_EQ(GetParam() < SH_GLSL_420_CORE_OUTPUT, foundInGLSLCode("uint webgl_packSnorm2x16_emu(vec2 v)"));
 }
 
-//Check if UnpackSnorm2x16 Emulation for GLSL 4.1 compile correctly.
-TEST_F(PackUnpackTest, UnpackSnorm2x16Emulation)
+//Check if UnpackSnorm2x16 Emulation for GLSL < 4.2 compile correctly.
+TEST_P(PackUnpackTest, UnpackSnorm2x16Emulation)
 {
     const std::string &shaderString =
         "#version 300 es\n"
@@ -71,11 +71,43 @@ TEST_F(PackUnpackTest, UnpackSnorm2x16Emulation)
         "   fragColor = vec4(0.0);\n"
         "}\n";
     compile(shaderString);
-    ASSERT_TRUE(foundInGLSLCode("vec2 webgl_unpackSnorm2x16_emu(uint u)"));
+    ASSERT_EQ(GetParam() < SH_GLSL_420_CORE_OUTPUT, foundInGLSLCode("vec2 webgl_unpackSnorm2x16_emu(uint u)"));
 }
 
-//Check if PackHalf2x16 Emulation for GLSL 4.1 compile correctly.
-TEST_F(PackUnpackTest, PackHalf2x16Emulation)
+//Check if PackUnorm2x16 Emulation for GLSL < 4.1 compiles correctly.
+TEST_P(PackUnpackTest, PackUnorm2x16Emulation)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "layout(location = 0) out mediump vec4 fragColor;"
+        "void main() {\n"
+        "   vec2 v;\n"
+        "   uint u = packUnorm2x16(v);\n"
+        "   fragColor = vec4(0.0);\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_EQ(GetParam() < SH_GLSL_410_CORE_OUTPUT, foundInGLSLCode("uint webgl_packUnorm2x16_emu(vec2 v)"));
+}
+
+//Check if UnpackSnorm2x16 Emulation for GLSL < 4.1 compiles correctly.
+TEST_P(PackUnpackTest, UnpackUnorm2x16Emulation)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "layout(location = 0) out mediump vec4 fragColor;"
+        "void main() {\n"
+        "   uint u;\n"
+        "   vec2 v=unpackUnorm2x16(u);\n"
+        "   fragColor = vec4(0.0);\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_EQ(GetParam() < SH_GLSL_410_CORE_OUTPUT, foundInGLSLCode("vec2 webgl_unpackUnorm2x16_emu(uint u)"));
+}
+
+//Check if PackHalf2x16 Emulation for GLSL < 4.2 compiles correctly.
+TEST_P(PackUnpackTest, PackHalf2x16Emulation)
 {
     const std::string &shaderString =
         "#version 300 es\n"
@@ -87,11 +119,11 @@ TEST_F(PackUnpackTest, PackHalf2x16Emulation)
         "   fragColor = vec4(0.0);\n"
         "}\n";
     compile(shaderString);
-    ASSERT_TRUE(foundInGLSLCode("uint webgl_packHalf2x16_emu(vec2 v)"));
+    ASSERT_EQ(GetParam() < SH_GLSL_420_CORE_OUTPUT, foundInGLSLCode("uint webgl_packHalf2x16_emu(vec2 v)"));
 }
 
-//Check if UnpackHalf2x16 Emulation for GLSL 4.1 compile correctly.
-TEST_F(PackUnpackTest, UnpackHalf2x16Emulation)
+//Check if UnpackHalf2x16 Emulation for GLSL < 4.2 compiles correctly.
+TEST_P(PackUnpackTest, UnpackHalf2x16Emulation)
 {
     const std::string &shaderString =
         "#version 300 es\n"
@@ -103,7 +135,13 @@ TEST_F(PackUnpackTest, UnpackHalf2x16Emulation)
         "   fragColor = vec4(0.0);\n"
         "}\n";
     compile(shaderString);
-    ASSERT_TRUE(foundInGLSLCode("vec2 webgl_unpackHalf2x16_emu(uint u)"));
+    ASSERT_EQ(GetParam() < SH_GLSL_420_CORE_OUTPUT, foundInGLSLCode("vec2 webgl_unpackHalf2x16_emu(uint u)"));
 }
 
+INSTANTIATE_TEST_CASE_P(, PackUnpackTest,
+                        testing::Values(SH_GLSL_330_CORE_OUTPUT, SH_GLSL_400_CORE_OUTPUT,
+                                        SH_GLSL_410_CORE_OUTPUT, SH_GLSL_420_CORE_OUTPUT,
+                                        SH_GLSL_430_CORE_OUTPUT, SH_GLSL_440_CORE_OUTPUT,
+                                        SH_GLSL_450_CORE_OUTPUT));
+
 } // namespace

src/tests/gl_tests/PackUnpackTest.cpp

@@ -59,6 +59,21 @@ class PackUnpackTest : public ANGLETest
         );
 
         // Fragment Shader source
+        const std::string uNormFS = SHADER_SOURCE
+        (   #version 300 es\n
+            precision mediump float;
+            uniform mediump vec2 v;
+            layout(location = 0) out mediump vec4 fragColor;
+
+            void main()
+            {
+                uint u = packUnorm2x16(v);
+                vec2 r = unpackUnorm2x16(u);
+                fragColor = vec4(r, 0.0, 1.0);
+            }
+        );
+
+        // Fragment Shader source
         const std::string halfFS = SHADER_SOURCE
         (   #version 300 es\n
             precision mediump float;
@@ -74,8 +89,9 @@ class PackUnpackTest : public ANGLETest
         );
 
         mSNormProgram = CompileProgram(vs, sNormFS);
+        mUNormProgram = CompileProgram(vs, uNormFS);
         mHalfProgram = CompileProgram(vs, halfFS);
-        if (mSNormProgram == 0 || mHalfProgram == 0)
+        if (mSNormProgram == 0 || mUNormProgram == 0|| mHalfProgram == 0)
         {
             FAIL() << "shader compilation failed.";
         }
@@ -99,6 +115,7 @@ class PackUnpackTest : public ANGLETest
         glDeleteTextures(1, &mOffscreenTexture2D);
         glDeleteFramebuffers(1, &mOffscreenFramebuffer);
         glDeleteProgram(mSNormProgram);
+        glDeleteProgram(mUNormProgram);
         glDeleteProgram(mHalfProgram);
 
         ANGLETest::TearDown();
@@ -131,6 +148,7 @@ class PackUnpackTest : public ANGLETest
     }
 
     GLuint mSNormProgram;
+    GLuint mUNormProgram;
     GLuint mHalfProgram;
     GLuint mOffscreenFramebuffer;
     GLuint mOffscreenTexture2D;
@@ -146,6 +164,16 @@ TEST_P(PackUnpackTest, PackUnpackSnormNormal)
     compareBeforeAfter(mSNormProgram, 1.0f, -0.00392f);
 }
 
+// Test the correctness of packSnorm2x16 and unpackSnorm2x16 functions calculating normal floating numbers.
+TEST_P(PackUnpackTest, PackUnpackUnormNormal)
+{
+    // Expect the shader to output the same value as the input
+    compareBeforeAfter(mUNormProgram, 0.5f, 0.2f, 0.5f, 0.2f);
+    compareBeforeAfter(mUNormProgram, 0.35f, 0.75f, 0.35f, 0.75f);
+    compareBeforeAfter(mUNormProgram, 0.00392f, 0.99215f, 0.00392f, 0.99215f);
+    compareBeforeAfter(mUNormProgram, 1.0f, 0.00392f, 1.0f, 0.00392f);
+}
+
 // Test the correctness of packHalf2x16 and unpackHalf2x16 functions calculating normal floating numbers.
 TEST_P(PackUnpackTest, PackUnpackHalfNormal)
 {
@@ -163,6 +191,14 @@ TEST_P(PackUnpackTest, PackUnpackSnormSubnormal)
     compareBeforeAfter(mSNormProgram, 0.00001f, -0.00001f);
 }
 
+// Test the correctness of packUnorm2x16 and unpackUnorm2x16 functions calculating subnormal floating numbers.
+TEST_P(PackUnpackTest, PackUnpackUnormSubnormal)
+{
+    // Expect the shader to output the same value as the input for positive numbers and clamp
+    // to [0, 1]
+    compareBeforeAfter(mUNormProgram, 0.00001f, -0.00001f, 0.00001f, 0.0f);
+}
+
 // Test the correctness of packHalf2x16 and unpackHalf2x16 functions calculating subnormal floating numbers.
 TEST_P(PackUnpackTest, PackUnpackHalfSubnormal)
 {
@@ -177,6 +213,12 @@ TEST_P(PackUnpackTest, PackUnpackSnormZero)
     compareBeforeAfter(mSNormProgram, 0.00000f, -0.00000f);
 }
 
+// Test the correctness of packUnorm2x16 and unpackUnorm2x16 functions calculating zero floating numbers.
+TEST_P(PackUnpackTest, PackUnpackUnormZero)
+{
+    compareBeforeAfter(mUNormProgram, 0.00000f, -0.00000f, 0.00000f, -0.00000f);
+}
+
 // Test the correctness of packHalf2x16 and unpackHalf2x16 functions calculating zero floating numbers.
 TEST_P(PackUnpackTest, PackUnpackHalfZero)
 {
@@ -184,6 +226,13 @@ TEST_P(PackUnpackTest, PackUnpackHalfZero)
     compareBeforeAfter(mHalfProgram, 0.00000f, -0.00000f);
 }
 
+// Test the correctness of packUnorm2x16 and unpackUnorm2x16 functions calculating overflow floating numbers.
+TEST_P(PackUnpackTest, PackUnpackUnormOverflow)
+{
+    // Expect the shader to clamp the input to [0, 1]
+    compareBeforeAfter(mUNormProgram, 67000.0f, -67000.0f, 1.0f, 0.0f);
+}
+
 // Test the correctness of packSnorm2x16 and unpackSnorm2x16 functions calculating overflow floating numbers.
 TEST_P(PackUnpackTest, PackUnpackSnormOverflow)
 {