src/third_party/angle/src/common/blocklayout.h

   1 //
   2 // Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6 // blocklayout.h:
   7 //   Methods and classes related to uniform layout and packing in GLSL and HLSL.
   8 //
   9
  10 #ifndef COMMON_BLOCKLAYOUT_H_
  11 #define COMMON_BLOCKLAYOUT_H_
  12
  13 #include <cstddef>
  14 #include <vector>
  15
  16 #include "angle_gl.h"
  17 #include <GLSLANG/ShaderLang.h>
  18
  19 namespace sh
  20 {
  21 struct ShaderVariable;
  22 struct InterfaceBlockField;
  23 struct Uniform;
  24 struct Varying;
  25 struct InterfaceBlock;
  26
  27 struct BlockMemberInfo
  28 {
  29     BlockMemberInfo(int offset, int arrayStride, int matrixStride, bool isRowMajorMatrix)
  30         : offset(offset),
  31           arrayStride(arrayStride),
  32           matrixStride(matrixStride),
  33           isRowMajorMatrix(isRowMajorMatrix)
  34     {}
  35
  36     static BlockMemberInfo getDefaultBlockInfo()
  37     {
  38         return BlockMemberInfo(-1, -1, -1, false);
  39     }
  40
  41     int offset;
  42     int arrayStride;
  43     int matrixStride;
  44     bool isRowMajorMatrix;
  45 };
  46
  47 class BlockLayoutEncoder
  48 {
  49   public:
  50     BlockLayoutEncoder();
  51
  52     void encodeInterfaceBlockFields(const std::vector<InterfaceBlockField> &fields);
  53     BlockMemberInfo encodeInterfaceBlockField(const InterfaceBlockField &field);
  54     void encodeType(GLenum type, unsigned int arraySize, bool isRowMajorMatrix);
  55
  56     size_t getBlockSize() const { return mCurrentOffset * BytesPerComponent; }
  57     size_t getCurrentRegister() const { return mCurrentOffset / ComponentsPerRegister; }
  58     size_t getCurrentElement() const { return mCurrentOffset % ComponentsPerRegister; }
  59
  60     virtual void enterAggregateType() = 0;
  61     virtual void exitAggregateType() = 0;
  62
  63     static const size_t BytesPerComponent = 4u;
  64     static const unsigned int ComponentsPerRegister = 4u;
  65
  66   protected:
  67     size_t mCurrentOffset;
  68
  69     void nextRegister();
  70
  71     virtual void getBlockLayoutInfo(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut) = 0;
  72     virtual void advanceOffset(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride) = 0;
  73 };
  74
  75 // Block layout according to the std140 block layout
  76 // See "Standard Uniform Block Layout" in Section 2.11.6 of the OpenGL ES 3.0 specification
  77
  78 class Std140BlockEncoder : public BlockLayoutEncoder
  79 {
  80   public:
  81     Std140BlockEncoder();
  82
  83     virtual void enterAggregateType();
  84     virtual void exitAggregateType();
  85
  86   protected:
  87     virtual void getBlockLayoutInfo(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut);
  88     virtual void advanceOffset(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride);
  89 };
  90
  91 // Block layout packed according to the D3D9 or default D3D10+ register packing rules
  92 // See http://msdn.microsoft.com/en-us/library/windows/desktop/bb509632(v=vs.85).aspx
  93 // The strategy should be ENCODE_LOOSE for D3D9 constant blocks, and ENCODE_PACKED
  94 // for everything else (D3D10+ constant blocks and all attributes/varyings).
  95
  96 class HLSLBlockEncoder : public BlockLayoutEncoder
  97 {
  98   public:
  99     enum HLSLBlockEncoderStrategy
 100     {
 101         ENCODE_PACKED,
 102         ENCODE_LOOSE
 103     };
 104
 105     HLSLBlockEncoder(HLSLBlockEncoderStrategy strategy);
 106
 107     virtual void enterAggregateType();
 108     virtual void exitAggregateType();
 109     void skipRegisters(unsigned int numRegisters);
 110
 111     bool isPacked() const { return mEncoderStrategy == ENCODE_PACKED; }
 112
 113     static HLSLBlockEncoderStrategy GetStrategyFor(ShShaderOutput outputType);
 114
 115   protected:
 116     virtual void getBlockLayoutInfo(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut);
 117     virtual void advanceOffset(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride);
 118
 119     HLSLBlockEncoderStrategy mEncoderStrategy;
 120 };
 121
 122 // This method returns the number of used registers for a ShaderVariable. It is dependent on the HLSLBlockEncoder
 123 // class to count the number of used registers in a struct (which are individually packed according to the same rules).
 124 unsigned int HLSLVariableRegisterCount(const Varying &variable);
 125 unsigned int HLSLVariableRegisterCount(const Uniform &variable, ShShaderOutput outputType);
 126
 127 }
 128
 129 #endif // COMMON_BLOCKLAYOUT_H_