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>
author: Andrew Knight <andrew.knight@digia.com> 2014-08-05 12:59:44 +0300
committer: Andrew Knight <andrew.knight@digia.com> 2014-08-05 16:43:22 +0200
commit: a6a12d8c0fc918972c15268f749ecc7c90b95d6c (patch)
tree: cb6d986d30ef97e932ab51768854d5d9b46729d3 /src/angle/patches
parent: 14f9c09542bd6cc19430473da9ce4c68f239ec7d (diff)
20 files changed, 2272 insertions, 2121 deletions
diff --git a/src/angle/patches/0000-General-fixes-for-ANGLE-2.1.patch b/src/angle/patches/0000-General-fixes-for-ANGLE-2.1.patch
new file mode 100644
index 0000000000..570ae63767
--- /dev/null
+++ b/src/angle/patches/0000-General-fixes-for-ANGLE-2.1.patch
@@ -0,0 +1,568 @@
+From 7597b9363748afc84d682dd9ef5bc8bc272812f3 Mon Sep 17 00:00:00 2001
+From: Andrew Knight <andrew.knight@digia.com>
+Date: Tue, 5 Aug 2014 09:21:44 +0300
+Subject: [PATCH] General fixes for ANGLE 2.1
+
+- Fix commit.h include (use hard-coded version)
+- Fix undefined intptr_t in egl.h and eglext.h
+- Fix export mismatch caused by angle_gl.h
+- Remove D3D9 d3dcompiler.h include requirement in the translator
+- Normalize all precompiled shader names and includes
+
+Change-Id: I22254aed62e89a26756ca0784bae95909189c0f9
+---
+ src/3rdparty/angle/include/EGL/egl.h               |  2 +-
+ src/3rdparty/angle/include/EGL/eglext.h            |  2 +-
+ src/3rdparty/angle/include/angle_gl.h              |  3 +
+ src/3rdparty/angle/src/common/platform.h           |  5 +-
+ src/3rdparty/angle/src/common/version.h            |  2 +-
+ src/3rdparty/angle/src/libEGL/Config.h             |  1 -
+ src/3rdparty/angle/src/libEGL/Display.cpp          |  3 +-
+ src/3rdparty/angle/src/libEGL/Surface.h            |  1 -
+ src/3rdparty/angle/src/libEGL/main.h               |  1 +
+ src/3rdparty/angle/src/libGLESv2/Context.h         |  1 -
+ src/3rdparty/angle/src/libGLESv2/formatutils.h     |  2 +-
+ src/3rdparty/angle/src/libGLESv2/main.h            |  3 +
+ src/3rdparty/angle/src/libGLESv2/precompiled.h     |  1 +
+ .../angle/src/libGLESv2/renderer/IndexRangeCache.h |  2 +-
+ .../angle/src/libGLESv2/renderer/Renderer.h        |  1 +
+ .../angle/src/libGLESv2/renderer/copyimage.h       |  2 +-
+ .../src/libGLESv2/renderer/d3d/HLSLCompiler.cpp    |  2 +
+ .../src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp    | 66 +++++++++++-----------
+ .../src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp   | 12 ++--
+ .../renderer/d3d/d3d11/PixelTransfer11.cpp         | 10 ++--
+ .../libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp   |  6 +-
+ .../renderer/d3d/d3d11/shaders/Clear11.hlsl        |  4 ++
+ .../src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp      | 20 +++----
+ .../src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp  |  4 +-
+ .../src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp |  2 +-
+ .../libGLESv2/renderer/d3d/d3d9/shaders/Blit.ps    |  6 +-
+ .../libGLESv2/renderer/d3d/d3d9/shaders/Blit.vs    |  4 +-
+ 27 files changed, 92 insertions(+), 76 deletions(-)
+
+diff --git a/src/3rdparty/angle/include/EGL/egl.h b/src/3rdparty/angle/include/EGL/egl.h
+index 12590a0..ab2f0cd 100644
+--- a/src/3rdparty/angle/include/EGL/egl.h
++++ b/src/3rdparty/angle/include/EGL/egl.h
+@@ -238,7 +238,7 @@ EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext (void);
+ #ifndef EGL_VERSION_1_5
+ #define EGL_VERSION_1_5 1
+ typedef void *EGLSync;
+-typedef intptr_t EGLAttrib;
++typedef khronos_intptr_t EGLAttrib;
+ typedef khronos_utime_nanoseconds_t EGLTime;
+ #define EGL_CONTEXT_MAJOR_VERSION         0x3098
+ #define EGL_CONTEXT_MINOR_VERSION         0x30FB
+diff --git a/src/3rdparty/angle/include/EGL/eglext.h b/src/3rdparty/angle/include/EGL/eglext.h
+index 9e29605..989359b 100644
+--- a/src/3rdparty/angle/include/EGL/eglext.h
++++ b/src/3rdparty/angle/include/EGL/eglext.h
+@@ -59,7 +59,7 @@ extern "C" {
+ #ifndef EGL_KHR_cl_event2
+ #define EGL_KHR_cl_event2 1
+ typedef void *EGLSyncKHR;
+-typedef intptr_t EGLAttribKHR;
++typedef khronos_intptr_t EGLAttribKHR;
+ typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNC64KHRPROC) (EGLDisplay dpy, EGLenum type, const EGLAttribKHR *attrib_list);
+ #ifdef EGL_EGLEXT_PROTOTYPES
+ EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync64KHR (EGLDisplay dpy, EGLenum type, const EGLAttribKHR *attrib_list);
+diff --git a/src/3rdparty/angle/include/angle_gl.h b/src/3rdparty/angle/include/angle_gl.h
+index d093f75..663aa25 100644
+--- a/src/3rdparty/angle/include/angle_gl.h
++++ b/src/3rdparty/angle/include/angle_gl.h
+@@ -10,6 +10,9 @@
+ #ifndef ANGLE_GL_H_
+ #define ANGLE_GL_H_
+ 
++#define GL_GLEXT_PROTOTYPES
++#define GL_APICALL
++
+ #include "GLES2/gl2.h"
+ #include "GLES2/gl2ext.h"
+ #include "GLES3/gl3.h"
+diff --git a/src/3rdparty/angle/src/common/platform.h b/src/3rdparty/angle/src/common/platform.h
+index d07297d..aa0b985 100644
+--- a/src/3rdparty/angle/src/common/platform.h
++++ b/src/3rdparty/angle/src/common/platform.h
+@@ -49,7 +49,6 @@
+ 
+ #   if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_PERF)
+ #       include <d3d9.h>
+-#       include <d3dcompiler.h>
+ #   endif
+ 
+ #   if defined(ANGLE_ENABLE_D3D11)
+@@ -62,6 +61,10 @@
+ 
+ #   undef near
+ #   undef far
++#   undef NEAR
++#   define NEAR
++#   undef FAR
++#   define FAR
+ #endif
+ 
+ #endif // COMMON_PLATFORM_H_
+diff --git a/src/3rdparty/angle/src/common/version.h b/src/3rdparty/angle/src/common/version.h
+index d9148d1..f01e024 100644
+--- a/src/3rdparty/angle/src/common/version.h
++++ b/src/3rdparty/angle/src/common/version.h
+@@ -1,4 +1,4 @@
+-#include "id/commit.h"
++#include "../commit.h"
+ 
+ #define ANGLE_MAJOR_VERSION 2
+ #define ANGLE_MINOR_VERSION 1
+diff --git a/src/3rdparty/angle/src/libEGL/Config.h b/src/3rdparty/angle/src/libEGL/Config.h
+index 680337b..9844114 100644
+--- a/src/3rdparty/angle/src/libEGL/Config.h
++++ b/src/3rdparty/angle/src/libEGL/Config.h
+@@ -11,7 +11,6 @@
+ #ifndef INCLUDE_CONFIG_H_
+ #define INCLUDE_CONFIG_H_
+ 
+-#define EGLAPI
+ #include <EGL/egl.h>
+ 
+ #include <set>
+diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp
+index 43d9b26..459648c 100644
+--- a/src/3rdparty/angle/src/libEGL/Display.cpp
++++ b/src/3rdparty/angle/src/libEGL/Display.cpp
+@@ -14,6 +14,7 @@
+ #include <map>
+ #include <vector>
+ #include <sstream>
++#include <iterator>
+ 
+ #include "common/debug.h"
+ #include "common/mathutil.h"
+@@ -552,7 +553,7 @@ void Display::initDisplayExtensionString()
+     }
+ 
+     // TODO: complete support for the EGL_KHR_create_context extension
+-    extensions.push_back("EGL_KHR_create_context");
++    //extensions.push_back("EGL_KHR_create_context");
+ 
+     std::ostringstream stream;
+     std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " "));
+diff --git a/src/3rdparty/angle/src/libEGL/Surface.h b/src/3rdparty/angle/src/libEGL/Surface.h
+index 2361fcd..3caf620 100644
+--- a/src/3rdparty/angle/src/libEGL/Surface.h
++++ b/src/3rdparty/angle/src/libEGL/Surface.h
+@@ -11,7 +11,6 @@
+ #ifndef LIBEGL_SURFACE_H_
+ #define LIBEGL_SURFACE_H_
+ 
+-#define EGLAPI
+ #include <EGL/egl.h>
+ 
+ #include "common/angleutils.h"
+diff --git a/src/3rdparty/angle/src/libEGL/main.h b/src/3rdparty/angle/src/libEGL/main.h
+index 77da8f0..6030fb6 100644
+--- a/src/3rdparty/angle/src/libEGL/main.h
++++ b/src/3rdparty/angle/src/libEGL/main.h
+@@ -9,6 +9,7 @@
+ #ifndef LIBEGL_MAIN_H_
+ #define LIBEGL_MAIN_H_
+ 
++#undef EGLAPI
+ #define EGLAPI
+ #include <EGL/egl.h>
+ #include <EGL/eglext.h>
+diff --git a/src/3rdparty/angle/src/libGLESv2/Context.h b/src/3rdparty/angle/src/libGLESv2/Context.h
+index 4b7e59e..6c93c74 100644
+--- a/src/3rdparty/angle/src/libGLESv2/Context.h
++++ b/src/3rdparty/angle/src/libGLESv2/Context.h
+@@ -11,7 +11,6 @@
+ #define LIBGLESV2_CONTEXT_H_
+ 
+ #include "angle_gl.h"
+-#include <EGL/egl.h>
+ 
+ #include <string>
+ #include <set>
+diff --git a/src/3rdparty/angle/src/libGLESv2/formatutils.h b/src/3rdparty/angle/src/libGLESv2/formatutils.h
+index fb4d2a3..2f59279 100644
+--- a/src/3rdparty/angle/src/libGLESv2/formatutils.h
++++ b/src/3rdparty/angle/src/libGLESv2/formatutils.h
+@@ -85,4 +85,4 @@ ColorWriteFunction GetColorWriteFunction(GLenum format, GLenum type);
+ 
+ }
+ 
+-#endif LIBGLESV2_FORMATUTILS_H_
++#endif // LIBGLESV2_FORMATUTILS_H_
+diff --git a/src/3rdparty/angle/src/libGLESv2/main.h b/src/3rdparty/angle/src/libGLESv2/main.h
+index 372b03f..c117039 100644
+--- a/src/3rdparty/angle/src/libGLESv2/main.h
++++ b/src/3rdparty/angle/src/libGLESv2/main.h
+@@ -10,6 +10,9 @@
+ #define LIBGLESV2_MAIN_H_
+ 
+ #include "common/debug.h"
++#undef EGLAPI
++#define EGLAPI
++#include <EGL/egl.h>
+ 
+ namespace egl
+ {
+diff --git a/src/3rdparty/angle/src/libGLESv2/precompiled.h b/src/3rdparty/angle/src/libGLESv2/precompiled.h
+index cc935a1..0404eab 100644
+--- a/src/3rdparty/angle/src/libGLESv2/precompiled.h
++++ b/src/3rdparty/angle/src/libGLESv2/precompiled.h
+@@ -29,3 +29,4 @@
+ #include <string>
+ #include <unordered_map>
+ #include <vector>
++#include <iterator>
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.h b/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.h
+index 4318e2b..837a44a 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.h
+@@ -56,4 +56,4 @@ class IndexRangeCache
+ 
+ }
+ 
+-#endif LIBGLESV2_RENDERER_INDEXRANGECACHE_H
++#endif // LIBGLESV2_RENDERER_INDEXRANGECACHE_H
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h
+index f1c7b49..be3ba29 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h
+@@ -15,6 +15,7 @@
+ #include "libGLESv2/Caps.h"
+ 
+ #if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL)
++#include <d3dcompiler.h>
+ // WARNING: D3DCOMPILE_OPTIMIZATION_LEVEL3 may lead to a DX9 shader compiler hang.
+ // It should only be used selectively to work around specific bugs.
+ #define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL1
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/copyimage.h b/src/3rdparty/angle/src/libGLESv2/renderer/copyimage.h
+index 2f37e1c..9b94404 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/copyimage.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/copyimage.h
+@@ -30,7 +30,7 @@ void WriteColor(const void *source, void *dest)
+ template <typename sourceType, typename destType, typename colorDataType>
+ void CopyPixel(const void *source, void *dest)
+ {
+-    colorType temp;
++    colorDataType temp;
+     ReadColor<sourceType, colorDataType>(source, &temp);
+     WriteColor<destType, colorDataType>(&temp, dest);
+ }
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+index 5613919..499ed52 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+@@ -7,6 +7,8 @@
+ 
+ #include "third_party/trace_event/trace_event.h"
+ 
++#include <d3dcompiler.h>
++
+ namespace rx
+ {
+ 
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp
+index 446149c..79a6543 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp
+@@ -14,39 +14,39 @@
+ #include "libGLESv2/renderer/d3d/d3d11/renderer11_utils.h"
+ #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h"
+ 
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg2di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr2d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr2dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr2di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlum2d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2d11ps.h"
+-
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough3d11vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough3d11gs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg3d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg3di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr3d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr3dui11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr3di11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough2dvs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg2duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr2dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr2duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr2dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlum2dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2dps.h"
++
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough3dvs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough3dgs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg3duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr3dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr3duips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughr3dips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlum3dps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3dps.h"
+ 
+ #include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/swizzlef2dps.h"
+ #include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/swizzlei2dps.h"
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp
+index 656cd94..9cd0b7d 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp
+@@ -16,14 +16,14 @@
+ #include "libGLESv2/Framebuffer.h"
+ #include "libGLESv2/FramebufferAttachment.h"
+ 
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearfloat11vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearfloatvs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearfloatps.h"
+ 
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearuint11vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearuint11ps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearuintvs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearuintps.h"
+ 
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearsint11vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearsint11ps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearsintvs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/clearsintps.h"
+ 
+ namespace rx
+ {
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp
+index 1ca456c..67540bb 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp
+@@ -23,11 +23,11 @@
+ #include "libGLESv2/Context.h"
+ 
+ // Precompiled shaders
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_gs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4f.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4i.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4ui.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexturevs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexturegs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture_4fps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture_4ips.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/buffertotexture_4uips.h"
+ 
+ namespace rx
+ {
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp
+index ed0c4ae..98166f0 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp
+@@ -12,8 +12,8 @@
+ #include "libGLESv2/renderer/d3d/d3d11/renderer11_utils.h"
+ #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h"
+ #include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h"
+-#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthrough2dvs.h"
++#include "libGLESv2/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dps.h"
+ 
+ namespace rx
+ {
+@@ -584,7 +584,7 @@ EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+     // Draw
+     deviceContext->Draw(4, 0);
+ 
+-#ifdef ANGLE_FORCE_VSYNC_OFF
++#if ANGLE_FORCE_VSYNC_OFF
+     result = mSwapChain->Present(0, 0);
+ #else
+     result = mSwapChain->Present(mSwapInterval, 0);
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/shaders/Clear11.hlsl b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/shaders/Clear11.hlsl
+index 6deef2b..b4cf380 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/shaders/Clear11.hlsl
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/shaders/Clear11.hlsl
+@@ -13,10 +13,12 @@ struct PS_OutputFloat
+     float4 color1 : SV_TARGET1;
+     float4 color2 : SV_TARGET2;
+     float4 color3 : SV_TARGET3;
++#if SM4
+     float4 color4 : SV_TARGET4;
+     float4 color5 : SV_TARGET5;
+     float4 color6 : SV_TARGET6;
+     float4 color7 : SV_TARGET7;
++#endif
+ };
+ 
+ PS_OutputFloat PS_ClearFloat(in float4 inPosition : SV_POSITION, in float4 inColor : COLOR)
+@@ -26,10 +28,12 @@ PS_OutputFloat PS_ClearFloat(in float4 inPosition : SV_POSITION, in float4 inCol
+     outColor.color1 = inColor;
+     outColor.color2 = inColor;
+     outColor.color3 = inColor;
++#if SM4
+     outColor.color4 = inColor;
+     outColor.color5 = inColor;
+     outColor.color6 = inColor;
+     outColor.color7 = inColor;
++#endif
+     return outColor;
+ }
+ 
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp
+index 2d72729..f486e5a 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp
+@@ -28,20 +28,20 @@ namespace
+ 
+ const BYTE* const g_shaderCode[] =
+ {
+-    g_vs20_standardvs,
+-    g_vs20_flipyvs,
+-    g_ps20_passthroughps,
+-    g_ps20_luminanceps,
+-    g_ps20_componentmaskps
++    g_vs20_VS_standard,
++    g_vs20_VS_flipy,
++    g_ps20_PS_passthrough,
++    g_ps20_PS_luminance,
++    g_ps20_PS_componentmask
+ };
+ 
+ const size_t g_shaderSize[] =
+ {
+-    sizeof(g_vs20_standardvs),
+-    sizeof(g_vs20_flipyvs),
+-    sizeof(g_ps20_passthroughps),
+-    sizeof(g_ps20_luminanceps),
+-    sizeof(g_ps20_componentmaskps)
++    sizeof(g_vs20_VS_standard),
++    sizeof(g_vs20_VS_flipy),
++    sizeof(g_ps20_PS_passthrough),
++    sizeof(g_ps20_PS_luminance),
++    sizeof(g_ps20_PS_componentmask)
+ };
+ }
+ 
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
+index 69c3feb..491c27a 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
+@@ -205,7 +205,7 @@ EGLint Renderer9::initialize()
+     {
+         TRACE_EVENT0("gpu", "D3d9Ex_QueryInterface");
+         ASSERT(mD3d9Ex);
+-        mD3d9Ex->QueryInterface(__uuidof(IDirect3D9), reinterpret_cast<void**>(&mD3d9));
++        mD3d9Ex->QueryInterface(IID_IDirect3D9, reinterpret_cast<void**>(&mD3d9));
+         ASSERT(mD3d9);
+     }
+     else
+@@ -343,7 +343,7 @@ EGLint Renderer9::initialize()
+     if (mD3d9Ex)
+     {
+         TRACE_EVENT0("gpu", "mDevice_QueryInterface");
+-        result = mDevice->QueryInterface(__uuidof(IDirect3DDevice9Ex), (void**)&mDeviceEx);
++        result = mDevice->QueryInterface(IID_IDirect3DDevice9Ex, (void**)&mDeviceEx);
+         ASSERT(SUCCEEDED(result));
+     }
+ 
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp
+index aef80a7..4a17acf 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp
+@@ -50,7 +50,7 @@ void SwapChain9::release()
+ 
+ static DWORD convertInterval(EGLint interval)
+ {
+-#ifdef ANGLE_FORCE_VSYNC_OFF
++#if ANGLE_FORCE_VSYNC_OFF
+     return D3DPRESENT_INTERVAL_IMMEDIATE;
+ #else
+     switch(interval)
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.ps b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.ps
+index dc357d0..eb43eb3 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.ps
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.ps
+@@ -11,7 +11,7 @@ uniform float4 add  : c1;
+ 
+ // Passthrough Pixel Shader
+ // Outputs texture 0 sampled at texcoord 0.
+-float4 passthroughps(float4 texcoord : TEXCOORD0) : COLOR
++float4 PS_passthrough(float4 texcoord : TEXCOORD0) : COLOR
+ {
+     return tex2D(tex, texcoord.xy);
+ };
+@@ -19,7 +19,7 @@ float4 passthroughps(float4 texcoord : TEXCOORD0) : COLOR
+ // Luminance Conversion Pixel Shader
+ // Performs a mad operation using the LA data from the texture with mult.xw and add.xw.
+ // Returns data in the form of llla
+-float4 luminanceps(float4 texcoord : TEXCOORD0) : COLOR
++float4 PS_luminance(float4 texcoord : TEXCOORD0) : COLOR
+ {
+     return (tex2D(tex, texcoord.xy).xw * mult.xw + add.xw).xxxy;
+ };
+@@ -27,7 +27,7 @@ float4 luminanceps(float4 texcoord : TEXCOORD0) : COLOR
+ // RGB/A Component Mask Pixel Shader
+ // Performs a mad operation using the texture's RGBA data with mult.xyzw and add.xyzw.
+ // Returns data in the form of rgba
+-float4 componentmaskps(float4 texcoord : TEXCOORD0) : COLOR
++float4 PS_componentmask(float4 texcoord : TEXCOORD0) : COLOR
+ {
+     return tex2D(tex, texcoord.xy) * mult + add;
+ };
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.vs b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.vs
+index 3a36980..3bd611b 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.vs
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/shaders/Blit.vs
+@@ -17,7 +17,7 @@ uniform float4 halfPixelSize : c0;
+ // Outputs the homogenous position as-is.
+ // Outputs a tex coord with (0,0) in the upper-left corner of the screen and (1,1) in the bottom right.
+ // C0.X must be negative half-pixel width, C0.Y must be half-pixel height. C0.ZW must be 0.
+-VS_OUTPUT standardvs(in float4 position : POSITION)
++VS_OUTPUT VS_standard(in float4 position : POSITION)
+ {
+     VS_OUTPUT Out;
+ 
+@@ -32,7 +32,7 @@ VS_OUTPUT standardvs(in float4 position : POSITION)
+ // Outputs the homogenous position as-is.
+ // Outputs a tex coord with (0,1) in the upper-left corner of the screen and (1,0) in the bottom right.
+ // C0.XY must be the half-pixel width and height. C0.ZW must be 0.
+-VS_OUTPUT flipyvs(in float4 position : POSITION)
++VS_OUTPUT VS_flipy(in float4 position : POSITION)
+ {
+     VS_OUTPUT Out;
+ 
+-- 
+1.9.0.msysgit.0
+
diff --git a/src/angle/patches/0001-Fix-compilation-for-MSVC-2008-and-std-tuple.patch b/src/angle/patches/0001-Fix-compilation-for-MSVC-2008-and-std-tuple.patch
index 06ab16abdb..0c04bf7fb2 100644
--- a/src/angle/patches/0001-Fix-compilation-for-MSVC-2008-and-std-tuple.patch
+++ b/src/angle/patches/0001-Fix-compilation-for-MSVC-2008-and-std-tuple.patch
@@ -1,7 +1,7 @@
-From 88297d02fd1aed6cac258b72d9d0a8baabad6203 Mon Sep 17 00:00:00 2001
+From da7db59c7a004bb8247dcd64e468b689f3cce163 Mon Sep 17 00:00:00 2001
 From: Thomas Hartmann <Thomas.Hartmann@digia.com>
-Date: Mon, 17 Feb 2014 16:56:51 +0200
-Subject: [PATCH] Fix compilation for MSVC 2008 and std::tuple
+Date: Sat, 28 Jun 2014 16:42:22 +0300
+Subject: [PATCH 01/12] Fix compilation for MSVC 2008 and std::tuple
 
 For MSVC 2008 make_tuple is in the tr1 namespace.
 
@@ -11,7 +11,7 @@ Change-Id: I4a51f6cabdf068993869b404b12ed1484a21a9d4
  1 file changed, 4 insertions(+)
 
 diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.cpp
-index 610a5ef..51d7f0b 100644
+index 14410d0..e957d96 100644
 --- a/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.cpp
 +++ b/src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.cpp
 @@ -81,7 +81,11 @@ IndexRangeCache::IndexRange::IndexRange(GLenum typ, intptr_t off, GLsizei c)
@@ -27,5 +27,5 @@ index 610a5ef..51d7f0b 100644
  
  IndexRangeCache::IndexBounds::IndexBounds()
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0002-Fix-compilation-of-ANGLE-with-mingw-tdm64-gcc-4.8.1.patch b/src/angle/patches/0002-Fix-compilation-of-ANGLE-with-mingw-tdm64-gcc-4.8.1.patch
index 8b91d4b8ea..c26b825b10 100644
--- a/src/angle/patches/0002-Fix-compilation-of-ANGLE-with-mingw-tdm64-gcc-4.8.1.patch
+++ b/src/angle/patches/0002-Fix-compilation-of-ANGLE-with-mingw-tdm64-gcc-4.8.1.patch
@@ -1,7 +1,7 @@
-From 95e3ca47772ef0552662b1d04b7ee08d9d1d2338 Mon Sep 17 00:00:00 2001
+From 21257ea437264c4e7302265d895a2f9331bb7282 Mon Sep 17 00:00:00 2001
 From: Kai Koehne <kai.koehne@digia.com>
-Date: Mon, 17 Feb 2014 16:59:19 +0200
-Subject: [PATCH] Fix compilation of ANGLE with mingw-tdm64 gcc 4.8.1
+Date: Sat, 28 Jun 2014 16:47:10 +0300
+Subject: [PATCH 02/12] Fix compilation of ANGLE with mingw-tdm64 gcc 4.8.1
 
 Do not rely on sprintf_s being declared/defined. This also fixes
 deployment to Windows XP.
@@ -12,22 +12,23 @@ commit proposed upstream.
 Task-number: QTBUG-36242
 Change-Id: I520e2f61aeab34963e7a57baafd413c7db93f110
 ---
- src/3rdparty/angle/src/libEGL/Display.cpp | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
+ src/3rdparty/angle/src/libEGL/Display.cpp | 3 +--
+ 1 file changed, 1 insertion(+), 2 deletions(-)
 
 diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp
-index a382c3b..13ef701 100644
+index 459648c..a87bfe8 100644
 --- a/src/3rdparty/angle/src/libEGL/Display.cpp
 +++ b/src/3rdparty/angle/src/libEGL/Display.cpp
-@@ -523,7 +523,7 @@ void Display::initVendorString()
+@@ -596,8 +596,7 @@ void Display::initVendorString()
      if (mRenderer && mRenderer->getLUID(&adapterLuid))
      {
          char adapterLuidString[64];
 -        sprintf_s(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart);
+-
 +        snprintf(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart);
- 
          mVendorString += adapterLuidString;
      }
+ }
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0003-Fix-compilation-with-MinGW-gcc-64-bit.patch b/src/angle/patches/0003-Fix-compilation-with-MinGW-gcc-64-bit.patch
index 7d70057a9a..24eb2c3c79 100644
--- a/src/angle/patches/0003-Fix-compilation-with-MinGW-gcc-64-bit.patch
+++ b/src/angle/patches/0003-Fix-compilation-with-MinGW-gcc-64-bit.patch
@@ -1,7 +1,7 @@
-From a03d8f647816767525489a2b26663d897f0264a0 Mon Sep 17 00:00:00 2001
+From 6611792d6ff11ef875d0ae3e9fd1a116ad832a39 Mon Sep 17 00:00:00 2001
 From: Kai Koehne <kai.koehne@digia.com>
-Date: Tue, 18 Feb 2014 09:34:39 +0200
-Subject: [PATCH] Fix compilation with MinGW gcc 64 bit
+Date: Sat, 28 Jun 2014 16:50:57 +0300
+Subject: [PATCH 03/12] Fix compilation with MinGW gcc 64 bit
 
 Fix compilation of ANGLE with gcc 4.8.0 64 bit: The
 
@@ -31,5 +31,5 @@ index 1880056..637cf9a 100644
          *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
      }
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch b/src/angle/patches/0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch
index 2c95c5bcfa..960b939896 100644
--- a/src/angle/patches/0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch
+++ b/src/angle/patches/0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch
@@ -1,7 +1,7 @@
-From 9b24b25eeb5ca97d7978c6840fdb1e903bf63a55 Mon Sep 17 00:00:00 2001
+From 6706ecec3897bf1c6cbfa6891ee9edbde6b64dd0 Mon Sep 17 00:00:00 2001
 From: Friedemann Kleint <Friedemann.Kleint@digia.com>
-Date: Tue, 18 Feb 2014 09:52:52 +0200
-Subject: [PATCH] Make it possible to link ANGLE statically for
+Date: Sat, 28 Jun 2014 17:00:55 +0300
+Subject: [PATCH 04/12] Make it possible to link ANGLE statically for
  single-thread use.
 
 Fix exports and provide static instances of thread-local
@@ -9,10 +9,10 @@ data depending on QT_OPENGL_ES_2_ANGLE_STATIC.
 
 Change-Id: Ifab25a820adf5953bb3b09036de53dbf7f1a7fd5
 ---
- src/3rdparty/angle/include/KHR/khrplatform.h | 2 +-
- src/3rdparty/angle/src/libEGL/main.cpp       | 6 ++++++
- src/3rdparty/angle/src/libGLESv2/main.cpp    | 6 ++++++
- 3 files changed, 13 insertions(+), 1 deletion(-)
+ src/3rdparty/angle/include/KHR/khrplatform.h |  2 +-
+ src/3rdparty/angle/src/libEGL/main.cpp       | 10 ++++++++++
+ src/3rdparty/angle/src/libGLESv2/main.cpp    | 10 ++++++++++
+ 3 files changed, 21 insertions(+), 1 deletion(-)
 
 diff --git a/src/3rdparty/angle/include/KHR/khrplatform.h b/src/3rdparty/angle/include/KHR/khrplatform.h
 index c9e6f17..1ac2d3f 100644
@@ -28,41 +28,81 @@ index c9e6f17..1ac2d3f 100644
  #elif defined (__SYMBIAN32__)
  #   define KHRONOS_APICALL IMPORT_C
 diff --git a/src/3rdparty/angle/src/libEGL/main.cpp b/src/3rdparty/angle/src/libEGL/main.cpp
-index 80dcc34..772b8eb 100644
+index 0f8439c..8a1baef 100644
 --- a/src/3rdparty/angle/src/libEGL/main.cpp
 +++ b/src/3rdparty/angle/src/libEGL/main.cpp
-@@ -106,7 +106,13 @@ namespace egl
+@@ -49,6 +49,8 @@ void DeallocateCurrent()
+ 
+ }
+ 
++#ifndef QT_OPENGL_ES_2_ANGLE_STATIC
++
+ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
+ {
+     switch (reason)
+@@ -100,16 +102,24 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+     return TRUE;
+ }
+ 
++#endif // !QT_OPENGL_ES_2_ANGLE_STATIC
++
+ namespace egl
+ {
  
  Current *GetCurrentData()
  {
 +#ifndef QT_OPENGL_ES_2_ANGLE_STATIC
-     Current *current = (Current*)TlsGetValue(currentTLS);
+     Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS));
+ 
+     // ANGLE issue 488: when the dll is loaded after thread initialization,
+     // thread local storage (current) might not exist yet.
+     return (current ? current : AllocateCurrent());
 +#else
 +    // No precautions for thread safety taken as ANGLE is used single-threaded in Qt.
-+    static Current s_current = { EGL_SUCCESS, EGL_OPENGL_ES_API, EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE };
-+    Current *current = &s_current;
++    static Current current = { EGL_SUCCESS, EGL_OPENGL_ES_API, EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE };
++    return &current;
 +#endif
+ }
  
-     // ANGLE issue 488: when the dll is loaded after thread initialization,
-     // thread local storage (current) might not exist yet.
+ void setCurrentError(EGLint error)
 diff --git a/src/3rdparty/angle/src/libGLESv2/main.cpp b/src/3rdparty/angle/src/libGLESv2/main.cpp
-index 50e2593..6b459d3 100644
+index 81e70a4..5a45ec3 100644
 --- a/src/3rdparty/angle/src/libGLESv2/main.cpp
 +++ b/src/3rdparty/angle/src/libGLESv2/main.cpp
-@@ -89,7 +89,13 @@ namespace gl
+@@ -47,6 +47,8 @@ void DeallocateCurrent()
+ 
+ }
+ 
++#ifndef QT_OPENGL_ES_2_ANGLE_STATIC
++
+ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
+ {
+     switch (reason)
+@@ -83,16 +85,24 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+     return TRUE;
+ }
+ 
++#endif // !QT_OPENGL_ES_2_ANGLE_STATIC
++
+ namespace gl
+ {
  
  Current *GetCurrentData()
  {
 +#ifndef QT_OPENGL_ES_2_ANGLE_STATIC
-     Current *current = (Current*)TlsGetValue(currentTLS);
+     Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS));
+ 
+     // ANGLE issue 488: when the dll is loaded after thread initialization,
+     // thread local storage (current) might not exist yet.
+     return (current ? current : AllocateCurrent());
 +#else
 +    // No precautions for thread safety taken as ANGLE is used single-threaded in Qt.
-+    static Current s_current = { 0, 0 };
-+    Current *current = &s_current;
++    static Current current = { 0, 0 };
++    return &current;
 +#endif
+ }
  
-     // ANGLE issue 488: when the dll is loaded after thread initialization,
-     // thread local storage (current) might not exist yet.
+ void makeCurrent(Context *context, egl::Display *display, egl::Surface *surface)
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0005-Fix-build-when-SSE2-is-not-available.patch b/src/angle/patches/0005-Fix-build-when-SSE2-is-not-available.patch
index 475ec55b0e..1dbf7d387f 100644
--- a/src/angle/patches/0005-Fix-build-when-SSE2-is-not-available.patch
+++ b/src/angle/patches/0005-Fix-build-when-SSE2-is-not-available.patch
@@ -1,7 +1,7 @@
-From cebc37237a74a130dffaefad0a10da17abc42981 Mon Sep 17 00:00:00 2001
+From 747d31f25883f6b9203245a498acf9945accdc0d Mon Sep 17 00:00:00 2001
 From: Andy Shaw <andy.shaw@digia.com>
-Date: Tue, 18 Feb 2014 09:59:17 +0200
-Subject: [PATCH] Fix build when SSE2 is not available.
+Date: Sat, 28 Jun 2014 17:06:45 +0300
+Subject: [PATCH 05/12] Fix build when SSE2 is not available.
 
 Although SSE2 support is detected at runtime it still may not be
 available at build time, so we have to ensure it only uses SSE2
@@ -9,23 +9,23 @@ when it is available at build time too.
 
 Change-Id: I86c45a6466ab4cec79aa0f62b0d5230a78ad825a
 ---
- src/3rdparty/angle/src/libGLESv2/mathutil.h               | 2 ++
- src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Image9.cpp | 6 +++++-
- 2 files changed, 7 insertions(+), 1 deletion(-)
+ src/3rdparty/angle/src/common/mathutil.h                    | 2 ++
+ src/3rdparty/angle/src/libGLESv2/renderer/loadimageSSE2.cpp | 8 ++++++++
+ 2 files changed, 10 insertions(+)
 
-diff --git a/src/3rdparty/angle/src/libGLESv2/mathutil.h b/src/3rdparty/angle/src/libGLESv2/mathutil.h
-index f902131..6474b66 100644
---- a/src/3rdparty/angle/src/libGLESv2/mathutil.h
-+++ b/src/3rdparty/angle/src/libGLESv2/mathutil.h
-@@ -92,6 +92,7 @@ inline bool supportsSSE2()
+diff --git a/src/3rdparty/angle/src/common/mathutil.h b/src/3rdparty/angle/src/common/mathutil.h
+index 58f9b4c..f32663f 100644
+--- a/src/3rdparty/angle/src/common/mathutil.h
++++ b/src/3rdparty/angle/src/common/mathutil.h
+@@ -118,6 +118,7 @@ inline bool supportsSSE2()
          return supports;
      }
  
 +#if defined(_M_IX86) || defined(_M_AMD64) // ARM doesn't provide __cpuid()
      int info[4];
      __cpuid(info, 0);
-     
-@@ -101,6 +102,7 @@ inline bool supportsSSE2()
+ 
+@@ -127,6 +128,7 @@ inline bool supportsSSE2()
  
          supports = (info[3] >> 26) & 1;
      }
@@ -33,45 +33,52 @@ index f902131..6474b66 100644
  
      checked = true;
  
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Image9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Image9.cpp
-index 8511946..cd12d8c 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Image9.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d9/Image9.cpp
-@@ -373,11 +373,13 @@ void Image9::loadData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei heigh
-     switch (mInternalFormat)
-     {
-       case GL_ALPHA8_EXT:
-+#if defined(__SSE2__)
-         if (gl::supportsSSE2())
-         {
-             loadAlphaDataToBGRASSE2(width, height, inputPitch, input, locked.Pitch, locked.pBits);
-         }
-         else
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/loadimageSSE2.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/loadimageSSE2.cpp
+index 9c83894..dcf347d 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/loadimageSSE2.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/loadimageSSE2.cpp
+@@ -11,6 +11,10 @@
+ 
+ #include "libGLESv2/renderer/loadimage.h"
+ 
++#if !defined(__SSE2__) && (defined(_M_X64) || _M_IX86_FP == 2)
++#define __SSE2__
 +#endif
-         {
-             loadAlphaDataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);
-         }
-@@ -413,11 +415,13 @@ void Image9::loadData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei heigh
-         loadRGB565DataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);
-         break;
-       case GL_RGBA8_OES:
-+#if defined(__SSE2__)
-         if (gl::supportsSSE2())
-         {
-             loadRGBAUByteDataToBGRASSE2(width, height, inputPitch, input, locked.Pitch, locked.pBits);
++
+ namespace rx
+ {
+ 
+@@ -18,6 +22,7 @@ void LoadA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+ {
++#ifdef __SSE2__
+     __m128i zeroWide = _mm_setzero_si128();
+ 
+     for (size_t z = 0; z < depth; z++)
+@@ -55,12 +60,14 @@ void LoadA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+             }
          }
-         else
+     }
 +#endif
-         {
-             loadRGBAUByteDataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);
+ }
+ 
+ void LoadRGBA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+                            const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                            uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+ {
++#ifdef __SSE2__
+     __m128i brMask = _mm_set1_epi32(0x00ff00ff);
+ 
+     for (size_t z = 0; z < depth; z++)
+@@ -100,6 +107,7 @@ void LoadRGBA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+             }
          }
-@@ -729,4 +733,4 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
-     mDirty = true;
+     }
++#endif
  }
  
--}
-\ No newline at end of file
-+}
+ }
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0006-Fix-compilation-of-libGLESv2-with-older-MinGW-w64-he.patch b/src/angle/patches/0006-Fix-compilation-of-libGLESv2-with-older-MinGW-w64-he.patch
index cf31245b95..df057c01ee 100644
--- a/src/angle/patches/0006-Fix-compilation-of-libGLESv2-with-older-MinGW-w64-he.patch
+++ b/src/angle/patches/0006-Fix-compilation-of-libGLESv2-with-older-MinGW-w64-he.patch
@@ -1,7 +1,7 @@
-From 68ba96d224a84389567f506661a78c32b307e84d Mon Sep 17 00:00:00 2001
+From 7609185310c081cbe396c993ccc84f2c43674281 Mon Sep 17 00:00:00 2001
 From: Kai Koehne <kai.koehne@digia.com>
-Date: Tue, 18 Feb 2014 10:29:14 +0200
-Subject: [PATCH] Fix compilation of libGLESv2 with older MinGW-w64
+Date: Sat, 28 Jun 2014 17:11:04 +0300
+Subject: [PATCH 06/12] Fix compilation of libGLESv2 with older MinGW-w64
  headers
 
 Fix compilation of libGLESv2 for mingw-headers predating MinGW-w64
@@ -15,20 +15,18 @@ MinGW-builds gcc 4.7.2-rev11) will unfortunately remain broken.
 
 Change-Id: I31272a1a991c4fc0f1611f8fb7510be51d6bb925
 ---
- .../angle/src/libGLESv2/renderer/Renderer.cpp         | 19 +++++++++++++++++++
- 1 file changed, 19 insertions(+)
+ .../angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp     | 15 +++++++++++++++
+ 1 file changed, 15 insertions(+)
 
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-index 3407353..e74120d 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-@@ -24,6 +24,25 @@
- #define D3DERR_OUTOFVIDEOMEMORY MAKE_HRESULT(1, 0x876, 380)
- #endif
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+index 499ed52..1df6a5e 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+@@ -9,6 +9,21 @@
  
-+#ifdef __MINGW32__
-+
-+#ifndef D3DCOMPILER_DLL
+ #include <d3dcompiler.h>
+ 
++#if defined(__MINGW32__) && !defined(D3DCOMPILER_DLL)
 +
 +// Add define + typedefs for older MinGW-w64 headers (pre 5783)
 +
@@ -41,13 +39,11 @@ index 3407353..e74120d 100644
 +        const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
 +        const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages);
 +
-+#endif // D3DCOMPILER_DLL
-+
-+#endif // __MINGW32__
++#endif // __MINGW32__ && !D3DCOMPILER_DLL
 +
  namespace rx
  {
  
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0019-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch b/src/angle/patches/0007-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
index b0939a1126..1a06cd0bec 100644
--- a/src/angle/patches/0019-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
+++ b/src/angle/patches/0007-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
@@ -1,7 +1,7 @@
-From 6a3ced5ce411cdcc27308996db496a9d0ca0496f Mon Sep 17 00:00:00 2001
+From 0cd67655973e4e05f041bbfaafc8ce376cc8332c Mon Sep 17 00:00:00 2001
 From: Thiago Macieira <thiago.macieira@intel.com>
-Date: Wed, 18 Jun 2014 16:32:53 -0700
-Subject: [PATCH 19/19] Fix ANGLE build with Microsoft Visual Studio "14" CTP
+Date: Fri, 4 Jul 2014 09:20:06 +0300
+Subject: [PATCH 07/12] Fix ANGLE build with Microsoft Visual Studio "14" CTP
 
 This version has a few new C99 support added, including snprintf.
 
@@ -11,11 +11,11 @@ Change-Id: I5776456fd94254a64f08791f59bc775cb24c9b7f
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/src/3rdparty/angle/src/common/angleutils.h b/src/3rdparty/angle/src/common/angleutils.h
-index 7723f0f..3d4246f 100644
+index 7701a42..d94b4f5 100644
 --- a/src/3rdparty/angle/src/common/angleutils.h
 +++ b/src/3rdparty/angle/src/common/angleutils.h
-@@ -56,7 +56,7 @@ void SafeDeleteArray(T*& resource)
-     resource = NULL;
+@@ -131,7 +131,7 @@ inline std::string Str(int i)
+     return strstr.str();
  }
  
 -#if defined(_MSC_VER)
@@ -24,5 +24,5 @@ index 7723f0f..3d4246f 100644
  #endif
  
 -- 
