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

Branch - branch -main

• Show log

  Commit

• Hash : 0cbc0fe4
  Author :
  Date : 2024-05-30T00:00:00
  

  Add IncompatibleTexture end2end tests
  
  Bug: angleproject:343922404
  Change-Id: Ic96cc1e2493454844ef65ec799e1aba221d9f084
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5589245
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/tests/gl_tests/IncompatibleTextureTest.cpp

• //
  // Copyright 2024 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.
  //
  // These tests assert that textures incompatible with samplers do not cause any runtime errors.
  
  #include "test_utils/ANGLETest.h"
  #include "test_utils/gl_raii.h"
  
  using namespace angle;
  
  namespace
  {
  
  enum class SamplerType
  {
      Float,
      SignedInteger,
      UnsignedInteger,
      Shadow,
  };
  
  enum class TextureType
  {
      UnsignedNormalized,
      SignedNormalized,
      Float,
      UnsignedInteger,
      SignedInteger,
      Depth,
      DepthStencilDepthMode,
      DepthStencilStencilMode,
      Stencil,
  };
  
  enum class TextureCompareMode
  {
      None,
      Ref,
  };
  
  // Variations corresponding to enums above.
  using IncompatibleTextureVariationsTestParams =
      std::tuple<angle::PlatformParameters, SamplerType, TextureType, TextureCompareMode>;
  
  std::ostream &operator<<(std::ostream &out, SamplerType samplerType)
  {
      switch (samplerType)
      {
          case SamplerType::Float:
              out << "Float";
              break;
          case SamplerType::SignedInteger:
              out << "SignedInteger";
              break;
          case SamplerType::UnsignedInteger:
              out << "UnsignedInteger";
              break;
          case SamplerType::Shadow:
              out << "Shadow";
              break;
      }
  
      return out;
  }
  
  std::ostream &operator<<(std::ostream &out, TextureType textureType)
  {
      switch (textureType)
      {
          case TextureType::UnsignedNormalized:
              out << "UnsignedNormalized";
              break;
          case TextureType::SignedNormalized:
              out << "SignedNormalized";
              break;
          case TextureType::Float:
              out << "Float";
              break;
          case TextureType::UnsignedInteger:
              out << "UnsignedInteger";
              break;
          case TextureType::SignedInteger:
              out << "SignedInteger";
              break;
          case TextureType::Depth:
              out << "Depth";
              break;
          case TextureType::DepthStencilDepthMode:
              out << "DepthStencilDepthMode";
              break;
          case TextureType::DepthStencilStencilMode:
              out << "DepthStencilStencilMode";
              break;
          case TextureType::Stencil:
              out << "Stencil";
              break;
      }
  
      return out;
  }
  
  std::ostream &operator<<(std::ostream &out, TextureCompareMode textureCompareMode)
  {
      switch (textureCompareMode)
      {
          case TextureCompareMode::None:
              out << "None";
              break;
          case TextureCompareMode::Ref:
              out << "Ref";
              break;
      }
  
      return out;
  }
  
  void ParseIncompatibleTextureTestParams(const IncompatibleTextureVariationsTestParams &params,
                                          SamplerType *samplerTypeOut,
                                          TextureType *textureTypeOut,
                                          TextureCompareMode *textureCompareModeOut)
  {
      *samplerTypeOut        = std::get<1>(params);
      *textureTypeOut        = std::get<2>(params);
      *textureCompareModeOut = std::get<3>(params);
  }
  
  std::string IncompatibleTextureVariationsTestPrint(
      const ::testing::TestParamInfo<IncompatibleTextureVariationsTestParams> &paramsInfo)
  {
      const IncompatibleTextureVariationsTestParams &params = paramsInfo.param;
      std::ostringstream out;
  
      out << std::get<0>(params);
  
      SamplerType samplerType;
      TextureType textureType;
      TextureCompareMode textureCompareMode;
      ParseIncompatibleTextureTestParams(params, &samplerType, &textureType, &textureCompareMode);
  
      out << "__" << "SamplerType" << samplerType << "_" << "TextureType" << textureType << "_"
          << "TextureCompareMode" << textureCompareMode;
      return out.str();
  }
  
  class IncompatibleTextureTest : public ANGLETest<IncompatibleTextureVariationsTestParams>
  {};
  
  // Test that no errors are generated
  TEST_P(IncompatibleTextureTest, Test)
  {
      SamplerType samplerType;
      TextureType textureType;
      TextureCompareMode textureCompareMode;
      ParseIncompatibleTextureTestParams(GetParam(), &samplerType, &textureType, &textureCompareMode);
  
      std::stringstream fragmentSource;
      fragmentSource << "#version 300 es\n" << "out mediump vec4 my_FragColor;\n";
      switch (samplerType)
      {
          case SamplerType::Float:
              fragmentSource << "uniform mediump sampler2D tex;\n";
              break;
          case SamplerType::SignedInteger:
              fragmentSource << "uniform mediump isampler2D tex;\n";
              break;
          case SamplerType::UnsignedInteger:
              fragmentSource << "uniform mediump usampler2D tex;\n";
              break;
          case SamplerType::Shadow:
              fragmentSource << "uniform mediump sampler2DShadow tex;\n";
              break;
      }
      fragmentSource << "void main()\n" << "{\n";
      fragmentSource << "    my_FragColor = vec4(texture(tex, "
                     << (samplerType == SamplerType::Shadow ? "vec3" : "vec2") << "(0)));\n";
      fragmentSource << "}";
      ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), fragmentSource.str().c_str());
      ASSERT_GL_NO_ERROR();
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      switch (textureType)
      {
          case TextureType::UnsignedNormalized:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
              break;
          case TextureType::SignedNormalized:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8_SNORM, 1, 1, 0, GL_RGBA, GL_BYTE, nullptr);
              break;
          case TextureType::Float:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT, nullptr);
              break;
          case TextureType::UnsignedInteger:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8UI, 1, 1, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE,
                           nullptr);
              break;
          case TextureType::SignedInteger:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8I, 1, 1, 0, GL_RGBA_INTEGER, GL_BYTE, nullptr);
              break;
          case TextureType::Depth:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, 1, 1, 0, GL_DEPTH_COMPONENT,
                           GL_UNSIGNED_SHORT, nullptr);
              break;
          case TextureType::DepthStencilDepthMode:
              glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH32F_STENCIL8, 1, 1, 0, GL_DEPTH_STENCIL,
                           GL_FLOAT_32_UNSIGNED_INT_24_8_REV, nullptr);
              break;
          case TextureType::DepthStencilStencilMode:
              ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_stencil_texturing"));
              glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH32F_STENCIL8, 1, 1, 0, GL_DEPTH_STENCIL,
                           GL_FLOAT_32_UNSIGNED_INT_24_8_REV, nullptr);
              glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE_ANGLE, GL_STENCIL_INDEX);
              break;
          case TextureType::Stencil:
              ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_texture_stencil8"));
              glTexImage2D(GL_TEXTURE_2D, 0, GL_STENCIL_INDEX8, 1, 1, 0, GL_STENCIL_INDEX,
                           GL_UNSIGNED_BYTE, nullptr);
              break;
      }
      ASSERT_GL_NO_ERROR();
  
      switch (textureCompareMode)
      {
          case TextureCompareMode::None:
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
              break;
          case TextureCompareMode::Ref:
              glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
              break;
      }
      ASSERT_GL_NO_ERROR();
  
      drawQuad(program, essl3_shaders::PositionAttrib(), 0.0f);
      EXPECT_GL_NO_ERROR();
  }
  
  constexpr SamplerType kSamplerTypes[] = {
      SamplerType::Float,
      SamplerType::SignedInteger,
      SamplerType::UnsignedInteger,
      SamplerType::Shadow,
  };
  constexpr TextureType kTextureTypes[] = {
      TextureType::UnsignedNormalized,    TextureType::SignedNormalized,        TextureType::Float,
      TextureType::UnsignedInteger,       TextureType::SignedInteger,           TextureType::Depth,
      TextureType::DepthStencilDepthMode, TextureType::DepthStencilStencilMode, TextureType::Stencil,
  };
  constexpr TextureCompareMode kTextureCompareModes[] = {
      TextureCompareMode::None,
      TextureCompareMode::Ref,
  };
  
  GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(IncompatibleTextureTest);
  ANGLE_INSTANTIATE_TEST_COMBINE_3(IncompatibleTextureTest,
                                   IncompatibleTextureVariationsTestPrint,
                                   testing::ValuesIn(kSamplerTypes),
                                   testing::ValuesIn(kTextureTypes),
                                   testing::ValuesIn(kTextureCompareModes),
                                   ANGLE_ALL_TEST_PLATFORMS_ES3);
  
  }  // anonymous namespace
  

Download