The Tor Browser / file comparison

comparison: gfx/angle/src/libGLESv2/renderer/SwapChain9.cpp

gfx/angle/src/libGLESv2/renderer/SwapChain9.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial