kc3-lang/angle/src/tests/capture_tests/CapturedTest.cpp

• Show log

  Commit

• Hash : e3a58b25
  Author :
  Date : 2024-04-11T09:33:55
  

  FrameCapture: Support deferred linking of shaders
  
  Modern Combat 5 creates and attaches programs and shaders but
  defers compiling and linking until needed. Added support in
  the tracer for this corner case and updated CapturedTest
  to exercise this behavior as well.
  
  Test: angle_end2end_tests --gtest_filter=CapturedTest.MultiFrame/ES3_Vulkan
  Bug: b/334030316
  Change-Id: Ib7fdf0fe25b11cdb3df33d50e49501f3a51e9510
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5449599
  Commit-Queue: Mark Łobodziński <mark@lunarg.com>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/tests/capture_tests/CapturedTest.cpp

• //
  // Copyright 2023 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"
  
  #include "test_utils/gl_raii.h"
  #include "util/random_utils.h"
  #include "util/shader_utils.h"
  #include "util/test_utils.h"
  
  using namespace angle;
  
  namespace
  {
  class CapturedTest : public ANGLETest<>
  {
    protected:
      CapturedTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setConfigDepthBits(24);
          setConfigStencilBits(8);
      }
  
      void testSetUp() override
      {
          // Calls not captured because we setup Start frame to MEC.
  
          // TODO: why are these framebuffers not showing up in the capture?
  
          mFBOs.resize(2, 0);
          glGenFramebuffers(2, mFBOs.data());
  
          constexpr char kInactiveVS[] = R"(precision highp float;
  void main(void) {
     gl_Position = vec4(0.5, 0.5, 0.5, 1.0);
  })";
  
          static constexpr char kInactiveDeferredVS[] = R"(attribute vec4 a_position;
  attribute vec2 a_texCoord;
  varying vec2 v_texCoord;
  void main()
  {
      gl_Position = a_position;
      v_texCoord = a_texCoord;
  })";
  
          static constexpr char kInactiveDeferredFS[] = R"(precision mediump float;
  varying vec2 v_texCoord;
  uniform sampler2D s_texture;
  void main()
  {
      gl_FragColor = vec4(0.4, 0.4, 0.4, 1.0);
      gl_FragColor = texture2D(s_texture, v_texCoord);
  })";
  
          static constexpr char kActiveDeferredVS[] = R"(attribute vec4 a_position;
  attribute vec2 a_texCoord;
  varying vec2 v_texCoord;
  void main()
  {
      gl_Position = a_position;
      v_texCoord = a_texCoord;
  })";
  
          // Create shaders, program but defer compiling & linking, use before capture starts
          // (Inactive)
          lateLinkTestVertShaderInactive                   = glCreateShader(GL_VERTEX_SHADER);
          const char *lateLinkTestVsSourceArrayInactive[1] = {kInactiveDeferredVS};
          glShaderSource(lateLinkTestVertShaderInactive, 1, lateLinkTestVsSourceArrayInactive, 0);
          lateLinkTestFragShaderInactive                   = glCreateShader(GL_FRAGMENT_SHADER);
          const char *lateLinkTestFsSourceArrayInactive[1] = {kInactiveDeferredFS};
          glShaderSource(lateLinkTestFragShaderInactive, 1, lateLinkTestFsSourceArrayInactive, 0);
          lateLinkTestProgramInactive = glCreateProgram();
          glAttachShader(lateLinkTestProgramInactive, lateLinkTestVertShaderInactive);
          glAttachShader(lateLinkTestProgramInactive, lateLinkTestFragShaderInactive);
  
          // Create inactive program having shader shared with deferred linked program
          glCompileShader(lateLinkTestVertShaderInactive);
          glCompileShader(lateLinkTestFragShaderInactive);
          glLinkProgram(lateLinkTestProgramInactive);
          ASSERT_GL_NO_ERROR();
  
          // Create vertex shader and program but defer compiling & linking until capture time
          // (Active) Use fragment shader attached to inactive program
          lateLinkTestVertShaderActive                   = glCreateShader(GL_VERTEX_SHADER);
          const char *lateLinkTestVsSourceArrayActive[1] = {kActiveDeferredVS};
          glShaderSource(lateLinkTestVertShaderActive, 1, lateLinkTestVsSourceArrayActive, 0);
          lateLinkTestProgramActive = glCreateProgram();
          glAttachShader(lateLinkTestProgramActive, lateLinkTestVertShaderActive);
          glAttachShader(lateLinkTestProgramActive, lateLinkTestFragShaderInactive);
          ASSERT_GL_NO_ERROR();
  
          // Create shader that is unused during capture
          inactiveProgram                    = glCreateProgram();
          inactiveShader                     = glCreateShader(GL_VERTEX_SHADER);
          const char *inactiveSourceArray[1] = {kInactiveVS};
          glShaderSource(inactiveShader, 1, inactiveSourceArray, 0);
          glCompileShader(inactiveShader);
          glAttachShader(inactiveProgram, inactiveShader);
  
          // Create Shader Program before capture begins to use during capture
          activeBeforeProgram                = glCreateProgram();
          activeBeforeVertShader             = glCreateShader(GL_VERTEX_SHADER);
          activeBeforeFragShader             = glCreateShader(GL_FRAGMENT_SHADER);
          const char *activeVsSourceArray[1] = {kActiveVS};
          glShaderSource(activeBeforeVertShader, 1, activeVsSourceArray, 0);
          glCompileShader(activeBeforeVertShader);
          glAttachShader(activeBeforeProgram, activeBeforeVertShader);
          const char *activeFsSourceArray[1] = {kActiveFS};
          glShaderSource(activeBeforeFragShader, 1, activeFsSourceArray, 0);
          glCompileShader(activeBeforeFragShader);
          glAttachShader(activeBeforeProgram, activeBeforeFragShader);
          glLinkProgram(activeBeforeProgram);
  
          // Get the attr/sampler locations
          mPositionLoc = glGetAttribLocation(activeBeforeProgram, "a_position");
          mTexCoordLoc = glGetAttribLocation(activeBeforeProgram, "a_texCoord");
          mSamplerLoc  = glGetUniformLocation(activeBeforeProgram, "s_texture");
          glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  
          // Bind the texture object before capture begins
          glGenTextures(1, &textureNeverBound);
          glGenTextures(1, &textureBoundBeforeCapture);
          glBindTexture(GL_TEXTURE_2D, textureBoundBeforeCapture);
          ASSERT_GL_NO_ERROR();
  
          const size_t width                 = 2;
          const size_t height                = 2;
          GLubyte pixels[width * height * 3] = {
              255, 0,   0,    // Red
              0,   255, 0,    // Green
              0,   0,   255,  // Blue
              255, 255, 0,    // Yellow
          };
          // Populate the pre-capture bound texture
          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      }
  
      void testTearDown() override
      {
          // Not reached during capture as we hit the End frame earlier.
  
          if (!mFBOs.empty())
          {
              glDeleteFramebuffers(static_cast<GLsizei>(mFBOs.size()), mFBOs.data());
          }
  
          glDeleteTextures(1, &textureNeverBound);
          glDeleteTextures(1, &textureBoundBeforeCapture);
          glDeleteProgram(inactiveProgram);
          glDeleteProgram(activeBeforeProgram);
          glDeleteShader(inactiveShader);
          glDeleteShader(activeBeforeVertShader);
          glDeleteShader(activeBeforeFragShader);
          glDeleteProgram(lateLinkTestProgramInactive);
          glDeleteProgram(lateLinkTestProgramActive);
          glDeleteShader(lateLinkTestVertShaderInactive);
          glDeleteShader(lateLinkTestFragShaderInactive);
          glDeleteShader(lateLinkTestVertShaderActive);
      }
  
      static constexpr char kActiveVS[] = R"(attribute vec4 a_position;
  attribute vec2 a_texCoord;
  varying vec2 v_texCoord;
  void main()
  {
      gl_Position = a_position;
      v_texCoord = a_texCoord;
  })";
  
      static constexpr char kActiveFS[] = R"(precision mediump float;
  varying vec2 v_texCoord;
  uniform sampler2D s_texture;
  void main()
  {
      gl_FragColor = texture2D(s_texture, v_texCoord);
  })";
  
      void frame1();
      void frame2();
      void frame3();
      void frame4();
  
      std::vector<GLuint> mFBOs;
  
      // For testing deferred compile/link
      GLuint lateLinkTestVertShaderInactive;
      GLuint lateLinkTestFragShaderInactive;
      GLuint lateLinkTestProgramInactive;
      GLuint lateLinkTestVertShaderActive;
      GLuint lateLinkTestProgramActive;
  
      GLuint inactiveProgram;
      GLuint inactiveShader;
  
      GLuint activeBeforeProgram;
      GLuint activeBeforeVertShader;
      GLuint activeBeforeFragShader;
  
      GLuint textureNeverBound;
      GLuint textureBoundBeforeCapture;
      GLuint mPositionLoc;
      GLuint mTexCoordLoc;
      GLint mSamplerLoc;
  };
  
  void CapturedTest::frame1()
  {
      glClearColor(0.25f, 0.5f, 0.5f, 0.5f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_NEAR(0, 0, 64, 128, 128, 128, 1.0);
  
      GLfloat vertices[] = {
          -0.75f, 0.25f,  0.0f,  // Position 0
          0.0f,   0.0f,          // TexCoord 0
          -0.75f, -0.75f, 0.0f,  // Position 1
          0.0f,   1.0f,          // TexCoord 1
          0.25f,  -0.75f, 0.0f,  // Position 2
          1.0f,   1.0f,          // TexCoord 2
          0.25f,  0.25f,  0.0f,  // Position 3
          1.0f,   0.0f           // TexCoord 3
      };
  
      GLushort indices[] = {0, 1, 2, 0, 2, 3};
  
      glClear(GL_COLOR_BUFFER_BIT);
      glUseProgram(activeBeforeProgram);
      glVertexAttribPointer(mPositionLoc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vertices);
      glVertexAttribPointer(mTexCoordLoc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vertices + 3);
      glEnableVertexAttribArray(mPositionLoc);
      glEnableVertexAttribArray(mTexCoordLoc);
      glUniform1i(mSamplerLoc, 0);
  
      // Draw without binding texture during capture
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
      EXPECT_PIXEL_EQ(20, 20, 0, 0, 255, 255);
  
      glDeleteVertexArrays(1, &mPositionLoc);
      glDeleteVertexArrays(1, &mTexCoordLoc);
  }
  
  void CapturedTest::frame2()
  {
      // Draw using texture created and bound during capture
  
      GLuint activeDuringProgram;
      GLuint activeDuringVertShader;
      GLuint activeDuringFragShader;
      GLuint positionLoc;
      GLuint texCoordLoc;
      GLuint textureBoundDuringCapture;
      GLint samplerLoc;
  
      activeDuringProgram                = glCreateProgram();
      activeDuringVertShader             = glCreateShader(GL_VERTEX_SHADER);
      activeDuringFragShader             = glCreateShader(GL_FRAGMENT_SHADER);
      const char *activeVsSourceArray[1] = {kActiveVS};
      glShaderSource(activeDuringVertShader, 1, activeVsSourceArray, 0);
      glCompileShader(activeDuringVertShader);
      glAttachShader(activeDuringProgram, activeDuringVertShader);
      const char *activeFsSourceArray[1] = {kActiveFS};
      glShaderSource(activeDuringFragShader, 1, activeFsSourceArray, 0);
      glCompileShader(activeDuringFragShader);
      glAttachShader(activeDuringProgram, activeDuringFragShader);
      glLinkProgram(activeDuringProgram);
  
      // Get the attr/sampler locations
      positionLoc = glGetAttribLocation(activeDuringProgram, "a_position");
      texCoordLoc = glGetAttribLocation(activeDuringProgram, "a_texCoord");
      samplerLoc  = glGetUniformLocation(activeDuringProgram, "s_texture");
      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  
      // Bind the texture object during capture
      glGenTextures(1, &textureBoundDuringCapture);
      glBindTexture(GL_TEXTURE_2D, textureBoundDuringCapture);
      ASSERT_GL_NO_ERROR();
  
      const size_t width                 = 2;
      const size_t height                = 2;
      GLubyte pixels[width * height * 3] = {
          255, 255, 0,    // Yellow
          0,   0,   255,  // Blue
          0,   255, 0,    // Green
          255, 0,   0,    // Red
      };
  
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      GLfloat vertices[] = {
          -0.25f, 0.75f,  0.0f,  // Position 0
          0.0f,   0.0f,          // TexCoord 0
          -0.25f, -0.25f, 0.0f,  // Position 1
          0.0f,   1.0f,          // TexCoord 1
          0.75f,  -0.25f, 0.0f,  // Position 2
          1.0f,   1.0f,          // TexCoord 2
          0.75f,  0.75f,  0.0f,  // Position 3
          1.0f,   0.0f           // TexCoord 3
      };
      GLushort indices[] = {0, 1, 2, 0, 2, 3};
  
      glClear(GL_COLOR_BUFFER_BIT);
      glUseProgram(activeDuringProgram);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vertices);
      glVertexAttribPointer(texCoordLoc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vertices + 3);
      glEnableVertexAttribArray(positionLoc);
      glEnableVertexAttribArray(texCoordLoc);
      glUniform1i(samplerLoc, 0);
  
      // Draw using texture bound during capture
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
      EXPECT_PIXEL_EQ(108, 108, 0, 0, 255, 255);
  
      glDeleteTextures(1, &textureBoundDuringCapture);
      glDeleteVertexArrays(1, &positionLoc);
      glDeleteVertexArrays(1, &texCoordLoc);
      glDeleteProgram(activeDuringProgram);
      glDeleteShader(activeDuringVertShader);
      glDeleteShader(activeDuringFragShader);
  }
  
  void CapturedTest::frame3()
  {
      // TODO: using local objects (with RAII helpers) here that create and destroy objects within the
      // frame. Maybe move some of this to test Setup.
  
      constexpr char kVS[] = R"(precision highp float;
  attribute vec3 attr1;
  void main(void) {
     gl_Position = vec4(attr1, 1.0);
  })";
  
      constexpr char kFS[] = R"(precision highp float;
  void main(void) {
     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
  })";
  
      GLBuffer emptyBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, emptyBuffer);
  
      ANGLE_GL_PROGRAM(program, kVS, kFS);
      glBindAttribLocation(program, 0, "attr1");
      glLinkProgram(program);
      ASSERT_TRUE(CheckLinkStatusAndReturnProgram(program, true));
      glUseProgram(program);
  
      // Use non-existing attribute 1.
      glEnableVertexAttribArray(1);
      glVertexAttribPointer(1, 3, GL_UNSIGNED_BYTE, false, 1, 0);
  
      glDrawArrays(GL_TRIANGLES, 0, 3);
      EXPECT_GL_NO_ERROR();
  
      // Note: RAII destructors called here causing additional GL calls.
  }
  
  void CapturedTest::frame4()
  {
      GLuint positionLoc;
      GLuint texCoordLoc;
      GLuint lateLinkTestTexture;
      GLint samplerLoc;
  
      // Deferred compile/link
      glCompileShader(lateLinkTestVertShaderActive);
      glLinkProgram(lateLinkTestProgramActive);
      ASSERT_GL_NO_ERROR();
  
      // Get the attr/sampler locations
      positionLoc = glGetAttribLocation(lateLinkTestProgramActive, "a_position");
      texCoordLoc = glGetAttribLocation(lateLinkTestProgramActive, "a_texCoord");
      samplerLoc  = glGetUniformLocation(lateLinkTestProgramActive, "s_texture");
      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  
      // Bind the texture object during capture
      glGenTextures(1, &lateLinkTestTexture);
      glBindTexture(GL_TEXTURE_2D, lateLinkTestTexture);
      ASSERT_GL_NO_ERROR();
  
      const size_t width                 = 2;
      const size_t height                = 2;
      GLubyte pixels[width * height * 3] = {
          255, 255, 0,    // Yellow
          0,   0,   255,  // Blue
          0,   255, 0,    // Green
          255, 0,   0,    // Red
      };
  
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      GLfloat vertices[] = {
          -0.25f, 0.75f,  0.0f,  // Position 0
          0.0f,   0.0f,          // TexCoord 0
          -0.25f, -0.25f, 0.0f,  // Position 1
          0.0f,   1.0f,          // TexCoord 1
          0.75f,  -0.25f, 0.0f,  // Position 2
          1.0f,   1.0f,          // TexCoord 2
          0.75f,  0.75f,  0.0f,  // Position 3
          1.0f,   0.0f           // TexCoord 3
      };
      GLushort indices[] = {0, 1, 2, 0, 2, 3};
  
      glClear(GL_COLOR_BUFFER_BIT);
      glUseProgram(lateLinkTestProgramActive);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vertices);
      glVertexAttribPointer(texCoordLoc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vertices + 3);
      glEnableVertexAttribArray(positionLoc);
      glEnableVertexAttribArray(texCoordLoc);
      glUniform1i(samplerLoc, 0);
  
      // Draw shaders & program created before capture
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
      EXPECT_PIXEL_EQ(108, 108, 0, 0, 255, 255);
  }
  
  // Test captured by capture_tests.py
  TEST_P(CapturedTest, MultiFrame)
  {
      // Swap before the first frame so that setup gets its own frame
      swapBuffers();
      frame1();
  
      swapBuffers();
      frame2();
  
      swapBuffers();
      frame3();
  
      swapBuffers();
      frame4();
  
      // Empty frames to reach capture end.
      for (int i = 0; i < 10; i++)
      {
          swapBuffers();
      }
      // Note: test teardown adds an additonal swap in
      // ANGLETestBase::ANGLETestPreTearDown() when --angle-per-test-capture-label
  }
  
  GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(CapturedTest);
  // Capture is only supported on the Vulkan backend
  ANGLE_INSTANTIATE_TEST(CapturedTest, ES3_VULKAN());
  
  }  // anonymous namespace
  

Download