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

• Show log

  Commit

• Hash : 6276b922
  Author :
  Date : 2017-09-25T02:35:57
  

  Vulkan: Implement basic uniform shader parsing.
  
  This is a first step at implementing uniforms with descriptor sets.
  It does not actually bind uniforms and upload data, but it does
  implement uniform shader parsing. Uniforms are gathered into a single
  uniform block which is bound to set 0, with binding 0 for vertex
  uniforms and binding 1 for fragment uniforms.
  
  Also adds a ReplaceSubstring helper to string_utils.
  
  Also removes the precision writing from OutputVulkanGLSL since this
  was generating warnings with glslang.
  
  BUG=angleproject:2167
  
  Change-Id: I9ec8351ec1973e583100f99292b0080ee968067b
  Reviewed-on: https://chromium-review.googlesource.com/699938
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Frank Henigman <fjhenigman@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• src/tests/gl_tests/SimpleOperationTest.cpp

• //
  // Copyright 2015 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // SimpleOperationTest:
  //   Basic GL commands such as linking a program, initializing a buffer, etc.
  
  #include "test_utils/ANGLETest.h"
  
  #include <vector>
  
  #include "random_utils.h"
  #include "test_utils/gl_raii.h"
  
  using namespace angle;
  
  namespace
  {
  
  class SimpleOperationTest : public ANGLETest
  {
    protected:
      SimpleOperationTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  
      void verifyBuffer(const std::vector<uint8_t> &data, GLenum binding);
  };
  
  void SimpleOperationTest::verifyBuffer(const std::vector<uint8_t> &data, GLenum binding)
  {
      if (!extensionEnabled("GL_EXT_map_buffer_range"))
      {
          return;
      }
  
      uint8_t *mapPointer =
          static_cast<uint8_t *>(glMapBufferRangeEXT(GL_ARRAY_BUFFER, 0, 1024, GL_MAP_READ_BIT));
      ASSERT_GL_NO_ERROR();
  
      std::vector<uint8_t> readbackData(data.size());
      memcpy(readbackData.data(), mapPointer, data.size());
      glUnmapBufferOES(GL_ARRAY_BUFFER);
  
      EXPECT_EQ(data, readbackData);
  }
  
  TEST_P(SimpleOperationTest, CompileVertexShader)
  {
      const std::string source =
          R"(attribute vec4 a_input;
          void main()
          {
              gl_Position = a_input;
          })";
  
      GLuint shader = CompileShader(GL_VERTEX_SHADER, source);
      EXPECT_NE(shader, 0u);
      glDeleteShader(shader);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, CompileFragmentShader)
  {
      const std::string source =
          R"(precision mediump float;
          varying vec4 v_input;
          void main()
          {
              gl_FragColor = v_input;
          })";
  
      GLuint shader = CompileShader(GL_FRAGMENT_SHADER, source);
      EXPECT_NE(shader, 0u);
      glDeleteShader(shader);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, LinkProgram)
  {
      const std::string vsSource =
          R"(void main()
          {
              gl_Position = vec4(1.0, 1.0, 1.0, 1.0);
          })";
  
      const std::string fsSource =
          R"(void main()
          {
              gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
          })";
  
      GLuint program = CompileProgram(vsSource, fsSource);
      EXPECT_NE(program, 0u);
      glDeleteProgram(program);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, LinkProgramWithUniforms)
  {
      const std::string vsSource =
          R"(void main()
          {
              gl_Position = vec4(1.0, 1.0, 1.0, 1.0);
          })";
  
      const std::string fsSource =
          R"(precision mediump float;
          uniform vec4 u_input;
          void main()
          {
              gl_FragColor = u_input;
          })";
  
      GLuint program = CompileProgram(vsSource, fsSource);
      EXPECT_NE(program, 0u);
  
      GLint uniformLoc = glGetUniformLocation(program, "u_input");
      EXPECT_NE(-1, uniformLoc);
  
      glDeleteProgram(program);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, LinkProgramWithAttributes)
  {
      const std::string vsSource =
          R"(attribute vec4 a_input;
          void main()
          {
              gl_Position = a_input;
          })";
  
      const std::string fsSource =
          R"(void main()
          {
              gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
          })";
  
      GLuint program = CompileProgram(vsSource, fsSource);
      EXPECT_NE(program, 0u);
  
      GLint attribLoc = glGetAttribLocation(program, "a_input");
      EXPECT_NE(-1, attribLoc);
  
      glDeleteProgram(program);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, BufferDataWithData)
  {
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
  
      std::vector<uint8_t> data(1024);
      FillVectorWithRandomUBytes(&data);
      glBufferData(GL_ARRAY_BUFFER, data.size(), &data[0], GL_STATIC_DRAW);
  
      verifyBuffer(data, GL_ARRAY_BUFFER);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, BufferDataWithNoData)
  {
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
      glBufferData(GL_ARRAY_BUFFER, 1024, nullptr, GL_STATIC_DRAW);
  
      EXPECT_GL_NO_ERROR();
  }
  
  TEST_P(SimpleOperationTest, BufferSubData)
  {
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
  
      constexpr size_t bufferSize = 1024;
      std::vector<uint8_t> data(bufferSize);
      FillVectorWithRandomUBytes(&data);
  
      glBufferData(GL_ARRAY_BUFFER, bufferSize, nullptr, GL_STATIC_DRAW);
  
      constexpr size_t subDataCount = 16;
      constexpr size_t sliceSize    = bufferSize / subDataCount;
      for (size_t i = 0; i < subDataCount; i++)
      {
          size_t offset = i * sliceSize;
          glBufferSubData(GL_ARRAY_BUFFER, offset, sliceSize, &data[offset]);
      }
  
      verifyBuffer(data, GL_ARRAY_BUFFER);
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Simple quad test.
  TEST_P(SimpleOperationTest, DrawQuad)
  {
      const std::string &vertexShader =
          "attribute vec3 position;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(position, 1);\n"
          "}";
      const std::string &fragmentShader =
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(0, 1, 0, 1);\n"
          "}";
      ANGLE_GL_PROGRAM(program, vertexShader, fragmentShader);
  
      drawQuad(program.get(), "position", 0.5f, 1.0f, true);
  
      EXPECT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Simple repeated draw and swap test.
  TEST_P(SimpleOperationTest, DrawQuadAndSwap)
  {
      const std::string &vertexShader =
          "attribute vec3 position;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(position, 1);\n"
          "}";
      const std::string &fragmentShader =
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(0, 1, 0, 1);\n"
          "}";
      ANGLE_GL_PROGRAM(program, vertexShader, fragmentShader);
  
      for (int i = 0; i < 8; ++i)
      {
          drawQuad(program.get(), "position", 0.5f, 1.0f, true);
          EXPECT_GL_NO_ERROR();
          EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
          swapBuffers();
      }
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Simple indexed quad test.
  TEST_P(SimpleOperationTest, DrawIndexedQuad)
  {
      const std::string vertexShader =
          "attribute vec3 position;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(position, 1);\n"
          "}";
      const std::string fragmentShader =
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(0, 1, 0, 1);\n"
          "}";
      ANGLE_GL_PROGRAM(program, vertexShader, fragmentShader);
  
      drawIndexedQuad(program.get(), "position", 0.5f, 1.0f, true);
  
      EXPECT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests a shader program with more than one vertex attribute, with vertex buffers.
  TEST_P(SimpleOperationTest, ThreeVertexAttributes)
  {
      const std::string vertexShader =
          R"(attribute vec2 position;
  attribute vec4 color1;
  attribute vec4 color2;
  varying vec4 color;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
      color = color1 + color2;
  })";
  
      const std::string fragmentShader =
          R"(precision mediump float;
  varying vec4 color;
  void main()
  {
      gl_FragColor = color;
  }
  )";
  
      ANGLE_GL_PROGRAM(program, vertexShader, fragmentShader);
  
      glUseProgram(program);
  
      GLint color1Loc = glGetAttribLocation(program, "color1");
      GLint color2Loc = glGetAttribLocation(program, "color2");
      ASSERT_NE(-1, color1Loc);
      ASSERT_NE(-1, color2Loc);
  
      const auto &indices = GetQuadIndices();
  
      // Make colored corners with red == x or 1 -x , and green = y or 1 - y.
  
      std::array<GLColor, 4> baseColors1 = {
          {GLColor::black, GLColor::red, GLColor::green, GLColor::yellow}};
      std::array<GLColor, 4> baseColors2 = {
          {GLColor::yellow, GLColor::green, GLColor::red, GLColor::black}};
  
      std::vector<GLColor> colors1;
      std::vector<GLColor> colors2;
  
      for (GLushort index : indices)
      {
          colors1.push_back(baseColors1[index]);
          colors2.push_back(baseColors2[index]);
      }
  
      GLBuffer color1Buffer;
      glBindBuffer(GL_ARRAY_BUFFER, color1Buffer);
      glBufferData(GL_ARRAY_BUFFER, colors1.size() * sizeof(GLColor), colors1.data(), GL_STATIC_DRAW);
      glVertexAttribPointer(color1Loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glEnableVertexAttribArray(color1Loc);
  
      GLBuffer color2Buffer;
      glBindBuffer(GL_ARRAY_BUFFER, color2Buffer);
      glBufferData(GL_ARRAY_BUFFER, colors2.size() * sizeof(GLColor), colors2.data(), GL_STATIC_DRAW);
      glVertexAttribPointer(color2Loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glEnableVertexAttribArray(color2Loc);
  
      // Draw a non-indexed quad with all vertex buffers. Should draw yellow to the entire window.
      drawQuad(program, "position", 0.5f, 1.0f, true);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_RECT_EQ(0, 0, getWindowWidth(), getWindowHeight(), GLColor::yellow);
  }
  
  // Creates a texture, no other operations.
  TEST_P(SimpleOperationTest, CreateTexture2DNoData)
  {
      GLTexture texture;
      glBindTexture(GL_TEXTURE_2D, texture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      ASSERT_GL_NO_ERROR();
  }
  
  // Creates a texture, no other operations.
  TEST_P(SimpleOperationTest, CreateTexture2DWithData)
  {
      std::vector<GLColor> colors(16 * 16, GLColor::red);
  
      GLTexture texture;
      glBindTexture(GL_TEXTURE_2D, texture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
      ASSERT_GL_NO_ERROR();
  }
  
  // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
  ANGLE_INSTANTIATE_TEST(SimpleOperationTest,
                         ES2_D3D9(),
                         ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE),
                         ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE),
                         ES3_D3D11(),
                         ES2_OPENGL(),
                         ES3_OPENGL(),
                         ES2_OPENGLES(),
                         ES3_OPENGLES(),
                         ES2_VULKAN());
  
  } // namespace
  

Download