kc3-lang/angle/src/tests/compiler_tests/FragDepth_test.cpp

Branch - branch -main

• Show log

  Commit

• Hash : 4cbe8548
  Author :
  Date : 2023-02-28T21:12:17
  

  Expose shader extensions based on ESSL version
  
  Previously, all suported extensions were always exposed in the
  preprocessor. This broke some games which relied on ESSL1-only extension
  macros not being defined in ESSL3 shaders. This change adds min/max
  version information to list of extensions so the preprocessor can
  conditionally expose extensions based on the shader language version,
  both via the extension name macros and the #extension directive.
  
  Test: angle_unittests --gtest_filter="VersionTest.*"
  Test: angle_end2end_tests --gtest_filter="*ESSL*ExtensionMacros*"
  Test: Run com.gameloft.android.ANMP.GloftGGHM on Pixel 6
  
  Bug: b/268091452
  Change-Id: I2332a6cb964f54c47d23e2ef6b24e99a0b5c8202
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4304907
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Mike Schuchardt <mikes@lunarg.com>
  

Download

• src/tests/compiler_tests/FragDepth_test.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.
  //
  // FragDepth_test.cpp:
  //   Test for GLES SL 3.0 gl_FragDepth variable implementation.
  //
  
  #include "GLSLANG/ShaderLang.h"
  #include "angle_gl.h"
  #include "gtest/gtest.h"
  
  namespace
  {
  const char ESSLVersion100[] = "#version 100\n";
  const char ESSLVersion300[] = "#version 300 es\n";
  const char EXTFDPragma[]    = "#extension GL_EXT_frag_depth : require\n";
  }  // namespace
  
  class FragDepthTest : public testing::TestWithParam<bool>
  {
    protected:
      void SetUp() override
      {
          sh::InitBuiltInResources(&mResources);
          mCompiler                 = nullptr;
          mResources.EXT_frag_depth = GetParam();
      }
  
      void TearDown() override { DestroyCompiler(); }
      void DestroyCompiler()
      {
          if (mCompiler)
          {
              sh::Destruct(mCompiler);
              mCompiler = nullptr;
          }
      }
  
      void InitializeCompiler()
      {
          DestroyCompiler();
          mCompiler = sh::ConstructCompiler(GL_FRAGMENT_SHADER, SH_GLES3_SPEC,
                                            SH_GLSL_COMPATIBILITY_OUTPUT, &mResources);
          ASSERT_TRUE(mCompiler != nullptr) << "Compiler could not be constructed.";
      }
  
      testing::AssertionResult TestShaderCompile(const char *version,
                                                 const char *pragma,
                                                 const char *shader)
      {
          const char *shaderStrings[] = {version, pragma, shader};
          bool success                = sh::Compile(mCompiler, shaderStrings, 3, {});
          if (success)
          {
              return ::testing::AssertionSuccess() << "Compilation success";
          }
          return ::testing::AssertionFailure() << sh::GetInfoLog(mCompiler);
      }
  
    protected:
      ShBuiltInResources mResources;
      ShHandle mCompiler;
  };
  
  // The GLES SL 3.0 built-in variable gl_FragDepth fails to compile with GLES SL 1.0.
  TEST_P(FragDepthTest, CompileFailsESSL100)
  {
      static const char shaderString[] =
          "precision mediump float;\n"
          "void main() { \n"
          "    gl_FragDepth = 1.0;\n"
          "}\n";
  
      InitializeCompiler();
      EXPECT_FALSE(TestShaderCompile(ESSLVersion100, "", shaderString));
      EXPECT_FALSE(TestShaderCompile("", "", shaderString));
      EXPECT_FALSE(TestShaderCompile("", EXTFDPragma, shaderString));
  }
  
  // The GLES SL 3.0 built-in variable gl_FragDepth compiles with GLES SL 3.0.
  TEST_P(FragDepthTest, CompileSucceedsESSL300)
  {
      static const char shaderString[] =
          "precision mediump float;\n"
          "void main() { \n"
          "    gl_FragDepth = 1.0;\n"
          "}\n";
      InitializeCompiler();
      EXPECT_TRUE(TestShaderCompile(ESSLVersion300, "", shaderString));
  }
  
  // Using #extension GL_EXT_frag_depth in GLSL ES 3.0 shader fails to compile.
  TEST_P(FragDepthTest, ExtensionFDFailsESSL300)
  {
      static const char shaderString[] =
          "precision mediump float;\n"
          "out vec4 fragColor;\n"
          "void main() { \n"
          "    fragColor = vec4(1.0);\n"
          "}\n";
      InitializeCompiler();
      EXPECT_FALSE(TestShaderCompile(ESSLVersion300, EXTFDPragma, shaderString));
  }
  
  // The tests should pass regardless whether the EXT_frag_depth is on or not.
  INSTANTIATE_TEST_SUITE_P(FragDepthTests, FragDepthTest, testing::Values(false, true));
  

Download