daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 1 | // |
Geoff Lang | cec3590 | 2014-04-16 10:52:36 -0400 | [diff] [blame] | 2 | // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved. |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 3 | // Use of this source code is governed by a BSD-style license that can be |
| 4 | // found in the LICENSE file. |
| 5 | // |
| 6 | |
| 7 | // Display.cpp: Implements the egl::Display class, representing the abstract |
| 8 | // display on which graphics are drawn. Implements EGLDisplay. |
| 9 | // [EGL 1.4] section 2.1.2 page 3. |
| 10 | |
| 11 | #include "libEGL/Display.h" |
| 12 | |
| 13 | #include <algorithm> |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 14 | #include <map> |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 15 | #include <vector> |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 16 | #include <sstream> |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 17 | |
| 18 | #include "common/debug.h" |
shannonwoods@chromium.org | a2ecfcc | 2013-05-30 00:11:59 +0000 | [diff] [blame] | 19 | #include "common/mathutil.h" |
daniel@transgaming.com | cfa8efd | 2012-11-28 19:30:55 +0000 | [diff] [blame] | 20 | #include "libGLESv2/main.h" |
shannon.woods@transgaming.com | 486d9e9 | 2013-02-28 23:15:41 +0000 | [diff] [blame] | 21 | #include "libGLESv2/Context.h" |
shannon.woods%transgaming.com@gtempaccount.com | 8bce3f5 | 2013-04-13 03:35:32 +0000 | [diff] [blame] | 22 | #include "libGLESv2/renderer/SwapChain.h" |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 23 | |
| 24 | #include "libEGL/main.h" |
shannon.woods@transgaming.com | 486d9e9 | 2013-02-28 23:15:41 +0000 | [diff] [blame] | 25 | #include "libEGL/Surface.h" |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 26 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 27 | namespace egl |
| 28 | { |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 29 | |
| 30 | typedef std::map<EGLNativeDisplayType, Display*> DisplayMap; |
| 31 | static DisplayMap *GetDisplayMap() |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 32 | { |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 33 | static DisplayMap displays; |
| 34 | return &displays; |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 35 | } |
| 36 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 37 | egl::Display *Display::getDisplay(EGLNativeDisplayType displayId, EGLint displayType) |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 38 | { |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 39 | DisplayMap *displays = GetDisplayMap(); |
| 40 | DisplayMap::const_iterator iter = displays->find(displayId); |
| 41 | if (iter != displays->end()) |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 42 | { |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 43 | return iter->second; |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 44 | } |
shannonwoods@chromium.org | eff3a12 | 2013-05-30 00:10:04 +0000 | [diff] [blame] | 45 | |
| 46 | // FIXME: Check if displayId is a valid display device context |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 47 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 48 | egl::Display *display = new egl::Display(displayId, displayType); |
| 49 | displays->insert(std::make_pair(displayId, display)); |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 50 | |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 51 | return display; |
| 52 | } |
| 53 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 54 | Display::Display(EGLNativeDisplayType displayId, EGLint displayType) |
| 55 | : mDisplayId(displayId), |
| 56 | mRequestedDisplayType(displayType), |
| 57 | mRenderer(NULL) |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 58 | { |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | Display::~Display() |
| 62 | { |
| 63 | terminate(); |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 64 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 65 | DisplayMap *displays = GetDisplayMap(); |
| 66 | DisplayMap::iterator iter = displays->find(mDisplayId); |
| 67 | if (iter != displays->end()) |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 68 | { |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 69 | displays->erase(iter); |
jbauman@chromium.org | 84d7cbc | 2011-07-14 22:53:19 +0000 | [diff] [blame] | 70 | } |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | bool Display::initialize() |
| 74 | { |
| 75 | if (isInitialized()) |
| 76 | { |
| 77 | return true; |
| 78 | } |
| 79 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 80 | mRenderer = glCreateRenderer(this, mDisplayId, mRequestedDisplayType); |
| 81 | |
daniel@transgaming.com | c1e2634 | 2012-11-28 19:31:16 +0000 | [diff] [blame] | 82 | if (!mRenderer) |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 83 | { |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 84 | terminate(); |
daniel@transgaming.com | c1e2634 | 2012-11-28 19:31:16 +0000 | [diff] [blame] | 85 | return error(EGL_NOT_INITIALIZED, false); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 86 | } |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 87 | |
daniel@transgaming.com | 114bd46 | 2012-10-31 18:42:47 +0000 | [diff] [blame] | 88 | EGLint minSwapInterval = mRenderer->getMinSwapInterval(); |
| 89 | EGLint maxSwapInterval = mRenderer->getMaxSwapInterval(); |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 90 | EGLint maxTextureSize = mRenderer->getRendererCaps().max2DTextureSize; |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 91 | |
daniel@transgaming.com | 76d3e6e | 2012-10-31 19:55:33 +0000 | [diff] [blame] | 92 | rx::ConfigDesc *descList; |
daniel@transgaming.com | 3281f97 | 2012-10-31 18:38:51 +0000 | [diff] [blame] | 93 | int numConfigs = mRenderer->generateConfigs(&descList); |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 94 | ConfigSet configSet; |
| 95 | |
daniel@transgaming.com | 3281f97 | 2012-10-31 18:38:51 +0000 | [diff] [blame] | 96 | for (int i = 0; i < numConfigs; ++i) |
Geoff Lang | aae65a4 | 2014-05-26 12:43:44 -0400 | [diff] [blame] | 97 | { |
| 98 | configSet.add(descList[i], minSwapInterval, maxSwapInterval, maxTextureSize, maxTextureSize); |
| 99 | } |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 100 | |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 101 | // Give the sorted configs a unique ID and store them internally |
| 102 | EGLint index = 1; |
| 103 | for (ConfigSet::Iterator config = configSet.mSet.begin(); config != configSet.mSet.end(); config++) |
| 104 | { |
| 105 | Config configuration = *config; |
| 106 | configuration.mConfigID = index; |
| 107 | index++; |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 108 | |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 109 | mConfigSet.mSet.insert(configuration); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 110 | } |
| 111 | |
daniel@transgaming.com | 3281f97 | 2012-10-31 18:38:51 +0000 | [diff] [blame] | 112 | mRenderer->deleteConfigs(descList); |
| 113 | descList = NULL; |
| 114 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 115 | if (!isInitialized()) |
| 116 | { |
| 117 | terminate(); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 118 | return false; |
| 119 | } |
| 120 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 121 | initDisplayExtensionString(); |
shannonwoods@chromium.org | 6e4f2a6 | 2013-05-30 00:15:19 +0000 | [diff] [blame] | 122 | initVendorString(); |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 123 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 124 | return true; |
| 125 | } |
| 126 | |
| 127 | void Display::terminate() |
| 128 | { |
| 129 | while (!mSurfaceSet.empty()) |
| 130 | { |
| 131 | destroySurface(*mSurfaceSet.begin()); |
| 132 | } |
| 133 | |
| 134 | while (!mContextSet.empty()) |
| 135 | { |
| 136 | destroyContext(*mContextSet.begin()); |
| 137 | } |
| 138 | |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 139 | glDestroyRenderer(mRenderer); |
| 140 | mRenderer = NULL; |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | bool Display::getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig) |
| 144 | { |
| 145 | return mConfigSet.getConfigs(configs, attribList, configSize, numConfig); |
| 146 | } |
| 147 | |
| 148 | bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value) |
| 149 | { |
| 150 | const egl::Config *configuration = mConfigSet.get(config); |
| 151 | |
| 152 | switch (attribute) |
| 153 | { |
| 154 | case EGL_BUFFER_SIZE: *value = configuration->mBufferSize; break; |
| 155 | case EGL_ALPHA_SIZE: *value = configuration->mAlphaSize; break; |
| 156 | case EGL_BLUE_SIZE: *value = configuration->mBlueSize; break; |
| 157 | case EGL_GREEN_SIZE: *value = configuration->mGreenSize; break; |
| 158 | case EGL_RED_SIZE: *value = configuration->mRedSize; break; |
| 159 | case EGL_DEPTH_SIZE: *value = configuration->mDepthSize; break; |
| 160 | case EGL_STENCIL_SIZE: *value = configuration->mStencilSize; break; |
| 161 | case EGL_CONFIG_CAVEAT: *value = configuration->mConfigCaveat; break; |
| 162 | case EGL_CONFIG_ID: *value = configuration->mConfigID; break; |
| 163 | case EGL_LEVEL: *value = configuration->mLevel; break; |
| 164 | case EGL_NATIVE_RENDERABLE: *value = configuration->mNativeRenderable; break; |
| 165 | case EGL_NATIVE_VISUAL_TYPE: *value = configuration->mNativeVisualType; break; |
| 166 | case EGL_SAMPLES: *value = configuration->mSamples; break; |
| 167 | case EGL_SAMPLE_BUFFERS: *value = configuration->mSampleBuffers; break; |
| 168 | case EGL_SURFACE_TYPE: *value = configuration->mSurfaceType; break; |
| 169 | case EGL_TRANSPARENT_TYPE: *value = configuration->mTransparentType; break; |
| 170 | case EGL_TRANSPARENT_BLUE_VALUE: *value = configuration->mTransparentBlueValue; break; |
| 171 | case EGL_TRANSPARENT_GREEN_VALUE: *value = configuration->mTransparentGreenValue; break; |
| 172 | case EGL_TRANSPARENT_RED_VALUE: *value = configuration->mTransparentRedValue; break; |
| 173 | case EGL_BIND_TO_TEXTURE_RGB: *value = configuration->mBindToTextureRGB; break; |
| 174 | case EGL_BIND_TO_TEXTURE_RGBA: *value = configuration->mBindToTextureRGBA; break; |
| 175 | case EGL_MIN_SWAP_INTERVAL: *value = configuration->mMinSwapInterval; break; |
| 176 | case EGL_MAX_SWAP_INTERVAL: *value = configuration->mMaxSwapInterval; break; |
| 177 | case EGL_LUMINANCE_SIZE: *value = configuration->mLuminanceSize; break; |
| 178 | case EGL_ALPHA_MASK_SIZE: *value = configuration->mAlphaMaskSize; break; |
| 179 | case EGL_COLOR_BUFFER_TYPE: *value = configuration->mColorBufferType; break; |
| 180 | case EGL_RENDERABLE_TYPE: *value = configuration->mRenderableType; break; |
| 181 | case EGL_MATCH_NATIVE_PIXMAP: *value = false; UNIMPLEMENTED(); break; |
| 182 | case EGL_CONFORMANT: *value = configuration->mConformant; break; |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 183 | case EGL_MAX_PBUFFER_WIDTH: *value = configuration->mMaxPBufferWidth; break; |
| 184 | case EGL_MAX_PBUFFER_HEIGHT: *value = configuration->mMaxPBufferHeight; break; |
| 185 | case EGL_MAX_PBUFFER_PIXELS: *value = configuration->mMaxPBufferPixels; break; |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 186 | default: |
| 187 | return false; |
| 188 | } |
| 189 | |
| 190 | return true; |
| 191 | } |
| 192 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 193 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 194 | |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 195 | EGLSurface Display::createWindowSurface(HWND window, EGLConfig config, const EGLint *attribList) |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 196 | { |
| 197 | const Config *configuration = mConfigSet.get(config); |
apatrick@chromium.org | f4490e2 | 2011-12-06 02:05:22 +0000 | [diff] [blame] | 198 | EGLint postSubBufferSupported = EGL_FALSE; |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 199 | |
John Bauman | 3dc300a | 2014-01-28 15:30:35 -0800 | [diff] [blame] | 200 | EGLint width = 0; |
| 201 | EGLint height = 0; |
| 202 | EGLint fixedSize = EGL_FALSE; |
| 203 | |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 204 | if (attribList) |
| 205 | { |
| 206 | while (*attribList != EGL_NONE) |
| 207 | { |
| 208 | switch (attribList[0]) |
| 209 | { |
| 210 | case EGL_RENDER_BUFFER: |
| 211 | switch (attribList[1]) |
| 212 | { |
| 213 | case EGL_BACK_BUFFER: |
| 214 | break; |
| 215 | case EGL_SINGLE_BUFFER: |
| 216 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); // Rendering directly to front buffer not supported |
| 217 | default: |
| 218 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 219 | } |
| 220 | break; |
apatrick@chromium.org | f4490e2 | 2011-12-06 02:05:22 +0000 | [diff] [blame] | 221 | case EGL_POST_SUB_BUFFER_SUPPORTED_NV: |
| 222 | postSubBufferSupported = attribList[1]; |
| 223 | break; |
John Bauman | 3dc300a | 2014-01-28 15:30:35 -0800 | [diff] [blame] | 224 | case EGL_WIDTH: |
| 225 | width = attribList[1]; |
| 226 | break; |
| 227 | case EGL_HEIGHT: |
| 228 | height = attribList[1]; |
| 229 | break; |
| 230 | case EGL_FIXED_SIZE_ANGLE: |
| 231 | fixedSize = attribList[1]; |
| 232 | break; |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 233 | case EGL_VG_COLORSPACE: |
| 234 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 235 | case EGL_VG_ALPHA_FORMAT: |
| 236 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 237 | default: |
| 238 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 239 | } |
| 240 | |
| 241 | attribList += 2; |
| 242 | } |
| 243 | } |
| 244 | |
John Bauman | 3dc300a | 2014-01-28 15:30:35 -0800 | [diff] [blame] | 245 | if (width < 0 || height < 0) |
| 246 | { |
| 247 | return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); |
| 248 | } |
| 249 | |
| 250 | if (!fixedSize) |
| 251 | { |
| 252 | width = -1; |
| 253 | height = -1; |
| 254 | } |
| 255 | |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 256 | if (hasExistingWindowSurface(window)) |
| 257 | { |
| 258 | return error(EGL_BAD_ALLOC, EGL_NO_SURFACE); |
| 259 | } |
| 260 | |
daniel@transgaming.com | f688c0d | 2012-10-31 17:52:57 +0000 | [diff] [blame] | 261 | if (mRenderer->testDeviceLost(false)) |
daniel@transgaming.com | cf23c45 | 2011-11-09 17:47:26 +0000 | [diff] [blame] | 262 | { |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 263 | if (!restoreLostDevice()) |
| 264 | return EGL_NO_SURFACE; |
| 265 | } |
| 266 | |
John Bauman | 3dc300a | 2014-01-28 15:30:35 -0800 | [diff] [blame] | 267 | Surface *surface = new Surface(this, configuration, window, fixedSize, width, height, postSubBufferSupported); |
jbauman@chromium.org | 4e29770 | 2011-05-12 23:04:07 +0000 | [diff] [blame] | 268 | |
| 269 | if (!surface->initialize()) |
| 270 | { |
| 271 | delete surface; |
| 272 | return EGL_NO_SURFACE; |
| 273 | } |
| 274 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 275 | mSurfaceSet.insert(surface); |
| 276 | |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 277 | return success(surface); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 278 | } |
| 279 | |
jbauman@chromium.org | 4e29770 | 2011-05-12 23:04:07 +0000 | [diff] [blame] | 280 | EGLSurface Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList) |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 281 | { |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 282 | EGLint width = 0, height = 0; |
| 283 | EGLenum textureFormat = EGL_NO_TEXTURE; |
| 284 | EGLenum textureTarget = EGL_NO_TEXTURE; |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 285 | const Config *configuration = mConfigSet.get(config); |
| 286 | |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 287 | if (attribList) |
| 288 | { |
| 289 | while (*attribList != EGL_NONE) |
| 290 | { |
| 291 | switch (attribList[0]) |
| 292 | { |
| 293 | case EGL_WIDTH: |
| 294 | width = attribList[1]; |
| 295 | break; |
| 296 | case EGL_HEIGHT: |
| 297 | height = attribList[1]; |
| 298 | break; |
| 299 | case EGL_LARGEST_PBUFFER: |
| 300 | if (attribList[1] != EGL_FALSE) |
| 301 | UNIMPLEMENTED(); // FIXME |
| 302 | break; |
| 303 | case EGL_TEXTURE_FORMAT: |
| 304 | switch (attribList[1]) |
| 305 | { |
| 306 | case EGL_NO_TEXTURE: |
| 307 | case EGL_TEXTURE_RGB: |
| 308 | case EGL_TEXTURE_RGBA: |
| 309 | textureFormat = attribList[1]; |
| 310 | break; |
| 311 | default: |
| 312 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 313 | } |
| 314 | break; |
| 315 | case EGL_TEXTURE_TARGET: |
| 316 | switch (attribList[1]) |
| 317 | { |
| 318 | case EGL_NO_TEXTURE: |
| 319 | case EGL_TEXTURE_2D: |
| 320 | textureTarget = attribList[1]; |
| 321 | break; |
| 322 | default: |
| 323 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 324 | } |
| 325 | break; |
| 326 | case EGL_MIPMAP_TEXTURE: |
| 327 | if (attribList[1] != EGL_FALSE) |
| 328 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 329 | break; |
| 330 | case EGL_VG_COLORSPACE: |
| 331 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 332 | case EGL_VG_ALPHA_FORMAT: |
| 333 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 334 | default: |
| 335 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 336 | } |
| 337 | |
| 338 | attribList += 2; |
| 339 | } |
| 340 | } |
| 341 | |
| 342 | if (width < 0 || height < 0) |
| 343 | { |
| 344 | return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE); |
| 345 | } |
| 346 | |
| 347 | if (width == 0 || height == 0) |
| 348 | { |
| 349 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 350 | } |
| 351 | |
Geoff Lang | c0b9ef4 | 2014-07-02 10:02:37 -0400 | [diff] [blame] | 352 | if (textureFormat != EGL_NO_TEXTURE && !mRenderer->getRendererExtensions().textureNPOT && (!gl::isPow2(width) || !gl::isPow2(height))) |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 353 | { |
| 354 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 355 | } |
| 356 | |
| 357 | if ((textureFormat != EGL_NO_TEXTURE && textureTarget == EGL_NO_TEXTURE) || |
| 358 | (textureFormat == EGL_NO_TEXTURE && textureTarget != EGL_NO_TEXTURE)) |
| 359 | { |
| 360 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 361 | } |
| 362 | |
| 363 | if (!(configuration->mSurfaceType & EGL_PBUFFER_BIT)) |
| 364 | { |
| 365 | return error(EGL_BAD_MATCH, EGL_NO_SURFACE); |
| 366 | } |
| 367 | |
| 368 | if ((textureFormat == EGL_TEXTURE_RGB && configuration->mBindToTextureRGB != EGL_TRUE) || |
| 369 | (textureFormat == EGL_TEXTURE_RGBA && configuration->mBindToTextureRGBA != EGL_TRUE)) |
| 370 | { |
| 371 | return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); |
| 372 | } |
| 373 | |
daniel@transgaming.com | f688c0d | 2012-10-31 17:52:57 +0000 | [diff] [blame] | 374 | if (mRenderer->testDeviceLost(false)) |
daniel@transgaming.com | cf23c45 | 2011-11-09 17:47:26 +0000 | [diff] [blame] | 375 | { |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 376 | if (!restoreLostDevice()) |
| 377 | return EGL_NO_SURFACE; |
| 378 | } |
| 379 | |
jbauman@chromium.org | 4e29770 | 2011-05-12 23:04:07 +0000 | [diff] [blame] | 380 | Surface *surface = new Surface(this, configuration, shareHandle, width, height, textureFormat, textureTarget); |
| 381 | |
| 382 | if (!surface->initialize()) |
| 383 | { |
| 384 | delete surface; |
| 385 | return EGL_NO_SURFACE; |
| 386 | } |
| 387 | |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 388 | mSurfaceSet.insert(surface); |
| 389 | |
jbauman@chromium.org | 06d7a75 | 2011-04-30 01:02:52 +0000 | [diff] [blame] | 390 | return success(surface); |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 391 | } |
| 392 | |
shannon.woods%transgaming.com@gtempaccount.com | daea4b4 | 2013-04-13 03:28:54 +0000 | [diff] [blame] | 393 | EGLContext Display::createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets, bool robustAccess) |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 394 | { |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 395 | if (!mRenderer) |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 396 | { |
shannon.woods%transgaming.com@gtempaccount.com | 2104d93 | 2013-04-13 03:38:46 +0000 | [diff] [blame] | 397 | return EGL_NO_CONTEXT; |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 398 | } |
daniel@transgaming.com | f688c0d | 2012-10-31 17:52:57 +0000 | [diff] [blame] | 399 | else if (mRenderer->testDeviceLost(false)) // Lost device |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 400 | { |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 401 | if (!restoreLostDevice()) |
shannon.woods%transgaming.com@gtempaccount.com | 2104d93 | 2013-04-13 03:38:46 +0000 | [diff] [blame] | 402 | { |
| 403 | return error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT); |
| 404 | } |
| 405 | } |
| 406 | |
| 407 | if (clientVersion > 2 && mRenderer->getMajorShaderModel() < 4) |
| 408 | { |
| 409 | return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 410 | } |
| 411 | |
shannon.woods%transgaming.com@gtempaccount.com | daea4b4 | 2013-04-13 03:28:54 +0000 | [diff] [blame] | 412 | gl::Context *context = glCreateContext(clientVersion, shareContext, mRenderer, notifyResets, robustAccess); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 413 | mContextSet.insert(context); |
| 414 | |
shannon.woods%transgaming.com@gtempaccount.com | 2104d93 | 2013-04-13 03:38:46 +0000 | [diff] [blame] | 415 | return success(context); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 416 | } |
| 417 | |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 418 | bool Display::restoreLostDevice() |
| 419 | { |
daniel@transgaming.com | cf23c45 | 2011-11-09 17:47:26 +0000 | [diff] [blame] | 420 | for (ContextSet::iterator ctx = mContextSet.begin(); ctx != mContextSet.end(); ctx++) |
| 421 | { |
| 422 | if ((*ctx)->isResetNotificationEnabled()) |
| 423 | return false; // If reset notifications have been requested, application must delete all contexts first |
| 424 | } |
| 425 | |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 426 | // Release surface resources to make the Reset() succeed |
| 427 | for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++) |
| 428 | { |
| 429 | (*surface)->release(); |
| 430 | } |
| 431 | |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 432 | if (!mRenderer->resetDevice()) |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 433 | { |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 434 | return error(EGL_BAD_ALLOC, false); |
vangelis@google.com | 8c9c452 | 2011-09-09 18:22:28 +0000 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | // Restore any surfaces that may have been lost |
| 438 | for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++) |
| 439 | { |
| 440 | (*surface)->resetSwapChain(); |
| 441 | } |
| 442 | |
| 443 | return true; |
| 444 | } |
| 445 | |
| 446 | |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 447 | void Display::destroySurface(egl::Surface *surface) |
| 448 | { |
daniel@transgaming.com | c556fa5 | 2011-05-26 14:13:29 +0000 | [diff] [blame] | 449 | delete surface; |
| 450 | mSurfaceSet.erase(surface); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 451 | } |
| 452 | |
| 453 | void Display::destroyContext(gl::Context *context) |
| 454 | { |
| 455 | glDestroyContext(context); |
| 456 | mContextSet.erase(context); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 457 | } |
| 458 | |
daniel@transgaming.com | 09fcc9f | 2011-11-09 17:46:47 +0000 | [diff] [blame] | 459 | void Display::notifyDeviceLost() |
| 460 | { |
| 461 | for (ContextSet::iterator context = mContextSet.begin(); context != mContextSet.end(); context++) |
| 462 | { |
| 463 | (*context)->markContextLost(); |
| 464 | } |
shannon.woods@transgaming.com | 779aa26 | 2013-02-28 23:04:58 +0000 | [diff] [blame] | 465 | egl::error(EGL_CONTEXT_LOST); |
daniel@transgaming.com | 09fcc9f | 2011-11-09 17:46:47 +0000 | [diff] [blame] | 466 | } |
| 467 | |
shannon.woods%transgaming.com@gtempaccount.com | 8bce3f5 | 2013-04-13 03:35:32 +0000 | [diff] [blame] | 468 | void Display::recreateSwapChains() |
| 469 | { |
| 470 | for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++) |
| 471 | { |
| 472 | (*surface)->getSwapChain()->recreate(); |
| 473 | } |
| 474 | } |
| 475 | |
daniel@transgaming.com | 3b1703f | 2011-05-11 15:36:26 +0000 | [diff] [blame] | 476 | bool Display::isInitialized() const |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 477 | { |
daniel@transgaming.com | 621ce05 | 2012-10-31 17:52:29 +0000 | [diff] [blame] | 478 | return mRenderer != NULL && mConfigSet.size() > 0; |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 479 | } |
| 480 | |
| 481 | bool Display::isValidConfig(EGLConfig config) |
| 482 | { |
| 483 | return mConfigSet.get(config) != NULL; |
| 484 | } |
| 485 | |
| 486 | bool Display::isValidContext(gl::Context *context) |
| 487 | { |
| 488 | return mContextSet.find(context) != mContextSet.end(); |
| 489 | } |
| 490 | |
| 491 | bool Display::isValidSurface(egl::Surface *surface) |
| 492 | { |
daniel@transgaming.com | c556fa5 | 2011-05-26 14:13:29 +0000 | [diff] [blame] | 493 | return mSurfaceSet.find(surface) != mSurfaceSet.end(); |
daniel@transgaming.com | e979ead | 2010-09-23 18:03:14 +0000 | [diff] [blame] | 494 | } |
| 495 | |
| 496 | bool Display::hasExistingWindowSurface(HWND window) |
| 497 | { |
| 498 | for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++) |
| 499 | { |
| 500 | if ((*surface)->getWindowHandle() == window) |
| 501 | { |
| 502 | return true; |
| 503 | } |
| 504 | } |
| 505 | |
| 506 | return false; |
| 507 | } |
| 508 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 509 | std::string Display::generateClientExtensionString() |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 510 | { |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 511 | std::vector<std::string> extensions; |
daniel@transgaming.com | 1a1fe24 | 2011-09-26 18:25:45 +0000 | [diff] [blame] | 512 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 513 | extensions.push_back("EGL_EXT_client_extensions"); |
| 514 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 515 | extensions.push_back("ANGLE_platform_angle"); |
| 516 | |
| 517 | if (supportsPlatformD3D()) |
| 518 | { |
| 519 | extensions.push_back("ANGLE_platform_angle_d3d"); |
| 520 | } |
| 521 | |
| 522 | if (supportsPlatformOpenGL()) |
| 523 | { |
| 524 | extensions.push_back("ANGLE_platform_angle_opengl"); |
| 525 | } |
| 526 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 527 | std::ostringstream stream; |
| 528 | std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " ")); |
| 529 | return stream.str(); |
| 530 | } |
| 531 | |
| 532 | void Display::initDisplayExtensionString() |
| 533 | { |
| 534 | std::vector<std::string> extensions; |
daniel@transgaming.com | 1a1fe24 | 2011-09-26 18:25:45 +0000 | [diff] [blame] | 535 | |
daniel@transgaming.com | 8747f18 | 2011-11-09 17:50:38 +0000 | [diff] [blame] | 536 | // Multi-vendor (EXT) extensions |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 537 | extensions.push_back("EGL_EXT_create_context_robustness"); |
daniel@transgaming.com | 8747f18 | 2011-11-09 17:50:38 +0000 | [diff] [blame] | 538 | |
| 539 | // ANGLE-specific extensions |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 540 | if (mRenderer->getShareHandleSupport()) |
apatrick@chromium.org | f4490e2 | 2011-12-06 02:05:22 +0000 | [diff] [blame] | 541 | { |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 542 | extensions.push_back("EGL_ANGLE_d3d_share_handle_client_buffer"); |
| 543 | extensions.push_back("EGL_ANGLE_surface_d3d_texture_2d_share_handle"); |
daniel@transgaming.com | 1a1fe24 | 2011-09-26 18:25:45 +0000 | [diff] [blame] | 544 | } |
| 545 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 546 | extensions.push_back("EGL_ANGLE_query_surface_pointer"); |
| 547 | extensions.push_back("EGL_ANGLE_window_fixed_size"); |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 548 | |
shannon.woods@transgaming.com | 8d2f086 | 2013-02-28 23:09:19 +0000 | [diff] [blame] | 549 | if (mRenderer->getPostSubBufferSupport()) |
| 550 | { |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 551 | extensions.push_back("EGL_NV_post_sub_buffer"); |
shannon.woods@transgaming.com | 8d2f086 | 2013-02-28 23:09:19 +0000 | [diff] [blame] | 552 | } |
apatrick@chromium.org | f4490e2 | 2011-12-06 02:05:22 +0000 | [diff] [blame] | 553 | |
shannonwoods@chromium.org | 7d9f7be | 2013-05-30 00:20:51 +0000 | [diff] [blame] | 554 | // TODO: complete support for the EGL_KHR_create_context extension |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 555 | extensions.push_back("EGL_KHR_create_context"); |
shannonwoods@chromium.org | 7d9f7be | 2013-05-30 00:20:51 +0000 | [diff] [blame] | 556 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 557 | std::ostringstream stream; |
| 558 | std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " ")); |
| 559 | mDisplayExtensionString = stream.str(); |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 560 | } |
| 561 | |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 562 | const char *Display::getExtensionString(egl::Display *display) |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 563 | { |
Geoff Lang | 2b5f3b3 | 2014-06-18 18:07:49 -0400 | [diff] [blame] | 564 | if (display != EGL_NO_DISPLAY) |
| 565 | { |
| 566 | return display->mDisplayExtensionString.c_str(); |
| 567 | } |
| 568 | else |
| 569 | { |
| 570 | static std::string clientExtensions = generateClientExtensionString(); |
| 571 | return clientExtensions.c_str(); |
| 572 | } |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 573 | } |
| 574 | |
Geoff Lang | 591e6af | 2014-06-18 18:08:57 -0400 | [diff] [blame] | 575 | bool Display::supportsPlatformD3D() |
| 576 | { |
| 577 | #if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11) |
| 578 | return true; |
| 579 | #else |
| 580 | return false; |
| 581 | #endif |
| 582 | } |
| 583 | |
| 584 | bool Display::supportsPlatformOpenGL() |
| 585 | { |
| 586 | return false; |
| 587 | } |
| 588 | |
shannonwoods@chromium.org | 6e4f2a6 | 2013-05-30 00:15:19 +0000 | [diff] [blame] | 589 | void Display::initVendorString() |
| 590 | { |
| 591 | mVendorString = "Google Inc."; |
| 592 | |
| 593 | LUID adapterLuid = {0}; |
| 594 | |
| 595 | if (mRenderer && mRenderer->getLUID(&adapterLuid)) |
| 596 | { |
| 597 | char adapterLuidString[64]; |
| 598 | sprintf_s(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart); |
| 599 | |
| 600 | mVendorString += adapterLuidString; |
| 601 | } |
| 602 | } |
| 603 | |
| 604 | const char *Display::getVendorString() const |
| 605 | { |
| 606 | return mVendorString.c_str(); |
| 607 | } |
daniel@transgaming.com | c6f7f9d | 2012-01-27 15:40:00 +0000 | [diff] [blame] | 608 | |
vladimirv@gmail.com | 721b7f2 | 2011-02-11 00:54:47 +0000 | [diff] [blame] | 609 | } |