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

• Show log

  Commit

• Hash : 07f0f019
  Author :
  Date : 2019-12-19T14:47:46
  

  Translator: Memory qualifiers on SSBO fields
  
  These were not output prior to this CL.  Of these qualifiers, readonly
  and writeonly are unnecessary as ANGLE already does the appropriate
  validation, but the rest (coherent, volatile, restrict) are necessary,
  even though the tests pass on the bots by coincidence of driver
  behavior/test simplicity.
  
  Bug: angleproject:3602
  Change-Id: Ie75fee0f004944b50ef21124ba25c4315e082b85
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1976499
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

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,
                          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