| // |
| // 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 |
| // found in the LICENSE file. |
| // |
| |
| // Surface.cpp: Implements the egl::Surface class, representing a drawing surface |
| // such as the client area of a window, including any back buffers. |
| // Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3. |
| |
| #include <tchar.h> |
| |
| #include "libEGL/Surface.h" |
| |
| #include "common/debug.h" |
| #include "libGLESv2/Texture.h" |
| #include "libGLESv2/renderer/SwapChain.h" |
| #include "libGLESv2/main.h" |
| |
| #include "libEGL/main.h" |
| #include "libEGL/Display.h" |
| |
| #include <dwmapi.h> |
| |
| namespace egl |
| { |
| |
| Surface::Surface(Display *display, const Config *config, HWND window, EGLint postSubBufferSupported) |
| : mDisplay(display), mConfig(config), mWindow(window), mPostSubBufferSupported(postSubBufferSupported) |
| { |
| mRenderer = mDisplay->getRenderer(); |
| mSwapChain = NULL; |
| mShareHandle = NULL; |
| mTexture = NULL; |
| mTextureFormat = EGL_NO_TEXTURE; |
| mTextureTarget = EGL_NO_TEXTURE; |
| |
| mPixelAspectRatio = (EGLint)(1.0 * EGL_DISPLAY_SCALING); // FIXME: Determine actual pixel aspect ratio |
| mRenderBuffer = EGL_BACK_BUFFER; |
| mSwapBehavior = EGL_BUFFER_PRESERVED; |
| mSwapInterval = -1; |
| mWidth = -1; |
| mHeight = -1; |
| setSwapInterval(1); |
| |
| subclassWindow(); |
| } |
| |
| Surface::Surface(Display *display, const Config *config, HANDLE shareHandle, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureType) |
| : mDisplay(display), mWindow(NULL), mConfig(config), mShareHandle(shareHandle), mWidth(width), mHeight(height), mPostSubBufferSupported(EGL_FALSE) |
| { |
| mRenderer = mDisplay->getRenderer(); |
| mSwapChain = NULL; |
| mWindowSubclassed = false; |
| mTexture = NULL; |
| mTextureFormat = textureFormat; |
| mTextureTarget = textureType; |
| |
| mPixelAspectRatio = (EGLint)(1.0 * EGL_DISPLAY_SCALING); // FIXME: Determine actual pixel aspect ratio |
| mRenderBuffer = EGL_BACK_BUFFER; |
| mSwapBehavior = EGL_BUFFER_PRESERVED; |
| mSwapInterval = -1; |
| setSwapInterval(1); |
| } |
| |
| Surface::~Surface() |
| { |
| unsubclassWindow(); |
| release(); |
| } |
| |
| bool Surface::initialize() |
| { |
| if (!resetSwapChain()) |
| return false; |
| |
| // Modify present parameters for this window, if we are composited, |
| // to minimize the amount of queuing done by DWM between our calls to |
| // present and the actual screen. |
| if (mWindow && (getComparableOSVersion() >= versionWindowsVista)) { |
| BOOL isComposited; |
| HRESULT result = DwmIsCompositionEnabled(&isComposited); |
| if (SUCCEEDED(result) && isComposited) { |
| DWM_PRESENT_PARAMETERS presentParams; |
| memset(&presentParams, 0, sizeof(presentParams)); |
| presentParams.cbSize = sizeof(DWM_PRESENT_PARAMETERS); |
| presentParams.cBuffer = 2; |
| |
| result = DwmSetPresentParameters(mWindow, &presentParams); |
| if (FAILED(result)) |
| ERR("Unable to set present parameters: 0x%08X", result); |
| } |
| } |
| |
| return true; |
| } |
| |
| void Surface::release() |
| { |
| delete mSwapChain; |
| mSwapChain = NULL; |
| |
| if (mTexture) |
| { |
| mTexture->releaseTexImage(); |
| mTexture = NULL; |
| } |
| } |
| |
| bool Surface::resetSwapChain() |
| { |
| ASSERT(!mSwapChain); |
| |
| int width; |
| int height; |
| |
| if (mWindow) |
| { |
| RECT windowRect; |
| if (!GetClientRect(getWindowHandle(), &windowRect)) |
| { |
| ASSERT(false); |
| |
| ERR("Could not retrieve the window dimensions"); |
| return error(EGL_BAD_SURFACE, false); |
| } |
| |
| width = windowRect.right - windowRect.left; |
| height = windowRect.bottom - windowRect.top; |
| } |
| else |
| { |
| // non-window surface - size is determined at creation |
| width = mWidth; |
| height = mHeight; |
| } |
| |
| mSwapChain = mRenderer->createSwapChain(mWindow, mShareHandle, |
| mConfig->mRenderTargetFormat, |
| mConfig->mDepthStencilFormat); |
| if (!mSwapChain) |
| { |
| return error(EGL_BAD_ALLOC, false); |
| } |
| |
| if (!resetSwapChain(width, height)) |
| { |
| delete mSwapChain; |
| mSwapChain = NULL; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool Surface::resetSwapChain(int backbufferWidth, int backbufferHeight) |
| { |
| ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0); |
| ASSERT(mSwapChain); |
| |
| EGLint status = mSwapChain->reset(backbufferWidth, backbufferHeight, mSwapInterval); |
| |
| if (status == EGL_CONTEXT_LOST) |
| { |
| mRenderer->notifyDeviceLost(); |
| return false; |
| } |
| else if (status != EGL_SUCCESS) |
| { |
| return error(status, false); |
| } |
| |
| mWidth = backbufferWidth; |
| mHeight = backbufferHeight; |
| mSwapIntervalDirty = false; |
| |
| return true; |
| } |
| |
| bool Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height) |
| { |
| if (!mSwapChain) |
| { |
| return true; |
| } |
| |
| if (x + width > mWidth) |
| { |
| width = mWidth - x; |
| } |
| |
| if (y + height > mHeight) |
| { |
| height = mHeight - y; |
| } |
| |
| if (width == 0 || height == 0) |
| { |
| return true; |
| } |
| |
| EGLint status = mSwapChain->swapRect(x, y, width, height); |
| |
| if (status == EGL_CONTEXT_LOST) |
| { |
| mRenderer->notifyDeviceLost(); |
| return false; |
| } |
| else if (status != EGL_SUCCESS) |
| { |
| return error(status, false); |
| } |
| |
| checkForOutOfDateSwapChain(); |
| |
| return true; |
| } |
| |
| HWND Surface::getWindowHandle() |
| { |
| return mWindow; |
| } |
| |
| |
| #define kSurfaceProperty _TEXT("Egl::SurfaceOwner") |
| #define kParentWndProc _TEXT("Egl::SurfaceParentWndProc") |
| |
| static LRESULT CALLBACK SurfaceWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) |
| { |
| if (message == WM_SIZE) |
| { |
| Surface* surf = reinterpret_cast<Surface*>(GetProp(hwnd, kSurfaceProperty)); |
| if(surf) |
| { |
| surf->checkForOutOfDateSwapChain(); |
| } |
| } |
| WNDPROC prevWndFunc = reinterpret_cast<WNDPROC >(GetProp(hwnd, kParentWndProc)); |
| return CallWindowProc(prevWndFunc, hwnd, message, wparam, lparam); |
| } |
| |
| void Surface::subclassWindow() |
| { |
| if (!mWindow) |
| { |
| return; |
| } |
| |
| DWORD processId; |
| DWORD threadId = GetWindowThreadProcessId(mWindow, &processId); |
| if (processId != GetCurrentProcessId() || threadId != GetCurrentThreadId()) |
| { |
| return; |
| } |
| |
| SetLastError(0); |
| LONG_PTR oldWndProc = SetWindowLongPtr(mWindow, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(SurfaceWindowProc)); |
| if(oldWndProc == 0 && GetLastError() != ERROR_SUCCESS) |
| { |
| mWindowSubclassed = false; |
| return; |
| } |
| |
| SetProp(mWindow, kSurfaceProperty, reinterpret_cast<HANDLE>(this)); |
| SetProp(mWindow, kParentWndProc, reinterpret_cast<HANDLE>(oldWndProc)); |
| mWindowSubclassed = true; |
| } |
| |
| void Surface::unsubclassWindow() |
| { |
| if(!mWindowSubclassed) |
| { |
| return; |
| } |
| |
| // un-subclass |
| LONG_PTR parentWndFunc = reinterpret_cast<LONG_PTR>(GetProp(mWindow, kParentWndProc)); |
| |
| // Check the windowproc is still SurfaceWindowProc. |
| // If this assert fails, then it is likely the application has subclassed the |
| // hwnd as well and did not unsubclass before destroying its EGL context. The |
| // application should be modified to either subclass before initializing the |
| // EGL context, or to unsubclass before destroying the EGL context. |
| if(parentWndFunc) |
| { |
| LONG_PTR prevWndFunc = SetWindowLongPtr(mWindow, GWLP_WNDPROC, parentWndFunc); |
| ASSERT(prevWndFunc == reinterpret_cast<LONG_PTR>(SurfaceWindowProc)); |
| } |
| |
| RemoveProp(mWindow, kSurfaceProperty); |
| RemoveProp(mWindow, kParentWndProc); |
| mWindowSubclassed = false; |
| } |
| |
| bool Surface::checkForOutOfDateSwapChain() |
| { |
| RECT client; |
| if (!GetClientRect(getWindowHandle(), &client)) |
| { |
| ASSERT(false); |
| return false; |
| } |
| |
| // 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; |
| bool sizeDirty = clientWidth != getWidth() || clientHeight != getHeight(); |
| |
| if (sizeDirty || mSwapIntervalDirty) |
| { |
| resetSwapChain(clientWidth, clientHeight); |
| if (static_cast<egl::Surface*>(getCurrentDrawSurface()) == this) |
| { |
| glMakeCurrent(glGetCurrentContext(), static_cast<egl::Display*>(getCurrentDisplay()), this); |
| } |
| |
| return true; |
| } |
| return false; |
| } |
| |
| bool Surface::swap() |
| { |
| return swapRect(0, 0, mWidth, mHeight); |
| } |
| |
| bool Surface::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height) |
| { |
| if (!mPostSubBufferSupported) |
| { |
| // Spec is not clear about how this should be handled. |
| return true; |
| } |
| |
| return swapRect(x, y, width, height); |
| } |
| |
| EGLint Surface::getWidth() const |
| { |
| return mWidth; |
| } |
| |
| EGLint Surface::getHeight() const |
| { |
| return mHeight; |
| } |
| |
| EGLint Surface::isPostSubBufferSupported() const |
| { |
| return mPostSubBufferSupported; |
| } |
| |
| rx::SwapChain *Surface::getSwapChain() const |
| { |
| return mSwapChain; |
| } |
| |
| void Surface::setSwapInterval(EGLint interval) |
| { |
| if (mSwapInterval == interval) |
| { |
| return; |
| } |
| |
| mSwapInterval = interval; |
| mSwapInterval = std::max(mSwapInterval, mRenderer->getMinSwapInterval()); |
| mSwapInterval = std::min(mSwapInterval, mRenderer->getMaxSwapInterval()); |
| |
| mSwapIntervalDirty = true; |
| } |
| |
| EGLenum Surface::getTextureFormat() const |
| { |
| return mTextureFormat; |
| } |
| |
| EGLenum Surface::getTextureTarget() const |
| { |
| return mTextureTarget; |
| } |
| |
| void Surface::setBoundTexture(gl::Texture2D *texture) |
| { |
| mTexture = texture; |
| } |
| |
| gl::Texture2D *Surface::getBoundTexture() const |
| { |
| return mTexture; |
| } |
| |
| EGLenum Surface::getFormat() const |
| { |
| return mConfig->mRenderTargetFormat; |
| } |
| } |