kc3-lang/angle/src/compiler/translator/FlagStd140Structs.cpp

• Show log

  Commit

• Hash : dd21ecf8
  Author :
  Date : 2018-01-10T12:42:09
  

  Add const qualification to symbol accesses
  
  All accesses to built-in symbols now happen through const-qualified
  pointers.
  
  This also encapsulates TSymbolTableLevel inside TSymbolTable.
  
  This prepares for statically allocating built-in symbols.
  
  BUG=angleproject:2267
  TEST=angle_unittests
  
  Change-Id: I473014d978daa765b4a733d761d6c08b28288776
  Reviewed-on: https://chromium-review.googlesource.com/859959
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/compiler/translator/FlagStd140Structs.cpp

• //
  // Copyright (c) 2013 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.
  //
  // FlagStd140Structs.cpp: Find structs in std140 blocks, where the padding added in the translator
  // conflicts with the "natural" unpadded type.
  
  #include "compiler/translator/FlagStd140Structs.h"
  
  #include "compiler/translator/IntermTraverse.h"
  #include "compiler/translator/SymbolTable.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class FlagStd140StructsTraverser : public TIntermTraverser
  {
    public:
      FlagStd140StructsTraverser() : TIntermTraverser(true, false, false) {}
  
      const std::vector<MappedStruct> getMappedStructs() const { return mMappedStructs; }
  
    protected:
      bool visitDeclaration(Visit visit, TIntermDeclaration *node) override;
  
    private:
      void mapBlockStructMembers(TIntermSymbol *blockDeclarator, const TInterfaceBlock *block);
  
      std::vector<MappedStruct> mMappedStructs;
  };
  
  void FlagStd140StructsTraverser::mapBlockStructMembers(TIntermSymbol *blockDeclarator,
                                                         const TInterfaceBlock *block)
  {
      for (auto *field : block->fields())
      {
          if (field->type()->getBasicType() == EbtStruct)
          {
              MappedStruct mappedStruct;
              mappedStruct.blockDeclarator = blockDeclarator;
              mappedStruct.field           = field;
              mMappedStructs.push_back(mappedStruct);
          }
      }
  }
  
  bool FlagStd140StructsTraverser::visitDeclaration(Visit visit, TIntermDeclaration *node)
  {
      TIntermTyped *declarator = node->getSequence()->back()->getAsTyped();
      if (declarator->getBasicType() == EbtInterfaceBlock)
      {
          const TInterfaceBlock *block = declarator->getType().getInterfaceBlock();
          if (block->blockStorage() == EbsStd140)
          {
              mapBlockStructMembers(declarator->getAsSymbolNode(), block);
          }
      }
      return false;
  }
  
  }  // anonymous namespace
  
  std::vector<MappedStruct> FlagStd140Structs(TIntermNode *node)
  {
      FlagStd140StructsTraverser flaggingTraversal;
  
      node->traverse(&flaggingTraversal);
  
      return flaggingTraversal.getMappedStructs();
  }
  
  }  // namespace sh
  

Download