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

• Show log

  Commit

• Hash : 86d7e4d8
  Author :
  Date : 2020-11-10T15:55:34
  

  Vulkan: Support texture buffers
  
  Texture buffers are placed in the same descriptor set with the rest of
  the textures.  However, the different code paths that handle textures
  have special cases for texture buffers as they create a different
  descriptor type (texel buffer instead of combined image sampler).  Image
  view serials are used to track the buffer view serials as well so the
  texture descriptor cache can handle texture buffers as well.
  
  This CL is missing storage texel buffer support.
  
  Bug: angleproject:3573
  Change-Id: Iff80ca22ff9b9957a0c9a3c7aaada1fa54b24ec8
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2532653
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  

Download

• src/compiler/translator/tree_ops/FlagSamplersWithTexelFetch.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.
  //
  // FlagSamplersForTexelFetch.cpp: finds all instances of texelFetch used with a static reference to
  // a sampler uniform, and flag that uniform as having been used with texelFetch
  //
  
  #include "compiler/translator/tree_ops/FlagSamplersWithTexelFetch.h"
  
  #include "angle_gl.h"
  #include "common/utilities.h"
  
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/tree_util/IntermNode_util.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  #include "compiler/translator/tree_util/ReplaceVariable.h"
  
  namespace sh
  {
  namespace
  {
  
  class FlagSamplersWithTexelFetchTraverser : public TIntermTraverser
  {
    public:
      FlagSamplersWithTexelFetchTraverser(TSymbolTable *symbolTable,
                                          std::vector<ShaderVariable> *uniforms)
          : TIntermTraverser(true, true, true, symbolTable), mUniforms(uniforms)
      {}
  
      bool visitAggregate(Visit visit, TIntermAggregate *node) override
      {
          // Decide if the node is a call to texelFetch[Offset]
          if (node->getOp() != EOpCallBuiltInFunction)
          {
              return true;
          }
  
          ASSERT(node->getFunction()->symbolType() == SymbolType::BuiltIn);
          if (node->getFunction()->name() != "texelFetch" &&
              node->getFunction()->name() != "texelFetchOffset")
          {
              return true;
          }
  
          const TIntermSequence *sequence = node->getSequence();
  
          ASSERT(sequence->size() > 0);
  
          TIntermSymbol *samplerSymbol = sequence->at(0)->getAsSymbolNode();
          ASSERT(samplerSymbol != nullptr);
  
          const TVariable &samplerVariable = samplerSymbol->variable();
  
          for (ShaderVariable &uniform : *mUniforms)
          {
              if (samplerVariable.name() == uniform.name)
              {
                  ASSERT(gl::IsSamplerType(uniform.type));
                  uniform.texelFetchStaticUse = true;
                  break;
              }
          }
  
          return true;
      }
  
    private:
      std::vector<ShaderVariable> *mUniforms;
  };
  
  }  // anonymous namespace
  
  bool FlagSamplersForTexelFetch(TCompiler *compiler,
                                 TIntermBlock *root,
                                 TSymbolTable *symbolTable,
                                 std::vector<ShaderVariable> *uniforms)
  {
      ASSERT(uniforms != nullptr);
      if (uniforms->size() > 0)
      {
          FlagSamplersWithTexelFetchTraverser traverser(symbolTable, uniforms);
          root->traverse(&traverser);
      }
  
      return true;
  }
  
  }  // namespace sh
  

Download