kc3-lang/angle/tests/angle_tests/GLSLTest.cpp

• Show log

  Commit

• Hash : 4836d22a
  Author :
  Date : 2014-07-24T06:55:51
  

  Fix ASSERT when rewriting else-if blocks with no else.
  
  The code assumed an else-if would end in an else. We can also save a
  few allocations in the cases where there is no else.
  
  BUG=angle:699
  
  Change-Id: I550857366775b4a34aea97e117ef732297d3f448
  Reviewed-on: https://chromium-review.googlesource.com/208681
  Tested-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Nicolas Capens <capn@chromium.org>
  

Download

• tests/angle_tests/GLSLTest.cpp

• #include "ANGLETest.h"
  
  class GLSLTest : public ANGLETest
  {
  protected:
      GLSLTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  
      virtual void SetUp()
      {
          ANGLETest::SetUp();
  
          mSimpleVSSource = SHADER_SOURCE
          (
              attribute vec4 inputAttribute;
              void main()
              {
                  gl_Position = inputAttribute;
              }
          );
      }
  
      std::string mSimpleVSSource;
  };
  
  TEST_F(GLSLTest, NamelessScopedStructs)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          void main()
          {
              struct
              {
                  float q;
              } b;
  
              gl_FragColor = vec4(1, 0, 0, 1);
              gl_FragColor.a += b.q;
          }
      );
  
      GLuint program = compileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  TEST_F(GLSLTest, ScopedStructsOrderBug)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          struct T
          {
              float f;
          };
  
          void main()
          {
              T a;
  
              struct T
              {
                  float q;
              };
  
              T b;
  
              gl_FragColor = vec4(1, 0, 0, 1);
              gl_FragColor.a += a.f;
              gl_FragColor.a += b.q;
          }
      );
  
      GLuint program = compileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_F(GLSLTest, ScopedStructsBug)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          struct T_0
          {
              float f;
          };
  
          void main()
          {
              gl_FragColor = vec4(1, 0, 0, 1);
  
              struct T
              {
                  vec2 v;
              };
  
              T_0 a;
              T b;
  
              gl_FragColor.a += a.f;
              gl_FragColor.a += b.v.x;
          }
      );
  
      GLuint program = compileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_F(GLSLTest, DxPositionBug)
  {
      const std::string &vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 inputAttribute;
          varying float dx_Position;
          void main()
          {
              gl_Position = vec4(inputAttribute);
              dx_Position = 0.0;
          }
      );
  
      const std::string &fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          varying float dx_Position;
  
          void main()
          {
              gl_FragColor = vec4(dx_Position, 0, 0, 1);
          }
      );
  
      GLuint program = compileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_F(GLSLTest, ElseIfRewriting)
  {
      const std::string &vertexShaderSource =
          "attribute vec4 a_position;\n"
          "varying float v;\n"
          "void main() {\n"
          "  gl_Position = a_position;\n"
          "  v = 1.0;\n"
          "  if (a_position.x <= 0.5) {\n"
          "    v = 0.0;\n"
          "  } else if (a_position.x >= 0.5) {\n"
          "    v = 2.0;\n"
          "  }\n"
          "}\n";
  
      const std::string &fragmentShaderSource =
          "precision highp float;\n"
          "varying float v;\n"
          "void main() {\n"
          "  vec4 color = vec4(1.0, 0.0, 0.0, 1.0);\n"
          "  if (v >= 1.0) color = vec4(0.0, 1.0, 0.0, 1.0);\n"
          "  if (v >= 2.0) color = vec4(0.0, 0.0, 1.0, 1.0);\n"
          "  gl_FragColor = color;\n"
          "}\n";
  
      GLuint program = compileProgram(vertexShaderSource, fragmentShaderSource);
      ASSERT_NE(0u, program);
  
      drawQuad(program, "a_position", 0.5f);
      swapBuffers();
  
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
      EXPECT_PIXEL_EQ(getWindowWidth()-1, 0, 0, 255, 0, 255);
  }
  
  TEST_F(GLSLTest, TwoElseIfRewriting)
  {
      const std::string &vertexShaderSource =
          "attribute vec4 a_position;\n"
          "varying float v;\n"
          "void main() {\n"
          "  gl_Position = a_position;\n"
          "  if (a_position.x == 0.0`) {\n"
          "    v = 1.0;\n"
          "  } else if (a_position.x > 0.5) {\n"
          "    v = 0.0;\n"
          "  } else if (a_position.x > 0.75) {\n"
          "    v = 0.5;\n"
          "  }\n"
          "}\n";
  
      const std::string &fragmentShaderSource =
          "precision highp float;\n"
          "varying float v;\n"
          "void main() {\n"
          "  gl_FragColor = vec4(v, 0.0, 0.0, 1.0);\n"
          "}\n";
  
      GLuint program = compileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  

Download