-1.8.4.5
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0007-Make-DX9-DX11-mutually-exclusive.patch b/src/angle/patches/0007-Make-DX9-DX11-mutually-exclusive.patch
deleted file mode 100644
index 25a2f12847..0000000000
--- a/src/angle/patches/0007-Make-DX9-DX11-mutually-exclusive.patch
+++ /dev/null
@@ -1,141 +0,0 @@
-From e1b26c6669cafb5c1298d6e5476c24686fccf1bd Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Thu, 20 Feb 2014 16:46:15 +0200
-Subject: [PATCH] Make DX9/DX11 support configurable
-
-ANGLE supports selecting the renderer on creation, choosing between
-D3D11 and D3D9 backends. This patch improves upon this by enabling the
-D3D backend(s) at compile time. This can make the binary size smaller
-(no extra render is built) and ensures compatibility with Windows Runtime
-when building only the D3D11 renderer.
-
-Change-Id: Id9473e0e631721083fe4026d475e37603a144c37
----
- src/3rdparty/angle/src/libEGL/Display.cpp             |  4 +++-
- src/3rdparty/angle/src/libGLESv2/Texture.cpp          |  6 +++++-
- src/3rdparty/angle/src/libGLESv2/precompiled.h        | 10 +++++++---
- .../angle/src/libGLESv2/renderer/Renderer.cpp         | 19 +++++++++++++------
- 4 files changed, 28 insertions(+), 11 deletions(-)
-
-diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp
-index 13ef701..a7f5f5a 100644
---- a/src/3rdparty/angle/src/libEGL/Display.cpp
-+++ b/src/3rdparty/angle/src/libEGL/Display.cpp
-@@ -471,7 +471,6 @@ bool Display::hasExistingWindowSurface(HWND window)
- 
- void Display::initExtensionString()
- {
--    HMODULE swiftShader = GetModuleHandle(TEXT("swiftshader_d3d9.dll"));
-     bool shareHandleSupported = mRenderer->getShareHandleSupport();
- 
-     mExtensionString = "";
-@@ -487,10 +486,13 @@ void Display::initExtensionString()
- 
-     mExtensionString += "EGL_ANGLE_query_surface_pointer ";
- 
-+#if defined(ANGLE_ENABLE_D3D9)
-+    HMODULE swiftShader = GetModuleHandle(TEXT("swiftshader_d3d9.dll"));
-     if (swiftShader)
-     {
-         mExtensionString += "EGL_ANGLE_software_display ";
-     }
-+#endif
- 
-     if (shareHandleSupported)
-     {
-diff --git a/src/3rdparty/angle/src/libGLESv2/Texture.cpp b/src/3rdparty/angle/src/libGLESv2/Texture.cpp
-index 3deecaf..3257d05 100644
---- a/src/3rdparty/angle/src/libGLESv2/Texture.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/Texture.cpp
-@@ -14,7 +14,11 @@
- #include "libGLESv2/main.h"
- #include "libGLESv2/mathutil.h"
- #include "libGLESv2/utilities.h"
--#include "libGLESv2/renderer/d3d9/Blit.h"
-+#if defined(ANGLE_ENABLE_D3D9)
-+#  include "libGLESv2/renderer/d3d9/Blit.h"
-+#else
-+#  define D3DFMT_UNKNOWN DXGI_FORMAT_UNKNOWN
-+#endif
- #include "libGLESv2/Renderbuffer.h"
- #include "libGLESv2/renderer/Image.h"
- #include "libGLESv2/renderer/Renderer.h"
-diff --git a/src/3rdparty/angle/src/libGLESv2/precompiled.h b/src/3rdparty/angle/src/libGLESv2/precompiled.h
-index 58ad181..79490b1 100644
---- a/src/3rdparty/angle/src/libGLESv2/precompiled.h
-+++ b/src/3rdparty/angle/src/libGLESv2/precompiled.h
-@@ -32,9 +32,13 @@
- #include <unordered_map>
- #include <vector>
- 
--#include <d3d9.h>
--#include <d3d11.h>
--#include <dxgi.h>
-+#if defined(ANGLE_ENABLE_D3D9)
-+#  include <d3d9.h>
-+#endif
-+#if defined(ANGLE_ENABLE_D3D11)
-+#  include <d3d11.h>
-+#  include <dxgi.h>
-+#endif
- #include <d3dcompiler.h>
- 
- #ifdef _MSC_VER
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-index 86be93f..3407353 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-@@ -11,14 +11,17 @@
- #include "libGLESv2/main.h"
- #include "libGLESv2/Program.h"
- #include "libGLESv2/renderer/Renderer.h"
--#include "libGLESv2/renderer/d3d9/Renderer9.h"
--#include "libGLESv2/renderer/d3d11/Renderer11.h"
-+#if defined(ANGLE_ENABLE_D3D9)
-+#  include "libGLESv2/renderer/d3d9/Renderer9.h"
-+#endif
-+#if defined(ANGLE_ENABLE_D3D11)
-+#  include "libGLESv2/renderer/d3d11/Renderer11.h"
-+#endif
- #include "libGLESv2/utilities.h"
- #include "third_party/trace_event/trace_event.h"
- 
--#if !defined(ANGLE_ENABLE_D3D11)
--// Enables use of the Direct3D 11 API for a default display, when available
--#define ANGLE_ENABLE_D3D11 0
-+#ifndef D3DERR_OUTOFVIDEOMEMORY
-+#define D3DERR_OUTOFVIDEOMEMORY MAKE_HRESULT(1, 0x876, 380)
- #endif
- 
- namespace rx
-@@ -177,7 +180,8 @@ rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayT
-     rx::Renderer *renderer = NULL;
-     EGLint status = EGL_BAD_ALLOC;
- 
--    if (ANGLE_ENABLE_D3D11 ||
-+#if defined(ANGLE_ENABLE_D3D11)
-+    if (displayId == EGL_DEFAULT_DISPLAY ||
-         displayId == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
-         displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
-     {
-@@ -200,7 +204,9 @@ rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayT
-         // Failed to create a D3D11 renderer, try creating a D3D9 renderer
-         delete renderer;
-     }
-+#endif // ANGLE_ENABLE_D3D11
- 
-+#if defined(ANGLE_ENABLE_D3D9)
-     bool softwareDevice = (displayId == EGL_SOFTWARE_DISPLAY_ANGLE);
-     renderer = new rx::Renderer9(display, hDc, softwareDevice);
- 
-@@ -213,6 +219,7 @@ rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayT
-     {
-         return renderer;
-     }
-+#endif // ANGLE_ENABLE_D3D9
- 
-     return NULL;
- }
--- 
-1.8.4.msysgit.0
-
diff --git a/src/angle/patches/0008-ANGLE-Dynamically-load-D3D-compiler-from-a-list-of-k.patch b/src/angle/patches/0008-ANGLE-Dynamically-load-D3D-compiler-from-a-list-or-t.patch
index c7cfafc246..55d1307601 100644
--- a/src/angle/patches/0008-ANGLE-Dynamically-load-D3D-compiler-from-a-list-of-k.patch
+++ b/src/angle/patches/0008-ANGLE-Dynamically-load-D3D-compiler-from-a-list-or-t.patch
@@ -1,7 +1,7 @@
-From 0fede57f6fc052942b910995fdfa4cd76a32f586 Mon Sep 17 00:00:00 2001
+From a3196fcfe7dd7aff5e5fa07d1a9bbf2c72fc0b41 Mon Sep 17 00:00:00 2001
 From: Andrew Knight <andrew.knight@digia.com>
-Date: Tue, 18 Feb 2014 12:11:45 +0200
-Subject: [PATCH] ANGLE: Dynamically load D3D compiler from a list or the
+Date: Fri, 4 Jul 2014 08:39:54 +0300
+Subject: [PATCH 08/12] ANGLE: Dynamically load D3D compiler from a list or the
  environment
 
 If the default compiler cannot be found, load it from a list of DLL names,
@@ -11,41 +11,37 @@ QT_D3DCOMPILER_DLL.
 
 Change-Id: I0d7a8a8a36cc571836f8fa59ea14513b9b19c19b
 ---
- .../angle/src/libGLESv2/renderer/Renderer.cpp      | 34 ++++++++++++++++++++--
- 1 file changed, 32 insertions(+), 2 deletions(-)
+ .../src/libGLESv2/renderer/d3d/HLSLCompiler.cpp    | 31 +++++++++++++++++++---
+ 1 file changed, 28 insertions(+), 3 deletions(-)
 
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-index e74120d..94cbc0e 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-@@ -43,6 +43,10 @@ typedef HRESULT (WINAPI *pD3DCompile)(const void *data, SIZE_T data_size, const
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+index 1df6a5e..31942e6 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+@@ -24,6 +24,14 @@ typedef HRESULT (WINAPI *pD3DCompile)(const void *data, SIZE_T data_size, const
  
- #endif // __MINGW32__
+ #endif // __MINGW32__ && !D3DCOMPILER_DLL
  
 +#ifndef QT_D3DCOMPILER_DLL
 +#define QT_D3DCOMPILER_DLL D3DCOMPILER_DLL
 +#endif
 +
++#ifndef LoadLibrary
++#define LoadLibrary(dll) LoadPackagedLibrary(dll, NULL)
++#endif
++
  namespace rx
  {
  
-@@ -77,10 +81,36 @@ bool Renderer::initializeCompiler()
+@@ -54,10 +62,27 @@ bool HLSLCompiler::initialize()
      }
  #endif  // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES
  
--    if (!mD3dCompilerModule)
+-    if (!mD3DCompilerModule)
 +    // Load the compiler DLL specified by the environment, or default to QT_D3DCOMPILER_DLL
-+#if !defined(ANGLE_OS_WINRT)
 +    const wchar_t *defaultCompiler = _wgetenv(L"QT_D3DCOMPILER_DLL");
 +    if (!defaultCompiler)
 +        defaultCompiler = QT_D3DCOMPILER_DLL;
-+#else // !ANGLE_OS_WINRT
-+#  ifdef _DEBUG
-+    const wchar_t *defaultCompiler = L"d3dcompiler_qtd.dll";
-+#  else
-+    const wchar_t *defaultCompiler = L"d3dcompiler_qt.dll";
-+#  endif
-+#endif // ANGLE_OS_WINRT
 +
 +    const wchar_t *compilerDlls[] = {
 +        defaultCompiler,
@@ -60,14 +56,14 @@ index e74120d..94cbc0e 100644
 +    // Load the first available known compiler DLL
 +    for (int i = 0; compilerDlls[i]; ++i)
      {
-         // Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with.
--        mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
+-        // Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with.
+-        mD3DCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
 +        mD3dCompilerModule = LoadLibrary(compilerDlls[i]);
 +        if (mD3dCompilerModule)
 +            break;
      }
  
-     if (!mD3dCompilerModule)
+     if (!mD3DCompilerModule)
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0009-ANGLE-Support-WinRT.patch b/src/angle/patches/0009-ANGLE-Support-WinRT.patch
index 92909d37d8..5630f7f9ce 100644
--- a/src/angle/patches/0009-ANGLE-Support-WinRT.patch
+++ b/src/angle/patches/0009-ANGLE-Support-WinRT.patch
@@ -1,7 +1,7 @@
-From 46b8b123ada1787c68525cd07dcdbfdbc003bcc5 Mon Sep 17 00:00:00 2001
+From be5e9dcf8a4cb23368b30f743082630bdccc7376 Mon Sep 17 00:00:00 2001
 From: Andrew Knight <andrew.knight@digia.com>
-Date: Thu, 20 Feb 2014 16:49:13 +0200
-Subject: [PATCH] ANGLE: Support WinRT
+Date: Tue, 5 Aug 2014 09:31:32 +0300
+Subject: [PATCH 09/12] ANGLE: Support WinRT
 
 This enables EGL for WinRT's native types, and adjusts some codepaths
 to accommodate differences between desktop Windows and WinRT.
@@ -15,36 +15,32 @@ to accommodate differences between desktop Windows and WinRT.
 Change-Id: Ia90377e700d335a1c569c2145008dd4b0dfd84d3
 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
 ---
- src/3rdparty/angle/include/EGL/eglplatform.h       | 10 ++-
- .../angle/src/compiler/translator/osinclude.h      | 20 +++---
- .../src/compiler/translator/ossource_posix.cpp     |  8 +++
- .../angle/src/compiler/translator/ossource_win.cpp |  8 +++
- .../src/compiler/translator/ossource_winrt.cpp     | 75 ++++++++++++++++++++++
- src/3rdparty/angle/src/libEGL/Display.cpp          | 11 ++--
- src/3rdparty/angle/src/libEGL/Display.h            |  7 +-
- src/3rdparty/angle/src/libEGL/Surface.cpp          | 42 +++++++++++-
- src/3rdparty/angle/src/libEGL/Surface.h            |  6 +-
- src/3rdparty/angle/src/libEGL/libEGL.cpp           |  4 +-
- src/3rdparty/angle/src/libEGL/main.cpp             | 29 ++++++++-
- src/3rdparty/angle/src/libGLESv2/Context.cpp       |  1 +
- src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp     |  1 +
- src/3rdparty/angle/src/libGLESv2/main.cpp          | 27 ++++++++
- src/3rdparty/angle/src/libGLESv2/main.h            |  2 +-
- src/3rdparty/angle/src/libGLESv2/precompiled.h     | 45 ++++++++++++-
- .../angle/src/libGLESv2/renderer/Renderer.cpp      | 15 +++--
- .../angle/src/libGLESv2/renderer/Renderer.h        |  3 +-
- .../angle/src/libGLESv2/renderer/SwapChain.h       |  5 +-
- .../src/libGLESv2/renderer/d3d11/Renderer11.cpp    | 13 +++-
- .../src/libGLESv2/renderer/d3d11/Renderer11.h      |  5 +-
- .../src/libGLESv2/renderer/d3d11/SwapChain11.cpp   | 37 +++++++++--
- .../src/libGLESv2/renderer/d3d11/SwapChain11.h     |  2 +-
- .../libGLESv2/renderer/d3d11/shaders/Clear11.hlsl  |  4 ++
- src/3rdparty/angle/src/libGLESv2/utilities.cpp     | 48 ++++++++++++++
- 25 files changed, 378 insertions(+), 50 deletions(-)
- create mode 100644 src/3rdparty/angle/src/compiler/translator/ossource_winrt.cpp
+ src/3rdparty/angle/include/EGL/eglplatform.h       |  10 +-
+ src/3rdparty/angle/src/common/platform.h           |   3 +
+ src/3rdparty/angle/src/common/tls.cpp              |  37 ++++-
+ src/3rdparty/angle/src/common/tls.h                |   6 +-
+ src/3rdparty/angle/src/common/utilities.cpp        |  51 +++++-
+ src/3rdparty/angle/src/libEGL/Display.cpp          |  13 +-
+ src/3rdparty/angle/src/libEGL/Display.h            |   6 +-
+ src/3rdparty/angle/src/libEGL/Surface.cpp          | 185 ++++++++++++++++++++-
+ src/3rdparty/angle/src/libEGL/Surface.h            |  39 ++++-
+ src/3rdparty/angle/src/libEGL/libEGL.cpp           |   8 +-
+ src/3rdparty/angle/src/libEGL/main.cpp             |  21 +++
+ src/3rdparty/angle/src/libGLESv2/main.cpp          |  20 +++
+ src/3rdparty/angle/src/libGLESv2/main.h            |   4 +
+ .../angle/src/libGLESv2/renderer/Renderer.h        |   2 +-
+ .../angle/src/libGLESv2/renderer/SwapChain.h       |  15 +-
+ .../src/libGLESv2/renderer/d3d/HLSLCompiler.cpp    |  12 +-
+ .../libGLESv2/renderer/d3d/d3d11/Renderer11.cpp    |  13 +-
+ .../src/libGLESv2/renderer/d3d/d3d11/Renderer11.h  |   4 +-
+ .../libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp   |  76 +++++++--
+ .../src/libGLESv2/renderer/d3d/d3d11/SwapChain11.h |   6 +-
+ .../src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp |   2 +-
+ .../src/libGLESv2/renderer/d3d/d3d9/SwapChain9.h   |   2 +-
+ 22 files changed, 486 insertions(+), 49 deletions(-)
 
 diff --git a/src/3rdparty/angle/include/EGL/eglplatform.h b/src/3rdparty/angle/include/EGL/eglplatform.h
-index 34283f2..eb15ae5 100644
+index 3ab8844..ea9f577 100644
 --- a/src/3rdparty/angle/include/EGL/eglplatform.h
 +++ b/src/3rdparty/angle/include/EGL/eglplatform.h
 @@ -67,7 +67,15 @@
@@ -52,11 +48,11 @@ index 34283f2..eb15ae5 100644
   */
  
 -#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
-+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP) /* Windows Runtime */
++#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP) /* Windows Runtime */
 +
 +struct IUnknown;
 +
-+typedef int       EGLNativeDisplayType;
++typedef IUnknown *EGLNativeDisplayType;
 +typedef void     *EGLNativePixmapType;
 +typedef IUnknown *EGLNativeWindowType;
 +
@@ -64,213 +60,213 @@ index 34283f2..eb15ae5 100644
  #ifndef WIN32_LEAN_AND_MEAN
  #define WIN32_LEAN_AND_MEAN 1
  #endif
-diff --git a/src/3rdparty/angle/src/compiler/translator/osinclude.h b/src/3rdparty/angle/src/compiler/translator/osinclude.h
-index c3063d6..cccfa63 100644
---- a/src/3rdparty/angle/src/compiler/translator/osinclude.h
-+++ b/src/3rdparty/angle/src/compiler/translator/osinclude.h
-@@ -13,7 +13,11 @@
- //
+diff --git a/src/3rdparty/angle/src/common/platform.h b/src/3rdparty/angle/src/common/platform.h
+index aa0b985..e16e7ac 100644
+--- a/src/3rdparty/angle/src/common/platform.h
++++ b/src/3rdparty/angle/src/common/platform.h
+@@ -11,6 +11,9 @@
  
  #if defined(_WIN32) || defined(_WIN64)
-+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
-+#define ANGLE_OS_WINRT
-+#else
- #define ANGLE_OS_WIN
+ #   define ANGLE_PLATFORM_WINDOWS 1
++#   if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
++#      define ANGLE_PLATFORM_WINRT 1
++#   endif
+ #elif defined(__APPLE__)
+ #   define ANGLE_PLATFORM_APPLE 1
+ #   define ANGLE_PLATFORM_POSIX 1
+diff --git a/src/3rdparty/angle/src/common/tls.cpp b/src/3rdparty/angle/src/common/tls.cpp
+index 6b78219..c46fab5 100644
+--- a/src/3rdparty/angle/src/common/tls.cpp
++++ b/src/3rdparty/angle/src/common/tls.cpp
+@@ -10,11 +10,28 @@
+ 
+ #include <assert.h>
+ 
++#if defined(ANGLE_PLATFORM_WINRT)
++#include <vector>
++std::vector<void *> *tls = nullptr;
++std::vector<TLSIndex> *freeIndices = nullptr;
 +#endif
- #elif defined(__APPLE__) || defined(__linux__) || \
-       defined(__FreeBSD__) || defined(__OpenBSD__) || \
-       defined(__NetBSD__) || defined(__DragonFly__) || \
-@@ -25,7 +29,7 @@
- #error Unsupported platform.
- #endif
- 
--#if defined(ANGLE_OS_WIN)
-+#if defined(ANGLE_OS_WIN) || defined(ANGLE_OS_WINRT)
- #define STRICT
- #define VC_EXTRALEAN 1
- #include <windows.h>
-@@ -44,23 +48,17 @@
- #if defined(ANGLE_OS_WIN)
- typedef DWORD OS_TLSIndex;
- #define OS_INVALID_TLS_INDEX (TLS_OUT_OF_INDEXES)
-+#elif defined(ANGLE_OS_WINRT)
-+typedef size_t OS_TLSIndex;
-+#define OS_INVALID_TLS_INDEX ((DWORD)0xFFFFFF)
- #elif defined(ANGLE_OS_POSIX)
- typedef pthread_key_t OS_TLSIndex;
- #define OS_INVALID_TLS_INDEX (static_cast<OS_TLSIndex>(-1))
- #endif  // ANGLE_OS_WIN
- 
- OS_TLSIndex OS_AllocTLSIndex();
-+void *OS_GetTLSValue(OS_TLSIndex nIndex);
- bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue);
- bool OS_FreeTLSIndex(OS_TLSIndex nIndex);
- 
--inline void* OS_GetTLSValue(OS_TLSIndex nIndex)
--{
--    ASSERT(nIndex != OS_INVALID_TLS_INDEX);
--#if defined(ANGLE_OS_WIN)
--    return TlsGetValue(nIndex);
--#elif defined(ANGLE_OS_POSIX)
--    return pthread_getspecific(nIndex);
--#endif  // ANGLE_OS_WIN
--}
--
- #endif // __OSINCLUDE_H
-diff --git a/src/3rdparty/angle/src/compiler/translator/ossource_posix.cpp b/src/3rdparty/angle/src/compiler/translator/ossource_posix.cpp
-index 90a3757..d4bba4c 100644
---- a/src/3rdparty/angle/src/compiler/translator/ossource_posix.cpp
-+++ b/src/3rdparty/angle/src/compiler/translator/ossource_posix.cpp
-@@ -33,6 +33,14 @@ OS_TLSIndex OS_AllocTLSIndex()
- }
- 
- 
-+void *OS_GetTLSValue(OS_TLSIndex nIndex)
-+{
-+    ASSERT(nIndex != OS_INVALID_TLS_INDEX);
-+
-+    return pthread_getspecific(nIndex);
-+}
-+
 +
- bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue)
+ TLSIndex CreateTLSIndex()
  {
-     if (nIndex == OS_INVALID_TLS_INDEX) {
-diff --git a/src/3rdparty/angle/src/compiler/translator/ossource_win.cpp b/src/3rdparty/angle/src/compiler/translator/ossource_win.cpp
-index 2cc5871..abd8bc7 100644
---- a/src/3rdparty/angle/src/compiler/translator/ossource_win.cpp
-+++ b/src/3rdparty/angle/src/compiler/translator/ossource_win.cpp
-@@ -29,6 +29,14 @@ OS_TLSIndex OS_AllocTLSIndex()
- }
- 
+     TLSIndex index;
  
-+void *OS_GetTLSValue(OS_TLSIndex nIndex)
-+{
-+    ASSERT(nIndex != OS_INVALID_TLS_INDEX);
-+
-+    return TlsGetValue(nIndex);
-+}
-+
-+
- bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue)
- {
- 	if (nIndex == OS_INVALID_TLS_INDEX) {
-diff --git a/src/3rdparty/angle/src/compiler/translator/ossource_winrt.cpp b/src/3rdparty/angle/src/compiler/translator/ossource_winrt.cpp
-new file mode 100644
-index 0000000..bb061ca
---- /dev/null
-+++ b/src/3rdparty/angle/src/compiler/translator/ossource_winrt.cpp
-@@ -0,0 +1,75 @@
-+//
-+// Copyright (c) 2002-2010 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.
-+//
-+
-+#include "compiler/translator/osinclude.h"
-+//
-+// This file contains contains Windows Runtime specific functions
-+//
-+
-+#if !defined(ANGLE_OS_WINRT)
-+#error Trying to build a WinRT specific file in a non-WinRT build.
-+#endif
-+
-+#include <vector>
-+
-+
-+//
-+// Thread Local Storage Operations
-+//
-+__declspec(thread) std::vector<void *> *tls = nullptr;
-+__declspec(thread) std::vector<OS_TLSIndex> *freeIndices = nullptr;
-+
-+OS_TLSIndex OS_AllocTLSIndex()
-+{
+-#ifdef ANGLE_PLATFORM_WINDOWS
++#if defined(ANGLE_PLATFORM_WINRT)
 +    if (!tls)
-+        tls = new std::vector<void*>;
-+
++        tls = new std::vector<void *>;
 +    if (freeIndices && !freeIndices->empty()) {
-+        OS_TLSIndex index = freeIndices->back();
++        index = freeIndices->back();
 +        freeIndices->pop_back();
 +        return index;
 +    } else {
 +        tls->push_back(nullptr);
 +        return tls->size() - 1;
 +    }
-+}
-+
-+
-+void *OS_GetTLSValue(OS_TLSIndex nIndex)
-+{
-+    ASSERT(nIndex != OS_INVALID_TLS_INDEX);
-+    ASSERT(tls);
++#elif defined(ANGLE_PLATFORM_WINDOWS)
+     index = TlsAlloc();
+ #elif defined(ANGLE_PLATFORM_POSIX)
+     // Create global pool key
+@@ -36,7 +53,12 @@ bool DestroyTLSIndex(TLSIndex index)
+         return false;
+     }
+ 
+-#ifdef ANGLE_PLATFORM_WINDOWS
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (!freeIndices)
++        freeIndices = new std::vector<TLSIndex>;
++    freeIndices->push_back(index);
++    return true;
++#elif ANGLE_PLATFORM_WINDOWS
+     return (TlsFree(index) == TRUE);
+ #elif defined(ANGLE_PLATFORM_POSIX)
+     return (pthread_key_delete(index) == 0);
+@@ -51,7 +73,10 @@ bool SetTLSValue(TLSIndex index, void *value)
+         return false;
+     }
+ 
+-#ifdef ANGLE_PLATFORM_WINDOWS
++#if defined(ANGLE_PLATFORM_WINRT)
++    tls->at(index) = value;
++    return true;
++#elif defined(ANGLE_PLATFORM_WINDOWS)
+     return (TlsSetValue(index, value) == TRUE);
+ #elif defined(ANGLE_PLATFORM_POSIX)
+     return (pthread_setspecific(index, value) == 0);
+@@ -60,13 +85,17 @@ bool SetTLSValue(TLSIndex index, void *value)
+ 
+ void *GetTLSValue(TLSIndex index)
+ {
++#if !defined(ANGLE_PLATFORM_WINRT) // Valid on WinRT, as Alloc handles the index creation
+     assert(index != TLS_INVALID_INDEX && "GetTLSValue(): Invalid TLS Index");
++#endif
+     if (index == TLS_INVALID_INDEX)
+     {
+         return NULL;
+     }
+ 
+-#ifdef ANGLE_PLATFORM_WINDOWS
++#if defined(ANGLE_PLATFORM_WINRT)
++    return tls->at(index);
++#elif defined(ANGLE_PLATFORM_WINDOWS)
+     return TlsGetValue(index);
+ #elif defined(ANGLE_PLATFORM_POSIX)
+     return pthread_getspecific(index);
+diff --git a/src/3rdparty/angle/src/common/tls.h b/src/3rdparty/angle/src/common/tls.h
+index 4b25fbc..c40ae1a 100644
+--- a/src/3rdparty/angle/src/common/tls.h
++++ b/src/3rdparty/angle/src/common/tls.h
+@@ -11,7 +11,11 @@
+ 
+ #include "common/platform.h"
+ 
+-#ifdef ANGLE_PLATFORM_WINDOWS
++#if defined(ANGLE_PLATFORM_WINRT)
++    typedef size_t TLSIndex;
++#   define TLS_OUT_OF_INDEXES (static_cast<TLSIndex>(-1))
++#   define TLS_INVALID_INDEX TLS_OUT_OF_INDEXES
++#elif defined(ANGLE_PLATFORM_WINDOWS)
+     typedef DWORD TLSIndex;
+ #   define TLS_INVALID_INDEX (TLS_OUT_OF_INDEXES)
+ #elif defined(ANGLE_PLATFORM_POSIX)
+diff --git a/src/3rdparty/angle/src/common/utilities.cpp b/src/3rdparty/angle/src/common/utilities.cpp
+index 405f119..4b8e325 100644
+--- a/src/3rdparty/angle/src/common/utilities.cpp
++++ b/src/3rdparty/angle/src/common/utilities.cpp
+@@ -9,6 +9,14 @@
+ #include "common/utilities.h"
+ #include "common/mathutil.h"
+ #include "common/platform.h"
++#if defined(ANGLE_PLATFORM_WINRT)
++#  include <locale>
++#  include <codecvt>
++#  include <wrl.h>
++#  include <windows.storage.h>
++   using namespace Microsoft::WRL;
++   using namespace ABI::Windows::Storage;
++#endif
+ 
+ #include <set>
+ 
+@@ -441,7 +449,48 @@ int VariableSortOrder(GLenum type)
+ 
+ std::string getTempPath()
+ {
+-#ifdef ANGLE_PLATFORM_WINDOWS
++#if defined(ANGLE_PLATFORM_WINRT)
++    static std::string path;
 +
-+    return tls->at(nIndex);
-+}
++    while (path.empty())
++    {
++        ComPtr<IApplicationDataStatics> factory;
++        Wrappers::HStringReference classId(RuntimeClass_Windows_Storage_ApplicationData);
++        HRESULT result = RoGetActivationFactory(classId.Get(), IID_PPV_ARGS(&factory));
++        if (FAILED(result))
++            break;
 +
++        ComPtr<IApplicationData> applicationData;
++        result = factory->get_Current(&applicationData);
++        if (FAILED(result))
++            break;
 +
-+bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue)
-+{
-+    if (!tls || nIndex >= tls->size() || nIndex == OS_INVALID_TLS_INDEX) {
-+        ASSERT(0 && "OS_SetTLSValue(): Invalid TLS Index");
-+        return false;
-+    }
++        ComPtr<IStorageFolder> storageFolder;
++        result = applicationData->get_LocalFolder(&storageFolder);
++        if (FAILED(result))
++            break;
 +
-+    tls->at(nIndex) = lpvValue;
-+    return true;
-+}
++        ComPtr<IStorageItem> localFolder;
++        result = storageFolder.As(&localFolder);
++        if (FAILED(result))
++            break;
 +
++        HSTRING localFolderPath;
++        result = localFolder->get_Path(&localFolderPath);
++        if (FAILED(result))
++            break;
 +
-+bool OS_FreeTLSIndex(OS_TLSIndex nIndex)
-+{
-+    if (!tls || nIndex >= tls->size() || nIndex == OS_INVALID_TLS_INDEX) {
-+        ASSERT(0 && "OS_SetTLSValue(): Invalid TLS Index");
-+        return false;
++        std::wstring_convert< std::codecvt_utf8<wchar_t> > converter;
++        path = converter.to_bytes(WindowsGetStringRawBuffer(localFolderPath, NULL));
++        if (path.empty())
++        {
++            UNREACHABLE();
++            break;
++        }
 +    }
 +
-+    if (!freeIndices)
-+        freeIndices = new std::vector<OS_TLSIndex>;
-+
-+    freeIndices->push_back(nIndex);
-+
-+    return true;
-+}
++    return path;
++#elif defined(ANGLE_PLATFORM_WINDOWS)
+     char path[MAX_PATH];
+     DWORD pathLen = GetTempPathA(sizeof(path) / sizeof(path[0]), path);
+     if (pathLen == 0)
 diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp
-index a7f5f5a..e75a4b6 100644
+index a87bfe8..7cd83c3 100644
 --- a/src/3rdparty/angle/src/libEGL/Display.cpp
 +++ b/src/3rdparty/angle/src/libEGL/Display.cpp
-@@ -1,3 +1,4 @@
-+#include "../libGLESv2/precompiled.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
-@@ -40,13 +41,13 @@ egl::Display *Display::getDisplay(EGLNativeDisplayType displayId)
- 
-     // FIXME: Check if displayId is a valid display device context
- 
--    egl::Display *display = new egl::Display(displayId, (HDC)displayId);
-+    egl::Display *display = new egl::Display(displayId);
- 
-     displays[displayId] = display;
-     return display;
+@@ -57,6 +57,10 @@ Display::Display(EGLNativeDisplayType displayId, EGLint displayType)
+       mRequestedDisplayType(displayType),
+       mRenderer(NULL)
+ {
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (mDisplayId)
++        mDisplayId->AddRef();
++#endif
  }
  
--Display::Display(EGLNativeDisplayType displayId, HDC deviceContext) : mDc(deviceContext)
-+Display::Display(EGLNativeDisplayType displayId)
- {
-     mDisplayId = displayId;
-     mRenderer = NULL;
-@@ -71,7 +72,7 @@ bool Display::initialize()
-         return true;
+ Display::~Display()
+@@ -69,6 +73,11 @@ Display::~Display()
+     {
+         displays->erase(iter);
      }
++
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (mDisplayId)
++        mDisplayId->Release();
++#endif
+ }
  
--    mRenderer = glCreateRenderer(this, mDc, mDisplayId);
-+    mRenderer = glCreateRenderer(this, mDisplayId);
-     
-     if (!mRenderer)
-     {
-@@ -186,7 +187,7 @@ bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
+ bool Display::initialize()
+@@ -193,7 +202,7 @@ bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
  
  
  
@@ -279,7 +275,7 @@ index a7f5f5a..e75a4b6 100644
  {
      const Config *configuration = mConfigSet.get(config);
      EGLint postSubBufferSupported = EGL_FALSE;
-@@ -456,7 +457,7 @@ bool Display::isValidSurface(egl::Surface *surface)
+@@ -494,7 +503,7 @@ bool Display::isValidSurface(egl::Surface *surface)
      return mSurfaceSet.find(surface) != mSurfaceSet.end();
  }
  
@@ -289,19 +285,19 @@ index a7f5f5a..e75a4b6 100644
      for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
      {
 diff --git a/src/3rdparty/angle/src/libEGL/Display.h b/src/3rdparty/angle/src/libEGL/Display.h
-index c816e4e..cd07bb3 100644
+index 250878f..73ba767 100644
 --- a/src/3rdparty/angle/src/libEGL/Display.h
 +++ b/src/3rdparty/angle/src/libEGL/Display.h
-@@ -38,7 +38,7 @@ class Display
+@@ -43,7 +43,7 @@ class Display
      bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
      bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
  
 -    EGLSurface createWindowSurface(HWND window, EGLConfig config, const EGLint *attribList);
 +    EGLSurface createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList);
      EGLSurface createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList);
-     EGLContext createContext(EGLConfig configHandle, const gl::Context *shareContext, bool notifyResets, bool robustAccess);
+     EGLContext createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets, bool robustAccess);
  
-@@ -49,7 +49,7 @@ class Display
+@@ -54,7 +54,7 @@ class Display
      bool isValidConfig(EGLConfig config);
      bool isValidContext(gl::Context *context);
      bool isValidSurface(egl::Surface *surface);
@@ -310,72 +306,184 @@ index c816e4e..cd07bb3 100644
  
      rx::Renderer *getRenderer() { return mRenderer; };
  
-@@ -63,12 +63,11 @@ class Display
+@@ -65,6 +65,8 @@ class Display
+     const char *getExtensionString() const;
+     const char *getVendorString() const;
+ 
++    EGLNativeDisplayType getDisplayId() const { return mDisplayId; }
++
    private:
      DISALLOW_COPY_AND_ASSIGN(Display);
  
--    Display(EGLNativeDisplayType displayId, HDC deviceContext);
-+    Display(EGLNativeDisplayType displayId);
- 
-     bool restoreLostDevice();
- 
-     EGLNativeDisplayType mDisplayId;
--    const HDC mDc;
- 
-     bool mSoftwareDevice;
-     
 diff --git a/src/3rdparty/angle/src/libEGL/Surface.cpp b/src/3rdparty/angle/src/libEGL/Surface.cpp
-index 12f8dfd..3443355 100644
+index 13b0f20..fa79961 100644
 --- a/src/3rdparty/angle/src/libEGL/Surface.cpp
 +++ b/src/3rdparty/angle/src/libEGL/Surface.cpp
-@@ -1,3 +1,4 @@
-+#include "../libGLESv2/precompiled.h"
- //
- // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
-@@ -22,10 +23,15 @@
+@@ -22,10 +22,20 @@
  #include "libEGL/main.h"
  #include "libEGL/Display.h"
  
-+#if defined(ANGLE_OS_WINRT)
-+#include <windows.foundation.h>
-+#include <windows.ui.core.h>
++#if defined(ANGLE_PLATFORM_WINRT)
++#  include "wrl.h"
++#  include "windows.graphics.display.h"
++#  include "windows.ui.core.h"
++using namespace ABI::Windows::Graphics::Display;
++using namespace ABI::Windows::Foundation;
++using namespace ABI::Windows::UI::Core;
++using namespace Microsoft::WRL;
 +#endif
 +
  namespace egl
  {
  
--Surface::Surface(Display *display, const Config *config, HWND window, EGLint postSubBufferSupported) 
-+Surface::Surface(Display *display, const Config *config, EGLNativeWindowType window, EGLint postSubBufferSupported)
+-Surface::Surface(Display *display, const Config *config, HWND window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported) 
++Surface::Surface(Display *display, const Config *config, EGLNativeWindowType window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported)
      : mDisplay(display), mConfig(config), mWindow(window), mPostSubBufferSupported(postSubBufferSupported)
  {
      mRenderer = mDisplay->getRenderer();
-@@ -98,6 +104,7 @@ bool Surface::resetSwapChain()
+@@ -43,6 +53,17 @@ Surface::Surface(Display *display, const Config *config, HWND window, EGLint fix
+     mHeight = height;
+     setSwapInterval(1);
+     mFixedSize = fixedSize;
++    mSwapFlags = rx::SWAP_NORMAL;
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (mWindow)
++        mWindow->AddRef();
++    mScaleFactor = 1.0;
++    mSizeToken.value = 0;
++    mDpiToken.value = 0;
++#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
++    mOrientationToken.value = 0;
++#   endif
++#endif
  
-     if (mWindow)
+     subclassWindow();
+ }
+@@ -64,16 +85,86 @@ Surface::Surface(Display *display, const Config *config, HANDLE shareHandle, EGL
+     setSwapInterval(1);
+     // This constructor is for offscreen surfaces, which are always fixed-size.
+     mFixedSize = EGL_TRUE;
++    mSwapFlags = rx::SWAP_NORMAL;
++#if defined(ANGLE_PLATFORM_WINRT)
++    mScaleFactor = 1.0;
++    mSizeToken.value = 0;
++    mDpiToken.value = 0;
++#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
++    mOrientationToken.value = 0;
++#   endif
++#endif
+ }
+ 
+ Surface::~Surface()
+ {
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (mSizeToken.value) {
++        ComPtr<ICoreWindow> coreWindow;
++        HRESULT hr = mWindow->QueryInterface(coreWindow.GetAddressOf());
++        ASSERT(SUCCEEDED(hr));
++
++        hr = coreWindow->remove_SizeChanged(mSizeToken);
++        ASSERT(SUCCEEDED(hr));
++    }
++    if (mDpiToken.value) {
++        ComPtr<IDisplayInformation> displayInformation;
++        HRESULT hr = mDisplay->getDisplayId()->QueryInterface(displayInformation.GetAddressOf());
++        ASSERT(SUCCEEDED(hr));
++
++        hr = displayInformation->remove_DpiChanged(mDpiToken);
++        ASSERT(SUCCEEDED(hr));
++    }
++#   if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
++    if (mOrientationToken.value) {
++        ComPtr<IDisplayInformation> displayInformation;
++        HRESULT hr = mDisplay->getDisplayId()->QueryInterface(displayInformation.GetAddressOf());
++        ASSERT(SUCCEEDED(hr));
++
++        hr = displayInformation->remove_OrientationChanged(mOrientationToken);
++        ASSERT(SUCCEEDED(hr));
++    }
++#   endif
++#endif
+     unsubclassWindow();
+     release();
+ }
+ 
+ bool Surface::initialize()
+ {
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (!mFixedSize) {
++        HRESULT hr;
++        ComPtr<IDisplayInformation> displayInformation;
++        hr = mDisplay->getDisplayId()->QueryInterface(displayInformation.GetAddressOf());
++        ASSERT(SUCCEEDED(hr));
++        onDpiChanged(displayInformation.Get(), 0);
++        hr = displayInformation->add_DpiChanged(Callback<ITypedEventHandler<DisplayInformation *, IInspectable *>>(this, &Surface::onDpiChanged).Get(),
++                                                &mDpiToken);
++        ASSERT(SUCCEEDED(hr));
++
++#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
++        onOrientationChanged(displayInformation.Get(), 0);
++        hr = displayInformation->add_OrientationChanged(Callback<ITypedEventHandler<DisplayInformation *, IInspectable *>>(this, &Surface::onOrientationChanged).Get(),
++                                                        &mOrientationToken);
++        ASSERT(SUCCEEDED(hr));
++#   endif
++
++        ComPtr<ICoreWindow> coreWindow;
++        hr = mWindow->QueryInterface(coreWindow.GetAddressOf());
++        ASSERT(SUCCEEDED(hr));
++
++        Rect rect;
++        hr = coreWindow->get_Bounds(&rect);
++        ASSERT(SUCCEEDED(hr));
++        mWidth = rect.Width * mScaleFactor;
++        mHeight = rect.Height * mScaleFactor;
++        hr = coreWindow->add_SizeChanged(Callback<ITypedEventHandler<CoreWindow *, WindowSizeChangedEventArgs *>>(this, &Surface::onSizeChanged).Get(),
++                                         &mSizeToken);
++        ASSERT(SUCCEEDED(hr));
++    }
++#endif
++
+     if (!resetSwapChain())
+       return false;
+ 
+@@ -90,6 +181,11 @@ void Surface::release()
+         mTexture->releaseTexImage();
+         mTexture = NULL;
+     }
++
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (mWindow)
++        mWindow->Release();
++#endif
+ }
+ 
+ bool Surface::resetSwapChain()
+@@ -99,6 +195,7 @@ bool Surface::resetSwapChain()
+     int width;
+     int height;
+ 
++#if !defined(ANGLE_PLATFORM_WINRT)
+     if (!mFixedSize)
      {
-+#if !defined(ANGLE_OS_WINRT)
          RECT windowRect;
-         if (!GetClientRect(getWindowHandle(), &windowRect))
-         {
-@@ -109,6 +116,16 @@ bool Surface::resetSwapChain()
- 
-         width = windowRect.right - windowRect.left;
+@@ -114,6 +211,7 @@ bool Surface::resetSwapChain()
          height = windowRect.bottom - windowRect.top;
-+#else
-+        ABI::Windows::Foundation::Rect windowRect;
-+        ABI::Windows::UI::Core::ICoreWindow *window;
-+        HRESULT hr = mWindow->QueryInterface(IID_PPV_ARGS(&window));
-+        if (FAILED(hr))
-+            return false;
-+        window->get_Bounds(&windowRect);
-+        width = windowRect.Width;
-+        height = windowRect.Height;
-+#endif
      }
      else
++#endif
      {
-@@ -221,7 +238,7 @@ bool Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+         // non-window surface - size is determined at creation
+         width = mWidth;
+@@ -207,7 +305,7 @@ bool Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+         return true;
+     }
+ 
+-    EGLint status = mSwapChain->swapRect(x, y, width, height);
++    EGLint status = mSwapChain->swapRect(x, y, width, height, mSwapFlags);
+ 
+     if (status == EGL_CONTEXT_LOST)
+     {
+@@ -224,7 +322,7 @@ bool Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
      return true;
  }
  
@@ -384,15 +492,15 @@ index 12f8dfd..3443355 100644
  {
      return mWindow;
  }
-@@ -230,6 +247,7 @@ HWND Surface::getWindowHandle()
+@@ -233,6 +331,7 @@ HWND Surface::getWindowHandle()
  #define kSurfaceProperty _TEXT("Egl::SurfaceOwner")
  #define kParentWndProc _TEXT("Egl::SurfaceParentWndProc")
  
-+#if !defined(ANGLE_OS_WINRT)
++#if !defined(ANGLE_PLATFORM_WINRT)
  static LRESULT CALLBACK SurfaceWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
  {
    if (message == WM_SIZE)
-@@ -243,9 +261,13 @@ static LRESULT CALLBACK SurfaceWindowProc(HWND hwnd, UINT message, WPARAM wparam
+@@ -246,9 +345,11 @@ static LRESULT CALLBACK SurfaceWindowProc(HWND hwnd, UINT message, WPARAM wparam
    WNDPROC prevWndFunc = reinterpret_cast<WNDPROC >(GetProp(hwnd, kParentWndProc));
    return CallWindowProc(prevWndFunc, hwnd, message, wparam, lparam);
  }
@@ -400,26 +508,26 @@ index 12f8dfd..3443355 100644
  
  void Surface::subclassWindow()
  {
-+#if defined(ANGLE_OS_WINRT)
-+    mWindowSubclassed = false;
-+#else
++#if !defined(ANGLE_PLATFORM_WINRT)
      if (!mWindow)
      {
          return;
-@@ -269,10 +291,12 @@ void Surface::subclassWindow()
+@@ -272,10 +373,14 @@ void Surface::subclassWindow()
      SetProp(mWindow, kSurfaceProperty, reinterpret_cast<HANDLE>(this));
      SetProp(mWindow, kParentWndProc, reinterpret_cast<HANDLE>(oldWndProc));
      mWindowSubclassed = true;
++#else
++    mWindowSubclassed = false;
 +#endif
  }
  
  void Surface::unsubclassWindow()
  {
-+#if !defined(ANGLE_OS_WINRT)
++#if !defined(ANGLE_PLATFORM_WINRT)
      if(!mWindowSubclassed)
      {
          return;
-@@ -295,10 +319,12 @@ void Surface::unsubclassWindow()
+@@ -299,16 +404,18 @@ void Surface::unsubclassWindow()
      RemoveProp(mWindow, kSurfaceProperty);
      RemoveProp(mWindow, kParentWndProc);
      mWindowSubclassed = false;
@@ -428,51 +536,134 @@ index 12f8dfd..3443355 100644
  
  bool Surface::checkForOutOfDateSwapChain()
  {
-+#if !defined(ANGLE_OS_WINRT)
-     RECT client;
-     if (!GetClientRect(getWindowHandle(), &client))
-     {
-@@ -309,14 +335,26 @@ bool Surface::checkForOutOfDateSwapChain()
-     // Grow the buffer now, if the window has grown. We need to grow now to avoid losing information.
-     int clientWidth = client.right - client.left;
-     int clientHeight = client.bottom - client.top;
-+#else
-+    ABI::Windows::Foundation::Rect windowRect;
-+    ABI::Windows::UI::Core::ICoreWindow *window;
-+    HRESULT hr = mWindow->QueryInterface(IID_PPV_ARGS(&window));
-+    if (FAILED(hr))
-+        return false;
-+    window->get_Bounds(&windowRect);
-+    int clientWidth = windowRect.Width;
-+    int clientHeight = windowRect.Height;
-+#endif
-     bool sizeDirty = clientWidth != getWidth() || clientHeight != getHeight();
- 
-+#if !defined(ANGLE_OS_WINRT)
-     if (IsIconic(getWindowHandle()))
+-    RECT client;
+     int clientWidth = getWidth();
+     int clientHeight = getHeight();
+     bool sizeDirty = false;
++#if !defined(ANGLE_PLATFORM_WINRT)
+     if (!mFixedSize && !IsIconic(getWindowHandle()))
      {
++        RECT client;
          // The window is automatically resized to 150x22 when it's minimized, but the swapchain shouldn't be resized
          // because that's not a useful size to render to.
-         sizeDirty = false;
+         if (!GetClientRect(getWindowHandle(), &client))
+@@ -322,6 +429,7 @@ bool Surface::checkForOutOfDateSwapChain()
+         clientHeight = client.bottom - client.top;
+         sizeDirty = clientWidth != getWidth() || clientHeight != getHeight();
      }
 +#endif
  
      bool wasDirty = (mSwapIntervalDirty || sizeDirty);
  
+@@ -446,4 +554,73 @@ EGLenum Surface::getFormat() const
+ {
+     return mConfig->mRenderTargetFormat;
+ }
++
++#if defined(ANGLE_PLATFORM_WINRT)
++
++HRESULT Surface::onSizeChanged(ICoreWindow *, IWindowSizeChangedEventArgs *args)
++{
++    HRESULT hr;
++    Size size;
++    hr = args->get_Size(&size);
++    ASSERT(SUCCEEDED(hr));
++
++    resizeSwapChain(std::floor(size.Width * mScaleFactor + 0.5),
++                    std::floor(size.Height * mScaleFactor + 0.5));
++
++    if (static_cast<egl::Surface*>(getCurrentDrawSurface()) == this)
++    {
++        glMakeCurrent(glGetCurrentContext(), static_cast<egl::Display*>(getCurrentDisplay()), this);
++    }
++
++    return S_OK;
++}
++
++HRESULT Surface::onDpiChanged(IDisplayInformation *displayInformation, IInspectable *)
++{
++    HRESULT hr;
++#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
++    ComPtr<IDisplayInformation2> displayInformation2;
++    hr = displayInformation->QueryInterface(displayInformation2.GetAddressOf());
++    ASSERT(SUCCEEDED(hr));
++
++    hr = displayInformation2->get_RawPixelsPerViewPixel(&mScaleFactor);
++    ASSERT(SUCCEEDED(hr));
++#   else
++    ResolutionScale resolutionScale;
++    hr = displayInformation->get_ResolutionScale(&resolutionScale);
++    ASSERT(SUCCEEDED(hr));
++
++    mScaleFactor = double(resolutionScale) / 100.0;
++#   endif
++    return S_OK;
++}
++
++#   if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
++HRESULT Surface::onOrientationChanged(IDisplayInformation *displayInformation, IInspectable *)
++{
++    HRESULT hr;
++    DisplayOrientations orientation;
++    hr = displayInformation->get_CurrentOrientation(&orientation);
++    ASSERT(SUCCEEDED(hr));
++    switch (orientation) {
++    default:
++    case DisplayOrientations_Portrait:
++        mSwapFlags = rx::SWAP_NORMAL;
++        break;
++    case DisplayOrientations_Landscape:
++        mSwapFlags = rx::SWAP_ROTATE_90;
++        break;
++    case DisplayOrientations_LandscapeFlipped:
++        mSwapFlags = rx::SWAP_ROTATE_270;
++        break;
++    case DisplayOrientations_PortraitFlipped:
++        mSwapFlags = rx::SWAP_ROTATE_180;
++        break;
++    }
++    return S_OK;
++}
++#   endif
++
++#endif
++
+ }
 diff --git a/src/3rdparty/angle/src/libEGL/Surface.h b/src/3rdparty/angle/src/libEGL/Surface.h
-index 938b800..1d2303c 100644
+index 3caf620..ebffce8 100644
 --- a/src/3rdparty/angle/src/libEGL/Surface.h
 +++ b/src/3rdparty/angle/src/libEGL/Surface.h
-@@ -34,7 +34,7 @@ class Config;
+@@ -15,6 +15,20 @@
+ 
+ #include "common/angleutils.h"
+ 
++#if defined(ANGLE_PLATFORM_WINRT)
++#include <EventToken.h>
++namespace ABI { namespace Windows {
++    namespace UI { namespace Core {
++        struct ICoreWindow;
++        struct IWindowSizeChangedEventArgs;
++    } }
++    namespace Graphics { namespace Display {
++        struct IDisplayInformation;
++    } }
++} }
++struct IInspectable;
++#endif
++
+ namespace gl
+ {
+ class Texture2D;
+@@ -33,7 +47,7 @@ class Config;
  class Surface
  {
    public:
--    Surface(Display *display, const egl::Config *config, HWND window, EGLint postSubBufferSupported);
-+    Surface(Display *display, const egl::Config *config, EGLNativeWindowType window, EGLint postSubBufferSupported);
+-    Surface(Display *display, const egl::Config *config, HWND window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported);
++    Surface(Display *display, const egl::Config *config, EGLNativeWindowType window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported);
      Surface(Display *display, const egl::Config *config, HANDLE shareHandle, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureTarget);
  
-     ~Surface();
-@@ -43,7 +43,7 @@ class Surface
+     virtual ~Surface();
+@@ -42,7 +56,7 @@ class Surface
      void release();
      bool resetSwapChain();
  
@@ -481,422 +672,270 @@ index 938b800..1d2303c 100644
      bool swap();
      bool postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height);
  
-@@ -79,7 +79,7 @@ private:
+@@ -71,6 +85,14 @@ class Surface
+ private:
+     DISALLOW_COPY_AND_ASSIGN(Surface);
+ 
++#if defined(ANGLE_PLATFORM_WINRT)
++    HRESULT onSizeChanged(ABI::Windows::UI::Core::ICoreWindow *, ABI::Windows::UI::Core::IWindowSizeChangedEventArgs *);
++    HRESULT onDpiChanged(ABI::Windows::Graphics::Display::IDisplayInformation *, IInspectable *);
++#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
++    HRESULT onOrientationChanged(ABI::Windows::Graphics::Display::IDisplayInformation *, IInspectable *);
++#   endif
++#endif
++
+     Display *const mDisplay;
+     rx::Renderer *mRenderer;
+ 
+@@ -83,7 +105,7 @@ private:
      bool resetSwapChain(int backbufferWidth, int backbufferHeight);
      bool swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
  
 -    const HWND mWindow;            // Window that the surface is created for.
-+    const EGLNativeWindowType mWindow; // Window that the surface is created for.
++    const EGLNativeWindowType mWindow;            // Window that the surface is created for.
      bool mWindowSubclassed;        // Indicates whether we successfully subclassed mWindow for WM_RESIZE hooking
      const egl::Config *mConfig;    // EGL config surface was created with
      EGLint mHeight;                // Height of surface
+@@ -104,9 +126,18 @@ private:
+     EGLint mSwapInterval;
+     EGLint mPostSubBufferSupported;
+     EGLint mFixedSize;
+-    
++    EGLint mSwapFlags;
++
+     bool mSwapIntervalDirty;
+     gl::Texture2D *mTexture;
++#if defined(ANGLE_PLATFORM_WINRT)
++    double mScaleFactor;
++    EventRegistrationToken mSizeToken;
++    EventRegistrationToken mDpiToken;
++#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
++    EventRegistrationToken mOrientationToken;
++#   endif
++#endif
+ };
+ }
+ 
 diff --git a/src/3rdparty/angle/src/libEGL/libEGL.cpp b/src/3rdparty/angle/src/libEGL/libEGL.cpp
-index 0ea46d4..b2944d5 100644
+index 23df448..a08e1ed 100644
 --- a/src/3rdparty/angle/src/libEGL/libEGL.cpp
 +++ b/src/3rdparty/angle/src/libEGL/libEGL.cpp
-@@ -308,14 +308,16 @@ EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EG
-             return EGL_NO_SURFACE;
-         }
+@@ -10,6 +10,7 @@
  
-+#if !defined(ANGLE_OS_WINRT)
-         HWND window = (HWND)win;
+ #include "common/debug.h"
+ #include "common/version.h"
++#include "common/platform.h"
+ #include "libGLESv2/Context.h"
+ #include "libGLESv2/Texture.h"
+ #include "libGLESv2/main.h"
+@@ -117,12 +118,13 @@ EGLDisplay __stdcall eglGetPlatformDisplayEXT(EGLenum platform, void *native_dis
+     }
  
-         if (!IsWindow(window))
-         {
-             return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
-         }
+     EGLNativeDisplayType displayId = static_cast<EGLNativeDisplayType>(native_display);
+-
++#if !defined(ANGLE_PLATFORM_WINRT)
+     // Validate the display device context
+     if (WindowFromDC(displayId) == NULL)
+     {
+         return egl::success(EGL_NO_DISPLAY);
+     }
 +#endif
  
--        return display->createWindowSurface(window, config, attrib_list);
-+        return display->createWindowSurface(win, config, attrib_list);
+     EGLint requestedDisplayType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+     if (attrib_list)
+@@ -324,14 +326,16 @@ EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EG
+         return EGL_NO_SURFACE;
      }
-     catch(std::bad_alloc&)
+ 
++#if !defined(ANGLE_PLATFORM_WINRT)
+     HWND window = (HWND)win;
+ 
+     if (!IsWindow(window))
      {
+         return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
+     }
++#endif
+ 
+-    return display->createWindowSurface(window, config, attrib_list);
++    return display->createWindowSurface(win, config, attrib_list);
+ }
+ 
+ EGLSurface __stdcall eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
 diff --git a/src/3rdparty/angle/src/libEGL/main.cpp b/src/3rdparty/angle/src/libEGL/main.cpp
-index 772b8eb..e972691 100644
+index 8a1baef..5788af7 100644
 --- a/src/3rdparty/angle/src/libEGL/main.cpp
 +++ b/src/3rdparty/angle/src/libEGL/main.cpp
-@@ -1,3 +1,4 @@
-+#include "../libGLESv2/precompiled.h"
- //
- // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
-@@ -10,14 +11,23 @@
- 
+@@ -11,6 +11,9 @@
  #include "common/debug.h"
+ #include "common/tls.h"
  
-+#if !defined(ANGLE_OS_WINRT)
- static DWORD currentTLS = TLS_OUT_OF_INDEXES;
-+#else
-+static __declspec(thread) void *currentTLS = 0;
++#if defined(ANGLE_PLATFORM_WINRT)
++__declspec(thread)
 +#endif
+ static TLSIndex currentTLS = TLS_OUT_OF_INDEXES;
  
  namespace egl
- {
+@@ -18,6 +21,12 @@ namespace egl
  
  Current *AllocateCurrent()
  {
-+#if !defined(ANGLE_OS_WINRT)
-     Current *current = (egl::Current*)LocalAlloc(LPTR, sizeof(egl::Current));
-+#else
-+    currentTLS = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Current));
-+    Current *current = (egl::Current*)currentTLS;
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (currentTLS == TLS_OUT_OF_INDEXES)
++    {
++        currentTLS = CreateTLSIndex();
++    }
 +#endif
- 
-     if (!current)
-     {
-@@ -25,8 +35,10 @@ Current *AllocateCurrent()
-         return NULL;
-     }
- 
-+#if !defined(ANGLE_OS_WINRT)
      ASSERT(currentTLS != TLS_OUT_OF_INDEXES);
-     TlsSetValue(currentTLS, current);
-+#endif
- 
-     current->error = EGL_SUCCESS;
-     current->API = EGL_OPENGL_ES_API;
-@@ -39,12 +51,20 @@ Current *AllocateCurrent()
+     if (currentTLS == TLS_OUT_OF_INDEXES)
+     {
+@@ -42,6 +51,12 @@ Current *AllocateCurrent()
  
  void DeallocateCurrent()
  {
-+#if !defined(ANGLE_OS_WINRT)
-     void *current = TlsGetValue(currentTLS);
- 
-     if (current)
-     {
-         LocalFree((HLOCAL)current);
-     }
-+#else
-+    if (currentTLS)
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (currentTLS == TLS_OUT_OF_INDEXES)
 +    {
-+        HeapFree(GetProcessHeap(), 0, currentTLS);
-+        currentTLS = 0;
++        return;
 +    }
 +#endif
- }
- 
- }
-@@ -69,13 +89,14 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
-                 }
+     Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS));
+     SafeDelete(current);
+     SetTLSValue(currentTLS, NULL);
+@@ -72,6 +87,10 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
              }
  #endif
--
-+#if !defined(ANGLE_OS_WINRT)
-             currentTLS = TlsAlloc();
  
++#if defined(ANGLE_PLATFORM_WINRT) // On WinRT, don't handle TLS from DllMain
++            return DisableThreadLibraryCalls(instance);
++#endif
++
+             currentTLS = CreateTLSIndex();
              if (currentTLS == TLS_OUT_OF_INDEXES)
              {
-                 return FALSE;
-             }
-+#endif
-         }
-         // Fall throught to initialize index
-       case DLL_THREAD_ATTACH:
-@@ -91,7 +112,9 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+@@ -91,8 +110,10 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+         break;
        case DLL_PROCESS_DETACH:
          {
++#if !defined(ANGLE_PLATFORM_WINRT)
              egl::DeallocateCurrent();
-+#if !defined(ANGLE_OS_WINRT)
-             TlsFree(currentTLS);
+             DestroyTLSIndex(currentTLS);
 +#endif
          }
          break;
        default:
-@@ -107,8 +130,12 @@ namespace egl
- Current *GetCurrentData()
- {
- #ifndef QT_OPENGL_ES_2_ANGLE_STATIC
-+#if !defined(ANGLE_OS_WINRT)
-     Current *current = (Current*)TlsGetValue(currentTLS);
- #else
-+    Current *current = (Current*)currentTLS;
-+#endif
-+#else
-     // No precautions for thread safety taken as ANGLE is used single-threaded in Qt.
-     static Current s_current = { EGL_SUCCESS, EGL_OPENGL_ES_API, EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE };
-     Current *current = &s_current;
-diff --git a/src/3rdparty/angle/src/libGLESv2/Context.cpp b/src/3rdparty/angle/src/libGLESv2/Context.cpp
-index 1a058b6..e651785 100644
---- a/src/3rdparty/angle/src/libGLESv2/Context.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/Context.cpp
-@@ -1076,6 +1076,7 @@ void Context::setRenderbufferStorage(GLsizei width, GLsizei height, GLenum inter
-       case GL_RGB565:
-       case GL_RGB8_OES:
-       case GL_RGBA8_OES:
-+      case GL_BGRA8_EXT:
-         renderbuffer = new gl::Colorbuffer(mRenderer,width, height, internalformat, samples);
-         break;
-       case GL_STENCIL_INDEX8:
-diff --git a/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp b/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp
-index a33481e..814dfbf 100644
---- a/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/libGLESv2.cpp
-@@ -4895,6 +4895,7 @@ void __stdcall glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samp
-               case GL_RGBA8_OES:
-               case GL_STENCIL_INDEX8:
-               case GL_DEPTH24_STENCIL8_OES:
-+              case GL_BGRA8_EXT:
-                 context->setRenderbufferStorage(width, height, internalformat, samples);
-                 break;
-               default:
 diff --git a/src/3rdparty/angle/src/libGLESv2/main.cpp b/src/3rdparty/angle/src/libGLESv2/main.cpp
-index 6b459d3..95f4b8d 100644
+index 5a45ec3..8820700 100644
 --- a/src/3rdparty/angle/src/libGLESv2/main.cpp
 +++ b/src/3rdparty/angle/src/libGLESv2/main.cpp
-@@ -11,14 +11,23 @@
+@@ -12,6 +12,9 @@
  
- #include "libGLESv2/Context.h"
+ #include "common/tls.h"
  
-+#if !defined(ANGLE_OS_WINRT)
- static DWORD currentTLS = TLS_OUT_OF_INDEXES;
-+#else
-+static __declspec(thread) void *currentTLS = 0;
++#if defined(ANGLE_PLATFORM_WINRT)
++__declspec(thread)
 +#endif
+ static TLSIndex currentTLS = TLS_OUT_OF_INDEXES;
  
  namespace gl
- {
+@@ -19,6 +22,12 @@ namespace gl
  
  Current *AllocateCurrent()
  {
-+#if !defined(ANGLE_OS_WINRT)
-     Current *current = (Current*)LocalAlloc(LPTR, sizeof(Current));
-+#else
-+    currentTLS = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Current));
-+    Current *current = (Current*)currentTLS;
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (currentTLS == TLS_OUT_OF_INDEXES)
++    {
++        currentTLS = CreateTLSIndex();
++    }
 +#endif
- 
-     if (!current)
-     {
-@@ -26,8 +35,10 @@ Current *AllocateCurrent()
-         return NULL;
-     }
- 
-+#if !defined(ANGLE_OS_WINRT)
      ASSERT(currentTLS != TLS_OUT_OF_INDEXES);
-     TlsSetValue(currentTLS, current);
-+#endif
- 
-     current->context = NULL;
-     current->display = NULL;
-@@ -37,12 +48,20 @@ Current *AllocateCurrent()
+     if (currentTLS == TLS_OUT_OF_INDEXES)
+     {
+@@ -40,6 +49,12 @@ Current *AllocateCurrent()
  
  void DeallocateCurrent()
  {
-+#if !defined(ANGLE_OS_WINRT)
-     void *current = TlsGetValue(currentTLS);
- 
-     if (current)
-     {
-         LocalFree((HLOCAL)current);
-     }
-+#else
-+    if (currentTLS)
++#if defined(ANGLE_PLATFORM_WINRT)
++    if (currentTLS == TLS_OUT_OF_INDEXES)
 +    {
-+        HeapFree(GetProcessHeap(), 0, currentTLS);
-+        currentTLS = 0;
++        return;
 +    }
 +#endif
- }
- 
- }
-@@ -53,12 +72,14 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+     Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS));
+     SafeDelete(current);
+     SetTLSValue(currentTLS, NULL);
+@@ -55,6 +70,9 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
      {
        case DLL_PROCESS_ATTACH:
          {
-+#if !defined(ANGLE_OS_WINRT)
-             currentTLS = TlsAlloc();
- 
++#if defined(ANGLE_PLATFORM_WINRT) // On WinRT, don't handle TLS from DllMain
++            return DisableThreadLibraryCalls(instance);
++#endif
+             currentTLS = CreateTLSIndex();
              if (currentTLS == TLS_OUT_OF_INDEXES)
              {
-                 return FALSE;
-             }
-+#endif
-         }
-         // Fall throught to initialize index
-       case DLL_THREAD_ATTACH:
-@@ -74,7 +95,9 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+@@ -74,8 +92,10 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
+         break;
        case DLL_PROCESS_DETACH:
          {
++#if !defined(ANGLE_PLATFORM_WINRT)
              gl::DeallocateCurrent();
-+#if !defined(ANGLE_OS_WINRT)
-             TlsFree(currentTLS);
+             DestroyTLSIndex(currentTLS);
 +#endif
          }
          break;
        default:
-@@ -90,8 +113,12 @@ namespace gl
- Current *GetCurrentData()
- {
- #ifndef QT_OPENGL_ES_2_ANGLE_STATIC
-+#if !defined(ANGLE_OS_WINRT)
-     Current *current = (Current*)TlsGetValue(currentTLS);
- #else
-+    Current *current = (Current*)currentTLS;
-+#endif
-+#else
-     // No precautions for thread safety taken as ANGLE is used single-threaded in Qt.
-     static Current s_current = { 0, 0 };
-     Current *current = &s_current;
 diff --git a/src/3rdparty/angle/src/libGLESv2/main.h b/src/3rdparty/angle/src/libGLESv2/main.h
-index b413f23..69465c9 100644
+index c117039..df28ea4 100644
 --- a/src/3rdparty/angle/src/libGLESv2/main.h
 +++ b/src/3rdparty/angle/src/libGLESv2/main.h
-@@ -57,7 +57,7 @@ gl::Context *glCreateContext(const gl::Context *shareContext, rx::Renderer *rend
- void glDestroyContext(gl::Context *context);
- void glMakeCurrent(gl::Context *context, egl::Display *display, egl::Surface *surface);
- gl::Context *glGetCurrentContext();
--rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayType displayId);
-+rx::Renderer *glCreateRenderer(egl::Display *display, EGLNativeDisplayType displayId);
- void glDestroyRenderer(rx::Renderer *renderer);
- 
- __eglMustCastToProperFunctionPointerType __stdcall glGetProcAddress(const char *procname);
-diff --git a/src/3rdparty/angle/src/libGLESv2/precompiled.h b/src/3rdparty/angle/src/libGLESv2/precompiled.h
-index 79490b1..2ff09f5 100644
---- a/src/3rdparty/angle/src/libGLESv2/precompiled.h
-+++ b/src/3rdparty/angle/src/libGLESv2/precompiled.h
-@@ -32,14 +32,55 @@
- #include <unordered_map>
- #include <vector>
- 
-+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
-+#  define ANGLE_OS_WINRT
-+#  if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-+#    define ANGLE_OS_WINPHONE
-+#  endif
-+#endif
-+
- #if defined(ANGLE_ENABLE_D3D9)
- #  include <d3d9.h>
- #endif
- #if defined(ANGLE_ENABLE_D3D11)
--#  include <d3d11.h>
-+#  if !defined(ANGLE_OS_WINRT)
-+#    include <d3d11.h>
-+#  else
-+#    include <d3d11_1.h>
-+#    define Sleep(x) WaitForSingleObjectEx(GetCurrentThread(), x, FALSE)
-+#    define GetVersion() WINVER
-+#    define LoadLibrary(x) LoadPackagedLibrary(x, NULL)
-+#  endif
- #  include <dxgi.h>
- #endif
--#include <d3dcompiler.h>
-+#if !defined(ANGLE_OS_WINPHONE)
-+#  include <d3dcompiler.h>
-+#endif
-+
-+#ifndef D3DCOMPILE_OPTIMIZATION_LEVEL0
-+#define D3DCOMPILE_OPTIMIZATION_LEVEL0 (1 << 14)
-+#endif
-+#ifndef D3DCOMPILE_OPTIMIZATION_LEVEL1
-+#define D3DCOMPILE_OPTIMIZATION_LEVEL1 0
-+#endif
-+#ifndef D3DCOMPILE_OPTIMIZATION_LEVEL2
-+#define D3DCOMPILE_OPTIMIZATION_LEVEL2 ((1 << 14) | (1 << 15))
-+#endif
-+#ifndef D3DCOMPILE_OPTIMIZATION_LEVEL3
-+#define D3DCOMPILE_OPTIMIZATION_LEVEL3 (1 << 15)
-+#endif
-+#ifndef D3DCOMPILE_DEBUG
-+#define D3DCOMPILE_DEBUG (1 << 0)
-+#endif
-+#ifndef D3DCOMPILE_SKIP_OPTIMIZATION
-+#define D3DCOMPILE_SKIP_OPTIMIZATION (1 << 2)
-+#endif
-+#ifndef D3DCOMPILE_AVOID_FLOW_CONTROL
-+#define D3DCOMPILE_AVOID_FLOW_CONTROL (1 << 9)
-+#endif
-+#ifndef D3DCOMPILE_PREFER_FLOW_CONTROL
-+#define D3DCOMPILE_PREFER_FLOW_CONTROL (1 << 10)
-+#endif
- 
- #ifdef _MSC_VER
- #include <hash_map>
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-index 94cbc0e..5278113 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp
-@@ -24,7 +24,7 @@
- #define D3DERR_OUTOFVIDEOMEMORY MAKE_HRESULT(1, 0x876, 380)
- #endif
- 
--#ifdef __MINGW32__
-+#if defined(__MINGW32__) || defined(ANGLE_OS_WINPHONE)
- 
- #ifndef D3DCOMPILER_DLL
- 
-@@ -41,7 +41,7 @@ typedef HRESULT (WINAPI *pD3DCompile)(const void *data, SIZE_T data_size, const
- 
- #endif // D3DCOMPILER_DLL
+@@ -14,6 +14,10 @@
+ #define EGLAPI
+ #include <EGL/egl.h>
  
--#endif // __MINGW32__
-+#endif // __MINGW32__ || ANGLE_OS_WINPHONE
- 
- #ifndef QT_D3DCOMPILER_DLL
- #define QT_D3DCOMPILER_DLL D3DCOMPILER_DLL
-@@ -224,17 +224,22 @@ ShaderBlob *Renderer::compileToBinary(gl::InfoLog &infoLog, const char *hlsl, co
- extern "C"
- {
- 
--rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayType displayId)
-+rx::Renderer *glCreateRenderer(egl::Display *display, EGLNativeDisplayType displayId)
- {
-     rx::Renderer *renderer = NULL;
-     EGLint status = EGL_BAD_ALLOC;
- 
-+#if defined(ANGLE_OS_WINRT)
-+    if (displayId == EGL_DEFAULT_DISPLAY)
-+        displayId = EGL_D3D11_ONLY_DISPLAY_ANGLE;
++#ifndef Sleep
++#define Sleep(ms) WaitForSingleObjectEx(GetCurrentThread(), ms, FALSE)
 +#endif
 +
- #if defined(ANGLE_ENABLE_D3D11)
-     if (displayId == EGL_DEFAULT_DISPLAY ||
-         displayId == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
-         displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
-     {
--        renderer = new rx::Renderer11(display, hDc);
-+        renderer = new rx::Renderer11(display);
- 
-         if (renderer)
-         {
-@@ -257,7 +262,7 @@ rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayT
- 
- #if defined(ANGLE_ENABLE_D3D9)
-     bool softwareDevice = (displayId == EGL_SOFTWARE_DISPLAY_ANGLE);
--    renderer = new rx::Renderer9(display, hDc, softwareDevice);
-+    renderer = new rx::Renderer9(display, displayId, softwareDevice);
- 
-     if (renderer)
-     {
+ namespace egl
+ {
+ class Display;
 diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h
-index 7244a0a..79578b2 100644
+index be3ba29..f1e0fd2 100644
 --- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h
 +++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h
-@@ -1,3 +1,4 @@
-+#include "../precompiled.h"
- //
- // 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
-@@ -113,7 +114,7 @@ class Renderer
+@@ -106,7 +106,7 @@ class Renderer
  
      virtual void sync(bool block) = 0;
  
 -    virtual SwapChain *createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) = 0;
 +    virtual SwapChain *createSwapChain(EGLNativeWindowType window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) = 0;
  
+     virtual void generateSwizzle(gl::Texture *texture) = 0;
      virtual void setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &sampler) = 0;
-     virtual void setTexture(gl::SamplerType type, int index, gl::Texture *texture) = 0;
 diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain.h b/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain.h
-index f09f19b..8231fbc 100644
+index f09f19b..77546f8 100644
 --- a/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain.h
 +++ b/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain.h
-@@ -1,3 +1,4 @@
-+#include "../precompiled.h"
- //
- // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
-@@ -22,7 +23,7 @@ namespace rx
+@@ -10,6 +10,7 @@
+ #ifndef LIBGLESV2_RENDERER_SWAPCHAIN_H_
+ #define LIBGLESV2_RENDERER_SWAPCHAIN_H_
+ 
++#include <EGL/eglplatform.h>
+ #include "common/angleutils.h"
+ 
+ #if !defined(ANGLE_FORCE_VSYNC_OFF)
+@@ -19,10 +20,18 @@
+ namespace rx
+ {
+ 
++enum SwapFlags
++{
++    SWAP_NORMAL = 0,
++    SWAP_ROTATE_90 = 1,
++    SWAP_ROTATE_270 = 2,
++    SWAP_ROTATE_180 = SWAP_ROTATE_90|SWAP_ROTATE_270,
++};
++
  class SwapChain
  {
    public:
@@ -905,45 +944,95 @@ index f09f19b..8231fbc 100644
          : mWindow(window), mShareHandle(shareHandle), mBackBufferFormat(backBufferFormat), mDepthBufferFormat(depthBufferFormat)
      {
      }
-@@ -37,7 +38,7 @@ class SwapChain
+@@ -31,13 +40,13 @@ class SwapChain
+ 
+     virtual EGLint resize(EGLint backbufferWidth, EGLint backbufferSize) = 0;
+     virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval) = 0;
+-    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height) = 0;
++    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height, EGLint flags) = 0;
+     virtual void recreate() = 0;
+ 
      virtual HANDLE getShareHandle() {return mShareHandle;};
  
    protected:
 -    const HWND mWindow;            // Window that the surface is created for.
-+    const EGLNativeWindowType mWindow;  // Window that the surface is created for.
++    const EGLNativeWindowType mWindow;            // Window that the surface is created for.
      const GLenum mBackBufferFormat;
      const GLenum mDepthBufferFormat;
  
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-index d9fcb7a..7f166fd 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-@@ -66,7 +66,7 @@ enum
-     MAX_TEXTURE_IMAGE_UNITS_VTF_SM4 = 16
- };
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+index 31942e6..e3b88d5 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/HLSLCompiler.cpp
+@@ -4,6 +4,7 @@
+ #include "libGLESv2/main.h"
+ 
+ #include "common/utilities.h"
++#include "common/platform.h"
  
--Renderer11::Renderer11(egl::Display *display, HDC hDc) : Renderer(display), mDc(hDc)
-+Renderer11::Renderer11(egl::Display *display) : Renderer(display)
+ #include "third_party/trace_event/trace_event.h"
+ 
+@@ -49,6 +50,7 @@ HLSLCompiler::~HLSLCompiler()
+ bool HLSLCompiler::initialize()
  {
-     mVertexDataManager = NULL;
-     mIndexDataManager = NULL;
-@@ -137,6 +137,7 @@ EGLint Renderer11::initialize()
-         return EGL_NOT_INITIALIZED;
+     TRACE_EVENT0("gpu", "initializeCompiler");
++#if !defined(ANGLE_PLATFORM_WINRT)
+ #if defined(ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES)
+     // Find a D3DCompiler module that had already been loaded based on a predefined list of versions.
+     static const char *d3dCompilerNames[] = ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES;
+@@ -80,8 +82,8 @@ bool HLSLCompiler::initialize()
+     // Load the first available known compiler DLL
+     for (int i = 0; compilerDlls[i]; ++i)
+     {
+-        mD3dCompilerModule = LoadLibrary(compilerDlls[i]);
+-        if (mD3dCompilerModule)
++        mD3DCompilerModule = LoadLibrary(compilerDlls[i]);
++        if (mD3DCompilerModule)
+             break;
      }
  
-+#if !defined(ANGLE_OS_WINRT)
-     mDxgiModule = LoadLibrary(TEXT("dxgi.dll"));
-     mD3d11Module = LoadLibrary(TEXT("d3d11.dll"));
+@@ -93,7 +95,9 @@ bool HLSLCompiler::initialize()
  
-@@ -146,6 +147,7 @@ EGLint Renderer11::initialize()
+     mD3DCompileFunc = reinterpret_cast<CompileFuncPtr>(GetProcAddress(mD3DCompilerModule, "D3DCompile"));
+     ASSERT(mD3DCompileFunc);
+-
++#else
++    mD3DCompileFunc = reinterpret_cast<CompileFuncPtr>(&D3DCompile);
++#endif
+     return mD3DCompileFunc != NULL;
+ }
+ 
+@@ -110,7 +114,9 @@ void HLSLCompiler::release()
+ ShaderBlob *HLSLCompiler::compileToBinary(gl::InfoLog &infoLog, const char *hlsl, const char *profile,
+                                           const UINT optimizationFlags[], const char *flagNames[], int attempts) const
+ {
++#if !defined(ANGLE_PLATFORM_WINRT)
+     ASSERT(mD3DCompilerModule && mD3DCompileFunc);
++#endif
+ 
+     if (!hlsl)
+     {
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+index a48a2cd..36d9a8f 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+@@ -9,6 +9,7 @@
+ 
+ #include "libGLESv2/main.h"
+ #include "common/utilities.h"
++#include "common/platform.h"
+ #include "libGLESv2/Buffer.h"
+ #include "libGLESv2/FramebufferAttachment.h"
+ #include "libGLESv2/ProgramBinary.h"
+@@ -129,6 +130,7 @@ EGLint Renderer11::initialize()
          return EGL_NOT_INITIALIZED;
      }
  
-+
-     // create the D3D11 device
-     ASSERT(mDevice == NULL);
-     PFN_D3D11_CREATE_DEVICE D3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE)GetProcAddress(mD3d11Module, "D3D11CreateDevice");
-@@ -155,6 +157,7 @@ EGLint Renderer11::initialize()
++#if !defined(ANGLE_PLATFORM_WINRT)
+     mDxgiModule = LoadLibrary(TEXT("dxgi.dll"));
+     mD3d11Module = LoadLibrary(TEXT("d3d11.dll"));
+ 
+@@ -147,6 +149,7 @@ EGLint Renderer11::initialize()
          ERR("Could not retrieve D3D11CreateDevice address - aborting!\n");
          return EGL_NOT_INITIALIZED;
      }
@@ -951,11 +1040,20 @@ index d9fcb7a..7f166fd 100644
  
      D3D_FEATURE_LEVEL featureLevels[] =
      {
-@@ -203,8 +206,12 @@ EGLint Renderer11::initialize()
+@@ -201,7 +204,7 @@ EGLint Renderer11::initialize()
          }
      }
  
-+#if !defined(ANGLE_OS_WINRT)
+-#if !ANGLE_SKIP_DXGI_1_2_CHECK
++#if !ANGLE_SKIP_DXGI_1_2_CHECK && !defined(ANGLE_PLATFORM_WINRT)
+     // In order to create a swap chain for an HWND owned by another process, DXGI 1.2 is required.
+     // The easiest way to check is to query for a IDXGIDevice2.
+     bool requireDXGI1_2 = false;
+@@ -231,8 +234,12 @@ EGLint Renderer11::initialize()
+     }
+ #endif
+ 
++#if !defined(ANGLE_PLATFORM_WINRT)
      IDXGIDevice *dxgiDevice = NULL;
 -    result = mDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);
 +#else
@@ -965,7 +1063,7 @@ index d9fcb7a..7f166fd 100644
  
      if (FAILED(result))
      {
-@@ -522,7 +529,7 @@ void Renderer11::sync(bool block)
+@@ -413,7 +420,7 @@ void Renderer11::sync(bool block)
      }
  }
  
@@ -974,41 +1072,41 @@ index d9fcb7a..7f166fd 100644
  {
      return new rx::SwapChain11(this, window, shareHandle, backBufferFormat, depthBufferFormat);
  }
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-index 1b6760b..ba3f0c6 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-@@ -39,7 +39,7 @@ enum
- class Renderer11 : public Renderer
- {
-   public:
--    Renderer11(egl::Display *display, HDC hDc);
-+    Renderer11(egl::Display *display);
-     virtual ~Renderer11();
- 
-     static Renderer11 *makeRenderer11(Renderer *renderer);
-@@ -52,7 +52,7 @@ class Renderer11 : public Renderer
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
+index 73a3fc2..618972d 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
+@@ -57,7 +57,7 @@ class Renderer11 : public Renderer
  
      virtual void sync(bool block);
  
 -    virtual SwapChain *createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat);
 +    virtual SwapChain *createSwapChain(EGLNativeWindowType window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat);
  
+     virtual void generateSwizzle(gl::Texture *texture);
      virtual void setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &sampler);
-     virtual void setTexture(gl::SamplerType type, int index, gl::Texture *texture);
-@@ -203,7 +203,6 @@ class Renderer11 : public Renderer
+@@ -238,7 +238,7 @@ class Renderer11 : public Renderer
  
      HMODULE mD3d11Module;
      HMODULE mDxgiModule;
 -    HDC mDc;
- 
-     bool mDeviceLost;
- 
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.cpp
-index d2b53a7..bd97d5c 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.cpp
-@@ -18,7 +18,7 @@
++    EGLNativeDisplayType mDc;
+     EGLint mRequestedDisplay;
+ 
+     HLSLCompiler mCompiler;
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp
+index 98166f0..0341df1 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.cpp
+@@ -9,6 +9,7 @@
+ 
+ #include "libGLESv2/renderer/d3d/d3d11/SwapChain11.h"
+ 
++#include "common/platform.h"
+ #include "libGLESv2/renderer/d3d/d3d11/renderer11_utils.h"
+ #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h"
+ #include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
+@@ -18,7 +19,7 @@
  namespace rx
  {
  
@@ -1017,83 +1115,172 @@ index d2b53a7..bd97d5c 100644
                           GLenum backBufferFormat, GLenum depthBufferFormat)
      : mRenderer(renderer), SwapChain(window, shareHandle, backBufferFormat, depthBufferFormat)
  {
-@@ -361,25 +361,50 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
+@@ -38,6 +39,8 @@ SwapChain11::SwapChain11(Renderer11 *renderer, HWND window, HANDLE shareHandle,
+     mPassThroughPS = NULL;
+     mWidth = -1;
+     mHeight = -1;
++    mViewportWidth = -1;
++    mViewportHeight = -1;
+     mSwapInterval = 0;
+     mAppCreatedShareHandle = mShareHandle != NULL;
+     mPassThroughResourcesInit = false;
+@@ -91,6 +94,7 @@ EGLint SwapChain11::resetOffscreenTexture(int backbufferWidth, int backbufferHei
+     ASSERT(backbufferWidth >= 1);
+     ASSERT(backbufferHeight >= 1);
+ 
++#if !defined(ANGLE_PLATFORM_WINRT)
+     // Preserve the render target content
+     ID3D11Texture2D *previousOffscreenTexture = mOffscreenTexture;
+     if (previousOffscreenTexture)
+@@ -99,6 +103,7 @@ EGLint SwapChain11::resetOffscreenTexture(int backbufferWidth, int backbufferHei
+     }
+     const int previousWidth = mWidth;
+     const int previousHeight = mHeight;
++#endif
+ 
+     releaseOffscreenTexture();
+ 
+@@ -277,7 +282,12 @@ EGLint SwapChain11::resetOffscreenTexture(int backbufferWidth, int backbufferHei
+ 
+     mWidth = backbufferWidth;
+     mHeight = backbufferHeight;
++#if !defined(ANGLE_PLATFORM_WINRT) || WINAPI_FAMILY==WINAPI_FAMILY_PC_APP
++    mViewportWidth = backbufferWidth;
++    mViewportHeight = backbufferHeight;
++#endif
+ 
++#if !defined(ANGLE_PLATFORM_WINRT)
+     if (previousOffscreenTexture != NULL)
+     {
+         D3D11_BOX sourceBox = {0};
+@@ -296,9 +306,10 @@ EGLint SwapChain11::resetOffscreenTexture(int backbufferWidth, int backbufferHei
  
+         if (mSwapChain)
+         {
+-            swapRect(0, 0, mWidth, mHeight);
++            swapRect(0, 0, mWidth, mHeight, SWAP_NORMAL);
+         }
+     }
++#endif
+ 
+     return EGL_SUCCESS;
+ }
+@@ -325,8 +336,15 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
+     SafeRelease(mBackBufferRTView);
+ 
+     // Resize swap chain
++    HRESULT result;
++#if !defined(ANGLE_PLATFORM_WINRT) || WINAPI_FAMILY==WINAPI_FAMILY_PC_APP // Windows phone swap chain is never resized, only the texture is
++#if !defined(ANGLE_PLATFORM_WINRT)
++    const int bufferCount = 1;
++#else
++    const int bufferCount = 2;
++#endif
+     DXGI_FORMAT backbufferDXGIFormat = gl_d3d11::GetTexFormat(mBackBufferFormat);
+-    HRESULT result = mSwapChain->ResizeBuffers(1, backbufferWidth, backbufferHeight, backbufferDXGIFormat, 0);
++    result = mSwapChain->ResizeBuffers(bufferCount, backbufferWidth, backbufferHeight, backbufferDXGIFormat, 0);
+ 
+     if (FAILED(result))
+     {
+@@ -342,7 +360,7 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
+             return EGL_BAD_ALLOC;
+         }
+     }
+-
++#endif
+     result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
+     ASSERT(SUCCEEDED(result));
+     if (SUCCEEDED(result))
+@@ -392,7 +410,7 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
      if (mWindow)
      {
-+#if !defined(ANGLE_OS_WINRT)
          IDXGIFactory *factory = mRenderer->getDxgiFactory();
- 
+-
++#if !defined(ANGLE_PLATFORM_WINRT)
          DXGI_SWAP_CHAIN_DESC swapChainDesc = {0};
--        swapChainDesc.BufferCount = 2;
-         swapChainDesc.BufferDesc.Format = gl_d3d11::ConvertRenderbufferFormat(mBackBufferFormat);
          swapChainDesc.BufferDesc.Width = backbufferWidth;
          swapChainDesc.BufferDesc.Height = backbufferHeight;
-+        swapChainDesc.BufferCount = 2;
-         swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
-         swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
-         swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
-         swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
-+        swapChainDesc.Windowed = TRUE;
-+        swapChainDesc.OutputWindow = mWindow;
+@@ -411,6 +429,37 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
+         swapChainDesc.Flags = 0;
+ 
+         HRESULT result = factory->CreateSwapChain(device, &swapChainDesc, &mSwapChain);
 +#else
-+        IDXGIFactory2 *factory;
-+        HRESULT result = mRenderer->getDxgiFactory()->QueryInterface(IID_PPV_ARGS(&factory));
++        IDXGIFactory2 *factory2;
++        HRESULT result = factory->QueryInterface(IID_PPV_ARGS(&factory2));
 +        ASSERT(SUCCEEDED(result));
 +
 +        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
-+        swapChainDesc.Format = gl_d3d11::ConvertRenderbufferFormat(mBackBufferFormat);
-+        swapChainDesc.Width = backbufferWidth;
-+        swapChainDesc.Height = backbufferHeight;
++        swapChainDesc.Width = 0;
++        swapChainDesc.Height = 0;
++        swapChainDesc.Format = gl_d3d11::GetTexFormat(mBackBufferFormat);
++        swapChainDesc.SampleDesc.Count = 1;
++        swapChainDesc.SampleDesc.Quality = 0;
++        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
 +        swapChainDesc.Stereo = FALSE;
-+#if !defined(ANGLE_OS_WINPHONE)
++        swapChainDesc.Flags = 0;
++#if WINAPI_FAMILY==WINAPI_FAMILY_PC_APP
++        swapChainDesc.Scaling = DXGI_SCALING_NONE;
 +        swapChainDesc.BufferCount = 2;
 +        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
-+#else
++#elif WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
 +        swapChainDesc.BufferCount = 1;
 +        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
 +#endif
-+#endif
-         swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
-         swapChainDesc.Flags = 0;
--        swapChainDesc.OutputWindow = mWindow;
-         swapChainDesc.SampleDesc.Count = 1;
-         swapChainDesc.SampleDesc.Quality = 0;
--        swapChainDesc.Windowed = TRUE;
- 
-+#if !defined(ANGLE_OS_WINRT)
-         HRESULT result = factory->CreateSwapChain(device, &swapChainDesc, &mSwapChain);
-+#else
++
 +        IDXGISwapChain1 *swapChain;
-+        result = factory->CreateSwapChainForCoreWindow(device, mWindow, &swapChainDesc, NULL, &swapChain);
++        result = factory2->CreateSwapChainForCoreWindow(device, mWindow, &swapChainDesc, NULL, &swapChain);
 +        mSwapChain = swapChain;
++        HRESULT hr = swapChain->GetDesc1(&swapChainDesc);
++        ASSERT(SUCCEEDED(hr));
++        mViewportWidth = swapChainDesc.Width;
++        mViewportHeight = swapChainDesc.Height;
 +#endif
  
          if (FAILED(result))
          {
-@@ -390,6 +415,7 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
-             {
-                 return EGL_CONTEXT_LOST;
-             }
-+#if !defined(ANGLE_OS_WINRT)
-             else
-             {
-                 // We cannot create a swap chain for an HWND that is owned by a different process on some versions of
-@@ -408,6 +434,9 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
-                     return EGL_BAD_ALLOC;
-                 }
-             }
-+#else
-+            return EGL_BAD_ALLOC;
-+#endif
-         }
+@@ -507,7 +556,7 @@ void SwapChain11::initPassThroughResources()
+ }
  
-         result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.h
-index 8001046..2a030c8 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.h
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/SwapChain11.h
-@@ -19,7 +19,7 @@ class Renderer11;
+ // parameters should be validated/clamped by caller
+-EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
++EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height, EGLint flags)
+ {
+     if (!mSwapChain)
+     {
+@@ -538,10 +587,13 @@ EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+     float u2 = (x + width) / float(mWidth);
+     float v2 = (y + height) / float(mHeight);
+ 
+-    d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, u1, v1);
+-    d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, u1, v2);
+-    d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1);
+-    d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2);
++    const int rotateL = flags & SWAP_ROTATE_90;
++    const int rotateR = flags & SWAP_ROTATE_270;
++
++    d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, rotateL ? u2 : u1, rotateR ? v2 : v1);
++    d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, rotateR ? u2 : u1, rotateL ? v1 : v2);
++    d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, rotateR ? u1 : u2, rotateL ? v2 : v1);
++    d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, rotateL ? u1 : u2, rotateR ? v1 : v2);
+ 
+     deviceContext->Unmap(mQuadVB, 0);
+ 
+@@ -571,8 +623,8 @@ EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+     D3D11_VIEWPORT viewport;
+     viewport.TopLeftX = 0;
+     viewport.TopLeftY = 0;
+-    viewport.Width = mWidth;
+-    viewport.Height = mHeight;
++    viewport.Width = mViewportWidth;
++    viewport.Height = mViewportHeight;
+     viewport.MinDepth = 0.0f;
+     viewport.MaxDepth = 1.0f;
+     deviceContext->RSSetViewports(1, &viewport);
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.h
+index fb0afd7..b30b785 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/SwapChain11.h
+@@ -19,13 +19,13 @@ class Renderer11;
  class SwapChain11 : public SwapChain
  {
    public:
@@ -1102,109 +1289,48 @@ index 8001046..2a030c8 100644
                  GLenum backBufferFormat, GLenum depthBufferFormat);
      virtual ~SwapChain11();
  
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/shaders/Clear11.hlsl b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/shaders/Clear11.hlsl
-index 042ac69..cb132dc 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/shaders/Clear11.hlsl
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/shaders/Clear11.hlsl
-@@ -12,10 +12,12 @@ struct PS_OutputMultiple
- 	float4 color1 : SV_TARGET1;
- 	float4 color2 : SV_TARGET2;
- 	float4 color3 : SV_TARGET3;
-+#ifdef SM4
- 	float4 color4 : SV_TARGET4;
- 	float4 color5 : SV_TARGET5;
- 	float4 color6 : SV_TARGET6;
- 	float4 color7 : SV_TARGET7;
-+#endif
- };
- 
- PS_OutputMultiple PS_ClearMultiple(in float4 inPosition : SV_POSITION, in float4 inColor : COLOR)
-@@ -25,10 +27,12 @@ PS_OutputMultiple PS_ClearMultiple(in float4 inPosition : SV_POSITION, in float4
- 	outColor.color1 = inColor;
- 	outColor.color2 = inColor;
- 	outColor.color3 = inColor;
-+#ifdef SM4
- 	outColor.color4 = inColor;
- 	outColor.color5 = inColor;
- 	outColor.color6 = inColor;
- 	outColor.color7 = inColor;
-+#endif
- 	return outColor;
+     EGLint resize(EGLint backbufferWidth, EGLint backbufferHeight);
+     virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval);
+-    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
++    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height, EGLint flags);
+     virtual void recreate();
+ 
+     virtual ID3D11Texture2D *getOffscreenTexture();
+@@ -52,6 +52,8 @@ class SwapChain11 : public SwapChain
+     Renderer11 *mRenderer;
+     EGLint mHeight;
+     EGLint mWidth;
++    EGLint mViewportWidth;
++    EGLint mViewportHeight;
+     bool mAppCreatedShareHandle;
+     unsigned int mSwapInterval;
+     bool mPassThroughResourcesInit;
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp
+index 4a17acf..c6567b6 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.cpp
+@@ -236,7 +236,7 @@ EGLint SwapChain9::reset(int backbufferWidth, int backbufferHeight, EGLint swapI
  }
  
