1#include "precompiled.h"
2//
3// Copyright (c) 2012-2013 The ANGLE Project Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style license that can be
5// found in the LICENSE file.
6//
7
8// Renderer9.cpp: Implements a back-end specific class for the D3D9 renderer.
9
10#include "libGLESv2/main.h"
11#include "libGLESv2/Buffer.h"
12#include "libGLESv2/Texture.h"
13#include "libGLESv2/Framebuffer.h"
14#include "libGLESv2/Renderbuffer.h"
15#include "libGLESv2/ProgramBinary.h"
16#include "libGLESv2/renderer/IndexDataManager.h"
17#include "libGLESv2/renderer/Renderer9.h"
18#include "libGLESv2/renderer/renderer9_utils.h"
19#include "libGLESv2/renderer/ShaderExecutable9.h"
20#include "libGLESv2/renderer/SwapChain9.h"
21#include "libGLESv2/renderer/TextureStorage9.h"
22#include "libGLESv2/renderer/Image9.h"
23#include "libGLESv2/renderer/Blit.h"
24#include "libGLESv2/renderer/RenderTarget9.h"
25#include "libGLESv2/renderer/VertexBuffer9.h"
26#include "libGLESv2/renderer/IndexBuffer9.h"
27#include "libGLESv2/renderer/BufferStorage9.h"
28#include "libGLESv2/renderer/Query9.h"
29#include "libGLESv2/renderer/Fence9.h"
30
31#include "libEGL/Display.h"
32
33// Can also be enabled by defining FORCE_REF_RAST in the project's predefined macros
34#define REF_RAST 0
35
36// The "Debug This Pixel..." feature in PIX often fails when using the
37// D3D9Ex interfaces.  In order to get debug pixel to work on a Vista/Win 7
38// machine, define "ANGLE_ENABLE_D3D9EX=0" in your project file.
39#if !defined(ANGLE_ENABLE_D3D9EX)
40// Enables use of the IDirect3D9Ex interface, when available
41#define ANGLE_ENABLE_D3D9EX 1
42#endif // !defined(ANGLE_ENABLE_D3D9EX)
43
44namespace rx
45{
46static const D3DFORMAT RenderTargetFormats[] =
47    {
48        D3DFMT_A1R5G5B5,
49    //  D3DFMT_A2R10G10B10,   // The color_ramp conformance test uses ReadPixels with UNSIGNED_BYTE causing it to think that rendering skipped a colour value.
50        D3DFMT_A8R8G8B8,
51        D3DFMT_R5G6B5,
52    //  D3DFMT_X1R5G5B5,      // Has no compatible OpenGL ES renderbuffer format
53        D3DFMT_X8R8G8B8
54    };
55
56static const D3DFORMAT DepthStencilFormats[] =
57    {
58        D3DFMT_UNKNOWN,
59    //  D3DFMT_D16_LOCKABLE,
60        D3DFMT_D32,
61    //  D3DFMT_D15S1,
62        D3DFMT_D24S8,
63        D3DFMT_D24X8,
64    //  D3DFMT_D24X4S4,
65        D3DFMT_D16,
66    //  D3DFMT_D32F_LOCKABLE,
67    //  D3DFMT_D24FS8
68    };
69
70enum
71{
72    MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256,
73    MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32,
74    MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224,
75    MAX_VARYING_VECTORS_SM2 = 8,
76    MAX_VARYING_VECTORS_SM3 = 10,
77
78    MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4
79};
80
81Renderer9::Renderer9(egl::Display *display, HDC hDc, bool softwareDevice) : Renderer(display), mDc(hDc), mSoftwareDevice(softwareDevice)
82{
83    mD3d9Module = NULL;
84
85    mD3d9 = NULL;
86    mD3d9Ex = NULL;
87    mDevice = NULL;
88    mDeviceEx = NULL;
89    mDeviceWindow = NULL;
90    mBlit = NULL;
91
92    mAdapter = D3DADAPTER_DEFAULT;
93
94    #if REF_RAST == 1 || defined(FORCE_REF_RAST)
95        mDeviceType = D3DDEVTYPE_REF;
96    #else
97        mDeviceType = D3DDEVTYPE_HAL;
98    #endif
99
100    mDeviceLost = false;
101
102    mMaxSupportedSamples = 0;
103
104    mMaskedClearSavedState = NULL;
105
106    mVertexDataManager = NULL;
107    mIndexDataManager = NULL;
108    mLineLoopIB = NULL;
109
110    mMaxNullColorbufferLRU = 0;
111    for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
112    {
113        mNullColorbufferCache[i].lruCount = 0;
114        mNullColorbufferCache[i].width = 0;
115        mNullColorbufferCache[i].height = 0;
116        mNullColorbufferCache[i].buffer = NULL;
117    }
118}
119
120Renderer9::~Renderer9()
121{
122    releaseDeviceResources();
123
124    if (mDevice)
125    {
126        // If the device is lost, reset it first to prevent leaving the driver in an unstable state
127        if (testDeviceLost(false))
128        {
129            resetDevice();
130        }
131
132        mDevice->Release();
133        mDevice = NULL;
134    }
135
136    if (mDeviceEx)
137    {
138        mDeviceEx->Release();
139        mDeviceEx = NULL;
140    }
141
142    if (mD3d9)
143    {
144        mD3d9->Release();
145        mD3d9 = NULL;
146    }
147
148    if (mDeviceWindow)
149    {
150        DestroyWindow(mDeviceWindow);
151        mDeviceWindow = NULL;
152    }
153
154    if (mD3d9Ex)
155    {
156        mD3d9Ex->Release();
157        mD3d9Ex = NULL;
158    }
159
160    if (mD3d9Module)
161    {
162        mD3d9Module = NULL;
163    }
164
165    while (!mMultiSampleSupport.empty())
166    {
167        delete [] mMultiSampleSupport.begin()->second;
168        mMultiSampleSupport.erase(mMultiSampleSupport.begin());
169    }
170}
171
172Renderer9 *Renderer9::makeRenderer9(Renderer *renderer)
173{
174    ASSERT(HAS_DYNAMIC_TYPE(rx::Renderer9*, renderer));
175    return static_cast<rx::Renderer9*>(renderer);
176}
177
178EGLint Renderer9::initialize()
179{
180    if (!initializeCompiler())
181    {
182        return EGL_NOT_INITIALIZED;
183    }
184
185    if (mSoftwareDevice)
186    {
187        mD3d9Module = GetModuleHandle(TEXT("swiftshader_d3d9.dll"));
188    }
189    else
190    {
191        mD3d9Module = GetModuleHandle(TEXT("d3d9.dll"));
192    }
193
194    if (mD3d9Module == NULL)
195    {
196        ERR("No D3D9 module found - aborting!\n");
197        return EGL_NOT_INITIALIZED;
198    }
199
200    typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex**);
201    Direct3DCreate9ExFunc Direct3DCreate9ExPtr = reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex"));
202
203    // Use Direct3D9Ex if available. Among other things, this version is less
204    // inclined to report a lost context, for example when the user switches
205    // desktop. Direct3D9Ex is available in Windows Vista and later if suitable drivers are available.
206    if (ANGLE_ENABLE_D3D9EX && Direct3DCreate9ExPtr && SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &mD3d9Ex)))
207    {
208        ASSERT(mD3d9Ex);
209        mD3d9Ex->QueryInterface(IID_IDirect3D9, reinterpret_cast<void**>(&mD3d9));
210        ASSERT(mD3d9);
211    }
212    else
213    {
214        mD3d9 = Direct3DCreate9(D3D_SDK_VERSION);
215    }
216
217    if (!mD3d9)
218    {
219        ERR("Could not create D3D9 device - aborting!\n");
220        return EGL_NOT_INITIALIZED;
221    }
222
223    if (mDc != NULL)
224    {
225    //  UNIMPLEMENTED();   // FIXME: Determine which adapter index the device context corresponds to
226    }
227
228    HRESULT result;
229
230    // Give up on getting device caps after about one second.
231    for (int i = 0; i < 10; ++i)
232    {
233        result = mD3d9->GetDeviceCaps(mAdapter, mDeviceType, &mDeviceCaps);
234        if (SUCCEEDED(result))
235        {
236            break;
237        }
238        else if (result == D3DERR_NOTAVAILABLE)
239        {
240            Sleep(100);   // Give the driver some time to initialize/recover
241        }
242        else if (FAILED(result))   // D3DERR_OUTOFVIDEOMEMORY, E_OUTOFMEMORY, D3DERR_INVALIDDEVICE, or another error we can't recover from
243        {
244            ERR("failed to get device caps (0x%x)\n", result);
245            return EGL_NOT_INITIALIZED;
246        }
247    }
248
249    if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(2, 0))
250    {
251        ERR("Renderer does not support PS 2.0. aborting!\n");
252        return EGL_NOT_INITIALIZED;
253    }
254
255    // When DirectX9 is running with an older DirectX8 driver, a StretchRect from a regular texture to a render target texture is not supported.
256    // This is required by Texture2D::convertToRenderTarget.
257    if ((mDeviceCaps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES) == 0)
258    {
259        ERR("Renderer does not support stretctrect from textures!\n");
260        return EGL_NOT_INITIALIZED;
261    }
262
263    mD3d9->GetAdapterIdentifier(mAdapter, 0, &mAdapterIdentifier);
264
265    // ATI cards on XP have problems with non-power-of-two textures.
266    mSupportsNonPower2Textures = !(mDeviceCaps.TextureCaps & D3DPTEXTURECAPS_POW2) &&
267        !(mDeviceCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) &&
268        !(mDeviceCaps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) &&
269        !(getComparableOSVersion() < versionWindowsVista && mAdapterIdentifier.VendorId == VENDOR_ID_AMD);
270
271    // Must support a minimum of 2:1 anisotropy for max anisotropy to be considered supported, per the spec
272    mSupportsTextureFilterAnisotropy = ((mDeviceCaps.RasterCaps & D3DPRASTERCAPS_ANISOTROPY) && (mDeviceCaps.MaxAnisotropy >= 2));
273
274    mMinSwapInterval = 4;
275    mMaxSwapInterval = 0;
276
277    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
278    {
279        mMinSwapInterval = std::min(mMinSwapInterval, 0);
280        mMaxSwapInterval = std::max(mMaxSwapInterval, 0);
281    }
282    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
283    {
284        mMinSwapInterval = std::min(mMinSwapInterval, 1);
285        mMaxSwapInterval = std::max(mMaxSwapInterval, 1);
286    }
287    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
288    {
289        mMinSwapInterval = std::min(mMinSwapInterval, 2);
290        mMaxSwapInterval = std::max(mMaxSwapInterval, 2);
291    }
292    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE)
293    {
294        mMinSwapInterval = std::min(mMinSwapInterval, 3);
295        mMaxSwapInterval = std::max(mMaxSwapInterval, 3);
296    }
297    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)
298    {
299        mMinSwapInterval = std::min(mMinSwapInterval, 4);
300        mMaxSwapInterval = std::max(mMaxSwapInterval, 4);
301    }
302
303    int max = 0;
304    for (unsigned int i = 0; i < ArraySize(RenderTargetFormats); ++i)
305    {
306        bool *multisampleArray = new bool[D3DMULTISAMPLE_16_SAMPLES + 1];
307        getMultiSampleSupport(RenderTargetFormats[i], multisampleArray);
308        mMultiSampleSupport[RenderTargetFormats[i]] = multisampleArray;
309
310        for (int j = D3DMULTISAMPLE_16_SAMPLES; j >= 0; --j)
311        {
312            if (multisampleArray[j] && j != D3DMULTISAMPLE_NONMASKABLE && j > max)
313            {
314                max = j;
315            }
316        }
317    }
318
319    for (unsigned int i = 0; i < ArraySize(DepthStencilFormats); ++i)
320    {
321        if (DepthStencilFormats[i] == D3DFMT_UNKNOWN)
322            continue;
323
324        bool *multisampleArray = new bool[D3DMULTISAMPLE_16_SAMPLES + 1];
325        getMultiSampleSupport(DepthStencilFormats[i], multisampleArray);
326        mMultiSampleSupport[DepthStencilFormats[i]] = multisampleArray;
327
328        for (int j = D3DMULTISAMPLE_16_SAMPLES; j >= 0; --j)
329        {
330            if (multisampleArray[j] && j != D3DMULTISAMPLE_NONMASKABLE && j > max)
331            {
332                max = j;
333            }
334        }
335    }
336
337    mMaxSupportedSamples = max;
338
339    static const TCHAR windowName[] = TEXT("AngleHiddenWindow");
340    static const TCHAR className[] = TEXT("STATIC");
341
342    mDeviceWindow = CreateWindowEx(WS_EX_NOACTIVATE, className, windowName, WS_DISABLED | WS_POPUP, 0, 0, 1, 1, HWND_MESSAGE, NULL, GetModuleHandle(NULL), NULL);
343
344    D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
345    DWORD behaviorFlags = D3DCREATE_FPU_PRESERVE | D3DCREATE_NOWINDOWCHANGES;
346
347    result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, behaviorFlags | D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &presentParameters, &mDevice);
348    if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DEVICELOST)
349    {
350        return EGL_BAD_ALLOC;
351    }
352
353    if (FAILED(result))
354    {
355        result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, behaviorFlags | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentParameters, &mDevice);
356
357        if (FAILED(result))
358        {
359            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_NOTAVAILABLE || result == D3DERR_DEVICELOST);
360            return EGL_BAD_ALLOC;
361        }
362    }
363
364    if (mD3d9Ex)
365    {
366        result = mDevice->QueryInterface(IID_IDirect3DDevice9Ex, (void**) &mDeviceEx);
367        ASSERT(SUCCEEDED(result));
368    }
369
370    mVertexShaderCache.initialize(mDevice);
371    mPixelShaderCache.initialize(mDevice);
372
373    // Check occlusion query support
374    IDirect3DQuery9 *occlusionQuery = NULL;
375    if (SUCCEEDED(mDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &occlusionQuery)) && occlusionQuery)
376    {
377        occlusionQuery->Release();
378        mOcclusionQuerySupport = true;
379    }
380    else
381    {
382        mOcclusionQuerySupport = false;
383    }
384
385    // Check event query support
386    IDirect3DQuery9 *eventQuery = NULL;
387    if (SUCCEEDED(mDevice->CreateQuery(D3DQUERYTYPE_EVENT, &eventQuery)) && eventQuery)
388    {
389        eventQuery->Release();
390        mEventQuerySupport = true;
391    }
392    else
393    {
394        mEventQuerySupport = false;
395    }
396
397    D3DDISPLAYMODE currentDisplayMode;
398    mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
399
400    // Check vertex texture support
401    // Only Direct3D 10 ready devices support all the necessary vertex texture formats.
402    // We test this using D3D9 by checking support for the R16F format.
403    mVertexTextureSupport = mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0) &&
404                            SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format,
405                                                               D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F));
406
407    // Check depth texture support
408    // we use INTZ for depth textures in Direct3D9
409    // we also want NULL texture support to ensure the we can make depth-only FBOs
410    // see http://aras-p.info/texts/D3D9GPUHacks.html
411    mDepthTextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format,
412                                                              D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, D3DFMT_INTZ)) &&
413                           SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format,
414                                                              D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, D3DFMT_NULL));
415
416    // Check 32 bit floating point texture support
417    mFloat32FilterSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
418                                                               D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F)) &&
419                            SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
420                                                               D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F));
421
422    mFloat32RenderSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
423                                                               D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F)) &&
424                            SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
425                                                               D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F));
426
427    if (!mFloat32FilterSupport && !mFloat32RenderSupport)
428    {
429        mFloat32TextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
430                                                                    D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F)) &&
431                                 SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
432                                                                    D3DRTYPE_CUBETEXTURE, D3DFMT_A32B32G32R32F));
433    }
434    else
435    {
436        mFloat32TextureSupport = true;
437    }
438
439    // Check 16 bit floating point texture support
440    mFloat16FilterSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
441                                                               D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16F)) &&
442                            SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_FILTER,
443                                                               D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F));
444
445    mFloat16RenderSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
446                                                               D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16F)) &&
447                            SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET,
448                                                               D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F));
449
450    if (!mFloat16FilterSupport && !mFloat16RenderSupport)
451    {
452        mFloat16TextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
453                                                                    D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16F)) &&
454                                 SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0,
455                                                                    D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F));
456    }
457    else
458    {
459        mFloat16TextureSupport = true;
460    }
461
462    // Check DXT texture support
463    mDXT1TextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_DXT1));
464    mDXT3TextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_DXT3));
465    mDXT5TextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_DXT5));
466
467    // Check luminance[alpha] texture support
468    mLuminanceTextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_L8));
469    mLuminanceAlphaTextureSupport = SUCCEEDED(mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, 0, D3DRTYPE_TEXTURE, D3DFMT_A8L8));
470
471    initializeDevice();
472
473    return EGL_SUCCESS;
474}
475
476// do any one-time device initialization
477// NOTE: this is also needed after a device lost/reset
478// to reset the scene status and ensure the default states are reset.
479void Renderer9::initializeDevice()
480{
481    // Permanent non-default states
482    mDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
483    mDevice->SetRenderState(D3DRS_LASTPIXEL, FALSE);
484
485    if (mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
486    {
487        mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, (DWORD&)mDeviceCaps.MaxPointSize);
488    }
489    else
490    {
491        mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, 0x3F800000);   // 1.0f
492    }
493
494    markAllStateDirty();
495
496    mSceneStarted = false;
497
498    ASSERT(!mBlit && !mVertexDataManager && !mIndexDataManager);
499    mBlit = new Blit(this);
500    mVertexDataManager = new rx::VertexDataManager(this);
501    mIndexDataManager = new rx::IndexDataManager(this);
502}
503
504D3DPRESENT_PARAMETERS Renderer9::getDefaultPresentParameters()
505{
506    D3DPRESENT_PARAMETERS presentParameters = {0};
507
508    // The default swap chain is never actually used. Surface will create a new swap chain with the proper parameters.
509    presentParameters.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
510    presentParameters.BackBufferCount = 1;
511    presentParameters.BackBufferFormat = D3DFMT_UNKNOWN;
512    presentParameters.BackBufferWidth = 1;
513    presentParameters.BackBufferHeight = 1;
514    presentParameters.EnableAutoDepthStencil = FALSE;
515    presentParameters.Flags = 0;
516    presentParameters.hDeviceWindow = mDeviceWindow;
517    presentParameters.MultiSampleQuality = 0;
518    presentParameters.MultiSampleType = D3DMULTISAMPLE_NONE;
519    presentParameters.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
520    presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
521    presentParameters.Windowed = TRUE;
522
523    return presentParameters;
524}
525
526int Renderer9::generateConfigs(ConfigDesc **configDescList)
527{
528    D3DDISPLAYMODE currentDisplayMode;
529    mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
530
531    unsigned int numRenderFormats = ArraySize(RenderTargetFormats);
532    unsigned int numDepthFormats = ArraySize(DepthStencilFormats);
533    (*configDescList) = new ConfigDesc[numRenderFormats * numDepthFormats];
534    int numConfigs = 0;
535
536    for (unsigned int formatIndex = 0; formatIndex < numRenderFormats; formatIndex++)
537    {
538        D3DFORMAT renderTargetFormat = RenderTargetFormats[formatIndex];
539
540        HRESULT result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, renderTargetFormat);
541
542        if (SUCCEEDED(result))
543        {
544            for (unsigned int depthStencilIndex = 0; depthStencilIndex < numDepthFormats; depthStencilIndex++)
545            {
546                D3DFORMAT depthStencilFormat = DepthStencilFormats[depthStencilIndex];
547                HRESULT result = D3D_OK;
548
549                if(depthStencilFormat != D3DFMT_UNKNOWN)
550                {
551                    result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, depthStencilFormat);
552                }
553
554                if (SUCCEEDED(result))
555                {
556                    if(depthStencilFormat != D3DFMT_UNKNOWN)
557                    {
558                        result = mD3d9->CheckDepthStencilMatch(mAdapter, mDeviceType, currentDisplayMode.Format, renderTargetFormat, depthStencilFormat);
559                    }
560
561                    if (SUCCEEDED(result))
562                    {
563                        ConfigDesc newConfig;
564                        newConfig.renderTargetFormat = d3d9_gl::ConvertBackBufferFormat(renderTargetFormat);
565                        newConfig.depthStencilFormat = d3d9_gl::ConvertDepthStencilFormat(depthStencilFormat);
566                        newConfig.multiSample = 0; // FIXME: enumerate multi-sampling
567                        newConfig.fastConfig = (currentDisplayMode.Format == renderTargetFormat);
568
569                        (*configDescList)[numConfigs++] = newConfig;
570                    }
571                }
572            }
573        }
574    }
575
576    return numConfigs;
577}
578
579void Renderer9::deleteConfigs(ConfigDesc *configDescList)
580{
581    delete [] (configDescList);
582}
583
584void Renderer9::startScene()
585{
586    if (!mSceneStarted)
587    {
588        long result = mDevice->BeginScene();
589        if (SUCCEEDED(result)) {
590            // This is defensive checking against the device being
591            // lost at unexpected times.
592            mSceneStarted = true;
593        }
594    }
595}
596
597void Renderer9::endScene()
598{
599    if (mSceneStarted)
600    {
601        // EndScene can fail if the device was lost, for example due
602        // to a TDR during a draw call.
603        mDevice->EndScene();
604        mSceneStarted = false;
605    }
606}
607
608void Renderer9::sync(bool block)
609{
610    HRESULT result;
611
612    IDirect3DQuery9* query = allocateEventQuery();
613    if (!query)
614    {
615        return;
616    }
617
618    result = query->Issue(D3DISSUE_END);
619    ASSERT(SUCCEEDED(result));
620
621    do
622    {
623        result = query->GetData(NULL, 0, D3DGETDATA_FLUSH);
624
625        if(block && result == S_FALSE)
626        {
627            // Keep polling, but allow other threads to do something useful first
628            Sleep(0);
629            // explicitly check for device loss
630            // some drivers seem to return S_FALSE even if the device is lost
631            // instead of D3DERR_DEVICELOST like they should
632            if (testDeviceLost(false))
633            {
634                result = D3DERR_DEVICELOST;
635            }
636        }
637    }
638    while(block && result == S_FALSE);
639
640    freeEventQuery(query);
641
642    if (d3d9::isDeviceLostError(result))
643    {
644        notifyDeviceLost();
645    }
646}
647
648SwapChain *Renderer9::createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat)
649{
650    return new rx::SwapChain9(this, window, shareHandle, backBufferFormat, depthBufferFormat);
651}
652
653IDirect3DQuery9* Renderer9::allocateEventQuery()
654{
655    IDirect3DQuery9 *query = NULL;
656
657    if (mEventQueryPool.empty())
658    {
659        HRESULT result = mDevice->CreateQuery(D3DQUERYTYPE_EVENT, &query);
660        ASSERT(SUCCEEDED(result));
661    }
662    else
663    {
664        query = mEventQueryPool.back();
665        mEventQueryPool.pop_back();
666    }
667
668    return query;
669}
670
671void Renderer9::freeEventQuery(IDirect3DQuery9* query)
672{
673    if (mEventQueryPool.size() > 1000)
674    {
675        query->Release();
676    }
677    else
678    {
679        mEventQueryPool.push_back(query);
680    }
681}
682
683IDirect3DVertexShader9 *Renderer9::createVertexShader(const DWORD *function, size_t length)
684{
685    return mVertexShaderCache.create(function, length);
686}
687
688IDirect3DPixelShader9 *Renderer9::createPixelShader(const DWORD *function, size_t length)
689{
690    return mPixelShaderCache.create(function, length);
691}
692
693HRESULT Renderer9::createVertexBuffer(UINT Length, DWORD Usage, IDirect3DVertexBuffer9 **ppVertexBuffer)
694{
695    D3DPOOL Pool = getBufferPool(Usage);
696    return mDevice->CreateVertexBuffer(Length, Usage, 0, Pool, ppVertexBuffer, NULL);
697}
698
699VertexBuffer *Renderer9::createVertexBuffer()
700{
701    return new VertexBuffer9(this);
702}
703
704HRESULT Renderer9::createIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, IDirect3DIndexBuffer9 **ppIndexBuffer)
705{
706    D3DPOOL Pool = getBufferPool(Usage);
707    return mDevice->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, NULL);
708}
709
710IndexBuffer *Renderer9::createIndexBuffer()
711{
712    return new IndexBuffer9(this);
713}
714
715BufferStorage *Renderer9::createBufferStorage()
716{
717    return new BufferStorage9();
718}
719
720QueryImpl *Renderer9::createQuery(GLenum type)
721{
722    return new Query9(this, type);
723}
724
725FenceImpl *Renderer9::createFence()
726{
727    return new Fence9(this);
728}
729
730void Renderer9::setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &samplerState)
731{
732    bool *forceSetSamplers = (type == gl::SAMPLER_PIXEL) ? mForceSetPixelSamplerStates : mForceSetVertexSamplerStates;
733    gl::SamplerState *appliedSamplers = (type == gl::SAMPLER_PIXEL) ? mCurPixelSamplerStates: mCurVertexSamplerStates;
734
735    if (forceSetSamplers[index] || memcmp(&samplerState, &appliedSamplers[index], sizeof(gl::SamplerState)) != 0)
736    {
737        int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
738        int d3dSampler = index + d3dSamplerOffset;
739
740        mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSU, gl_d3d9::ConvertTextureWrap(samplerState.wrapS));
741        mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSV, gl_d3d9::ConvertTextureWrap(samplerState.wrapT));
742
743        mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAGFILTER, gl_d3d9::ConvertMagFilter(samplerState.magFilter, samplerState.maxAnisotropy));
744        D3DTEXTUREFILTERTYPE d3dMinFilter, d3dMipFilter;
745        gl_d3d9::ConvertMinFilter(samplerState.minFilter, &d3dMinFilter, &d3dMipFilter, samplerState.maxAnisotropy);
746        mDevice->SetSamplerState(d3dSampler, D3DSAMP_MINFILTER, d3dMinFilter);
747        mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPFILTER, d3dMipFilter);
748        mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXMIPLEVEL, samplerState.lodOffset);
749        if (mSupportsTextureFilterAnisotropy)
750        {
751            mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXANISOTROPY, (DWORD)samplerState.maxAnisotropy);
752        }
753    }
754
755    forceSetSamplers[index] = false;
756    appliedSamplers[index] = samplerState;
757}
758
759void Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *texture)
760{
761    int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
762    int d3dSampler = index + d3dSamplerOffset;
763    IDirect3DBaseTexture9 *d3dTexture = NULL;
764    unsigned int serial = 0;
765    bool forceSetTexture = false;
766
767    unsigned int *appliedSerials = (type == gl::SAMPLER_PIXEL) ? mCurPixelTextureSerials : mCurVertexTextureSerials;
768
769    if (texture)
770    {
771        TextureStorageInterface *texStorage = texture->getNativeTexture();
772        if (texStorage)
773        {
774            TextureStorage9 *storage9 = TextureStorage9::makeTextureStorage9(texStorage->getStorageInstance());
775            d3dTexture = storage9->getBaseTexture();
776        }
777        // If we get NULL back from getBaseTexture here, something went wrong
778        // in the texture class and we're unexpectedly missing the d3d texture
779        ASSERT(d3dTexture != NULL);
780
781        serial = texture->getTextureSerial();
782        forceSetTexture = texture->hasDirtyImages();
783    }
784
785    if (forceSetTexture || appliedSerials[index] != serial)
786    {
787        mDevice->SetTexture(d3dSampler, d3dTexture);
788    }
789
790    appliedSerials[index] = serial;
791}
792
793void Renderer9::setRasterizerState(const gl::RasterizerState &rasterState)
794{
795    bool rasterStateChanged = mForceSetRasterState || memcmp(&rasterState, &mCurRasterState, sizeof(gl::RasterizerState)) != 0;
796
797    if (rasterStateChanged)
798    {
799        // Set the cull mode
800        if (rasterState.cullFace)
801        {
802            mDevice->SetRenderState(D3DRS_CULLMODE, gl_d3d9::ConvertCullMode(rasterState.cullMode, rasterState.frontFace));
803        }
804        else
805        {
806            mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
807        }
808
809        if (rasterState.polygonOffsetFill)
810        {
811            if (mCurDepthSize > 0)
812            {
813                mDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, *(DWORD*)&rasterState.polygonOffsetFactor);
814
815                float depthBias = ldexp(rasterState.polygonOffsetUnits, -static_cast<int>(mCurDepthSize));
816                mDevice->SetRenderState(D3DRS_DEPTHBIAS, *(DWORD*)&depthBias);
817            }
818        }
819        else
820        {
821            mDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0);
822            mDevice->SetRenderState(D3DRS_DEPTHBIAS, 0);
823        }
824
825        mCurRasterState = rasterState;
826    }
827
828    mForceSetRasterState = false;
829}
830
831void Renderer9::setBlendState(const gl::BlendState &blendState, const gl::Color &blendColor, unsigned int sampleMask)
832{
833    bool blendStateChanged = mForceSetBlendState || memcmp(&blendState, &mCurBlendState, sizeof(gl::BlendState)) != 0;
834    bool blendColorChanged = mForceSetBlendState || memcmp(&blendColor, &mCurBlendColor, sizeof(gl::Color)) != 0;
835    bool sampleMaskChanged = mForceSetBlendState || sampleMask != mCurSampleMask;
836
837    if (blendStateChanged || blendColorChanged)
838    {
839        if (blendState.blend)
840        {
841            mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
842
843            if (blendState.sourceBlendRGB != GL_CONSTANT_ALPHA && blendState.sourceBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA &&
844                blendState.destBlendRGB != GL_CONSTANT_ALPHA && blendState.destBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA)
845            {
846                mDevice->SetRenderState(D3DRS_BLENDFACTOR, gl_d3d9::ConvertColor(blendColor));
847            }
848            else
849            {
850                mDevice->SetRenderState(D3DRS_BLENDFACTOR, D3DCOLOR_RGBA(gl::unorm<8>(blendColor.alpha),
851                                                                         gl::unorm<8>(blendColor.alpha),
852                                                                         gl::unorm<8>(blendColor.alpha),
853                                                                         gl::unorm<8>(blendColor.alpha)));
854            }
855
856            mDevice->SetRenderState(D3DRS_SRCBLEND, gl_d3d9::ConvertBlendFunc(blendState.sourceBlendRGB));
857            mDevice->SetRenderState(D3DRS_DESTBLEND, gl_d3d9::ConvertBlendFunc(blendState.destBlendRGB));
858            mDevice->SetRenderState(D3DRS_BLENDOP, gl_d3d9::ConvertBlendOp(blendState.blendEquationRGB));
859
860            if (blendState.sourceBlendRGB != blendState.sourceBlendAlpha ||
861                blendState.destBlendRGB != blendState.destBlendAlpha ||
862                blendState.blendEquationRGB != blendState.blendEquationAlpha)
863            {
864                mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
865
866                mDevice->SetRenderState(D3DRS_SRCBLENDALPHA, gl_d3d9::ConvertBlendFunc(blendState.sourceBlendAlpha));
867                mDevice->SetRenderState(D3DRS_DESTBLENDALPHA, gl_d3d9::ConvertBlendFunc(blendState.destBlendAlpha));
868                mDevice->SetRenderState(D3DRS_BLENDOPALPHA, gl_d3d9::ConvertBlendOp(blendState.blendEquationAlpha));
869            }
870            else
871            {
872                mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
873            }
874        }
875        else
876        {
877            mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
878        }
879
880        if (blendState.sampleAlphaToCoverage)
881        {
882            FIXME("Sample alpha to coverage is unimplemented.");
883        }
884
885        // Set the color mask
886        bool zeroColorMaskAllowed = getAdapterVendor() != VENDOR_ID_AMD;
887        // Apparently some ATI cards have a bug where a draw with a zero color
888        // write mask can cause later draws to have incorrect results. Instead,
889        // set a nonzero color write mask but modify the blend state so that no
890        // drawing is done.
891        // http://code.google.com/p/angleproject/issues/detail?id=169
892
893        DWORD colorMask = gl_d3d9::ConvertColorMask(blendState.colorMaskRed, blendState.colorMaskGreen,
894                                                    blendState.colorMaskBlue, blendState.colorMaskAlpha);
895        if (colorMask == 0 && !zeroColorMaskAllowed)
896        {
897            // Enable green channel, but set blending so nothing will be drawn.
898            mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_GREEN);
899            mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
900
901            mDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO);
902            mDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
903            mDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
904        }
905        else
906        {
907            mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, colorMask);
908        }
909
910        mDevice->SetRenderState(D3DRS_DITHERENABLE, blendState.dither ? TRUE : FALSE);
911
912        mCurBlendState = blendState;
913        mCurBlendColor = blendColor;
914    }
915
916    if (sampleMaskChanged)
917    {
918        // Set the multisample mask
919        mDevice->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE);
920        mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, static_cast<DWORD>(sampleMask));
921
922        mCurSampleMask = sampleMask;
923    }
924
925    mForceSetBlendState = false;
926}
927
928void Renderer9::setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
929                                     int stencilBackRef, bool frontFaceCCW)
930{
931    bool depthStencilStateChanged = mForceSetDepthStencilState ||
932                                    memcmp(&depthStencilState, &mCurDepthStencilState, sizeof(gl::DepthStencilState)) != 0;
933    bool stencilRefChanged = mForceSetDepthStencilState || stencilRef != mCurStencilRef ||
934                             stencilBackRef != mCurStencilBackRef;
935    bool frontFaceCCWChanged = mForceSetDepthStencilState || frontFaceCCW != mCurFrontFaceCCW;
936
937    if (depthStencilStateChanged)
938    {
939        if (depthStencilState.depthTest)
940        {
941            mDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
942            mDevice->SetRenderState(D3DRS_ZFUNC, gl_d3d9::ConvertComparison(depthStencilState.depthFunc));
943        }
944        else
945        {
946            mDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
947        }
948
949        mCurDepthStencilState = depthStencilState;
950    }
951
952    if (depthStencilStateChanged || stencilRefChanged || frontFaceCCWChanged)
953    {
954        if (depthStencilState.stencilTest && mCurStencilSize > 0)
955        {
956            mDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
957            mDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, TRUE);
958
959            // FIXME: Unsupported by D3D9
960            const D3DRENDERSTATETYPE D3DRS_CCW_STENCILREF = D3DRS_STENCILREF;
961            const D3DRENDERSTATETYPE D3DRS_CCW_STENCILMASK = D3DRS_STENCILMASK;
962            const D3DRENDERSTATETYPE D3DRS_CCW_STENCILWRITEMASK = D3DRS_STENCILWRITEMASK;
963            if (depthStencilState.stencilWritemask != depthStencilState.stencilBackWritemask ||
964                stencilRef != stencilBackRef ||
965                depthStencilState.stencilMask != depthStencilState.stencilBackMask)
966            {
967                ERR("Separate front/back stencil writemasks, reference values, or stencil mask values are invalid under WebGL.");
968                return gl::error(GL_INVALID_OPERATION);
969            }
970
971            // get the maximum size of the stencil ref
972            unsigned int maxStencil = (1 << mCurStencilSize) - 1;
973
974            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILWRITEMASK : D3DRS_CCW_STENCILWRITEMASK,
975                                    depthStencilState.stencilWritemask);
976            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILFUNC : D3DRS_CCW_STENCILFUNC,
977                                    gl_d3d9::ConvertComparison(depthStencilState.stencilFunc));
978
979            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILREF : D3DRS_CCW_STENCILREF,
980                                    (stencilRef < (int)maxStencil) ? stencilRef : maxStencil);
981            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILMASK : D3DRS_CCW_STENCILMASK,
982                                    depthStencilState.stencilMask);
983
984            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILFAIL : D3DRS_CCW_STENCILFAIL,
985                                    gl_d3d9::ConvertStencilOp(depthStencilState.stencilFail));
986            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILZFAIL : D3DRS_CCW_STENCILZFAIL,
987                                    gl_d3d9::ConvertStencilOp(depthStencilState.stencilPassDepthFail));
988            mDevice->SetRenderState(frontFaceCCW ? D3DRS_STENCILPASS : D3DRS_CCW_STENCILPASS,
989                                    gl_d3d9::ConvertStencilOp(depthStencilState.stencilPassDepthPass));
990
991            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILWRITEMASK : D3DRS_CCW_STENCILWRITEMASK,
992                                    depthStencilState.stencilBackWritemask);
993            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILFUNC : D3DRS_CCW_STENCILFUNC,
994                                    gl_d3d9::ConvertComparison(depthStencilState.stencilBackFunc));
995
996            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILREF : D3DRS_CCW_STENCILREF,
997                                    (stencilBackRef < (int)maxStencil) ? stencilBackRef : maxStencil);
998            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILMASK : D3DRS_CCW_STENCILMASK,
999                                    depthStencilState.stencilBackMask);
1000
1001            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILFAIL : D3DRS_CCW_STENCILFAIL,
1002                                    gl_d3d9::ConvertStencilOp(depthStencilState.stencilBackFail));
1003            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILZFAIL : D3DRS_CCW_STENCILZFAIL,
1004                                    gl_d3d9::ConvertStencilOp(depthStencilState.stencilBackPassDepthFail));
1005            mDevice->SetRenderState(!frontFaceCCW ? D3DRS_STENCILPASS : D3DRS_CCW_STENCILPASS,
1006                                    gl_d3d9::ConvertStencilOp(depthStencilState.stencilBackPassDepthPass));
1007        }
1008        else
1009        {
1010            mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
1011        }
1012
1013        mDevice->SetRenderState(D3DRS_ZWRITEENABLE, depthStencilState.depthMask ? TRUE : FALSE);
1014
1015        mCurStencilRef = stencilRef;
1016        mCurStencilBackRef = stencilBackRef;
1017        mCurFrontFaceCCW = frontFaceCCW;
1018    }
1019
1020    mForceSetDepthStencilState = false;
1021}
1022
1023void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
1024{
1025    bool scissorChanged = mForceSetScissor ||
1026                          memcmp(&scissor, &mCurScissor, sizeof(gl::Rectangle)) != 0 ||
1027                          enabled != mScissorEnabled;
1028
1029    if (scissorChanged)
1030    {
1031        if (enabled)
1032        {
1033            RECT rect;
1034            rect.left = gl::clamp(scissor.x, 0, static_cast<int>(mRenderTargetDesc.width));
1035            rect.top = gl::clamp(scissor.y, 0, static_cast<int>(mRenderTargetDesc.height));
1036            rect.right = gl::clamp(scissor.x + scissor.width, 0, static_cast<int>(mRenderTargetDesc.width));
1037            rect.bottom = gl::clamp(scissor.y + scissor.height, 0, static_cast<int>(mRenderTargetDesc.height));
1038            mDevice->SetScissorRect(&rect);
1039        }
1040
1041        mDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, enabled ? TRUE : FALSE);
1042
1043        mScissorEnabled = enabled;
1044        mCurScissor = scissor;
1045    }
1046
1047    mForceSetScissor = false;
1048}
1049
1050bool Renderer9::setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
1051                            bool ignoreViewport)
1052{
1053    gl::Rectangle actualViewport = viewport;
1054    float actualZNear = gl::clamp01(zNear);
1055    float actualZFar = gl::clamp01(zFar);
1056    if (ignoreViewport)
1057    {
1058        actualViewport.x = 0;
1059        actualViewport.y = 0;
1060        actualViewport.width = mRenderTargetDesc.width;
1061        actualViewport.height = mRenderTargetDesc.height;
1062        actualZNear = 0.0f;
1063        actualZFar = 1.0f;
1064    }
1065
1066    D3DVIEWPORT9 dxViewport;
1067    dxViewport.X = gl::clamp(actualViewport.x, 0, static_cast<int>(mRenderTargetDesc.width));
1068    dxViewport.Y = gl::clamp(actualViewport.y, 0, static_cast<int>(mRenderTargetDesc.height));
1069    dxViewport.Width = gl::clamp(actualViewport.width, 0, static_cast<int>(mRenderTargetDesc.width) - static_cast<int>(dxViewport.X));
1070    dxViewport.Height = gl::clamp(actualViewport.height, 0, static_cast<int>(mRenderTargetDesc.height) - static_cast<int>(dxViewport.Y));
1071    dxViewport.MinZ = actualZNear;
1072    dxViewport.MaxZ = actualZFar;
1073
1074    if (dxViewport.Width <= 0 || dxViewport.Height <= 0)
1075    {
1076        return false;   // Nothing to render
1077    }
1078
1079    bool viewportChanged = mForceSetViewport || memcmp(&actualViewport, &mCurViewport, sizeof(gl::Rectangle)) != 0 ||
1080                           actualZNear != mCurNear || actualZFar != mCurFar;
1081    if (viewportChanged)
1082    {
1083        mDevice->SetViewport(&dxViewport);
1084
1085        mCurViewport = actualViewport;
1086        mCurNear = actualZNear;
1087        mCurFar = actualZFar;
1088
1089        dx_VertexConstants vc = {0};
1090        dx_PixelConstants pc = {0};
1091
1092        vc.viewAdjust[0] = (float)((actualViewport.width - (int)dxViewport.Width) + 2 * (actualViewport.x - (int)dxViewport.X) - 1) / dxViewport.Width;
1093        vc.viewAdjust[1] = (float)((actualViewport.height - (int)dxViewport.Height) + 2 * (actualViewport.y - (int)dxViewport.Y) - 1) / dxViewport.Height;
1094        vc.viewAdjust[2] = (float)actualViewport.width / dxViewport.Width;
1095        vc.viewAdjust[3] = (float)actualViewport.height / dxViewport.Height;
1096
1097        pc.viewCoords[0] = actualViewport.width  * 0.5f;
1098        pc.viewCoords[1] = actualViewport.height * 0.5f;
1099        pc.viewCoords[2] = actualViewport.x + (actualViewport.width  * 0.5f);
1100        pc.viewCoords[3] = actualViewport.y + (actualViewport.height * 0.5f);
1101
1102        pc.depthFront[0] = (actualZFar - actualZNear) * 0.5f;
1103        pc.depthFront[1] = (actualZNear + actualZFar) * 0.5f;
1104        pc.depthFront[2] = !gl::IsTriangleMode(drawMode) ? 0.0f : (frontFace == GL_CCW ? 1.0f : -1.0f);;
1105
1106        vc.depthRange[0] = actualZNear;
1107        vc.depthRange[1] = actualZFar;
1108        vc.depthRange[2] = actualZFar - actualZNear;
1109
1110        pc.depthRange[0] = actualZNear;
1111        pc.depthRange[1] = actualZFar;
1112        pc.depthRange[2] = actualZFar - actualZNear;
1113
1114        if (memcmp(&vc, &mVertexConstants, sizeof(dx_VertexConstants)) != 0)
1115        {
1116            mVertexConstants = vc;
1117            mDxUniformsDirty = true;
1118        }
1119
1120        if (memcmp(&pc, &mPixelConstants, sizeof(dx_PixelConstants)) != 0)
1121        {
1122            mPixelConstants = pc;
1123            mDxUniformsDirty = true;
1124        }
1125    }
1126
1127    mForceSetViewport = false;
1128    return true;
1129}
1130
1131bool Renderer9::applyPrimitiveType(GLenum mode, GLsizei count)
1132{
1133    switch (mode)
1134    {
1135      case GL_POINTS:
1136        mPrimitiveType = D3DPT_POINTLIST;
1137        mPrimitiveCount = count;
1138        break;
1139      case GL_LINES:
1140        mPrimitiveType = D3DPT_LINELIST;
1141        mPrimitiveCount = count / 2;
1142        break;
1143      case GL_LINE_LOOP:
1144        mPrimitiveType = D3DPT_LINESTRIP;
1145        mPrimitiveCount = count - 1;   // D3D doesn't support line loops, so we draw the last line separately
1146        break;
1147      case GL_LINE_STRIP:
1148        mPrimitiveType = D3DPT_LINESTRIP;
1149        mPrimitiveCount = count - 1;
1150        break;
1151      case GL_TRIANGLES:
1152        mPrimitiveType = D3DPT_TRIANGLELIST;
1153        mPrimitiveCount = count / 3;
1154        break;
1155      case GL_TRIANGLE_STRIP:
1156        mPrimitiveType = D3DPT_TRIANGLESTRIP;
1157        mPrimitiveCount = count - 2;
1158        break;
1159      case GL_TRIANGLE_FAN:
1160        mPrimitiveType = D3DPT_TRIANGLEFAN;
1161        mPrimitiveCount = count - 2;
1162        break;
1163      default:
1164        return gl::error(GL_INVALID_ENUM, false);
1165    }
1166
1167    return mPrimitiveCount > 0;
1168}
1169
1170
1171gl::Renderbuffer *Renderer9::getNullColorbuffer(gl::Renderbuffer *depthbuffer)
1172{
1173    if (!depthbuffer)
1174    {
1175        ERR("Unexpected null depthbuffer for depth-only FBO.");
1176        return NULL;
1177    }
1178
1179    GLsizei width  = depthbuffer->getWidth();
1180    GLsizei height = depthbuffer->getHeight();
1181
1182    // search cached nullcolorbuffers
1183    for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
1184    {
1185        if (mNullColorbufferCache[i].buffer != NULL &&
1186            mNullColorbufferCache[i].width == width &&
1187            mNullColorbufferCache[i].height == height)
1188        {
1189            mNullColorbufferCache[i].lruCount = ++mMaxNullColorbufferLRU;
1190            return mNullColorbufferCache[i].buffer;
1191        }
1192    }
1193
1194    gl::Renderbuffer *nullbuffer = new gl::Renderbuffer(this, 0, new gl::Colorbuffer(this, width, height, GL_NONE, 0));
1195
1196    // add nullbuffer to the cache
1197    NullColorbufferCacheEntry *oldest = &mNullColorbufferCache[0];
1198    for (int i = 1; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
1199    {
1200        if (mNullColorbufferCache[i].lruCount < oldest->lruCount)
1201        {
1202            oldest = &mNullColorbufferCache[i];
1203        }
1204    }
1205
1206    delete oldest->buffer;
1207    oldest->buffer = nullbuffer;
1208    oldest->lruCount = ++mMaxNullColorbufferLRU;
1209    oldest->width = width;
1210    oldest->height = height;
1211
1212    return nullbuffer;
1213}
1214
1215bool Renderer9::applyRenderTarget(gl::Framebuffer *framebuffer)
1216{
1217    // if there is no color attachment we must synthesize a NULL colorattachment
1218    // to keep the D3D runtime happy.  This should only be possible if depth texturing.
1219    gl::Renderbuffer *renderbufferObject = NULL;
1220    if (framebuffer->getColorbufferType(0) != GL_NONE)
1221    {
1222        renderbufferObject = framebuffer->getColorbuffer(0);
1223    }
1224    else
1225    {
1226        renderbufferObject = getNullColorbuffer(framebuffer->getDepthbuffer());
1227    }
1228    if (!renderbufferObject)
1229    {
1230        ERR("unable to locate renderbuffer for FBO.");
1231        return false;
1232    }
1233
1234    bool renderTargetChanged = false;
1235    unsigned int renderTargetSerial = renderbufferObject->getSerial();
1236    if (renderTargetSerial != mAppliedRenderTargetSerial)
1237    {
1238        // Apply the render target on the device
1239        IDirect3DSurface9 *renderTargetSurface = NULL;
1240
1241        RenderTarget *renderTarget = renderbufferObject->getRenderTarget();
1242        if (renderTarget)
1243        {
1244            renderTargetSurface = RenderTarget9::makeRenderTarget9(renderTarget)->getSurface();
1245        }
1246
1247        if (!renderTargetSurface)
1248        {
1249            ERR("render target pointer unexpectedly null.");
1250            return false;   // Context must be lost
1251        }
1252
1253        mDevice->SetRenderTarget(0, renderTargetSurface);
1254        renderTargetSurface->Release();
1255
1256        mAppliedRenderTargetSerial = renderTargetSerial;
1257        renderTargetChanged = true;
1258    }
1259
1260    gl::Renderbuffer *depthStencil = NULL;
1261    unsigned int depthbufferSerial = 0;
1262    unsigned int stencilbufferSerial = 0;
1263    if (framebuffer->getDepthbufferType() != GL_NONE)
1264    {
1265        depthStencil = framebuffer->getDepthbuffer();
1266        if (!depthStencil)
1267        {
1268            ERR("Depth stencil pointer unexpectedly null.");
1269            return false;
1270        }
1271
1272        depthbufferSerial = depthStencil->getSerial();
1273    }
1274    else if (framebuffer->getStencilbufferType() != GL_NONE)
1275    {
1276        depthStencil = framebuffer->getStencilbuffer();
1277        if (!depthStencil)
1278        {
1279            ERR("Depth stencil pointer unexpectedly null.");
1280            return false;
1281        }
1282
1283        stencilbufferSerial = depthStencil->getSerial();
1284    }
1285
1286    if (depthbufferSerial != mAppliedDepthbufferSerial ||
1287        stencilbufferSerial != mAppliedStencilbufferSerial ||
1288        !mDepthStencilInitialized)
1289    {
1290        unsigned int depthSize = 0;
1291        unsigned int stencilSize = 0;
1292
1293        // Apply the depth stencil on the device
1294        if (depthStencil)
1295        {
1296            IDirect3DSurface9 *depthStencilSurface = NULL;
1297            RenderTarget *depthStencilRenderTarget = depthStencil->getDepthStencil();
1298
1299            if (depthStencilRenderTarget)
1300            {
1301                depthStencilSurface = RenderTarget9::makeRenderTarget9(depthStencilRenderTarget)->getSurface();
1302            }
1303
1304            if (!depthStencilSurface)
1305            {
1306                ERR("depth stencil pointer unexpectedly null.");
1307                return false;   // Context must be lost
1308            }
1309
1310            mDevice->SetDepthStencilSurface(depthStencilSurface);
1311            depthStencilSurface->Release();
1312
1313            depthSize = depthStencil->getDepthSize();
1314            stencilSize = depthStencil->getStencilSize();
1315        }
1316        else
1317        {
1318            mDevice->SetDepthStencilSurface(NULL);
1319        }
1320
1321        if (!mDepthStencilInitialized || depthSize != mCurDepthSize)
1322        {
1323            mCurDepthSize = depthSize;
1324            mForceSetRasterState = true;
1325        }
1326
1327        if (!mDepthStencilInitialized || stencilSize != mCurStencilSize)
1328        {
1329            mCurStencilSize = stencilSize;
1330            mForceSetDepthStencilState = true;
1331        }
1332
1333        mAppliedDepthbufferSerial = depthbufferSerial;
1334        mAppliedStencilbufferSerial = stencilbufferSerial;
1335        mDepthStencilInitialized = true;
1336    }
1337
1338    if (renderTargetChanged || !mRenderTargetDescInitialized)
1339    {
1340        mForceSetScissor = true;
1341        mForceSetViewport = true;
1342
1343        mRenderTargetDesc.width = renderbufferObject->getWidth();
1344        mRenderTargetDesc.height = renderbufferObject->getHeight();
1345        mRenderTargetDesc.format = renderbufferObject->getActualFormat();
1346        mRenderTargetDescInitialized = true;
1347    }
1348
1349    return true;
1350}
1351
1352GLenum Renderer9::applyVertexBuffer(gl::ProgramBinary *programBinary, gl::VertexAttribute vertexAttributes[], GLint first, GLsizei count, GLsizei instances)
1353{
1354    TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS];
1355    GLenum err = mVertexDataManager->prepareVertexData(vertexAttributes, programBinary, first, count, attributes, instances);
1356    if (err != GL_NO_ERROR)
1357    {
1358        return err;
1359    }
1360
1361    return mVertexDeclarationCache.applyDeclaration(mDevice, attributes, programBinary, instances, &mRepeatDraw);
1362}
1363
1364// Applies the indices and element array bindings to the Direct3D 9 device
1365GLenum Renderer9::applyIndexBuffer(const GLvoid *indices, gl::Buffer *elementArrayBuffer, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo)
1366{
1367    GLenum err = mIndexDataManager->prepareIndexData(type, count, elementArrayBuffer, indices, indexInfo);
1368
1369    if (err == GL_NO_ERROR)
1370    {
1371        // Directly binding the storage buffer is not supported for d3d9
1372        ASSERT(indexInfo->storage == NULL);
1373
1374        if (indexInfo->serial != mAppliedIBSerial)
1375        {
1376            IndexBuffer9* indexBuffer = IndexBuffer9::makeIndexBuffer9(indexInfo->indexBuffer);
1377
1378            mDevice->SetIndices(indexBuffer->getBuffer());
1379            mAppliedIBSerial = indexInfo->serial;
1380        }
1381    }
1382
1383    return err;
1384}
1385
1386void Renderer9::drawArrays(GLenum mode, GLsizei count, GLsizei instances)
1387{
1388    startScene();
1389
1390    if (mode == GL_LINE_LOOP)
1391    {
1392        drawLineLoop(count, GL_NONE, NULL, 0, NULL);
1393    }
1394    else if (instances > 0)
1395    {
1396        StaticIndexBufferInterface *countingIB = mIndexDataManager->getCountingIndices(count);
1397        if (countingIB)
1398        {
1399            if (mAppliedIBSerial != countingIB->getSerial())
1400            {
1401                IndexBuffer9 *indexBuffer = IndexBuffer9::makeIndexBuffer9(countingIB->getIndexBuffer());
1402
1403                mDevice->SetIndices(indexBuffer->getBuffer());
1404                mAppliedIBSerial = countingIB->getSerial();
1405            }
1406
1407            for (int i = 0; i < mRepeatDraw; i++)
1408            {
1409                mDevice->DrawIndexedPrimitive(mPrimitiveType, 0, 0, count, 0, mPrimitiveCount);
1410            }
1411        }
1412        else
1413        {
1414            ERR("Could not create a counting index buffer for glDrawArraysInstanced.");
1415            return gl::error(GL_OUT_OF_MEMORY);
1416        }
1417    }
1418    else   // Regular case
1419    {
1420        mDevice->DrawPrimitive(mPrimitiveType, 0, mPrimitiveCount);
1421    }
1422}
1423
1424void Renderer9::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei /*instances*/)
1425{
1426    startScene();
1427
1428    if (mode == GL_POINTS)
1429    {
1430        drawIndexedPoints(count, type, indices, elementArrayBuffer);
1431    }
1432    else if (mode == GL_LINE_LOOP)
1433    {
1434        drawLineLoop(count, type, indices, indexInfo.minIndex, elementArrayBuffer);
1435    }
1436    else
1437    {
1438        for (int i = 0; i < mRepeatDraw; i++)
1439        {
1440            GLsizei vertexCount = indexInfo.maxIndex - indexInfo.minIndex + 1;
1441            mDevice->DrawIndexedPrimitive(mPrimitiveType, -(INT)indexInfo.minIndex, indexInfo.minIndex, vertexCount, indexInfo.startIndex, mPrimitiveCount);
1442        }
1443    }
1444}
1445
1446void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer)
1447{
1448    // Get the raw indices for an indexed draw
1449    if (type != GL_NONE && elementArrayBuffer)
1450    {
1451        gl::Buffer *indexBuffer = elementArrayBuffer;
1452        BufferStorage *storage = indexBuffer->getStorage();
1453        intptr_t offset = reinterpret_cast<intptr_t>(indices);
1454        indices = static_cast<const GLubyte*>(storage->getData()) + offset;
1455    }
1456
1457    UINT startIndex = 0;
1458
1459    if (get32BitIndexSupport())
1460    {
1461        if (!mLineLoopIB)
1462        {
1463            mLineLoopIB = new StreamingIndexBufferInterface(this);
1464            if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
1465            {
1466                delete mLineLoopIB;
1467                mLineLoopIB = NULL;
1468
1469                ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP.");
1470                return gl::error(GL_OUT_OF_MEMORY);
1471            }
1472        }
1473
1474        if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
1475        {
1476            ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP, too many indices required.");
1477            return gl::error(GL_OUT_OF_MEMORY);
1478        }
1479
1480        // Checked by Renderer9::applyPrimitiveType
1481        ASSERT(count >= 0);
1482
1483        const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
1484        if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
1485        {
1486            ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
1487            return gl::error(GL_OUT_OF_MEMORY);
1488        }
1489
1490        void* mappedMemory = NULL;
1491        int offset = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory);
1492        if (offset == -1 || mappedMemory == NULL)
1493        {
1494            ERR("Could not map index buffer for GL_LINE_LOOP.");
1495            return gl::error(GL_OUT_OF_MEMORY);
1496        }
1497
1498        startIndex = static_cast<UINT>(offset) / 4;
1499        unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
1500
1501        switch (type)
1502        {
1503          case GL_NONE:   // Non-indexed draw
1504            for (int i = 0; i < count; i++)
1505            {
1506                data[i] = i;
1507            }
1508            data[count] = 0;
1509            break;
1510          case GL_UNSIGNED_BYTE:
1511            for (int i = 0; i < count; i++)
1512            {
1513                data[i] = static_cast<const GLubyte*>(indices)[i];
1514            }
1515            data[count] = static_cast<const GLubyte*>(indices)[0];
1516            break;
1517          case GL_UNSIGNED_SHORT:
1518            for (int i = 0; i < count; i++)
1519            {
1520                data[i] = static_cast<const GLushort*>(indices)[i];
1521            }
1522            data[count] = static_cast<const GLushort*>(indices)[0];
1523            break;
1524          case GL_UNSIGNED_INT:
1525            for (int i = 0; i < count; i++)
1526            {
1527                data[i] = static_cast<const GLuint*>(indices)[i];
1528            }
1529            data[count] = static_cast<const GLuint*>(indices)[0];
1530            break;
1531          default: UNREACHABLE();
1532        }
1533
1534        if (!mLineLoopIB->unmapBuffer())
1535        {
1536            ERR("Could not unmap index buffer for GL_LINE_LOOP.");
1537            return gl::error(GL_OUT_OF_MEMORY);
1538        }
1539    }
1540    else
1541    {
1542        if (!mLineLoopIB)
1543        {
1544            mLineLoopIB = new StreamingIndexBufferInterface(this);
1545            if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT))
1546            {
1547                delete mLineLoopIB;
1548                mLineLoopIB = NULL;
1549
1550                ERR("Could not create a 16-bit looping index buffer for GL_LINE_LOOP.");
1551                return gl::error(GL_OUT_OF_MEMORY);
1552            }
1553        }
1554
1555        // Checked by Renderer9::applyPrimitiveType
1556        ASSERT(count >= 0);
1557
1558        if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)))
1559        {
1560            ERR("Could not create a 16-bit looping index buffer for GL_LINE_LOOP, too many indices required.");
1561            return gl::error(GL_OUT_OF_MEMORY);
1562        }
1563
1564        const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * sizeof(unsigned short);
1565        if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT))
1566        {
1567            ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
1568            return gl::error(GL_OUT_OF_MEMORY);
1569        }
1570
1571        void* mappedMemory = NULL;
1572        int offset = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory);
1573        if (offset == -1 || mappedMemory == NULL)
1574        {
1575            ERR("Could not map index buffer for GL_LINE_LOOP.");
1576            return gl::error(GL_OUT_OF_MEMORY);
1577        }
1578
1579        startIndex = static_cast<UINT>(offset) / 2;
1580        unsigned short *data = reinterpret_cast<unsigned short*>(mappedMemory);
1581
1582        switch (type)
1583        {
1584          case GL_NONE:   // Non-indexed draw
1585            for (int i = 0; i < count; i++)
1586            {
1587                data[i] = i;
1588            }
1589            data[count] = 0;
1590            break;
1591          case GL_UNSIGNED_BYTE:
1592            for (int i = 0; i < count; i++)
1593            {
1594                data[i] = static_cast<const GLubyte*>(indices)[i];
1595            }
1596            data[count] = static_cast<const GLubyte*>(indices)[0];
1597            break;
1598          case GL_UNSIGNED_SHORT:
1599            for (int i = 0; i < count; i++)
1600            {
1601                data[i] = static_cast<const GLushort*>(indices)[i];
1602            }
1603            data[count] = static_cast<const GLushort*>(indices)[0];
1604            break;
1605          case GL_UNSIGNED_INT:
1606            for (int i = 0; i < count; i++)
1607            {
1608                data[i] = static_cast<const GLuint*>(indices)[i];
1609            }
1610            data[count] = static_cast<const GLuint*>(indices)[0];
1611            break;
1612          default: UNREACHABLE();
1613        }
1614
1615        if (!mLineLoopIB->unmapBuffer())
1616        {
1617            ERR("Could not unmap index buffer for GL_LINE_LOOP.");
1618            return gl::error(GL_OUT_OF_MEMORY);
1619        }
1620    }
1621
1622    if (mAppliedIBSerial != mLineLoopIB->getSerial())
1623    {
1624        IndexBuffer9 *indexBuffer = IndexBuffer9::makeIndexBuffer9(mLineLoopIB->getIndexBuffer());
1625
1626        mDevice->SetIndices(indexBuffer->getBuffer());
1627        mAppliedIBSerial = mLineLoopIB->getSerial();
1628    }
1629
1630    mDevice->DrawIndexedPrimitive(D3DPT_LINESTRIP, -minIndex, minIndex, count, startIndex, count);
1631}
1632
1633template <typename T>
1634static void drawPoints(IDirect3DDevice9* device, GLsizei count, const GLvoid *indices)
1635{
1636    for (int i = 0; i < count; i++)
1637    {
1638        unsigned int indexValue = static_cast<unsigned int>(static_cast<const T*>(indices)[i]);
1639        device->DrawPrimitive(D3DPT_POINTLIST, indexValue, 1);
1640    }
1641}
1642
1643void Renderer9::drawIndexedPoints(GLsizei count, GLenum type, const GLvoid *indices, gl::Buffer *elementArrayBuffer)
1644{
1645    // Drawing index point lists is unsupported in d3d9, fall back to a regular DrawPrimitive call
1646    // for each individual point. This call is not expected to happen often.
1647
1648    if (elementArrayBuffer)
1649    {
1650        BufferStorage *storage = elementArrayBuffer->getStorage();
1651        intptr_t offset = reinterpret_cast<intptr_t>(indices);
1652        indices = static_cast<const GLubyte*>(storage->getData()) + offset;
1653    }
1654
1655    switch (type)
1656    {
1657        case GL_UNSIGNED_BYTE:  drawPoints<GLubyte>(mDevice, count, indices);  break;
1658        case GL_UNSIGNED_SHORT: drawPoints<GLushort>(mDevice, count, indices); break;
1659        case GL_UNSIGNED_INT:   drawPoints<GLuint>(mDevice, count, indices);   break;
1660        default: UNREACHABLE();
1661    }
1662}
1663
1664void Renderer9::applyShaders(gl::ProgramBinary *programBinary)
1665{
1666    unsigned int programBinarySerial = programBinary->getSerial();
1667    if (programBinarySerial != mAppliedProgramBinarySerial)
1668    {
1669        ShaderExecutable *vertexExe = programBinary->getVertexExecutable();
1670        ShaderExecutable *pixelExe = programBinary->getPixelExecutable();
1671
1672        IDirect3DVertexShader9 *vertexShader = NULL;
1673        if (vertexExe) vertexShader = ShaderExecutable9::makeShaderExecutable9(vertexExe)->getVertexShader();
1674
1675        IDirect3DPixelShader9 *pixelShader = NULL;
1676        if (pixelExe) pixelShader = ShaderExecutable9::makeShaderExecutable9(pixelExe)->getPixelShader();
1677
1678        mDevice->SetPixelShader(pixelShader);
1679        mDevice->SetVertexShader(vertexShader);
1680        programBinary->dirtyAllUniforms();
1681        mDxUniformsDirty = true;
1682
1683        mAppliedProgramBinarySerial = programBinarySerial;
1684    }
1685}
1686
1687void Renderer9::applyUniforms(gl::ProgramBinary *programBinary, gl::UniformArray *uniformArray)
1688{
1689    for (std::vector<gl::Uniform*>::const_iterator ub = uniformArray->begin(), ue = uniformArray->end(); ub != ue; ++ub)
1690    {
1691        gl::Uniform *targetUniform = *ub;
1692
1693        if (targetUniform->dirty)
1694        {
1695            GLfloat *f = (GLfloat*)targetUniform->data;
1696            GLint *i = (GLint*)targetUniform->data;
1697
1698            switch (targetUniform->type)
1699            {
1700              case GL_SAMPLER_2D:
1701              case GL_SAMPLER_CUBE:
1702                break;
1703              case GL_BOOL:
1704              case GL_BOOL_VEC2:
1705              case GL_BOOL_VEC3:
1706              case GL_BOOL_VEC4:
1707                applyUniformnbv(targetUniform, i);
1708                break;
1709              case GL_FLOAT:
1710              case GL_FLOAT_VEC2:
1711              case GL_FLOAT_VEC3:
1712              case GL_FLOAT_VEC4:
1713              case GL_FLOAT_MAT2:
1714              case GL_FLOAT_MAT3:
1715              case GL_FLOAT_MAT4:
1716                applyUniformnfv(targetUniform, f);
1717                break;
1718              case GL_INT:
1719              case GL_INT_VEC2:
1720              case GL_INT_VEC3:
1721              case GL_INT_VEC4:
1722                applyUniformniv(targetUniform, i);
1723                break;
1724              default:
1725                UNREACHABLE();
1726            }
1727
1728            targetUniform->dirty = false;
1729        }
1730    }
1731
1732    // Driver uniforms
1733    if (mDxUniformsDirty)
1734    {
1735        mDevice->SetVertexShaderConstantF(0, (float*)&mVertexConstants, sizeof(dx_VertexConstants) / sizeof(float[4]));
1736        mDevice->SetPixelShaderConstantF(0, (float*)&mPixelConstants, sizeof(dx_PixelConstants) / sizeof(float[4]));
1737        mDxUniformsDirty = false;
1738    }
1739}
1740
1741void Renderer9::applyUniformnfv(gl::Uniform *targetUniform, const GLfloat *v)
1742{
1743    if (targetUniform->psRegisterIndex >= 0)
1744    {
1745        mDevice->SetPixelShaderConstantF(targetUniform->psRegisterIndex, v, targetUniform->registerCount);
1746    }
1747
1748    if (targetUniform->vsRegisterIndex >= 0)
1749    {
1750        mDevice->SetVertexShaderConstantF(targetUniform->vsRegisterIndex, v, targetUniform->registerCount);
1751    }
1752}
1753
1754void Renderer9::applyUniformniv(gl::Uniform *targetUniform, const GLint *v)
1755{
1756    ASSERT(targetUniform->registerCount <= MAX_VERTEX_CONSTANT_VECTORS_D3D9);
1757    GLfloat vector[MAX_VERTEX_CONSTANT_VECTORS_D3D9][4];
1758
1759    for (unsigned int i = 0; i < targetUniform->registerCount; i++)
1760    {
1761        vector[i][0] = (GLfloat)v[4 * i + 0];
1762        vector[i][1] = (GLfloat)v[4 * i + 1];
1763        vector[i][2] = (GLfloat)v[4 * i + 2];
1764        vector[i][3] = (GLfloat)v[4 * i + 3];
1765    }
1766
1767    applyUniformnfv(targetUniform, (GLfloat*)vector);
1768}
1769
1770void Renderer9::applyUniformnbv(gl::Uniform *targetUniform, const GLint *v)
1771{
1772    ASSERT(targetUniform->registerCount <= MAX_VERTEX_CONSTANT_VECTORS_D3D9);
1773    GLfloat vector[MAX_VERTEX_CONSTANT_VECTORS_D3D9][4];
1774
1775    for (unsigned int i = 0; i < targetUniform->registerCount; i++)
1776    {
1777        vector[i][0] = (v[4 * i + 0] == GL_FALSE) ? 0.0f : 1.0f;
1778        vector[i][1] = (v[4 * i + 1] == GL_FALSE) ? 0.0f : 1.0f;
1779        vector[i][2] = (v[4 * i + 2] == GL_FALSE) ? 0.0f : 1.0f;
1780        vector[i][3] = (v[4 * i + 3] == GL_FALSE) ? 0.0f : 1.0f;
1781    }
1782
1783    applyUniformnfv(targetUniform, (GLfloat*)vector);
1784}
1785
1786void Renderer9::clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer)
1787{
1788    D3DCOLOR color = D3DCOLOR_ARGB(gl::unorm<8>(clearParams.colorClearValue.alpha),
1789                                   gl::unorm<8>(clearParams.colorClearValue.red),
1790                                   gl::unorm<8>(clearParams.colorClearValue.green),
1791                                   gl::unorm<8>(clearParams.colorClearValue.blue));
1792    float depth = gl::clamp01(clearParams.depthClearValue);
1793    int stencil = clearParams.stencilClearValue & 0x000000FF;
1794
1795    unsigned int stencilUnmasked = 0x0;
1796    if ((clearParams.mask & GL_STENCIL_BUFFER_BIT) && frameBuffer->hasStencil())
1797    {
1798        unsigned int stencilSize = gl::GetStencilSize(frameBuffer->getStencilbuffer()->getActualFormat());
1799        stencilUnmasked = (0x1 << stencilSize) - 1;
1800    }
1801
1802    bool alphaUnmasked = (gl::GetAlphaSize(mRenderTargetDesc.format) == 0) || clearParams.colorMaskAlpha;
1803
1804    const bool needMaskedStencilClear = (clearParams.mask & GL_STENCIL_BUFFER_BIT) &&
1805                                        (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked;
1806    const bool needMaskedColorClear = (clearParams.mask & GL_COLOR_BUFFER_BIT) &&
1807                                      !(clearParams.colorMaskRed && clearParams.colorMaskGreen &&
1808                                        clearParams.colorMaskBlue && alphaUnmasked);
1809
1810    if (needMaskedColorClear || needMaskedStencilClear)
1811    {
1812        // State which is altered in all paths from this point to the clear call is saved.
1813        // State which is altered in only some paths will be flagged dirty in the case that
1814        //  that path is taken.
1815        HRESULT hr;
1816        if (mMaskedClearSavedState == NULL)
1817        {
1818            hr = mDevice->BeginStateBlock();
1819            ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
1820
1821            mDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
1822            mDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
1823            mDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
1824            mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
1825            mDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
1826            mDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
1827            mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
1828            mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
1829            mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
1830            mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
1831            mDevice->SetPixelShader(NULL);
1832            mDevice->SetVertexShader(NULL);
1833            mDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
1834            mDevice->SetStreamSource(0, NULL, 0, 0);
1835            mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
1836            mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
1837            mDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR);
1838            mDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
1839            mDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR);
1840            mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color);
1841            mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
1842
1843            for(int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
1844            {
1845                mDevice->SetStreamSourceFreq(i, 1);
1846            }
1847
1848            hr = mDevice->EndStateBlock(&mMaskedClearSavedState);
1849            ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
1850        }
1851
1852        ASSERT(mMaskedClearSavedState != NULL);
1853
1854        if (mMaskedClearSavedState != NULL)
1855        {
1856            hr = mMaskedClearSavedState->Capture();
1857            ASSERT(SUCCEEDED(hr));
1858        }
1859
1860        mDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
1861        mDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
1862        mDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
1863        mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
1864        mDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
1865        mDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
1866        mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
1867        mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
1868
1869        if (clearParams.mask & GL_COLOR_BUFFER_BIT)
1870        {
1871            mDevice->SetRenderState(D3DRS_COLORWRITEENABLE,
1872                                    gl_d3d9::ConvertColorMask(clearParams.colorMaskRed,
1873                                                              clearParams.colorMaskGreen,
1874                                                              clearParams.colorMaskBlue,
1875                                                              clearParams.colorMaskAlpha));
1876        }
1877        else
1878        {
1879            mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
1880        }
1881
1882        if (stencilUnmasked != 0x0 && (clearParams.mask & GL_STENCIL_BUFFER_BIT))
1883        {
1884            mDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
1885            mDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE);
1886            mDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
1887            mDevice->SetRenderState(D3DRS_STENCILREF, stencil);
1888            mDevice->SetRenderState(D3DRS_STENCILWRITEMASK, clearParams.stencilWriteMask);
1889            mDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_REPLACE);
1890            mDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_REPLACE);
1891            mDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
1892        }
1893        else
1894        {
1895            mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
1896        }
1897
1898        mDevice->SetPixelShader(NULL);
1899        mDevice->SetVertexShader(NULL);
1900        mDevice->SetFVF(D3DFVF_XYZRHW);
1901        mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
1902        mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
1903        mDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR);
1904        mDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
1905        mDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR);
1906        mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color);
1907        mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
1908
1909        for(int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
1910        {
1911            mDevice->SetStreamSourceFreq(i, 1);
1912        }
1913
1914        float quad[4][4];   // A quadrilateral covering the target, aligned to match the edges
1915        quad[0][0] = -0.5f;
1916        quad[0][1] = mRenderTargetDesc.height - 0.5f;
1917        quad[0][2] = 0.0f;
1918        quad[0][3] = 1.0f;
1919
1920        quad[1][0] = mRenderTargetDesc.width - 0.5f;
1921        quad[1][1] = mRenderTargetDesc.height - 0.5f;
1922        quad[1][2] = 0.0f;
1923        quad[1][3] = 1.0f;
1924
1925        quad[2][0] = -0.5f;
1926        quad[2][1] = -0.5f;
1927        quad[2][2] = 0.0f;
1928        quad[2][3] = 1.0f;
1929
1930        quad[3][0] = mRenderTargetDesc.width - 0.5f;
1931        quad[3][1] = -0.5f;
1932        quad[3][2] = 0.0f;
1933        quad[3][3] = 1.0f;
1934
1935        startScene();
1936        mDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float[4]));
1937
1938        if (clearParams.mask & GL_DEPTH_BUFFER_BIT)
1939        {
1940            mDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
1941            mDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
1942            mDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER, color, depth, stencil);
1943        }
1944
1945        if (mMaskedClearSavedState != NULL)
1946        {
1947            mMaskedClearSavedState->Apply();
1948        }
1949    }
1950    else if (clearParams.mask)
1951    {
1952        DWORD dxClearFlags = 0;
1953        if (clearParams.mask & GL_COLOR_BUFFER_BIT)
1954        {
1955            dxClearFlags |= D3DCLEAR_TARGET;
1956        }
1957        if (clearParams.mask & GL_DEPTH_BUFFER_BIT)
1958        {
1959            dxClearFlags |= D3DCLEAR_ZBUFFER;
1960        }
1961        if (clearParams.mask & GL_STENCIL_BUFFER_BIT)
1962        {
1963            dxClearFlags |= D3DCLEAR_STENCIL;
1964        }
1965
1966        mDevice->Clear(0, NULL, dxClearFlags, color, depth, stencil);
1967    }
1968}
1969
1970void Renderer9::markAllStateDirty()
1971{
1972    mAppliedRenderTargetSerial = 0;
1973    mAppliedDepthbufferSerial = 0;
1974    mAppliedStencilbufferSerial = 0;
1975    mDepthStencilInitialized = false;
1976    mRenderTargetDescInitialized = false;
1977
1978    mForceSetDepthStencilState = true;
1979    mForceSetRasterState = true;
1980    mForceSetScissor = true;
1981    mForceSetViewport = true;
1982    mForceSetBlendState = true;
1983
1984    for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS; i++)
1985    {
1986        mForceSetVertexSamplerStates[i] = true;
1987        mCurVertexTextureSerials[i] = 0;
1988    }
1989    for (unsigned int i = 0; i < gl::MAX_TEXTURE_IMAGE_UNITS; i++)
1990    {
1991        mForceSetPixelSamplerStates[i] = true;
1992        mCurPixelTextureSerials[i] = 0;
1993    }
1994
1995    mAppliedIBSerial = 0;
1996    mAppliedProgramBinarySerial = 0;
1997    mDxUniformsDirty = true;
1998
1999    mVertexDeclarationCache.markStateDirty();
2000}
2001
2002void Renderer9::releaseDeviceResources()
2003{
2004    while (!mEventQueryPool.empty())
2005    {
2006        mEventQueryPool.back()->Release();
2007        mEventQueryPool.pop_back();
2008    }
2009
2010    if (mMaskedClearSavedState)
2011    {
2012        mMaskedClearSavedState->Release();
2013        mMaskedClearSavedState = NULL;
2014    }
2015
2016    mVertexShaderCache.clear();
2017    mPixelShaderCache.clear();
2018
2019    delete mBlit;
2020    mBlit = NULL;
2021
2022    delete mVertexDataManager;
2023    mVertexDataManager = NULL;
2024
2025    delete mIndexDataManager;
2026    mIndexDataManager = NULL;
2027
2028    delete mLineLoopIB;
2029    mLineLoopIB = NULL;
2030
2031    for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
2032    {
2033        delete mNullColorbufferCache[i].buffer;
2034        mNullColorbufferCache[i].buffer = NULL;
2035    }
2036
2037}
2038
2039
2040void Renderer9::notifyDeviceLost()
2041{
2042    mDeviceLost = true;
2043    mDisplay->notifyDeviceLost();
2044}
2045
2046bool Renderer9::isDeviceLost()
2047{
2048    return mDeviceLost;
2049}
2050
2051// set notify to true to broadcast a message to all contexts of the device loss
2052bool Renderer9::testDeviceLost(bool notify)
2053{
2054    HRESULT status = S_OK;
2055
2056    if (mDeviceEx)
2057    {
2058        status = mDeviceEx->CheckDeviceState(NULL);
2059    }
2060    else if (mDevice)
2061    {
2062        status = mDevice->TestCooperativeLevel();
2063    }
2064    else
2065    {
2066        // No device yet, so no reset required
2067    }
2068
2069    bool isLost = FAILED(status) || d3d9::isDeviceLostError(status);
2070
2071    if (isLost)
2072    {
2073        // ensure we note the device loss --
2074        // we'll probably get this done again by notifyDeviceLost
2075        // but best to remember it!
2076        // Note that we don't want to clear the device loss status here
2077        // -- this needs to be done by resetDevice
2078        mDeviceLost = true;
2079        if (notify)
2080        {
2081            notifyDeviceLost();
2082        }
2083    }
2084
2085    return isLost;
2086}
2087
2088bool Renderer9::testDeviceResettable()
2089{
2090    HRESULT status = D3D_OK;
2091
2092    if (mDeviceEx)
2093    {
2094        status = mDeviceEx->CheckDeviceState(NULL);
2095    }
2096    else if (mDevice)
2097    {
2098        status = mDevice->TestCooperativeLevel();
2099    }
2100
2101    // On D3D9Ex, DEVICELOST represents a hung device that needs to be restarted
2102    // DEVICEREMOVED indicates the device has been stopped and must be recreated
2103    switch (status)
2104    {
2105      case D3DERR_DEVICENOTRESET:
2106      case D3DERR_DEVICEHUNG:
2107        return true;
2108      case D3DERR_DEVICELOST:
2109        return (mDeviceEx != NULL);
2110      case D3DERR_DEVICEREMOVED:
2111        UNIMPLEMENTED();
2112        return false;
2113      default:
2114        return false;
2115    }
2116}
2117
2118bool Renderer9::resetDevice()
2119{
2120    releaseDeviceResources();
2121
2122    D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
2123
2124    HRESULT result = D3D_OK;
2125    bool lost = testDeviceLost(false);
2126    int attempts = 3;
2127
2128    while (lost && attempts > 0)
2129    {
2130        if (mDeviceEx)
2131        {
2132            Sleep(500);   // Give the graphics driver some CPU time
2133            result = mDeviceEx->ResetEx(&presentParameters, NULL);
2134        }
2135        else
2136        {
2137            result = mDevice->TestCooperativeLevel();
2138            while (result == D3DERR_DEVICELOST)
2139            {
2140                Sleep(100);   // Give the graphics driver some CPU time
2141                result = mDevice->TestCooperativeLevel();
2142            }
2143
2144            if (result == D3DERR_DEVICENOTRESET)
2145            {
2146                result = mDevice->Reset(&presentParameters);
2147            }
2148        }
2149
2150        lost = testDeviceLost(false);
2151        attempts --;
2152    }
2153
2154    if (FAILED(result))
2155    {
2156        ERR("Reset/ResetEx failed multiple times: 0x%08X", result);
2157        return false;
2158    }
2159
2160    // reset device defaults
2161    initializeDevice();
2162    mDeviceLost = false;
2163
2164    return true;
2165}
2166
2167DWORD Renderer9::getAdapterVendor() const
2168{
2169    return mAdapterIdentifier.VendorId;
2170}
2171
2172std::string Renderer9::getRendererDescription() const
2173{
2174    std::ostringstream rendererString;
2175
2176    rendererString << mAdapterIdentifier.Description;
2177    if (getShareHandleSupport())
2178    {
2179        rendererString << " Direct3D9Ex";
2180    }
2181    else
2182    {
2183        rendererString << " Direct3D9";
2184    }
2185
2186    rendererString << " vs_" << D3DSHADER_VERSION_MAJOR(mDeviceCaps.VertexShaderVersion) << "_" << D3DSHADER_VERSION_MINOR(mDeviceCaps.VertexShaderVersion);
2187    rendererString << " ps_" << D3DSHADER_VERSION_MAJOR(mDeviceCaps.PixelShaderVersion) << "_" << D3DSHADER_VERSION_MINOR(mDeviceCaps.PixelShaderVersion);
2188
2189    return rendererString.str();
2190}
2191
2192GUID Renderer9::getAdapterIdentifier() const
2193{
2194    return mAdapterIdentifier.DeviceIdentifier;
2195}
2196
2197void Renderer9::getMultiSampleSupport(D3DFORMAT format, bool *multiSampleArray)
2198{
2199    for (int multiSampleIndex = 0; multiSampleIndex <= D3DMULTISAMPLE_16_SAMPLES; multiSampleIndex++)
2200    {
2201        HRESULT result = mD3d9->CheckDeviceMultiSampleType(mAdapter, mDeviceType, format,
2202                                                           TRUE, (D3DMULTISAMPLE_TYPE)multiSampleIndex, NULL);
2203
2204        multiSampleArray[multiSampleIndex] = SUCCEEDED(result);
2205    }
2206}
2207
2208bool Renderer9::getBGRATextureSupport() const
2209{
2210    // DirectX 9 always supports BGRA
2211    return true;
2212}
2213
2214bool Renderer9::getDXT1TextureSupport()
2215{
2216    return mDXT1TextureSupport;
2217}
2218
2219bool Renderer9::getDXT3TextureSupport()
2220{
2221    return mDXT3TextureSupport;
2222}
2223
2224bool Renderer9::getDXT5TextureSupport()
2225{
2226    return mDXT5TextureSupport;
2227}
2228
2229bool Renderer9::getDepthTextureSupport() const
2230{
2231    return mDepthTextureSupport;
2232}
2233
2234bool Renderer9::getFloat32TextureSupport(bool *filtering, bool *renderable)
2235{
2236    *filtering = mFloat32FilterSupport;
2237    *renderable = mFloat32RenderSupport;
2238    return mFloat32TextureSupport;
2239}
2240
2241bool Renderer9::getFloat16TextureSupport(bool *filtering, bool *renderable)
2242{
2243    *filtering = mFloat16FilterSupport;
2244    *renderable = mFloat16RenderSupport;
2245    return mFloat16TextureSupport;
2246}
2247
2248bool Renderer9::getLuminanceTextureSupport()
2249{
2250    return mLuminanceTextureSupport;
2251}
2252
2253bool Renderer9::getLuminanceAlphaTextureSupport()
2254{
2255    return mLuminanceAlphaTextureSupport;
2256}
2257
2258bool Renderer9::getTextureFilterAnisotropySupport() const
2259{
2260    return mSupportsTextureFilterAnisotropy;
2261}
2262
2263float Renderer9::getTextureMaxAnisotropy() const
2264{
2265    if (mSupportsTextureFilterAnisotropy)
2266    {
2267        return static_cast<float>(mDeviceCaps.MaxAnisotropy);
2268    }
2269    return 1.0f;
2270}
2271
2272bool Renderer9::getEventQuerySupport()
2273{
2274    return mEventQuerySupport;
2275}
2276
2277unsigned int Renderer9::getMaxVertexTextureImageUnits() const
2278{
2279    META_ASSERT(MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 <= gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
2280    return mVertexTextureSupport ? MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 : 0;
2281}
2282
2283unsigned int Renderer9::getMaxCombinedTextureImageUnits() const
2284{
2285    return gl::MAX_TEXTURE_IMAGE_UNITS + getMaxVertexTextureImageUnits();
2286}
2287
2288unsigned int Renderer9::getReservedVertexUniformVectors() const
2289{
2290    return 2;   // dx_ViewAdjust and dx_DepthRange.
2291}
2292
2293unsigned int Renderer9::getReservedFragmentUniformVectors() const
2294{
2295    return 3;   // dx_ViewCoords, dx_DepthFront and dx_DepthRange.
2296}
2297
2298unsigned int Renderer9::getMaxVertexUniformVectors() const
2299{
2300    return MAX_VERTEX_CONSTANT_VECTORS_D3D9 - getReservedVertexUniformVectors();
2301}
2302
2303unsigned int Renderer9::getMaxFragmentUniformVectors() const
2304{
2305    const int maxPixelConstantVectors = (getMajorShaderModel() >= 3) ? MAX_PIXEL_CONSTANT_VECTORS_SM3 : MAX_PIXEL_CONSTANT_VECTORS_SM2;
2306
2307    return maxPixelConstantVectors - getReservedFragmentUniformVectors();
2308}
2309
2310unsigned int Renderer9::getMaxVaryingVectors() const
2311{
2312    return (getMajorShaderModel() >= 3) ? MAX_VARYING_VECTORS_SM3 : MAX_VARYING_VECTORS_SM2;
2313}
2314
2315bool Renderer9::getNonPower2TextureSupport() const
2316{
2317    return mSupportsNonPower2Textures;
2318}
2319
2320bool Renderer9::getOcclusionQuerySupport() const
2321{
2322    return mOcclusionQuerySupport;
2323}
2324
2325bool Renderer9::getInstancingSupport() const
2326{
2327    return mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0);
2328}
2329
2330bool Renderer9::getShareHandleSupport() const
2331{
2332    // PIX doesn't seem to support using share handles, so disable them.
2333    return (mD3d9Ex != NULL) && !gl::perfActive();
2334}
2335
2336bool Renderer9::getDerivativeInstructionSupport() const
2337{
2338    return (mDeviceCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS) != 0;
2339}
2340
2341bool Renderer9::getPostSubBufferSupport() const
2342{
2343    return true;
2344}
2345
2346int Renderer9::getMajorShaderModel() const
2347{
2348    return D3DSHADER_VERSION_MAJOR(mDeviceCaps.PixelShaderVersion);
2349}
2350
2351float Renderer9::getMaxPointSize() const
2352{
2353    // Point size clamped at 1.0f for SM2
2354    return getMajorShaderModel() == 3 ? mDeviceCaps.MaxPointSize : 1.0f;
2355}
2356
2357int Renderer9::getMaxViewportDimension() const
2358{
2359    int maxTextureDimension = std::min(std::min(getMaxTextureWidth(), getMaxTextureHeight()),
2360                                       (int)gl::IMPLEMENTATION_MAX_TEXTURE_SIZE);
2361    return maxTextureDimension;
2362}
2363
2364int Renderer9::getMaxTextureWidth() const
2365{
2366    return (int)mDeviceCaps.MaxTextureWidth;
2367}
2368
2369int Renderer9::getMaxTextureHeight() const
2370{
2371    return (int)mDeviceCaps.MaxTextureHeight;
2372}
2373
2374bool Renderer9::get32BitIndexSupport() const
2375{
2376    return mDeviceCaps.MaxVertexIndex >= (1 << 16);
2377}
2378
2379DWORD Renderer9::getCapsDeclTypes() const
2380{
2381    return mDeviceCaps.DeclTypes;
2382}
2383
2384int Renderer9::getMinSwapInterval() const
2385{
2386    return mMinSwapInterval;
2387}
2388
2389int Renderer9::getMaxSwapInterval() const
2390{
2391    return mMaxSwapInterval;
2392}
2393
2394int Renderer9::getMaxSupportedSamples() const
2395{
2396    return mMaxSupportedSamples;
2397}
2398
2399int Renderer9::getNearestSupportedSamples(D3DFORMAT format, int requested) const
2400{
2401    if (requested == 0)
2402    {
2403        return requested;
2404    }
2405
2406    std::map<D3DFORMAT, bool *>::const_iterator itr = mMultiSampleSupport.find(format);
2407    if (itr == mMultiSampleSupport.end())
2408    {
2409        if (format == D3DFMT_UNKNOWN)
2410            return 0;
2411        return -1;
2412    }
2413
2414    for (int i = requested; i <= D3DMULTISAMPLE_16_SAMPLES; ++i)
2415    {
2416        if (itr->second[i] && i != D3DMULTISAMPLE_NONMASKABLE)
2417        {
2418            return i;
2419        }
2420    }
2421
2422    return -1;
2423}
2424
2425unsigned int Renderer9::getMaxRenderTargets() const
2426{
2427    // we do not support MRT in d3d9
2428    return 1;
2429}
2430
2431D3DFORMAT Renderer9::ConvertTextureInternalFormat(GLint internalformat)
2432{
2433    switch (internalformat)
2434    {
2435      case GL_DEPTH_COMPONENT16:
2436      case GL_DEPTH_COMPONENT32_OES:
2437      case GL_DEPTH24_STENCIL8_OES:
2438        return D3DFMT_INTZ;
2439      case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
2440      case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
2441        return D3DFMT_DXT1;
2442      case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
2443        return D3DFMT_DXT3;
2444      case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
2445        return D3DFMT_DXT5;
2446      case GL_RGBA32F_EXT:
2447      case GL_RGB32F_EXT:
2448      case GL_ALPHA32F_EXT:
2449      case GL_LUMINANCE32F_EXT:
2450      case GL_LUMINANCE_ALPHA32F_EXT:
2451        return D3DFMT_A32B32G32R32F;
2452      case GL_RGBA16F_EXT:
2453      case GL_RGB16F_EXT:
2454      case GL_ALPHA16F_EXT:
2455      case GL_LUMINANCE16F_EXT:
2456      case GL_LUMINANCE_ALPHA16F_EXT:
2457        return D3DFMT_A16B16G16R16F;
2458      case GL_LUMINANCE8_EXT:
2459        if (getLuminanceTextureSupport())
2460        {
2461            return D3DFMT_L8;
2462        }
2463        break;
2464      case GL_LUMINANCE8_ALPHA8_EXT:
2465        if (getLuminanceAlphaTextureSupport())
2466        {
2467            return D3DFMT_A8L8;
2468        }
2469        break;
2470      case GL_RGB8_OES:
2471      case GL_RGB565:
2472        return D3DFMT_X8R8G8B8;
2473    }
2474
2475    return D3DFMT_A8R8G8B8;
2476}
2477
2478bool Renderer9::copyToRenderTarget(TextureStorageInterface2D *dest, TextureStorageInterface2D *source)
2479{
2480    bool result = false;
2481
2482    if (source && dest)
2483    {
2484        TextureStorage9_2D *source9 = TextureStorage9_2D::makeTextureStorage9_2D(source->getStorageInstance());
2485        TextureStorage9_2D *dest9 = TextureStorage9_2D::makeTextureStorage9_2D(dest->getStorageInstance());
2486
2487        int levels = source9->levelCount();
2488        for (int i = 0; i < levels; ++i)
2489        {
2490            IDirect3DSurface9 *srcSurf = source9->getSurfaceLevel(i, false);
2491            IDirect3DSurface9 *dstSurf = dest9->getSurfaceLevel(i, false);
2492
2493            result = copyToRenderTarget(dstSurf, srcSurf, source9->isManaged());
2494
2495            if (srcSurf) srcSurf->Release();
2496            if (dstSurf) dstSurf->Release();
2497
2498            if (!result)
2499                return false;
2500        }
2501    }
2502
2503    return result;
2504}
2505
2506bool Renderer9::copyToRenderTarget(TextureStorageInterfaceCube *dest, TextureStorageInterfaceCube *source)
2507{
2508    bool result = false;
2509
2510    if (source && dest)
2511    {
2512        TextureStorage9_Cube *source9 = TextureStorage9_Cube::makeTextureStorage9_Cube(source->getStorageInstance());
2513        TextureStorage9_Cube *dest9 = TextureStorage9_Cube::makeTextureStorage9_Cube(dest->getStorageInstance());
2514        int levels = source9->levelCount();
2515        for (int f = 0; f < 6; f++)
2516        {
2517            for (int i = 0; i < levels; i++)
2518            {
2519                IDirect3DSurface9 *srcSurf = source9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, false);
2520                IDirect3DSurface9 *dstSurf = dest9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, true);
2521
2522                result = copyToRenderTarget(dstSurf, srcSurf, source9->isManaged());
2523
2524                if (srcSurf) srcSurf->Release();
2525                if (dstSurf) dstSurf->Release();
2526
2527                if (!result)
2528                    return false;
2529            }
2530        }
2531    }
2532
2533    return result;
2534}
2535
2536D3DPOOL Renderer9::getBufferPool(DWORD usage) const
2537{
2538    if (mD3d9Ex != NULL)
2539    {
2540        return D3DPOOL_DEFAULT;
2541    }
2542    else
2543    {
2544        if (!(usage & D3DUSAGE_DYNAMIC))
2545        {
2546            return D3DPOOL_MANAGED;
2547        }
2548    }
2549
2550    return D3DPOOL_DEFAULT;
2551}
2552
2553bool Renderer9::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
2554                          GLint xoffset, GLint yoffset, TextureStorageInterface2D *storage, GLint level)
2555{
2556    RECT rect;
2557    rect.left = sourceRect.x;
2558    rect.top = sourceRect.y;
2559    rect.right = sourceRect.x + sourceRect.width;
2560    rect.bottom = sourceRect.y + sourceRect.height;
2561
2562    return mBlit->copy(framebuffer, rect, destFormat, xoffset, yoffset, storage, level);
2563}
2564
2565bool Renderer9::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
2566                          GLint xoffset, GLint yoffset, TextureStorageInterfaceCube *storage, GLenum target, GLint level)
2567{
2568    RECT rect;
2569    rect.left = sourceRect.x;
2570    rect.top = sourceRect.y;
2571    rect.right = sourceRect.x + sourceRect.width;
2572    rect.bottom = sourceRect.y + sourceRect.height;
2573
2574    return mBlit->copy(framebuffer, rect, destFormat, xoffset, yoffset, storage, target, level);
2575}
2576
2577bool Renderer9::blitRect(gl::Framebuffer *readFramebuffer, const gl::Rectangle &readRect, gl::Framebuffer *drawFramebuffer, const gl::Rectangle &drawRect,
2578                         bool blitRenderTarget, bool blitDepthStencil)
2579{
2580    endScene();
2581
2582    if (blitRenderTarget)
2583    {
2584        gl::Renderbuffer *readBuffer = readFramebuffer->getColorbuffer(0);
2585        gl::Renderbuffer *drawBuffer = drawFramebuffer->getColorbuffer(0);
2586        RenderTarget9 *readRenderTarget = NULL;
2587        RenderTarget9 *drawRenderTarget = NULL;
2588        IDirect3DSurface9* readSurface = NULL;
2589        IDirect3DSurface9* drawSurface = NULL;
2590
2591        if (readBuffer)
2592        {
2593            readRenderTarget = RenderTarget9::makeRenderTarget9(readBuffer->getRenderTarget());
2594        }
2595        if (drawBuffer)
2596        {
2597            drawRenderTarget = RenderTarget9::makeRenderTarget9(drawBuffer->getRenderTarget());
2598        }
2599
2600        if (readRenderTarget)
2601        {
2602            readSurface = readRenderTarget->getSurface();
2603        }
2604        if (drawRenderTarget)
2605        {
2606            drawSurface = drawRenderTarget->getSurface();
2607        }
2608
2609        if (!readSurface || !drawSurface)
2610        {
2611            ERR("Failed to retrieve the render target.");
2612            return gl::error(GL_OUT_OF_MEMORY, false);
2613        }
2614
2615        RECT srcRect;
2616        srcRect.left = readRect.x;
2617        srcRect.right = readRect.x + readRect.width;
2618        srcRect.top = readRect.y;
2619        srcRect.bottom = readRect.y + readRect.height;
2620
2621        RECT dstRect;
2622        dstRect.left = drawRect.x;
2623        dstRect.right = drawRect.x + drawRect.width;
2624        dstRect.top = drawRect.y;
2625        dstRect.bottom = drawRect.y + drawRect.height;
2626
2627        HRESULT result = mDevice->StretchRect(readSurface, &srcRect, drawSurface, &dstRect, D3DTEXF_NONE);
2628
2629        readSurface->Release();
2630        drawSurface->Release();
2631
2632        if (FAILED(result))
2633        {
2634            ERR("BlitFramebufferANGLE failed: StretchRect returned %x.", result);
2635            return false;
2636        }
2637    }
2638
2639    if (blitDepthStencil)
2640    {
2641        gl::Renderbuffer *readBuffer = readFramebuffer->getDepthOrStencilbuffer();
2642        gl::Renderbuffer *drawBuffer = drawFramebuffer->getDepthOrStencilbuffer();
2643        RenderTarget9 *readDepthStencil = NULL;
2644        RenderTarget9 *drawDepthStencil = NULL;
2645        IDirect3DSurface9* readSurface = NULL;
2646        IDirect3DSurface9* drawSurface = NULL;
2647
2648        if (readBuffer)
2649        {
2650            readDepthStencil = RenderTarget9::makeRenderTarget9(readBuffer->getDepthStencil());
2651        }
2652        if (drawBuffer)
2653        {
2654            drawDepthStencil = RenderTarget9::makeRenderTarget9(drawBuffer->getDepthStencil());
2655        }
2656
2657        if (readDepthStencil)
2658        {
2659            readSurface = readDepthStencil->getSurface();
2660        }
2661        if (drawDepthStencil)
2662        {
2663            drawSurface = drawDepthStencil->getSurface();
2664        }
2665
2666        if (!readSurface || !drawSurface)
2667        {
2668            ERR("Failed to retrieve the render target.");
2669            return gl::error(GL_OUT_OF_MEMORY, false);
2670        }
2671
2672        HRESULT result = mDevice->StretchRect(readSurface, NULL, drawSurface, NULL, D3DTEXF_NONE);
2673
2674        readSurface->Release();
2675        drawSurface->Release();
2676
2677        if (FAILED(result))
2678        {
2679            ERR("BlitFramebufferANGLE failed: StretchRect returned %x.", result);
2680            return false;
2681        }
2682    }
2683
2684    return true;
2685}
2686
2687void Renderer9::readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
2688                           GLsizei outputPitch, bool packReverseRowOrder, GLint packAlignment, void* pixels)
2689{
2690    RenderTarget9 *renderTarget = NULL;
2691    IDirect3DSurface9 *surface = NULL;
2692    gl::Renderbuffer *colorbuffer = framebuffer->getColorbuffer(0);
2693
2694    if (colorbuffer)
2695    {
2696        renderTarget = RenderTarget9::makeRenderTarget9(colorbuffer->getRenderTarget());
2697    }
2698
2699    if (renderTarget)
2700    {
2701        surface = renderTarget->getSurface();
2702    }
2703
2704    if (!surface)
2705    {
2706        // context must be lost
2707        return;
2708    }
2709
2710    D3DSURFACE_DESC desc;
2711    surface->GetDesc(&desc);
2712
2713    if (desc.MultiSampleType != D3DMULTISAMPLE_NONE)
2714    {
2715        UNIMPLEMENTED();   // FIXME: Requires resolve using StretchRect into non-multisampled render target
2716        surface->Release();
2717        return gl::error(GL_OUT_OF_MEMORY);
2718    }
2719
2720    HRESULT result;
2721    IDirect3DSurface9 *systemSurface = NULL;
2722    bool directToPixels = !packReverseRowOrder && packAlignment <= 4 && getShareHandleSupport() &&
2723                          x == 0 && y == 0 && UINT(width) == desc.Width && UINT(height) == desc.Height &&
2724                          desc.Format == D3DFMT_A8R8G8B8 && format == GL_BGRA_EXT && type == GL_UNSIGNED_BYTE;
2725    if (directToPixels)
2726    {
2727        // Use the pixels ptr as a shared handle to write directly into client's memory
2728        result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format,
2729                                                      D3DPOOL_SYSTEMMEM, &systemSurface, &pixels);
2730        if (FAILED(result))
2731        {
2732            // Try again without the shared handle
2733            directToPixels = false;
2734        }
2735    }
2736
2737    if (!directToPixels)
2738    {
2739        result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format,
2740                                                      D3DPOOL_SYSTEMMEM, &systemSurface, NULL);
2741        if (FAILED(result))
2742        {
2743            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
2744            surface->Release();
2745            return gl::error(GL_OUT_OF_MEMORY);
2746        }
2747    }
2748
2749    result = mDevice->GetRenderTargetData(surface, systemSurface);
2750    surface->Release();
2751    surface = NULL;
2752
2753    if (FAILED(result))
2754    {
2755        systemSurface->Release();
2756
2757        // It turns out that D3D will sometimes produce more error
2758        // codes than those documented.
2759        if (d3d9::isDeviceLostError(result))
2760        {
2761            notifyDeviceLost();
2762            return gl::error(GL_OUT_OF_MEMORY);
2763        }
2764        else
2765        {
2766            UNREACHABLE();
2767            return;
2768        }
2769
2770    }
2771
2772    if (directToPixels)
2773    {
2774        systemSurface->Release();
2775        return;
2776    }
2777
2778    RECT rect;
2779    rect.left = gl::clamp(x, 0L, static_cast<LONG>(desc.Width));
2780    rect.top = gl::clamp(y, 0L, static_cast<LONG>(desc.Height));
2781    rect.right = gl::clamp(x + width, 0L, static_cast<LONG>(desc.Width));
2782    rect.bottom = gl::clamp(y + height, 0L, static_cast<LONG>(desc.Height));
2783
2784    D3DLOCKED_RECT lock;
2785    result = systemSurface->LockRect(&lock, &rect, D3DLOCK_READONLY);
2786
2787    if (FAILED(result))
2788    {
2789        UNREACHABLE();
2790        systemSurface->Release();
2791
2792        return;   // No sensible error to generate
2793    }
2794
2795    unsigned char *dest = (unsigned char*)pixels;
2796    unsigned short *dest16 = (unsigned short*)pixels;
2797
2798    unsigned char *source;
2799    int inputPitch;
2800    if (packReverseRowOrder)
2801    {
2802        source = ((unsigned char*)lock.pBits) + lock.Pitch * (rect.bottom - rect.top - 1);
2803        inputPitch = -lock.Pitch;
2804    }
2805    else
2806    {
2807        source = (unsigned char*)lock.pBits;
2808        inputPitch = lock.Pitch;
2809    }
2810
2811    unsigned int fastPixelSize = 0;
2812
2813    if (desc.Format == D3DFMT_A8R8G8B8 &&
2814        format == GL_BGRA_EXT &&
2815        type == GL_UNSIGNED_BYTE)
2816    {
2817        fastPixelSize = 4;
2818    }
2819    else if ((desc.Format == D3DFMT_A4R4G4B4 &&
2820             format == GL_BGRA_EXT &&
2821             type == GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT) ||
2822             (desc.Format == D3DFMT_A1R5G5B5 &&
2823             format == GL_BGRA_EXT &&
2824             type == GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT))
2825    {
2826        fastPixelSize = 2;
2827    }
2828    else if (desc.Format == D3DFMT_A16B16G16R16F &&
2829             format == GL_RGBA &&
2830             type == GL_HALF_FLOAT_OES)
2831    {
2832        fastPixelSize = 8;
2833    }
2834    else if (desc.Format == D3DFMT_A32B32G32R32F &&
2835             format == GL_RGBA &&
2836             type == GL_FLOAT)
2837    {
2838        fastPixelSize = 16;
2839    }
2840
2841    for (int j = 0; j < rect.bottom - rect.top; j++)
2842    {
2843        if (fastPixelSize != 0)
2844        {
2845            // Fast path for formats which require no translation:
2846            // D3DFMT_A8R8G8B8 to BGRA/UNSIGNED_BYTE
2847            // D3DFMT_A4R4G4B4 to BGRA/UNSIGNED_SHORT_4_4_4_4_REV_EXT
2848            // D3DFMT_A1R5G5B5 to BGRA/UNSIGNED_SHORT_1_5_5_5_REV_EXT
2849            // D3DFMT_A16B16G16R16F to RGBA/HALF_FLOAT_OES
2850            // D3DFMT_A32B32G32R32F to RGBA/FLOAT
2851            //
2852            // Note that buffers with no alpha go through the slow path below.
2853            memcpy(dest + j * outputPitch,
2854                   source + j * inputPitch,
2855                   (rect.right - rect.left) * fastPixelSize);
2856            continue;
2857        }
2858        else if (desc.Format == D3DFMT_A8R8G8B8 &&
2859                 format == GL_RGBA &&
2860                 type == GL_UNSIGNED_BYTE)
2861        {
2862            // Fast path for swapping red with blue
2863            for (int i = 0; i < rect.right - rect.left; i++)
2864            {
2865                unsigned int argb = *(unsigned int*)(source + 4 * i + j * inputPitch);
2866                *(unsigned int*)(dest + 4 * i + j * outputPitch) =
2867                    (argb & 0xFF00FF00) |       // Keep alpha and green
2868                    (argb & 0x00FF0000) >> 16 | // Move red to blue
2869                    (argb & 0x000000FF) << 16;  // Move blue to red
2870            }
2871            continue;
2872        }
2873
2874        for (int i = 0; i < rect.right - rect.left; i++)
2875        {
2876            float r;
2877            float g;
2878            float b;
2879            float a;
2880
2881            switch (desc.Format)
2882            {
2883              case D3DFMT_R5G6B5:
2884                {
2885                    unsigned short rgb = *(unsigned short*)(source + 2 * i + j * inputPitch);
2886
2887                    a = 1.0f;
2888                    b = (rgb & 0x001F) * (1.0f / 0x001F);
2889                    g = (rgb & 0x07E0) * (1.0f / 0x07E0);
2890                    r = (rgb & 0xF800) * (1.0f / 0xF800);
2891                }
2892                break;
2893              case D3DFMT_A1R5G5B5:
2894                {
2895                    unsigned short argb = *(unsigned short*)(source + 2 * i + j * inputPitch);
2896
2897                    a = (argb & 0x8000) ? 1.0f : 0.0f;
2898                    b = (argb & 0x001F) * (1.0f / 0x001F);
2899                    g = (argb & 0x03E0) * (1.0f / 0x03E0);
2900                    r = (argb & 0x7C00) * (1.0f / 0x7C00);
2901                }
2902                break;
2903              case D3DFMT_A8R8G8B8:
2904                {
2905                    unsigned int argb = *(unsigned int*)(source + 4 * i + j * inputPitch);
2906
2907                    a = (argb & 0xFF000000) * (1.0f / 0xFF000000);
2908                    b = (argb & 0x000000FF) * (1.0f / 0x000000FF);
2909                    g = (argb & 0x0000FF00) * (1.0f / 0x0000FF00);
2910                    r = (argb & 0x00FF0000) * (1.0f / 0x00FF0000);
2911                }
2912                break;
2913              case D3DFMT_X8R8G8B8:
2914                {
2915                    unsigned int xrgb = *(unsigned int*)(source + 4 * i + j * inputPitch);
2916
2917                    a = 1.0f;
2918                    b = (xrgb & 0x000000FF) * (1.0f / 0x000000FF);
2919                    g = (xrgb & 0x0000FF00) * (1.0f / 0x0000FF00);
2920                    r = (xrgb & 0x00FF0000) * (1.0f / 0x00FF0000);
2921                }
2922                break;
2923              case D3DFMT_A2R10G10B10:
2924                {
2925                    unsigned int argb = *(unsigned int*)(source + 4 * i + j * inputPitch);
2926
2927                    a = (argb & 0xC0000000) * (1.0f / 0xC0000000);
2928                    b = (argb & 0x000003FF) * (1.0f / 0x000003FF);
2929                    g = (argb & 0x000FFC00) * (1.0f / 0x000FFC00);
2930                    r = (argb & 0x3FF00000) * (1.0f / 0x3FF00000);
2931                }
2932                break;
2933              case D3DFMT_A32B32G32R32F:
2934                {
2935                    // float formats in D3D are stored rgba, rather than the other way round
2936                    r = *((float*)(source + 16 * i + j * inputPitch) + 0);
2937                    g = *((float*)(source + 16 * i + j * inputPitch) + 1);
2938                    b = *((float*)(source + 16 * i + j * inputPitch) + 2);
2939                    a = *((float*)(source + 16 * i + j * inputPitch) + 3);
2940                }
2941                break;
2942              case D3DFMT_A16B16G16R16F:
2943                {
2944                    // float formats in D3D are stored rgba, rather than the other way round
2945                    r = gl::float16ToFloat32(*((unsigned short*)(source + 8 * i + j * inputPitch) + 0));
2946                    g = gl::float16ToFloat32(*((unsigned short*)(source + 8 * i + j * inputPitch) + 1));
2947                    b = gl::float16ToFloat32(*((unsigned short*)(source + 8 * i + j * inputPitch) + 2));
2948                    a = gl::float16ToFloat32(*((unsigned short*)(source + 8 * i + j * inputPitch) + 3));
2949                }
2950                break;
2951              default:
2952                UNIMPLEMENTED();   // FIXME
2953                UNREACHABLE();
2954                return;
2955            }
2956
2957            switch (format)
2958            {
2959              case GL_RGBA:
2960                switch (type)
2961                {
2962                  case GL_UNSIGNED_BYTE:
2963                    dest[4 * i + j * outputPitch + 0] = (unsigned char)(255 * r + 0.5f);
2964                    dest[4 * i + j * outputPitch + 1] = (unsigned char)(255 * g + 0.5f);
2965                    dest[4 * i + j * outputPitch + 2] = (unsigned char)(255 * b + 0.5f);
2966                    dest[4 * i + j * outputPitch + 3] = (unsigned char)(255 * a + 0.5f);
2967                    break;
2968                  default: UNREACHABLE();
2969                }
2970                break;
2971              case GL_BGRA_EXT:
2972                switch (type)
2973                {
2974                  case GL_UNSIGNED_BYTE:
2975                    dest[4 * i + j * outputPitch + 0] = (unsigned char)(255 * b + 0.5f);
2976                    dest[4 * i + j * outputPitch + 1] = (unsigned char)(255 * g + 0.5f);
2977                    dest[4 * i + j * outputPitch + 2] = (unsigned char)(255 * r + 0.5f);
2978                    dest[4 * i + j * outputPitch + 3] = (unsigned char)(255 * a + 0.5f);
2979                    break;
2980                  case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
2981                    // According to the desktop GL spec in the "Transfer of Pixel Rectangles" section
2982                    // this type is packed as follows:
2983                    //   15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
2984                    //  --------------------------------------------------------------------------------
2985                    // |       4th         |        3rd         |        2nd        |   1st component   |
2986                    //  --------------------------------------------------------------------------------
2987                    // in the case of BGRA_EXT, B is the first component, G the second, and so forth.
2988                    dest16[i + j * outputPitch / sizeof(unsigned short)] =
2989                        ((unsigned short)(15 * a + 0.5f) << 12)|
2990                        ((unsigned short)(15 * r + 0.5f) << 8) |
2991                        ((unsigned short)(15 * g + 0.5f) << 4) |
2992                        ((unsigned short)(15 * b + 0.5f) << 0);
2993                    break;
2994                  case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
2995                    // According to the desktop GL spec in the "Transfer of Pixel Rectangles" section
2996                    // this type is packed as follows:
2997                    //   15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
2998                    //  --------------------------------------------------------------------------------
2999                    // | 4th |          3rd           |           2nd          |      1st component     |
3000                    //  --------------------------------------------------------------------------------
3001                    // in the case of BGRA_EXT, B is the first component, G the second, and so forth.
3002                    dest16[i + j * outputPitch / sizeof(unsigned short)] =
3003                        ((unsigned short)(     a + 0.5f) << 15) |
3004                        ((unsigned short)(31 * r + 0.5f) << 10) |
3005                        ((unsigned short)(31 * g + 0.5f) << 5) |
3006                        ((unsigned short)(31 * b + 0.5f) << 0);
3007                    break;
3008                  default: UNREACHABLE();
3009                }
3010                break;
3011              case GL_RGB:
3012                switch (type)
3013                {
3014                  case GL_UNSIGNED_SHORT_5_6_5:
3015                    dest16[i + j * outputPitch / sizeof(unsigned short)] =
3016                        ((unsigned short)(31 * b + 0.5f) << 0) |
3017                        ((unsigned short)(63 * g + 0.5f) << 5) |
3018                        ((unsigned short)(31 * r + 0.5f) << 11);
3019                    break;
3020                  case GL_UNSIGNED_BYTE:
3021                    dest[3 * i + j * outputPitch + 0] = (unsigned char)(255 * r + 0.5f);
3022                    dest[3 * i + j * outputPitch + 1] = (unsigned char)(255 * g + 0.5f);
3023                    dest[3 * i + j * outputPitch + 2] = (unsigned char)(255 * b + 0.5f);
3024                    break;
3025                  default: UNREACHABLE();
3026                }
3027                break;
3028              default: UNREACHABLE();
3029            }
3030        }
3031    }
3032
3033    systemSurface->UnlockRect();
3034
3035    systemSurface->Release();
3036}
3037
3038RenderTarget *Renderer9::createRenderTarget(SwapChain *swapChain, bool depth)
3039{
3040    SwapChain9 *swapChain9 = SwapChain9::makeSwapChain9(swapChain);
3041    IDirect3DSurface9 *surface = NULL;
3042    if (depth)
3043    {
3044        surface = swapChain9->getDepthStencil();
3045    }
3046    else
3047    {
3048        surface = swapChain9->getRenderTarget();
3049    }
3050
3051    RenderTarget9 *renderTarget = new RenderTarget9(this, surface);
3052
3053    return renderTarget;
3054}
3055
3056RenderTarget *Renderer9::createRenderTarget(int width, int height, GLenum format, GLsizei samples, bool depth)
3057{
3058    RenderTarget9 *renderTarget = new RenderTarget9(this, width, height, format, samples);
3059    return renderTarget;
3060}
3061
3062ShaderExecutable *Renderer9::loadExecutable(const void *function, size_t length, rx::ShaderType type)
3063{
3064    ShaderExecutable9 *executable = NULL;
3065
3066    switch (type)
3067    {
3068      case rx::SHADER_VERTEX:
3069        {
3070            IDirect3DVertexShader9 *vshader = createVertexShader((DWORD*)function, length);
3071            if (vshader)
3072            {
3073                executable = new ShaderExecutable9(function, length, vshader);
3074            }
3075        }
3076        break;
3077      case rx::SHADER_PIXEL:
3078        {
3079            IDirect3DPixelShader9 *pshader = createPixelShader((DWORD*)function, length);
3080            if (pshader)
3081            {
3082                executable = new ShaderExecutable9(function, length, pshader);
3083            }
3084        }
3085        break;
3086      default:
3087        UNREACHABLE();
3088        break;
3089    }
3090
3091    return executable;
3092}
3093
3094ShaderExecutable *Renderer9::compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, rx::ShaderType type)
3095{
3096    const char *profile = NULL;
3097
3098    switch (type)
3099    {
3100      case rx::SHADER_VERTEX:
3101        profile = getMajorShaderModel() >= 3 ? "vs_3_0" : "vs_2_0";
3102        break;
3103      case rx::SHADER_PIXEL:
3104        profile = getMajorShaderModel() >= 3 ? "ps_3_0" : "ps_2_0";
3105        break;
3106      default:
3107        UNREACHABLE();
3108        return NULL;
3109    }
3110
3111    ID3DBlob *binary = (ID3DBlob*)compileToBinary(infoLog, shaderHLSL, profile, ANGLE_COMPILE_OPTIMIZATION_LEVEL, true);
3112    if (!binary)
3113        return NULL;
3114
3115    ShaderExecutable *executable = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type);
3116    binary->Release();
3117
3118    return executable;
3119}
3120
3121bool Renderer9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
3122{
3123    return mBlit->boxFilter(source, dest);
3124}
3125
3126D3DPOOL Renderer9::getTexturePool(DWORD usage) const
3127{
3128    if (mD3d9Ex != NULL)
3129    {
3130        return D3DPOOL_DEFAULT;
3131    }
3132    else
3133    {
3134        if (!(usage & (D3DUSAGE_DEPTHSTENCIL | D3DUSAGE_RENDERTARGET)))
3135        {
3136            return D3DPOOL_MANAGED;
3137        }
3138    }
3139
3140    return D3DPOOL_DEFAULT;
3141}
3142
3143bool Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged)
3144{
3145    if (source && dest)
3146    {
3147        HRESULT result = D3DERR_OUTOFVIDEOMEMORY;
3148
3149        if (fromManaged)
3150        {
3151            D3DSURFACE_DESC desc;
3152            source->GetDesc(&desc);
3153
3154            IDirect3DSurface9 *surf = 0;
3155            result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surf, NULL);
3156
3157            if (SUCCEEDED(result))
3158            {
3159                Image9::copyLockableSurfaces(surf, source);
3160                result = mDevice->UpdateSurface(surf, NULL, dest, NULL);
3161                surf->Release();
3162            }
3163        }
3164        else
3165        {
3166            endScene();
3167            result = mDevice->StretchRect(source, NULL, dest, NULL, D3DTEXF_NONE);
3168        }
3169
3170        if (FAILED(result))
3171        {
3172            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
3173            return false;
3174        }
3175    }
3176
3177    return true;
3178}
3179
3180Image *Renderer9::createImage()
3181{
3182    return new Image9();
3183}
3184
3185void Renderer9::generateMipmap(Image *dest, Image *src)
3186{
3187    Image9 *src9 = Image9::makeImage9(src);
3188    Image9 *dst9 = Image9::makeImage9(dest);
3189    Image9::generateMipmap(dst9, src9);
3190}
3191
3192TextureStorage *Renderer9::createTextureStorage2D(SwapChain *swapChain)
3193{
3194    SwapChain9 *swapChain9 = SwapChain9::makeSwapChain9(swapChain);
3195    return new TextureStorage9_2D(this, swapChain9);
3196}
3197
3198TextureStorage *Renderer9::createTextureStorage2D(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
3199{
3200    return new TextureStorage9_2D(this, levels, internalformat, usage, forceRenderable, width, height);
3201}
3202
3203TextureStorage *Renderer9::createTextureStorageCube(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
3204{
3205    return new TextureStorage9_Cube(this, levels, internalformat, usage, forceRenderable, size);
3206}
3207
3208bool Renderer9::getLUID(LUID *adapterLuid) const
3209{
3210    adapterLuid->HighPart = 0;
3211    adapterLuid->LowPart = 0;
3212
3213    if (mD3d9Ex)
3214    {
3215        mD3d9Ex->GetAdapterLUID(mAdapter, adapterLuid);
3216        return true;
3217    }
3218
3219    return false;
3220}
3221
3222}
3223