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

• Show log

  Commit

• Hash : a20af6d7
  Author :
  Date : 2017-09-18T13:32:29
  

  Use C++11 raw string literals instead of SHADER_SOURCE macro
  
  This is better in many ways:
  1. It doesn't confuse clang format
  2. \n doesn't need to be included after preprocessor directives like
     the version directive.
  3. It's using built-in functionality instead of something custom.
  
  Raw string literals should be the preferred way to include shader
  source in C++ files going forward.
  
  BUG=angleproject:2157
  TEST=angle_end2end_tests
  
  Change-Id: I8b236a6e2d5c25d920297e5bc5b5b143eddeba1f
  Reviewed-on: https://chromium-review.googlesource.com/671046
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/tests/gl_tests/UnpackRowLength.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.
  //
  
  #include "test_utils/ANGLETest.h"
  
  using namespace angle;
  
  namespace
  {
  
  class UnpackRowLengthTest : public ANGLETest
  {
    protected:
      UnpackRowLengthTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setConfigDepthBits(24);
  
          mProgram = 0;
      }
  
      void SetUp() override
      {
          ANGLETest::SetUp();
  
          const std::string vertexShaderSource =
              R"(precision highp float;
              attribute vec4 position;
  
              void main()
              {
                  gl_Position = position;
              })";
  
          const std::string fragmentShaderSource =
              R"(uniform sampler2D tex;
  
              void main()
              {
                  gl_FragColor = texture2D(tex, vec2(0.0, 1.0));
              })";
  
          mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
          if (mProgram == 0)
          {
              FAIL() << "shader compilation failed.";
          }
      }
  
      void TearDown() override
      {
          glDeleteProgram(mProgram);
  
          ANGLETest::TearDown();
      }
  
      void testRowLength(int texSize, int rowLength)
      {
          glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength);
  
          if ((getClientMajorVersion() == 3) || extensionEnabled("GL_EXT_unpack_subimage"))
          {
              // Only texSize * texSize region is filled as WHITE, other parts are BLACK.
              // If the UNPACK_ROW_LENGTH is implemented correctly, all texels inside this texture are WHITE.
              std::vector<GLubyte> buf(rowLength * texSize * 4);
              for (int y = 0; y < texSize; y++)
              {
                  std::vector<GLubyte>::iterator rowIter = buf.begin() + y * rowLength * 4;
                  std::fill(rowIter, rowIter + texSize * 4, static_cast<GLubyte>(255u));
                  std::fill(rowIter + texSize * 4, rowIter + rowLength * 4, static_cast<GLubyte>(0u));
              }
  
              GLuint tex;
              glGenTextures(1, &tex);
              glBindTexture(GL_TEXTURE_2D, tex);
  
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texSize, texSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buf[0]);
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  
              drawQuad(mProgram, "position", 0.5f);
  
              EXPECT_PIXEL_EQ(0, 0, 255, 255, 255, 255);
              EXPECT_PIXEL_EQ(1, 0, 255, 255, 255, 255);
  
              glDeleteTextures(1, &tex);
          }
          else
          {
              EXPECT_GL_ERROR(GL_INVALID_ENUM);
          }
      }
  
      GLuint mProgram;
  };
  
  TEST_P(UnpackRowLengthTest, RowLength128)
  {
      testRowLength(128, 128);
  }
  
  TEST_P(UnpackRowLengthTest, RowLength1024)
  {
      testRowLength(128, 1024);
  }
  
  // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
  ANGLE_INSTANTIATE_TEST(UnpackRowLengthTest,
                         ES3_D3D11(),
                         ES2_D3D11(),
                         ES2_D3D9(),
                         ES2_OPENGL(),
                         ES3_OPENGL(),
                         ES2_OPENGLES(),
                         ES3_OPENGLES());
  
  } // namespace
  

Download