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

• Show log

  Commit

• Hash : 3f2e61de
  Author :
  Date : 2014-09-05T10:38:05
  

  Enable MRT pixel shader rewriting.
  
  Writing to all 8 pixel outputs was causing performance problems on
  Intel and AMD. Enabling Geoff's work to rewrite our pixel shaders
  solves the regression.
  
  This patch also includes a workaround to the nVidia driver bug
  where it would ignore NULL RT values in OMSetRenderTargets, by
  compacting the RT list to skip NULL values.
  
  BUG=angle:705
  BUG=365078
  
  Change-Id: Ia68af6f0ccd5f10c484d6f76297a0bec694948f0
  Reviewed-on: https://chromium-review.googlesource.com/214852
  Tested-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• tests/angle_tests/DrawBuffersTest.cpp

• #include "ANGLETest.h"
  
  class DrawBuffersTest : public ANGLETest
  {
    protected:
      DrawBuffersTest(int clientVersion)
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setConfigDepthBits(24);
          setClientVersion(clientVersion);
      }
  
      virtual void SetUp()
      {
          ANGLETest::SetUp();
  
          glGenFramebuffers(1, &mFBO);
          glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
  
          glGenTextures(4, mTextures);
  
          for (size_t texIndex = 0; texIndex < ArraySize(mTextures); texIndex++)
          {
              glBindTexture(GL_TEXTURE_2D, mTextures[texIndex]);
              glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, getWindowWidth(), getWindowHeight());
          }
  
          GLfloat data[] =
          {
              -1.0f, 1.0f,
              -1.0f, -2.0f,
              2.0f, 1.0f
          };
  
          glGenBuffers(1, &mBuffer);
          glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
          glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6, data, GL_STATIC_DRAW);
  
          GLint maxDrawBuffers;
          glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
          ASSERT_EQ(maxDrawBuffers, 8);
  
          ASSERT_GL_NO_ERROR();
      }
  
      virtual void TearDown()
      {
          glDeleteFramebuffers(1, &mFBO);
          glDeleteTextures(4, mTextures);
          glDeleteBuffers(1, &mBuffer);
  
          ANGLETest::TearDown();
      }
  
      void setupMRTProgramESSL3(bool bufferEnabled[8], GLuint *programOut)
      {
          const std::string vertexShaderSource =
              "#version 300 es\n"
              "in vec4 position;\n"
              "void main() {\n"
              "    gl_Position = position;\n"
              "}\n";
  
          std::stringstream strstr;
  
          strstr << "#version 300 es\n"
                    "precision highp float;\n";
  
          for (unsigned int index = 0; index < 8; index++)
          {
              if (bufferEnabled[index])
              {
                  strstr << "layout(location = " << index << ") "
                            "out vec4 value" << index << ";\n";
              }
          }
  
          strstr << "void main()\n"
                    "{\n";
  
          for (unsigned int index = 0; index < 8; index++)
          {
              if (bufferEnabled[index])
              {
                  unsigned int r = (index + 1) & 1;
                  unsigned int g = (index + 1) & 2;
                  unsigned int b = (index + 1) & 4;
  
                  strstr << "    value" << index << " = vec4("
                         << r << ".0, " << g << ".0, "
                         << b << ".0, 1.0);\n";
              }
          }
  
          strstr << "}\n";
  
          *programOut = CompileProgram(vertexShaderSource, strstr.str());
          if (*programOut == 0)
          {
              FAIL() << "shader compilation failed.";
          }
  
          glUseProgram(*programOut);
  
          GLint location = glGetAttribLocation(*programOut, "position");
          ASSERT_NE(location, -1);
          glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
          glVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 8, NULL);
          glEnableVertexAttribArray(location);
      }
  
      void setupMRTProgramESSL1(bool bufferEnabled[8], GLuint *programOut)
      {
          const std::string vertexShaderSource =
              "attribute vec4 position;\n"
              "void main() {\n"
              "    gl_Position = position;\n"
              "}\n";
  
          std::stringstream strstr;
  
          strstr << "#extension GL_EXT_draw_buffers : enable\n"
                    "precision highp float;\n"
                    "void main()\n"
                    "{\n";
  
          for (unsigned int index = 0; index < 8; index++)
          {
              if (bufferEnabled[index])
              {
                  unsigned int r = (index + 1) & 1;
                  unsigned int g = (index + 1) & 2;
                  unsigned int b = (index + 1) & 4;
  
                  strstr << "    gl_FragData[" << index << "] = vec4("
                      << r << ".0, " << g << ".0, "
                      << b << ".0, 1.0);\n";
              }
          }
  
          strstr << "}\n";
  
          *programOut = CompileProgram(vertexShaderSource, strstr.str());
          if (*programOut == 0)
          {
              FAIL() << "shader compilation failed.";
          }
  
          glUseProgram(*programOut);
  
          GLint location = glGetAttribLocation(*programOut, "position");
          ASSERT_NE(location, -1);
          glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
          glVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 8, NULL);
          glEnableVertexAttribArray(location);
      }
  
      void setupMRTProgram(bool bufferEnabled[8], GLuint *programOut)
      {
          if (getClientVersion() == 3)
          {
              setupMRTProgramESSL3(bufferEnabled, programOut);
          }
          else
          {
              ASSERT_EQ(getClientVersion(), 2);
              setupMRTProgramESSL1(bufferEnabled, programOut);
          }
      }
  
      void verifyAttachment(unsigned int index, GLuint textureName)
      {
          for (unsigned int colorAttachment = 0; colorAttachment < 8; colorAttachment++)
          {
              glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + colorAttachment, GL_TEXTURE_2D, 0, 0);
          }
  
          glBindTexture(GL_TEXTURE_2D, textureName);
          glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);
  
          unsigned int r = (((index + 1) & 1) > 0) ? 255 : 0;
          unsigned int g = (((index + 1) & 2) > 0) ? 255 : 0;
          unsigned int b = (((index + 1) & 4) > 0) ? 255 : 0;
  
          EXPECT_PIXEL_EQ(getWindowWidth() / 2, getWindowHeight() / 2, r, g, b, 255);
      }
  
      void gapsTest()
      {
          glBindTexture(GL_TEXTURE_2D, mTextures[0]);
          glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, mTextures[0], 0);
  
          bool flags[8] = { false, true };
  
          GLuint program;
          setupMRTProgram(flags, &program);
  
          const GLenum bufs[] =
          {
              GL_NONE,
              GL_COLOR_ATTACHMENT1
          };
          glUseProgram(program);
          glDrawBuffersEXT(2, bufs);
          glDrawArrays(GL_TRIANGLES, 0, 3);
  
          verifyAttachment(1, mTextures[0]);
  
          glDeleteProgram(program);
      }
  
      void firstAndLastTest()
      {
          glBindTexture(GL_TEXTURE_2D, mTextures[0]);
          glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
  
          glBindTexture(GL_TEXTURE_2D, mTextures[1]);
          glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_2D, mTextures[1], 0);
  
          bool flags[8] = { true, false, false, true };
  
          GLuint program;
          setupMRTProgram(flags, &program);
  
          const GLenum bufs[] =
          {
              GL_COLOR_ATTACHMENT0,
              GL_NONE,
              GL_NONE,
              GL_COLOR_ATTACHMENT3
          };
  
          glUseProgram(program);
          glDrawBuffersEXT(4, bufs);
          glDrawArrays(GL_TRIANGLES, 0, 3);
  
          verifyAttachment(0, mTextures[0]);
          verifyAttachment(3, mTextures[1]);
  
          EXPECT_GL_NO_ERROR();
  
          glDeleteProgram(program);
      }
  
      void firstHalfNULLTest()
      {
          bool flags[8] = { false };
          GLenum bufs[8] = { GL_NONE };
  
          for (unsigned int texIndex = 0; texIndex < 4; texIndex++)
          {
              glBindTexture(GL_TEXTURE_2D, mTextures[texIndex]);
              glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT4 + texIndex, GL_TEXTURE_2D, mTextures[texIndex], 0);
              flags[texIndex + 4] = true;
              bufs[texIndex + 4] = GL_COLOR_ATTACHMENT4 + texIndex;
          }
  
          GLuint program;
          setupMRTProgram(flags, &program);
  
          glUseProgram(program);
          glDrawBuffersEXT(8, bufs);
          glDrawArrays(GL_TRIANGLES, 0, 3);
  
          for (unsigned int texIndex = 0; texIndex < 4; texIndex++)
          {
              verifyAttachment(texIndex + 4, mTextures[texIndex]);
          }
  
          EXPECT_GL_NO_ERROR();
  
          glDeleteProgram(program);
      }
  
      GLuint mFBO;
      GLuint mTextures[4];
      GLuint mBuffer;
  };
  
  class DrawBuffersTestESSL3 : public DrawBuffersTest
  {
    protected:
      DrawBuffersTestESSL3()
          : DrawBuffersTest(3)
      {}
  };
  
  class DrawBuffersTestESSL1 : public DrawBuffersTest
  {
    protected:
      DrawBuffersTestESSL1()
          : DrawBuffersTest(2)
      {}
  };
  
  TEST_F(DrawBuffersTestESSL3, Gaps)
  {
      gapsTest();
  }
  
  TEST_F(DrawBuffersTestESSL1, Gaps)
  {
      gapsTest();
  }
  
  TEST_F(DrawBuffersTestESSL3, FirstAndLast)
  {
      firstAndLastTest();
  }
  
  TEST_F(DrawBuffersTestESSL1, FirstAndLast)
  {
      firstAndLastTest();
  }
  
  TEST_F(DrawBuffersTestESSL3, FirstHalfNULL)
  {
      firstHalfNULLTest();
  }
  
  TEST_F(DrawBuffersTestESSL1, FirstHalfNULL)
  {
      firstHalfNULLTest();
  }
  

Download