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

• Show log

  Commit

• Hash : ef0fe638
  Author :
  Date : 2023-01-16T00:00:00
  

  Implement EXT_polygon_offset_clamp
  
  * Added polygonOffsetClamp to the RasterizerState
  * Adjusted State::setPolygonOffsetParams
  * Added PolygonOffsetClampTest end2end tests
  * Added StateChangeTestES3.PolygonOffsetClamp test
  * Suppressed the affected dEQP test as it has a bug
  
  Capture
  * Updated serialized rasterizer state
  * Updated CaptureMidExecutionSetup
  
  OpenGL
  * Rely on the EXT extension defined both
    for desktop and ES contexts
  * On desktops, might as well use the ARB extension
    or GL 4.6 once ANGLE supports them
  
  D3D11
  * Requires FL10_0 or higher
  * Maps to D3D11_RASTERIZER_DESC.DepthBiasClamp
  * Drive-by cleanup of extensions init code
  
  Vulkan
  * Requires depthBiasClamp physical device feature
  * Maps to the depthBiasClamp parameter
    of the vkCmdSetDepthBias command
  
  Metal
  * Maps to the clamp parameter
    of the setDepthBias command
  
  Bug: angleproject:7957
  Change-Id: If6b28df4084f0a81db29f75fb434e75d394c8730
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4169945
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Alexey Knyazev <lexa.knyazev@gmail.com>
  

Download