-diff --git a/src/3rdparty/angle/src/libGLESv2/utilities.cpp b/src/3rdparty/angle/src/libGLESv2/utilities.cpp
-index 32df49e..30765ff 100644
---- a/src/3rdparty/angle/src/libGLESv2/utilities.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/utilities.cpp
-@@ -9,6 +9,14 @@
- 
- #include "libGLESv2/utilities.h"
- #include "libGLESv2/mathutil.h"
-+#if defined(ANGLE_OS_WINRT)
-+#  include <locale>
-+#  include <codecvt>
-+#  include <wrl.h>
-+#  include <windows.storage.h>
-+   using namespace Microsoft::WRL;
-+   using namespace ABI::Windows::Storage;
-+#endif
- 
- namespace gl
+ // parameters should be validated/clamped by caller
+-EGLint SwapChain9::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
++EGLint SwapChain9::swapRect(EGLint x, EGLint y, EGLint width, EGLint height, EGLint)
  {
-@@ -737,6 +745,7 @@ bool IsTriangleMode(GLenum drawMode)
- 
- std::string getTempPath()
- {
-+#if !defined(ANGLE_OS_WINRT)
-     char path[MAX_PATH];
-     DWORD pathLen = GetTempPathA(sizeof(path) / sizeof(path[0]), path);
-     if (pathLen == 0)
-@@ -751,6 +760,45 @@ std::string getTempPath()
-         UNREACHABLE();
-         return std::string();
-     }
-+#else
-+    static std::string path;
-+
-+    while (path.empty()) {
-+        ComPtr<IApplicationDataStatics> factory;
-+        Wrappers::HStringReference classId(RuntimeClass_Windows_Storage_ApplicationData);
-+        HRESULT result = RoGetActivationFactory(classId.Get(), IID_PPV_ARGS(&factory));
-+        if (FAILED(result))
-+            break;
-+
-+        ComPtr<IApplicationData> applicationData;
-+        result = factory->get_Current(&applicationData);
-+        if (FAILED(result))
-+            break;
-+
-+        ComPtr<IStorageFolder> storageFolder;
-+        result = applicationData->get_LocalFolder(&storageFolder);
-+        if (FAILED(result))
-+            break;
-+
-+        ComPtr<IStorageItem> localFolder;
-+        result = storageFolder.As(&localFolder);
-+        if (FAILED(result))
-+            break;
-+
-+        HSTRING localFolderPath;
-+        result = localFolder->get_Path(&localFolderPath);
-+        if (FAILED(result))
-+            break;
-+
-+        std::wstring_convert< std::codecvt_utf8<wchar_t> > converter;
-+        path = converter.to_bytes(WindowsGetStringRawBuffer(localFolderPath, NULL));
-+        if (path.empty())
-+        {
-+            UNREACHABLE();
-+            break;
-+        }
-+    }
-+#endif
-     
-     return path;
- }
+     if (!mSwapChain)
+     {
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.h
+index 16a62bd..4d756f8 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d9/SwapChain9.h
+@@ -25,7 +25,7 @@ class SwapChain9 : public SwapChain
+ 
+     EGLint resize(EGLint backbufferWidth, EGLint backbufferHeight);
+     virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval);
+-    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
++    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height, EGLint);
+     virtual void recreate();
+ 
+     virtual IDirect3DSurface9 *getRenderTarget();
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch b/src/angle/patches/0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch
index 34c881ba21..b17f07c00b 100644
--- a/src/angle/patches/0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch
+++ b/src/angle/patches/0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch
@@ -1,75 +1,224 @@
-From e84f947df4ae095eae600550749b3a4e8de5ee8b Mon Sep 17 00:00:00 2001
+From cda47c3e09db62c0af7d94537ec51aca5a728db9 Mon Sep 17 00:00:00 2001
 From: Andrew Knight <andrew.knight@digia.com>
