kc3-lang/angle/src/compiler/translator/ShaderStorageBlockOutputHLSL.h

• Show log

  Commit

• Hash : 4e712be2
  Author :
  Date : 2019-01-03T13:53:59
  

  Refactor BlockLayoutEncoder APIs for std430.
  
  This splits HLSL SSBO access into two steps.
  
  First we compute a mapping from the collected SSBO variable names to
  TField pointers. Then during tree traversal we use a block encoding
  visitor class that uses the shader names to store BlockMemberInfo
  structures for the structures and variables. Each nested structure
  is traversed separately so that the BlockMemberInfo offsets are
  relative to the structure start rather than the enclosing block. The
  array stride for a structure is the size of the struct after all the
  alignment is included.
  
  This gives the correct results for the SSBO access chain in the HLSL
  code. It also will allow us to use the same encoding and visiting logic
  for SSBOs on the API side.
  
  Bug: angleproject:3024
  Change-Id: I42b1db0e7547782ae77fe5f64a797f803f203f45
  Reviewed-on: https://chromium-review.googlesource.com/c/1352731
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• src/compiler/translator/ShaderStorageBlockOutputHLSL.h

• //
  // Copyright 2018 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.
  //
  // ShaderStorageBlockOutputHLSL: A traverser to translate a buffer variable of shader storage block
  // to an offset of RWByteAddressBuffer.
  //
  
  #ifndef COMPILER_TRANSLATOR_SHADERSTORAGEBLOCKOUTPUTHLSL_H_
  #define COMPILER_TRANSLATOR_SHADERSTORAGEBLOCKOUTPUTHLSL_H_
  
  #include "compiler/translator/ShaderStorageBlockFunctionHLSL.h"
  #include "compiler/translator/blocklayout.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  class ResourcesHLSL;
  class OutputHLSL;
  class TSymbolTable;
  
  struct TReferencedBlock : angle::NonCopyable
  {
      POOL_ALLOCATOR_NEW_DELETE();
      TReferencedBlock(const TInterfaceBlock *block, const TVariable *instanceVariable);
      const TInterfaceBlock *block;
      const TVariable *instanceVariable;  // May be nullptr if the block is not instanced.
  };
  
  // Maps from uniqueId to a variable.
  using ReferencedInterfaceBlocks = std::map<int, const TReferencedBlock *>;
  
  // Used to save shader storage block field member information.
  using BlockMemberInfoMap = std::map<const TField *, BlockMemberInfo>;
  
  using ShaderVarToFieldMap = std::map<std::string, const TField *>;
  
  class ShaderStorageBlockOutputHLSL : public TIntermTraverser
  {
    public:
      ShaderStorageBlockOutputHLSL(OutputHLSL *outputHLSL,
                                   TSymbolTable *symbolTable,
                                   ResourcesHLSL *resourcesHLSL,
                                   const std::vector<InterfaceBlock> &shaderStorageBlocks);
  
      ~ShaderStorageBlockOutputHLSL();
  
      // This writes part of the function call to store a value to a SSBO to the output stream. After
      // calling this, ", <stored value>)" should be written to the output stream to complete the
      // function call.
      void outputStoreFunctionCallPrefix(TIntermTyped *node);
      // This writes the function call to load a SSBO value to the output stream.
      void outputLoadFunctionCall(TIntermTyped *node);
      // This writes the function call to get the lengh of unsized array member of SSBO.
      void outputLengthFunctionCall(TIntermTyped *node);
      // Writes the atomic memory function calls for SSBO.
      void outputAtomicMemoryFunctionCallPrefix(TIntermTyped *node, TOperator op);
  
      void writeShaderStorageBlocksHeader(TInfoSinkBase &out) const;
  
    protected:
      void visitSymbol(TIntermSymbol *) override;
      void visitConstantUnion(TIntermConstantUnion *) override;
      bool visitSwizzle(Visit visit, TIntermSwizzle *node) override;
      bool visitBinary(Visit visit, TIntermBinary *) override;
      bool visitAggregate(Visit visit, TIntermAggregate *node) override;
      bool visitTernary(Visit visit, TIntermTernary *) override;
      bool visitUnary(Visit visit, TIntermUnary *) override;
  
    private:
      void traverseSSBOAccess(TIntermTyped *node, SSBOMethod method);
      void setMatrixStride(TIntermTyped *node, TLayoutBlockStorage storage, bool rowMajor);
      bool isEndOfSSBOAccessChain();
      void writeEOpIndexDirectOrIndirectOutput(TInfoSinkBase &out, Visit visit, TIntermBinary *node);
      // Common part in dot operations.
      void writeDotOperatorOutput(TInfoSinkBase &out, const TField *field);
  
      int mMatrixStride;
      bool mRowMajor;
      bool mLocationAsTheLastArgument;
      OutputHLSL *mOutputHLSL;
      ShaderStorageBlockFunctionHLSL *mSSBOFunctionHLSL;
      ResourcesHLSL *mResourcesHLSL;
      ReferencedInterfaceBlocks mReferencedShaderStorageBlocks;
  
      BlockMemberInfoMap mBlockMemberInfoMap;
      const std::vector<InterfaceBlock> &mShaderStorageBlocks;
  };
  }  // namespace sh
  
  #endif  // COMPILER_TRANSLATOR_SHADERSTORAGEBLOCKOUTPUTHLSL_H_
  

Download