kc3-lang/angle/src/compiler/OutputHLSL.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2013-08-30 13:21:10
  Hash : 94599669
  Message : Ensure struct varyings maintain the proper interpolation qualifier for the child fields. TRAC #23749 Signed-off-by: Geoff Lang Signed-off-by: Nicolas Capens

• src/compiler/OutputHLSL.h

• //
  // Copyright (c) 2002-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.
  //
  
  #ifndef COMPILER_OUTPUTHLSL_H_
  #define COMPILER_OUTPUTHLSL_H_
  
  #include <list>
  #include <set>
  #include <map>
  
  #define GL_APICALL
  #include <GLES3/gl3.h>
  #include <GLES2/gl2.h>
  
  #include "compiler/intermediate.h"
  #include "compiler/ParseHelper.h"
  #include "compiler/ShaderVariable.h"
  
  namespace sh
  {
  class UnfoldShortCircuit;
  
  class OutputHLSL : public TIntermTraverser
  {
    public:
      OutputHLSL(TParseContext &context, const ShBuiltInResources& resources, ShShaderOutput outputType);
      ~OutputHLSL();
  
      void output();
  
      TInfoSinkBase &getBodyStream();
      const std::vector<Uniform> &getUniforms();
      const ActiveInterfaceBlocks &getInterfaceBlocks() const;
      const std::vector<Attribute> &getOutputVariables() const;
      const std::vector<Attribute> &getAttributes() const;
      const std::vector<Varying> &getVaryings() const;
  
      TString typeString(const TType &type);
      TString textureString(const TType &type);
      TString samplerString(const TType &type);
      TString interpolationString(TQualifier qualifier);
      TString structureString(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing);
      TString structureTypeName(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing);
      static TString qualifierString(TQualifier qualifier);
      static TString arrayString(const TType &type);
      static TString initializer(const TType &type);
      static TString decorate(const TString &string);                      // Prepends an underscore to avoid naming clashes
      static TString decorateUniform(const TString &string, const TType &type);
      static TString decorateField(const TString &string, const TStructure &structure);
  
    protected:
      void header();
  
      // Visit AST nodes and output their code to the body stream
      void visitSymbol(TIntermSymbol*);
      void visitConstantUnion(TIntermConstantUnion*);
      bool visitBinary(Visit visit, TIntermBinary*);
      bool visitUnary(Visit visit, TIntermUnary*);
      bool visitSelection(Visit visit, TIntermSelection*);
      bool visitAggregate(Visit visit, TIntermAggregate*);
      bool visitLoop(Visit visit, TIntermLoop*);
      bool visitBranch(Visit visit, TIntermBranch*);
  
      void traverseStatements(TIntermNode *node);
      bool isSingleStatement(TIntermNode *node);
      bool handleExcessiveLoop(TIntermLoop *node);
      void outputTriplet(Visit visit, const TString &preString, const TString &inString, const TString &postString);
      void outputLineDirective(int line);
      TString argumentString(const TIntermSymbol *symbol);
      int vectorSize(const TType &type) const;
  
      void addConstructor(const TType &type, const TString &name, const TIntermSequence *parameters);
      const ConstantUnion *writeConstantUnion(const TType &type, const ConstantUnion *constUnion);
  
      TString scopeString(unsigned int depthLimit);
      TString scopedStruct(const TString &typeName);
      TString structLookup(const TString &typeName);
  
      TParseContext &mContext;
      const ShShaderOutput mOutputType;
      UnfoldShortCircuit *mUnfoldShortCircuit;
      bool mInsideFunction;
  
      // Output streams
      TInfoSinkBase mHeader;
      TInfoSinkBase mBody;
      TInfoSinkBase mFooter;
  
      typedef std::map<TString, TIntermSymbol*> ReferencedSymbols;
      ReferencedSymbols mReferencedUniforms;
      ReferencedSymbols mReferencedInterfaceBlocks;
      ReferencedSymbols mReferencedAttributes;
      ReferencedSymbols mReferencedVaryings;
      ReferencedSymbols mReferencedOutputVariables;
  
      struct TextureFunction
      {
          enum Method
          {
              IMPLICIT,   // Mipmap LOD determined implicitly (standard lookup)
              BIAS,
              LOD,
              LOD0,
              SIZE   // textureSize()
          };
  
          TBasicType sampler;
          int coords;
          bool proj;
          Method method;
  
          TString name() const;
  
          bool operator<(const TextureFunction &rhs) const;
      };
  
      typedef std::set<TextureFunction> TextureFunctionSet;
  
      // Parameters determining what goes in the header output
      TextureFunctionSet mUsesTexture;
      bool mUsesFragColor;
      bool mUsesFragData;
      bool mUsesDepthRange;
      bool mUsesFragCoord;
      bool mUsesPointCoord;
      bool mUsesFrontFacing;
      bool mUsesPointSize;
      bool mUsesFragDepth;
      bool mUsesXor;
      bool mUsesMod1;
      bool mUsesMod2v;
      bool mUsesMod2f;
      bool mUsesMod3v;
      bool mUsesMod3f;
      bool mUsesMod4v;
      bool mUsesMod4f;
      bool mUsesFaceforward1;
      bool mUsesFaceforward2;
      bool mUsesFaceforward3;
      bool mUsesFaceforward4;
      bool mUsesAtan2_1;
      bool mUsesAtan2_2;
      bool mUsesAtan2_3;
      bool mUsesAtan2_4;
  
      int mNumRenderTargets;
  
      typedef std::set<TString> Constructors;
      Constructors mConstructors;
  
      typedef std::set<TString> StructNames;
      StructNames mStructNames;
  
      typedef std::list<TString> StructDeclarations;
      StructDeclarations mStructDeclarations;
  
      typedef std::vector<int> ScopeBracket;
      ScopeBracket mScopeBracket;
      unsigned int mScopeDepth;
  
      int mUniqueIndex;   // For creating unique names
  
      bool mContainsLoopDiscontinuity;
      bool mOutputLod0Function;
      bool mInsideDiscontinuousLoop;
  
      TIntermSymbol *mExcessiveLoopIndex;
  
      int mUniformRegister;
      int mInterfaceBlockRegister;
      int mSamplerRegister;
      int mPaddingCounter;
  
      TString registerString(TIntermSymbol *operand);
      int samplerRegister(TIntermSymbol *sampler);
      int uniformRegister(TIntermSymbol *uniform);
      void declareInterfaceBlockField(const TType &type, const TString &name, std::vector<InterfaceBlockField>& output);
      Uniform declareUniformToList(const TType &type, const TString &name, int registerIndex, std::vector<Uniform>& output);
      void declareUniform(const TType &type, const TString &name, int index);
      void declareVaryingToList(const TType &type, TQualifier baseTypeQualifier, const TString &name, std::vector<Varying>& fieldsOut);
  
      // Returns the uniform's register index
      int declareUniformAndAssignRegister(const TType &type, const TString &name);
  
      TString interfaceBlockFieldString(const TInterfaceBlock &interfaceBlock, const TField &field);
      TString decoratePrivate(const TString &privateText);
      TString interfaceBlockStructNameString(const TInterfaceBlock &interfaceBlockType);
      TString interfaceBlockInstanceString(const TInterfaceBlock& interfaceBlock, unsigned int arrayIndex);
      TString interfaceBlockFieldTypeString(const TField &field, TLayoutBlockStorage blockStorage);
      TString interfaceBlockFieldString(const TInterfaceBlock &interfaceBlock, TLayoutBlockStorage blockStorage);
      TString interfaceBlockStructString(const TInterfaceBlock &interfaceBlock);
      TString interfaceBlockString(const TInterfaceBlock &interfaceBlock, unsigned int registerIndex, unsigned int arrayIndex);
      TString std140PrePaddingString(const TType &type, int *elementIndex);
      TString std140PostPaddingString(const TType &type, bool useHLSLRowMajorPacking);
      TString structInitializerString(int indent, const TStructure &structure, const TString &rhsStructName);
      
      static GLenum glVariableType(const TType &type);
      static GLenum glVariablePrecision(const TType &type);
      static bool isVaryingIn(TQualifier qualifier);
      static bool isVaryingOut(TQualifier qualifier);
      static bool isVarying(TQualifier qualifier);
  
      std::vector<Uniform> mActiveUniforms;
      ActiveInterfaceBlocks mActiveInterfaceBlocks;
      std::vector<Attribute> mActiveOutputVariables;
      std::vector<Attribute> mActiveAttributes;
      std::vector<Varying> mActiveVaryings;
      std::map<TString, int> mStd140StructElementIndexes;
      std::map<TIntermTyped*, TString> mFlaggedStructMappedNames;
      std::map<TIntermTyped*, TString> mFlaggedStructOriginalNames;
  
      void makeFlaggedStructMaps(const std::vector<TIntermTyped *> &flaggedStructs);
  };
  }
  
  #endif   // COMPILER_OUTPUTHLSL_H_