diff options
Diffstat (limited to 'src/3rdparty/angle/src/compiler/translator/OutputHLSL.h')
-rw-r--r-- | src/3rdparty/angle/src/compiler/translator/OutputHLSL.h | 186 |
1 files changed, 94 insertions, 92 deletions
diff --git a/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h b/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h index 8756d0ba4c..014f4f5002 100644 --- a/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h +++ b/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h @@ -8,67 +8,94 @@ #define COMPILER_TRANSLATOR_OUTPUTHLSL_H_ #include <list> -#include <set> #include <map> #include <stack> #include "angle_gl.h" #include "compiler/translator/ASTMetadataHLSL.h" -#include "compiler/translator/IntermNode.h" -#include "compiler/translator/ParseContext.h" +#include "compiler/translator/Compiler.h" +#include "compiler/translator/FlagStd140Structs.h" +#include "compiler/translator/IntermTraverse.h" class BuiltInFunctionEmulator; namespace sh { -class UnfoldShortCircuit; class StructureHLSL; +class TextureFunctionHLSL; +class TSymbolTable; +class ImageFunctionHLSL; +class UnfoldShortCircuit; class UniformHLSL; -typedef std::map<TString, TIntermSymbol*> ReferencedSymbols; +typedef std::map<TString, TIntermSymbol *> ReferencedSymbols; class OutputHLSL : public TIntermTraverser { public: - OutputHLSL(sh::GLenum shaderType, int shaderVersion, - const TExtensionBehavior &extensionBehavior, - const char *sourcePath, ShShaderOutput outputType, - int numRenderTargets, const std::vector<Uniform> &uniforms, - int compileOptions); + OutputHLSL(sh::GLenum shaderType, + int shaderVersion, + const TExtensionBehavior &extensionBehavior, + const char *sourcePath, + ShShaderOutput outputType, + int numRenderTargets, + const std::vector<Uniform> &uniforms, + ShCompileOptions compileOptions, + TSymbolTable *symbolTable, + PerformanceDiagnostics *perfDiagnostics); ~OutputHLSL(); void output(TIntermNode *treeRoot, TInfoSinkBase &objSink); - const std::map<std::string, unsigned int> &getInterfaceBlockRegisterMap() const; + const std::map<std::string, unsigned int> &getUniformBlockRegisterMap() const; const std::map<std::string, unsigned int> &getUniformRegisterMap() const; static TString initializer(const TType &type); - TInfoSinkBase &getInfoSink() { ASSERT(!mInfoSinkStack.empty()); return *mInfoSinkStack.top(); } + TInfoSinkBase &getInfoSink() + { + ASSERT(!mInfoSinkStack.empty()); + return *mInfoSinkStack.top(); + } static bool canWriteAsHLSLLiteral(TIntermTyped *expression); protected: - void header(TInfoSinkBase &out, const BuiltInFunctionEmulator *builtInFunctionEmulator); + void header(TInfoSinkBase &out, + const std::vector<MappedStruct> &std140Structs, + const BuiltInFunctionEmulator *builtInFunctionEmulator) const; + + void writeFloat(TInfoSinkBase &out, float f); + void writeSingleConstant(TInfoSinkBase &out, const TConstantUnion *const constUnion); + const TConstantUnion *writeConstantUnionArray(TInfoSinkBase &out, + const TConstantUnion *const constUnion, + const size_t size); // Visit AST nodes and output their code to the body stream - void visitSymbol(TIntermSymbol*); - void visitRaw(TIntermRaw*); - void visitConstantUnion(TIntermConstantUnion*); - bool visitBinary(Visit visit, TIntermBinary*); - bool visitUnary(Visit visit, TIntermUnary*); - bool visitSelection(Visit visit, TIntermSelection*); - bool visitSwitch(Visit visit, TIntermSwitch *); - bool visitCase(Visit visit, TIntermCase *); - bool visitAggregate(Visit visit, TIntermAggregate*); - bool visitLoop(Visit visit, TIntermLoop*); - bool visitBranch(Visit visit, TIntermBranch*); - - bool isSingleStatement(TIntermNode *node); + void visitSymbol(TIntermSymbol *) override; + void visitRaw(TIntermRaw *) override; + void visitConstantUnion(TIntermConstantUnion *) override; + bool visitSwizzle(Visit visit, TIntermSwizzle *node) override; + bool visitBinary(Visit visit, TIntermBinary *) override; + bool visitUnary(Visit visit, TIntermUnary *) override; + bool visitTernary(Visit visit, TIntermTernary *) override; + bool visitIfElse(Visit visit, TIntermIfElse *) override; + bool visitSwitch(Visit visit, TIntermSwitch *) override; + bool visitCase(Visit visit, TIntermCase *) override; + bool visitFunctionPrototype(Visit visit, TIntermFunctionPrototype *node) override; + bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override; + bool visitAggregate(Visit visit, TIntermAggregate *) override; + bool visitBlock(Visit visit, TIntermBlock *node) override; + bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node) override; + bool visitDeclaration(Visit visit, TIntermDeclaration *node) override; + bool visitLoop(Visit visit, TIntermLoop *) override; + bool visitBranch(Visit visit, TIntermBranch *) override; + bool handleExcessiveLoop(TInfoSinkBase &out, TIntermLoop *node); - // Emit one of three strings depending on traverse phase. Called with literal strings so using const char* instead of TString. + // Emit one of three strings depending on traverse phase. Called with literal strings so using + // const char* instead of TString. void outputTriplet(TInfoSinkBase &out, Visit visit, const char *preString, @@ -76,32 +103,28 @@ class OutputHLSL : public TIntermTraverser const char *postString); void outputLineDirective(TInfoSinkBase &out, int line); TString argumentString(const TIntermSymbol *symbol); - int vectorSize(const TType &type) const; - - // Emit constructor. Called with literal names so using const char* instead of TString. - void outputConstructor(TInfoSinkBase &out, - Visit visit, - const TType &type, - const char *name, - const TIntermSequence *parameters); + + void outputConstructor(TInfoSinkBase &out, Visit visit, TIntermAggregate *node); const TConstantUnion *writeConstantUnion(TInfoSinkBase &out, const TType &type, const TConstantUnion *constUnion); void outputEqual(Visit visit, const TType &type, TOperator op, TInfoSinkBase &out); + void outputAssign(Visit visit, const TType &type, TInfoSinkBase &out); - void writeEmulatedFunctionTriplet(TInfoSinkBase &out, Visit visit, const char *preStr); - void makeFlaggedStructMaps(const std::vector<TIntermTyped *> &flaggedStructs); + void writeEmulatedFunctionTriplet(TInfoSinkBase &out, Visit visit, TOperator op); - // Returns true if it found a 'same symbol' initializer (initializer that references the variable it's initting) - bool writeSameSymbolInitializer(TInfoSinkBase &out, TIntermSymbol *symbolNode, TIntermTyped *expression); + // Returns true if it found a 'same symbol' initializer (initializer that references the + // variable it's initting) + bool writeSameSymbolInitializer(TInfoSinkBase &out, + TIntermSymbol *symbolNode, + TIntermTyped *expression); // Returns true if variable initializer could be written using literal {} notation. bool writeConstantInitialization(TInfoSinkBase &out, TIntermSymbol *symbolNode, TIntermTyped *expression); - void writeDeferredGlobalInitializers(TInfoSinkBase &out); - void writeSelection(TInfoSinkBase &out, TIntermSelection *node); + void writeIfElse(TInfoSinkBase &out, TIntermIfElse *node); // Returns the function name TString addStructEqualityFunction(const TStructure &structure); @@ -117,7 +140,7 @@ class OutputHLSL : public TIntermTraverser const TExtensionBehavior &mExtensionBehavior; const char *mSourcePath; const ShShaderOutput mOutputType; - int mCompileOptions; + ShCompileOptions mCompileOptions; bool mInsideFunction; @@ -126,49 +149,23 @@ class OutputHLSL : public TIntermTraverser TInfoSinkBase mBody; TInfoSinkBase mFooter; - // A stack is useful when we want to traverse in the header, or in helper functions, but not always - // write to the body. Instead use an InfoSink stack to keep our current state intact. + // A stack is useful when we want to traverse in the header, or in helper functions, but not + // always write to the body. Instead use an InfoSink stack to keep our current state intact. // TODO (jmadill): Just passing an InfoSink in function parameters would be simpler. std::stack<TInfoSinkBase *> mInfoSinkStack; ReferencedSymbols mReferencedUniforms; - ReferencedSymbols mReferencedInterfaceBlocks; + ReferencedSymbols mReferencedUniformBlocks; ReferencedSymbols mReferencedAttributes; ReferencedSymbols mReferencedVaryings; ReferencedSymbols mReferencedOutputVariables; StructureHLSL *mStructureHLSL; UniformHLSL *mUniformHLSL; - - struct TextureFunction - { - enum Method - { - IMPLICIT, // Mipmap LOD determined implicitly (standard lookup) - BIAS, - LOD, - LOD0, - LOD0BIAS, - SIZE, // textureSize() - FETCH, - GRAD - }; - - TBasicType sampler; - int coords; - bool proj; - bool offset; - Method method; - - TString name() const; - - bool operator<(const TextureFunction &rhs) const; - }; - - typedef std::set<TextureFunction> TextureFunctionSet; + TextureFunctionHLSL *mTextureFunctionHLSL; + ImageFunctionHLSL *mImageFunctionHLSL; // Parameters determining what goes in the header output - TextureFunctionSet mUsesTexture; bool mUsesFragColor; bool mUsesFragData; bool mUsesDepthRange; @@ -177,16 +174,23 @@ class OutputHLSL : public TIntermTraverser bool mUsesFrontFacing; bool mUsesPointSize; bool mUsesInstanceID; + bool mHasMultiviewExtensionEnabled; + bool mUsesViewID; + bool mUsesVertexID; bool mUsesFragDepth; + bool mUsesNumWorkGroups; + bool mUsesWorkGroupID; + bool mUsesLocalInvocationID; + bool mUsesGlobalInvocationID; + bool mUsesLocalInvocationIndex; bool mUsesXor; bool mUsesDiscardRewriting; bool mUsesNestedBreak; bool mRequiresIEEEStrictCompiling; - int mNumRenderTargets; - int mUniqueIndex; // For creating unique names + int mUniqueIndex; // For creating unique names CallDAG mCallDag; MetadataList mASTMetadataList; @@ -197,15 +201,7 @@ class OutputHLSL : public TIntermTraverser TIntermSymbol *mExcessiveLoopIndex; - TString structInitializerString(int indent, const TStructure &structure, const TString &rhsStructName); - - std::map<TIntermTyped*, TString> mFlaggedStructMappedNames; - std::map<TIntermTyped*, TString> mFlaggedStructOriginalNames; - - // Some initializers may have been unfolded into if statements, thus we can't evaluate all initializers - // at global static scope in HLSL. Instead, we can initialize these static globals inside a helper function. - // This also enables initialization of globals with uniforms. - TIntermSequence mDeferredGlobalInitializers; + TString structInitializerString(int indent, const TType &type, const TString &name) const; struct HelperFunction { @@ -219,28 +215,34 @@ class OutputHLSL : public TIntermTraverser // which we add the functions, since nested structures call each other recursively, and // structure equality functions may need to call array equality functions and vice versa. // The ownership of the pointers is maintained by the type-specific arrays. - std::vector<HelperFunction*> mEqualityFunctions; + std::vector<HelperFunction *> mEqualityFunctions; struct StructEqualityFunction : public HelperFunction { const TStructure *structure; }; - std::vector<StructEqualityFunction*> mStructEqualityFunctions; + std::vector<StructEqualityFunction *> mStructEqualityFunctions; struct ArrayHelperFunction : public HelperFunction { TType type; }; - std::vector<ArrayHelperFunction*> mArrayEqualityFunctions; + std::vector<ArrayHelperFunction *> mArrayEqualityFunctions; std::vector<ArrayHelperFunction> mArrayAssignmentFunctions; - // The construct-into functions are functions that fill an N-element array passed as an out parameter - // with the other N parameters of the function. This is used to work around that arrays can't be - // return values in HLSL. + // The construct-into functions are functions that fill an N-element array passed as an out + // parameter with the other N parameters of the function. This is used to work around that + // arrays can't be return values in HLSL. std::vector<ArrayHelperFunction> mArrayConstructIntoFunctions; -}; + PerformanceDiagnostics *mPerfDiagnostics; + + private: + TString generateStructMapping(const std::vector<MappedStruct> &std140Structs) const; + TString samplerNamePrefixFromStruct(TIntermTyped *node); + bool ancestorEvaluatesToSamplerInStruct(); +}; } -#endif // COMPILER_TRANSLATOR_OUTPUTHLSL_H_ +#endif // COMPILER_TRANSLATOR_OUTPUTHLSL_H_ |