-Date: Thu, 20 Feb 2014 16:51:36 +0200
-Subject: [PATCH] ANGLE: Enable D3D11 for feature level 9 cards
+Date: Mon, 4 Aug 2014 23:51:59 +0300
+Subject: [PATCH 10/12] ANGLE: Enable D3D11 for feature level 9 cards
 
 Enable use of ANGLE on lower-end hardware, such as Surface RT and
 Windows Phone 8.
 
-Based on https://codereview.appspot.com/12917046/
-
 Change-Id: Ice536802e4eedc1d264abd0dd65960638fce59e4
 ---
- .../angle/src/libGLESv2/renderer/d3d11/Image11.cpp |  7 +-
- .../libGLESv2/renderer/d3d11/RenderStateCache.cpp  |  5 +-
- .../src/libGLESv2/renderer/d3d11/Renderer11.cpp    | 90 ++++++++++++++++++++--
- .../src/libGLESv2/renderer/d3d11/Renderer11.h      |  1 +
- .../libGLESv2/renderer/d3d11/TextureStorage11.cpp  | 10 +--
- .../libGLESv2/renderer/d3d11/renderer11_utils.cpp  |  4 +-
- .../libGLESv2/renderer/d3d11/renderer11_utils.h    |  2 +-
- 7 files changed, 100 insertions(+), 19 deletions(-)
+ src/3rdparty/angle/src/libGLESv2/angletypes.cpp    |   4 +-
+ .../src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp    |  65 +++---
+ .../src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp  |   4 +-
+ .../src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp   |   8 +-
+ .../renderer/d3d/d3d11/PixelTransfer11.cpp         |   7 +-
+ .../libGLESv2/renderer/d3d/d3d11/Renderer11.cpp    | 246 ++++++++++++++-------
+ .../src/libGLESv2/renderer/d3d/d3d11/Renderer11.h  |   1 +
+ .../renderer/d3d/d3d11/TextureStorage11.cpp        |   2 +-
+ .../libGLESv2/renderer/d3d/d3d11/formatutils11.cpp |   4 +-
+ 9 files changed, 219 insertions(+), 122 deletions(-)
 
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Image11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Image11.cpp
-index 2b07b9d..5d039a3 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Image11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Image11.cpp
-@@ -142,7 +142,7 @@ bool Image11::redefine(Renderer *renderer, GLint internalformat, GLsizei width,
-         mHeight = height;
-         mInternalFormat = internalformat;
-         // compute the d3d format that will be used
--        mDXGIFormat = gl_d3d11::ConvertTextureFormat(internalformat);
-+        mDXGIFormat = gl_d3d11::ConvertTextureFormat(internalformat, mRenderer->getFeatureLevel());
-         mActualFormat = d3d11_gl::ConvertTextureInternalFormat(mDXGIFormat);
- 
-         if (mStagingTexture)
-@@ -191,7 +191,10 @@ void Image11::loadData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei heig
-     switch (mInternalFormat)
+diff --git a/src/3rdparty/angle/src/libGLESv2/angletypes.cpp b/src/3rdparty/angle/src/libGLESv2/angletypes.cpp
+index ec5521e..bc929c7 100644
+--- a/src/3rdparty/angle/src/libGLESv2/angletypes.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/angletypes.cpp
+@@ -23,8 +23,8 @@ SamplerState::SamplerState()
+       maxAnisotropy(1.0f),
+       baseLevel(0),
+       maxLevel(1000),
+-      minLod(-1000.0f),
+-      maxLod(1000.0f),
++      minLod(-FLT_MAX),
++      maxLod(FLT_MAX),
+       compareMode(GL_NONE),
+       compareFunc(GL_LEQUAL),
+       swizzleRed(GL_RED),
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp
+index 79a6543..9b0f336 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Blit11.cpp
+@@ -210,7 +210,7 @@ Blit11::Blit11(rx::Renderer11 *renderer)
+     pointSamplerDesc.BorderColor[2] = 0.0f;
+     pointSamplerDesc.BorderColor[3] = 0.0f;
+     pointSamplerDesc.MinLOD = 0.0f;
+-    pointSamplerDesc.MaxLOD = 0.0f;
++    pointSamplerDesc.MaxLOD = mRenderer->isLevel9() ? FLT_MAX : 0.0f;
+ 
+     result = device->CreateSamplerState(&pointSamplerDesc, &mPointSampler);
+     ASSERT(SUCCEEDED(result));
+@@ -229,7 +229,7 @@ Blit11::Blit11(rx::Renderer11 *renderer)
+     linearSamplerDesc.BorderColor[2] = 0.0f;
+     linearSamplerDesc.BorderColor[3] = 0.0f;
+     linearSamplerDesc.MinLOD = 0.0f;
+-    linearSamplerDesc.MaxLOD = 0.0f;
++    linearSamplerDesc.MaxLOD = mRenderer->isLevel9() ? FLT_MAX : 0.0f;
+ 
+     result = device->CreateSamplerState(&linearSamplerDesc, &mLinearSampler);
+     ASSERT(SUCCEEDED(result));
+@@ -291,28 +291,32 @@ Blit11::Blit11(rx::Renderer11 *renderer)
+     ASSERT(SUCCEEDED(result));
+     d3d11::SetDebugName(mQuad2DVS, "Blit11 2D vertex shader");
+ 
+-    result = device->CreatePixelShader(g_PS_PassthroughDepth2D, ArraySize(g_PS_PassthroughDepth2D), NULL, &mDepthPS);
+-    ASSERT(SUCCEEDED(result));
+-    d3d11::SetDebugName(mDepthPS, "Blit11 2D depth pixel shader");
+-
+-    D3D11_INPUT_ELEMENT_DESC quad3DLayout[] =
++    if (!renderer->isLevel9())
      {
-       case GL_ALPHA8_EXT:
--        loadAlphaDataToNative(width, height, inputPitch, input, mappedImage.RowPitch, offsetMappedData);
-+        if (mRenderer->getFeatureLevel() >= D3D_FEATURE_LEVEL_10_0)
-+            loadAlphaDataToNative(width, height, inputPitch, input, mappedImage.RowPitch, offsetMappedData);
-+        else
-+            loadAlphaDataToBGRA(width, height, inputPitch, input, mappedImage.RowPitch, offsetMappedData);
+-        { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,    0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+-        { "LAYER",    0, DXGI_FORMAT_R32_UINT,        0,  8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+-        { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+-    };
++        result = device->CreatePixelShader(g_PS_PassthroughDepth2D, ArraySize(g_PS_PassthroughDepth2D), NULL, &mDepthPS);
++        ASSERT(SUCCEEDED(result));
++        d3d11::SetDebugName(mDepthPS, "Blit11 2D depth pixel shader");
+ 
+-    result = device->CreateInputLayout(quad3DLayout, ArraySize(quad3DLayout), g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), &mQuad3DIL);
+-    ASSERT(SUCCEEDED(result));
+-    d3d11::SetDebugName(mQuad3DIL, "Blit11 3D input layout");
++        D3D11_INPUT_ELEMENT_DESC quad3DLayout[] =
++        {
++            { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,    0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
++            { "LAYER",    0, DXGI_FORMAT_R32_UINT,        0,  8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
++            { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
++        };
+ 
+-    result = device->CreateVertexShader(g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), NULL, &mQuad3DVS);
+-    ASSERT(SUCCEEDED(result));
+-    d3d11::SetDebugName(mQuad3DVS, "Blit11 3D vertex shader");
++        result = device->CreateInputLayout(quad3DLayout, ArraySize(quad3DLayout), g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), &mQuad3DIL);
++        ASSERT(SUCCEEDED(result));
++        d3d11::SetDebugName(mQuad3DIL, "Blit11 3D input layout");
+ 
+-    result = device->CreateGeometryShader(g_GS_Passthrough3D, ArraySize(g_GS_Passthrough3D), NULL, &mQuad3DGS);
+-    ASSERT(SUCCEEDED(result));
+-    d3d11::SetDebugName(mQuad3DGS, "Renderer11 copy 3D texture geometry shader");
++        result = device->CreateVertexShader(g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), NULL, &mQuad3DVS);
++        ASSERT(SUCCEEDED(result));
++        d3d11::SetDebugName(mQuad3DVS, "Blit11 3D vertex shader");
++
++        result = device->CreateGeometryShader(g_GS_Passthrough3D, ArraySize(g_GS_Passthrough3D), NULL, &mQuad3DGS);
++        ASSERT(SUCCEEDED(result));
++        d3d11::SetDebugName(mQuad3DGS, "Renderer11 copy 3D texture geometry shader");
++
++    }
+ 
+     buildShaderMap();
+ 
+@@ -970,21 +974,27 @@ void Blit11::buildShaderMap()
+     ID3D11Device *device = mRenderer->getDevice();
+ 
+     add2DBlitShaderToMap(GL_RGBA,            false, d3d11::CompilePS(device, g_PS_PassthroughRGBA2D,     "Blit11 2D RGBA pixel shader"           ));
+-    add2DBlitShaderToMap(GL_RGBA_INTEGER,    false, d3d11::CompilePS(device, g_PS_PassthroughRGBA2DUI,   "Blit11 2D RGBA UI pixel shader"        ));
+-    add2DBlitShaderToMap(GL_RGBA_INTEGER,    true,  d3d11::CompilePS(device, g_PS_PassthroughRGBA2DI,    "Blit11 2D RGBA I pixel shader"         ));
+     add2DBlitShaderToMap(GL_BGRA_EXT,        false, d3d11::CompilePS(device, g_PS_PassthroughRGBA2D,     "Blit11 2D BGRA pixel shader"           ));
+     add2DBlitShaderToMap(GL_RGB,             false, d3d11::CompilePS(device, g_PS_PassthroughRGB2D,      "Blit11 2D RGB pixel shader"            ));
++    add2DBlitShaderToMap(GL_RG,              false, d3d11::CompilePS(device, g_PS_PassthroughRG2D,       "Blit11 2D RG pixel shader"             ));
++    add2DBlitShaderToMap(GL_RED,             false, d3d11::CompilePS(device, g_PS_PassthroughR2D,        "Blit11 2D R pixel shader"              ));
++    add2DBlitShaderToMap(GL_ALPHA,           false, d3d11::CompilePS(device, g_PS_PassthroughRGBA2D,     "Blit11 2D alpha pixel shader"          ));
++    add2DBlitShaderToMap(GL_LUMINANCE,       false, d3d11::CompilePS(device, g_PS_PassthroughLum2D,      "Blit11 2D lum pixel shader"            ));
++    add2DBlitShaderToMap(GL_LUMINANCE_ALPHA, false, d3d11::CompilePS(device, g_PS_PassthroughLumAlpha2D, "Blit11 2D luminance alpha pixel shader"));
++
++    addSwizzleShaderToMap(GL_FLOAT,        D3D_SRV_DIMENSION_TEXTURE2D,      d3d11::CompilePS(device, g_PS_SwizzleF2D,       "Blit11 2D F swizzle pixel shader" ));
++
++    if (mRenderer->isLevel9())
++        return;
++
++    add2DBlitShaderToMap(GL_RGBA_INTEGER,    false, d3d11::CompilePS(device, g_PS_PassthroughRGBA2DUI,   "Blit11 2D RGBA UI pixel shader"        ));
++    add2DBlitShaderToMap(GL_RGBA_INTEGER,    true,  d3d11::CompilePS(device, g_PS_PassthroughRGBA2DI,    "Blit11 2D RGBA I pixel shader"         ));
+     add2DBlitShaderToMap(GL_RGB_INTEGER,     false, d3d11::CompilePS(device, g_PS_PassthroughRGB2DUI,    "Blit11 2D RGB UI pixel shader"         ));
+     add2DBlitShaderToMap(GL_RGB_INTEGER,     true,  d3d11::CompilePS(device, g_PS_PassthroughRGB2DI,     "Blit11 2D RGB I pixel shader"          ));
+-    add2DBlitShaderToMap(GL_RG,              false, d3d11::CompilePS(device, g_PS_PassthroughRG2D,       "Blit11 2D RG pixel shader"             ));
+     add2DBlitShaderToMap(GL_RG_INTEGER,      false, d3d11::CompilePS(device, g_PS_PassthroughRG2DUI,     "Blit11 2D RG UI pixel shader"          ));
+     add2DBlitShaderToMap(GL_RG_INTEGER,      true,  d3d11::CompilePS(device, g_PS_PassthroughRG2DI,      "Blit11 2D RG I pixel shader"           ));
+-    add2DBlitShaderToMap(GL_RED,             false, d3d11::CompilePS(device, g_PS_PassthroughR2D,        "Blit11 2D R pixel shader"              ));
+     add2DBlitShaderToMap(GL_RED_INTEGER,     false, d3d11::CompilePS(device, g_PS_PassthroughR2DUI,      "Blit11 2D R UI pixel shader"           ));
+     add2DBlitShaderToMap(GL_RED_INTEGER,     true,  d3d11::CompilePS(device, g_PS_PassthroughR2DI,       "Blit11 2D R I pixel shader"            ));
+-    add2DBlitShaderToMap(GL_ALPHA,           false, d3d11::CompilePS(device, g_PS_PassthroughRGBA2D,     "Blit11 2D alpha pixel shader"          ));
+-    add2DBlitShaderToMap(GL_LUMINANCE,       false, d3d11::CompilePS(device, g_PS_PassthroughLum2D,      "Blit11 2D lum pixel shader"            ));
+-    add2DBlitShaderToMap(GL_LUMINANCE_ALPHA, false, d3d11::CompilePS(device, g_PS_PassthroughLumAlpha2D, "Blit11 2D luminance alpha pixel shader"));
+ 
+     add3DBlitShaderToMap(GL_RGBA,            false, d3d11::CompilePS(device, g_PS_PassthroughRGBA3D,     "Blit11 3D RGBA pixel shader"           ));
+     add3DBlitShaderToMap(GL_RGBA_INTEGER,    false, d3d11::CompilePS(device, g_PS_PassthroughRGBA3DUI,   "Blit11 3D UI RGBA pixel shader"        ));
+@@ -1003,7 +1013,6 @@ void Blit11::buildShaderMap()
+     add3DBlitShaderToMap(GL_LUMINANCE,       false, d3d11::CompilePS(device, g_PS_PassthroughLum3D,      "Blit11 3D luminance pixel shader"      ));
+     add3DBlitShaderToMap(GL_LUMINANCE_ALPHA, false, d3d11::CompilePS(device, g_PS_PassthroughLumAlpha3D, "Blit11 3D luminance alpha pixel shader"));
+ 
+-    addSwizzleShaderToMap(GL_FLOAT,        D3D_SRV_DIMENSION_TEXTURE2D,      d3d11::CompilePS(device, g_PS_SwizzleF2D,       "Blit11 2D F swizzle pixel shader" ));
+     addSwizzleShaderToMap(GL_UNSIGNED_INT, D3D_SRV_DIMENSION_TEXTURE2D,      d3d11::CompilePS(device, g_PS_SwizzleUI2D,      "Blit11 2D UI swizzle pixel shader"));
+     addSwizzleShaderToMap(GL_INT,          D3D_SRV_DIMENSION_TEXTURE2D,      d3d11::CompilePS(device, g_PS_SwizzleI2D,       "Blit11 2D I swizzle pixel shader" ));
+ 
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp
+index b677fb5..352da96 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp
+@@ -711,7 +711,9 @@ void Buffer11::NativeBuffer11::fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Ren
+ 
+       case BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK:
+         bufferDesc->Usage = D3D11_USAGE_DEFAULT;
+-        bufferDesc->BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_STREAM_OUTPUT;
++        bufferDesc->BindFlags = D3D11_BIND_VERTEX_BUFFER;
++        if (renderer->getMaxTransformFeedbackBuffers() > 0)
++            bufferDesc->BindFlags |= D3D11_BIND_STREAM_OUTPUT;
+         bufferDesc->CPUAccessFlags = 0;
          break;
-       case GL_LUMINANCE8_EXT:
-         loadLuminanceDataToNativeOrBGRA(width, height, inputPitch, input, mappedImage.RowPitch, offsetMappedData, false);
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp
-index 0047e04..a1c324c 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp
-@@ -419,7 +419,8 @@ ID3D11SamplerState *RenderStateCache::getSamplerState(const gl::SamplerState &sa
-         samplerDesc.BorderColor[2] = 0.0f;
-         samplerDesc.BorderColor[3] = 0.0f;
-         samplerDesc.MinLOD = gl_d3d11::ConvertMinLOD(samplerState.minFilter, samplerState.lodOffset);
--        samplerDesc.MaxLOD = gl_d3d11::ConvertMaxLOD(samplerState.minFilter, samplerState.lodOffset);
-+        samplerDesc.MaxLOD = mDevice->GetFeatureLevel() >= D3D_FEATURE_LEVEL_10_0
-+                ? gl_d3d11::ConvertMaxLOD(samplerState.minFilter, samplerState.lodOffset) : FLT_MAX;
- 
-         ID3D11SamplerState *dx11SamplerState = NULL;
-         HRESULT result = mDevice->CreateSamplerState(&samplerDesc, &dx11SamplerState);
-@@ -435,4 +436,4 @@ ID3D11SamplerState *RenderStateCache::getSamplerState(const gl::SamplerState &sa
-     }
+ 
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp
+index 9cd0b7d..8db5ea2 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp
+@@ -105,7 +105,7 @@ Clear11::Clear11(Renderer11 *renderer)
+     rsDesc.DepthBias = 0;
+     rsDesc.DepthBiasClamp = 0.0f;
+     rsDesc.SlopeScaledDepthBias = 0.0f;
+-    rsDesc.DepthClipEnable = FALSE;
++    rsDesc.DepthClipEnable = mRenderer->isLevel9();
+     rsDesc.ScissorEnable = FALSE;
+     rsDesc.MultisampleEnable = FALSE;
+     rsDesc.AntialiasedLineEnable = FALSE;
+@@ -115,6 +115,12 @@ Clear11::Clear11(Renderer11 *renderer)
+     d3d11::SetDebugName(mRasterizerState, "Clear11 masked clear rasterizer state");
+ 
+     mFloatClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_FLOAT, g_VS_ClearFloat, g_PS_ClearFloat);
++    if (mRenderer->isLevel9()) {
++        mUintClearShader = { 0 };
++        mIntClearShader = { 0 };
++        return;
++    }
++
+     mUintClearShader  = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_UINT,  g_VS_ClearUint,  g_PS_ClearUint );
+     mIntClearShader   = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_SINT,  g_VS_ClearSint,  g_PS_ClearSint );
  }
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp
+index 67540bb..0704034 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/PixelTransfer11.cpp
+@@ -89,13 +89,16 @@ PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
+     ASSERT(SUCCEEDED(result));
+     d3d11::SetDebugName(mParamsConstantBuffer, "PixelTransfer11 constant buffer");
  