• src/tests/gl_tests/PolygonOffsetClampTest.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.
  //
  // PolygonOffsetClampTest.cpp: Test cases for GL_EXT_polygon_offset_clamp
  //
  
  #include "test_utils/ANGLETest.h"
  #include "test_utils/gl_raii.h"
  #include "util/EGLWindow.h"
  #include "util/test_utils.h"
  
  using namespace angle;
  
  class PolygonOffsetClampTest : public ANGLETest<>
  {
    protected:
      PolygonOffsetClampTest()
      {
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setConfigDepthBits(24);
          setExtensionsEnabled(false);
      }
  };
  
  // Test state queries and updates
  TEST_P(PolygonOffsetClampTest, State)
  {
      // New state query fails without the extension
      {
          GLfloat clamp = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_CLAMP_EXT, &clamp);
          EXPECT_GL_ERROR(GL_INVALID_ENUM);
          EXPECT_EQ(clamp, -1.0f);
  
          ASSERT_GL_NO_ERROR();
      }
  
      // New function does nothing without enabling the extension
      {
          glPolygonOffsetClampEXT(1.0f, 2.0f, 3.0f);
          EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  
          GLfloat factor = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
          EXPECT_EQ(factor, 0.0f);
  
          GLfloat units = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
          EXPECT_EQ(units, 0.0f);
  
          ASSERT_GL_NO_ERROR();
      }
  
      ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_polygon_offset_clamp"));
  
      // Default state
      {
          GLfloat factor = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
          EXPECT_EQ(factor, 0.0f);
  
          GLfloat units = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
          EXPECT_EQ(units, 0.0f);
  
          GLfloat clamp = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_CLAMP_EXT, &clamp);
          EXPECT_EQ(clamp, 0.0f);
  
          ASSERT_GL_NO_ERROR();
      }
  
      // Full state update using the new function
      {
          glPolygonOffsetClampEXT(1.0f, 2.0f, 3.0f);
  
          GLfloat factor = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
          EXPECT_EQ(factor, 1.0f);
  
          GLfloat units = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
          EXPECT_EQ(units, 2.0f);
  
          GLfloat clamp = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_CLAMP_EXT, &clamp);
          EXPECT_EQ(clamp, 3.0f);
  
          ASSERT_GL_NO_ERROR();
      }
  
      // Core function resets the clamp value to zero
      {
          glPolygonOffset(4.0f, 5.0f);
  
          GLfloat factor = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
          EXPECT_EQ(factor, 4.0f);
  
          GLfloat units = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
          EXPECT_EQ(units, 5.0f);
  
          GLfloat clamp = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_CLAMP_EXT, &clamp);
          EXPECT_EQ(clamp, 0.0f);
  
          ASSERT_GL_NO_ERROR();
      }
  
      // NaNs must be accepted and replaced with zeros
      {
          glPolygonOffsetClampEXT(6.0f, 7.0f, 8.0f);
  
          float nan = std::numeric_limits<float>::quiet_NaN();
          glPolygonOffsetClampEXT(nan, nan, nan);
  
          GLfloat factor = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
          EXPECT_EQ(factor, 0.0f);
  
          GLfloat units = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
          EXPECT_EQ(units, 0.0f);
  
          GLfloat clamp = -1.0f;
          glGetFloatv(GL_POLYGON_OFFSET_CLAMP_EXT, &clamp);
          EXPECT_EQ(clamp, 0.0f);
  
          ASSERT_GL_NO_ERROR();
      }
  }
  
  // Test polygon offset clamping behavior. Ported from dEQP.
  TEST_P(PolygonOffsetClampTest, Operation)
  {
      ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_polygon_offset_clamp"));
      ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_depth_texture"));
  
      GLTexture depthTexture;
      glBindTexture(GL_TEXTURE_2D, depthTexture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 64, 64, 0, GL_DEPTH_COMPONENT,
                   GL_UNSIGNED_SHORT, nullptr);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      GLTexture colorTexture;
      glBindTexture(GL_TEXTURE_2D, colorTexture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      GLFramebuffer fbo;
      glBindFramebuffer(GL_FRAMEBUFFER, fbo);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTexture, 0);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0);
  
      GLTexture colorReadbackTexture;
      glBindTexture(GL_TEXTURE_2D, colorReadbackTexture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      GLFramebuffer fboReadback;
      glBindFramebuffer(GL_FRAMEBUFFER, fboReadback);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             colorReadbackTexture, 0);
  
      ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
  
      constexpr char kFS[] = R"(
  varying highp vec2 v_texCoord;
  uniform highp sampler2D tex;
  void main()
  {
      // Store as unorm24
      highp float d = floor(texture2D(tex, v_texCoord).r * 16777215.0);
      highp float r = floor(d / 65536.0);
      highp float g = floor(mod(d, 65536.0) / 256.0);
      highp float b = mod(d, 256.0);
      gl_FragColor = vec4(r, g, b, 1.0) / 255.0;
  })";
  
      ANGLE_GL_PROGRAM(readDepthProgram, essl1_shaders::vs::Texture2D(), kFS);
  
      // Setup depth testing
      glEnable(GL_DEPTH_TEST);
      glDepthFunc(GL_ALWAYS);
  
      // Bind framebuffer for drawing
      glBindFramebuffer(GL_FRAMEBUFFER, fbo);
  
      // Offset units and clamp values. Should work with all depth buffer formats.
      const std::vector<std::array<GLfloat, 2>> testValues = {
          {-5000.0f, -0.0001f},
          {+5000.0f, +0.0001f},
          {-5000.0f, 0.0f},
          {+5000.0f, 0.0f},
          {-5000.0f, -std::numeric_limits<float>::infinity()},
          {+5000.0f, +std::numeric_limits<float>::infinity()}};
  
      auto readDepthValue = [&]() {
          glBindFramebuffer(GL_FRAMEBUFFER, fboReadback);
          glDisable(GL_DEPTH_TEST);
          glUseProgram(readDepthProgram);
          glUniform1i(glGetUniformLocation(readDepthProgram, "tex"), 0);
  
          glBindTexture(GL_TEXTURE_2D, depthTexture);
          drawQuad(readDepthProgram, "a_position", 0.5);
  
          GLubyte pixels[4];
          glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
  
          // Convert read depth value to GLfloat normalized
          GLfloat depthValue = (GLfloat)(pixels[0] * 65536 + pixels[1] * 256 + pixels[2]) / 0xFFFFFF;
  
          // Restore state
          glBindFramebuffer(GL_FRAMEBUFFER, fbo);
          glEnable(GL_DEPTH_TEST);
          glUseProgram(testProgram);
  
          return depthValue;
      };
  
      for (auto testValue : testValues)
      {
          const GLfloat units = testValue[0];
          const GLfloat clamp = testValue[1];
  
          // Draw reference polygon
          glDisable(GL_POLYGON_OFFSET_FILL);
          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
          drawQuad(testProgram, "a_position", 0.0);
  
          // Get reference depth value
          const GLfloat depthValue = readDepthValue();
  
          // Draw polygon with depth offset
          glEnable(GL_POLYGON_OFFSET_FILL);
          glPolygonOffset(0.0f, units);
          drawQuad(testProgram, "a_position", 0.0);
  
          // Get depth value with offset
          const GLfloat depthValueOffset = readDepthValue();
  
          // Draw reference polygon
          glDisable(GL_POLYGON_OFFSET_FILL);
          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
          drawQuad(testProgram, "a_position", 0.0);
  
          // Draw polygon with depth offset
          glEnable(GL_POLYGON_OFFSET_FILL);
          glPolygonOffsetClampEXT(0.0f, units, clamp);
          drawQuad(testProgram, "a_position", 0.0);
  
          // Get depth value with clamped offset
          const GLfloat depthValueOffsetClamp = readDepthValue();
  
          // Check depth values
          {
              if (clamp == 0.0f || isinf(clamp))
              {
                  ASSERT_NE(units, 0.0f);
  
                  // Ensure that offset works
                  if (units > 0.0f)
                  {
                      EXPECT_LT(depthValue, depthValueOffset);
                      EXPECT_LT(depthValue, depthValueOffsetClamp);
                  }
                  else if (units < 0.0f)
                  {
                      EXPECT_GT(depthValue, depthValueOffset);
                      EXPECT_GT(depthValue, depthValueOffsetClamp);
                  }
  
                  // Clamping must have no effect
                  EXPECT_EQ(depthValueOffset, depthValueOffsetClamp);
              }
              else if (clamp < 0.0f)
              {
                  ASSERT_LT(units, 0);
  
                  // Negative clamp value sets effective offset to max(offset, clamp)
                  EXPECT_GT(depthValue, depthValueOffset);
                  EXPECT_GT(depthValue, depthValueOffsetClamp);
                  EXPECT_LT(depthValueOffset, depthValueOffsetClamp);
              }
              else if (clamp > 0.0f)
              {
                  ASSERT_GT(units, 0);
  
                  // Positive clamp value sets effective offset to min(offset, clamp)
                  EXPECT_LT(depthValue, depthValueOffset);
                  EXPECT_LT(depthValue, depthValueOffsetClamp);
                  EXPECT_GT(depthValueOffset, depthValueOffsetClamp);
              }
          }
      }
  }
  
  ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(PolygonOffsetClampTest);
  

Download