kc3-lang/angle/src/tests/gl_tests/ShaderAlgorithmTest.cpp

• Show log

  Commit

• Hash : 0ac0603e
  Author :
  Date : 2024-05-14T00:00:00
  

  Fold nested std::max calls
  
  When a maximum of three values is needed,
  an initializer list with all three values
  is more readable than two std::max calls.
  
  Fixed: angleproject:8695
  Change-Id: I073ea1af07b215610c85981eea03f6e73107bce6
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5541974
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Alexey Knyazev <lexa.knyazev@gmail.com>
  

Download

• src/tests/gl_tests/ShaderAlgorithmTest.cpp

• #include "test_utils/ANGLETest.h"
  #include "test_utils/gl_raii.h"
  
  using namespace angle;
  
  namespace
  {
  
  const int GRID_SIZE = 3;
  
  class ShaderAlgorithmTest : public ANGLETest<>
  {
    protected:
      ShaderAlgorithmTest()
      {
          setWindowWidth(64);
          setWindowHeight(64);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  
      ~ShaderAlgorithmTest() {}
  };
  
  // Simplied version of dEQP test dEQP?GLES2.functional.shaders.algorithm.rgb_to_hsl_vertex
  TEST_P(ShaderAlgorithmTest, rgb_to_hsl_vertex_shader)
  {
      const char kVS[] =
          "attribute highp vec3 a_position;\n"
          "attribute highp vec3 a_unitCoords;\n"
          "varying mediump vec3 v_color;\n"
  
          "void main()\n"
          "{\n"
          "    gl_Position =vec4(a_position.x, a_position.y, a_position.z, 1.0);\n"
          "    mediump vec3 coords = a_unitCoords;\n"
          "    mediump vec3 res = vec3(0.0);\n"
          "    mediump float r = coords.x, g = coords.y, b = coords.z;\n"
          "    mediump float minVal = min(min(r, g), b);\n"
          "    mediump float maxVal = max(max(r, g), b);\n"
          "    mediump float H = 0.0; \n"
          "    mediump float S = 0.0; \n"
          "    if (r == maxVal)\n"
          "       H = 1.0;\n"
          "    else\n"
          "       S = 1.0;\n"
          "    res = vec3(H, S, 0);\n"
          "    v_color = res;\n"
          "}\n";
  
      const char kFS[] =
          "varying mediump vec3 v_color;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(v_color, 1.0);\n"
          "}\n";
  
      ANGLE_GL_PROGRAM(program, kVS, kFS);
  
      // compute a_position vertex data
      std::vector<Vector3> positions{Vector3(-1.0f, -1.0f, 0.0f), Vector3(-1.0f, 1.0f, 0.0f),
                                     Vector3(1.0f, 1.0f, 0.0f), Vector3(1.0f, -1.0f, 0.0f)};
  
      // Pass the vertex data to VBO
      GLBuffer posBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(positions[0]) * positions.size(), positions.data(),
                   GL_STATIC_DRAW);
  
      // Link position data to "a_position" vertex attrib
      GLint posLocation = glGetAttribLocation(program, "a_position");
      ASSERT_NE(-1, posLocation);
      glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(posLocation);
  
      // Pass the index data to EBO
      std::vector<GLuint> indices{0, 1, 2, 0, 2, 3};
      GLBuffer indexBuffer;
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices[0]) * indices.size(), indices.data(),
                   GL_STATIC_DRAW);
  
      // Initialize the "a_unitCoords" vertex attributes data
      std::vector<Vector3> unitcoords;
      unitcoords.resize(4);
      GLBuffer unitCoordBuffer;
      GLint unitCoordLocation = glGetAttribLocation(program, "a_unitCoords");
      ASSERT_NE(-1, unitCoordLocation);
  
      const float epsilon = 1.0e-7;
      int gridSize        = GRID_SIZE;
  
      for (int y = 0; y < gridSize + 1; y++)
      {
          for (int x = 0; x < gridSize + 1; x++)
          {
              float sx = (float)x / (float)gridSize;
              float sy = (float)y / (float)gridSize;
  
              // Pass the a_unitCoords data to VBO
              for (int vtx = 0; vtx < 4; vtx++)
              {
                  unitcoords[vtx] = Vector3(sx, sy, 0.33f * sx + 0.5f * sy);
              }
              glBindBuffer(GL_ARRAY_BUFFER, unitCoordBuffer);
              glBufferData(GL_ARRAY_BUFFER, sizeof(unitcoords[0]) * unitcoords.size(),
                           unitcoords.data(), GL_STATIC_DRAW);
  
              // Link the unitcoords data to "a_unitCoords" vertex attrib
              glVertexAttribPointer(unitCoordLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
              glEnableVertexAttribArray(unitCoordLocation);
  
              // Draw and verify
              glUseProgram(program);
              glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
  
              ASSERT_GL_NO_ERROR();
  
              float maxVal = std::max({sx, sy, 0.33f * sx + 0.5f * sy});
              if (abs(maxVal - sx) <= epsilon)
              {
                  EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
              }
              else
              {
                  EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
              }
          }
      }
  }
  
  ANGLE_INSTANTIATE_TEST_ES2_AND(
      ShaderAlgorithmTest,
      ES2_VULKAN().enable(Feature::AvoidOpSelectWithMismatchingRelaxedPrecision));
  
  }  // namespace
  

Download