--}
-\ No newline at end of file
-+}
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-index 7f166fd..31d976d 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-@@ -164,6 +164,11 @@ EGLint Renderer11::initialize()
++    StructZero(&mParamsData);
++
+     // init shaders
++    if (mRenderer->isLevel9())
++        return;
++
+     mBufferToTextureVS = d3d11::CompileVS(device, g_VS_BufferToTexture, "BufferToTexture VS");
+     mBufferToTextureGS = d3d11::CompileGS(device, g_GS_BufferToTexture, "BufferToTexture GS");
+ 
+     buildShaderMap();
+-
+-    StructZero(&mParamsData);
+ }
+ 
+ PixelTransfer11::~PixelTransfer11()
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+index 36d9a8f..17a13f9 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+@@ -156,6 +156,11 @@ EGLint Renderer11::initialize()
          D3D_FEATURE_LEVEL_11_0,
          D3D_FEATURE_LEVEL_10_1,
          D3D_FEATURE_LEVEL_10_0,
@@ -80,8 +229,258 @@ index 7f166fd..31d976d 100644
 +#endif
      };
  
-     HRESULT result = S_OK;
-@@ -1533,7 +1538,7 @@ void Renderer11::applyUniforms(gl::ProgramBinary *programBinary, gl::UniformArra
+     D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_HARDWARE;
+@@ -1114,6 +1119,84 @@ void Renderer11::drawElements(GLenum mode, GLsizei count, GLenum type, const GLv
+     }
+ }
+ 
++template<typename T>
++static void fillLineLoopIndices(GLenum type, GLsizei count, const GLvoid *indices, T *data)
++{
++    switch (type)
++    {
++      case GL_NONE:   // Non-indexed draw
++        for (int i = 0; i < count; i++)
++        {
++            data[i] = i;
++        }
++        data[count] = 0;
++        break;
++      case GL_UNSIGNED_BYTE:
++        for (int i = 0; i < count; i++)
++        {
++            data[i] = static_cast<const GLubyte*>(indices)[i];
++        }
++        data[count] = static_cast<const GLubyte*>(indices)[0];
++        break;
++      case GL_UNSIGNED_SHORT:
++        for (int i = 0; i < count; i++)
++        {
++            data[i] = static_cast<const GLushort*>(indices)[i];
++        }
++        data[count] = static_cast<const GLushort*>(indices)[0];
++        break;
++      case GL_UNSIGNED_INT:
++        for (int i = 0; i < count; i++)
++        {
++            data[i] = static_cast<const GLuint*>(indices)[i];
++        }
++        data[count] = static_cast<const GLuint*>(indices)[0];
++        break;
++      default: UNREACHABLE();
++    }
++}
++
++template<typename T>
++static void fillTriangleFanIndices(GLenum type, unsigned int numTris, const GLvoid *indices, T *data)
++{
++    switch (type)
++    {
++      case GL_NONE:   // Non-indexed draw
++        for (unsigned int i = 0; i < numTris; i++)
++        {
++            data[i*3 + 0] = 0;
++            data[i*3 + 1] = i + 1;
++            data[i*3 + 2] = i + 2;
++        }
++        break;
++      case GL_UNSIGNED_BYTE:
++        for (unsigned int i = 0; i < numTris; i++)
++        {
++            data[i*3 + 0] = static_cast<const GLubyte*>(indices)[0];
++            data[i*3 + 1] = static_cast<const GLubyte*>(indices)[i + 1];
++            data[i*3 + 2] = static_cast<const GLubyte*>(indices)[i + 2];
++        }
++        break;
++      case GL_UNSIGNED_SHORT:
++        for (unsigned int i = 0; i < numTris; i++)
++        {
++            data[i*3 + 0] = static_cast<const GLushort*>(indices)[0];
++            data[i*3 + 1] = static_cast<const GLushort*>(indices)[i + 1];
++            data[i*3 + 2] = static_cast<const GLushort*>(indices)[i + 2];
++        }
++        break;
++      case GL_UNSIGNED_INT:
++        for (unsigned int i = 0; i < numTris; i++)
++        {
++            data[i*3 + 0] = static_cast<const GLuint*>(indices)[0];
++            data[i*3 + 1] = static_cast<const GLuint*>(indices)[i + 1];
++            data[i*3 + 2] = static_cast<const GLuint*>(indices)[i + 2];
++        }
++        break;
++      default: UNREACHABLE();
++    }
++}
++
+ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer)
+ {
+     // Get the raw indices for an indexed draw
+@@ -1125,10 +1208,13 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
+         indices = static_cast<const GLubyte*>(storage->getData()) + offset;
+     }
+ 
++    // TODO: some level 9 hardware supports 32-bit indices; test and store support instead
++    const int indexType = isLevel9() ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
++
+     if (!mLineLoopIB)
+     {
+         mLineLoopIB = new StreamingIndexBufferInterface(this);
+-        if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
++        if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, indexType))
+         {
+             delete mLineLoopIB;
+             mLineLoopIB = NULL;
+@@ -1141,14 +1227,15 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
+     // Checked by Renderer11::applyPrimitiveType
+     ASSERT(count >= 0);
+ 
+-    if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
++    int indexTypeSize = indexType == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
++    if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned int>::max() / indexTypeSize))
+     {
+         ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP, too many indices required.");
+         return gl::error(GL_OUT_OF_MEMORY);
+     }
+ 
+-    const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
+-    if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
++    const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * indexTypeSize;
++    if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, indexType))
+     {
+         ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
+         return gl::error(GL_OUT_OF_MEMORY);
+@@ -1162,42 +1249,12 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
+         return gl::error(GL_OUT_OF_MEMORY);
+     }
+ 
+-    unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
++    if (indexType == GL_UNSIGNED_SHORT)
++        fillLineLoopIndices(type, count, indices, reinterpret_cast<unsigned short*>(mappedMemory));
++    else
++        fillLineLoopIndices(type, count, indices, reinterpret_cast<unsigned int*>(mappedMemory));
+     unsigned int indexBufferOffset = offset;
+ 
+-    switch (type)
+-    {
+-      case GL_NONE:   // Non-indexed draw
+-        for (int i = 0; i < count; i++)
+-        {
+-            data[i] = i;
+-        }
+-        data[count] = 0;
+-        break;
+-      case GL_UNSIGNED_BYTE:
+-        for (int i = 0; i < count; i++)
+-        {
+-            data[i] = static_cast<const GLubyte*>(indices)[i];
+-        }
+-        data[count] = static_cast<const GLubyte*>(indices)[0];
+-        break;
+-      case GL_UNSIGNED_SHORT:
+-        for (int i = 0; i < count; i++)
+-        {
+-            data[i] = static_cast<const GLushort*>(indices)[i];
+-        }
+-        data[count] = static_cast<const GLushort*>(indices)[0];
+-        break;
+-      case GL_UNSIGNED_INT:
+-        for (int i = 0; i < count; i++)
+-        {
+-            data[i] = static_cast<const GLuint*>(indices)[i];
+-        }
+-        data[count] = static_cast<const GLuint*>(indices)[0];
+-        break;
+-      default: UNREACHABLE();
+-    }
+-
+     if (!mLineLoopIB->unmapBuffer())
+     {
+         ERR("Could not unmap index buffer for GL_LINE_LOOP.");
+@@ -1230,10 +1287,12 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
+         indices = static_cast<const GLubyte*>(storage->getData()) + offset;
+     }
+ 
++    const int indexType = isLevel9() ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
++
+     if (!mTriangleFanIB)
+     {
+         mTriangleFanIB = new StreamingIndexBufferInterface(this);
+-        if (!mTriangleFanIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
++        if (!mTriangleFanIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, indexType))
+         {
+             delete mTriangleFanIB;
+             mTriangleFanIB = NULL;
+@@ -1248,14 +1307,15 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
+ 
+     const unsigned int numTris = count - 2;
+ 
+-    if (numTris > (std::numeric_limits<unsigned int>::max() / (sizeof(unsigned int) * 3)))
++    int indexTypeSize = indexType == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
++    if (numTris > (std::numeric_limits<unsigned int>::max() / (indexTypeSize * 3)))
+     {
+         ERR("Could not create a scratch index buffer for GL_TRIANGLE_FAN, too many indices required.");
+         return gl::error(GL_OUT_OF_MEMORY);
+     }
+ 
+-    const unsigned int spaceNeeded = (numTris * 3) * sizeof(unsigned int);
+-    if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
++    const unsigned int spaceNeeded = (numTris * 3) * indexTypeSize;
++    if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, indexType))
+     {
+         ERR("Could not reserve enough space in scratch index buffer for GL_TRIANGLE_FAN.");
+         return gl::error(GL_OUT_OF_MEMORY);
+@@ -1269,46 +1329,12 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
+         return gl::error(GL_OUT_OF_MEMORY);
+     }
+ 
+-    unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
++    if (indexType == GL_UNSIGNED_SHORT)
++        fillTriangleFanIndices(type, numTris, indices, reinterpret_cast<unsigned short*>(mappedMemory));
++    else
++        fillTriangleFanIndices(type, numTris, indices, reinterpret_cast<unsigned int*>(mappedMemory));
+     unsigned int indexBufferOffset = offset;
+ 
+-    switch (type)
+-    {
+-      case GL_NONE:   // Non-indexed draw
+-        for (unsigned int i = 0; i < numTris; i++)
+-        {
+-            data[i*3 + 0] = 0;
+-            data[i*3 + 1] = i + 1;
+-            data[i*3 + 2] = i + 2;
+-        }
+-        break;
+-      case GL_UNSIGNED_BYTE:
+-        for (unsigned int i = 0; i < numTris; i++)
+-        {
+-            data[i*3 + 0] = static_cast<const GLubyte*>(indices)[0];
+-            data[i*3 + 1] = static_cast<const GLubyte*>(indices)[i + 1];
+-            data[i*3 + 2] = static_cast<const GLubyte*>(indices)[i + 2];
+-        }
+-        break;
+-      case GL_UNSIGNED_SHORT:
+-        for (unsigned int i = 0; i < numTris; i++)
+-        {
+-            data[i*3 + 0] = static_cast<const GLushort*>(indices)[0];
+-            data[i*3 + 1] = static_cast<const GLushort*>(indices)[i + 1];
+-            data[i*3 + 2] = static_cast<const GLushort*>(indices)[i + 2];
+-        }
+-        break;
+-      case GL_UNSIGNED_INT:
+-        for (unsigned int i = 0; i < numTris; i++)
+-        {
+-            data[i*3 + 0] = static_cast<const GLuint*>(indices)[0];
+-            data[i*3 + 1] = static_cast<const GLuint*>(indices)[i + 1];
+-            data[i*3 + 2] = static_cast<const GLuint*>(indices)[i + 2];
+-        }
+-        break;
+-      default: UNREACHABLE();
+-    }
+-
+     if (!mTriangleFanIB->unmapBuffer())
+     {
+         ERR("Could not unmap scratch index buffer for GL_TRIANGLE_FAN.");
+@@ -1550,7 +1576,7 @@ void Renderer11::applyUniforms(const gl::ProgramBinary &programBinary)
      }
  
      // needed for the point sprite geometry shader
@@ -90,7 +489,7 @@ index 7f166fd..31d976d 100644
      {
          mDeviceContext->GSSetConstantBuffers(0, 1, &mDriverConstantBufferPS);
          mCurrentGeometryConstantBuffer = mDriverConstantBufferPS;
-@@ -1956,6 +1961,11 @@ bool Renderer11::testDeviceResettable()
+@@ -1700,6 +1726,11 @@ bool Renderer11::testDeviceResettable()
          D3D_FEATURE_LEVEL_11_0,
          D3D_FEATURE_LEVEL_10_1,
          D3D_FEATURE_LEVEL_10_0,
@@ -102,31 +501,7 @@ index 7f166fd..31d976d 100644
      };
  
      ID3D11Device* dummyDevice;
