Part 2 of 2: <http://webkit.org/b/56337> Enable -Werror on ANGLE
[WebKit-https.git] / 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 }