kc3-lang/angle/src/compiler/translator/blocklayoutHLSL.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/blocklayoutHLSL.h

• //
  // Copyright (c) 2013-2014 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.
  //
  // blocklayout.h:
  //   Methods and classes related to uniform layout and packing in GLSL and HLSL.
  //
  
  #ifndef COMMON_BLOCKLAYOUTHLSL_H_
  #define COMMON_BLOCKLAYOUTHLSL_H_
  
  #include <cstddef>
  #include <vector>
  
  #include <GLSLANG/ShaderLang.h>
  #include "angle_gl.h"
  #include "blocklayout.h"
  
  namespace sh
  {
  // Block layout packed according to the D3D9 or default D3D10+ register packing rules
  // See http://msdn.microsoft.com/en-us/library/windows/desktop/bb509632(v=vs.85).aspx
  // The strategy should be ENCODE_LOOSE for D3D9 constant blocks, and ENCODE_PACKED
  // for everything else (D3D10+ constant blocks and all attributes/varyings).
  
  class HLSLBlockEncoder : public BlockLayoutEncoder
  {
    public:
      enum HLSLBlockEncoderStrategy
      {
          ENCODE_PACKED,
          ENCODE_LOOSE
      };
  
      HLSLBlockEncoder(HLSLBlockEncoderStrategy strategy, bool transposeMatrices);
  
      void enterAggregateType(const ShaderVariable &structVar) override;
      void exitAggregateType(const ShaderVariable &structVar) override;
      void skipRegisters(unsigned int numRegisters);
  
      bool isPacked() const { return mEncoderStrategy == ENCODE_PACKED; }
  
      static HLSLBlockEncoderStrategy GetStrategyFor(ShShaderOutput outputType);
  
    protected:
      void getBlockLayoutInfo(GLenum type,
                              const std::vector<unsigned int> &arraySizes,
                              bool isRowMajorMatrix,
                              int *arrayStrideOut,
                              int *matrixStrideOut) override;
      void advanceOffset(GLenum type,
                         const std::vector<unsigned int> &arraySizes,
                         bool isRowMajorMatrix,
                         int arrayStride,
                         int matrixStride) override;
  
      HLSLBlockEncoderStrategy mEncoderStrategy;
      bool mTransposeMatrices;
  };
  
  // This method returns the number of used registers for a ShaderVariable. It is dependent on the
  // HLSLBlockEncoder class to count the number of used registers in a struct (which are individually
  // packed according to the same rules).
  unsigned int HLSLVariableRegisterCount(const Uniform &variable, ShShaderOutput outputType);
  }  // namespace sh
  
  #endif  // COMMON_BLOCKLAYOUTHLSL_H_
  

Download