1//
2// Copyright (c) 2012-2014 The ANGLE Project Authors. All rights reserved.
3// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
7// SwapChain9.cpp: Implements a back-end specific class for the D3D9 swap chain.
8
9#include "libGLESv2/renderer/d3d/d3d9/SwapChain9.h"
10#include "libGLESv2/renderer/d3d/d3d9/renderer9_utils.h"
11#include "libGLESv2/renderer/d3d/d3d9/formatutils9.h"
12#include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
13
14namespace rx
15{
16
17SwapChain9::SwapChain9(Renderer9 *renderer, HWND window, HANDLE shareHandle,
18                       GLenum backBufferFormat, GLenum depthBufferFormat)
19    : mRenderer(renderer), SwapChain(window, shareHandle, backBufferFormat, depthBufferFormat)
20{
21    mSwapChain = NULL;
22    mBackBuffer = NULL;
23    mDepthStencil = NULL;
24    mRenderTarget = NULL;
25    mOffscreenTexture = NULL;
26    mWidth = -1;
27    mHeight = -1;
28    mSwapInterval = -1;
29}
30
31SwapChain9::~SwapChain9()
32{
33    release();
34}
35
36void SwapChain9::release()
37{
38    SafeRelease(mSwapChain);
39    SafeRelease(mBackBuffer);
40    SafeRelease(mDepthStencil);
41    SafeRelease(mRenderTarget);
42    SafeRelease(mOffscreenTexture);
43
44    if (mWindow)
45    {
46        mShareHandle = NULL;
47    }
48}
49
50static DWORD convertInterval(EGLint interval)
51{
52#ifdef ANGLE_FORCE_VSYNC_OFF
53    return D3DPRESENT_INTERVAL_IMMEDIATE;
54#else
55    switch(interval)
56    {
57      case 0: return D3DPRESENT_INTERVAL_IMMEDIATE;
58      case 1: return D3DPRESENT_INTERVAL_ONE;
59      case 2: return D3DPRESENT_INTERVAL_TWO;
60      case 3: return D3DPRESENT_INTERVAL_THREE;
61      case 4: return D3DPRESENT_INTERVAL_FOUR;
62      default: UNREACHABLE();
63    }
64
65    return D3DPRESENT_INTERVAL_DEFAULT;
66#endif
67}
68
69EGLint SwapChain9::resize(int backbufferWidth, int backbufferHeight)
70{
71    // D3D9 does not support resizing swap chains without recreating them
72    return reset(backbufferWidth, backbufferHeight, mSwapInterval);
73}
74
75EGLint SwapChain9::reset(int backbufferWidth, int backbufferHeight, EGLint swapInterval)
76{
77    IDirect3DDevice9 *device = mRenderer->getDevice();
78
79    if (device == NULL)
80    {
81        return EGL_BAD_ACCESS;
82    }
83
84    // Evict all non-render target textures to system memory and release all resources
85    // before reallocating them to free up as much video memory as possible.
86    device->EvictManagedResources();
87
88    HRESULT result;
89
90    // Release specific resources to free up memory for the new render target, while the
91    // old render target still exists for the purpose of preserving its contents.
92    SafeRelease(mSwapChain);
93    SafeRelease(mBackBuffer);
94    SafeRelease(mOffscreenTexture);
95    SafeRelease(mDepthStencil);
96
97    HANDLE *pShareHandle = NULL;
98    if (!mWindow && mRenderer->getShareHandleSupport())
99    {
100        pShareHandle = &mShareHandle;
101    }
102
103    const d3d9::TextureFormat &backBufferd3dFormatInfo = d3d9::GetTextureFormatInfo(mBackBufferFormat);
104    result = device->CreateTexture(backbufferWidth, backbufferHeight, 1, D3DUSAGE_RENDERTARGET,
105                                   backBufferd3dFormatInfo.texFormat, D3DPOOL_DEFAULT, &mOffscreenTexture,
106                                   pShareHandle);
107    if (FAILED(result))
108    {
109        ERR("Could not create offscreen texture: %08lX", result);
110        release();
111
112        if (d3d9::isDeviceLostError(result))
113        {
114            return EGL_CONTEXT_LOST;
115        }
116        else
117        {
118            return EGL_BAD_ALLOC;
119        }
120    }
121
122    IDirect3DSurface9 *oldRenderTarget = mRenderTarget;
123
124    result = mOffscreenTexture->GetSurfaceLevel(0, &mRenderTarget);
125    ASSERT(SUCCEEDED(result));
126
127    if (oldRenderTarget)
128    {
129        RECT rect =
130        {
131            0, 0,
132            mWidth, mHeight
133        };
134
135        if (rect.right > static_cast<LONG>(backbufferWidth))
136        {
137            rect.right = backbufferWidth;
138        }
139
140        if (rect.bottom > static_cast<LONG>(backbufferHeight))
141        {
142            rect.bottom = backbufferHeight;
143        }
144
145        mRenderer->endScene();
146
147        result = device->StretchRect(oldRenderTarget, &rect, mRenderTarget, &rect, D3DTEXF_NONE);
148        ASSERT(SUCCEEDED(result));
149
150        SafeRelease(oldRenderTarget);
151    }
152
153    const d3d9::TextureFormat &depthBufferd3dFormatInfo = d3d9::GetTextureFormatInfo(mDepthBufferFormat);
154
155    if (mWindow)
156    {
157        D3DPRESENT_PARAMETERS presentParameters = {0};
158        presentParameters.AutoDepthStencilFormat = depthBufferd3dFormatInfo.renderFormat;
159        presentParameters.BackBufferCount = 1;
160        presentParameters.BackBufferFormat = backBufferd3dFormatInfo.renderFormat;
161        presentParameters.EnableAutoDepthStencil = FALSE;
162        presentParameters.Flags = 0;
163        presentParameters.hDeviceWindow = mWindow;
164        presentParameters.MultiSampleQuality = 0;                  // FIXME: Unimplemented
165        presentParameters.MultiSampleType = D3DMULTISAMPLE_NONE;   // FIXME: Unimplemented
166        presentParameters.PresentationInterval = convertInterval(swapInterval);
167        presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
168        presentParameters.Windowed = TRUE;
169        presentParameters.BackBufferWidth = backbufferWidth;
170        presentParameters.BackBufferHeight = backbufferHeight;
171
172        // http://crbug.com/140239
173        // http://crbug.com/143434
174        //
175        // Some AMD/Intel switchable systems / drivers appear to round swap chain surfaces to a multiple of 64 pixels in width
176        // when using the integrated Intel. This rounds the width up rather than down.
177        //
178        // Some non-switchable AMD GPUs / drivers do not respect the source rectangle to Present. Therefore, when the vendor ID
179        // is not Intel, the back buffer width must be exactly the same width as the window or horizontal scaling will occur.
180        if (mRenderer->getAdapterVendor() == VENDOR_ID_INTEL)
181        {
182            presentParameters.BackBufferWidth = (presentParameters.BackBufferWidth + 63) / 64 * 64;
183        }
184
185        result = device->CreateAdditionalSwapChain(&presentParameters, &mSwapChain);
186
187        if (FAILED(result))
188        {
189            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_INVALIDCALL || result == D3DERR_DEVICELOST);
190
191            ERR("Could not create additional swap chains or offscreen surfaces: %08lX", result);
192            release();
193
194            if (d3d9::isDeviceLostError(result))
195            {
196                return EGL_CONTEXT_LOST;
197            }
198            else
199            {
200                return EGL_BAD_ALLOC;
201            }
202        }
203
204        result = mSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mBackBuffer);
205        ASSERT(SUCCEEDED(result));
206        InvalidateRect(mWindow, NULL, FALSE);
207    }
208
209    if (mDepthBufferFormat != GL_NONE)
210    {
211        result = device->CreateDepthStencilSurface(backbufferWidth, backbufferHeight,
212                                                   depthBufferd3dFormatInfo.renderFormat,
213                                                   D3DMULTISAMPLE_NONE, 0, FALSE, &mDepthStencil, NULL);
214
215        if (FAILED(result))
216        {
217            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_INVALIDCALL);
218
219            ERR("Could not create depthstencil surface for new swap chain: 0x%08X", result);
220            release();
221
222            if (d3d9::isDeviceLostError(result))
223            {
224                return EGL_CONTEXT_LOST;
225            }
226            else
227            {
228                return EGL_BAD_ALLOC;
229            }
230        }
231    }
232
233    mWidth = backbufferWidth;
234    mHeight = backbufferHeight;
235    mSwapInterval = swapInterval;
236
237    return EGL_SUCCESS;
238}
239
240// parameters should be validated/clamped by caller
241EGLint SwapChain9::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
242{
243    if (!mSwapChain)
244    {
245        return EGL_SUCCESS;
246    }
247
248    IDirect3DDevice9 *device = mRenderer->getDevice();
249
250    // Disable all pipeline operations
251    device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
252    device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
253    device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
254    device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
255    device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
256    device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
257    device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
258    device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED);
259    device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
260    device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
261    device->SetPixelShader(NULL);
262    device->SetVertexShader(NULL);
263
264    device->SetRenderTarget(0, mBackBuffer);
265    device->SetDepthStencilSurface(NULL);
266
267    device->SetTexture(0, mOffscreenTexture);
268    device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
269    device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
270    device->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
271    device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
272    device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
273    device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
274    device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
275    device->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
276
277    for (UINT streamIndex = 0; streamIndex < gl::MAX_VERTEX_ATTRIBS; streamIndex++)
278    {
279        device->SetStreamSourceFreq(streamIndex, 1);
280    }
281
282    D3DVIEWPORT9 viewport = {0, 0, mWidth, mHeight, 0.0f, 1.0f};
283    device->SetViewport(&viewport);
284
285    float x1 = x - 0.5f;
286    float y1 = (mHeight - y - height) - 0.5f;
287    float x2 = (x + width) - 0.5f;
288    float y2 = (mHeight - y) - 0.5f;
289
290    float u1 = x / float(mWidth);
291    float v1 = y / float(mHeight);
292    float u2 = (x + width) / float(mWidth);
293    float v2 = (y + height) / float(mHeight);
294
295    float quad[4][6] = {{x1, y1, 0.0f, 1.0f, u1, v2},
296                        {x2, y1, 0.0f, 1.0f, u2, v2},
297                        {x2, y2, 0.0f, 1.0f, u2, v1},
298                        {x1, y2, 0.0f, 1.0f, u1, v1}};   // x, y, z, rhw, u, v
299
300    mRenderer->startScene();
301    device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, quad, 6 * sizeof(float));
302    mRenderer->endScene();
303
304    device->SetTexture(0, NULL);
305
306    RECT rect =
307    {
308        x, mHeight - y - height,
309        x + width, mHeight - y
310    };
311
312    HRESULT result = mSwapChain->Present(&rect, &rect, NULL, NULL, 0);
313
314    mRenderer->markAllStateDirty();
315
316    if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DRIVERINTERNALERROR)
317    {
318        return EGL_BAD_ALLOC;
319    }
320
321    // On Windows 8 systems, IDirect3DSwapChain9::Present sometimes returns 0x88760873 when the windows is
322    // in the process of entering/exiting fullscreen. This code doesn't seem to have any documentation.  The
323    // device appears to be ok after emitting this error so simply return a failure to swap.
324    if (result == 0x88760873)
325    {
326        return EGL_BAD_MATCH;
327    }
328
329    // http://crbug.com/313210
330    // If our swap failed, trigger a device lost event. Resetting will work around an AMD-specific
331    // device removed bug with lost contexts when reinstalling drivers.
332    if (FAILED(result))
333    {
334        mRenderer->notifyDeviceLost();
335        return EGL_CONTEXT_LOST;
336    }
337
338    return EGL_SUCCESS;
339}
340
341// Increments refcount on surface.
342// caller must Release() the returned surface
343// TODO: remove the AddRef to match SwapChain11
344IDirect3DSurface9 *SwapChain9::getRenderTarget()
345{
346    if (mRenderTarget)
347    {
348        mRenderTarget->AddRef();
349    }
350
351    return mRenderTarget;
352}
353
354// Increments refcount on surface.
355// caller must Release() the returned surface
356// TODO: remove the AddRef to match SwapChain11
357IDirect3DSurface9 *SwapChain9::getDepthStencil()
358{
359    if (mDepthStencil)
360    {
361        mDepthStencil->AddRef();
362    }
363
364    return mDepthStencil;
365}
366
367// Increments refcount on texture.
368// caller must Release() the returned texture
369// TODO: remove the AddRef to match SwapChain11
370IDirect3DTexture9 *SwapChain9::getOffscreenTexture()
371{
372    if (mOffscreenTexture)
373    {
374        mOffscreenTexture->AddRef();
375    }
376
377    return mOffscreenTexture;
378}
379
380SwapChain9 *SwapChain9::makeSwapChain9(SwapChain *swapChain)
381{
382    ASSERT(HAS_DYNAMIC_TYPE(rx::SwapChain9*, swapChain));
383    return static_cast<rx::SwapChain9*>(swapChain);
384}
385
386void SwapChain9::recreate()
387{
388    if (!mSwapChain)
389    {
390        return;
391    }
392
393    IDirect3DDevice9 *device = mRenderer->getDevice();
394    if (device == NULL)
395    {
396        return;
397    }
398
399    D3DPRESENT_PARAMETERS presentParameters;
400    HRESULT result = mSwapChain->GetPresentParameters(&presentParameters);
401    ASSERT(SUCCEEDED(result));
402
403    IDirect3DSwapChain9* newSwapChain = NULL;
404    result = device->CreateAdditionalSwapChain(&presentParameters, &newSwapChain);
405    if (FAILED(result))
406    {
407        return;
408    }
409
410    SafeRelease(mSwapChain);
411    mSwapChain = newSwapChain;
412
413    SafeRelease(mBackBuffer);
414    result = mSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mBackBuffer);
415    ASSERT(SUCCEEDED(result));
416}
417
418}
419