Source/ThirdParty/ANGLE/src/libEGL/Display.cpp

   1 //
   2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
   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>
  14 #include <vector>
  15
  16 #include "common/debug.h"
  17
  18 #include "libEGL/main.h"
  19
  20 #define REF_RAST 0        // Can also be enabled by defining FORCE_REF_RAST in the project's predefined macros
  21 #define ENABLE_D3D9EX 1   // Enables use of the IDirect3D9Ex interface, when available
  22
  23 namespace egl
  24 {
  25 Display::Display(HDC deviceContext) : mDc(deviceContext)
  26 {
  27     mD3d9Module = NULL;
  28
  29     mD3d9 = NULL;
  30     mD3d9ex = NULL;
  31     mDevice = NULL;
  32     mDeviceWindow = NULL;
  33
  34     mAdapter = D3DADAPTER_DEFAULT;
  35
  36     #if REF_RAST == 1 || defined(FORCE_REF_RAST)
  37         mDeviceType = D3DDEVTYPE_REF;
  38     #else
  39         mDeviceType = D3DDEVTYPE_HAL;
  40     #endif
  41
  42     mMinSwapInterval = 1;
  43     mMaxSwapInterval = 1;
  44 }
  45
  46 Display::~Display()
  47 {
  48     terminate();
  49 }
  50
  51 bool Display::initialize()
  52 {
  53     if (isInitialized())
  54     {
  55         return true;
  56     }
  57
  58     mD3d9Module = LoadLibrary(TEXT("d3d9.dll"));
  59     if (mD3d9Module == NULL)
  60     {
  61         terminate();
  62         return false;
  63     }
  64
  65     typedef IDirect3D9* (WINAPI *Direct3DCreate9Func)(UINT);
  66     Direct3DCreate9Func Direct3DCreate9Ptr = reinterpret_cast<Direct3DCreate9Func>(GetProcAddress(mD3d9Module, "Direct3DCreate9"));
  67
  68     if (Direct3DCreate9Ptr == NULL)
  69     {
  70         terminate();
  71         return false;
  72     }
  73
  74     typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex**);
  75     Direct3DCreate9ExFunc Direct3DCreate9ExPtr = reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex"));
  76
  77     // Use Direct3D9Ex if available. Among other things, this version is less
  78     // inclined to report a lost context, for example when the user switches
  79     // desktop. Direct3D9Ex is available in Windows Vista and later if suitable drivers are available.
  80     if (ENABLE_D3D9EX && Direct3DCreate9ExPtr && SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &mD3d9ex)))
  81     {
  82         ASSERT(mD3d9ex);
  83         mD3d9ex->QueryInterface(IID_IDirect3D9, reinterpret_cast<void**>(&mD3d9));
  84         ASSERT(mD3d9);
  85     }
  86     else
  87     {
  88         mD3d9 = Direct3DCreate9Ptr(D3D_SDK_VERSION);
  89     }
  90
  91     if (mD3d9)
  92     {
  93         if (mDc != NULL)
  94         {
  95         //  UNIMPLEMENTED();   // FIXME: Determine which adapter index the device context corresponds to
  96         }
  97
  98         HRESULT result;
  99
 100         // Give up on getting device caps after about one second.
 101         for (int i = 0; i < 10; ++i)
 102         {
 103             result = mD3d9->GetDeviceCaps(mAdapter, mDeviceType, &mDeviceCaps);
 104
 105             if (SUCCEEDED(result))
 106             {
 107                 break;
 108             }
 109             else if (result == D3DERR_NOTAVAILABLE)
 110             {
 111                 Sleep(100);   // Give the driver some time to initialize/recover
 112             }
 113             else if (FAILED(result))   // D3DERR_OUTOFVIDEOMEMORY, E_OUTOFMEMORY, D3DERR_INVALIDDEVICE, or another error we can't recover from
 114             {
 115                 terminate();
 116                 return error(EGL_BAD_ALLOC, false);
 117             }
 118         }
 119
 120         if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(2, 0))
 121         {
 122             terminate();
 123             return error(EGL_NOT_INITIALIZED, false);
 124         }
 125
 126         // When DirectX9 is running with an older DirectX8 driver, a StretchRect from a regular texture to a render target texture is not supported.
 127         // This is required by Texture2D::convertToRenderTarget.
 128         if ((mDeviceCaps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES) == 0)
 129         {
 130             terminate();
 131             return error(EGL_NOT_INITIALIZED, false);
 132         }
 133
 134         mMinSwapInterval = 4;
 135         mMaxSwapInterval = 0;
 136
 137         if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE) {mMinSwapInterval = std::min(mMinSwapInterval, 0); mMaxSwapInterval = std::max(mMaxSwapInterval, 0);}
 138         if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE)       {mMinSwapInterval = std::min(mMinSwapInterval, 1); mMaxSwapInterval = std::max(mMaxSwapInterval, 1);}
 139         if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO)       {mMinSwapInterval = std::min(mMinSwapInterval, 2); mMaxSwapInterval = std::max(mMaxSwapInterval, 2);}
 140         if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE)     {mMinSwapInterval = std::min(mMinSwapInterval, 3); mMaxSwapInterval = std::max(mMaxSwapInterval, 3);}
 141         if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)      {mMinSwapInterval = std::min(mMinSwapInterval, 4); mMaxSwapInterval = std::max(mMaxSwapInterval, 4);}
 142
 143         const D3DFORMAT renderTargetFormats[] =
 144         {
 145             D3DFMT_A1R5G5B5,
 146         //  D3DFMT_A2R10G10B10,   // The color_ramp conformance test uses ReadPixels with UNSIGNED_BYTE causing it to think that rendering skipped a colour value.
 147             D3DFMT_A8R8G8B8,
 148             D3DFMT_R5G6B5,
 149         //  D3DFMT_X1R5G5B5,      // Has no compatible OpenGL ES renderbuffer format
 150             D3DFMT_X8R8G8B8
 151         };
 152
 153         const D3DFORMAT depthStencilFormats[] =
 154         {
 155         //  D3DFMT_D16_LOCKABLE,
 156             D3DFMT_D32,
 157         //  D3DFMT_D15S1,
 158             D3DFMT_D24S8,
 159             D3DFMT_D24X8,
 160         //  D3DFMT_D24X4S4,
 161             D3DFMT_D16,
 162         //  D3DFMT_D32F_LOCKABLE,
 163         //  D3DFMT_D24FS8
 164         };
 165
 166         D3DDISPLAYMODE currentDisplayMode;
 167         mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
 168
 169         ConfigSet configSet;
 170
 171         for (int formatIndex = 0; formatIndex < sizeof(renderTargetFormats) / sizeof(D3DFORMAT); formatIndex++)
 172         {
 173             D3DFORMAT renderTargetFormat = renderTargetFormats[formatIndex];
 174
 175             HRESULT result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, renderTargetFormat);
 176
 177             if (SUCCEEDED(result))
 178             {
 179                 for (int depthStencilIndex = 0; depthStencilIndex < sizeof(depthStencilFormats) / sizeof(D3DFORMAT); depthStencilIndex++)
 180                 {
 181                     D3DFORMAT depthStencilFormat = depthStencilFormats[depthStencilIndex];
 182                     HRESULT result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, depthStencilFormat);
 183
 184                     if (SUCCEEDED(result))
 185                     {
 186                         HRESULT result = mD3d9->CheckDepthStencilMatch(mAdapter, mDeviceType, currentDisplayMode.Format, renderTargetFormat, depthStencilFormat);
 187
 188                         if (SUCCEEDED(result))
 189                         {
 190                             // FIXME: enumerate multi-sampling
 191
 192                             configSet.add(currentDisplayMode, mMinSwapInterval, mMaxSwapInterval, renderTargetFormat, depthStencilFormat, 0);
 193                         }
 194                     }
 195                 }
 196             }
 197         }
 198
 199         // Give the sorted configs a unique ID and store them internally
 200         EGLint index = 1;
 201         for (ConfigSet::Iterator config = configSet.mSet.begin(); config != configSet.mSet.end(); config++)
 202         {
 203             Config configuration = *config;
 204             configuration.mConfigID = index;
 205             index++;
 206
 207             mConfigSet.mSet.insert(configuration);
 208         }
 209     }
 210
 211     if (!isInitialized())
 212     {
 213         terminate();
 214
 215         return false;
 216     }
 217
 218     static const TCHAR windowName[] = TEXT("AngleHiddenWindow");
 219     static const TCHAR className[] = TEXT("STATIC");
 220
 221     mDeviceWindow = CreateWindowEx(WS_EX_NOACTIVATE, className, windowName, WS_DISABLED | WS_POPUP, 0, 0, 1, 1, HWND_MESSAGE, NULL, GetModuleHandle(NULL), NULL);
 222
 223     return true;
 224 }
 225
 226 void Display::terminate()
 227 {
 228     while (!mSurfaceSet.empty())
 229     {
 230         destroySurface(*mSurfaceSet.begin());
 231     }
 232
 233     while (!mContextSet.empty())
 234     {
 235         destroyContext(*mContextSet.begin());
 236     }
 237
 238     if (mDevice)
 239     {
 240         // If the device is lost, reset it first to prevent leaving the driver in an unstable state
 241         if (FAILED(mDevice->TestCooperativeLevel()))
 242         {
 243             resetDevice();
 244         }
 245
 246         mDevice->Release();
 247         mDevice = NULL;
 248     }
 249
 250     if (mD3d9)
 251     {
 252         mD3d9->Release();
 253         mD3d9 = NULL;
 254     }
 255
 256     if (mDeviceWindow)
 257     {
 258         DestroyWindow(mDeviceWindow);
 259         mDeviceWindow = NULL;
 260     }
 261
 262     if (mD3d9ex)
 263     {
 264         mD3d9ex->Release();
 265         mD3d9ex = NULL;
 266     }
 267
 268     if (mD3d9Module)
 269     {
 270         FreeLibrary(mD3d9Module);
 271         mD3d9Module = NULL;
 272     }
 273 }
 274
 275 void Display::startScene()
 276 {
 277     if (!mSceneStarted)
 278     {
 279         long result = mDevice->BeginScene();
 280         ASSERT(SUCCEEDED(result));
 281         mSceneStarted = true;
 282     }
 283 }
 284
 285 void Display::endScene()
 286 {
 287     if (mSceneStarted)
 288     {
 289         long result = mDevice->EndScene();
 290         ASSERT(SUCCEEDED(result));
 291         mSceneStarted = false;
 292     }
 293 }
 294
 295 bool Display::getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig)
 296 {
 297     return mConfigSet.getConfigs(configs, attribList, configSize, numConfig);
 298 }
 299
 300 bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
 301 {
 302     const egl::Config *configuration = mConfigSet.get(config);
 303
 304     switch (attribute)
 305     {
 306       case EGL_BUFFER_SIZE:               *value = configuration->mBufferSize;             break;
 307       case EGL_ALPHA_SIZE:                *value = configuration->mAlphaSize;              break;
 308       case EGL_BLUE_SIZE:                 *value = configuration->mBlueSize;               break;
 309       case EGL_GREEN_SIZE:                *value = configuration->mGreenSize;              break;
 310       case EGL_RED_SIZE:                  *value = configuration->mRedSize;                break;
 311       case EGL_DEPTH_SIZE:                *value = configuration->mDepthSize;              break;
 312       case EGL_STENCIL_SIZE:              *value = configuration->mStencilSize;            break;
 313       case EGL_CONFIG_CAVEAT:             *value = configuration->mConfigCaveat;           break;
 314       case EGL_CONFIG_ID:                 *value = configuration->mConfigID;               break;
 315       case EGL_LEVEL:                     *value = configuration->mLevel;                  break;
 316       case EGL_NATIVE_RENDERABLE:         *value = configuration->mNativeRenderable;       break;
 317       case EGL_NATIVE_VISUAL_TYPE:        *value = configuration->mNativeVisualType;       break;
 318       case EGL_SAMPLES:                   *value = configuration->mSamples;                break;
 319       case EGL_SAMPLE_BUFFERS:            *value = configuration->mSampleBuffers;          break;
 320       case EGL_SURFACE_TYPE:              *value = configuration->mSurfaceType;            break;
 321       case EGL_TRANSPARENT_TYPE:          *value = configuration->mTransparentType;        break;
 322       case EGL_TRANSPARENT_BLUE_VALUE:    *value = configuration->mTransparentBlueValue;   break;
 323       case EGL_TRANSPARENT_GREEN_VALUE:   *value = configuration->mTransparentGreenValue;  break;
 324       case EGL_TRANSPARENT_RED_VALUE:     *value = configuration->mTransparentRedValue;    break;
 325       case EGL_BIND_TO_TEXTURE_RGB:       *value = configuration->mBindToTextureRGB;       break;
 326       case EGL_BIND_TO_TEXTURE_RGBA:      *value = configuration->mBindToTextureRGBA;      break;
 327       case EGL_MIN_SWAP_INTERVAL:         *value = configuration->mMinSwapInterval;        break;
 328       case EGL_MAX_SWAP_INTERVAL:         *value = configuration->mMaxSwapInterval;        break;
 329       case EGL_LUMINANCE_SIZE:            *value = configuration->mLuminanceSize;          break;
 330       case EGL_ALPHA_MASK_SIZE:           *value = configuration->mAlphaMaskSize;          break;
 331       case EGL_COLOR_BUFFER_TYPE:         *value = configuration->mColorBufferType;        break;
 332       case EGL_RENDERABLE_TYPE:           *value = configuration->mRenderableType;         break;
 333       case EGL_MATCH_NATIVE_PIXMAP:       *value = false; UNIMPLEMENTED();                 break;
 334       case EGL_CONFORMANT:                *value = configuration->mConformant;             break;
 335       default:
 336         return false;
 337     }
 338
 339     return true;
 340 }
 341
 342 bool Display::createDevice()
 343 {
 344     D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
 345     DWORD behaviorFlags = D3DCREATE_FPU_PRESERVE | D3DCREATE_NOWINDOWCHANGES;
 346
 347     HRESULT result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, behaviorFlags | D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &presentParameters, &mDevice);
 348
 349     if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DEVICELOST)
 350     {
 351         return error(EGL_BAD_ALLOC, false);
 352     }
 353
 354     if (FAILED(result))
 355     {
 356         result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, behaviorFlags | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentParameters, &mDevice);
 357
 358         if (FAILED(result))
 359         {
 360             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_NOTAVAILABLE || result == D3DERR_DEVICELOST);
 361             return error(EGL_BAD_ALLOC, false);
 362         }
 363     }
 364
 365     // Permanent non-default states
 366     mDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
 367
 368     mSceneStarted = false;
 369
 370     return true;
 371 }
 372
 373 bool Display::resetDevice()
 374 {
 375     D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
 376     HRESULT result;
 377
 378     do
 379     {
 380         Sleep(0);   // Give the graphics driver some CPU time
 381
 382         result = mDevice->Reset(&presentParameters);
 383     }
 384     while (result == D3DERR_DEVICELOST);
 385
 386     if (FAILED(result))
 387     {
 388         return error(EGL_BAD_ALLOC, false);
 389     }
 390
 391     ASSERT(SUCCEEDED(result));
 392
 393     return true;
 394 }
 395
 396 Surface *Display::createWindowSurface(HWND window, EGLConfig config)
 397 {
 398     const Config *configuration = mConfigSet.get(config);
 399
 400     Surface *surface = new Surface(this, configuration, window);
 401     mSurfaceSet.insert(surface);
 402
 403     return surface;
 404 }
 405
 406 EGLContext Display::createContext(EGLConfig configHandle, const gl::Context *shareContext)
 407 {
 408     if (!mDevice)
 409     {
 410         if (!createDevice())
 411         {
 412             return NULL;
 413         }
 414     }
 415     else if (FAILED(mDevice->TestCooperativeLevel()))   // Lost device
 416     {
 417         if (!resetDevice())
 418         {
 419             return NULL;
 420         }
 421
 422         // Restore any surfaces that may have been lost
 423         for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 424         {
 425             (*surface)->resetSwapChain();
 426         }
 427     }
 428
 429     const egl::Config *config = mConfigSet.get(configHandle);
 430
 431     gl::Context *context = glCreateContext(config, shareContext);
 432     mContextSet.insert(context);
 433
 434     return context;
 435 }
 436
 437 void Display::destroySurface(egl::Surface *surface)
 438 {
 439     delete surface;
 440     mSurfaceSet.erase(surface);
 441 }
 442
 443 void Display::destroyContext(gl::Context *context)
 444 {
 445     glDestroyContext(context);
 446     mContextSet.erase(context);
 447
 448     if (mContextSet.empty() && mDevice && FAILED(mDevice->TestCooperativeLevel()))   // Last context of a lost device
 449     {
 450         for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 451         {
 452             (*surface)->release();
 453         }
 454     }
 455 }
 456
 457 bool Display::isInitialized()
 458 {
 459     return mD3d9 != NULL && mConfigSet.size() > 0;
 460 }
 461
 462 bool Display::isValidConfig(EGLConfig config)
 463 {
 464     return mConfigSet.get(config) != NULL;
 465 }
 466
 467 bool Display::isValidContext(gl::Context *context)
 468 {
 469     return mContextSet.find(context) != mContextSet.end();
 470 }
 471
 472 bool Display::isValidSurface(egl::Surface *surface)
 473 {
 474     return mSurfaceSet.find(surface) != mSurfaceSet.end();
 475 }
 476
 477 bool Display::hasExistingWindowSurface(HWND window)
 478 {
 479     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 480     {
 481         if ((*surface)->getWindowHandle() == window)
 482         {
 483             return true;
 484         }
 485     }
 486
 487     return false;
 488 }
 489
 490 EGLint Display::getMinSwapInterval()
 491 {
 492     return mMinSwapInterval;
 493 }
 494
 495 EGLint Display::getMaxSwapInterval()
 496 {
 497     return mMaxSwapInterval;
 498 }
 499
 500 IDirect3DDevice9 *Display::getDevice()
 501 {
 502     if (!mDevice)
 503     {
 504         if (!createDevice())
 505         {
 506             return NULL;
 507         }
 508     }
 509
 510     return mDevice;
 511 }
 512
 513 D3DCAPS9 Display::getDeviceCaps()
 514 {
 515     return mDeviceCaps;
 516 }
 517
 518 void Display::getMultiSampleSupport(D3DFORMAT format, bool *multiSampleArray)
 519 {
 520     for (int multiSampleIndex = 0; multiSampleIndex <= D3DMULTISAMPLE_16_SAMPLES; multiSampleIndex++)
 521     {
 522         HRESULT result = mD3d9->CheckDeviceMultiSampleType(mAdapter, mDeviceType, format,
 523                                                            TRUE, (D3DMULTISAMPLE_TYPE)multiSampleIndex, NULL);
 524
 525         multiSampleArray[multiSampleIndex] = SUCCEEDED(result);
 526     }
 527 }
 528
 529 bool Display::getCompressedTextureSupport()
 530 {
 531     D3DDISPLAYMODE currentDisplayMode;
 532     mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
 533
 534     return SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_DXT1));
 535 }
 536
 537 bool Display::getFloatTextureSupport(bool *filtering, bool *renderable)
 538 {
 539     D3DDISPLAYMODE currentDisplayMode;
 540     mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
 541
 542     *filtering = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
 543                                                     D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F)) &&
 544                  SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
 545                                                     D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F));
 546
 547     *renderable = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
 548                                                      D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F))&&
 549                   SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
 550                                                      D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F));
 551
 552     if (!filtering && !renderable)
 553     {
 554         return SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
 555                                                   D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F)) &&
 556                SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
 557                                                   D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F));
 558     }
 559     else
 560     {
 561         return true;
 562     }
 563 }
 564
 565 bool Display::getHalfFloatTextureSupport(bool *filtering, bool *renderable)
 566 {
 567     D3DDISPLAYMODE currentDisplayMode;
 568     mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
 569
 570     *filtering = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
 571                                                     D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16F)) &&
 572                  SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
 573                                                     D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F));
 574
 575     *renderable = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
 576                                                     D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16F)) &&
 577                  SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
 578                                                     D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F));
 579
 580     if (!filtering && !renderable)
 581     {
 582         return SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
 583                                                   D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16F)) &&
 584                SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
 585                                                   D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F));
 586     }
 587     else
 588     {
 589         return true;
 590     }
 591 }
 592
 593 bool Display::getLuminanceTextureSupport()
 594 {
 595     D3DDISPLAYMODE currentDisplayMode;
 596     mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
 597
 598     return SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_L8));
 599 }
 600
 601 bool Display::getLuminanceAlphaTextureSupport()
 602 {
 603     D3DDISPLAYMODE currentDisplayMode;
 604     mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
 605
 606     return SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_A8L8));
 607 }
 608
 609 D3DPOOL Display::getBufferPool(DWORD usage) const
 610 {
 611     if (mD3d9ex != NULL)
 612     {
 613         return D3DPOOL_DEFAULT;
 614     }
 615     else
 616     {
 617         if (!(usage & D3DUSAGE_DYNAMIC))
 618         {
 619             return D3DPOOL_MANAGED;
 620         }
 621     }
 622
 623     return D3DPOOL_DEFAULT;
 624 }
 625
 626 bool Display::getEventQuerySupport()
 627 {
 628     IDirect3DQuery9 *query;
 629     HRESULT result = mDevice->CreateQuery(D3DQUERYTYPE_EVENT, &query);
 630     if (SUCCEEDED(result))
 631     {
 632         query->Release();
 633     }
 634
 635     return result != D3DERR_NOTAVAILABLE;
 636 }
 637
 638 D3DPRESENT_PARAMETERS Display::getDefaultPresentParameters()
 639 {
 640     D3DPRESENT_PARAMETERS presentParameters = {0};
 641
 642     // The default swap chain is never actually used. Surface will create a new swap chain with the proper parameters.
 643     presentParameters.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
 644     presentParameters.BackBufferCount = 1;
 645     presentParameters.BackBufferFormat = D3DFMT_UNKNOWN;
 646     presentParameters.BackBufferWidth = 1;
 647     presentParameters.BackBufferHeight = 1;
 648     presentParameters.EnableAutoDepthStencil = FALSE;
 649     presentParameters.Flags = 0;
 650     presentParameters.hDeviceWindow = mDeviceWindow;
 651     presentParameters.MultiSampleQuality = 0;
 652     presentParameters.MultiSampleType = D3DMULTISAMPLE_NONE;
 653     presentParameters.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
 654     presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
 655     presentParameters.Windowed = TRUE;
 656
 657     return presentParameters;
 658 }
 659 }