kc3-lang/angle/src/compiler/translator/tree_ops/RewriteInterpolateAtOffset.cpp

• Show log

  Commit

• Hash : 995493cc
  Author :
  Date : 2020-11-18T20:33:33
  

  Revert "Vulkan: Remove rotation related data from driver uniform"
  
  This reverts commit fd97c3343e9ff23677124b7528ec945bca65796a.
  
  Reason for revert: The specialization constant for rotation causes
  performance regression with older qualcomm driver. We need to keep the
  driver uniform code path for the older driver.
  
  Original change's description:
  > Vulkan: Remove rotation related data from driver uniform
  >
  > Rotation is now handled in the shader compiler with specialization
  > constant, it should be removed from driver uniforms. Since Metal is
  > using the flipXY, flipXY/negFlipXY are still kept in the shader side
  > implementation, but have moved to TranslatorMetal in this CL.
  >
  > Bug: b/171750979
  > Change-Id: Ie8d15ef227cb52a6e19e4319ecc9f09bda42e667
  > Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2519863
  > Reviewed-by: Ian Elliott <ianelliott@google.com>
  > Reviewed-by: Tim Van Patten <timvp@google.com>
  > Reviewed-by: Jamie Madill <jmadill@chromium.org>
  > Commit-Queue: Charlie Lao <cclao@google.com>
  
  TBR=ianelliott@google.com,timvp@google.com,jmadill@chromium.org,cclao@google.com
  
  Bug: b/171750979
  Change-Id: Iff9cffb28851ade1d9c5cd23fde73910a19867ce
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2547808
  Reviewed-by: Ian Elliott <ianelliott@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

• src/compiler/translator/tree_ops/RewriteInterpolateAtOffset.cpp

• //
  // Copyright 2020 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.
  //
  // Implementation of InterpolateAtOffset viewport transformation.
  // See header for more info.
  
  #include "compiler/translator/tree_ops/RewriteDfdy.h"
  
  #include "common/angleutils.h"
  #include "compiler/translator/StaticType.h"
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/TranslatorVulkan.h"
  #include "compiler/translator/tree_util/DriverUniform.h"
  #include "compiler/translator/tree_util/FlipRotateSpecConst.h"
  #include "compiler/translator/tree_util/IntermNode_util.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class Traverser : public TIntermTraverser
  {
    public:
      ANGLE_NO_DISCARD static bool Apply(TCompiler *compiler,
                                         ShCompileOptions compileOptions,
                                         TIntermNode *root,
                                         const TSymbolTable &symbolTable,
                                         int ShaderVersion,
                                         FlipRotateSpecConst *rotationSpecConst,
                                         const DriverUniform *driverUniforms);
  
    private:
      Traverser(TSymbolTable *symbolTable,
                ShCompileOptions compileOptions,
                int shaderVersion,
                FlipRotateSpecConst *rotationSpecConst,
                const DriverUniform *driverUniforms);
      bool visitAggregate(Visit visit, TIntermAggregate *node) override;
  
      const TSymbolTable *symbolTable = nullptr;
      const int shaderVersion;
      FlipRotateSpecConst *mRotationSpecConst = nullptr;
      const DriverUniform *mDriverUniforms    = nullptr;
      bool mUsePreRotation                    = false;
  };
  
  Traverser::Traverser(TSymbolTable *symbolTable,
                       ShCompileOptions compileOptions,
                       int shaderVersion,
                       FlipRotateSpecConst *rotationSpecConst,
                       const DriverUniform *driverUniforms)
      : TIntermTraverser(true, false, false, symbolTable),
        symbolTable(symbolTable),
        shaderVersion(shaderVersion),
        mRotationSpecConst(rotationSpecConst),
        mDriverUniforms(driverUniforms),
        mUsePreRotation((compileOptions & SH_ADD_PRE_ROTATION) != 0)
  {}
  
  // static
  bool Traverser::Apply(TCompiler *compiler,
                        ShCompileOptions compileOptions,
                        TIntermNode *root,
                        const TSymbolTable &symbolTable,
                        int shaderVersion,
                        FlipRotateSpecConst *rotationSpecConst,
                        const DriverUniform *driverUniforms)
  {
      TSymbolTable *pSymbolTable = const_cast<TSymbolTable *>(&symbolTable);
      Traverser traverser(pSymbolTable, compileOptions, shaderVersion, rotationSpecConst,
                          driverUniforms);
      root->traverse(&traverser);
      return traverser.updateTree(compiler, root);
  }
  
  bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
  {
      // Decide if the node represents the call of texelFetchOffset.
      if (node->getOp() != EOpCallBuiltInFunction)
      {
          return true;
      }
  
      ASSERT(node->getFunction()->symbolType() == SymbolType::BuiltIn);
      if (node->getFunction()->name() != "interpolateAtOffset")
      {
          return true;
      }
  
      const TIntermSequence *sequence = node->getSequence();
      ASSERT(sequence->size() == 2u);
  
      TIntermSequence *interpolateAtOffsetArguments = new TIntermSequence();
      // interpolant node
      interpolateAtOffsetArguments->push_back(sequence->at(0));
      // offset
      TIntermTyped *offsetNode = sequence->at(1)->getAsTyped();
      ASSERT(offsetNode->getType() == *(StaticType::GetBasic<EbtFloat, 2>()));
  
      // If pre-rotation is enabled apply the transformation else just flip the Y-coordinate
      TIntermTyped *rotatedXY;
      if (mUsePreRotation)
      {
          rotatedXY = mRotationSpecConst->getFragRotationMultiplyFlipXY();
          if (!rotatedXY)
          {
              TIntermTyped *flipXY       = mDriverUniforms->getFlipXYRef();
              TIntermTyped *fragRotation = mDriverUniforms->getFragRotationMatrixRef();
              rotatedXY = new TIntermBinary(EOpMatrixTimesVector, fragRotation, flipXY);
          }
      }
      else
      {
          rotatedXY = mRotationSpecConst->getFlipXY();
          if (!rotatedXY)
          {
              rotatedXY = mDriverUniforms->getFlipXYRef();
          }
      }
  
      TIntermBinary *correctedOffset = new TIntermBinary(EOpMul, offsetNode, rotatedXY);
      correctedOffset->setLine(offsetNode->getLine());
      interpolateAtOffsetArguments->push_back(correctedOffset);
  
      TIntermTyped *interpolateAtOffsetNode = CreateBuiltInFunctionCallNode(
          "interpolateAtOffset", interpolateAtOffsetArguments, *symbolTable, shaderVersion);
      interpolateAtOffsetNode->setLine(node->getLine());
  
      // Replace the old node by this new node.
      queueReplacement(interpolateAtOffsetNode, OriginalNode::IS_DROPPED);
  
      return true;
  }
  
  }  // anonymous namespace
  
  bool RewriteInterpolateAtOffset(TCompiler *compiler,
                                  ShCompileOptions compileOptions,
                                  TIntermNode *root,
                                  const TSymbolTable &symbolTable,
                                  int shaderVersion,
                                  FlipRotateSpecConst *rotationSpecConst,
                                  const DriverUniform *driverUniforms)
  {
      // interpolateAtOffset is only valid in GLSL 3.0 and later.
      if (shaderVersion < 300)
      {
          return true;
      }
  
      return Traverser::Apply(compiler, compileOptions, root, symbolTable, shaderVersion,
                              rotationSpecConst, driverUniforms);
  }
  
  }  // namespace sh
  

Download