kc3-lang/angle/src/compiler/translator/OutputVulkanGLSLForMetal.mm

• Show log

  Commit

• Hash : 1a5c7a16
  Author :
  Date : 2020-02-25T12:02:31
  

  Reland "Vulkan:Include precision qualifier in GLSL"
  
  Currently still ignoring precision qualifiers for Vulkan shaders by
  default, but have added feature "enablePrecisionQualifiers" that can be
  enabled in order to include precision qualifiers.
  
  With this initial implementation, it's possible to get precision
  qualifier mis-matches in the generated GLSL 4.50. According to the
  spec this is allowed. From GLSLangSpec 4.50 section 4.7 "Precision and
  Precision Qualifiers":
  
  For the purposes of determining if an output from one shader stage
  matches an input of the next stage, the precision qualifier need not
  match.
  
  However, when converted to SPIR-V and run through the shader validation
  any mismatches will cause shader validation errors. Initially just
  ignoring those errors with this commit.
  
  Bug: angleproject:3078
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2057749
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Tobin Ehlis <tobine@google.com>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Commit-Queue: Tobin Ehlis <tobine@google.com>
  Change-Id: Ieecca604bb2c834c9b1c2bcab85279d1f8755dfa
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2086280
  

Download

• src/compiler/translator/OutputVulkanGLSLForMetal.mm

• //
  // Copyright (c) 2019 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.
  //
  // TOutputVulkanGLSLForMetal:
  //    This is a special version Vulkan GLSL output that will make some special
  //    considerations for Metal backend limitations.
  //
  
  #include "compiler/translator/OutputVulkanGLSLForMetal.h"
  
  #include "common/apple_platform_utils.h"
  #include "compiler/translator/BaseTypes.h"
  #include "compiler/translator/Symbol.h"
  #include "compiler/translator/util.h"
  
  namespace sh
  {
  
  namespace
  {
  bool gOverrideRemoveInvariant = false;
  
  bool ShoudRemoveInvariant(const TType &type)
  {
      if (gOverrideRemoveInvariant)
      {
          return true;
      }
  
      if (type.getQualifier() != EvqPosition)
      {
          // Metal only supports invariant for gl_Position
          return true;
      }
  
      if (ANGLE_APPLE_AVAILABLE_XCI(10.14, 13.0, 12))
      {
          return false;
      }
      else
      {
          // Metal 2.1 is not available, so we need to remove "invariant" keyword
          return true;
      }
  }
  
  }
  
  // static
  void TOutputVulkanGLSLForMetal::RemoveInvariantForTest(bool remove)
  {
      gOverrideRemoveInvariant = remove;
  }
  
  TOutputVulkanGLSLForMetal::TOutputVulkanGLSLForMetal(TInfoSinkBase &objSink,
                                                       ShArrayIndexClampingStrategy clampingStrategy,
                                                       ShHashFunction64 hashFunction,
                                                       NameMap &nameMap,
                                                       TSymbolTable *symbolTable,
                                                       sh::GLenum shaderType,
                                                       int shaderVersion,
                                                       ShShaderOutput output,
                                                       ShCompileOptions compileOptions)
      : TOutputVulkanGLSL(objSink,
                          clampingStrategy,
                          hashFunction,
                          nameMap,
                          symbolTable,
                          shaderType,
                          shaderVersion,
                          output,
                          false,
                          true,
                          compileOptions)
  {}
  
  void TOutputVulkanGLSLForMetal::writeVariableType(const TType &type,
                                                    const TSymbol *symbol,
                                                    bool isFunctionArgument)
  {
      TType overrideType(type);
  
      // Remove invariant keyword if required.
      if (type.isInvariant() && ShoudRemoveInvariant(type))
      {
          overrideType.setInvariant(false);
      }
  
      TOutputVulkanGLSL::writeVariableType(overrideType, symbol, isFunctionArgument);
  }
  
  bool TOutputVulkanGLSLForMetal::visitGlobalQualifierDeclaration(
      Visit visit,
      TIntermGlobalQualifierDeclaration *node)
  {
      TInfoSinkBase &out = objSink();
      ASSERT(visit == PreVisit);
      const TIntermSymbol *symbol = node->getSymbol();
  
      // No support for the |precise| keyword from EXT_gpu_shader5 (or ES3.2).
      ASSERT(node->isInvariant());
  
      if (!ShoudRemoveInvariant(symbol->getType()))
      {
          out << "invariant ";
      }
      out << hashName(&symbol->variable());
      return false;
  }
  }  // namespace sh
  

Download