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

• Show log

  Commit

• Hash : 6803a2d0
  Author :
  Date : 2022-04-01T16:52:49
  

  D3D11: implement SSBOs in pixel and vertex shaders.
  
  Since the 'u' register space for UAVs in pixel shaders is shared
  with render targets, and the number of render targets may vary
  depending on GL state, this required deferring register allocation
  until draw-time output in DynamicHLSL.
  
  Since non-compute shaders aren't able to immediately output the
  SSBO declaration, initial register allocation was broken out from
  ResourcesHLSL::shaderStorageBlocksHeader()
  into ResourcesHLSL::allocateShaderStorageBlockRegisters() with
  the former only called for compute shaders. These initial allocations
  are offset by the number of RTs at draw time.
  
  Since Raw UAVs may now be created at draw time for non-compute
  shaders, call markRawBufferUsage() from the Renderer11::draw*()
  entry points as it is from dispatchCompute*().
  
  Bug: angleproject:7156
  Change-Id: I6ab65af1ff36df0313e3c1f8f79661b1547ab9a2
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3565562
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Stephen White <senorblanco@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/IntermNode.h"
  #include "compiler/translator/ShaderStorageBlockFunctionHLSL.h"
  #include "compiler/translator/blocklayout.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:
      ShaderStorageBlockOutputHLSL(OutputHLSL *outputHLSL,
                                   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(GLenum shaderType, TInfoSinkBase &out) const;
  
    private:
      void traverseSSBOAccess(TIntermTyped *node, SSBOMethod method);
      TIntermTyped *traverseNode(TInfoSinkBase &out,
                                 TIntermTyped *node,
                                 BlockMemberInfo *blockMemberInfo);
      int getMatrixStride(TIntermTyped *node,
                          TLayoutBlockStorage storage,
                          bool rowMajor,
                          bool *isRowMajor) const;
      TIntermTyped *writeEOpIndexDirectOrIndirectOutput(TInfoSinkBase &out,
                                                        TIntermBinary *node,
                                                        BlockMemberInfo *blockMemberInfo);
      // Common part in dot operations.
      TIntermTyped *createFieldOffset(const TField *field, BlockMemberInfo *blockMemberInfo);
      void collectShaderStorageBlocks(TIntermTyped *node);
      OutputHLSL *mOutputHLSL;
      ShaderStorageBlockFunctionHLSL *mSSBOFunctionHLSL;
      ResourcesHLSL *mResourcesHLSL;
      ReferencedInterfaceBlocks mReferencedShaderStorageBlocks;
  
      BlockMemberInfoMap mBlockMemberInfoMap;
      const std::vector<InterfaceBlock> &mShaderStorageBlocks;
  };
  }  // namespace sh
  
  #endif  // COMPILER_TRANSLATOR_SHADERSTORAGEBLOCKOUTPUTHLSL_H_
  

Download