-@@ -2139,6 +2149,11 @@ float Renderer11::getTextureMaxAnisotropy() const
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0:
-         return D3D10_MAX_MAXANISOTROPY;
-+      case D3D_FEATURE_LEVEL_9_3:
-+      case D3D_FEATURE_LEVEL_9_2:
-+        return 16;
-+      case D3D_FEATURE_LEVEL_9_1:
-+        return D3D_FL9_1_DEFAULT_MAX_ANISOTROPY;
-       default: UNREACHABLE();
-         return 0;
-     }
-@@ -2158,6 +2173,11 @@ Range Renderer11::getViewportBounds() const
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0:
-         return Range(D3D10_VIEWPORT_BOUNDS_MIN, D3D10_VIEWPORT_BOUNDS_MAX);
-+      case D3D_FEATURE_LEVEL_9_3:
-+        return Range(D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION * -2, D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION * 2);
-+      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1:
-+        return Range(D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION * -2, D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION * 2);
-       default: UNREACHABLE();
-         return Range(0, 0);
-     }
-@@ -2172,6 +2192,10 @@ unsigned int Renderer11::getMaxVertexTextureImageUnits() const
+@@ -1817,6 +1848,10 @@ unsigned int Renderer11::getMaxVertexTextureImageUnits() const
        case D3D_FEATURE_LEVEL_10_1:
        case D3D_FEATURE_LEVEL_10_0:
          return MAX_TEXTURE_IMAGE_UNITS_VTF_SM4;
@@ -137,7 +512,7 @@ index 7f166fd..31d976d 100644
        default: UNREACHABLE();
          return 0;
      }
-@@ -2195,14 +2219,14 @@ unsigned int Renderer11::getReservedFragmentUniformVectors() const
+@@ -1840,14 +1875,14 @@ unsigned int Renderer11::getReservedFragmentUniformVectors() const
  unsigned int Renderer11::getMaxVertexUniformVectors() const
  {
      META_ASSERT(MAX_VERTEX_UNIFORM_VECTORS_D3D11 <= D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT);
@@ -154,273 +529,161 @@ index 7f166fd..31d976d 100644
      return MAX_FRAGMENT_UNIFORM_VECTORS_D3D11;
  }
  
-@@ -2216,6 +2240,10 @@ unsigned int Renderer11::getMaxVaryingVectors() const
-       case D3D_FEATURE_LEVEL_10_1:
+@@ -1864,6 +1899,11 @@ unsigned int Renderer11::getMaxVaryingVectors() const
+         return D3D10_1_VS_OUTPUT_REGISTER_COUNT - getReservedVaryings();
        case D3D_FEATURE_LEVEL_10_0:
-         return D3D10_VS_OUTPUT_REGISTER_COUNT;
+         return D3D10_VS_OUTPUT_REGISTER_COUNT - getReservedVaryings();
 +      case D3D_FEATURE_LEVEL_9_3:
++        return 10 - getReservedVaryings();
 +      case D3D_FEATURE_LEVEL_9_2:
 +      case D3D_FEATURE_LEVEL_9_1:
-+        return 8;
++        return 8 - getReservedVaryings();
        default: UNREACHABLE();
          return 0;
      }
-@@ -2229,6 +2257,10 @@ bool Renderer11::getNonPower2TextureSupport() const
+@@ -1881,6 +1921,10 @@ unsigned int Renderer11::getMaxVertexShaderUniformBuffers() const
        case D3D_FEATURE_LEVEL_10_1:
        case D3D_FEATURE_LEVEL_10_0:
-         return true;
+         return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - getReservedVertexUniformBuffers();
 +      case D3D_FEATURE_LEVEL_9_3:
 +      case D3D_FEATURE_LEVEL_9_2:
 +      case D3D_FEATURE_LEVEL_9_1:
-+        return false;
++        return 0;
        default: UNREACHABLE();
-         return false;
+         return 0;
      }
-@@ -2242,6 +2274,11 @@ bool Renderer11::getOcclusionQuerySupport() const
+@@ -1898,6 +1942,10 @@ unsigned int Renderer11::getMaxFragmentShaderUniformBuffers() const
        case D3D_FEATURE_LEVEL_10_1:
        case D3D_FEATURE_LEVEL_10_0:
-         return true;
+         return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - getReservedFragmentUniformBuffers();
 +      case D3D_FEATURE_LEVEL_9_3:
 +      case D3D_FEATURE_LEVEL_9_2:
-+        return true;
 +      case D3D_FEATURE_LEVEL_9_1:
-+        return false;
++        return 0;
        default: UNREACHABLE();
-         return false;
+         return 0;
      }
-@@ -2254,7 +2291,11 @@ bool Renderer11::getInstancingSupport() const
-       case D3D_FEATURE_LEVEL_11_0:
-       case D3D_FEATURE_LEVEL_10_1:
+@@ -1935,6 +1983,10 @@ unsigned int Renderer11::getMaxTransformFeedbackBuffers() const
+         return D3D10_1_SO_BUFFER_SLOT_COUNT;
        case D3D_FEATURE_LEVEL_10_0:
--        return true;
+         return D3D10_SO_BUFFER_SLOT_COUNT;
 +      case D3D_FEATURE_LEVEL_9_3:
-+         return true;
 +      case D3D_FEATURE_LEVEL_9_2:
 +      case D3D_FEATURE_LEVEL_9_1:
-+        return false;
++        return 0;
        default: UNREACHABLE();
-         return false;
+         return 0;
+     }
+@@ -1951,6 +2003,10 @@ unsigned int Renderer11::getMaxTransformFeedbackSeparateComponents() const
+         // D3D 10 and 10.1 only allow one output per output slot if an output slot other than zero
+         // is used.
+         return 4;
++      case D3D_FEATURE_LEVEL_9_3:
++      case D3D_FEATURE_LEVEL_9_2:
++      case D3D_FEATURE_LEVEL_9_1:
++        return 0;
+       default: UNREACHABLE();
+         return 0;
      }
-@@ -2276,6 +2317,11 @@ bool Renderer11::getDerivativeInstructionSupport() const
+@@ -1973,6 +2029,10 @@ unsigned int Renderer11::getMaxUniformBufferSize() const
        case D3D_FEATURE_LEVEL_10_1:
        case D3D_FEATURE_LEVEL_10_0:
-         return true;
+         return D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent;
 +      case D3D_FEATURE_LEVEL_9_3:
-+        return true;
 +      case D3D_FEATURE_LEVEL_9_2:
 +      case D3D_FEATURE_LEVEL_9_1:
-+        return false;
++        return 0;
        default: UNREACHABLE();
-         return false;
+         return 0;
      }
-@@ -2294,6 +2340,9 @@ int Renderer11::getMajorShaderModel() const
+@@ -2021,7 +2081,11 @@ int Renderer11::getMajorShaderModel() const
+     {
        case D3D_FEATURE_LEVEL_11_0: return D3D11_SHADER_MAJOR_VERSION;   // 5
        case D3D_FEATURE_LEVEL_10_1: return D3D10_1_SHADER_MAJOR_VERSION; // 4
-       case D3D_FEATURE_LEVEL_10_0: return D3D10_SHADER_MAJOR_VERSION;   // 4
+-      case D3D_FEATURE_LEVEL_10_0: return D3D10_SHADER_MAJOR_VERSION;   // 4
++      case D3D_FEATURE_LEVEL_10_0:
 +      case D3D_FEATURE_LEVEL_9_3:
 +      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1:  return D3D10_SHADER_MAJOR_VERSION;   // 4 (level 9)
++      case D3D_FEATURE_LEVEL_9_1:
++                                   return D3D10_SHADER_MAJOR_VERSION;   // 4
        default: UNREACHABLE();      return 0;
      }
  }
-@@ -2305,6 +2354,9 @@ int Renderer11::getMinorShaderModel() const
+@@ -2032,7 +2096,10 @@ int Renderer11::getMinorShaderModel() const
+     {
        case D3D_FEATURE_LEVEL_11_0: return D3D11_SHADER_MINOR_VERSION;   // 0
        case D3D_FEATURE_LEVEL_10_1: return D3D10_1_SHADER_MINOR_VERSION; // 1
-       case D3D_FEATURE_LEVEL_10_0: return D3D10_SHADER_MINOR_VERSION;   // 0
+-      case D3D_FEATURE_LEVEL_10_0: return D3D10_SHADER_MINOR_VERSION;   // 0
++      case D3D_FEATURE_LEVEL_10_0:
 +      case D3D_FEATURE_LEVEL_9_3:
 +      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1:  return D3D10_SHADER_MINOR_VERSION;   // 0 (level 9)
++      case D3D_FEATURE_LEVEL_9_1:  return D3D10_SHADER_MINOR_VERSION;   // 0
        default: UNREACHABLE();      return 0;
      }
  }
-@@ -2330,6 +2382,11 @@ int Renderer11::getMaxViewportDimension() const
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0: 
-         return D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION;   // 8192
+@@ -2615,6 +2682,15 @@ ShaderExecutable *Renderer11::compileToExecutable(gl::InfoLog &infoLog, const ch
+       case D3D_FEATURE_LEVEL_10_0:
+         profileVersion = "4_0";
+         break;
 +      case D3D_FEATURE_LEVEL_9_3:
-+        return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; // 4096
++        profileVersion = "4_0_level_9_3";
++        break;
 +      case D3D_FEATURE_LEVEL_9_2:
++        profileVersion = "4_0_level_9_2";
++        break;
 +      case D3D_FEATURE_LEVEL_9_1:
-+        return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; // 2048
-       default: UNREACHABLE();      
-         return 0;
-     }
-@@ -2342,6 +2399,9 @@ int Renderer11::getMaxTextureWidth() const
-       case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;   // 16384
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION;   // 8192
-+      case D3D_FEATURE_LEVEL_9_3: return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; // 4096
-+      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; // 2048
-       default: UNREACHABLE();      return 0;
-     }
- }
-@@ -2353,6 +2413,9 @@ int Renderer11::getMaxTextureHeight() const
-       case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;   // 16384
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION;   // 8192
-+      case D3D_FEATURE_LEVEL_9_3: return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; // 4096
-+      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; // 2048
-       default: UNREACHABLE();      return 0;
-     }
- }
-@@ -2364,6 +2427,9 @@ bool Renderer11::get32BitIndexSupport() const
-       case D3D_FEATURE_LEVEL_11_0: 
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP >= 32;   // true
-+      case D3D_FEATURE_LEVEL_9_3:
-+      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1:  return false;
-       default: UNREACHABLE();      return false;
-     }
- }
-@@ -2410,6 +2476,8 @@ unsigned int Renderer11::getMaxRenderTargets() const
- {
-     META_ASSERT(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT <= gl::IMPLEMENTATION_MAX_DRAW_BUFFERS);
-     META_ASSERT(D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT <= gl::IMPLEMENTATION_MAX_DRAW_BUFFERS);
-+    META_ASSERT(D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT <= gl::IMPLEMENTATION_MAX_DRAW_BUFFERS);
-+    META_ASSERT(D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT <= gl::IMPLEMENTATION_MAX_DRAW_BUFFERS);
- 
-     switch (mFeatureLevel)
-     {
-@@ -2417,6 +2485,9 @@ unsigned int Renderer11::getMaxRenderTargets() const
-         return D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT;  // 8
-       case D3D_FEATURE_LEVEL_10_1:
-       case D3D_FEATURE_LEVEL_10_0:
-+      case D3D_FEATURE_LEVEL_9_3: //  return D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT; // 4
-+      case D3D_FEATURE_LEVEL_9_2:
-+      case D3D_FEATURE_LEVEL_9_1: //  return D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT; // 1
-         // Feature level 10.0 and 10.1 cards perform very poorly when the pixel shader
-         // outputs to multiple RTs that are not bound.
-         // TODO: Remove pixel shader outputs for render targets that are not bound.
-@@ -2603,7 +2674,7 @@ bool Renderer11::copyTexture(ID3D11ShaderResourceView *source, const gl::Rectang
-         samplerDesc.BorderColor[2] = 0.0f;
-         samplerDesc.BorderColor[3] = 0.0f;
-         samplerDesc.MinLOD = 0.0f;
--        samplerDesc.MaxLOD = 0.0f;
-+        samplerDesc.MaxLOD = mDevice->GetFeatureLevel() >= D3D_FEATURE_LEVEL_10_0 ? 0.0f : FLT_MAX;
- 
-         result = mDevice->CreateSamplerState(&samplerDesc, &mCopySampler);
-         ASSERT(SUCCEEDED(result));
-@@ -2848,7 +2919,7 @@ ShaderExecutable *Renderer11::loadExecutable(const void *function, size_t length
- 
- ShaderExecutable *Renderer11::compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, rx::ShaderType type, D3DWorkaroundType workaround)
- {
--    const char *profile = NULL;
-+    std::string profile;
- 
-     switch (type)
-     {
-@@ -2866,7 +2937,12 @@ ShaderExecutable *Renderer11::compileToExecutable(gl::InfoLog &infoLog, const ch
++        profileVersion = "4_0_level_9_1";
++        break;
+       default:
+         UNREACHABLE();
          return NULL;
-     }
- 
--    ID3DBlob *binary = (ID3DBlob*)compileToBinary(infoLog, shaderHLSL, profile, D3DCOMPILE_OPTIMIZATION_LEVEL0, false);
-+    if (mFeatureLevel == D3D_FEATURE_LEVEL_9_3)
-+        profile += "_level_9_3";
-+    else if (mFeatureLevel == D3D_FEATURE_LEVEL_9_2 || mFeatureLevel == D3D_FEATURE_LEVEL_9_1)
-+        profile += "_level_9_1";
-+
-+    ID3DBlob *binary = (ID3DBlob*)compileToBinary(infoLog, shaderHLSL, profile.c_str(), D3DCOMPILE_OPTIMIZATION_LEVEL0, false);
-     if (!binary)
-         return NULL;
- 
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-index ba3f0c6..a8a722c 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-@@ -177,6 +177,7 @@ class Renderer11 : public Renderer
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
+index 618972d..a31f15e 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
+@@ -199,6 +199,7 @@ class Renderer11 : public Renderer
      ID3D11Device *getDevice() { return mDevice; }
      ID3D11DeviceContext *getDeviceContext() { return mDeviceContext; };
      IDXGIFactory *getDxgiFactory() { return mDxgiFactory; };
-+    D3D_FEATURE_LEVEL getFeatureLevel() { return mFeatureLevel; }
- 
-     bool getRenderTargetResource(gl::Renderbuffer *colorbuffer, unsigned int *subresourceIndex, ID3D11Texture2D **resource);
-     void unapplyRenderTargets();
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp
-index 5f6ea21..fdfbe52 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp
-@@ -222,14 +222,14 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapch
- }
- 
- TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
--    : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, forceRenderable))
-+    : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat, Renderer11::makeRenderer11(renderer)->getFeatureLevel()), usage, forceRenderable))
- {
-     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
-     {
-         mRenderTarget[i] = NULL;
-     }
- 
--    DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat);
-+    DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat, mRenderer->getFeatureLevel());
-     if (d3d11::IsDepthStencilFormat(convertedFormat))
-     {
-         mTextureFormat = d3d11::GetDepthTextureFormat(convertedFormat);
-@@ -331,7 +331,7 @@ RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
-             srvDesc.Format = mShaderResourceFormat;
-             srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
-             srvDesc.Texture2D.MostDetailedMip = level;
--            srvDesc.Texture2D.MipLevels = 1;
-+            srvDesc.Texture2D.MipLevels = level ? 1 : -1;
- 
-             ID3D11ShaderResourceView *srv;
-             result = device->CreateShaderResourceView(mTexture, &srvDesc, &srv);
-@@ -440,7 +440,7 @@ void TextureStorage11_2D::generateMipmap(int level)
- }
++    bool isLevel9() { return mFeatureLevel <= D3D_FEATURE_LEVEL_9_3; }
  
- TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
--    : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, forceRenderable))
-+    : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat, Renderer11::makeRenderer11(renderer)->getFeatureLevel()), usage, forceRenderable))
- {
-     for (unsigned int i = 0; i < 6; i++)
-     {
-@@ -450,7 +450,7 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLe
-         }
-     }
+     Blit11 *getBlitter() { return mBlit; }
  
--    DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat);
-+    DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat, mRenderer->getFeatureLevel());
-     if (d3d11::IsDepthStencilFormat(convertedFormat))
-     {
-         mTextureFormat = d3d11::GetDepthTextureFormat(convertedFormat);
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.cpp
-index 6f06024..34b8259 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.cpp
-@@ -329,7 +329,7 @@ DXGI_FORMAT ConvertRenderbufferFormat(GLenum format)
-     return DXGI_FORMAT_R8G8B8A8_UNORM;
- }
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
+index 65e0e63..00b81b7 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
+@@ -441,7 +441,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, GLenum internalform
+         D3D11_TEXTURE2D_DESC desc;
+         desc.Width = width;      // Compressed texture size constraints?
+         desc.Height = height;
+-        desc.MipLevels = ((levels > 0) ? (mTopLevel + levels) : 0);
++        desc.MipLevels = mRenderer->isLevel9() ? 1 : ((levels > 0) ? (mTopLevel + levels) : 0);
+         desc.ArraySize = 1;
+         desc.Format = mTextureFormat;
+         desc.SampleDesc.Count = 1;
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/formatutils11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/formatutils11.cpp
+index a300c2e..c991fd4 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/formatutils11.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/formatutils11.cpp
+@@ -106,7 +106,7 @@ static D3D11ES3FormatMap BuildD3D11FormatMap()
  
--DXGI_FORMAT ConvertTextureFormat(GLenum internalformat)
-+DXGI_FORMAT ConvertTextureFormat(GLenum internalformat, D3D_FEATURE_LEVEL featureLevel)
- {
-     switch (internalformat)
-     {
-@@ -342,7 +342,7 @@ DXGI_FORMAT ConvertTextureFormat(GLenum internalformat)
-       case GL_LUMINANCE8_ALPHA8_EXT:
-         return DXGI_FORMAT_R8G8B8A8_UNORM;
-       case GL_ALPHA8_EXT:
--        return DXGI_FORMAT_A8_UNORM;
-+        return featureLevel >= D3D_FEATURE_LEVEL_10_0 ? DXGI_FORMAT_A8_UNORM : DXGI_FORMAT_B8G8R8A8_UNORM;
-       case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-       case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-         return DXGI_FORMAT_BC1_UNORM;
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.h
-index 1bc48c1..70ad4fe 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.h
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/renderer11_utils.h
-@@ -32,7 +32,7 @@ FLOAT ConvertMinLOD(GLenum minFilter, unsigned int lodOffset);
- FLOAT ConvertMaxLOD(GLenum minFilter, unsigned int lodOffset);
- 
- DXGI_FORMAT ConvertRenderbufferFormat(GLenum format);
--DXGI_FORMAT ConvertTextureFormat(GLenum format);
-+DXGI_FORMAT ConvertTextureFormat(GLenum format, D3D_FEATURE_LEVEL featureLevel);
- }
+     // From GL_EXT_texture_storage
+     //                           | GL internal format       |               | D3D11 texture format          | D3D11 SRV format                    | D3D11 RTV format              | D3D11 DSV format               |
+-    map.insert(D3D11ES3FormatPair(GL_ALPHA8_EXT,             D3D11FormatInfo(DXGI_FORMAT_A8_UNORM,           DXGI_FORMAT_A8_UNORM,                 DXGI_FORMAT_A8_UNORM,           DXGI_FORMAT_UNKNOWN             )));
++    map.insert(D3D11ES3FormatPair(GL_ALPHA8_EXT,             D3D11FormatInfo(DXGI_FORMAT_R8G8B8A8_UNORM,     DXGI_FORMAT_R8G8B8A8_UNORM,           DXGI_FORMAT_R8G8B8A8_UNORM,           DXGI_FORMAT_UNKNOWN             )));
+     map.insert(D3D11ES3FormatPair(GL_LUMINANCE8_EXT,         D3D11FormatInfo(DXGI_FORMAT_R8G8B8A8_UNORM,     DXGI_FORMAT_R8G8B8A8_UNORM,           DXGI_FORMAT_R8G8B8A8_UNORM,     DXGI_FORMAT_UNKNOWN             )));
+     map.insert(D3D11ES3FormatPair(GL_ALPHA32F_EXT,           D3D11FormatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT,       DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_UNKNOWN             )));
+     map.insert(D3D11ES3FormatPair(GL_LUMINANCE32F_EXT,       D3D11FormatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT,       DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_UNKNOWN             )));
+@@ -309,7 +309,7 @@ D3D11LoadFunctionMap buildD3D11LoadFunctionMap()
+     insertLoadFunction(&map, GL_ALPHA,              GL_HALF_FLOAT_OES,                 LoadA16FToRGBA16F                    );
  
- namespace d3d11_gl
+     // From GL_EXT_texture_storage
+-    insertLoadFunction(&map, GL_ALPHA8_EXT,             GL_UNSIGNED_BYTE,              LoadToNative<GLubyte, 1>             );
++    insertLoadFunction(&map, GL_ALPHA8_EXT,             GL_UNSIGNED_BYTE,              LoadA8ToBGRA8                        );
+     insertLoadFunction(&map, GL_LUMINANCE8_EXT,         GL_UNSIGNED_BYTE,              LoadL8ToRGBA8                        );
+     insertLoadFunction(&map, GL_LUMINANCE8_ALPHA8_EXT,  GL_UNSIGNED_BYTE,              LoadLA8ToRGBA8                       );
+     insertLoadFunction(&map, GL_ALPHA32F_EXT,           GL_FLOAT,                      LoadA32FToRGBA32F                    );
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0011-ANGLE-Fix-compilation-error-on-MinGW-caused-by-trace.patch b/src/angle/patches/0011-ANGLE-Fix-compilation-error-on-MinGW-caused-by-trace.patch
index fdee11d324..72221117c4 100644
--- a/src/angle/patches/0011-ANGLE-Fix-compilation-error-on-MinGW-caused-by-trace.patch
+++ b/src/angle/patches/0011-ANGLE-Fix-compilation-error-on-MinGW-caused-by-trace.patch
@@ -1,7 +1,8 @@
-From 8ea24fcce69900f42299fd01772714a566f9111e Mon Sep 17 00:00:00 2001
+From a814e99f287ff19317ab1651428a5fa330aefd08 Mon Sep 17 00:00:00 2001
 From: Andrew Knight <andrew.knight@digia.com>
-Date: Mon, 24 Feb 2014 11:08:23 +0200
-Subject: [PATCH] ANGLE: Fix compilation error on MinGW caused by trace_event.h
+Date: Wed, 2 Jul 2014 08:33:00 +0300
+Subject: [PATCH 11/12] ANGLE: Fix compilation error on MinGW caused by
+ trace_event.h
 
 The event trace header in ANGLE's third_party directory has an unused
 template which causes a compilation error on MinGW. Disable this part
@@ -33,5 +34,5 @@ index 637cf9a..96ac910 100644
  } // namespace TraceEvent
  
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0012-ANGLE-fix-semantic-index-lookup.patch b/src/angle/patches/0012-ANGLE-fix-semantic-index-lookup.patch
index fe16d1d7b2..2ce3b32721 100644
--- a/src/angle/patches/0012-ANGLE-fix-semantic-index-lookup.patch
+++ b/src/angle/patches/0012-ANGLE-fix-semantic-index-lookup.patch
@@ -1,7 +1,7 @@
-From 15b694fa33cf76f93de62b8106972083f5fb3114 Mon Sep 17 00:00:00 2001
+From 107c66f691b824edfa63e8c7e578603b5ecb0d0e Mon Sep 17 00:00:00 2001
 From: Andrew Knight <andrew.knight@digia.com>
-Date: Fri, 21 Feb 2014 13:34:21 +0200
-Subject: [PATCH] ANGLE: fix semantic index lookup
+Date: Mon, 4 Aug 2014 23:53:47 +0300
+Subject: [PATCH 12/12] ANGLE: fix semantic index lookup
 
 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
@@ -9,15 +9,15 @@ GL type lookup for the translated attribute.
 
 Change-Id: I75d05ed707f56c45210e3dcbc277f894e3dc5a48
 ---
- src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp                   | 2 +-
- src/3rdparty/angle/src/libGLESv2/renderer/d3d11/InputLayoutCache.cpp | 4 ++--
+ src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp                    | 2 +-
+ .../angle/src/libGLESv2/renderer/d3d/d3d11/InputLayoutCache.cpp       | 4 ++--
  2 files changed, 3 insertions(+), 3 deletions(-)
 
 diff --git a/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp b/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp
-index 41a83b6..13c515a 100644
+index 38a6604..9fad5fb 100644
 --- a/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp
 +++ b/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp
-@@ -2643,7 +2643,7 @@ void ProgramBinary::sortAttributesByLayout(rx::TranslatedAttribute attributes[MA
+@@ -2814,7 +2814,7 @@ void ProgramBinary::sortAttributesByLayout(rx::TranslatedAttribute attributes[MA
      for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
      {
          int oldIndex = mAttributesByLayout[i];
@@ -26,11 +26,11 @@ index 41a83b6..13c515a 100644
          attributes[i] = oldTranslatedAttributes[oldIndex];
      }
  }
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/InputLayoutCache.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/InputLayoutCache.cpp
-index 3418e89..4940b8c 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/InputLayoutCache.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/InputLayoutCache.cpp
-@@ -103,10 +103,10 @@ GLenum InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl::M
+diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/InputLayoutCache.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/InputLayoutCache.cpp
+index a10f64e..3536faf 100644
+--- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/InputLayoutCache.cpp
++++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d/d3d11/InputLayoutCache.cpp
+@@ -114,10 +114,10 @@ GLenum InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl::M
              // Record the type of the associated vertex shader vector in our key
              // This will prevent mismatched vertex shaders from using the same input layout
              GLint attributeSize;
@@ -40,9 +40,9 @@ index 3418e89..4940b8c 100644
              ilKey.elements[ilKey.elementCount].desc.SemanticName = semanticName;
 -            ilKey.elements[ilKey.elementCount].desc.SemanticIndex = sortedSemanticIndices[i];
 +            ilKey.elements[ilKey.elementCount].desc.SemanticIndex = i;
-             ilKey.elements[ilKey.elementCount].desc.Format = attributes[i].attribute->mArrayEnabled ? vertexBuffer->getDXGIFormat(*attributes[i].attribute) : DXGI_FORMAT_R32G32B32A32_FLOAT;
+             ilKey.elements[ilKey.elementCount].desc.Format = dxgiFormat;
              ilKey.elements[ilKey.elementCount].desc.InputSlot = i;
              ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = 0;
 -- 
-1.8.4.msysgit.0
+1.9.0.msysgit.0
 
diff --git a/src/angle/patches/0013-ANGLE-Allow-for-universal-program-binaries.patch b/src/angle/patches/0013-ANGLE-Allow-for-universal-program-binaries.patch
deleted file mode 100644
index 11c32880df..0000000000
--- a/src/angle/patches/0013-ANGLE-Allow-for-universal-program-binaries.patch
+++ /dev/null
@@ -1,93 +0,0 @@
-From 5eeb4a06f182b4fc0e3dcb82f47fcf4286890f94 Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Fri, 21 Feb 2014 08:35:01 +0200
-Subject: [PATCH] ANGLE: Allow for universal program binaries
-
-As a safety precaution, ANGLE writes the commit hash, optimization level,
-and adapter ID to its binary format. However, this hurts portability
-between systems by making shader pre-compilation/caching artificially
-system-specific.
-
-The shader compiler doesn't take the target adapter into account, and the
-optimization level information discarded by ANGLE anyway. So, allow ANGLE
-to bypass these checks on systems where precompilation is required (i.e.
-WinRT). The default mechanism still applies unless
-ANGLE_ENABLE_UNIVERSAL_BINARY is passed as a define.
-
-Change-Id: Iec6d833fd7010ed163978557238f00e7ac6ae416
----
- src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp | 11 ++++++++++-
- 1 file changed, 10 insertions(+), 1 deletion(-)
-
-diff --git a/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp b/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp
-index 8896665..41a83b6 100644
---- a/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp
-@@ -1637,6 +1637,7 @@ bool ProgramBinary::load(InfoLog &infoLog, const void *binary, GLsizei length)
-         return false;
-     }
- 
-+#if !defined(ANGLE_ENABLE_UNIVERSAL_BINARY)
-     unsigned char commitString[ANGLE_COMMIT_HASH_SIZE];
-     stream.read(commitString, ANGLE_COMMIT_HASH_SIZE);
-     if (memcmp(commitString, ANGLE_COMMIT_HASH, sizeof(unsigned char) * ANGLE_COMMIT_HASH_SIZE) != 0)
-@@ -1652,6 +1653,7 @@ bool ProgramBinary::load(InfoLog &infoLog, const void *binary, GLsizei length)
-         infoLog.append("Mismatched compilation flags.");
-         return false;
-     }
-+#endif
- 
-     for (int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
-     {
-@@ -1742,6 +1744,7 @@ bool ProgramBinary::load(InfoLog &infoLog, const void *binary, GLsizei length)
- 
-     const char *ptr = (const char*) binary + stream.offset();
- 
-+#if !defined(ANGLE_ENABLE_UNIVERSAL_BINARY)
-     const GUID *binaryIdentifier = (const GUID *) ptr;
-     ptr += sizeof(GUID);
- 
-@@ -1751,6 +1754,7 @@ bool ProgramBinary::load(InfoLog &infoLog, const void *binary, GLsizei length)
-         infoLog.append("Invalid program binary.");
-         return false;
-     }
-+#endif
- 
-     const char *pixelShaderFunction = ptr;
-     ptr += pixelShaderSize;
-@@ -1808,9 +1812,10 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
-     stream.write(GL_PROGRAM_BINARY_ANGLE);
-     stream.write(ANGLE_MAJOR_VERSION);
-     stream.write(ANGLE_MINOR_VERSION);
-+#if !defined(ANGLE_ENABLE_UNIVERSAL_BINARY)
-     stream.write(ANGLE_COMMIT_HASH, ANGLE_COMMIT_HASH_SIZE);
-     stream.write(ANGLE_COMPILE_OPTIMIZATION_LEVEL);
--
-+#endif
-     for (unsigned int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
-     {
-         stream.write(mLinkedAttribute[i].type);
-@@ -1866,7 +1871,9 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
-     UINT geometryShaderSize = (mGeometryExecutable != NULL) ? mGeometryExecutable->getLength() : 0;
-     stream.write(geometryShaderSize);
- 
-+#if !defined(ANGLE_ENABLE_UNIVERSAL_BINARY)
-     GUID identifier = mRenderer->getAdapterIdentifier();
-+#endif
- 
-     GLsizei streamLength = stream.length();
-     const void *streamData = stream.data();
-@@ -1889,8 +1896,10 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
-         memcpy(ptr, streamData, streamLength);
-         ptr += streamLength;
- 
-+#if !defined(ANGLE_ENABLE_UNIVERSAL_BINARY)
-         memcpy(ptr, &identifier, sizeof(GUID));
-         ptr += sizeof(GUID);
-+#endif
- 
-         memcpy(ptr, mPixelExecutable->getFunction(), pixelShaderSize);
-         ptr += pixelShaderSize;
--- 
-1.8.4.msysgit.0
-
diff --git a/src/angle/patches/0014-ANGLE-D3D11-Fix-internal-index-buffer-for-level-9-ha.patch b/src/angle/patches/0014-ANGLE-D3D11-Fix-internal-index-buffer-for-level-9-ha.patch
deleted file mode 100644
index 52dfcd6da2..0000000000
--- a/src/angle/patches/0014-ANGLE-D3D11-Fix-internal-index-buffer-for-level-9-ha.patch
+++ /dev/null
@@ -1,256 +0,0 @@
-From d7eb7ea643f00d47447d755b4a2125922d69a3b3 Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Thu, 20 Mar 2014 13:21:29 +0200
-Subject: [PATCH] ANGLE D3D11: Fix internal index buffer for level 9 hardware
-
-Some level 9 hardware does not support 32-bit indices, and in most
-places this is already checked. It would appear that most phone
-hardware actually does support 32-bit indices, and so this bug wasn't
-caught until testing on the Surface RT. This is not surprising, as some
-level 9 resources are only a minimum for the hardware spec, not the
-true limit of the device/driver.
-
-This patch provides the general fix to use 16-bit indices on such
-hardware, but a whitelist of known good GPUs should be added to enable
-32-bit indices where available.
-
-Change-Id: I282ede5dd4a323037ade6c44b7cfac2c6445b491
----
- .../src/libGLESv2/renderer/d3d11/Renderer11.cpp    | 169 ++++++++++++---------
- 1 file changed, 94 insertions(+), 75 deletions(-)
-
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-index 31d976d..2de477b 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-@@ -1137,6 +1137,84 @@ void Renderer11::drawElements(GLenum mode, GLsizei count, GLenum type, const GLv
-     }
- }
- 
-+template<typename T>
-+static void fillLineLoopIndices(GLenum type, GLsizei count, const GLvoid *indices, T *data)
-+{
-+    switch (type)
-+    {
-+      case GL_NONE:   // Non-indexed draw
-+        for (int i = 0; i < count; i++)
-+        {
-+            data[i] = i;
-+        }
-+        data[count] = 0;
-+        break;
-+      case GL_UNSIGNED_BYTE:
-+        for (int i = 0; i < count; i++)
-+        {
-+            data[i] = static_cast<const GLubyte*>(indices)[i];
-+        }
-+        data[count] = static_cast<const GLubyte*>(indices)[0];
-+        break;
-+      case GL_UNSIGNED_SHORT:
-+        for (int i = 0; i < count; i++)
-+        {
-+            data[i] = static_cast<const GLushort*>(indices)[i];
-+        }
-+        data[count] = static_cast<const GLushort*>(indices)[0];
-+        break;
-+      case GL_UNSIGNED_INT:
-+        for (int i = 0; i < count; i++)
-+        {
-+            data[i] = static_cast<const GLuint*>(indices)[i];
-+        }
-+        data[count] = static_cast<const GLuint*>(indices)[0];
-+        break;
-+      default: UNREACHABLE();
-+    }
-+}
-+
-+template<typename T>
-+static void fillTriangleFanIndices(GLenum type, unsigned int numTris, const GLvoid *indices, T *data)
-+{
-+    switch (type)
-+    {
-+      case GL_NONE:   // Non-indexed draw
-+        for (unsigned int i = 0; i < numTris; i++)
-+        {
-+            data[i*3 + 0] = 0;
-+            data[i*3 + 1] = i + 1;
-+            data[i*3 + 2] = i + 2;
-+        }
-+        break;
-+      case GL_UNSIGNED_BYTE:
-+        for (unsigned int i = 0; i < numTris; i++)
-+        {
-+            data[i*3 + 0] = static_cast<const GLubyte*>(indices)[0];
-+            data[i*3 + 1] = static_cast<const GLubyte*>(indices)[i + 1];
-+            data[i*3 + 2] = static_cast<const GLubyte*>(indices)[i + 2];
-+        }
-+        break;
-+      case GL_UNSIGNED_SHORT:
-+        for (unsigned int i = 0; i < numTris; i++)
-+        {
-+            data[i*3 + 0] = static_cast<const GLushort*>(indices)[0];
-+            data[i*3 + 1] = static_cast<const GLushort*>(indices)[i + 1];
-+            data[i*3 + 2] = static_cast<const GLushort*>(indices)[i + 2];
-+        }
-+        break;
-+      case GL_UNSIGNED_INT:
-+        for (unsigned int i = 0; i < numTris; i++)
-+        {
-+            data[i*3 + 0] = static_cast<const GLuint*>(indices)[0];
-+            data[i*3 + 1] = static_cast<const GLuint*>(indices)[i + 1];
-+            data[i*3 + 2] = static_cast<const GLuint*>(indices)[i + 2];
-+        }
-+        break;
-+      default: UNREACHABLE();
-+    }
-+}
-+
- void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer)
- {
-     // Get the raw indices for an indexed draw
-@@ -1148,10 +1226,12 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
-         indices = static_cast<const GLubyte*>(storage->getData()) + offset;
-     }
- 
-+    const int indexType = get32BitIndexSupport() ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
-+
-     if (!mLineLoopIB)
-     {
-         mLineLoopIB = new StreamingIndexBufferInterface(this);
--        if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
-+        if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, indexType))
-         {
-             delete mLineLoopIB;
-             mLineLoopIB = NULL;
-@@ -1171,7 +1251,7 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
-     }
- 
-     const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
--    if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
-+    if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, indexType))
-     {
-         ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-         return gl::error(GL_OUT_OF_MEMORY);
-@@ -1185,42 +1265,12 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
-         return gl::error(GL_OUT_OF_MEMORY);
-     }
- 
--    unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
-+    if (indexType == GL_UNSIGNED_SHORT)
-+        fillLineLoopIndices(type, count, indices, reinterpret_cast<unsigned short*>(mappedMemory));
-+    else
-+        fillLineLoopIndices(type, count, indices, reinterpret_cast<unsigned int*>(mappedMemory));
-     unsigned int indexBufferOffset = offset;
- 
--    switch (type)
--    {
--      case GL_NONE:   // Non-indexed draw
--        for (int i = 0; i < count; i++)
--        {
--            data[i] = i;
--        }
--        data[count] = 0;
--        break;
--      case GL_UNSIGNED_BYTE:
--        for (int i = 0; i < count; i++)
--        {
--            data[i] = static_cast<const GLubyte*>(indices)[i];
--        }
--        data[count] = static_cast<const GLubyte*>(indices)[0];
--        break;
--      case GL_UNSIGNED_SHORT:
--        for (int i = 0; i < count; i++)
--        {
--            data[i] = static_cast<const GLushort*>(indices)[i];
--        }
--        data[count] = static_cast<const GLushort*>(indices)[0];
--        break;
--      case GL_UNSIGNED_INT:
--        for (int i = 0; i < count; i++)
--        {
--            data[i] = static_cast<const GLuint*>(indices)[i];
--        }
--        data[count] = static_cast<const GLuint*>(indices)[0];
--        break;
--      default: UNREACHABLE();
--    }
--
-     if (!mLineLoopIB->unmapBuffer())
-     {
-         ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-@@ -1251,10 +1301,12 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
-         indices = static_cast<const GLubyte*>(storage->getData()) + offset;
-     }
- 
-+    const int indexType = get32BitIndexSupport() ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
-+
-     if (!mTriangleFanIB)
-     {
-         mTriangleFanIB = new StreamingIndexBufferInterface(this);
--        if (!mTriangleFanIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
-+        if (!mTriangleFanIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, indexType))
-         {
-             delete mTriangleFanIB;
-             mTriangleFanIB = NULL;
-@@ -1276,7 +1328,7 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
-     }
- 
-     const unsigned int spaceNeeded = (numTris * 3) * sizeof(unsigned int);
--    if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
-+    if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, indexType))
-     {
-         ERR("Could not reserve enough space in scratch index buffer for GL_TRIANGLE_FAN.");
-         return gl::error(GL_OUT_OF_MEMORY);
-@@ -1290,45 +1342,12 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
-         return gl::error(GL_OUT_OF_MEMORY);
-     }
- 
--    unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
-+    if (indexType == GL_UNSIGNED_SHORT)
-+        fillTriangleFanIndices(type, numTris, indices, reinterpret_cast<unsigned short*>(mappedMemory));
-+    else
-+        fillTriangleFanIndices(type, numTris, indices, reinterpret_cast<unsigned int*>(mappedMemory));
-     unsigned int indexBufferOffset = offset;
- 
--    switch (type)
--    {
--      case GL_NONE:   // Non-indexed draw
--        for (unsigned int i = 0; i < numTris; i++)
--        {
--            data[i*3 + 0] = 0;
--            data[i*3 + 1] = i + 1;
--            data[i*3 + 2] = i + 2;
--        }
--        break;
--      case GL_UNSIGNED_BYTE:
--        for (unsigned int i = 0; i < numTris; i++)
--        {
--            data[i*3 + 0] = static_cast<const GLubyte*>(indices)[0];
--            data[i*3 + 1] = static_cast<const GLubyte*>(indices)[i + 1];
--            data[i*3 + 2] = static_cast<const GLubyte*>(indices)[i + 2];
--        }
--        break;
--      case GL_UNSIGNED_SHORT:
--        for (unsigned int i = 0; i < numTris; i++)
--        {
--            data[i*3 + 0] = static_cast<const GLushort*>(indices)[0];
--            data[i*3 + 1] = static_cast<const GLushort*>(indices)[i + 1];
--            data[i*3 + 2] = static_cast<const GLushort*>(indices)[i + 2];
--        }
--        break;
--      case GL_UNSIGNED_INT:
--        for (unsigned int i = 0; i < numTris; i++)
--        {
--            data[i*3 + 0] = static_cast<const GLuint*>(indices)[0];
--            data[i*3 + 1] = static_cast<const GLuint*>(indices)[i + 1];
--            data[i*3 + 2] = static_cast<const GLuint*>(indices)[i + 2];
--        }
--        break;
--      default: UNREACHABLE();
--    }
- 
-     if (!mTriangleFanIB->unmapBuffer())
-     {
--- 
-1.8.4.msysgit.0
-
diff --git a/src/angle/patches/0015-ANGLE-Don-t-export-DLLMain-functions-for-static-buil.patch b/src/angle/patches/0015-ANGLE-Don-t-export-DLLMain-functions-for-static-buil.patch
deleted file mode 100644
index 0341da289a..0000000000
--- a/src/angle/patches/0015-ANGLE-Don-t-export-DLLMain-functions-for-static-buil.patch
+++ /dev/null
@@ -1,63 +0,0 @@
-From 6545677945d24854007d39fed86d4e44900b5c1a Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Thu, 27 Mar 2014 15:36:52 +0200
-Subject: [PATCH] ANGLE: Don't export DLLMain functions for static builds
-
-These ifdef guards were originally a part of
-"0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch",
-but were lost during the last ANGLE upgrade.
-
-Task-number: QTBUG-37842
-Change-Id: I4340c1641675dd310c14454a851eb4bc0ae2ec0d
----
- src/3rdparty/angle/src/libEGL/main.cpp    | 4 ++++
- src/3rdparty/angle/src/libGLESv2/main.cpp | 4 ++++
- 2 files changed, 8 insertions(+)
-
-diff --git a/src/3rdparty/angle/src/libEGL/main.cpp b/src/3rdparty/angle/src/libEGL/main.cpp
-index e972691..4cdf5f0 100644
---- a/src/3rdparty/angle/src/libEGL/main.cpp
-+++ b/src/3rdparty/angle/src/libEGL/main.cpp
-@@ -69,6 +69,8 @@ void DeallocateCurrent()
- 
- }
- 
-+#ifndef QT_OPENGL_ES_2_ANGLE_STATIC
-+
- extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
- {
-     switch (reason)
-@@ -124,6 +126,8 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
-     return TRUE;
- }
- 
-+#endif // !QT_OPENGL_ES_2_ANGLE_STATIC
-+
- namespace egl
- {
- 
-diff --git a/src/3rdparty/angle/src/libGLESv2/main.cpp b/src/3rdparty/angle/src/libGLESv2/main.cpp
-index 95f4b8d..e527994 100644
---- a/src/3rdparty/angle/src/libGLESv2/main.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/main.cpp
-@@ -66,6 +66,8 @@ void DeallocateCurrent()
- 
- }
- 
-+#ifndef QT_OPENGL_ES_2_ANGLE_STATIC
-+
- extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
- {
-     switch (reason)
-@@ -107,6 +109,8 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
-     return TRUE;
- }
- 
-+#endif // !QT_OPENGL_ES_2_ANGLE_STATIC
-+
- namespace gl
- {
- 
--- 
-1.8.4.msysgit.0
-
diff --git a/src/angle/patches/0016-ANGLE-WinRT-Call-Trim-when-application-suspends.patch b/src/angle/patches/0016-ANGLE-WinRT-Call-Trim-when-application-suspends.patch
deleted file mode 100644
index bf2a1ad363..0000000000
--- a/src/angle/patches/0016-ANGLE-WinRT-Call-Trim-when-application-suspends.patch
+++ /dev/null
@@ -1,118 +0,0 @@
-From 158b7642c53843ed954fa667ff23b8746f95f8eb Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Tue, 22 Apr 2014 09:13:57 +0300
-Subject: [PATCH] ANGLE WinRT: Call Trim() when application suspends
-
-This is required by Windows Store Apps to pass certification.
-
-Task-number: QTBUG-38481
-Change-Id: I6dc00431ee5f6c7d4c64111ccc38f46483d3b9a8
----
- .../src/libGLESv2/renderer/d3d11/Renderer11.cpp    | 47 ++++++++++++++++++++++
- .../src/libGLESv2/renderer/d3d11/Renderer11.h      | 15 +++++++
- 2 files changed, 62 insertions(+)
-
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-index 2de477b..e70727c 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.cpp
-@@ -40,6 +40,13 @@
- 
- #include "libEGL/Display.h"
- 
-+#if defined(ANGLE_OS_WINRT) && !defined(ANGLE_OS_WINPHONE)
-+#  include <dxgi1_3.h>
-+#  include <wrl.h>
-+#  include <windows.applicationmodel.core.h>
-+typedef ABI::Windows::Foundation::IEventHandler<ABI::Windows::ApplicationModel::SuspendingEventArgs *> SuspendEventHandler;
-+#endif
-+
- #ifdef _DEBUG
- // this flag enables suppressing some spurious warnings that pop up in certain WebGL samples
- // and conformance tests. to enable all warnings, remove this define.
-@@ -426,9 +433,49 @@ EGLint Renderer11::initialize()
-         }
-     }
- 
-+#if defined(ANGLE_OS_WINRT) && !defined(ANGLE_OS_WINPHONE)
-+    // Monitor when the application suspends so that Trim() can be called
-+    Microsoft::WRL::ComPtr<ABI::Windows::ApplicationModel::Core::ICoreApplication> application;
-+    result = RoGetActivationFactory(Microsoft::WRL::Wrappers::HString::MakeReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication).Get(),
-+                                    IID_PPV_ARGS(&application));
-+    if (FAILED(result))
-+    {
-+        ERR("Error obtaining CoreApplication: 0x%08X", result);
-+        return EGL_NOT_INITIALIZED;
-+    }
-+
-+    EventRegistrationToken cookie;
-+    result = application->add_Suspending(Microsoft::WRL::Callback<SuspendEventHandler>(this, &Renderer11::onSuspend).Get(), &cookie);
-+    if (FAILED(result))
-+    {
-+        ERR("Error setting suspend callback: 0x%08X", result);
-+        return EGL_NOT_INITIALIZED;
-+    }
-+#endif
-+
-     return EGL_SUCCESS;
- }
- 
-+#if defined(ANGLE_OS_WINRT) && !defined(ANGLE_OS_WINPHONE)
-+HRESULT Renderer11::onSuspend(IInspectable *, ABI::Windows::ApplicationModel::ISuspendingEventArgs *)
-+{
-+    if (!mDevice)
-+        return S_OK;
-+
-+    Microsoft::WRL::ComPtr<IDXGIDevice3> dxgiDevice;
-+    HRESULT result = mDevice->QueryInterface(IID_PPV_ARGS(&dxgiDevice));
-+    if (FAILED(result))
-+    {
-+        ERR("Error obtaining DXGIDevice3 on suspend: 0x%08X", result);
-+        return S_OK;
-+    }
-+
-+    dxgiDevice->Trim();
-+
-+    return S_OK;
-+}
-+#endif
-+
- // do any one-time device initialization
- // NOTE: this is also needed after a device lost/reset
- // to reset the scene status and ensure the default states are reset.
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-index a8a722c..773fc26 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/Renderer11.h
-@@ -18,6 +18,17 @@
- #include "libGLESv2/renderer/d3d11/InputLayoutCache.h"
- #include "libGLESv2/renderer/RenderTarget.h"
- 
-+#if defined(ANGLE_OS_WINRT) && !defined(ANGLE_OS_WINPHONE)
-+struct IInspectable;
-+namespace ABI {
-+    namespace Windows {
-+        namespace ApplicationModel {
-+            struct ISuspendingEventArgs;
-+        }
-+    }
-+}
-+#endif
-+
- namespace gl
- {
- class Renderbuffer;
-@@ -202,6 +213,10 @@ class Renderer11 : public Renderer
-                               RenderTarget *drawRenderTarget, bool wholeBufferCopy);
-     ID3D11Texture2D *resolveMultisampledTexture(ID3D11Texture2D *source, unsigned int subresource);
- 
-+#if defined(ANGLE_OS_WINRT) && !defined(ANGLE_OS_WINPHONE)
-+    HRESULT onSuspend(IInspectable *, ABI::Windows::ApplicationModel::ISuspendingEventArgs *);
-+#endif
-+
-     HMODULE mD3d11Module;
-     HMODULE mDxgiModule;
- 
--- 
-1.9.0.msysgit.0
-
diff --git a/src/angle/patches/0017-ANGLE-D3D11-Don-t-use-mipmaps-in-level-9-textures.patch b/src/angle/patches/0017-ANGLE-D3D11-Don-t-use-mipmaps-in-level-9-textures.patch
deleted file mode 100644
index 200a8105de..0000000000
--- a/src/angle/patches/0017-ANGLE-D3D11-Don-t-use-mipmaps-in-level-9-textures.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-From 9632c57033b514bfb10a0dfa7ba51ec27a944616 Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Tue, 6 May 2014 13:35:14 +0300
-Subject: [PATCH] ANGLE D3D11: Don't use mipmaps in level 9 textures
-
-As the mipmaps levels aren't being generated on level 9, they shouldn't
-be used. Fall back to multisampled textures instead (which is the
-behavior for non-power-of-two textures anyway). This fixes an issue in
-which textured polygons (e.g. QML Images) turn black when scaled down.
-
-Change-Id: I648b8be473dc38f4e1b26724cbaff610e586fdbd
----
- src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp
-index fdfbe52..0c981ac 100644
---- a/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp
-+++ b/src/3rdparty/angle/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp
-@@ -257,7 +257,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum
-         D3D11_TEXTURE2D_DESC desc;
-         desc.Width = width;      // Compressed texture size constraints?
-         desc.Height = height;
--        desc.MipLevels = (levels > 0) ? levels + mLodOffset : 0;
-+        desc.MipLevels = mRenderer->getFeatureLevel() >= D3D_FEATURE_LEVEL_10_0 ? ((levels > 0) ? levels + mLodOffset : 0) : 1;
-         desc.ArraySize = 1;
-         desc.Format = mTextureFormat;
-         desc.SampleDesc.Count = 1;
--- 
-1.9.0.msysgit.0
-
diff --git a/src/angle/patches/0018-ANGLE-WinRT-Create-swap-chain-using-physical-resolut.patch b/src/angle/patches/0018-ANGLE-WinRT-Create-swap-chain-using-physical-resolut.patch
deleted file mode 100644
index d46851b1e8..0000000000
--- a/src/angle/patches/0018-ANGLE-WinRT-Create-swap-chain-using-physical-resolut.patch
+++ /dev/null
@@ -1,145 +0,0 @@
-From 59c6d4c94acb4735a73f50f46f91a6cce7389f94 Mon Sep 17 00:00:00 2001
-From: Andrew Knight <andrew.knight@digia.com>
-Date: Wed, 21 May 2014 00:58:21 +0300
-Subject: [PATCH] ANGLE WinRT: Create swap chain using physical resolution
-
-ANGLE has been creating the framebuffer in logical pixels instead of
-physical pixels, which leads to unexpected results and side effects like
-smudged anti-aliased text. This fixes the issue by multiplying the DIP
-resolution by the scale factor, making the framebuffer match the physical
-pixel resolution of the screen.
-
-Change-Id: I3594995ce8e18a31b47e27165f72bc6a391b97b6
----
- src/3rdparty/angle/src/libEGL/Surface.cpp | 97 ++++++++++++++++++++++++++-----
- 1 file changed, 83 insertions(+), 14 deletions(-)
-
-diff --git a/src/3rdparty/angle/src/libEGL/Surface.cpp b/src/3rdparty/angle/src/libEGL/Surface.cpp
-index 3443355..a2e2306 100644
---- a/src/3rdparty/angle/src/libEGL/Surface.cpp
-+++ b/src/3rdparty/angle/src/libEGL/Surface.cpp
-@@ -24,8 +24,83 @@
- #include "libEGL/Display.h"
- 
- #if defined(ANGLE_OS_WINRT)
-+#include <wrl.h>
- #include <windows.foundation.h>
- #include <windows.ui.core.h>
-+#include <windows.graphics.display.h>
-+
-+static bool getCoreWindowSize(const EGLNativeWindowType win, int *width, int *height)
-+{
-+    Microsoft::WRL::ComPtr<ABI::Windows::UI::Core::ICoreWindow> window;
-+    HRESULT hr = win->QueryInterface(IID_PPV_ARGS(&window));
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to cast native display pointer to ICoreWindow *.");
-+        return false;
-+    }
-+
-+#if _MSC_VER<=1700
-+    Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Display::IDisplayPropertiesStatics> displayInformation;
-+    hr = RoGetActivationFactory(Microsoft::WRL::Wrappers::HString::MakeReference(RuntimeClass_Windows_Graphics_Display_DisplayProperties).Get(),
-+                                IID_PPV_ARGS(&displayInformation));
-+#else
-+    Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Display::IDisplayInformationStatics> displayInformationFactory;
-+    hr = RoGetActivationFactory(Microsoft::WRL::Wrappers::HString::MakeReference(RuntimeClass_Windows_Graphics_Display_DisplayInformation).Get(),
-+                                IID_PPV_ARGS(&displayInformationFactory));
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to get display information factory.");
-+        return false;
-+    }
-+
-+    Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Display::IDisplayInformation> displayInformation;
-+    hr = displayInformationFactory->GetForCurrentView(&displayInformation);
-+#endif
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to get display information.");
-+        return false;
-+    }
-+
-+#if defined(ANGLE_OS_WINPHONE) && _MSC_VER>=1800 // Windows Phone 8.1
-+    Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Display::IDisplayInformation2> displayInformation2;
-+    hr = displayInformation.As(&displayInformation2);
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to get extended display information.");
-+        return false;
-+    }
-+
-+    DOUBLE scaleFactor;
-+    hr = displayInformation2->get_RawPixelsPerViewPixel(&scaleFactor);
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to get raw pixels per view pixel.");
-+        return false;
-+    }
-+#else
-+    ABI::Windows::Graphics::Display::ResolutionScale resolutionScale;
-+    hr = displayInformation->get_ResolutionScale(&resolutionScale);
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to get resolution scale.");
-+        return false;
-+    }
-+    DOUBLE scaleFactor = DOUBLE(resolutionScale) / 100.0;
-+#endif
-+
-+    ABI::Windows::Foundation::Rect windowRect;
-+    hr = window->get_Bounds(&windowRect);
-+    if (FAILED(hr))
-+    {
-+        ERR("Failed to get ICoreWindow bounds.");
-+        return false;
-+    }
-+
-+    *width = std::floor(windowRect.Width * scaleFactor + 0.5);
-+    *height = std::floor(windowRect.Height * scaleFactor + 0.5);
-+    return true;
-+}
- #endif
- 
- namespace egl
-@@ -117,14 +192,10 @@ bool Surface::resetSwapChain()
-         width = windowRect.right - windowRect.left;
-         height = windowRect.bottom - windowRect.top;
- #else
--        ABI::Windows::Foundation::Rect windowRect;
--        ABI::Windows::UI::Core::ICoreWindow *window;
--        HRESULT hr = mWindow->QueryInterface(IID_PPV_ARGS(&window));
--        if (FAILED(hr))
-+        if (!getCoreWindowSize(mWindow, &width, &height))
-+        {
-             return false;
--        window->get_Bounds(&windowRect);
--        width = windowRect.Width;
--        height = windowRect.Height;
-+        }
- #endif
-     }
-     else
-@@ -336,14 +407,12 @@ bool Surface::checkForOutOfDateSwapChain()
-     int clientWidth = client.right - client.left;
-     int clientHeight = client.bottom - client.top;
- #else
--    ABI::Windows::Foundation::Rect windowRect;
--    ABI::Windows::UI::Core::ICoreWindow *window;
--    HRESULT hr = mWindow->QueryInterface(IID_PPV_ARGS(&window));
--    if (FAILED(hr))
-+    int clientWidth;
-+    int clientHeight;
-+    if (!getCoreWindowSize(mWindow, &clientWidth, &clientHeight))
-+    {
-         return false;
--    window->get_Bounds(&windowRect);
--    int clientWidth = windowRect.Width;
--    int clientHeight = windowRect.Height;
-+    }
- #endif
-     bool sizeDirty = clientWidth != getWidth() || clientHeight != getHeight();
- 
--- 
-1.9.0.msysgit.0
-
author	Andrew Knight <andrew.knight@digia.com>	2014-08-05 12:59:44 +0300
committer	Andrew Knight <andrew.knight@digia.com>	2014-08-05 16:43:22 +0200
commit	a6a12d8c0fc918972c15268f749ecc7c90b95d6c (patch)
tree	cb6d986d30ef97e932ab51768854d5d9b46729d3 /src/angle/patches
parent	14f9c09542bd6cc19430473da9ce4c68f239ec7d (diff)