Upgrade ANGLE to 1.3.5bb7ec572d0a

This brings Qt's copy of ANGLE up to ANGLE master, which contains a number
of bugfixes as well as restructuring for the upcoming ES 3.0 support. This
version brings considerable stability improvements to the D3D11 renderer.

The static translator project files have been merged to align with the
ANGLE source tree.

Two new patches have been applied to fix errors in upstream ANGLE:
- 0011-ANGLE-Fix-compilation-error-on-MinGW-caused-by-trace.patch
  The event trace header in ANGLE's third_party directory has an unused
  template which causes a compilation error on MinGW. Disable this part
  of the code.
- 0012-ANGLE-fix-semantic-index-lookup.patch
  The sorted semantic index table was returning a direct mapping to the
  new indices, instead of the old indices. This caused a mismatch in the
  GL type lookup for the translated attribute.

All other patches have been rebased, removed if no longer needed,
and renamed to clear up the application order:
- 0001-Fix-compilation-for-MSVC-2008-and-std-tuple.patch
  No changes.
- 0001-Fix-compilation-with-MinGW-mingw-tdm64-gcc-4.8.1.patch
  No changes. Renamed to 0002.
- 0001-Fix-compilation-with-MinGW-gcc-64-bit.patch
  No changes. Renamed to 0003.
- 0001-Make-it-possible-to-link-ANGLE-statically-for-single.patch
  Modified patch to adapt to new DLL loading structure. Renamed to 0004.
- 0005-Fix-build-when-SSE2-is-not-available.patch
  No changes.
- 0011-Fix-compilation-of-libGLESv2-with-older-MinGW-w64-he.patch
  No changes. Renamed to 0006.
