From a6a12d8c0fc918972c15268f749ecc7c90b95d6c Mon Sep 17 00:00:00 2001 From: Andrew Knight Date: Tue, 5 Aug 2014 12:59:44 +0300 Subject: ANGLE: upgrade to 2.1~07d49ef5350a This version of ANGLE provides partial ES3 support, numerous bug fixes, and several potentially useful vendor extensions. All patches have been rebased. The following changes are noted: 0000-General-fixes-for-ANGLE-2.1.patch contains compile fixes for the new ANGLE 0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch has incorporated patch 0015. 0007-Make-DX9-DX11-mutually-exclusive.patch has been removed as it was fixed upstream. 0007-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch has been moved up to fill the patch number gap. 0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch now contains patch 0014 and 0017. 0013-ANGLE-Allow-for-universal-program-binaries.patch has been removed as it is no longer relevant. 0014-ANGLE-D3D11-Fix-internal-index-buffer-for-level-9-ha.patch has been merged with patch 0010. 0015-ANGLE-Don-t-export-DLLMain-functions-for-static-buil.patch has been merged with patch 0004. 0016-ANGLE-WinRT-Call-Trim-when-application-suspends.patch has been removed and will be replaced by a follow-up patch using a different technique. 0017-ANGLE-D3D11-Don-t-use-mipmaps-in-level-9-textures.patch has been merged with patch 0010. 0018-ANGLE-WinRT-Create-swap-chain-using-physical-resolut.patch has been removed and will be replaced by a follow-up patch extending the EGL_ANGLE_window_fixed_size extension. 0019-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch is now patch 0007. [ChangeLog][Third-party libraries] ANGLE has been upgraded to version 2.1, bringing partial support for OpenGL ES3 over Direct3D 11, numerous bug fixes, and several new vendor extensions. Change-Id: I6d95ce1480462d67228d83c1e5c74a1706b5b21c Reviewed-by: Friedemann Kleint --- src/3rdparty/angle/src/libEGL/libEGL.cpp | 1239 +++++++++++++----------------- 1 file changed, 535 insertions(+), 704 deletions(-) (limited to 'src/3rdparty/angle/src/libEGL/libEGL.cpp') diff --git a/src/3rdparty/angle/src/libEGL/libEGL.cpp b/src/3rdparty/angle/src/libEGL/libEGL.cpp index b2944d5c0d..a08e1edeab 100644 --- a/src/3rdparty/angle/src/libEGL/libEGL.cpp +++ b/src/3rdparty/angle/src/libEGL/libEGL.cpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // @@ -10,6 +10,7 @@ #include "common/debug.h" #include "common/version.h" +#include "common/platform.h" #include "libGLESv2/Context.h" #include "libGLESv2/Texture.h" #include "libGLESv2/main.h" @@ -99,99 +100,139 @@ EGLDisplay __stdcall eglGetDisplay(EGLNativeDisplayType display_id) { EVENT("(EGLNativeDisplayType display_id = 0x%0.8p)", display_id); - try + return egl::Display::getDisplay(display_id, EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE); +} + +EGLDisplay __stdcall eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list) +{ + EVENT("(EGLenum platform = %d, void* native_display = 0x%0.8p, const EGLint* attrib_list = 0x%0.8p)", + platform, native_display, attrib_list); + + switch (platform) { - return egl::Display::getDisplay(display_id); + case EGL_PLATFORM_ANGLE_ANGLE: + break; + + default: + return egl::error(EGL_BAD_CONFIG, EGL_NO_DISPLAY); } - catch(std::bad_alloc&) + + EGLNativeDisplayType displayId = static_cast(native_display); +#if !defined(ANGLE_PLATFORM_WINRT) + // Validate the display device context + if (WindowFromDC(displayId) == NULL) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_DISPLAY); + return egl::success(EGL_NO_DISPLAY); } -} - -EGLBoolean __stdcall eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) -{ - EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint *major = 0x%0.8p, EGLint *minor = 0x%0.8p)", - dpy, major, minor); +#endif - try + EGLint requestedDisplayType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE; + if (attrib_list) { - if (dpy == EGL_NO_DISPLAY) + for (const EGLint *curAttrib = attrib_list; curAttrib[0] != EGL_NONE; curAttrib += 2) { - return egl::error(EGL_BAD_DISPLAY, EGL_FALSE); + switch (curAttrib[0]) + { + case EGL_PLATFORM_ANGLE_TYPE_ANGLE: + requestedDisplayType = curAttrib[1]; + break; + + default: + break; + } } + } - egl::Display *display = static_cast(dpy); + switch (requestedDisplayType) + { + case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE: + break; - if (!display->initialize()) + case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE: + case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE: + case EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE: + if (!egl::Display::supportsPlatformD3D()) { - return egl::error(EGL_NOT_INITIALIZED, EGL_FALSE); + return egl::success(EGL_NO_DISPLAY); } + break; - if (major) *major = 1; - if (minor) *minor = 4; + case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE: + case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE: + if (!egl::Display::supportsPlatformOpenGL()) + { + return egl::success(EGL_NO_DISPLAY); + } + break; - return egl::success(EGL_TRUE); + default: + return egl::success(EGL_NO_DISPLAY); } - catch(std::bad_alloc&) + + return egl::Display::getDisplay(displayId, requestedDisplayType); +} + +EGLBoolean __stdcall eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) +{ + EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint *major = 0x%0.8p, EGLint *minor = 0x%0.8p)", + dpy, major, minor); + + if (dpy == EGL_NO_DISPLAY) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_DISPLAY, EGL_FALSE); } + + egl::Display *display = static_cast(dpy); + + if (!display->initialize()) + { + return egl::error(EGL_NOT_INITIALIZED, EGL_FALSE); + } + + if (major) *major = 1; + if (minor) *minor = 4; + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglTerminate(EGLDisplay dpy) { EVENT("(EGLDisplay dpy = 0x%0.8p)", dpy); - try + if (dpy == EGL_NO_DISPLAY) { - if (dpy == EGL_NO_DISPLAY) - { - return egl::error(EGL_BAD_DISPLAY, EGL_FALSE); - } + return egl::error(EGL_BAD_DISPLAY, EGL_FALSE); + } - egl::Display *display = static_cast(dpy); + egl::Display *display = static_cast(dpy); - display->terminate(); + display->terminate(); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(EGL_TRUE); } const char *__stdcall eglQueryString(EGLDisplay dpy, EGLint name) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint name = %d)", dpy, name); - try + egl::Display *display = static_cast(dpy); + if (!(display == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) && !validateDisplay(display)) { - egl::Display *display = static_cast(dpy); - - if (!validateDisplay(display)) - { - return NULL; - } - - switch (name) - { - case EGL_CLIENT_APIS: - return egl::success("OpenGL_ES"); - case EGL_EXTENSIONS: - return egl::success(display->getExtensionString()); - case EGL_VENDOR: - return egl::success(display->getVendorString()); - case EGL_VERSION: - return egl::success("1.4 (ANGLE " ANGLE_VERSION_STRING ")"); - } - - return egl::error(EGL_BAD_PARAMETER, (const char*)NULL); + return NULL; } - catch(std::bad_alloc&) + + switch (name) { - return egl::error(EGL_BAD_ALLOC, (const char*)NULL); + case EGL_CLIENT_APIS: + return egl::success("OpenGL_ES"); + case EGL_EXTENSIONS: + return egl::success(egl::Display::getExtensionString(display)); + case EGL_VENDOR: + return egl::success(display->getVendorString()); + case EGL_VERSION: + return egl::success("1.4 (ANGLE " ANGLE_VERSION_STRING ")"); + default: + return egl::error(EGL_BAD_PARAMETER, (const char*)NULL); } } @@ -201,33 +242,26 @@ EGLBoolean __stdcall eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint co "EGLint config_size = %d, EGLint *num_config = 0x%0.8p)", dpy, configs, config_size, num_config); - try - { - egl::Display *display = static_cast(dpy); - - if (!validateDisplay(display)) - { - return EGL_FALSE; - } + egl::Display *display = static_cast(dpy); - if (!num_config) - { - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); - } + if (!validateDisplay(display)) + { + return EGL_FALSE; + } - const EGLint attribList[] = {EGL_NONE}; + if (!num_config) + { + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); + } - if (!display->getConfigs(configs, attribList, config_size, num_config)) - { - return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); - } + const EGLint attribList[] = {EGL_NONE}; - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) + if (!display->getConfigs(configs, attribList, config_size, num_config)) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); } + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config) @@ -236,35 +270,28 @@ EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, "EGLConfig *configs = 0x%0.8p, EGLint config_size = %d, EGLint *num_config = 0x%0.8p)", dpy, attrib_list, configs, config_size, num_config); - try - { - egl::Display *display = static_cast(dpy); - - if (!validateDisplay(display)) - { - return EGL_FALSE; - } + egl::Display *display = static_cast(dpy); - if (!num_config) - { - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); - } - - const EGLint attribList[] = {EGL_NONE}; + if (!validateDisplay(display)) + { + return EGL_FALSE; + } - if (!attrib_list) - { - attrib_list = attribList; - } + if (!num_config) + { + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); + } - display->getConfigs(configs, attrib_list, config_size, num_config); + const EGLint attribList[] = {EGL_NONE}; - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) + if (!attrib_list) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + attrib_list = attribList; } + + display->getConfigs(configs, attrib_list, config_size, num_config); + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) @@ -272,26 +299,19 @@ EGLBoolean __stdcall eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)", dpy, config, attribute, value); - try - { - egl::Display *display = static_cast(dpy); - - if (!validateConfig(display, config)) - { - return EGL_FALSE; - } - - if (!display->getConfigAttrib(config, attribute, value)) - { - return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); - } + egl::Display *display = static_cast(dpy); - return egl::success(EGL_TRUE); + if (!validateConfig(display, config)) + { + return EGL_FALSE; } - catch(std::bad_alloc&) + + if (!display->getConfigAttrib(config, attribute, value)) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); } + + return egl::success(EGL_TRUE); } EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list) @@ -299,30 +319,23 @@ EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EG EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLNativeWindowType win = 0x%0.8p, " "const EGLint *attrib_list = 0x%0.8p)", dpy, config, win, attrib_list); - try - { - egl::Display *display = static_cast(dpy); + egl::Display *display = static_cast(dpy); - if (!validateConfig(display, config)) - { - return EGL_NO_SURFACE; - } - -#if !defined(ANGLE_OS_WINRT) - HWND window = (HWND)win; + if (!validateConfig(display, config)) + { + return EGL_NO_SURFACE; + } - if (!IsWindow(window)) - { - return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); - } -#endif +#if !defined(ANGLE_PLATFORM_WINRT) + HWND window = (HWND)win; - return display->createWindowSurface(win, config, attrib_list); - } - catch(std::bad_alloc&) + if (!IsWindow(window)) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE); + return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); } +#endif + + return display->createWindowSurface(win, config, attrib_list); } EGLSurface __stdcall eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) @@ -330,21 +343,14 @@ EGLSurface __stdcall eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, c EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)", dpy, config, attrib_list); - try - { - egl::Display *display = static_cast(dpy); - - if (!validateConfig(display, config)) - { - return EGL_NO_SURFACE; - } + egl::Display *display = static_cast(dpy); - return display->createOffscreenSurface(config, NULL, attrib_list); - } - catch(std::bad_alloc&) + if (!validateConfig(display, config)) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE); + return EGL_NO_SURFACE; } + + return display->createOffscreenSurface(config, NULL, attrib_list); } EGLSurface __stdcall eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list) @@ -352,52 +358,38 @@ EGLSurface __stdcall eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EG EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLNativePixmapType pixmap = 0x%0.8p, " "const EGLint *attrib_list = 0x%0.8p)", dpy, config, pixmap, attrib_list); - try - { - egl::Display *display = static_cast(dpy); + egl::Display *display = static_cast(dpy); - if (!validateConfig(display, config)) - { - return EGL_NO_SURFACE; - } - - UNIMPLEMENTED(); // FIXME - - return egl::success(EGL_NO_SURFACE); - } - catch(std::bad_alloc&) + if (!validateConfig(display, config)) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE); + return EGL_NO_SURFACE; } + + UNIMPLEMENTED(); // FIXME + + return egl::success(EGL_NO_SURFACE); } EGLBoolean __stdcall eglDestroySurface(EGLDisplay dpy, EGLSurface surface) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = static_cast(surface); + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = static_cast(surface); - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } - - if (surface == EGL_NO_SURFACE) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } - - display->destroySurface((egl::Surface*)surface); - - return egl::success(EGL_TRUE); + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; } - catch(std::bad_alloc&) + + if (surface == EGL_NO_SURFACE) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); } + + display->destroySurface((egl::Surface*)surface); + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) @@ -405,84 +397,80 @@ EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)", dpy, surface, attribute, value); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = (egl::Surface*)surface; + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = (egl::Surface*)surface; - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } - - if (surface == EGL_NO_SURFACE) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } - - switch (attribute) - { - case EGL_VG_ALPHA_FORMAT: - UNIMPLEMENTED(); // FIXME - break; - case EGL_VG_COLORSPACE: - UNIMPLEMENTED(); // FIXME - break; - case EGL_CONFIG_ID: - UNIMPLEMENTED(); // FIXME - break; - case EGL_HEIGHT: - *value = eglSurface->getHeight(); - break; - case EGL_HORIZONTAL_RESOLUTION: - UNIMPLEMENTED(); // FIXME - break; - case EGL_LARGEST_PBUFFER: - UNIMPLEMENTED(); // FIXME - break; - case EGL_MIPMAP_TEXTURE: - UNIMPLEMENTED(); // FIXME - break; - case EGL_MIPMAP_LEVEL: - UNIMPLEMENTED(); // FIXME - break; - case EGL_MULTISAMPLE_RESOLVE: - UNIMPLEMENTED(); // FIXME - break; - case EGL_PIXEL_ASPECT_RATIO: - UNIMPLEMENTED(); // FIXME - break; - case EGL_RENDER_BUFFER: - UNIMPLEMENTED(); // FIXME - break; - case EGL_SWAP_BEHAVIOR: - UNIMPLEMENTED(); // FIXME - break; - case EGL_TEXTURE_FORMAT: - UNIMPLEMENTED(); // FIXME - break; - case EGL_TEXTURE_TARGET: - UNIMPLEMENTED(); // FIXME - break; - case EGL_VERTICAL_RESOLUTION: - UNIMPLEMENTED(); // FIXME - break; - case EGL_WIDTH: - *value = eglSurface->getWidth(); - break; - case EGL_POST_SUB_BUFFER_SUPPORTED_NV: - *value = eglSurface->isPostSubBufferSupported(); - break; - default: - return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); - } - - return egl::success(EGL_TRUE); + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; } - catch(std::bad_alloc&) + + if (surface == EGL_NO_SURFACE) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); } + + switch (attribute) + { + case EGL_VG_ALPHA_FORMAT: + UNIMPLEMENTED(); // FIXME + break; + case EGL_VG_COLORSPACE: + UNIMPLEMENTED(); // FIXME + break; + case EGL_CONFIG_ID: + *value = eglSurface->getConfigID(); + break; + case EGL_HEIGHT: + *value = eglSurface->getHeight(); + break; + case EGL_HORIZONTAL_RESOLUTION: + UNIMPLEMENTED(); // FIXME + break; + case EGL_LARGEST_PBUFFER: + UNIMPLEMENTED(); // FIXME + break; + case EGL_MIPMAP_TEXTURE: + UNIMPLEMENTED(); // FIXME + break; + case EGL_MIPMAP_LEVEL: + UNIMPLEMENTED(); // FIXME + break; + case EGL_MULTISAMPLE_RESOLVE: + UNIMPLEMENTED(); // FIXME + break; + case EGL_PIXEL_ASPECT_RATIO: + *value = eglSurface->getPixelAspectRatio(); + break; + case EGL_RENDER_BUFFER: + *value = eglSurface->getRenderBuffer(); + break; + case EGL_SWAP_BEHAVIOR: + *value = eglSurface->getSwapBehavior(); + break; + case EGL_TEXTURE_FORMAT: + *value = eglSurface->getTextureFormat(); + break; + case EGL_TEXTURE_TARGET: + *value = eglSurface->getTextureTarget(); + break; + case EGL_VERTICAL_RESOLUTION: + UNIMPLEMENTED(); // FIXME + break; + case EGL_WIDTH: + *value = eglSurface->getWidth(); + break; + case EGL_POST_SUB_BUFFER_SUPPORTED_NV: + *value = eglSurface->isPostSubBufferSupported(); + break; + case EGL_FIXED_SIZE_ANGLE: + *value = eglSurface->isFixedSize(); + break; + default: + return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); + } + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value) @@ -490,114 +478,79 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf TRACE("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, void **value = 0x%0.8p)", dpy, surface, attribute, value); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = (egl::Surface*)surface; + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = (egl::Surface*)surface; - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; + } - if (surface == EGL_NO_SURFACE) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } + if (surface == EGL_NO_SURFACE) + { + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); + } - switch (attribute) + switch (attribute) + { + case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE: { - case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE: - { - rx::SwapChain *swapchain = eglSurface->getSwapChain(); - *value = (void*) (swapchain ? swapchain->getShareHandle() : NULL); - } - break; - default: - return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); + rx::SwapChain *swapchain = eglSurface->getSwapChain(); + *value = (void*) (swapchain ? swapchain->getShareHandle() : NULL); } - - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + break; + default: + return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE); } + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglBindAPI(EGLenum api) { EVENT("(EGLenum api = 0x%X)", api); - try + switch (api) { - switch (api) - { - case EGL_OPENGL_API: - case EGL_OPENVG_API: - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); // Not supported by this implementation - case EGL_OPENGL_ES_API: - break; - default: - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); - } + case EGL_OPENGL_API: + case EGL_OPENVG_API: + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); // Not supported by this implementation + case EGL_OPENGL_ES_API: + break; + default: + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); + } - egl::setCurrentAPI(api); + egl::setCurrentAPI(api); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(EGL_TRUE); } EGLenum __stdcall eglQueryAPI(void) { EVENT("()"); - try - { - EGLenum API = egl::getCurrentAPI(); + EGLenum API = egl::getCurrentAPI(); - return egl::success(API); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(API); } EGLBoolean __stdcall eglWaitClient(void) { EVENT("()"); - try - { - UNIMPLEMENTED(); // FIXME + UNIMPLEMENTED(); // FIXME - return egl::success(0); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(0); } EGLBoolean __stdcall eglReleaseThread(void) { EVENT("()"); - try - { - eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE); + eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(EGL_TRUE); } EGLSurface __stdcall eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) @@ -606,26 +559,19 @@ EGLSurface __stdcall eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum bu "EGLConfig config = 0x%0.8p, const EGLint *attrib_list = 0x%0.8p)", dpy, buftype, buffer, config, attrib_list); - try - { - egl::Display *display = static_cast(dpy); - - if (!validateConfig(display, config)) - { - return EGL_NO_SURFACE; - } + egl::Display *display = static_cast(dpy); - if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE || !buffer) - { - return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); - } - - return display->createOffscreenSurface(config, (HANDLE)buffer, attrib_list); + if (!validateConfig(display, config)) + { + return EGL_NO_SURFACE; } - catch(std::bad_alloc&) + + if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE || !buffer) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE); + return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } + + return display->createOffscreenSurface(config, (HANDLE)buffer, attrib_list); } EGLBoolean __stdcall eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) @@ -633,145 +579,117 @@ EGLBoolean __stdcall eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint value = %d)", dpy, surface, attribute, value); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = static_cast(surface); - - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } - - UNIMPLEMENTED(); // FIXME + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = static_cast(surface); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) + if (!validateSurface(display, eglSurface)) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return EGL_FALSE; } + + UNIMPLEMENTED(); // FIXME + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = static_cast(surface); + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = static_cast(surface); - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } - - if (buffer != EGL_BACK_BUFFER) - { - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); - } - - if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle()) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; + } - if (eglSurface->getBoundTexture()) - { - return egl::error(EGL_BAD_ACCESS, EGL_FALSE); - } + if (buffer != EGL_BACK_BUFFER) + { + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); + } - if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE) - { - return egl::error(EGL_BAD_MATCH, EGL_FALSE); - } + if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle()) + { + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); + } - if (!glBindTexImage(eglSurface)) - { - return egl::error(EGL_BAD_MATCH, EGL_FALSE); - } + if (eglSurface->getBoundTexture()) + { + return egl::error(EGL_BAD_ACCESS, EGL_FALSE); + } - return egl::success(EGL_TRUE); + if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE) + { + return egl::error(EGL_BAD_MATCH, EGL_FALSE); } - catch(std::bad_alloc&) + + if (!glBindTexImage(eglSurface)) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_MATCH, EGL_FALSE); } + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = static_cast(surface); + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = static_cast(surface); - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } - - if (buffer != EGL_BACK_BUFFER) - { - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); - } + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; + } - if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle()) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } + if (buffer != EGL_BACK_BUFFER) + { + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); + } - if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE) - { - return egl::error(EGL_BAD_MATCH, EGL_FALSE); - } + if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle()) + { + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); + } - gl::Texture2D *texture = eglSurface->getBoundTexture(); + if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE) + { + return egl::error(EGL_BAD_MATCH, EGL_FALSE); + } - if (texture) - { - texture->releaseTexImage(); - } + gl::Texture2D *texture = eglSurface->getBoundTexture(); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) + if (texture) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + texture->releaseTexImage(); } + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglSwapInterval(EGLDisplay dpy, EGLint interval) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint interval = %d)", dpy, interval); - try - { - egl::Display *display = static_cast(dpy); + egl::Display *display = static_cast(dpy); - if (!validateDisplay(display)) - { - return EGL_FALSE; - } - - egl::Surface *draw_surface = static_cast(egl::getCurrentDrawSurface()); + if (!validateDisplay(display)) + { + return EGL_FALSE; + } - if (draw_surface == NULL) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } - - draw_surface->setSwapInterval(interval); + egl::Surface *draw_surface = static_cast(egl::getCurrentDrawSurface()); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) + if (draw_surface == NULL) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); } + + draw_surface->setSwapInterval(interval); + + return egl::success(EGL_TRUE); } EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) @@ -779,108 +697,97 @@ EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLConte EVENT("(EGLDisplay dpy = 0x%0.8p, EGLConfig config = 0x%0.8p, EGLContext share_context = 0x%0.8p, " "const EGLint *attrib_list = 0x%0.8p)", dpy, config, share_context, attrib_list); - try - { - // Get the requested client version (default is 1) and check it is two. - EGLint client_version = 1; - bool reset_notification = false; - bool robust_access = false; + // Get the requested client version (default is 1) and check it is 2 or 3. + EGLint client_version = 1; + bool reset_notification = false; + bool robust_access = false; - if (attrib_list) + if (attrib_list) + { + for (const EGLint* attribute = attrib_list; attribute[0] != EGL_NONE; attribute += 2) { - for (const EGLint* attribute = attrib_list; attribute[0] != EGL_NONE; attribute += 2) + switch (attribute[0]) { - switch (attribute[0]) + case EGL_CONTEXT_CLIENT_VERSION: + client_version = attribute[1]; + break; + case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT: + if (attribute[1] == EGL_TRUE) { - case EGL_CONTEXT_CLIENT_VERSION: - client_version = attribute[1]; - break; - case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT: - if (attribute[1] == EGL_TRUE) - { - return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT); // Unimplemented - // robust_access = true; - } - else if (attribute[1] != EGL_FALSE) - return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); - break; - case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: - if (attribute[1] == EGL_LOSE_CONTEXT_ON_RESET_EXT) - reset_notification = true; - else if (attribute[1] != EGL_NO_RESET_NOTIFICATION_EXT) - return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); - break; - default: - return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); + return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT); // Unimplemented + // robust_access = true; } + else if (attribute[1] != EGL_FALSE) + return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); + break; + case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: + if (attribute[1] == EGL_LOSE_CONTEXT_ON_RESET_EXT) + reset_notification = true; + else if (attribute[1] != EGL_NO_RESET_NOTIFICATION_EXT) + return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); + break; + default: + return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT); } } + } - if (client_version != 2) - { - return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT); - } + if (client_version != 2 && client_version != 3) + { + return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT); + } - gl::Context *sharedContextPtr = (share_context != EGL_NO_CONTEXT ? static_cast(share_context) : NULL); + egl::Display *display = static_cast(dpy); - if (sharedContextPtr != NULL && sharedContextPtr->isResetNotificationEnabled() != reset_notification) + if (share_context) + { + gl::Context* sharedGLContext = static_cast(share_context); + + if (sharedGLContext->isResetNotificationEnabled() != reset_notification) { return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT); } - egl::Display *display = static_cast(dpy); - - // Can not share contexts between displays - if (sharedContextPtr != NULL && sharedContextPtr->getRenderer() != display->getRenderer()) + if (sharedGLContext->getClientVersion() != client_version) { - return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT); + return egl::error(EGL_BAD_CONTEXT, EGL_NO_CONTEXT); } - if (!validateConfig(display, config)) + // Can not share contexts between displays + if (sharedGLContext->getRenderer() != display->getRenderer()) { - return EGL_NO_CONTEXT; + return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT); } - - EGLContext context = display->createContext(config, static_cast(share_context), reset_notification, robust_access); - - if (context) - return egl::success(context); - else - return egl::error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT); } - catch(std::bad_alloc&) + + if (!validateConfig(display, config)) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_CONTEXT); + return EGL_NO_CONTEXT; } + + return display->createContext(config, client_version, static_cast(share_context), reset_notification, robust_access); } EGLBoolean __stdcall eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p)", dpy, ctx); - try - { - egl::Display *display = static_cast(dpy); - gl::Context *context = static_cast(ctx); - - if (!validateContext(display, context)) - { - return EGL_FALSE; - } - - if (ctx == EGL_NO_CONTEXT) - { - return egl::error(EGL_BAD_CONTEXT, EGL_FALSE); - } + egl::Display *display = static_cast(dpy); + gl::Context *context = static_cast(ctx); - display->destroyContext(context); - - return egl::success(EGL_TRUE); + if (!validateContext(display, context)) + { + return EGL_FALSE; } - catch(std::bad_alloc&) + + if (ctx == EGL_NO_CONTEXT) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_BAD_CONTEXT, EGL_FALSE); } + + display->destroyContext(context); + + return egl::success(EGL_TRUE); } EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) @@ -888,95 +795,74 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface draw = 0x%0.8p, EGLSurface read = 0x%0.8p, EGLContext ctx = 0x%0.8p)", dpy, draw, read, ctx); - try + egl::Display *display = static_cast(dpy); + gl::Context *context = static_cast(ctx); + + if (ctx != EGL_NO_CONTEXT && !validateContext(display, context)) { - egl::Display *display = static_cast(dpy); - gl::Context *context = static_cast(ctx); + return EGL_FALSE; + } - if (ctx != EGL_NO_CONTEXT && !validateContext(display, context)) + if (dpy != EGL_NO_DISPLAY) + { + rx::Renderer *renderer = display->getRenderer(); + if (renderer->testDeviceLost(true)) { return EGL_FALSE; } - if (dpy != EGL_NO_DISPLAY) + if (renderer->isDeviceLost()) { - rx::Renderer *renderer = display->getRenderer(); - if (renderer->testDeviceLost(true)) - { - return EGL_FALSE; - } - - if (renderer->isDeviceLost()) - { - return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); - } + return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); } + } - if ((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast(draw))) || - (read != EGL_NO_SURFACE && !validateSurface(display, static_cast(read)))) - { - return EGL_FALSE; - } + if ((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast(draw))) || + (read != EGL_NO_SURFACE && !validateSurface(display, static_cast(read)))) + { + return EGL_FALSE; + } - if (draw != read) - { - UNIMPLEMENTED(); // FIXME - } + if (draw != read) + { + UNIMPLEMENTED(); // FIXME + } - egl::setCurrentDisplay(dpy); - egl::setCurrentDrawSurface(draw); - egl::setCurrentReadSurface(read); + egl::setCurrentDisplay(dpy); + egl::setCurrentDrawSurface(draw); + egl::setCurrentReadSurface(read); - glMakeCurrent(context, display, static_cast(draw)); + glMakeCurrent(context, display, static_cast(draw)); - return egl::success(EGL_TRUE); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(EGL_TRUE); } EGLContext __stdcall eglGetCurrentContext(void) { EVENT("()"); - try - { - EGLContext context = glGetCurrentContext(); + EGLContext context = glGetCurrentContext(); - return egl::success(context); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_NO_CONTEXT); - } + return egl::success(context); } EGLSurface __stdcall eglGetCurrentSurface(EGLint readdraw) { EVENT("(EGLint readdraw = %d)", readdraw); - try + if (readdraw == EGL_READ) { - if (readdraw == EGL_READ) - { - EGLSurface read = egl::getCurrentReadSurface(); - return egl::success(read); - } - else if (readdraw == EGL_DRAW) - { - EGLSurface draw = egl::getCurrentDrawSurface(); - return egl::success(draw); - } - else - { - return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); - } + EGLSurface read = egl::getCurrentReadSurface(); + return egl::success(read); } - catch(std::bad_alloc&) + else if (readdraw == EGL_DRAW) { - return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE); + EGLSurface draw = egl::getCurrentDrawSurface(); + return egl::success(draw); + } + else + { + return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } } @@ -984,16 +870,9 @@ EGLDisplay __stdcall eglGetCurrentDisplay(void) { EVENT("()"); - try - { - EGLDisplay dpy = egl::getCurrentDisplay(); + EGLDisplay dpy = egl::getCurrentDisplay(); - return egl::success(dpy); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_NO_DISPLAY); - } + return egl::success(dpy); } EGLBoolean __stdcall eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) @@ -1001,90 +880,62 @@ EGLBoolean __stdcall eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attr EVENT("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)", dpy, ctx, attribute, value); - try - { - egl::Display *display = static_cast(dpy); - gl::Context *context = static_cast(ctx); - - if (!validateContext(display, context)) - { - return EGL_FALSE; - } + egl::Display *display = static_cast(dpy); + gl::Context *context = static_cast(ctx); - UNIMPLEMENTED(); // FIXME - - return egl::success(0); - } - catch(std::bad_alloc&) + if (!validateContext(display, context)) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return EGL_FALSE; } + + UNIMPLEMENTED(); // FIXME + + return egl::success(0); } EGLBoolean __stdcall eglWaitGL(void) { EVENT("()"); - try - { - UNIMPLEMENTED(); // FIXME + UNIMPLEMENTED(); // FIXME - return egl::success(0); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(0); } EGLBoolean __stdcall eglWaitNative(EGLint engine) { EVENT("(EGLint engine = %d)", engine); - try - { - UNIMPLEMENTED(); // FIXME + UNIMPLEMENTED(); // FIXME - return egl::success(0); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); - } + return egl::success(0); } EGLBoolean __stdcall eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p)", dpy, surface); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = (egl::Surface*)surface; - - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = (egl::Surface*)surface; - if (display->getRenderer()->isDeviceLost()) - { - return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); - } + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; + } - if (surface == EGL_NO_SURFACE) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } + if (display->getRenderer()->isDeviceLost()) + { + return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); + } - if (eglSurface->swap()) - { - return egl::success(EGL_TRUE); - } + if (surface == EGL_NO_SURFACE) + { + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); } - catch(std::bad_alloc&) + + if (eglSurface->swap()) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::success(EGL_TRUE); } return EGL_FALSE; @@ -1094,68 +945,54 @@ EGLBoolean __stdcall eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativ { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLNativePixmapType target = 0x%0.8p)", dpy, surface, target); - try - { - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = static_cast(surface); - - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } - - if (display->getRenderer()->isDeviceLost()) - { - return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); - } - - UNIMPLEMENTED(); // FIXME + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = static_cast(surface); - return egl::success(0); + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; } - catch(std::bad_alloc&) + + if (display->getRenderer()->isDeviceLost()) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); } + + UNIMPLEMENTED(); // FIXME + + return egl::success(0); } EGLBoolean __stdcall eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height) { EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint x = %d, EGLint y = %d, EGLint width = %d, EGLint height = %d)", dpy, surface, x, y, width, height); - try + if (x < 0 || y < 0 || width < 0 || height < 0) { - if (x < 0 || y < 0 || width < 0 || height < 0) - { - return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); - } - - egl::Display *display = static_cast(dpy); - egl::Surface *eglSurface = static_cast(surface); + return egl::error(EGL_BAD_PARAMETER, EGL_FALSE); + } - if (!validateSurface(display, eglSurface)) - { - return EGL_FALSE; - } + egl::Display *display = static_cast(dpy); + egl::Surface *eglSurface = static_cast(surface); - if (display->getRenderer()->isDeviceLost()) - { - return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); - } + if (!validateSurface(display, eglSurface)) + { + return EGL_FALSE; + } - if (surface == EGL_NO_SURFACE) - { - return egl::error(EGL_BAD_SURFACE, EGL_FALSE); - } + if (display->getRenderer()->isDeviceLost()) + { + return egl::error(EGL_CONTEXT_LOST, EGL_FALSE); + } - if (eglSurface->postSubBuffer(x, y, width, height)) - { - return egl::success(EGL_TRUE); - } + if (surface == EGL_NO_SURFACE) + { + return egl::error(EGL_BAD_SURFACE, EGL_FALSE); } - catch(std::bad_alloc&) + + if (eglSurface->postSubBuffer(x, y, width, height)) { - return egl::error(EGL_BAD_ALLOC, EGL_FALSE); + return egl::success(EGL_TRUE); } return EGL_FALSE; @@ -1165,34 +1002,28 @@ __eglMustCastToProperFunctionPointerType __stdcall eglGetProcAddress(const char { EVENT("(const char *procname = \"%s\")", procname); - try + struct Extension { - struct Extension - { - const char *name; - __eglMustCastToProperFunctionPointerType address; - }; + const char *name; + __eglMustCastToProperFunctionPointerType address; + }; - static const Extension eglExtensions[] = - { - {"eglQuerySurfacePointerANGLE", (__eglMustCastToProperFunctionPointerType)eglQuerySurfacePointerANGLE}, - {"eglPostSubBufferNV", (__eglMustCastToProperFunctionPointerType)eglPostSubBufferNV}, - {"", NULL}, - }; + static const Extension eglExtensions[] = + { + { "eglQuerySurfacePointerANGLE", (__eglMustCastToProperFunctionPointerType)eglQuerySurfacePointerANGLE }, + { "eglPostSubBufferNV", (__eglMustCastToProperFunctionPointerType)eglPostSubBufferNV }, + { "eglGetPlatformDisplayEXT", (__eglMustCastToProperFunctionPointerType)eglGetPlatformDisplayEXT }, + { "", NULL }, + }; - for (unsigned int ext = 0; ext < ArraySize(eglExtensions); ext++) + for (unsigned int ext = 0; ext < ArraySize(eglExtensions); ext++) + { + if (strcmp(procname, eglExtensions[ext].name) == 0) { - if (strcmp(procname, eglExtensions[ext].name) == 0) - { - return (__eglMustCastToProperFunctionPointerType)eglExtensions[ext].address; - } + return (__eglMustCastToProperFunctionPointerType)eglExtensions[ext].address; } - - return glGetProcAddress(procname); - } - catch(std::bad_alloc&) - { - return egl::error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL); } + + return glGetProcAddress(procname); } } -- cgit v1.2.3