ANGLE: upgrade to 2.1~07d49ef5350a

This version of ANGLE provides partial ES3 support, numerous
bug fixes, and several potentially useful vendor extensions.

All patches have been rebased. The following changes are noted:

0000-General-fixes-for-ANGLE-2.1.patch
  contains compile fixes for the new ANGLE

0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch
  has incorporated patch 0015.

0007-Make-DX9-DX11-mutually-exclusive.patch
  has been removed as it was fixed upstream.

0007-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
  has been moved up to fill the patch number gap.

0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch
  now contains patch 0014 and 0017.

0013-ANGLE-Allow-for-universal-program-binaries.patch
  has been removed as it is no longer relevant.

0014-ANGLE-D3D11-Fix-internal-index-buffer-for-level-9-ha.patch
  has been merged with patch 0010.

0015-ANGLE-Don-t-export-DLLMain-functions-for-static-buil.patch
  has been merged with patch 0004.

0016-ANGLE-WinRT-Call-Trim-when-application-suspends.patch
  has been removed and will be replaced by a follow-up patch using a
  different technique.

0017-ANGLE-D3D11-Don-t-use-mipmaps-in-level-9-textures.patch
  has been merged with patch 0010.

0018-ANGLE-WinRT-Create-swap-chain-using-physical-resolut.patch
  has been removed and will be replaced by a follow-up patch extending
  the EGL_ANGLE_window_fixed_size extension.

0019-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
  is now patch 0007.

[ChangeLog][Third-party libraries] ANGLE has been upgraded to
version 2.1, bringing partial support for OpenGL ES3 over
Direct3D 11, numerous bug fixes, and several new vendor extensions.

Change-Id: I6d95ce1480462d67228d83c1e5c74a1706b5b21c
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>

1 files changed, 62 insertions, 56 deletions

diff --git a/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h b/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h
index 3afd8e9ada..78bb741a11 100644
--- a/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h
+++ b/src/3rdparty/angle/src/compiler/translator/OutputHLSL.h
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-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.
 //
@@ -11,16 +11,18 @@
 #include <set>
 #include <map>
 
-#define GL_APICALL
-#include <GLES2/gl2.h>
-
+#include "angle_gl.h"
 #include "compiler/translator/intermediate.h"
 #include "compiler/translator/ParseContext.h"
-#include "compiler/translator/Uniform.h"
+#include "common/shadervars.h"
 
 namespace sh
 {
 class UnfoldShortCircuit;
+class StructureHLSL;
+class UniformHLSL;
+
+typedef std::map<TString, TIntermSymbol*> ReferencedSymbols;
 
 class OutputHLSL : public TIntermTraverser
 {
@@ -31,22 +33,23 @@ class OutputHLSL : public TIntermTraverser
     void output();
 
     TInfoSinkBase &getBodyStream();
-    const ActiveUniforms &getUniforms();
+    const std::vector<sh::Uniform> &getUniforms();
+    const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const;
+    const std::vector<sh::Attribute> &getOutputVariables() const;
+    const std::vector<sh::Attribute> &getAttributes() const;
+    const std::vector<sh::Varying> &getVaryings() const;
+
+    const std::map<std::string, unsigned int> &getInterfaceBlockRegisterMap() const;
+    const std::map<std::string, unsigned int> &getUniformRegisterMap() const;
 
-    TString typeString(const TType &type);
-    TString textureString(const TType &type);
-    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 TType &structure);
 
   protected:
     void header();
 
     // 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*);
@@ -63,13 +66,9 @@ class OutputHLSL : public TIntermTraverser
     TString argumentString(const TIntermSymbol *symbol);
     int vectorSize(const TType &type) const;
 
-    void addConstructor(const TType &type, const TString &name, const TIntermSequence *parameters);
+    void outputConstructor(Visit visit, 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;
@@ -80,27 +79,44 @@ class OutputHLSL : public TIntermTraverser
     TInfoSinkBase mBody;
     TInfoSinkBase mFooter;
 
-    typedef std::map<TString, TIntermSymbol*> ReferencedSymbols;
     ReferencedSymbols mReferencedUniforms;
+    ReferencedSymbols mReferencedInterfaceBlocks;
     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;
 
     // Parameters determining what goes in the header output
-    bool mUsesTexture2D;
-    bool mUsesTexture2D_bias;
-    bool mUsesTexture2DLod;
-    bool mUsesTexture2DProj;
-    bool mUsesTexture2DProj_bias;
-    bool mUsesTexture2DProjLod;
-    bool mUsesTextureCube;
-    bool mUsesTextureCube_bias;
-    bool mUsesTextureCubeLod;
-    bool mUsesTexture2DLod0;
-    bool mUsesTexture2DLod0_bias;
-    bool mUsesTexture2DProjLod0;
-    bool mUsesTexture2DProjLod0_bias;
-    bool mUsesTextureCubeLod0;
-    bool mUsesTextureCubeLod0_bias;
+    TextureFunctionSet mUsesTexture;
     bool mUsesFragColor;
     bool mUsesFragData;
     bool mUsesDepthRange;
@@ -126,42 +142,32 @@ class OutputHLSL : public TIntermTraverser
     bool mUsesAtan2_3;
     bool mUsesAtan2_4;
     bool mUsesDiscardRewriting;
+    bool mUsesNestedBreak;
 
     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;
+    int mNestedLoopDepth;
 
     TIntermSymbol *mExcessiveLoopIndex;
 
-    int mUniformRegister;
-    int mSamplerRegister;
+    void declareVaryingToList(const TType &type, TQualifier baseTypeQualifier, const TString &name, std::vector<sh::Varying>& fieldsOut);
 
-    TString registerString(TIntermSymbol *operand);
-    int samplerRegister(TIntermSymbol *sampler);
-    int uniformRegister(TIntermSymbol *uniform);
-    void declareUniform(const TType &type, const TString &name, int index);
-    static GLenum glVariableType(const TType &type);
-    static GLenum glVariablePrecision(const TType &type);
+    TString structInitializerString(int indent, const TStructure &structure, const TString &rhsStructName);
 
-    ActiveUniforms mActiveUniforms;
+    std::vector<sh::Attribute> mActiveOutputVariables;
+    std::vector<sh::Attribute> mActiveAttributes;
+    std::vector<sh::Varying> mActiveVaryings;
+    std::map<TIntermTyped*, TString> mFlaggedStructMappedNames;
+    std::map<TIntermTyped*, TString> mFlaggedStructOriginalNames;
+
+    void makeFlaggedStructMaps(const std::vector<TIntermTyped *> &flaggedStructs);
 };
+
 }
 
 #endif   // COMPILER_OUTPUTHLSL_H_