- 0006-Make-DX9-DX11-mutually-exclusive.patch
  Made the patch less invasive by allowing D3D9 code to run unless
  explicitly disabled (e.g. on WinRT, where it doesn't compile). This
  makes the patch smaller and allows Desktop Windows to compile both
  D3D9 and D3D11 codepaths. Renamed to 0007.
- 0015-ANGLE-Dynamically-load-D3D-compiler-from-a-list-of-k.patch
  No changes. Renamed to 0008.
- 0012-ANGLE-Support-WinRT.patch
  Made D3D11_level9 initialization only possible if D3D9 is disabled.
  This makes sure Desktop PCs use the old D3D9 codepath instead of
  the less-tested D3D11_level9 codepath. Renamed to 0009.
- 0013-Enable-D3D11-for-feature-level-9-cards.patch
  Conveniently smaller patch due to buffer implementation improvements
  upstream. Renamed to 0010.
- 0014-ANGLE-D3D11-Alwayls-execute-QueryInterface.patch
  This was a fix for patch 0009, so was integrated there. Removed.
- 0016-ANGLE-D3D11-Fix-build-on-desktop-Windows.patch
  This was a fix for patch 0009, so it was integrated there. Removed.
- 0001-ANGLE-Fix-compilation-with-MSVC2013.patch
  Fixed upstream. Removed.
- 0007-ANGLE-Fix-typedefs-for-Win64.patch
  Fixed upstream. Removed.
- 0004-Fix-black-screen-after-minimizing-OpenGL-window-with.patch
  The issue has been fixed in Qt itself. Removed.
- 0008-DX11-Prevent-assert-when-view-is-minimized-or-.patch
  The cause of the problem was the same as patch 0004, but for the
  D3D11 codepath. Removed.

Change-Id: Id69484ab3a3e013050741c462fb1b06dfb0fd112
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
Reviewed-by: Kai Koehne <kai.koehne@digia.com>
Reviewed-by: Oliver Wolff <oliver.wolff@digia.com>

1 files changed, 356 insertions, 0 deletions

diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Renderer9.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Renderer9.h
new file mode 100644
index 0000000000..24fd2bdd84
--- /dev/null
+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Renderer9.h
@@ -0,0 +1,356 @@
+//
+// Copyright (c) 2012-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.
+//
+
+// Renderer9.h: Defines a back-end specific class for the D3D9 renderer.
+
+#ifndef LIBGLESV2_RENDERER_RENDERER9_H_
+#define LIBGLESV2_RENDERER_RENDERER9_H_
+
+#include "common/angleutils.h"
+#include "libGLESv2/mathutil.h"
+#include "libGLESv2/renderer/ShaderCache.h"
+#include "libGLESv2/renderer/d3d9/VertexDeclarationCache.h"
+#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/RenderTarget.h"
+
+namespace gl
+{
+class Renderbuffer;
+}
+
+namespace rx
+{
+class VertexDataManager;
+class IndexDataManager;
+class StreamingIndexBufferInterface;
+struct TranslatedAttribute;
+
+class Renderer9 : public Renderer
+{
+  public:
+    Renderer9(egl::Display *display, HDC hDc, bool softwareDevice);
+    virtual ~Renderer9();
+
+    static Renderer9 *makeRenderer9(Renderer *renderer);
+
+    virtual EGLint initialize();
+    virtual bool resetDevice();
+
+    virtual int generateConfigs(ConfigDesc **configDescList);
+    virtual void deleteConfigs(ConfigDesc *configDescList);
+
+    void startScene();
+    void endScene();
+
+    virtual void sync(bool block);
+
+    virtual SwapChain *createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat);
+
+    IDirect3DQuery9* allocateEventQuery();
+    void freeEventQuery(IDirect3DQuery9* query);
+
+    // resource creation
+    IDirect3DVertexShader9 *createVertexShader(const DWORD *function, size_t length);
+    IDirect3DPixelShader9 *createPixelShader(const DWORD *function, size_t length);
+    HRESULT createVertexBuffer(UINT Length, DWORD Usage, IDirect3DVertexBuffer9 **ppVertexBuffer);
+    HRESULT createIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, IDirect3DIndexBuffer9 **ppIndexBuffer);
+#if 0
+    void *createTexture2D();
+    void *createTextureCube();
+    void *createQuery();
+    void *createIndexBuffer();
+    void *createVertexbuffer();
+
+    // state setup
+    void applyShaders();
+    void applyConstants();
+#endif
+    virtual void setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &sampler);
+    virtual void setTexture(gl::SamplerType type, int index, gl::Texture *texture);
+
+    virtual void setRasterizerState(const gl::RasterizerState &rasterState);
+    virtual void setBlendState(gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::Color &blendColor,
+                               unsigned int sampleMask);
+    virtual void setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
+                                      int stencilBackRef, bool frontFaceCCW);
+
+    virtual void setScissorRectangle(const gl::Rectangle &scissor, bool enabled);
+    virtual bool setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
+                             bool ignoreViewport);
+
+    virtual bool applyRenderTarget(gl::Framebuffer *frameBuffer);
+    virtual void applyShaders(gl::ProgramBinary *programBinary);
+    virtual void applyUniforms(gl::ProgramBinary *programBinary, gl::UniformArray *uniformArray);
+    virtual bool applyPrimitiveType(GLenum primitiveType, GLsizei elementCount);
+    virtual GLenum applyVertexBuffer(gl::ProgramBinary *programBinary, gl::VertexAttribute vertexAttributes[], GLint first, GLsizei count, GLsizei instances);
+    virtual GLenum applyIndexBuffer(const GLvoid *indices, gl::Buffer *elementArrayBuffer, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo);
+
+    virtual void drawArrays(GLenum mode, GLsizei count, GLsizei instances);
+    virtual void drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances);
+
+    virtual void clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer);
+
+    virtual void markAllStateDirty();
+
+    // lost device
+    void notifyDeviceLost();
+    virtual bool isDeviceLost();
+    virtual bool testDeviceLost(bool notify);
+    virtual bool testDeviceResettable();
+
+    // Renderer capabilities
+    IDirect3DDevice9 *getDevice() { return mDevice; }
+    virtual DWORD getAdapterVendor() const;
+    virtual std::string getRendererDescription() const;
+    virtual GUID getAdapterIdentifier() const;
+
+    virtual bool getBGRATextureSupport() const;
+    virtual bool getDXT1TextureSupport();
+    virtual bool getDXT3TextureSupport();
+    virtual bool getDXT5TextureSupport();
+    virtual bool getEventQuerySupport();
+    virtual bool getFloat32TextureSupport(bool *filtering, bool *renderable);
+    virtual bool getFloat16TextureSupport(bool *filtering, bool *renderable);
+    virtual bool getLuminanceTextureSupport();
+    virtual bool getLuminanceAlphaTextureSupport();
+    virtual unsigned int getMaxVertexTextureImageUnits() const;
+    virtual unsigned int getMaxCombinedTextureImageUnits() const;
+    virtual unsigned int getReservedVertexUniformVectors() const;
+    virtual unsigned int getReservedFragmentUniformVectors() const;
+    virtual unsigned int getMaxVertexUniformVectors() const;
+    virtual unsigned int getMaxFragmentUniformVectors() const;
+    virtual unsigned int getMaxVaryingVectors() const;
+    virtual bool getNonPower2TextureSupport() const;
+    virtual bool getDepthTextureSupport() const;
+    virtual bool getOcclusionQuerySupport() const;
+    virtual bool getInstancingSupport() const;
+    virtual bool getTextureFilterAnisotropySupport() const;
+    virtual float getTextureMaxAnisotropy() const;
+    virtual bool getShareHandleSupport() const;
+    virtual bool getDerivativeInstructionSupport() const;
+    virtual bool getPostSubBufferSupport() const;
+
+    virtual int getMajorShaderModel() const;
+    virtual float getMaxPointSize() const;
+    virtual int getMaxViewportDimension() const;
+    virtual int getMaxTextureWidth() const;
+    virtual int getMaxTextureHeight() const;
+    virtual bool get32BitIndexSupport() const;
+    DWORD getCapsDeclTypes() const;
+    virtual int getMinSwapInterval() const;
+    virtual int getMaxSwapInterval() const;
+
+    virtual GLsizei getMaxSupportedSamples() const;
+    int getNearestSupportedSamples(D3DFORMAT format, int requested) const;
+    
+    virtual unsigned int getMaxRenderTargets() const;
+
+    D3DFORMAT ConvertTextureInternalFormat(GLint internalformat);
+
+    // Pixel operations
+    virtual bool copyToRenderTarget(TextureStorageInterface2D *dest, TextureStorageInterface2D *source);
+    virtual bool copyToRenderTarget(TextureStorageInterfaceCube *dest, TextureStorageInterfaceCube *source);
+
+    virtual bool copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
+                           GLint xoffset, GLint yoffset, TextureStorageInterface2D *storage, GLint level);
+    virtual bool copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
+                           GLint xoffset, GLint yoffset, TextureStorageInterfaceCube *storage, GLenum target, GLint level);
+
+    virtual bool blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
+                          bool blitRenderTarget, bool blitDepthStencil);
+    virtual void readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
+                            GLsizei outputPitch, bool packReverseRowOrder, GLint packAlignment, void* pixels);
+
+    // RenderTarget creation
+    virtual RenderTarget *createRenderTarget(SwapChain *swapChain, bool depth);
+    virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples, bool depth);
+
+    // Shader operations
+    virtual ShaderExecutable *loadExecutable(const void *function, size_t length, rx::ShaderType type);
+    virtual ShaderExecutable *compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, rx::ShaderType type, D3DWorkaroundType workaround);
+
+    // Image operations
+    virtual Image *createImage();
+    virtual void generateMipmap(Image *dest, Image *source);
+    virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain);
+    virtual TextureStorage *createTextureStorage2D(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
+    virtual TextureStorage *createTextureStorageCube(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size);
+
+    // Buffer creation
+    virtual VertexBuffer *createVertexBuffer();
+    virtual IndexBuffer *createIndexBuffer();
+    virtual BufferStorage *createBufferStorage();
+
+    // Query and Fence creation
+    virtual QueryImpl *createQuery(GLenum type);
+    virtual FenceImpl *createFence();
+
+    // D3D9-renderer specific methods
+    bool boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
+
+    D3DPOOL getTexturePool(DWORD usage) const;
+
+    virtual bool getLUID(LUID *adapterLuid) const;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(Renderer9);
+
+    void deinitialize();
+
+    void applyUniformnfv(gl::Uniform *targetUniform, const GLfloat *v);
+    void applyUniformniv(gl::Uniform *targetUniform, const GLint *v);
+    void applyUniformnbv(gl::Uniform *targetUniform, const GLint *v);
+
+    void drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer);
+    void drawIndexedPoints(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer);
+
+    void getMultiSampleSupport(D3DFORMAT format, bool *multiSampleArray);
+    bool copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged);
+    gl::Renderbuffer *getNullColorbuffer(gl::Renderbuffer *depthbuffer);
+
+    D3DPOOL getBufferPool(DWORD usage) const;
+
+    HMODULE mD3d9Module;
+    HDC mDc;
+
+    void initializeDevice();
+    D3DPRESENT_PARAMETERS getDefaultPresentParameters();
+    void releaseDeviceResources();
+
+    HRESULT getDeviceStatusCode();
+    bool isRemovedDeviceResettable() const;
+    bool resetRemovedDevice();
+
+    UINT mAdapter;
+    D3DDEVTYPE mDeviceType;
+    bool mSoftwareDevice;   // FIXME: Deprecate
+    IDirect3D9 *mD3d9;  // Always valid after successful initialization.
+    IDirect3D9Ex *mD3d9Ex;  // Might be null if D3D9Ex is not supported.
+    IDirect3DDevice9 *mDevice;
+    IDirect3DDevice9Ex *mDeviceEx;  // Might be null if D3D9Ex is not supported.
+
+    Blit *mBlit;
+
+    HWND mDeviceWindow;
+
+    bool mDeviceLost;
+    D3DCAPS9 mDeviceCaps;
+    D3DADAPTER_IDENTIFIER9 mAdapterIdentifier;
+
+    D3DPRIMITIVETYPE mPrimitiveType;
+    int mPrimitiveCount;
+    GLsizei mRepeatDraw;
+
+    bool mSceneStarted;
+    bool mSupportsNonPower2Textures;
+    bool mSupportsTextureFilterAnisotropy;
+    int mMinSwapInterval;
+    int mMaxSwapInterval;
+
+    bool mOcclusionQuerySupport;
+    bool mEventQuerySupport;
+    bool mVertexTextureSupport;
+
+    bool mDepthTextureSupport;
+
+    bool mFloat32TextureSupport;
+    bool mFloat32FilterSupport;
+    bool mFloat32RenderSupport;
+
+    bool mFloat16TextureSupport;
+    bool mFloat16FilterSupport;
+    bool mFloat16RenderSupport;
+
+    bool mDXT1TextureSupport;
+    bool mDXT3TextureSupport;
+    bool mDXT5TextureSupport;
+
+    bool mLuminanceTextureSupport;
+    bool mLuminanceAlphaTextureSupport;
+
+    std::map<D3DFORMAT, bool *> mMultiSampleSupport;
+    GLsizei mMaxSupportedSamples;
+
+    // current render target states
+    unsigned int mAppliedRenderTargetSerial;
+    unsigned int mAppliedDepthbufferSerial;
+    unsigned int mAppliedStencilbufferSerial;
+    bool mDepthStencilInitialized;
+    bool mRenderTargetDescInitialized;
+    rx::RenderTarget::Desc mRenderTargetDesc;
+    unsigned int mCurStencilSize;
+    unsigned int mCurDepthSize;
+
+    IDirect3DStateBlock9 *mMaskedClearSavedState;
+
+    // previously set render states
+    bool mForceSetDepthStencilState;
+    gl::DepthStencilState mCurDepthStencilState;
+    int mCurStencilRef;
+    int mCurStencilBackRef;
+    bool mCurFrontFaceCCW;
+
+    bool mForceSetRasterState;
+    gl::RasterizerState mCurRasterState;
+
+    bool mForceSetScissor;
+    gl::Rectangle mCurScissor;
+    bool mScissorEnabled;
+
+    bool mForceSetViewport;
+    gl::Rectangle mCurViewport;
+    float mCurNear;
+    float mCurFar;
+    float mCurDepthFront;
+
+    bool mForceSetBlendState;
+    gl::BlendState mCurBlendState;
+    gl::Color mCurBlendColor;
+    GLuint mCurSampleMask;
+
+    // Currently applied sampler states
+    bool mForceSetVertexSamplerStates[gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
+    gl::SamplerState mCurVertexSamplerStates[gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
+
+    bool mForceSetPixelSamplerStates[gl::MAX_TEXTURE_IMAGE_UNITS];
+    gl::SamplerState mCurPixelSamplerStates[gl::MAX_TEXTURE_IMAGE_UNITS];
+
+    // Currently applied textures
+    unsigned int mCurVertexTextureSerials[gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS];
+    unsigned int mCurPixelTextureSerials[gl::MAX_TEXTURE_IMAGE_UNITS];
+
+    unsigned int mAppliedIBSerial;
+    unsigned int mAppliedProgramBinarySerial;
+    
+    rx::dx_VertexConstants mVertexConstants;
+    rx::dx_PixelConstants mPixelConstants;
+    bool mDxUniformsDirty;
+
+    // A pool of event queries that are currently unused.
+    std::vector<IDirect3DQuery9*> mEventQueryPool;
+    VertexShaderCache mVertexShaderCache;
+    PixelShaderCache mPixelShaderCache;
+
+    VertexDataManager *mVertexDataManager;
+    VertexDeclarationCache mVertexDeclarationCache;
+
+    IndexDataManager *mIndexDataManager;
+    StreamingIndexBufferInterface *mLineLoopIB;
+
+    enum { NUM_NULL_COLORBUFFER_CACHE_ENTRIES = 12 };
+    struct NullColorbufferCacheEntry
+    {
+        UINT lruCount;
+        int width;
+        int height;
+        gl::Renderbuffer *buffer;
+    } mNullColorbufferCache[NUM_NULL_COLORBUFFER_CACHE_ENTRIES];
+    UINT mMaxNullColorbufferLRU;
+
+};
+
+}
+#endif // LIBGLESV2_RENDERER_RENDERER9_H_