diff options
Diffstat (limited to 'src/angle')
33 files changed, 2731 insertions, 812 deletions
diff --git a/src/angle/patches/0001-ANGLE-Fix-compilation-with-MSVC2013.patch b/src/angle/patches/0001-ANGLE-Fix-compilation-with-MSVC2013.patch deleted file mode 100644 index cf32a20d46..0000000000 --- a/src/angle/patches/0001-ANGLE-Fix-compilation-with-MSVC2013.patch +++ /dev/null @@ -1,28 +0,0 @@ -From 4863cf64cd332a5fcefe453634c3c5ef62cb758c Mon Sep 17 00:00:00 2001 -From: Friedemann Kleint <Friedemann.Kleint@digia.com> -Date: Thu, 24 Oct 2013 12:49:59 +0300 -Subject: [PATCH] ANGLE: Fix compilation with MSVC2013. - -Add missing include for std::min(), std::max(). - -Change-Id: I740e5db94f9f958ac65de8dd7baab7e203482637 ---- - src/3rdparty/angle/src/libEGL/Surface.cpp | 2 ++ - 1 file changed, 2 insertions(+) - -diff --git a/src/3rdparty/angle/src/libEGL/Surface.cpp b/src/3rdparty/angle/src/libEGL/Surface.cpp -index b47a7bc..83fbbf5 100644 ---- a/src/3rdparty/angle/src/libEGL/Surface.cpp -+++ b/src/3rdparty/angle/src/libEGL/Surface.cpp -@@ -20,6 +20,8 @@ - #include "libEGL/main.h" - #include "libEGL/Display.h" - -+#include <algorithm> -+ - namespace egl - { - --- -1.8.3.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 2fa23aed8f..06ab16abdb 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,32 +1,31 @@ -From d4776adddb971642164de54141e015abde881740 Mon Sep 17 00:00:00 2001 +From 88297d02fd1aed6cac258b72d9d0a8baabad6203 Mon Sep 17 00:00:00 2001 From: Thomas Hartmann <Thomas.Hartmann@digia.com> -Date: Tue, 8 Oct 2013 09:46:54 +0200 +Date: Mon, 17 Feb 2014 16:56:51 +0200 Subject: [PATCH] Fix compilation for MSVC 2008 and std::tuple For MSVC 2008 make_tuple is in the tr1 namespace. Change-Id: I4a51f6cabdf068993869b404b12ed1484a21a9d4 --- - .../src/libGLESv2/renderer/IndexRangeCache.cpp | 6 +++++- - 1 files changed, 5 insertions(+), 1 deletions(-) + src/3rdparty/angle/src/libGLESv2/renderer/IndexRangeCache.cpp | 4 ++++ + 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..95a6961 100644 +index 610a5ef..51d7f0b 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) bool IndexRangeCache::IndexRange::operator<(const IndexRange& rhs) const { -- return std::make_tuple(type, offset, count) < std::make_tuple(rhs.type, rhs.offset, rhs.count); +#if defined(_MSC_VER) && _MSC_VER < 1600 + return std::tr1::make_tuple(type, offset, count) < std::tr1::make_tuple(rhs.type, rhs.offset, rhs.count); +#else -+ return std::make_tuple(type, offset, count) < std::make_tuple(rhs.type, rhs.offset, rhs.count); + return std::make_tuple(type, offset, count) < std::make_tuple(rhs.type, rhs.offset, rhs.count); +#endif } IndexRangeCache::IndexBounds::IndexBounds() -- -1.7.6.msysgit.0 +1.8.4.msysgit.0 diff --git a/src/angle/patches/0001-Make-it-possible-to-link-ANGLE-statically-for-single.patch b/src/angle/patches/0001-Make-it-possible-to-link-ANGLE-statically-for-single.patch deleted file mode 100644 index 9de8c54fb6..0000000000 --- a/src/angle/patches/0001-Make-it-possible-to-link-ANGLE-statically-for-single.patch +++ /dev/null @@ -1,200 +0,0 @@ -From f1eeb288ae18f3015f435fc2df25ec1eb0f15e1a Mon Sep 17 00:00:00 2001 -From: Friedemann Kleint <Friedemann.Kleint@digia.com> -Date: Sat, 14 Sep 2013 11:07:17 +0300 -Subject: [PATCH] Make it possible to link ANGLE statically for - single-thread use. - -Fix exports and provide static instances of thread-local -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 | 35 ++++++++++++++++++++-------- - src/3rdparty/angle/src/libGLESv2/main.cpp | 21 ++++++++++++++--- - 3 files changed, 44 insertions(+), 14 deletions(-) - -diff --git a/src/3rdparty/angle/include/KHR/khrplatform.h b/src/3rdparty/angle/include/KHR/khrplatform.h -index 8ec0d19..541bfa9 100644 ---- a/src/3rdparty/angle/include/KHR/khrplatform.h -+++ b/src/3rdparty/angle/include/KHR/khrplatform.h -@@ -97,7 +97,7 @@ - *------------------------------------------------------------------------- - * This precedes the return type of the function in the function prototype. - */ --#if defined(_WIN32) && !defined(__SCITECH_SNAP__) -+#if defined(_WIN32) && !defined(__SCITECH_SNAP__) && !defined(QT_OPENGL_ES_2_ANGLE_STATIC) - # define KHRONOS_APICALL __declspec(dllimport) - #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 424ec3f..7dea5fc 100644 ---- a/src/3rdparty/angle/src/libEGL/main.cpp -+++ b/src/3rdparty/angle/src/libEGL/main.cpp -@@ -10,6 +10,8 @@ - - #include "common/debug.h" - -+#ifndef QT_OPENGL_ES_2_ANGLE_STATIC -+ - static DWORD currentTLS = TLS_OUT_OF_INDEXES; - - extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) -@@ -86,74 +88,87 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved - return TRUE; - } - -+#endif // !QT_OPENGL_ES_2_ANGLE_STATIC -+ - namespace egl - { -+Current *getCurrent() -+{ -+#ifndef QT_OPENGL_ES_2_ANGLE_STATIC -+ return (Current*)TlsGetValue(currentTLS); -+#else -+ // No precautions for thread safety taken as ANGLE is used single-threaded in Qt. -+ static Current curr = { EGL_SUCCESS, EGL_OPENGL_ES_API, EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE }; -+ return &curr; -+#endif -+} -+ - void setCurrentError(EGLint error) - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - current->error = error; - } - - EGLint getCurrentError() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->error; - } - - void setCurrentAPI(EGLenum API) - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - current->API = API; - } - - EGLenum getCurrentAPI() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->API; - } - - void setCurrentDisplay(EGLDisplay dpy) - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - current->display = dpy; - } - - EGLDisplay getCurrentDisplay() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->display; - } - - void setCurrentDrawSurface(EGLSurface surface) - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - current->drawSurface = surface; - } - - EGLSurface getCurrentDrawSurface() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->drawSurface; - } - - void setCurrentReadSurface(EGLSurface surface) - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - current->readSurface = surface; - } - - EGLSurface getCurrentReadSurface() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->readSurface; - } -diff --git a/src/3rdparty/angle/src/libGLESv2/main.cpp b/src/3rdparty/angle/src/libGLESv2/main.cpp -index 6d7a241..730a6ac 100644 ---- a/src/3rdparty/angle/src/libGLESv2/main.cpp -+++ b/src/3rdparty/angle/src/libGLESv2/main.cpp -@@ -11,6 +11,8 @@ - - #include "libGLESv2/Context.h" - -+#ifndef QT_OPENGL_ES_2_ANGLE_STATIC -+ - static DWORD currentTLS = TLS_OUT_OF_INDEXES; - - extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) -@@ -69,11 +71,24 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved - return TRUE; - } - -+#endif // !QT_OPENGL_ES_2_ANGLE_STATIC -+ - namespace gl - { -+Current *getCurrent() -+{ -+#ifndef QT_OPENGL_ES_2_ANGLE_STATIC -+ return (Current*)TlsGetValue(currentTLS); -+#else -+ // No precautions for thread safety taken as ANGLE is used single-threaded in Qt. -+ static gl::Current curr = { 0, 0 }; -+ return &curr; -+#endif -+} -+ - void makeCurrent(Context *context, egl::Display *display, egl::Surface *surface) - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - current->context = context; - current->display = display; -@@ -86,7 +101,7 @@ void makeCurrent(Context *context, egl::Display *display, egl::Surface *surface) - - Context *getContext() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->context; - } -@@ -112,7 +127,7 @@ Context *getNonLostContext() - - egl::Display *getDisplay() - { -- Current *current = (Current*)TlsGetValue(currentTLS); -+ Current *current = getCurrent(); - - return current->display; - } --- -1.8.1.msysgit.1 - diff --git a/src/angle/patches/0001-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 498cce1b7c..8b91d4b8ea 100644 --- a/src/angle/patches/0001-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,6 +1,6 @@ -From 58a797397378aff3aa039a8b2a2d7011fe788737 Mon Sep 17 00:00:00 2001 +From 95e3ca47772ef0552662b1d04b7ee08d9d1d2338 Mon Sep 17 00:00:00 2001 From: Kai Koehne <kai.koehne@digia.com> -Date: Tue, 21 Jan 2014 10:23:38 +0100 +Date: Mon, 17 Feb 2014 16:59:19 +0200 Subject: [PATCH] Fix compilation of ANGLE with mingw-tdm64 gcc 4.8.1 Do not rely on sprintf_s being declared/defined. This also fixes @@ -16,7 +16,7 @@ Change-Id: I520e2f61aeab34963e7a57baafd413c7db93f110 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp -index a382c3b..82b48ce 100644 +index a382c3b..13ef701 100644 --- a/src/3rdparty/angle/src/libEGL/Display.cpp +++ b/src/3rdparty/angle/src/libEGL/Display.cpp @@ -523,7 +523,7 @@ void Display::initVendorString() @@ -24,10 +24,10 @@ index a382c3b..82b48ce 100644 { char adapterLuidString[64]; - sprintf_s(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart); -+ snprintf(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08l%08l)", adapterLuid.HighPart, adapterLuid.LowPart); ++ snprintf(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart); mVendorString += adapterLuidString; } -- -1.8.5.2.msysgit.0 +1.8.4.msysgit.0 diff --git a/src/angle/patches/0001-Fix-compilation-with-MinGW-gcc-64-bit.patch b/src/angle/patches/0003-Fix-compilation-with-MinGW-gcc-64-bit.patch index 0420694c91..7d70057a9a 100644 --- a/src/angle/patches/0001-Fix-compilation-with-MinGW-gcc-64-bit.patch +++ b/src/angle/patches/0003-Fix-compilation-with-MinGW-gcc-64-bit.patch @@ -1,6 +1,6 @@ -From 821c28d387b332bf16b6ea35ec22a77d3ba41632 Mon Sep 17 00:00:00 2001 +From a03d8f647816767525489a2b26663d897f0264a0 Mon Sep 17 00:00:00 2001 From: Kai Koehne <kai.koehne@digia.com> -Date: Mon, 28 Oct 2013 10:27:53 +0100 +Date: Tue, 18 Feb 2014 09:34:39 +0200 Subject: [PATCH] Fix compilation with MinGW gcc 64 bit Fix compilation of ANGLE with gcc 4.8.0 64 bit: The @@ -18,10 +18,10 @@ Change-Id: Ibde75dd4b5536f3827bdf0ab02a15e93a1a8a4f0 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/3rdparty/angle/src/third_party/trace_event/trace_event.h b/src/3rdparty/angle/src/third_party/trace_event/trace_event.h -index 113b126..72d354d 100644 +index 1880056..637cf9a 100644 --- a/src/3rdparty/angle/src/third_party/trace_event/trace_event.h +++ b/src/3rdparty/angle/src/third_party/trace_event/trace_event.h -@@ -589,7 +589,7 @@ const unsigned long long noEventId = 0; +@@ -587,7 +587,7 @@ const unsigned long long noEventId = 0; class TraceID { public: explicit TraceID(const void* id, unsigned char* flags) : @@ -31,5 +31,5 @@ index 113b126..72d354d 100644 *flags |= TRACE_EVENT_FLAG_MANGLE_ID; } -- -1.8.3.msysgit.0 +1.8.4.msysgit.0 diff --git a/src/angle/patches/0004-Fix-black-screen-after-minimizing-OpenGL-window-with.patch b/src/angle/patches/0004-Fix-black-screen-after-minimizing-OpenGL-window-with.patch deleted file mode 100644 index 6eb84fd02e..0000000000 --- a/src/angle/patches/0004-Fix-black-screen-after-minimizing-OpenGL-window-with.patch +++ /dev/null @@ -1,45 +0,0 @@ -From 991dfbdfc018cb30bc1ac4df429411680b47d674 Mon Sep 17 00:00:00 2001 -From: Miikka Heikkinen <miikka.heikkinen@digia.com> -Date: Sat, 14 Sep 2013 11:07:45 +0300 -Subject: [PATCH] Fix black screen after minimizing OpenGL window with - ANGLE - -CreateTexture will fail on zero dimensions, so just release old target -and reset dimensions when resetSwapChain is called with zero size area. - -Task-number: QTBUG-27994 -Change-Id: I1e500c4fd4b92f7d9ea2a49a44f3fb930b575cd1 -Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> ---- - src/3rdparty/angle/src/libGLESv2/renderer/SwapChain9.cpp | 15 +++++++++++++++ - 1 file changed, 15 insertions(+) - -diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain9.cpp -index 0324d01..f57a874 100644 ---- a/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain9.cpp -+++ b/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain9.cpp -@@ -137,6 +137,21 @@ EGLint SwapChain9::reset(int backbufferWidth, int backbufferHeight, EGLint swapI - pShareHandle = &mShareHandle; - } - -+ // CreateTexture will fail on zero dimensions, so just release old target -+ if (!backbufferWidth || !backbufferHeight) -+ { -+ if (mRenderTarget) -+ { -+ mRenderTarget->Release(); -+ mRenderTarget = NULL; -+ } -+ -+ mWidth = backbufferWidth; -+ mHeight = backbufferHeight; -+ -+ return EGL_SUCCESS; -+ } -+ - result = device->CreateTexture(backbufferWidth, backbufferHeight, 1, D3DUSAGE_RENDERTARGET, - gl_d3d9::ConvertRenderbufferFormat(mBackBufferFormat), D3DPOOL_DEFAULT, - &mOffscreenTexture, pShareHandle); --- -1.8.1.msysgit.1 - 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 new file mode 100644 index 0000000000..2c95c5bcfa --- /dev/null +++ b/src/angle/patches/0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch @@ -0,0 +1,68 @@ +From 9b24b25eeb5ca97d7978c6840fdb1e903bf63a55 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 + single-thread use. + +Fix exports and provide static instances of thread-local +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(-) + +diff --git a/src/3rdparty/angle/include/KHR/khrplatform.h b/src/3rdparty/angle/include/KHR/khrplatform.h +index c9e6f17..1ac2d3f 100644 +--- a/src/3rdparty/angle/include/KHR/khrplatform.h ++++ b/src/3rdparty/angle/include/KHR/khrplatform.h +@@ -97,7 +97,7 @@ + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +-#if defined(_WIN32) && !defined(__SCITECH_SNAP__) ++#if defined(_WIN32) && !defined(__SCITECH_SNAP__) && !defined(QT_OPENGL_ES_2_ANGLE_STATIC) + # define KHRONOS_APICALL __declspec(dllimport) + #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 +--- a/src/3rdparty/angle/src/libEGL/main.cpp ++++ b/src/3rdparty/angle/src/libEGL/main.cpp +@@ -106,7 +106,13 @@ namespace egl + + Current *GetCurrentData() + { ++#ifndef QT_OPENGL_ES_2_ANGLE_STATIC + Current *current = (Current*)TlsGetValue(currentTLS); ++#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; ++#endif + + // ANGLE issue 488: when the dll is loaded after thread initialization, + // thread local storage (current) might not exist yet. +diff --git a/src/3rdparty/angle/src/libGLESv2/main.cpp b/src/3rdparty/angle/src/libGLESv2/main.cpp +index 50e2593..6b459d3 100644 +--- a/src/3rdparty/angle/src/libGLESv2/main.cpp ++++ b/src/3rdparty/angle/src/libGLESv2/main.cpp +@@ -89,7 +89,13 @@ namespace gl + + Current *GetCurrentData() + { ++#ifndef QT_OPENGL_ES_2_ANGLE_STATIC + Current *current = (Current*)TlsGetValue(currentTLS); ++#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; ++#endif + + // ANGLE issue 488: when the dll is loaded after thread initialization, + // thread local storage (current) might not exist yet. +-- +1.8.4.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 840f6dc36e..475ec55b0e 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,6 +1,6 @@ -From af7cb8e35774f5cba15256cb463da8c1c4d533f3 Mon Sep 17 00:00:00 2001 +From cebc37237a74a130dffaefad0a10da17abc42981 Mon Sep 17 00:00:00 2001 From: Andy Shaw <andy.shaw@digia.com> -Date: Sat, 14 Sep 2013 11:25:53 +0300 +Date: Tue, 18 Feb 2014 09:59:17 +0200 Subject: [PATCH] Fix build when SSE2 is not available. Although SSE2 support is detected at runtime it still may not be @@ -9,15 +9,15 @@ 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/Image9.cpp | 4 ++++ - 2 files changed, 6 insertions(+) + 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(-) diff --git a/src/3rdparty/angle/src/libGLESv2/mathutil.h b/src/3rdparty/angle/src/libGLESv2/mathutil.h -index bb48b94..0835486 100644 +index f902131..6474b66 100644 --- a/src/3rdparty/angle/src/libGLESv2/mathutil.h +++ b/src/3rdparty/angle/src/libGLESv2/mathutil.h -@@ -93,6 +93,7 @@ inline bool supportsSSE2() +@@ -92,6 +92,7 @@ inline bool supportsSSE2() return supports; } @@ -25,7 +25,7 @@ index bb48b94..0835486 100644 int info[4]; __cpuid(info, 0); -@@ -102,6 +103,7 @@ inline bool supportsSSE2() +@@ -101,6 +102,7 @@ inline bool supportsSSE2() supports = (info[3] >> 26) & 1; } @@ -33,10 +33,10 @@ index bb48b94..0835486 100644 checked = true; -diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Image9.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Image9.cpp -index b3dcc59..53030b7 100644 ---- a/src/3rdparty/angle/src/libGLESv2/renderer/Image9.cpp -+++ b/src/3rdparty/angle/src/libGLESv2/renderer/Image9.cpp +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) { @@ -65,6 +65,13 @@ index b3dcc59..53030b7 100644 { loadRGBAUByteDataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits); } +@@ -729,4 +733,4 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, + mDirty = true; + } + +-} +\ No newline at end of file ++} -- -1.8.1.msysgit.1 +1.8.4.msysgit.0 diff --git a/src/angle/patches/0011-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 9189501b59..cf31245b95 100644 --- a/src/angle/patches/0011-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,8 @@ -From 6d8be1da6a5a5177289200247f98e0200e0e3df3 Mon Sep 17 00:00:00 2001 +From 68ba96d224a84389567f506661a78c32b307e84d Mon Sep 17 00:00:00 2001 From: Kai Koehne <kai.koehne@digia.com> -Date: Sat, 14 Sep 2013 11:38:47 +0300 -Subject: [PATCH] Fix compilation of libGLESv2 with older MinGW-w64 headers +Date: Tue, 18 Feb 2014 10:29:14 +0200 +Subject: [PATCH] Fix compilation of libGLESv2 with older MinGW-w64 + headers Fix compilation of libGLESv2 for mingw-headers predating MinGW-w64 svn commit 5567 (like MinGW-builds gcc 4.7.2-rev8, the toolchain @@ -18,18 +19,18 @@ Change-Id: I31272a1a991c4fc0f1611f8fb7510be51d6bb925 1 file changed, 19 insertions(+) diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp -index 70b9326..d1d234b 100644 +index 3407353..e74120d 100644 --- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp +++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp -@@ -21,6 +21,25 @@ - #define ANGLE_ENABLE_D3D11 0 +@@ -24,6 +24,25 @@ + #define D3DERR_OUTOFVIDEOMEMORY MAKE_HRESULT(1, 0x876, 380) #endif +#ifdef __MINGW32__ + +#ifndef D3DCOMPILER_DLL + -+//Add define + typedefs for older MinGW-w64 headers (pre 5783) ++// Add define + typedefs for older MinGW-w64 headers (pre 5783) + +#define D3DCOMPILER_DLL L"d3dcompiler_43.dll" + @@ -48,5 +49,5 @@ index 70b9326..d1d234b 100644 { -- -1.8.1.msysgit.1 +1.8.4.msysgit.0 diff --git a/src/angle/patches/0006-Make-DX9-DX11-mutually-exclusive.patch b/src/angle/patches/0006-Make-DX9-DX11-mutually-exclusive.patch deleted file mode 100644 index 1e618d43c7..0000000000 --- a/src/angle/patches/0006-Make-DX9-DX11-mutually-exclusive.patch +++ /dev/null @@ -1,149 +0,0 @@ -From c2eb5746cdf65091932558ac48ae1e6175d45a3c Mon Sep 17 00:00:00 2001 -From: Andrew Knight <andrew.knight@digia.com> -Date: Sat, 14 Sep 2013 12:01:19 +0300 -Subject: [PATCH] Make DX9/DX11 mutually exclusive - -ANGLE supports selecting the renderer on creation, choosing between -D3D11 and D3D9 backends. This patch removes that feature, and makes the -D3D version a compile-time decision. This makes the binary size smaller -(no extra render is built) and ensures compatibility with Windows Runtime, -which supports only Direct3D 11. - -Change-Id: Id9473e0e631721083fe4026d475e37603a144c37 ---- - src/3rdparty/angle/src/common/RefCountObject.cpp | 1 - - src/3rdparty/angle/src/common/debug.cpp | 4 +++ - src/3rdparty/angle/src/libGLESv2/Texture.cpp | 6 +++- - src/3rdparty/angle/src/libGLESv2/precompiled.h | 3 ++ - .../angle/src/libGLESv2/renderer/Renderer.cpp | 37 +++++++--------------- - 5 files changed, 24 insertions(+), 27 deletions(-) - -diff --git a/src/3rdparty/angle/src/common/RefCountObject.cpp b/src/3rdparty/angle/src/common/RefCountObject.cpp -index 0364adf..c1ef90c 100644 ---- a/src/3rdparty/angle/src/common/RefCountObject.cpp -+++ b/src/3rdparty/angle/src/common/RefCountObject.cpp -@@ -1,4 +1,3 @@ --#include "precompiled.h" - // - // 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 -diff --git a/src/3rdparty/angle/src/common/debug.cpp b/src/3rdparty/angle/src/common/debug.cpp -index 2333740..9b93256 100644 ---- a/src/3rdparty/angle/src/common/debug.cpp -+++ b/src/3rdparty/angle/src/common/debug.cpp -@@ -8,7 +8,11 @@ - - #include "common/debug.h" - #include "common/system.h" -+#ifndef ANGLE_ENABLE_D3D11 - #include <d3d9.h> -+#else -+typedef DWORD D3DCOLOR; -+#endif - - namespace gl - { -diff --git a/src/3rdparty/angle/src/libGLESv2/Texture.cpp b/src/3rdparty/angle/src/libGLESv2/Texture.cpp -index ae83037..72c0a8a 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/Blit.h" -+#ifndef ANGLE_ENABLE_D3D11 -+# include "libGLESv2/renderer/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 a850d57..50dec6b 100644 ---- a/src/3rdparty/angle/src/libGLESv2/precompiled.h -+++ b/src/3rdparty/angle/src/libGLESv2/precompiled.h -@@ -32,9 +32,12 @@ - #include <unordered_map> - #include <vector> - -+#ifndef ANGLE_ENABLE_D3D11 - #include <d3d9.h> -+#else - #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 d1d234b..21ad223 100644 ---- a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp -+++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp -@@ -11,8 +11,11 @@ - #include "libGLESv2/main.h" - #include "libGLESv2/Program.h" - #include "libGLESv2/renderer/Renderer.h" -+#ifndef ANGLE_ENABLE_D3D11 - #include "libGLESv2/renderer/Renderer9.h" -+#else - #include "libGLESv2/renderer/Renderer11.h" -+#endif - #include "libGLESv2/utilities.h" - #include "third_party/trace_event/trace_event.h" - -@@ -21,6 +24,10 @@ - #define ANGLE_ENABLE_D3D11 0 - #endif - -+#ifndef D3DERR_OUTOFVIDEOMEMORY -+#define D3DERR_OUTOFVIDEOMEMORY MAKE_HRESULT(1, 0x876, 380) -+#endif -+ - #ifdef __MINGW32__ - - #ifndef D3DCOMPILER_DLL -@@ -192,34 +199,14 @@ rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, EGLNativeDisplayT - { - rx::Renderer *renderer = NULL; - EGLint status = EGL_BAD_ALLOC; -- -- if (ANGLE_ENABLE_D3D11 || -- displayId == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE || -- displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE) -- { -- renderer = new rx::Renderer11(display, hDc); -- -- if (renderer) -- { -- status = renderer->initialize(); -- } -- -- if (status == EGL_SUCCESS) -- { -- return renderer; -- } -- else if (displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE) -- { -- return NULL; -- } -- -- // Failed to create a D3D11 renderer, try creating a D3D9 renderer -- delete renderer; -- } - -+#if ANGLE_ENABLE_D3D11 -+ renderer = new rx::Renderer11(display, hDc); -+#else - bool softwareDevice = (displayId == EGL_SOFTWARE_DISPLAY_ANGLE); - renderer = new rx::Renderer9(display, hDc, softwareDevice); -- -+#endif -+ - if (renderer) - { - status = renderer->initialize(); --- -1.8.1.msysgit.1 - diff --git a/src/angle/patches/0007-ANGLE-Fix-typedefs-for-Win64.patch b/src/angle/patches/0007-ANGLE-Fix-typedefs-for-Win64.patch deleted file mode 100644 index 5779d68e70..0000000000 --- a/src/angle/patches/0007-ANGLE-Fix-typedefs-for-Win64.patch +++ /dev/null @@ -1,38 +0,0 @@ -From 2c7319083bc7bac6faafdf29b3a1d5440abf1313 Mon Sep 17 00:00:00 2001 -From: Jonathan Liu <net147@gmail.com> -Date: Sat, 14 Sep 2013 11:32:01 +0300 -Subject: [PATCH] ANGLE: Fix typedefs for Win64 - -The long int type is incorrect for Windows 64-bit as LLP64 is used -there. - -Change-Id: Ibbe6f94bffd511ab1285020c89874021a762c2af ---- - src/3rdparty/angle/include/KHR/khrplatform.h | 7 +++++++ - 1 file changed, 7 insertions(+) - -diff --git a/src/3rdparty/angle/include/KHR/khrplatform.h b/src/3rdparty/angle/include/KHR/khrplatform.h -index 541bfa9..001e925 100644 ---- a/src/3rdparty/angle/include/KHR/khrplatform.h -+++ b/src/3rdparty/angle/include/KHR/khrplatform.h -@@ -221,10 +221,17 @@ typedef signed char khronos_int8_t; - typedef unsigned char khronos_uint8_t; - typedef signed short int khronos_int16_t; - typedef unsigned short int khronos_uint16_t; -+#ifdef _WIN64 -+typedef signed long long int khronos_intptr_t; -+typedef unsigned long long int khronos_uintptr_t; -+typedef signed long long int khronos_ssize_t; -+typedef unsigned long long int khronos_usize_t; -+#else - typedef signed long int khronos_intptr_t; - typedef unsigned long int khronos_uintptr_t; - typedef signed long int khronos_ssize_t; - typedef unsigned long int khronos_usize_t; -+#endif - - #if KHRONOS_SUPPORT_FLOAT - /* --- -1.8.1.msysgit.1 - diff --git a/src/angle/patches/0007-Make-DX9-DX11-mutually-exclusive.patch b/src/angle/patches/0007-Make-DX9-DX11-mutually-exclusive.patch new file mode 100644 index 0000000000..25a2f12847 --- /dev/null +++ b/src/angle/patches/0007-Make-DX9-DX11-mutually-exclusive.patch @@ -0,0 +1,141 @@ +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-DX11-Prevent-assert-when-view-is-minimized-or-.patch b/src/angle/patches/0008-ANGLE-DX11-Prevent-assert-when-view-is-minimized-or-.patch deleted file mode 100644 index 10b36c2096..0000000000 --- a/src/angle/patches/0008-ANGLE-DX11-Prevent-assert-when-view-is-minimized-or-.patch +++ /dev/null @@ -1,58 +0,0 @@ -From 6f4600a842bbc7438c8d330305de82b960598ad3 Mon Sep 17 00:00:00 2001 -From: Andrew Knight <andrew.knight@digia.com> -Date: Sun, 15 Sep 2013 00:18:44 +0300 -Subject: [PATCH] ANGLE DX11: Prevent assert when view is minimized or size - goes to 0x0 - -This allows the Direct3D 11 version of ANGLE to gracefully allow -surfaces with dimensions of 0. This is important because Qt may resize -the surface to 0x0 because of window minimization or other user -action (window resize). As EGL specifies that empty (0x0) surfaces are -valid, this makes sure an assert doesn't occur in the case that a valid -surface is resized to an empty one. - -Change-Id: Ia60c4c694090d03c1da7f43c56e90b925c8eab6d ---- - src/3rdparty/angle/src/libEGL/Surface.cpp | 9 ++++++++- - src/3rdparty/angle/src/libGLESv2/renderer/SwapChain11.cpp | 3 +++ - 2 files changed, 11 insertions(+), 1 deletion(-) - -diff --git a/src/3rdparty/angle/src/libEGL/Surface.cpp b/src/3rdparty/angle/src/libEGL/Surface.cpp -index 311790c..b47a7bc 100644 ---- a/src/3rdparty/angle/src/libEGL/Surface.cpp -+++ b/src/3rdparty/angle/src/libEGL/Surface.cpp -@@ -135,9 +135,16 @@ bool Surface::resetSwapChain() - - bool Surface::resizeSwapChain(int backbufferWidth, int backbufferHeight) - { -- ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0); - ASSERT(mSwapChain); - -+ // Prevent bad swap chain resize by calling reset if size is invalid -+ if (backbufferWidth < 1 || backbufferHeight < 1) -+ { -+ mWidth = backbufferWidth; -+ mHeight = backbufferHeight; -+ return mSwapChain->reset(0, 0, mSwapInterval) == EGL_SUCCESS; -+ } -+ - EGLint status = mSwapChain->resize(backbufferWidth, backbufferHeight); - - if (status == EGL_CONTEXT_LOST) -diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain11.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain11.cpp -index a50db3b..0da58cb 100644 ---- a/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain11.cpp -+++ b/src/3rdparty/angle/src/libGLESv2/renderer/SwapChain11.cpp -@@ -369,6 +369,9 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight) - return EGL_BAD_ACCESS; - } - -+ if (!mSwapChain) -+ reset(backbufferWidth, backbufferHeight, mSwapInterval); -+ - // Can only call resize if we have already created our swap buffer and resources - ASSERT(mSwapChain && mBackBufferTexture && mBackBufferRTView); - --- -1.8.1.msysgit.1 - 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-of-k.patch new file mode 100644 index 0000000000..c7cfafc246 --- /dev/null +++ b/src/angle/patches/0008-ANGLE-Dynamically-load-D3D-compiler-from-a-list-of-k.patch @@ -0,0 +1,73 @@ +From 0fede57f6fc052942b910995fdfa4cd76a32f586 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 + environment + +If the default compiler cannot be found, load it from a list of DLL names, +including a non-versioned proxy DLL provided by Qt. On Desktop Windows, +the default compiler can also be specified by an environment variable, +QT_D3DCOMPILER_DLL. + +Change-Id: I0d7a8a8a36cc571836f8fa59ea14513b9b19c19b +--- + .../angle/src/libGLESv2/renderer/Renderer.cpp | 34 ++++++++++++++++++++-- + 1 file changed, 32 insertions(+), 2 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 + + #endif // __MINGW32__ + ++#ifndef QT_D3DCOMPILER_DLL ++#define QT_D3DCOMPILER_DLL D3DCOMPILER_DLL ++#endif ++ + namespace rx + { + +@@ -77,10 +81,36 @@ bool Renderer::initializeCompiler() + } + #endif // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES + +- 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, ++ L"d3dcompiler_47.dll", ++ L"d3dcompiler_46.dll", ++ L"d3dcompiler_45.dll", ++ L"d3dcompiler_44.dll", ++ L"d3dcompiler_43.dll", ++ 0 ++ }; ++ ++ // 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); ++ mD3dCompilerModule = LoadLibrary(compilerDlls[i]); ++ if (mD3dCompilerModule) ++ break; + } + + if (!mD3dCompilerModule) +-- +1.8.4.msysgit.0 + diff --git a/src/angle/patches/0009-ANGLE-Support-WinRT.patch b/src/angle/patches/0009-ANGLE-Support-WinRT.patch new file mode 100644 index 0000000000..92909d37d8 --- /dev/null +++ b/src/angle/patches/0009-ANGLE-Support-WinRT.patch @@ -0,0 +1,1210 @@ +From 46b8b123ada1787c68525cd07dcdbfdbc003bcc5 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 + +This enables EGL for WinRT's native types, and adjusts some codepaths +to accommodate differences between desktop Windows and WinRT. + +- WinRT native handles added to eglplatform.h +- References to native handles in libEGL/libGLESv2 follow eglplatform.h +- D3D 11.1 structures and methods used when necessary +- TLS replaced with thread attribute +- LocalAlloc/Free replaced with Heap API + +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 + +diff --git a/src/3rdparty/angle/include/EGL/eglplatform.h b/src/3rdparty/angle/include/EGL/eglplatform.h +index 34283f2..eb15ae5 100644 +--- a/src/3rdparty/angle/include/EGL/eglplatform.h ++++ b/src/3rdparty/angle/include/EGL/eglplatform.h +@@ -67,7 +67,15 @@ + * implementations. + */ + +-#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 */ ++ ++struct IUnknown; ++ ++typedef int EGLNativeDisplayType; ++typedef void *EGLNativePixmapType; ++typedef IUnknown *EGLNativeWindowType; ++ ++#elif defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */ + #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 @@ + // + + #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 ++#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) + { + 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() + } + + ++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() ++{ ++ if (!tls) ++ tls = new std::vector<void*>; ++ ++ if (freeIndices && !freeIndices->empty()) { ++ OS_TLSIndex 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); ++ ++ return tls->at(nIndex); ++} ++ ++ ++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; ++ } ++ ++ tls->at(nIndex) = lpvValue; ++ return true; ++} ++ ++ ++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; ++ } ++ ++ if (!freeIndices) ++ freeIndices = new std::vector<OS_TLSIndex>; ++ ++ freeIndices->push_back(nIndex); ++ ++ return true; ++} +diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp +index a7f5f5a..e75a4b6 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; + } + +-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; + } + +- mRenderer = glCreateRenderer(this, mDc, mDisplayId); ++ mRenderer = glCreateRenderer(this, mDisplayId); + + if (!mRenderer) + { +@@ -186,7 +187,7 @@ bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value) + + + +-EGLSurface Display::createWindowSurface(HWND window, EGLConfig config, const EGLint *attribList) ++EGLSurface Display::createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList) + { + const Config *configuration = mConfigSet.get(config); + EGLint postSubBufferSupported = EGL_FALSE; +@@ -456,7 +457,7 @@ bool Display::isValidSurface(egl::Surface *surface) + return mSurfaceSet.find(surface) != mSurfaceSet.end(); + } + +-bool Display::hasExistingWindowSurface(HWND window) ++bool Display::hasExistingWindowSurface(EGLNativeWindowType window) + { + 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 +--- a/src/3rdparty/angle/src/libEGL/Display.h ++++ b/src/3rdparty/angle/src/libEGL/Display.h +@@ -38,7 +38,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); + +@@ -49,7 +49,7 @@ class Display + bool isValidConfig(EGLConfig config); + bool isValidContext(gl::Context *context); + bool isValidSurface(egl::Surface *surface); +- bool hasExistingWindowSurface(HWND window); ++ bool hasExistingWindowSurface(EGLNativeWindowType window); + + rx::Renderer *getRenderer() { return mRenderer; }; + +@@ -63,12 +63,11 @@ class Display + 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 +--- 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 @@ + #include "libEGL/main.h" + #include "libEGL/Display.h" + ++#if defined(ANGLE_OS_WINRT) ++#include <windows.foundation.h> ++#include <windows.ui.core.h> ++#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) + : mDisplay(display), mConfig(config), mWindow(window), mPostSubBufferSupported(postSubBufferSupported) + { + mRenderer = mDisplay->getRenderer(); +@@ -98,6 +104,7 @@ bool Surface::resetSwapChain() + + if (mWindow) + { ++#if !defined(ANGLE_OS_WINRT) + RECT windowRect; + if (!GetClientRect(getWindowHandle(), &windowRect)) + { +@@ -109,6 +116,16 @@ 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)) ++ return false; ++ window->get_Bounds(&windowRect); ++ width = windowRect.Width; ++ height = windowRect.Height; ++#endif + } + else + { +@@ -221,7 +238,7 @@ bool Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height) + return true; + } + +-HWND Surface::getWindowHandle() ++EGLNativeWindowType Surface::getWindowHandle() + { + return mWindow; + } +@@ -230,6 +247,7 @@ HWND Surface::getWindowHandle() + #define kSurfaceProperty _TEXT("Egl::SurfaceOwner") + #define kParentWndProc _TEXT("Egl::SurfaceParentWndProc") + ++#if !defined(ANGLE_OS_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 + WNDPROC prevWndFunc = reinterpret_cast<WNDPROC >(GetProp(hwnd, kParentWndProc)); + return CallWindowProc(prevWndFunc, hwnd, message, wparam, lparam); + } ++#endif + + void Surface::subclassWindow() + { ++#if defined(ANGLE_OS_WINRT) ++ mWindowSubclassed = false; ++#else + if (!mWindow) + { + return; +@@ -269,10 +291,12 @@ void Surface::subclassWindow() + SetProp(mWindow, kSurfaceProperty, reinterpret_cast<HANDLE>(this)); + SetProp(mWindow, kParentWndProc, reinterpret_cast<HANDLE>(oldWndProc)); + mWindowSubclassed = true; ++#endif + } + + void Surface::unsubclassWindow() + { ++#if !defined(ANGLE_OS_WINRT) + if(!mWindowSubclassed) + { + return; +@@ -295,10 +319,12 @@ void Surface::unsubclassWindow() + RemoveProp(mWindow, kSurfaceProperty); + RemoveProp(mWindow, kParentWndProc); + mWindowSubclassed = false; ++#endif + } + + 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())) + { + // 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; + } ++#endif + + bool wasDirty = (mSwapIntervalDirty || sizeDirty); + +diff --git a/src/3rdparty/angle/src/libEGL/Surface.h b/src/3rdparty/angle/src/libEGL/Surface.h +index 938b800..1d2303c 100644 +--- a/src/3rdparty/angle/src/libEGL/Surface.h ++++ b/src/3rdparty/angle/src/libEGL/Surface.h +@@ -34,7 +34,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, HANDLE shareHandle, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureTarget); + + ~Surface(); +@@ -43,7 +43,7 @@ class Surface + void release(); + bool resetSwapChain(); + +- HWND getWindowHandle(); ++ EGLNativeWindowType getWindowHandle(); + bool swap(); + bool postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height); + +@@ -79,7 +79,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. + 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 +diff --git a/src/3rdparty/angle/src/libEGL/libEGL.cpp b/src/3rdparty/angle/src/libEGL/libEGL.cpp +index 0ea46d4..b2944d5 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; + } + ++#if !defined(ANGLE_OS_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); + } + catch(std::bad_alloc&) + { +diff --git a/src/3rdparty/angle/src/libEGL/main.cpp b/src/3rdparty/angle/src/libEGL/main.cpp +index 772b8eb..e972691 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 @@ + + #include "common/debug.h" + ++#if !defined(ANGLE_OS_WINRT) + static DWORD currentTLS = TLS_OUT_OF_INDEXES; ++#else ++static __declspec(thread) void *currentTLS = 0; ++#endif + + 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; ++#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() + + void DeallocateCurrent() + { ++#if !defined(ANGLE_OS_WINRT) + void *current = TlsGetValue(currentTLS); + + if (current) + { + LocalFree((HLOCAL)current); + } ++#else ++ if (currentTLS) ++ { ++ HeapFree(GetProcessHeap(), 0, currentTLS); ++ currentTLS = 0; ++ } ++#endif + } + + } +@@ -69,13 +89,14 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved + } + } + #endif +- ++#if !defined(ANGLE_OS_WINRT) + currentTLS = TlsAlloc(); + + 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 + case DLL_PROCESS_DETACH: + { + egl::DeallocateCurrent(); ++#if !defined(ANGLE_OS_WINRT) + TlsFree(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 +--- a/src/3rdparty/angle/src/libGLESv2/main.cpp ++++ b/src/3rdparty/angle/src/libGLESv2/main.cpp +@@ -11,14 +11,23 @@ + + #include "libGLESv2/Context.h" + ++#if !defined(ANGLE_OS_WINRT) + static DWORD currentTLS = TLS_OUT_OF_INDEXES; ++#else ++static __declspec(thread) void *currentTLS = 0; ++#endif + + 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; ++#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() + + void DeallocateCurrent() + { ++#if !defined(ANGLE_OS_WINRT) + void *current = TlsGetValue(currentTLS); + + if (current) + { + LocalFree((HLOCAL)current); + } ++#else ++ if (currentTLS) ++ { ++ HeapFree(GetProcessHeap(), 0, currentTLS); ++ currentTLS = 0; ++ } ++#endif + } + + } +@@ -53,12 +72,14 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved + { + case DLL_PROCESS_ATTACH: + { ++#if !defined(ANGLE_OS_WINRT) + currentTLS = TlsAlloc(); + + 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 + case DLL_PROCESS_DETACH: + { + gl::DeallocateCurrent(); ++#if !defined(ANGLE_OS_WINRT) + TlsFree(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 +--- 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 + +-#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; ++#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) + { +diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.h +index 7244a0a..79578b2 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 + + 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 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 +--- 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 + class SwapChain + { + public: +- SwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) ++ SwapChain(EGLNativeWindowType window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) + : mWindow(window), mShareHandle(shareHandle), mBackBufferFormat(backBufferFormat), mDepthBufferFormat(depthBufferFormat) + { + } +@@ -37,7 +38,7 @@ class SwapChain + 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 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 + }; + +-Renderer11::Renderer11(egl::Display *display, HDC hDc) : Renderer(display), mDc(hDc) ++Renderer11::Renderer11(egl::Display *display) : Renderer(display) + { + mVertexDataManager = NULL; + mIndexDataManager = NULL; +@@ -137,6 +137,7 @@ EGLint Renderer11::initialize() + return EGL_NOT_INITIALIZED; + } + ++#if !defined(ANGLE_OS_WINRT) + mDxgiModule = LoadLibrary(TEXT("dxgi.dll")); + mD3d11Module = LoadLibrary(TEXT("d3d11.dll")); + +@@ -146,6 +147,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() + ERR("Could not retrieve D3D11CreateDevice address - aborting!\n"); + return EGL_NOT_INITIALIZED; + } ++#endif + + D3D_FEATURE_LEVEL featureLevels[] = + { +@@ -203,8 +206,12 @@ EGLint Renderer11::initialize() + } + } + ++#if !defined(ANGLE_OS_WINRT) + IDXGIDevice *dxgiDevice = NULL; +- result = mDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); ++#else ++ IDXGIDevice1 *dxgiDevice = NULL; ++#endif ++ result = mDevice->QueryInterface(IID_PPV_ARGS(&dxgiDevice)); + + if (FAILED(result)) + { +@@ -522,7 +529,7 @@ void Renderer11::sync(bool block) + } + } + +-SwapChain *Renderer11::createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) ++SwapChain *Renderer11::createSwapChain(EGLNativeWindowType window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) + { + 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 + + 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 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 + + 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 @@ + namespace rx + { + +-SwapChain11::SwapChain11(Renderer11 *renderer, HWND window, HANDLE shareHandle, ++SwapChain11::SwapChain11(Renderer11 *renderer, EGLNativeWindowType window, HANDLE shareHandle, + GLenum backBufferFormat, GLenum depthBufferFormat) + : mRenderer(renderer), SwapChain(window, shareHandle, backBufferFormat, depthBufferFormat) + { +@@ -361,25 +361,50 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap + + if (mWindow) + { ++#if !defined(ANGLE_OS_WINRT) + IDXGIFactory *factory = mRenderer->getDxgiFactory(); + + 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; ++#else ++ IDXGIFactory2 *factory; ++ HRESULT result = mRenderer->getDxgiFactory()->QueryInterface(IID_PPV_ARGS(&factory)); ++ ASSERT(SUCCEEDED(result)); ++ ++ DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0}; ++ swapChainDesc.Format = gl_d3d11::ConvertRenderbufferFormat(mBackBufferFormat); ++ swapChainDesc.Width = backbufferWidth; ++ swapChainDesc.Height = backbufferHeight; ++ swapChainDesc.Stereo = FALSE; ++#if !defined(ANGLE_OS_WINPHONE) ++ swapChainDesc.BufferCount = 2; ++ swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; ++#else ++ 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); ++ mSwapChain = swapChain; ++#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 + } + + 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; + class SwapChain11 : public SwapChain + { + public: +- SwapChain11(Renderer11 *renderer, HWND window, HANDLE shareHandle, ++ SwapChain11(Renderer11 *renderer, EGLNativeWindowType window, HANDLE shareHandle, + 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; + } + +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 + { +@@ -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; + } +-- +1.8.4.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 new file mode 100644 index 0000000000..34c881ba21 --- /dev/null +++ b/src/angle/patches/0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch @@ -0,0 +1,426 @@ +From e84f947df4ae095eae600550749b3a4e8de5ee8b 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 + +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(-) + +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) + { + 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); + 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 + } + } + +-} +\ 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() + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_1, + D3D_FEATURE_LEVEL_10_0, ++#if !defined(ANGLE_ENABLE_D3D9) ++ D3D_FEATURE_LEVEL_9_3, ++ D3D_FEATURE_LEVEL_9_2, ++ D3D_FEATURE_LEVEL_9_1, ++#endif + }; + + HRESULT result = S_OK; +@@ -1533,7 +1538,7 @@ void Renderer11::applyUniforms(gl::ProgramBinary *programBinary, gl::UniformArra + } + + // needed for the point sprite geometry shader +- if (mCurrentGeometryConstantBuffer != mDriverConstantBufferPS) ++ if (mFeatureLevel >= D3D_FEATURE_LEVEL_10_0 && mCurrentGeometryConstantBuffer != mDriverConstantBufferPS) + { + mDeviceContext->GSSetConstantBuffers(0, 1, &mDriverConstantBufferPS); + mCurrentGeometryConstantBuffer = mDriverConstantBufferPS; +@@ -1956,6 +1961,11 @@ bool Renderer11::testDeviceResettable() + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_1, + D3D_FEATURE_LEVEL_10_0, ++#if !defined(ANGLE_ENABLE_D3D9) ++ D3D_FEATURE_LEVEL_9_3, ++ D3D_FEATURE_LEVEL_9_2, ++ D3D_FEATURE_LEVEL_9_1, ++#endif + }; + + 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 + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return MAX_TEXTURE_IMAGE_UNITS_VTF_SM4; ++ case D3D_FEATURE_LEVEL_9_3: ++ case D3D_FEATURE_LEVEL_9_2: ++ case D3D_FEATURE_LEVEL_9_1: ++ return 0; + default: UNREACHABLE(); + return 0; + } +@@ -2195,14 +2219,14 @@ unsigned int Renderer11::getReservedFragmentUniformVectors() const + unsigned int Renderer11::getMaxVertexUniformVectors() const + { + META_ASSERT(MAX_VERTEX_UNIFORM_VECTORS_D3D11 <= D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT); +- ASSERT(mFeatureLevel >= D3D_FEATURE_LEVEL_10_0); ++ ASSERT(mFeatureLevel >= D3D_FEATURE_LEVEL_9_1); + return MAX_VERTEX_UNIFORM_VECTORS_D3D11; + } + + unsigned int Renderer11::getMaxFragmentUniformVectors() const + { + META_ASSERT(MAX_FRAGMENT_UNIFORM_VECTORS_D3D11 <= D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT); +- ASSERT(mFeatureLevel >= D3D_FEATURE_LEVEL_10_0); ++ ASSERT(mFeatureLevel >= D3D_FEATURE_LEVEL_9_1); + return MAX_FRAGMENT_UNIFORM_VECTORS_D3D11; + } + +@@ -2216,6 +2240,10 @@ unsigned int Renderer11::getMaxVaryingVectors() const + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_VS_OUTPUT_REGISTER_COUNT; ++ case D3D_FEATURE_LEVEL_9_3: ++ case D3D_FEATURE_LEVEL_9_2: ++ case D3D_FEATURE_LEVEL_9_1: ++ return 8; + default: UNREACHABLE(); + return 0; + } +@@ -2229,6 +2257,10 @@ bool Renderer11::getNonPower2TextureSupport() const + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 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; + } +@@ -2242,6 +2274,11 @@ bool Renderer11::getOcclusionQuerySupport() const + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; ++ case D3D_FEATURE_LEVEL_9_3: ++ case D3D_FEATURE_LEVEL_9_2: ++ return true; ++ case D3D_FEATURE_LEVEL_9_1: ++ return false; + default: UNREACHABLE(); + return false; + } +@@ -2254,7 +2291,11 @@ bool Renderer11::getInstancingSupport() const + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: +- return true; ++ case D3D_FEATURE_LEVEL_9_3: ++ return true; ++ case D3D_FEATURE_LEVEL_9_2: ++ case D3D_FEATURE_LEVEL_9_1: ++ return false; + default: UNREACHABLE(); + return false; + } +@@ -2276,6 +2317,11 @@ bool Renderer11::getDerivativeInstructionSupport() const + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; ++ case D3D_FEATURE_LEVEL_9_3: ++ return true; ++ case D3D_FEATURE_LEVEL_9_2: ++ case D3D_FEATURE_LEVEL_9_1: ++ return false; + default: UNREACHABLE(); + return false; + } +@@ -2294,6 +2340,9 @@ 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_9_3: ++ case D3D_FEATURE_LEVEL_9_2: ++ case D3D_FEATURE_LEVEL_9_1: return D3D10_SHADER_MAJOR_VERSION; // 4 (level 9) + default: UNREACHABLE(); return 0; + } + } +@@ -2305,6 +2354,9 @@ 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_9_3: ++ case D3D_FEATURE_LEVEL_9_2: ++ case D3D_FEATURE_LEVEL_9_1: return D3D10_SHADER_MINOR_VERSION; // 0 (level 9) + 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 ++ 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; + } +@@ -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 + 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 + 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) + } + + 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 + } + } + +- 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; + } + +-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); + } + + namespace d3d11_gl +-- +1.8.4.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 new file mode 100644 index 0000000000..fdee11d324 --- /dev/null +++ b/src/angle/patches/0011-ANGLE-Fix-compilation-error-on-MinGW-caused-by-trace.patch @@ -0,0 +1,37 @@ +From 8ea24fcce69900f42299fd01772714a566f9111e 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 + +The event trace header in ANGLE's third_party directory has an unused +template which causes a compilation error on MinGW. Disable this part +of the code. + +Change-Id: I167eac56507fafba34e3eb5ce6071d8f136a4e41 +--- + src/3rdparty/angle/src/third_party/trace_event/trace_event.h | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/src/3rdparty/angle/src/third_party/trace_event/trace_event.h b/src/3rdparty/angle/src/third_party/trace_event/trace_event.h +index 637cf9a..96ac910 100644 +--- a/src/3rdparty/angle/src/third_party/trace_event/trace_event.h ++++ b/src/3rdparty/angle/src/third_party/trace_event/trace_event.h +@@ -791,6 +791,7 @@ private: + // TraceEventSamplingStateScope records the current sampling state + // and sets a new sampling state. When the scope exists, it restores + // the sampling state having recorded. ++#if 0 // This is not used by ANGLE and causes a compilation error on MinGW + template<size_t BucketNumber> + class SamplingStateScope { + public: +@@ -818,6 +819,7 @@ public: + private: + const char* m_previousState; + }; ++#endif + + } // namespace TraceEvent + +-- +1.8.4.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 new file mode 100644 index 0000000000..fe16d1d7b2 --- /dev/null +++ b/src/angle/patches/0012-ANGLE-fix-semantic-index-lookup.patch @@ -0,0 +1,48 @@ +From 15b694fa33cf76f93de62b8106972083f5fb3114 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 + +The sorted semantic index table was returning a direct mapping to the +new indices, instead of the old indices. This caused a mismatch in the +GL type lookup for the translated attribute. + +Change-Id: I75d05ed707f56c45210e3dcbc277f894e3dc5a48 +--- + src/3rdparty/angle/src/libGLESv2/ProgramBinary.cpp | 2 +- + src/3rdparty/angle/src/libGLESv2/renderer/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 +--- 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 + for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++) + { + int oldIndex = mAttributesByLayout[i]; +- sortedSemanticIndices[i] = mSemanticIndex[oldIndex]; ++ sortedSemanticIndices[i] = oldIndex; + 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 + // 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; +- programBinary->getActiveAttribute(ilKey.elementCount, 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL); ++ programBinary->getActiveAttribute(sortedSemanticIndices[i], 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL); + + 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.InputSlot = i; + ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = 0; +-- +1.8.4.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 new file mode 100644 index 0000000000..11c32880df --- /dev/null +++ b/src/angle/patches/0013-ANGLE-Allow-for-universal-program-binaries.patch @@ -0,0 +1,93 @@ +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/src/common/common.pri b/src/angle/src/common/common.pri index 514c80dbd1..58ad88673a 100644 --- a/src/angle/src/common/common.pri +++ b/src/angle/src/common/common.pri @@ -7,7 +7,7 @@ INCLUDEPATH += \ LIBS_PRIVATE = $$QMAKE_LIBS_CORE $$QMAKE_LIBS_GUI # DirectX is included in the Windows 8 Kit, but everything else requires the DX SDK. -win32-msvc2012|win32-msvc2013 { +win32-msvc2012|win32-msvc2013|winrt { FXC = fxc.exe } else { DX_DIR = $$(DXSDK_DIR) diff --git a/src/angle/src/compiler/compiler.pro b/src/angle/src/compiler/compiler.pro index 26b03bfc86..7f3f3e301e 100644 --- a/src/angle/src/compiler/compiler.pro +++ b/src/angle/src/compiler/compiler.pro @@ -1,3 +1,3 @@ TEMPLATE = subdirs CONFIG += ordered -SUBDIRS = preprocessor translator_common.pro translator_hlsl.pro +SUBDIRS = preprocessor translator.pro diff --git a/src/angle/src/compiler/preprocessor/preprocessor.pro b/src/angle/src/compiler/preprocessor/preprocessor.pro index 432c8dcf32..74cd97c5a4 100644 --- a/src/angle/src/compiler/preprocessor/preprocessor.pro +++ b/src/angle/src/compiler/preprocessor/preprocessor.pro @@ -21,6 +21,7 @@ HEADERS += \ $$ANGLE_DIR/src/compiler/preprocessor/DirectiveParser.h \ $$ANGLE_DIR/src/compiler/preprocessor/ExpressionParser.h \ $$ANGLE_DIR/src/compiler/preprocessor/Input.h \ + $$ANGLE_DIR/src/compiler/preprocessor/length_limits.h \ $$ANGLE_DIR/src/compiler/preprocessor/Lexer.h \ $$ANGLE_DIR/src/compiler/preprocessor/Macro.h \ $$ANGLE_DIR/src/compiler/preprocessor/MacroExpander.h \ diff --git a/src/angle/src/compiler/translator.pro b/src/angle/src/compiler/translator.pro new file mode 100644 index 0000000000..0051486f82 --- /dev/null +++ b/src/angle/src/compiler/translator.pro @@ -0,0 +1,163 @@ +TEMPLATE = lib +CONFIG += static +TARGET = $$qtLibraryTarget(translator) + +include(../config.pri) + +# Mingw 4.7 chokes on implicit move semantics, so disable C++11 here +mingw: CONFIG -= c++11 + +INCLUDEPATH += \ + $$ANGLE_DIR/src \ + $$ANGLE_DIR/include + +DEFINES += _SECURE_SCL=0 _LIB COMPILER_IMPLEMENTATION + +FLEX_SOURCES = $$ANGLE_DIR/src/compiler/translator/glslang.l +BISON_SOURCES = $$ANGLE_DIR/src/compiler/translator/glslang.y + +HEADERS += \ + $$ANGLE_DIR/include/GLSLANG/ResourceLimits.h \ + $$ANGLE_DIR/include/GLSLANG/ShaderLang.h \ + $$ANGLE_DIR/src/compiler/translator/BaseTypes.h \ + $$ANGLE_DIR/src/compiler/translator/BuiltInFunctionEmulator.h \ + $$ANGLE_DIR/src/compiler/translator/Common.h \ + $$ANGLE_DIR/src/compiler/translator/compilerdebug.h \ + $$ANGLE_DIR/src/compiler/translator/ConstantUnion.h \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraph.h \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraphBuilder.h \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraphOutput.h \ + $$ANGLE_DIR/src/compiler/translator/DetectCallDepth.h \ + $$ANGLE_DIR/src/compiler/translator/DetectDiscontinuity.h \ + $$ANGLE_DIR/src/compiler/translator/Diagnostics.h \ + $$ANGLE_DIR/src/compiler/translator/DirectiveHandler.h \ + $$ANGLE_DIR/src/compiler/translator/ExtensionBehavior.h \ + $$ANGLE_DIR/src/compiler/translator/ForLoopUnroll.h \ + $$ANGLE_DIR/src/compiler/translator/HashNames.h \ + $$ANGLE_DIR/src/compiler/translator/InfoSink.h \ + $$ANGLE_DIR/src/compiler/translator/Initialize.h \ + $$ANGLE_DIR/src/compiler/translator/InitializeDll.h \ + $$ANGLE_DIR/src/compiler/translator/InitializeParseContext.h \ + $$ANGLE_DIR/src/compiler/translator/InitializeVariables.h \ + $$ANGLE_DIR/src/compiler/translator/intermediate.h \ + $$ANGLE_DIR/src/compiler/translator/localintermediate.h \ + $$ANGLE_DIR/src/compiler/translator/MapLongVariableNames.h \ + $$ANGLE_DIR/src/compiler/translator/MMap.h \ + $$ANGLE_DIR/src/compiler/translator/NodeSearch.h \ + $$ANGLE_DIR/src/compiler/translator/osinclude.h \ + $$ANGLE_DIR/src/compiler/translator/OutputESSL.h \ + $$ANGLE_DIR/src/compiler/translator/OutputGLSL.h \ + $$ANGLE_DIR/src/compiler/translator/OutputGLSLBase.h \ + $$ANGLE_DIR/src/compiler/translator/OutputHLSL.h \ + $$ANGLE_DIR/src/compiler/translator/ParseContext.h \ + $$ANGLE_DIR/src/compiler/translator/PoolAlloc.h \ + $$ANGLE_DIR/src/compiler/translator/Pragma.h \ + $$ANGLE_DIR/src/compiler/translator/QualifierAlive.h \ + $$ANGLE_DIR/src/compiler/translator/RemoveTree.h \ + $$ANGLE_DIR/src/compiler/translator/RenameFunction.h \ + $$ANGLE_DIR/src/compiler/translator/RewriteElseBlocks.h \ + $$ANGLE_DIR/src/compiler/translator/SearchSymbol.h \ + $$ANGLE_DIR/src/compiler/translator/ShHandle.h \ + $$ANGLE_DIR/src/compiler/translator/SymbolTable.h \ + $$ANGLE_DIR/src/compiler/translator/timing/RestrictFragmentShaderTiming.h \ + $$ANGLE_DIR/src/compiler/translator/timing/RestrictVertexShaderTiming.h \ + $$ANGLE_DIR/src/compiler/translator/TranslatorESSL.h \ + $$ANGLE_DIR/src/compiler/translator/TranslatorGLSL.h \ + $$ANGLE_DIR/src/compiler/translator/TranslatorHLSL.h \ + $$ANGLE_DIR/src/compiler/translator/Types.h \ + $$ANGLE_DIR/src/compiler/translator/UnfoldShortCircuit.h \ + $$ANGLE_DIR/src/compiler/translator/UnfoldShortCircuitAST.h \ + $$ANGLE_DIR/src/compiler/translator/Uniform.h \ + $$ANGLE_DIR/src/compiler/translator/util.h \ + $$ANGLE_DIR/src/compiler/translator/ValidateLimitations.h \ + $$ANGLE_DIR/src/compiler/translator/VariableInfo.h \ + $$ANGLE_DIR/src/compiler/translator/VariablePacker.h \ + $$ANGLE_DIR/src/compiler/translator/VersionGLSL.h \ + $$ANGLE_DIR/src/third_party/compiler/ArrayBoundsClamper.h + + +SOURCES += \ + $$ANGLE_DIR/src/compiler/translator/BuiltInFunctionEmulator.cpp \ + $$ANGLE_DIR/src/compiler/translator/CodeGen.cpp \ + $$ANGLE_DIR/src/compiler/translator/Compiler.cpp \ + $$ANGLE_DIR/src/compiler/translator/compilerdebug.cpp \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraph.cpp \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraphBuilder.cpp \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraphOutput.cpp \ + $$ANGLE_DIR/src/compiler/translator/depgraph/DependencyGraphTraverse.cpp \ + $$ANGLE_DIR/src/compiler/translator/DetectCallDepth.cpp \ + $$ANGLE_DIR/src/compiler/translator/DetectDiscontinuity.cpp \ + $$ANGLE_DIR/src/compiler/translator/Diagnostics.cpp \ + $$ANGLE_DIR/src/compiler/translator/DirectiveHandler.cpp \ + $$ANGLE_DIR/src/compiler/translator/ForLoopUnroll.cpp \ + $$ANGLE_DIR/src/compiler/translator/InfoSink.cpp \ + $$ANGLE_DIR/src/compiler/translator/Initialize.cpp \ + $$ANGLE_DIR/src/compiler/translator/InitializeDll.cpp \ + $$ANGLE_DIR/src/compiler/translator/InitializeParseContext.cpp \ + $$ANGLE_DIR/src/compiler/translator/InitializeVariables.cpp \ + $$ANGLE_DIR/src/compiler/translator/Intermediate.cpp \ + $$ANGLE_DIR/src/compiler/translator/intermOut.cpp \ + $$ANGLE_DIR/src/compiler/translator/IntermTraverse.cpp \ + $$ANGLE_DIR/src/compiler/translator/MapLongVariableNames.cpp \ + $$ANGLE_DIR/src/compiler/translator/OutputESSL.cpp \ + $$ANGLE_DIR/src/compiler/translator/OutputGLSL.cpp \ + $$ANGLE_DIR/src/compiler/translator/OutputGLSLBase.cpp \ + $$ANGLE_DIR/src/compiler/translator/OutputHLSL.cpp \ + $$ANGLE_DIR/src/compiler/translator/parseConst.cpp \ + $$ANGLE_DIR/src/compiler/translator/ParseContext.cpp \ + $$ANGLE_DIR/src/compiler/translator/PoolAlloc.cpp \ + $$ANGLE_DIR/src/compiler/translator/QualifierAlive.cpp \ + $$ANGLE_DIR/src/compiler/translator/RemoveTree.cpp \ + $$ANGLE_DIR/src/compiler/translator/RewriteElseBlocks.cpp \ + $$ANGLE_DIR/src/compiler/translator/SearchSymbol.cpp \ + $$ANGLE_DIR/src/compiler/translator/ShaderLang.cpp \ + $$ANGLE_DIR/src/compiler/translator/SymbolTable.cpp \ + $$ANGLE_DIR/src/compiler/translator/timing/RestrictFragmentShaderTiming.cpp \ + $$ANGLE_DIR/src/compiler/translator/timing/RestrictVertexShaderTiming.cpp \ + $$ANGLE_DIR/src/compiler/translator/TranslatorESSL.cpp \ + $$ANGLE_DIR/src/compiler/translator/TranslatorGLSL.cpp \ + $$ANGLE_DIR/src/compiler/translator/TranslatorHLSL.cpp \ + $$ANGLE_DIR/src/compiler/translator/UnfoldShortCircuit.cpp \ + $$ANGLE_DIR/src/compiler/translator/UnfoldShortCircuitAST.cpp \ + $$ANGLE_DIR/src/compiler/translator/Uniform.cpp \ + $$ANGLE_DIR/src/compiler/translator/util.cpp \ + $$ANGLE_DIR/src/compiler/translator/ValidateLimitations.cpp \ + $$ANGLE_DIR/src/compiler/translator/VariableInfo.cpp \ + $$ANGLE_DIR/src/compiler/translator/VariablePacker.cpp \ + $$ANGLE_DIR/src/compiler/translator/VersionGLSL.cpp \ + $$ANGLE_DIR/src/third_party/compiler/ArrayBoundsClamper.cpp + + +winrt { + SOURCES += $$ANGLE_DIR/src/compiler/translator/ossource_winrt.cpp +} else { + SOURCES += $$ANGLE_DIR/src/compiler/translator/ossource_win.cpp +} + +# NOTE: 'win_flex' and 'bison' can be found in qt5/gnuwin32/bin +flex.commands = $$addGnuPath(win_flex) --noline --nounistd --outfile=${QMAKE_FILE_BASE}_lex.cpp ${QMAKE_FILE_NAME} +flex.output = ${QMAKE_FILE_BASE}_lex.cpp +flex.input = FLEX_SOURCES +flex.dependency_type = TYPE_C +flex.variable_out = GENERATED_SOURCES +QMAKE_EXTRA_COMPILERS += flex + +bison.commands = $$addGnuPath(bison) --no-lines --skeleton=yacc.c --defines=${QMAKE_FILE_BASE}_tab.h \ + --output=${QMAKE_FILE_BASE}_tab.cpp ${QMAKE_FILE_NAME} +bison.output = ${QMAKE_FILE_BASE}_tab.h +bison.input = BISON_SOURCES +bison.dependency_type = TYPE_C +bison.variable_out = GENERATED_SOURCES +QMAKE_EXTRA_COMPILERS += bison + +# This is a dummy compiler to work around the fact that an extra compiler can only +# have one output file even if the command generates two. +MAKEFILE_NOOP_COMMAND = @echo -n +msvc: MAKEFILE_NOOP_COMMAND = @echo >NUL +bison_impl.output = ${QMAKE_FILE_BASE}_tab.cpp +bison_impl.input = BISON_SOURCES +bison_impl.commands = $$MAKEFILE_NOOP_COMMAND +bison_impl.depends = ${QMAKE_FILE_BASE}_tab.h +bison_impl.output = ${QMAKE_FILE_BASE}_tab.cpp +bison_impl.variable_out = GENERATED_SOURCES +QMAKE_EXTRA_COMPILERS += bison_impl diff --git a/src/angle/src/compiler/translator_common.pro b/src/angle/src/compiler/translator_common.pro deleted file mode 100644 index b2812158e1..0000000000 --- a/src/angle/src/compiler/translator_common.pro +++ /dev/null @@ -1,128 +0,0 @@ -TEMPLATE = lib -CONFIG += static -TARGET = $$qtLibraryTarget(translator_common) - -include(../config.pri) - -# Mingw 4.7 chokes on implicit move semantics, so disable C++11 here -win32-g++*: CONFIG -= c++11 - -INCLUDEPATH += \ - $$ANGLE_DIR/src \ - $$ANGLE_DIR/include - -DEFINES += _SECURE_SCL=0 _LIB COMPILER_IMPLEMENTATION - -FLEX_SOURCES = $$ANGLE_DIR/src/compiler/glslang.l -BISON_SOURCES = $$ANGLE_DIR/src/compiler/glslang.y - -HEADERS += \ - $$ANGLE_DIR/src/compiler/BaseTypes.h \ - $$ANGLE_DIR/src/compiler/BuiltInFunctionEmulator.h \ - $$ANGLE_DIR/src/compiler/Common.h \ - $$ANGLE_DIR/src/compiler/ConstantUnion.h \ - $$ANGLE_DIR/src/compiler/debug.h \ - $$ANGLE_DIR/src/compiler/DetectRecursion.h \ - $$ANGLE_DIR/src/compiler/DetectCallDepth.h \ - $$ANGLE_DIR/src/compiler/Diagnostics.h \ - $$ANGLE_DIR/src/compiler/DirectiveHandler.h \ - $$ANGLE_DIR/src/compiler/ForLoopUnroll.h \ - $$ANGLE_DIR/src/compiler/InfoSink.h \ - $$ANGLE_DIR/src/compiler/Initialize.h \ - $$ANGLE_DIR/src/compiler/InitializeDll.h \ - $$ANGLE_DIR/src/compiler/InitializeGlobals.h \ - $$ANGLE_DIR/src/compiler/InitializeGLPosition.h \ - $$ANGLE_DIR/src/compiler/InitializeParseContext.h \ - $$ANGLE_DIR/src/compiler/intermediate.h \ - $$ANGLE_DIR/src/compiler/localintermediate.h \ - $$ANGLE_DIR/src/compiler/MapLongVariableNames.h \ - $$ANGLE_DIR/src/compiler/MMap.h \ - $$ANGLE_DIR/src/compiler/osinclude.h \ - $$ANGLE_DIR/src/compiler/ParseHelper.h \ - $$ANGLE_DIR/src/compiler/PoolAlloc.h \ - $$ANGLE_DIR/src/compiler/QualifierAlive.h \ - $$ANGLE_DIR/src/compiler/RemoveTree.h \ - $$ANGLE_DIR/src/compiler/RenameFunction.h \ - $$ANGLE_DIR/include/GLSLANG/ResourceLimits.h \ - $$ANGLE_DIR/include/GLSLANG/ShaderLang.h \ - $$ANGLE_DIR/src/compiler/ShHandle.h \ - $$ANGLE_DIR/src/compiler/SymbolTable.h \ - $$ANGLE_DIR/src/compiler/Types.h \ - $$ANGLE_DIR/src/compiler/UnfoldShortCircuit.h \ - $$ANGLE_DIR/src/compiler/util.h \ - $$ANGLE_DIR/src/compiler/ValidateLimitations.h \ - $$ANGLE_DIR/src/compiler/VariableInfo.h \ - $$ANGLE_DIR/src/compiler/VariablePacker.h \ - $$ANGLE_DIR/src/compiler/timing/RestrictFragmentShaderTiming.h \ - $$ANGLE_DIR/src/compiler/timing/RestrictVertexShaderTiming.h \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraph.h \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraphBuilder.h \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraphOutput.h \ - $$ANGLE_DIR/src/third_party/compiler/ArrayBoundsClamper.h - -SOURCES += \ - $$ANGLE_DIR/src/compiler/BuiltInFunctionEmulator.cpp \ - $$ANGLE_DIR/src/compiler/Compiler.cpp \ - $$ANGLE_DIR/src/compiler/debug.cpp \ - $$ANGLE_DIR/src/compiler/DetectCallDepth.cpp \ - $$ANGLE_DIR/src/compiler/DetectRecursion.cpp \ - $$ANGLE_DIR/src/compiler/Diagnostics.cpp \ - $$ANGLE_DIR/src/compiler/DirectiveHandler.cpp \ - $$ANGLE_DIR/src/compiler/ForLoopUnroll.cpp \ - $$ANGLE_DIR/src/compiler/InfoSink.cpp \ - $$ANGLE_DIR/src/compiler/Initialize.cpp \ - $$ANGLE_DIR/src/compiler/InitializeDll.cpp \ - $$ANGLE_DIR/src/compiler/InitializeGLPosition.cpp \ - $$ANGLE_DIR/src/compiler/InitializeParseContext.cpp \ - $$ANGLE_DIR/src/compiler/Intermediate.cpp \ - $$ANGLE_DIR/src/compiler/intermOut.cpp \ - $$ANGLE_DIR/src/compiler/IntermTraverse.cpp \ - $$ANGLE_DIR/src/compiler/MapLongVariableNames.cpp \ - $$ANGLE_DIR/src/compiler/ossource_win.cpp \ - $$ANGLE_DIR/src/compiler/parseConst.cpp \ - $$ANGLE_DIR/src/compiler/ParseHelper.cpp \ - $$ANGLE_DIR/src/compiler/PoolAlloc.cpp \ - $$ANGLE_DIR/src/compiler/QualifierAlive.cpp \ - $$ANGLE_DIR/src/compiler/RemoveTree.cpp \ - $$ANGLE_DIR/src/compiler/ShaderLang.cpp \ - $$ANGLE_DIR/src/compiler/SymbolTable.cpp \ - $$ANGLE_DIR/src/compiler/util.cpp \ - $$ANGLE_DIR/src/compiler/ValidateLimitations.cpp \ - $$ANGLE_DIR/src/compiler/VariableInfo.cpp \ - $$ANGLE_DIR/src/compiler/VariablePacker.cpp \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraph.cpp \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraphBuilder.cpp \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraphOutput.cpp \ - $$ANGLE_DIR/src/compiler/depgraph/DependencyGraphTraverse.cpp \ - $$ANGLE_DIR/src/compiler/timing/RestrictFragmentShaderTiming.cpp \ - $$ANGLE_DIR/src/compiler/timing/RestrictVertexShaderTiming.cpp \ - $$ANGLE_DIR/src/third_party/compiler/ArrayBoundsClamper.cpp - -# NOTE: 'win_flex' and 'bison' can be found in qt5/gnuwin32/bin -flex.commands = $$addGnuPath(win_flex) --noline --nounistd --outfile=${QMAKE_FILE_BASE}_lex.cpp ${QMAKE_FILE_NAME} -flex.output = ${QMAKE_FILE_BASE}_lex.cpp -flex.input = FLEX_SOURCES -flex.dependency_type = TYPE_C -flex.variable_out = GENERATED_SOURCES -QMAKE_EXTRA_COMPILERS += flex - -bison.commands = $$addGnuPath(bison) --no-lines --skeleton=yacc.c --defines=${QMAKE_FILE_BASE}_tab.h \ - --output=${QMAKE_FILE_BASE}_tab.cpp ${QMAKE_FILE_NAME} -bison.output = ${QMAKE_FILE_BASE}_tab.h -bison.input = BISON_SOURCES -bison.dependency_type = TYPE_C -bison.variable_out = GENERATED_SOURCES -QMAKE_EXTRA_COMPILERS += bison - -# This is a dummy compiler to work around the fact that an extra compiler can only -# have one output file even if the command generates two. -MAKEFILE_NOOP_COMMAND = @echo -n -msvc: MAKEFILE_NOOP_COMMAND = @echo >NUL -bison_impl.output = ${QMAKE_FILE_BASE}_tab.cpp -bison_impl.input = BISON_SOURCES -bison_impl.commands = $$MAKEFILE_NOOP_COMMAND -bison_impl.depends = ${QMAKE_FILE_BASE}_tab.h -bison_impl.output = ${QMAKE_FILE_BASE}_tab.cpp -bison_impl.variable_out = GENERATED_SOURCES -QMAKE_EXTRA_COMPILERS += bison_impl - diff --git a/src/angle/src/compiler/translator_hlsl.pro b/src/angle/src/compiler/translator_hlsl.pro deleted file mode 100644 index 1c31cad297..0000000000 --- a/src/angle/src/compiler/translator_hlsl.pro +++ /dev/null @@ -1,30 +0,0 @@ -TEMPLATE = lib -CONFIG += static -TARGET = $$qtLibraryTarget(translator_hlsl) - -include(../config.pri) - -# Mingw 4.7 chokes on implicit move semantics, so disable C++11 here -win32-g++*: CONFIG -= c++11 - -INCLUDEPATH += $$ANGLE_DIR/src \ - $$ANGLE_DIR/include - -DEFINES += COMPILER_IMPLEMENTATION - -HEADERS += \ - $$ANGLE_DIR/src/compiler/DetectDiscontinuity.h \ - $$ANGLE_DIR/src/compiler/OutputHLSL.h \ - $$ANGLE_DIR/src/compiler/SearchSymbol.h \ - $$ANGLE_DIR/src/compiler/TranslatorHLSL.h \ - $$ANGLE_DIR/src/compiler/UnfoldShortCircuit.h \ - $$ANGLE_DIR/src/compiler/Uniform.h - -SOURCES += \ - $$ANGLE_DIR/src/compiler/CodeGenHLSL.cpp \ - $$ANGLE_DIR/src/compiler/DetectDiscontinuity.cpp \ - $$ANGLE_DIR/src/compiler/OutputHLSL.cpp \ - $$ANGLE_DIR/src/compiler/SearchSymbol.cpp \ - $$ANGLE_DIR/src/compiler/TranslatorHLSL.cpp \ - $$ANGLE_DIR/src/compiler/UnfoldShortCircuit.cpp \ - $$ANGLE_DIR/src/compiler/Uniform.cpp diff --git a/src/angle/src/config.pri b/src/angle/src/config.pri index 1c6d8b0167..8e0f6b7f42 100644 --- a/src/angle/src/config.pri +++ b/src/angle/src/config.pri @@ -37,14 +37,14 @@ DEFINES += _WINDOWS \ NOMINMAX \ WIN32_LEAN_AND_MEAN=1 -# Defines specifying the API version (0x0600 = Vista) -DEFINES += _WIN32_WINNT=0x0600 WINVER=0x0600 - -# ANGLE specific defines -DEFINES += ANGLE_DISABLE_TRACE \ - ANGLE_DISABLE_PERF \ - ANGLE_COMPILE_OPTIMIZATION_LEVEL=D3DCOMPILE_OPTIMIZATION_LEVEL0 \ - ANGLE_USE_NEW_PREPROCESSOR=1 +# Defines specifying the API version (0x0600 = Vista, 0x0602 = Win8)) +winrt { + DEFINES += _WIN32_WINNT=0x0602 WINVER=0x0602 + DEFINES += ANGLE_ENABLE_UNIVERSAL_BINARY +} else { + DEFINES += _WIN32_WINNT=0x0600 WINVER=0x0600 + DEFINES += ANGLE_ENABLE_D3D9 +} angle_d3d11 { DEFINES += ANGLE_ENABLE_D3D11 @@ -54,7 +54,7 @@ angle_d3d11 { CONFIG(debug, debug|release) { DEFINES += _DEBUG } else { - CONFIG += rtti_off + !static: CONFIG += rtti_off DEFINES += NDEBUG } diff --git a/src/angle/src/d3dcompiler/d3dcompiler.pro b/src/angle/src/d3dcompiler/d3dcompiler.pro new file mode 100644 index 0000000000..5a10187279 --- /dev/null +++ b/src/angle/src/d3dcompiler/d3dcompiler.pro @@ -0,0 +1,15 @@ +TEMPLATE = lib +TARGET = $$qtLibraryTarget(d3dcompiler_qt) + +include(../config.pri) +CONFIG += qt + +QT = core +DEFINES += QT_NO_CAST_FROM_ASCII QT_NO_CAST_TO_ASCII +SOURCES += main.cpp +win32:!winrt: LIBS += -lole32 + +# __stdcall exports get mangled, so use a def file +DEF_FILE += $${TARGET}.def + +load(qt_installs) diff --git a/src/angle/src/d3dcompiler/d3dcompiler_qt.def b/src/angle/src/d3dcompiler/d3dcompiler_qt.def new file mode 100644 index 0000000000..0b8679c8e0 --- /dev/null +++ b/src/angle/src/d3dcompiler/d3dcompiler_qt.def @@ -0,0 +1,3 @@ +LIBRARY d3dcompiler_qt +EXPORTS + D3DCompile @1 diff --git a/src/angle/src/d3dcompiler/d3dcompiler_qtd.def b/src/angle/src/d3dcompiler/d3dcompiler_qtd.def new file mode 100644 index 0000000000..0bdd0a1ffd --- /dev/null +++ b/src/angle/src/d3dcompiler/d3dcompiler_qtd.def @@ -0,0 +1,3 @@ +LIBRARY d3dcompiler_qtd +EXPORTS + D3DCompile @1 diff --git a/src/angle/src/d3dcompiler/main.cpp b/src/angle/src/d3dcompiler/main.cpp new file mode 100644 index 0000000000..7742596226 --- /dev/null +++ b/src/angle/src/d3dcompiler/main.cpp @@ -0,0 +1,303 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QByteArray> +#include <QCryptographicHash> +#include <QDateTime> +#include <QDir> +#include <QElapsedTimer> +#include <QFile> +#include <QLoggingCategory> +#include <QStandardPaths> +#include <QThread> + +#include <qt_windows.h> +#include <d3dcommon.h> + +Q_LOGGING_CATEGORY(QT_D3DCOMPILER, "qt.angle.d3dcompiler") + +namespace D3DCompiler { + +typedef HRESULT (WINAPI *D3DCompileFunc)(const void *data, SIZE_T data_size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, + const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages); +static D3DCompileFunc compile; + +class Blob : public ID3DBlob +{ +public: + Blob(const QByteArray &data) : m_data(data) + { + IIDFromString(L"00000000-0000-0000-C000-000000000046", &IID_IUnknown); + IIDFromString(L"8BA5FB08-5195-40e2-AC58-0D989C3A0102", &IID_ID3DBlob); + } + + virtual ~Blob() + { + } + + // ID3DBlob + LPVOID __stdcall GetBufferPointer() + { + return m_data.data(); + } + + SIZE_T __stdcall GetBufferSize() + { + return m_data.size(); + } + + // IUnknown + HRESULT __stdcall QueryInterface(REFIID riid, void **ppv) + { + IUnknown *out = 0; + if (riid == IID_IUnknown) + out = static_cast<IUnknown*>(this); + else if (riid == IID_ID3DBlob) + out = this; + + *ppv = out; + if (!out) + return E_NOINTERFACE; + + out->AddRef(); + return S_OK; + } + + ULONG __stdcall AddRef() + { + return ++m_ref; + } + + ULONG __stdcall Release() + { + ULONG ref = --m_ref; + if (!m_ref) + delete this; + + return ref; + } + +private: + QByteArray m_data; + ULONG m_ref; + + // These symbols might be missing, so define them here + IID IID_IUnknown; + IID IID_ID3DBlob; +}; + +static bool loadCompiler() +{ + static HMODULE d3dcompiler = 0; + if (!d3dcompiler) { + const wchar_t *dllNames[] = { + L"d3dcompiler_47.dll", + L"d3dcompiler_46.dll", + L"d3dcompiler_45.dll", + L"d3dcompiler_44.dll", + L"d3dcompiler_43.dll", + 0 + }; + for (int i = 0; const wchar_t *name = dllNames[i]; ++i) { +#ifndef Q_OS_WINRT + d3dcompiler = LoadLibrary(name); +#else + d3dcompiler = LoadPackagedLibrary(name, NULL); +#endif + if (d3dcompiler) { + qCDebug(QT_D3DCOMPILER) << "Found" << QString::fromWCharArray(name); + D3DCompiler::compile = reinterpret_cast<D3DCompiler::D3DCompileFunc>(GetProcAddress(d3dcompiler, "D3DCompile")); + if (D3DCompiler::compile) { + qCDebug(QT_D3DCOMPILER) << "Loaded" << QString::fromWCharArray(name); + break; + } + qCDebug(QT_D3DCOMPILER) << "Failed to load" << QString::fromWCharArray(name); + } + } + + if (!d3dcompiler) + qCDebug(QT_D3DCOMPILER) << "Unable to load D3D shader compiler."; + } + + return bool(compile); +} + +static QString cacheKeyFor(const void *data) +{ + return QString::fromUtf8(QCryptographicHash::hash(reinterpret_cast<const char *>(data), QCryptographicHash::Sha1).toHex()); +} + +} // namespace D3DCompiler + +#ifdef __MINGW32__ +extern "C" +#endif +__declspec(dllexport) HRESULT WINAPI D3DCompile( + const void *, SIZE_T, const char *, const D3D_SHADER_MACRO *, ID3DInclude *, + const char *, const char *, UINT, UINT, ID3DBlob **, ID3DBlob **); + +HRESULT WINAPI D3DCompile( + const void *data, SIZE_T data_size, const char *filename, + const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, + const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **errorMsgs) +{ + // Shortcut to compile using the runtime compiler if it is available + static bool compilerAvailable = + !qgetenv("QT_D3DCOMPILER_DISABLE_DLL").toInt() && D3DCompiler::loadCompiler(); + if (compilerAvailable) { + HRESULT hr = D3DCompiler::compile(data, data_size, filename, defines, include, entrypoint, + target, sflags, eflags, shader, errorMsgs); + return hr; + } + + static bool initialized = false; + static QString binaryPath; + static QString sourcePath; + if (!initialized) { + QString base; + if (qEnvironmentVariableIsSet("QT_D3DCOMPILER_DIR")) + base = QString::fromLocal8Bit(qgetenv("QT_D3DCOMPILER_DIR")); + + if (base.isEmpty()) { + const QString location = QStandardPaths::writableLocation(QStandardPaths::DataLocation); + if (!location.isEmpty()) + base = location + QStringLiteral("/d3dcompiler"); + } + + // Unless the service has run, this directory won't exist. + QDir baseDir(base); + if (baseDir.exists()) { + // Check if we have can read/write blobs + if (baseDir.exists(QStringLiteral("binary"))) { + binaryPath = baseDir.absoluteFilePath(QStringLiteral("binary/")); + } else { + qCWarning(QT_D3DCOMPILER) << "D3D compiler base directory exists, but the binary directory does not.\n" + "Check the compiler service."; + } + + // Check if we can write shader source + if (baseDir.exists(QStringLiteral("source"))) { + sourcePath = baseDir.absoluteFilePath(QStringLiteral("source/")); + } else { + qCWarning(QT_D3DCOMPILER) << "D3D compiler base directory exists, but the source directory does not.\n" + "Check the compiler service."; + } + } else { + qCWarning(QT_D3DCOMPILER) << "D3D compiler base directory does not exist:" + << QDir::toNativeSeparators(base) + << "\nCheck that the compiler service is running."; + } + + initialized = true; + } + + QByteArray macros; + if (const D3D_SHADER_MACRO *macro = defines) { + while (macro) { + macros.append('#').append(macro->Name).append(' ').append(macro->Definition).append('\n'); + ++macro; + } + } + + const QByteArray sourceData = macros + QByteArray::fromRawData(reinterpret_cast<const char *>(data), data_size); + const QString fileName = D3DCompiler::cacheKeyFor(sourceData) + + QLatin1Char('!') + QString::fromUtf8(entrypoint) + + QLatin1Char('!') + QString::fromUtf8(target) + + QLatin1Char('!') + QString::number(sflags); + + // Check if pre-compiled shader blob is available + if (!binaryPath.isEmpty()) { + QString blobName = binaryPath + fileName; + QFile blob(blobName); + while (!blob.exists()) { + // Progressively drop optional parts + blobName.truncate(blobName.lastIndexOf(QLatin1Char('!'))); + if (blobName.isEmpty()) + break; + blob.setFileName(blobName); + } + if (blob.exists()) { + if (blob.open(QFile::ReadOnly)) { + qCDebug(QT_D3DCOMPILER) << "Opening precompiled shader blob at" << blob.fileName(); + *shader = new D3DCompiler::Blob(blob.readAll()); + return S_FALSE; + } + qCDebug(QT_D3DCOMPILER) << "Found, but unable to open, precompiled shader blob at" << blob.fileName(); + } + } + + // Shader blob is not available; write out shader source + if (!sourcePath.isEmpty()) { + // Dump source to source path; wait for blob to appear + QFile source(sourcePath + fileName); + if (!source.open(QFile::WriteOnly)) { + qCDebug(QT_D3DCOMPILER) << "Unable to write shader source to file:" << source.fileName() << source.errorString(); + return E_ACCESSDENIED; + } + + source.write(sourceData); + qCDebug(QT_D3DCOMPILER) << "Wrote shader source, waiting for blob:" << source.fileName(); + source.close(); + + qint64 timeout = qgetenv("QT_D3DCOMPILER_TIMEOUT").toLong(); + if (!timeout) + timeout = 3000; + + QElapsedTimer timer; + timer.start(); + QFile blob(binaryPath + fileName); + while (!(blob.exists() && blob.open(QFile::ReadOnly)) && timer.elapsed() < timeout) + QThread::msleep(100); + + if (blob.isOpen()) { + *shader = new D3DCompiler::Blob(blob.readAll()); + return S_FALSE; + } + + qCDebug(QT_D3DCOMPILER) << "Shader blob failed to materialize after" << timeout << "ms."; + *errorMsgs = new D3DCompiler::Blob("Shader compilation timeout."); + return E_ABORT; + } + + *errorMsgs = new D3DCompiler::Blob("No shader compiler or service could be found."); + return E_FAIL; +} diff --git a/src/angle/src/libEGL/libEGL.pro b/src/angle/src/libEGL/libEGL.pro index b5854189f9..4f10583fc0 100644 --- a/src/angle/src/libEGL/libEGL.pro +++ b/src/angle/src/libEGL/libEGL.pro @@ -3,11 +3,11 @@ TARGET = $$qtLibraryTarget(libEGL) include(../common/common.pri) -angle_d3d11 { +angle_d3d11: \ LIBS_PRIVATE += -ld3d11 -} else { +!winrt: \ LIBS_PRIVATE += -ld3d9 -} + LIBS_PRIVATE += -ldxguid -L$$QT_BUILD_TREE/lib -l$$qtLibraryTarget(libGLESv2) HEADERS += \ @@ -27,7 +27,7 @@ SOURCES += \ !static { DEF_FILE = $$ANGLE_DIR/src/libEGL/$${TARGET}.def - win32-g++*:equals(QT_ARCH, i386): DEF_FILE = $$ANGLE_DIR/src/libEGL/$${TARGET}_mingw32.def + mingw:equals(QT_ARCH, i386): DEF_FILE = $$ANGLE_DIR/src/libEGL/$${TARGET}_mingw32.def } load(qt_installs) diff --git a/src/angle/src/libGLESv2/libGLESv2.pro b/src/angle/src/libGLESv2/libGLESv2.pro index 5d54c0f86a..6176016f13 100644 --- a/src/angle/src/libGLESv2/libGLESv2.pro +++ b/src/angle/src/libGLESv2/libGLESv2.pro @@ -7,13 +7,13 @@ include(../common/common.pri) INCLUDEPATH += $$OUT_PWD/.. $$ANGLE_DIR/src/libGLESv2 # Remember to adapt tools/configure/configureapp.cpp if the Direct X version changes. -angle_d3d11 { +angle_d3d11: \ LIBS_PRIVATE += -ldxgi -ld3d11 -} else { +!winrt: \ LIBS_PRIVATE += -ld3d9 -} + LIBS_PRIVATE += -ldxguid -STATICLIBS = translator_common translator_hlsl preprocessor +STATICLIBS = translator preprocessor for(libname, STATICLIBS) { # Appends 'd' to the library for debug builds and builds up the fully @@ -93,72 +93,74 @@ SSE2_SOURCES += $$ANGLE_DIR/src/libGLESv2/renderer/ImageSSE2.cpp angle_d3d11 { HEADERS += \ - $$ANGLE_DIR/src/libGLESv2/renderer/BufferStorage11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Fence11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Image11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/IndexBuffer11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/InputLayoutCache.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Query11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Renderer11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/renderer11_utils.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/RenderTarget11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/RenderStateCache.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/ShaderExecutable11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/SwapChain11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/TextureStorage11.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/VertexBuffer11.h + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/BufferStorage11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Fence11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Image11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/IndexBuffer11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/InputLayoutCache.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Query11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Renderer11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/renderer11_utils.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/RenderTarget11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/RenderStateCache.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/ShaderExecutable11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/SwapChain11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/TextureStorage11.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/VertexBuffer11.h SOURCES += \ - $$ANGLE_DIR/src/libGLESv2/renderer/BufferStorage11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Fence11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Image11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/IndexBuffer11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/InputLayoutCache.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Query11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Renderer11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/renderer11_utils.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/RenderTarget11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/RenderStateCache.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/ShaderExecutable11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/SwapChain11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/TextureStorage11.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/VertexBuffer11.cpp -} else { + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/BufferStorage11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Fence11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Image11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/IndexBuffer11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/InputLayoutCache.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Query11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/Renderer11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/renderer11_utils.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/RenderTarget11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/ShaderExecutable11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/SwapChain11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/TextureStorage11.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/VertexBuffer11.cpp +} + +!winrt { HEADERS += \ - $$ANGLE_DIR/src/libGLESv2/renderer/Blit.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/BufferStorage9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Fence9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Image9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/IndexBuffer9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Query9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/Renderer9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/renderer9_utils.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/RenderTarget9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/ShaderExecutable9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/SwapChain9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/TextureStorage9.h \ - $$ANGLE_DIR/src/libGLESv2/renderer/VertexBuffer9.h + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Blit.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/BufferStorage9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Fence9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Image9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/IndexBuffer9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Query9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Renderer9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/renderer9_utils.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/RenderTarget9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/ShaderExecutable9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/SwapChain9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/TextureStorage9.h \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/VertexBuffer9.h SOURCES += \ - $$ANGLE_DIR/src/libGLESv2/renderer/Blit.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/BufferStorage9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Fence9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Image9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/IndexBuffer9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Query9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/Renderer9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/renderer9_utils.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/RenderTarget9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/ShaderExecutable9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/SwapChain9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/TextureStorage9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/VertexBuffer9.cpp \ - $$ANGLE_DIR/src/libGLESv2/renderer/VertexDeclarationCache.cpp + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Blit.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/BufferStorage9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Fence9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Image9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/IndexBuffer9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Query9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/Renderer9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/renderer9_utils.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/RenderTarget9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/ShaderExecutable9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/SwapChain9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/TextureStorage9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/VertexBuffer9.cpp \ + $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/VertexDeclarationCache.cpp } !static { DEF_FILE = $$ANGLE_DIR/src/libGLESv2/$${TARGET}.def - win32-g++*:equals(QT_ARCH, i386): DEF_FILE = $$ANGLE_DIR/src/libGLESv2/$${TARGET}_mingw32.def + mingw:equals(QT_ARCH, i386): DEF_FILE = $$ANGLE_DIR/src/libGLESv2/$${TARGET}_mingw32.def } float_converter.target = float_converter @@ -167,10 +169,10 @@ float_converter.commands = python $$ANGLE_DIR/src/libGLESv2/Float16ToFloat32.py QMAKE_EXTRA_TARGETS += float_converter # Generate the shader header files. -PS_BLIT_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/shaders/Blit.ps -VS_BLIT_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/shaders/Blit.vs -PASSTHROUGH_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/shaders/Passthrough11.hlsl -CLEAR_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/shaders/Clear11.hlsl +PS_BLIT_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/shaders/Blit.ps +VS_BLIT_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/d3d9/shaders/Blit.vs +PASSTHROUGH_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/shaders/Passthrough11.hlsl +CLEAR_INPUT = $$ANGLE_DIR/src/libGLESv2/renderer/d3d11/shaders/Clear11.hlsl PIXEL_SHADERS_BLIT = passthroughps luminanceps componentmaskps PIXEL_SHADERS_PASSTHROUGH = PassthroughRGBA PassthroughRGB \ PassthroughLum PassthroughLumAlpha @@ -178,61 +180,62 @@ PIXEL_SHADERS_CLEAR = ClearSingle ClearMultiple VERTEX_SHADERS_BLIT = standardvs flipyvs VERTEX_SHADERS_PASSTHROUGH = Passthrough VERTEX_SHADERS_CLEAR = Clear -SHADER_DIR = $$OUT_PWD/renderer/shaders/compiled +SHADER_DIR_9 = $$OUT_PWD/renderer/d3d9/shaders/compiled +SHADER_DIR_11 = $$OUT_PWD/renderer/d3d11/shaders/compiled for (ps, PIXEL_SHADERS_BLIT) { fxc_ps_$${ps}.commands = $$FXC /nologo /E $$ps /T ps_2_0 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} - fxc_ps_$${ps}.output = $$SHADER_DIR/$${ps}.h + fxc_ps_$${ps}.output = $$SHADER_DIR_9/$${ps}.h fxc_ps_$${ps}.input = PS_BLIT_INPUT fxc_ps_$${ps}.dependency_type = TYPE_C fxc_ps_$${ps}.variable_out = HEADERS fxc_ps_$${ps}.CONFIG += target_predeps - QMAKE_EXTRA_COMPILERS += fxc_ps_$${ps} + !winrt: QMAKE_EXTRA_COMPILERS += fxc_ps_$${ps} } for (ps, PIXEL_SHADERS_PASSTHROUGH) { - fxc_ps_$${ps}.commands = $$FXC /nologo /E PS_$$ps /T ps_4_0 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} - fxc_ps_$${ps}.output = $$SHADER_DIR/$${ps}11ps.h + fxc_ps_$${ps}.commands = $$FXC /nologo /E PS_$$ps /T ps_4_0_level_9_1 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} + fxc_ps_$${ps}.output = $$SHADER_DIR_11/$${ps}11ps.h fxc_ps_$${ps}.input = PASSTHROUGH_INPUT fxc_ps_$${ps}.dependency_type = TYPE_C fxc_ps_$${ps}.variable_out = HEADERS fxc_ps_$${ps}.CONFIG += target_predeps - QMAKE_EXTRA_COMPILERS += fxc_ps_$${ps} + angle_d3d11: QMAKE_EXTRA_COMPILERS += fxc_ps_$${ps} } for (ps, PIXEL_SHADERS_CLEAR) { - fxc_ps_$${ps}.commands = $$FXC /nologo /E PS_$$ps /T ps_4_0 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} - fxc_ps_$${ps}.output = $$SHADER_DIR/$${ps}11ps.h + fxc_ps_$${ps}.commands = $$FXC /nologo /E PS_$$ps /T ps_4_0_level_9_1 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} + fxc_ps_$${ps}.output = $$SHADER_DIR_11/$${ps}11ps.h fxc_ps_$${ps}.input = CLEAR_INPUT fxc_ps_$${ps}.dependency_type = TYPE_C fxc_ps_$${ps}.variable_out = HEADERS fxc_ps_$${ps}.CONFIG += target_predeps - QMAKE_EXTRA_COMPILERS += fxc_ps_$${ps} + angle_d3d11: QMAKE_EXTRA_COMPILERS += fxc_ps_$${ps} } for (vs, VERTEX_SHADERS_BLIT) { fxc_vs_$${vs}.commands = $$FXC /nologo /E $$vs /T vs_2_0 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} - fxc_vs_$${vs}.output = $$SHADER_DIR/$${vs}.h + fxc_vs_$${vs}.output = $$SHADER_DIR_9/$${vs}.h fxc_vs_$${vs}.input = VS_BLIT_INPUT fxc_vs_$${vs}.dependency_type = TYPE_C fxc_vs_$${vs}.variable_out = HEADERS fxc_vs_$${vs}.CONFIG += target_predeps - QMAKE_EXTRA_COMPILERS += fxc_vs_$${vs} + !winrt: QMAKE_EXTRA_COMPILERS += fxc_vs_$${vs} } for (vs, VERTEX_SHADERS_PASSTHROUGH) { - fxc_vs_$${vs}.commands = $$FXC /nologo /E VS_$$vs /T vs_4_0 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} - fxc_vs_$${vs}.output = $$SHADER_DIR/$${vs}11vs.h + fxc_vs_$${vs}.commands = $$FXC /nologo /E VS_$$vs /T vs_4_0_level_9_1 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} + fxc_vs_$${vs}.output = $$SHADER_DIR_11/$${vs}11vs.h fxc_vs_$${vs}.input = PASSTHROUGH_INPUT fxc_vs_$${vs}.dependency_type = TYPE_C fxc_vs_$${vs}.variable_out = HEADERS fxc_vs_$${vs}.CONFIG += target_predeps - QMAKE_EXTRA_COMPILERS += fxc_vs_$${vs} + angle_d3d11: QMAKE_EXTRA_COMPILERS += fxc_vs_$${vs} } for (vs, VERTEX_SHADERS_CLEAR) { - fxc_vs_$${vs}.commands = $$FXC /nologo /E VS_$$vs /T vs_4_0 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} - fxc_vs_$${vs}.output = $$SHADER_DIR/$${vs}11vs.h + fxc_vs_$${vs}.commands = $$FXC /nologo /E VS_$$vs /T vs_4_0_level_9_1 /Fh ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} + fxc_vs_$${vs}.output = $$SHADER_DIR_11/$${vs}11vs.h fxc_vs_$${vs}.input = CLEAR_INPUT fxc_vs_$${vs}.dependency_type = TYPE_C fxc_vs_$${vs}.variable_out = HEADERS fxc_vs_$${vs}.CONFIG += target_predeps - QMAKE_EXTRA_COMPILERS += fxc_vs_$${vs} + angle_d3d11: QMAKE_EXTRA_COMPILERS += fxc_vs_$${vs} } load(qt_installs) diff --git a/src/angle/src/src.pro b/src/angle/src/src.pro index d1f5f57591..2b7d523207 100644 --- a/src/angle/src/src.pro +++ b/src/angle/src/src.pro @@ -1,3 +1,4 @@ TEMPLATE = subdirs SUBDIRS += compiler libGLESv2 libEGL +angle_d3d11: SUBDIRS += d3dcompiler CONFIG += ordered |