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 // Renderer9.cpp: Implements a back-end specific class for the D3D9 renderer.
8
9 #include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
10
11 #include <EGL/eglext.h>
12 #include <sstream>
13
14 #include "common/utilities.h"
15 #include "libANGLE/Buffer.h"
16 #include "libANGLE/Context.h"
17 #include "libANGLE/Display.h"
18 #include "libANGLE/Framebuffer.h"
19 #include "libANGLE/FramebufferAttachment.h"
20 #include "libANGLE/Program.h"
21 #include "libANGLE/Renderbuffer.h"
22 #include "libANGLE/State.h"
23 #include "libANGLE/Surface.h"
24 #include "libANGLE/Texture.h"
25 #include "libANGLE/angletypes.h"
26 #include "libANGLE/features.h"
27 #include "libANGLE/formatutils.h"
28 #include "libANGLE/renderer/d3d/CompilerD3D.h"
29 #include "libANGLE/renderer/d3d/DeviceD3D.h"
30 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
31 #include "libANGLE/renderer/d3d/IndexDataManager.h"
32 #include "libANGLE/renderer/d3d/ProgramD3D.h"
33 #include "libANGLE/renderer/d3d/RenderbufferD3D.h"
34 #include "libANGLE/renderer/d3d/ShaderD3D.h"
35 #include "libANGLE/renderer/d3d/SurfaceD3D.h"
36 #include "libANGLE/renderer/d3d/TextureD3D.h"
37 #include "libANGLE/renderer/d3d/d3d9/Blit9.h"
38 #include "libANGLE/renderer/d3d/d3d9/Buffer9.h"
39 #include "libANGLE/renderer/d3d/d3d9/Context9.h"
40 #include "libANGLE/renderer/d3d/d3d9/Fence9.h"
41 #include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h"
42 #include "libANGLE/renderer/d3d/d3d9/Image9.h"
43 #include "libANGLE/renderer/d3d/d3d9/IndexBuffer9.h"
44 #include "libANGLE/renderer/d3d/d3d9/NativeWindow9.h"
45 #include "libANGLE/renderer/d3d/d3d9/Query9.h"
46 #include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h"
47 #include "libANGLE/renderer/d3d/d3d9/ShaderExecutable9.h"
48 #include "libANGLE/renderer/d3d/d3d9/SwapChain9.h"
49 #include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h"
50 #include "libANGLE/renderer/d3d/d3d9/VertexArray9.h"
51 #include "libANGLE/renderer/d3d/d3d9/VertexBuffer9.h"
52 #include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
53 #include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
54 #include "third_party/trace_event/trace_event.h"
55
56 #if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL)
57 #define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL3
58 #endif
59
60 // Enable ANGLE_SUPPORT_SHADER_MODEL_2 if you wish devices with only shader model 2.
61 // Such a device would not be conformant.
62 #ifndef ANGLE_SUPPORT_SHADER_MODEL_2
63 #define ANGLE_SUPPORT_SHADER_MODEL_2 0
64 #endif
65
66 namespace rx
67 {
68
69 enum
70 {
71 MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256,
72 MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32,
73 MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224,
74 MAX_VARYING_VECTORS_SM2 = 8,
75 MAX_VARYING_VECTORS_SM3 = 10,
76
77 MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4
78 };
79
Renderer9(egl::Display * display)80 Renderer9::Renderer9(egl::Display *display) : RendererD3D(display), mStateManager(this)
81 {
82 mD3d9Module = nullptr;
83
84 mD3d9 = nullptr;
85 mD3d9Ex = nullptr;
86 mDevice = nullptr;
87 mDeviceEx = nullptr;
88 mDeviceWindow = nullptr;
89 mBlit = nullptr;
90
91 mAdapter = D3DADAPTER_DEFAULT;
92
93 const egl::AttributeMap &attributes = display->getAttributeMap();
94 EGLint requestedDeviceType = static_cast<EGLint>(attributes.get(
95 EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE));
96 switch (requestedDeviceType)
97 {
98 case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE:
99 mDeviceType = D3DDEVTYPE_HAL;
100 break;
101
102 case EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE:
103 mDeviceType = D3DDEVTYPE_REF;
104 break;
105
106 case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE:
107 mDeviceType = D3DDEVTYPE_NULLREF;
108 break;
109
110 default:
111 UNREACHABLE();
112 }
113
114 mMaskedClearSavedState = nullptr;
115
116 mVertexDataManager = nullptr;
117 mIndexDataManager = nullptr;
118 mLineLoopIB = nullptr;
119 mCountingIB = nullptr;
120
121 mMaxNullColorbufferLRU = 0;
122 for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
123 {
124 mNullColorbufferCache[i].lruCount = 0;
125 mNullColorbufferCache[i].width = 0;
126 mNullColorbufferCache[i].height = 0;
127 mNullColorbufferCache[i].buffer = nullptr;
128 }
129
130 mAppliedVertexShader = nullptr;
131 mAppliedPixelShader = nullptr;
132 mAppliedProgramSerial = 0;
133
134 gl::InitializeDebugAnnotations(&mAnnotator);
135
136 mEGLDevice = nullptr;
137 }
138
~Renderer9()139 Renderer9::~Renderer9()
140 {
141 if (mDevice)
142 {
143 // If the device is lost, reset it first to prevent leaving the driver in an unstable state
144 if (testDeviceLost())
145 {
146 resetDevice();
147 }
148 }
149
150 release();
151 }
152
release()153 void Renderer9::release()
154 {
155 RendererD3D::cleanup();
156
157 gl::UninitializeDebugAnnotations();
158
159 mTranslatedAttribCache.clear();
160
161 releaseDeviceResources();
162
163 SafeDelete(mEGLDevice);
164 SafeRelease(mDevice);
165 SafeRelease(mDeviceEx);
166 SafeRelease(mD3d9);
167 SafeRelease(mD3d9Ex);
168
169 mCompiler.release();
170
171 if (mDeviceWindow)
172 {
173 DestroyWindow(mDeviceWindow);
174 mDeviceWindow = nullptr;
175 }
176
177 mD3d9Module = nullptr;
178 }
179
initialize()180 egl::Error Renderer9::initialize()
181 {
182 TRACE_EVENT0("gpu.angle", "GetModuleHandle_d3d9");
183 mD3d9Module = GetModuleHandle(TEXT("d3d9.dll"));
184
185 if (mD3d9Module == nullptr)
186 {
187 return egl::EglNotInitialized(D3D9_INIT_MISSING_DEP) << "No D3D9 module found.";
188 }
189
190 typedef HRESULT(WINAPI * Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex **);
191 Direct3DCreate9ExFunc Direct3DCreate9ExPtr =
192 reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex"));
193
194 // Use Direct3D9Ex if available. Among other things, this version is less
195 // inclined to report a lost context, for example when the user switches
196 // desktop. Direct3D9Ex is available in Windows Vista and later if suitable drivers are
197 // available.
198 if (ANGLE_D3D9EX == ANGLE_ENABLED && Direct3DCreate9ExPtr &&
199 SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &mD3d9Ex)))
200 {
201 TRACE_EVENT0("gpu.angle", "D3d9Ex_QueryInterface");
202 ASSERT(mD3d9Ex);
203 mD3d9Ex->QueryInterface(__uuidof(IDirect3D9), reinterpret_cast<void **>(&mD3d9));
204 ASSERT(mD3d9);
205 }
206 else
207 {
208 TRACE_EVENT0("gpu.angle", "Direct3DCreate9");
209 mD3d9 = Direct3DCreate9(D3D_SDK_VERSION);
210 }
211
212 if (!mD3d9)
213 {
214 return egl::EglNotInitialized(D3D9_INIT_MISSING_DEP) << "Could not create D3D9 device.";
215 }
216
217 if (mDisplay->getNativeDisplayId() != nullptr)
218 {
219 // UNIMPLEMENTED(); // FIXME: Determine which adapter index the device context
220 // corresponds to
221 }
222
223 HRESULT result;
224
225 // Give up on getting device caps after about one second.
226 {
227 TRACE_EVENT0("gpu.angle", "GetDeviceCaps");
228 for (int i = 0; i < 10; ++i)
229 {
230 result = mD3d9->GetDeviceCaps(mAdapter, mDeviceType, &mDeviceCaps);
231 if (SUCCEEDED(result))
232 {
233 break;
234 }
235 else if (result == D3DERR_NOTAVAILABLE)
236 {
237 Sleep(100); // Give the driver some time to initialize/recover
238 }
239 else if (FAILED(result)) // D3DERR_OUTOFVIDEOMEMORY, E_OUTOFMEMORY,
240 // D3DERR_INVALIDDEVICE, or another error we can't recover
241 // from
242 {
243 return egl::EglNotInitialized(D3D9_INIT_OTHER_ERROR)
244 << "Failed to get device caps, " << gl::FmtHR(result);
245 }
246 }
247 }
248
249 #if ANGLE_SUPPORT_SHADER_MODEL_2
250 size_t minShaderModel = 2;
251 #else
252 size_t minShaderModel = 3;
253 #endif
254
255 if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(minShaderModel, 0))
256 {
257 return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_VERSION)
258 << "Renderer does not support PS " << minShaderModel << ".0, aborting!";
259 }
260
261 // When DirectX9 is running with an older DirectX8 driver, a StretchRect from a regular texture
262 // to a render target texture is not supported. This is required by
263 // Texture2D::ensureRenderTarget.
264 if ((mDeviceCaps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES) == 0)
265 {
266 return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_STRETCHRECT)
267 << "Renderer does not support StretctRect from textures.";
268 }
269
270 {
271 TRACE_EVENT0("gpu.angle", "GetAdapterIdentifier");
272 mD3d9->GetAdapterIdentifier(mAdapter, 0, &mAdapterIdentifier);
273 }
274
275 static const TCHAR windowName[] = TEXT("AngleHiddenWindow");
276 static const TCHAR className[] = TEXT("STATIC");
277
278 {
279 TRACE_EVENT0("gpu.angle", "CreateWindowEx");
280 mDeviceWindow =
281 CreateWindowEx(WS_EX_NOACTIVATE, className, windowName, WS_DISABLED | WS_POPUP, 0, 0, 1,
282 1, HWND_MESSAGE, nullptr, GetModuleHandle(nullptr), nullptr);
283 }
284
285 D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
286 DWORD behaviorFlags =
287 D3DCREATE_FPU_PRESERVE | D3DCREATE_NOWINDOWCHANGES | D3DCREATE_MULTITHREADED;
288
289 {
290 TRACE_EVENT0("gpu.angle", "D3d9_CreateDevice");
291 result = mD3d9->CreateDevice(
292 mAdapter, mDeviceType, mDeviceWindow,
293 behaviorFlags | D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE,
294 &presentParameters, &mDevice);
295 }
296 if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DEVICELOST)
297 {
298 return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY)
299 << "CreateDevice failed: device lost of out of memory";
300 }
301
302 if (FAILED(result))
303 {
304 TRACE_EVENT0("gpu.angle", "D3d9_CreateDevice2");
305 result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow,
306 behaviorFlags | D3DCREATE_SOFTWARE_VERTEXPROCESSING,
307 &presentParameters, &mDevice);
308
309 if (FAILED(result))
310 {
311 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY ||
312 result == D3DERR_NOTAVAILABLE || result == D3DERR_DEVICELOST);
313 return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY)
314 << "CreateDevice2 failed: device lost, not available, or of out of memory";
315 }
316 }
317
318 if (mD3d9Ex)
319 {
320 TRACE_EVENT0("gpu.angle", "mDevice_QueryInterface");
321 result = mDevice->QueryInterface(__uuidof(IDirect3DDevice9Ex), (void **)&mDeviceEx);
322 ASSERT(SUCCEEDED(result));
323 }
324
325 {
326 TRACE_EVENT0("gpu.angle", "ShaderCache initialize");
327 mVertexShaderCache.initialize(mDevice);
328 mPixelShaderCache.initialize(mDevice);
329 }
330
331 D3DDISPLAYMODE currentDisplayMode;
332 mD3d9->GetAdapterDisplayMode(mAdapter, ¤tDisplayMode);
333
334 // Check vertex texture support
335 // Only Direct3D 10 ready devices support all the necessary vertex texture formats.
336 // We test this using D3D9 by checking support for the R16F format.
337 mVertexTextureSupport = mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0) &&
338 SUCCEEDED(mD3d9->CheckDeviceFormat(
339 mAdapter, mDeviceType, currentDisplayMode.Format,
340 D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F));
341
342 ANGLE_TRY(initializeDevice());
343
344 return egl::NoError();
345 }
346
347 // do any one-time device initialization
348 // NOTE: this is also needed after a device lost/reset
349 // to reset the scene status and ensure the default states are reset.
initializeDevice()350 egl::Error Renderer9::initializeDevice()
351 {
352 // Permanent non-default states
353 mDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
354 mDevice->SetRenderState(D3DRS_LASTPIXEL, FALSE);
355
356 if (mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
357 {
358 mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, (DWORD &)mDeviceCaps.MaxPointSize);
359 }
360 else
361 {
362 mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, 0x3F800000); // 1.0f
363 }
364
365 const gl::Caps &rendererCaps = getNativeCaps();
366
367 mCurVertexSamplerStates.resize(rendererCaps.maxVertexTextureImageUnits);
368 mCurPixelSamplerStates.resize(rendererCaps.maxTextureImageUnits);
369
370 mCurVertexTextures.resize(rendererCaps.maxVertexTextureImageUnits);
371 mCurPixelTextures.resize(rendererCaps.maxTextureImageUnits);
372
373 markAllStateDirty();
374
375 mSceneStarted = false;
376
377 ASSERT(!mBlit);
378 mBlit = new Blit9(this);
379 ANGLE_TRY(mBlit->initialize());
380
381 ASSERT(!mVertexDataManager && !mIndexDataManager);
382 mVertexDataManager = new VertexDataManager(this);
383 mIndexDataManager = new IndexDataManager(this);
384
385 if (mVertexDataManager->initialize().isError())
386 {
387 return egl::EglBadAlloc() << "Error initializing VertexDataManager";
388 }
389
390 mTranslatedAttribCache.resize(getNativeCaps().maxVertexAttributes);
391
392 mStateManager.initialize();
393
394 return egl::NoError();
395 }
396
getDefaultPresentParameters()397 D3DPRESENT_PARAMETERS Renderer9::getDefaultPresentParameters()
398 {
399 D3DPRESENT_PARAMETERS presentParameters = {0};
400
401 // The default swap chain is never actually used. Surface will create a new swap chain with the
402 // proper parameters.
403 presentParameters.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
404 presentParameters.BackBufferCount = 1;
405 presentParameters.BackBufferFormat = D3DFMT_UNKNOWN;
406 presentParameters.BackBufferWidth = 1;
407 presentParameters.BackBufferHeight = 1;
408 presentParameters.EnableAutoDepthStencil = FALSE;
409 presentParameters.Flags = 0;
410 presentParameters.hDeviceWindow = mDeviceWindow;
411 presentParameters.MultiSampleQuality = 0;
412 presentParameters.MultiSampleType = D3DMULTISAMPLE_NONE;
413 presentParameters.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
414 presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
415 presentParameters.Windowed = TRUE;
416
417 return presentParameters;
418 }
419
generateConfigs()420 egl::ConfigSet Renderer9::generateConfigs()
421 {
422 static const GLenum colorBufferFormats[] = {
423 GL_BGR5_A1_ANGLEX, GL_BGRA8_EXT, GL_RGB565,
424
425 };
426
427 static const GLenum depthStencilBufferFormats[] = {
428 GL_NONE,
429 GL_DEPTH_COMPONENT32_OES,
430 GL_DEPTH24_STENCIL8_OES,
431 GL_DEPTH_COMPONENT24_OES,
432 GL_DEPTH_COMPONENT16,
433 };
434
435 const gl::Caps &rendererCaps = getNativeCaps();
436 const gl::TextureCapsMap &rendererTextureCaps = getNativeTextureCaps();
437
438 D3DDISPLAYMODE currentDisplayMode;
439 mD3d9->GetAdapterDisplayMode(mAdapter, ¤tDisplayMode);
440
441 // Determine the min and max swap intervals
442 int minSwapInterval = 4;
443 int maxSwapInterval = 0;
444
445 if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
446 {
447 minSwapInterval = std::min(minSwapInterval, 0);
448 maxSwapInterval = std::max(maxSwapInterval, 0);
449 }
450 if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
451 {
452 minSwapInterval = std::min(minSwapInterval, 1);
453 maxSwapInterval = std::max(maxSwapInterval, 1);
454 }
455 if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
456 {
457 minSwapInterval = std::min(minSwapInterval, 2);
458 maxSwapInterval = std::max(maxSwapInterval, 2);
459 }
460 if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE)
461 {
462 minSwapInterval = std::min(minSwapInterval, 3);
463 maxSwapInterval = std::max(maxSwapInterval, 3);
464 }
465 if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)
466 {
467 minSwapInterval = std::min(minSwapInterval, 4);
468 maxSwapInterval = std::max(maxSwapInterval, 4);
469 }
470
471 egl::ConfigSet configs;
472 for (size_t formatIndex = 0; formatIndex < ArraySize(colorBufferFormats); formatIndex++)
473 {
474 GLenum colorBufferInternalFormat = colorBufferFormats[formatIndex];
475 const gl::TextureCaps &colorBufferFormatCaps =
476 rendererTextureCaps.get(colorBufferInternalFormat);
477 if (colorBufferFormatCaps.renderable)
478 {
479 for (size_t depthStencilIndex = 0;
480 depthStencilIndex < ArraySize(depthStencilBufferFormats); depthStencilIndex++)
481 {
482 GLenum depthStencilBufferInternalFormat =
483 depthStencilBufferFormats[depthStencilIndex];
484 const gl::TextureCaps &depthStencilBufferFormatCaps =
485 rendererTextureCaps.get(depthStencilBufferInternalFormat);
486 if (depthStencilBufferFormatCaps.renderable ||
487 depthStencilBufferInternalFormat == GL_NONE)
488 {
489 const gl::InternalFormat &colorBufferFormatInfo =
490 gl::GetSizedInternalFormatInfo(colorBufferInternalFormat);
491 const gl::InternalFormat &depthStencilBufferFormatInfo =
492 gl::GetSizedInternalFormatInfo(depthStencilBufferInternalFormat);
493 const d3d9::TextureFormat &d3d9ColorBufferFormatInfo =
494 d3d9::GetTextureFormatInfo(colorBufferInternalFormat);
495
496 egl::Config config;
497 config.renderTargetFormat = colorBufferInternalFormat;
498 config.depthStencilFormat = depthStencilBufferInternalFormat;
499 config.bufferSize = colorBufferFormatInfo.pixelBytes * 8;
500 config.redSize = colorBufferFormatInfo.redBits;
501 config.greenSize = colorBufferFormatInfo.greenBits;
502 config.blueSize = colorBufferFormatInfo.blueBits;
503 config.luminanceSize = colorBufferFormatInfo.luminanceBits;
504 config.alphaSize = colorBufferFormatInfo.alphaBits;
505 config.alphaMaskSize = 0;
506 config.bindToTextureRGB = (colorBufferFormatInfo.format == GL_RGB);
507 config.bindToTextureRGBA = (colorBufferFormatInfo.format == GL_RGBA ||
508 colorBufferFormatInfo.format == GL_BGRA_EXT);
509 config.colorBufferType = EGL_RGB_BUFFER;
510 // Mark as slow if blits to the back-buffer won't be straight forward
511 config.configCaveat =
512 (currentDisplayMode.Format == d3d9ColorBufferFormatInfo.renderFormat)
513 ? EGL_NONE
514 : EGL_SLOW_CONFIG;
515 config.configID = static_cast<EGLint>(configs.size() + 1);
516 config.conformant = EGL_OPENGL_ES2_BIT;
517 config.depthSize = depthStencilBufferFormatInfo.depthBits;
518 config.level = 0;
519 config.matchNativePixmap = EGL_NONE;
520 config.maxPBufferWidth = rendererCaps.max2DTextureSize;
521 config.maxPBufferHeight = rendererCaps.max2DTextureSize;
522 config.maxPBufferPixels =
523 rendererCaps.max2DTextureSize * rendererCaps.max2DTextureSize;
524 config.maxSwapInterval = maxSwapInterval;
525 config.minSwapInterval = minSwapInterval;
526 config.nativeRenderable = EGL_FALSE;
527 config.nativeVisualID = 0;
528 config.nativeVisualType = EGL_NONE;
529 config.renderableType = EGL_OPENGL_ES2_BIT;
530 config.sampleBuffers = 0; // FIXME: enumerate multi-sampling
531 config.samples = 0;
532 config.stencilSize = depthStencilBufferFormatInfo.stencilBits;
533 config.surfaceType =
534 EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
535 config.transparentType = EGL_NONE;
536 config.transparentRedValue = 0;
537 config.transparentGreenValue = 0;
538 config.transparentBlueValue = 0;
539 config.colorComponentType = gl_egl::GLComponentTypeToEGLColorComponentType(
540 colorBufferFormatInfo.componentType);
541
542 configs.add(config);
543 }
544 }
545 }
546 }
547
548 ASSERT(configs.size() > 0);
549 return configs;
550 }
551
generateDisplayExtensions(egl::DisplayExtensions * outExtensions) const552 void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const
553 {
554 outExtensions->createContextRobustness = true;
555
556 if (getShareHandleSupport())
557 {
558 outExtensions->d3dShareHandleClientBuffer = true;
559 outExtensions->surfaceD3DTexture2DShareHandle = true;
560 }
561 outExtensions->d3dTextureClientBuffer = true;
562
563 outExtensions->querySurfacePointer = true;
564 outExtensions->windowFixedSize = true;
565 outExtensions->postSubBuffer = true;
566 outExtensions->deviceQuery = true;
567
568 outExtensions->image = true;
569 outExtensions->imageBase = true;
570 outExtensions->glTexture2DImage = true;
571 outExtensions->glRenderbufferImage = true;
572
573 outExtensions->flexibleSurfaceCompatibility = true;
574
575 // Contexts are virtualized so textures can be shared globally
576 outExtensions->displayTextureShareGroup = true;
577
578 // D3D9 can be used without an output surface
579 outExtensions->surfacelessContext = true;
580
581 outExtensions->robustResourceInitialization = true;
582 }
583
startScene()584 void Renderer9::startScene()
585 {
586 if (!mSceneStarted)
587 {
588 long result = mDevice->BeginScene();
589 if (SUCCEEDED(result))
590 {
591 // This is defensive checking against the device being
592 // lost at unexpected times.
593 mSceneStarted = true;
594 }
595 }
596 }
597
endScene()598 void Renderer9::endScene()
599 {
600 if (mSceneStarted)
601 {
602 // EndScene can fail if the device was lost, for example due
603 // to a TDR during a draw call.
604 mDevice->EndScene();
605 mSceneStarted = false;
606 }
607 }
608
flush()609 gl::Error Renderer9::flush()
610 {
611 IDirect3DQuery9 *query = nullptr;
612 gl::Error error = allocateEventQuery(&query);
613 if (error.isError())
614 {
615 return error;
616 }
617
618 HRESULT result = query->Issue(D3DISSUE_END);
619 if (FAILED(result))
620 {
621 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
622 return gl::OutOfMemory() << "Failed to issue event query, " << gl::FmtHR(result);
623 }
624
625 // Grab the query data once
626 result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH);
627 freeEventQuery(query);
628 if (FAILED(result))
629 {
630 if (d3d9::isDeviceLostError(result))
631 {
632 notifyDeviceLost();
633 }
634
635 return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
636 }
637
638 return gl::NoError();
639 }
640
finish()641 gl::Error Renderer9::finish()
642 {
643 IDirect3DQuery9 *query = nullptr;
644 gl::Error error = allocateEventQuery(&query);
645 if (error.isError())
646 {
647 return error;
648 }
649
650 HRESULT result = query->Issue(D3DISSUE_END);
651 if (FAILED(result))
652 {
653 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
654 return gl::OutOfMemory() << "Failed to issue event query, " << gl::FmtHR(result);
655 }
656
657 // Grab the query data once
658 result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH);
659 if (FAILED(result))
660 {
661 if (d3d9::isDeviceLostError(result))
662 {
663 notifyDeviceLost();
664 }
665
666 freeEventQuery(query);
667 return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
668 }
669
670 // Loop until the query completes
671 while (result == S_FALSE)
672 {
673 // Keep polling, but allow other threads to do something useful first
674 ScheduleYield();
675
676 result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH);
677
678 // explicitly check for device loss
679 // some drivers seem to return S_FALSE even if the device is lost
680 // instead of D3DERR_DEVICELOST like they should
681 if (result == S_FALSE && testDeviceLost())
682 {
683 result = D3DERR_DEVICELOST;
684 }
685
686 if (FAILED(result))
687 {
688 if (d3d9::isDeviceLostError(result))
689 {
690 notifyDeviceLost();
691 }
692
693 freeEventQuery(query);
694 return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
695 }
696 }
697
698 freeEventQuery(query);
699
700 return gl::NoError();
701 }
702
isValidNativeWindow(EGLNativeWindowType window) const703 bool Renderer9::isValidNativeWindow(EGLNativeWindowType window) const
704 {
705 return NativeWindow9::IsValidNativeWindow(window);
706 }
707
createNativeWindow(EGLNativeWindowType window,const egl::Config *,const egl::AttributeMap &) const708 NativeWindowD3D *Renderer9::createNativeWindow(EGLNativeWindowType window,
709 const egl::Config *,
710 const egl::AttributeMap &) const
711 {
712 return new NativeWindow9(window);
713 }
714
createSwapChain(NativeWindowD3D * nativeWindow,HANDLE shareHandle,IUnknown * d3dTexture,GLenum backBufferFormat,GLenum depthBufferFormat,EGLint orientation,EGLint samples)715 SwapChainD3D *Renderer9::createSwapChain(NativeWindowD3D *nativeWindow,
716 HANDLE shareHandle,
717 IUnknown *d3dTexture,
718 GLenum backBufferFormat,
719 GLenum depthBufferFormat,
720 EGLint orientation,
721 EGLint samples)
722 {
723 return new SwapChain9(this, GetAs<NativeWindow9>(nativeWindow), shareHandle, d3dTexture,
724 backBufferFormat, depthBufferFormat, orientation);
725 }
726
getD3DTextureInfo(const egl::Config * config,IUnknown * d3dTexture,EGLint * width,EGLint * height,GLenum * fboFormat) const727 egl::Error Renderer9::getD3DTextureInfo(const egl::Config *config,
728 IUnknown *d3dTexture,
729 EGLint *width,
730 EGLint *height,
731 GLenum *fboFormat) const
732 {
733 IDirect3DTexture9 *texture = nullptr;
734 if (FAILED(d3dTexture->QueryInterface(&texture)))
735 {
736 return egl::EglBadParameter() << "Client buffer is not a IDirect3DTexture9";
737 }
738
739 IDirect3DDevice9 *textureDevice = nullptr;
740 texture->GetDevice(&textureDevice);
741 if (textureDevice != mDevice)
742 {
743 SafeRelease(texture);
744 return egl::EglBadParameter() << "Texture's device does not match.";
745 }
746 SafeRelease(textureDevice);
747
748 D3DSURFACE_DESC desc;
749 texture->GetLevelDesc(0, &desc);
750 SafeRelease(texture);
751
752 if (width)
753 {
754 *width = static_cast<EGLint>(desc.Width);
755 }
756 if (height)
757 {
758 *height = static_cast<EGLint>(desc.Height);
759 }
760
761 // From table egl.restrictions in EGL_ANGLE_d3d_texture_client_buffer.
762 switch (desc.Format)
763 {
764 case D3DFMT_R8G8B8:
765 case D3DFMT_A8R8G8B8:
766 case D3DFMT_A16B16G16R16F:
767 case D3DFMT_A32B32G32R32F:
768 break;
769
770 default:
771 return egl::EglBadParameter()
772 << "Unknown client buffer texture format: " << desc.Format;
773 }
774
775 if (fboFormat)
776 {
777 const auto &d3dFormatInfo = d3d9::GetD3DFormatInfo(desc.Format);
778 ASSERT(d3dFormatInfo.info().id != angle::Format::ID::NONE);
779 *fboFormat = d3dFormatInfo.info().fboImplementationInternalFormat;
780 }
781
782 return egl::NoError();
783 }
784
validateShareHandle(const egl::Config * config,HANDLE shareHandle,const egl::AttributeMap & attribs) const785 egl::Error Renderer9::validateShareHandle(const egl::Config *config,
786 HANDLE shareHandle,
787 const egl::AttributeMap &attribs) const
788 {
789 if (shareHandle == nullptr)
790 {
791 return egl::EglBadParameter() << "NULL share handle.";
792 }
793
794 EGLint width = attribs.getAsInt(EGL_WIDTH, 0);
795 EGLint height = attribs.getAsInt(EGL_HEIGHT, 0);
796 ASSERT(width != 0 && height != 0);
797
798 const d3d9::TextureFormat &backBufferd3dFormatInfo =
799 d3d9::GetTextureFormatInfo(config->renderTargetFormat);
800
801 IDirect3DTexture9 *texture = nullptr;
802 HRESULT result = mDevice->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET,
803 backBufferd3dFormatInfo.texFormat, D3DPOOL_DEFAULT,
804 &texture, &shareHandle);
805 if (FAILED(result))
806 {
807 return egl::EglBadParameter() << "Failed to open share handle, " << gl::FmtHR(result);
808 }
809
810 DWORD levelCount = texture->GetLevelCount();
811
812 D3DSURFACE_DESC desc;
813 texture->GetLevelDesc(0, &desc);
814 SafeRelease(texture);
815
816 if (levelCount != 1 || desc.Width != static_cast<UINT>(width) ||
817 desc.Height != static_cast<UINT>(height) ||
818 desc.Format != backBufferd3dFormatInfo.texFormat)
819 {
820 return egl::EglBadParameter() << "Invalid texture parameters in share handle texture.";
821 }
822
823 return egl::NoError();
824 }
825
createContext(const gl::ContextState & state)826 ContextImpl *Renderer9::createContext(const gl::ContextState &state)
827 {
828 return new Context9(state, this);
829 }
830
getD3DDevice()831 void *Renderer9::getD3DDevice()
832 {
833 return reinterpret_cast<void *>(mDevice);
834 }
835
allocateEventQuery(IDirect3DQuery9 ** outQuery)836 gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
837 {
838 if (mEventQueryPool.empty())
839 {
840 HRESULT result = mDevice->CreateQuery(D3DQUERYTYPE_EVENT, outQuery);
841 if (FAILED(result))
842 {
843 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
844 return gl::OutOfMemory() << "Failed to allocate event query, " << gl::FmtHR(result);
845 }
846 }
847 else
848 {
849 *outQuery = mEventQueryPool.back();
850 mEventQueryPool.pop_back();
851 }
852
853 return gl::NoError();
854 }
855
freeEventQuery(IDirect3DQuery9 * query)856 void Renderer9::freeEventQuery(IDirect3DQuery9 *query)
857 {
858 if (mEventQueryPool.size() > 1000)
859 {
860 SafeRelease(query);
861 }
862 else
863 {
864 mEventQueryPool.push_back(query);
865 }
866 }
867
createVertexShader(const DWORD * function,size_t length,IDirect3DVertexShader9 ** outShader)868 gl::Error Renderer9::createVertexShader(const DWORD *function,
869 size_t length,
870 IDirect3DVertexShader9 **outShader)
871 {
872 return mVertexShaderCache.create(function, length, outShader);
873 }
874
createPixelShader(const DWORD * function,size_t length,IDirect3DPixelShader9 ** outShader)875 gl::Error Renderer9::createPixelShader(const DWORD *function,
876 size_t length,
877 IDirect3DPixelShader9 **outShader)
878 {
879 return mPixelShaderCache.create(function, length, outShader);
880 }
881
createVertexBuffer(UINT Length,DWORD Usage,IDirect3DVertexBuffer9 ** ppVertexBuffer)882 HRESULT Renderer9::createVertexBuffer(UINT Length,
883 DWORD Usage,
884 IDirect3DVertexBuffer9 **ppVertexBuffer)
885 {
886 D3DPOOL Pool = getBufferPool(Usage);
887 return mDevice->CreateVertexBuffer(Length, Usage, 0, Pool, ppVertexBuffer, nullptr);
888 }
889
createVertexBuffer()890 VertexBuffer *Renderer9::createVertexBuffer()
891 {
892 return new VertexBuffer9(this);
893 }
894
createIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,IDirect3DIndexBuffer9 ** ppIndexBuffer)895 HRESULT Renderer9::createIndexBuffer(UINT Length,
896 DWORD Usage,
897 D3DFORMAT Format,
898 IDirect3DIndexBuffer9 **ppIndexBuffer)
899 {
900 D3DPOOL Pool = getBufferPool(Usage);
901 return mDevice->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, nullptr);
902 }
903
createIndexBuffer()904 IndexBuffer *Renderer9::createIndexBuffer()
905 {
906 return new IndexBuffer9(this);
907 }
908
createStreamProducerD3DTextureNV12(egl::Stream::ConsumerType consumerType,const egl::AttributeMap & attribs)909 StreamProducerImpl *Renderer9::createStreamProducerD3DTextureNV12(
910 egl::Stream::ConsumerType consumerType,
911 const egl::AttributeMap &attribs)
912 {
913 // Streams are not supported under D3D9
914 UNREACHABLE();
915 return nullptr;
916 }
917
supportsFastCopyBufferToTexture(GLenum internalFormat) const918 bool Renderer9::supportsFastCopyBufferToTexture(GLenum internalFormat) const
919 {
920 // Pixel buffer objects are not supported in D3D9, since D3D9 is ES2-only and PBOs are ES3.
921 return false;
922 }
923
fastCopyBufferToTexture(const gl::Context * context,const gl::PixelUnpackState & unpack,unsigned int offset,RenderTargetD3D * destRenderTarget,GLenum destinationFormat,GLenum sourcePixelsType,const gl::Box & destArea)924 gl::Error Renderer9::fastCopyBufferToTexture(const gl::Context *context,
925 const gl::PixelUnpackState &unpack,
926 unsigned int offset,
927 RenderTargetD3D *destRenderTarget,
928 GLenum destinationFormat,
929 GLenum sourcePixelsType,
930 const gl::Box &destArea)
931 {
932 // Pixel buffer objects are not supported in D3D9, since D3D9 is ES2-only and PBOs are ES3.
933 UNREACHABLE();
934 return gl::InternalError();
935 }
936
setSamplerState(const gl::Context * context,gl::SamplerType type,int index,gl::Texture * texture,const gl::SamplerState & samplerState)937 gl::Error Renderer9::setSamplerState(const gl::Context *context,
938 gl::SamplerType type,
939 int index,
940 gl::Texture *texture,
941 const gl::SamplerState &samplerState)
942 {
943 CurSamplerState &appliedSampler = (type == gl::SAMPLER_PIXEL) ? mCurPixelSamplerStates[index]
944 : mCurVertexSamplerStates[index];
945
946 // Make sure to add the level offset for our tiny compressed texture workaround
947 TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
948
949 TextureStorage *storage = nullptr;
950 ANGLE_TRY(textureD3D->getNativeTexture(context, &storage));
951
952 // Storage should exist, texture should be complete
953 ASSERT(storage);
954
955 DWORD baseLevel = texture->getBaseLevel() + storage->getTopLevel();
956
957 if (appliedSampler.forceSet || appliedSampler.baseLevel != baseLevel ||
958 memcmp(&samplerState, &appliedSampler, sizeof(gl::SamplerState)) != 0)
959 {
960 int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
961 int d3dSampler = index + d3dSamplerOffset;
962
963 mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSU,
964 gl_d3d9::ConvertTextureWrap(samplerState.wrapS));
965 mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSV,
966 gl_d3d9::ConvertTextureWrap(samplerState.wrapT));
967
968 mDevice->SetSamplerState(
969 d3dSampler, D3DSAMP_MAGFILTER,
970 gl_d3d9::ConvertMagFilter(samplerState.magFilter, samplerState.maxAnisotropy));
971
972 D3DTEXTUREFILTERTYPE d3dMinFilter, d3dMipFilter;
973 float lodBias;
974 gl_d3d9::ConvertMinFilter(samplerState.minFilter, &d3dMinFilter, &d3dMipFilter, &lodBias,
975 samplerState.maxAnisotropy, baseLevel);
976 mDevice->SetSamplerState(d3dSampler, D3DSAMP_MINFILTER, d3dMinFilter);
977 mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPFILTER, d3dMipFilter);
978 mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXMIPLEVEL, baseLevel);
979 mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPMAPLODBIAS, static_cast<DWORD>(lodBias));
980 if (getNativeExtensions().textureFilterAnisotropic)
981 {
982 DWORD maxAnisotropy =
983 std::min(mDeviceCaps.MaxAnisotropy, static_cast<DWORD>(samplerState.maxAnisotropy));
984 mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXANISOTROPY, maxAnisotropy);
985 }
986 }
987
988 appliedSampler.forceSet = false;
989 appliedSampler.samplerState = samplerState;
990 appliedSampler.baseLevel = baseLevel;
991
992 return gl::NoError();
993 }
994
setTexture(const gl::Context * context,gl::SamplerType type,int index,gl::Texture * texture)995 gl::Error Renderer9::setTexture(const gl::Context *context,
996 gl::SamplerType type,
997 int index,
998 gl::Texture *texture)
999 {
1000 int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
1001 int d3dSampler = index + d3dSamplerOffset;
1002 IDirect3DBaseTexture9 *d3dTexture = nullptr;
1003 bool forceSetTexture = false;
1004
1005 std::vector<uintptr_t> &appliedTextures =
1006 (type == gl::SAMPLER_PIXEL) ? mCurPixelTextures : mCurVertexTextures;
1007
1008 if (texture)
1009 {
1010 TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
1011
1012 TextureStorage *texStorage = nullptr;
1013 ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage));
1014
1015 // Texture should be complete and have a storage
1016 ASSERT(texStorage);
1017
1018 TextureStorage9 *storage9 = GetAs<TextureStorage9>(texStorage);
1019 ANGLE_TRY(storage9->getBaseTexture(context, &d3dTexture));
1020
1021 // If we get NULL back from getBaseTexture here, something went wrong
1022 // in the texture class and we're unexpectedly missing the d3d texture
1023 ASSERT(d3dTexture != nullptr);
1024
1025 forceSetTexture = textureImpl->hasDirtyImages();
1026 textureImpl->resetDirty();
1027 }
1028
1029 if (forceSetTexture || appliedTextures[index] != reinterpret_cast<uintptr_t>(d3dTexture))
1030 {
1031 mDevice->SetTexture(d3dSampler, d3dTexture);
1032 }
1033
1034 appliedTextures[index] = reinterpret_cast<uintptr_t>(d3dTexture);
1035
1036 return gl::NoError();
1037 }
1038
updateState(const gl::Context * context,GLenum drawMode)1039 gl::Error Renderer9::updateState(const gl::Context *context, GLenum drawMode)
1040 {
1041 const auto &glState = context->getGLState();
1042
1043 // Applies the render target surface, depth stencil surface, viewport rectangle and
1044 // scissor rectangle to the renderer
1045 gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
1046 ASSERT(framebuffer && !framebuffer->hasAnyDirtyBit() && framebuffer->cachedComplete());
1047
1048 ANGLE_TRY(applyRenderTarget(context, framebuffer));
1049
1050 // Setting viewport state
1051 setViewport(glState.getViewport(), glState.getNearPlane(), glState.getFarPlane(), drawMode,
1052 glState.getRasterizerState().frontFace, false);
1053
1054 // Setting scissors state
1055 setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
1056
1057 // Setting blend, depth stencil, and rasterizer states
1058 // Since framebuffer->getSamples will return the original samples which may be different with
1059 // the sample counts that we set in render target view, here we use renderTarget->getSamples to
1060 // get the actual samples.
1061 GLsizei samples = 0;
1062 const gl::FramebufferAttachment *firstColorAttachment = framebuffer->getFirstColorbuffer();
1063 if (firstColorAttachment)
1064 {
1065 ASSERT(firstColorAttachment->isAttached());
1066 RenderTarget9 *renderTarget = nullptr;
1067 ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
1068 samples = renderTarget->getSamples();
1069 }
1070 gl::RasterizerState rasterizer = glState.getRasterizerState();
1071 rasterizer.pointDrawMode = (drawMode == GL_POINTS);
1072 rasterizer.multiSample = (samples != 0);
1073
1074 unsigned int mask = GetBlendSampleMask(glState, samples);
1075 ANGLE_TRY(setBlendDepthRasterStates(context, mask));
1076
1077 mStateManager.resetDirtyBits();
1078
1079 return gl::NoError();
1080 }
1081
setScissorRectangle(const gl::Rectangle & scissor,bool enabled)1082 void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
1083 {
1084 mStateManager.setScissorState(scissor, enabled);
1085 }
1086
setBlendDepthRasterStates(const gl::Context * context,GLenum drawMode)1087 gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context, GLenum drawMode)
1088 {
1089 const auto &glState = context->getGLState();
1090 gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer();
1091 ASSERT(!drawFramebuffer->hasAnyDirtyBit());
1092 // Since framebuffer->getSamples will return the original samples which may be different with
1093 // the sample counts that we set in render target view, here we use renderTarget->getSamples to
1094 // get the actual samples.
1095 GLsizei samples = 0;
1096 const gl::FramebufferAttachment *firstColorAttachment = drawFramebuffer->getFirstColorbuffer();
1097 if (firstColorAttachment)
1098 {
1099 ASSERT(firstColorAttachment->isAttached());
1100 RenderTarget9 *renderTarget = nullptr;
1101 ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
1102 samples = renderTarget->getSamples();
1103 }
1104 gl::RasterizerState rasterizer = glState.getRasterizerState();
1105 rasterizer.pointDrawMode = (drawMode == GL_POINTS);
1106 rasterizer.multiSample = (samples != 0);
1107
1108 unsigned int mask = GetBlendSampleMask(glState, samples);
1109 return mStateManager.setBlendDepthRasterStates(glState, mask);
1110 }
1111
setViewport(const gl::Rectangle & viewport,float zNear,float zFar,GLenum drawMode,GLenum frontFace,bool ignoreViewport)1112 void Renderer9::setViewport(const gl::Rectangle &viewport,
1113 float zNear,
1114 float zFar,
1115 GLenum drawMode,
1116 GLenum frontFace,
1117 bool ignoreViewport)
1118 {
1119 mStateManager.setViewportState(viewport, zNear, zFar, drawMode, frontFace, ignoreViewport);
1120 }
1121
applyPrimitiveType(GLenum mode,GLsizei count,bool usesPointSize)1122 bool Renderer9::applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSize)
1123 {
1124 switch (mode)
1125 {
1126 case GL_POINTS:
1127 mPrimitiveType = D3DPT_POINTLIST;
1128 mPrimitiveCount = count;
1129 break;
1130 case GL_LINES:
1131 mPrimitiveType = D3DPT_LINELIST;
1132 mPrimitiveCount = count / 2;
1133 break;
1134 case GL_LINE_LOOP:
1135 mPrimitiveType = D3DPT_LINESTRIP;
1136 mPrimitiveCount =
1137 count - 1; // D3D doesn't support line loops, so we draw the last line separately
1138 break;
1139 case GL_LINE_STRIP:
1140 mPrimitiveType = D3DPT_LINESTRIP;
1141 mPrimitiveCount = count - 1;
1142 break;
1143 case GL_TRIANGLES:
1144 mPrimitiveType = D3DPT_TRIANGLELIST;
1145 mPrimitiveCount = count / 3;
1146 break;
1147 case GL_TRIANGLE_STRIP:
1148 mPrimitiveType = D3DPT_TRIANGLESTRIP;
1149 mPrimitiveCount = count - 2;
1150 break;
1151 case GL_TRIANGLE_FAN:
1152 mPrimitiveType = D3DPT_TRIANGLEFAN;
1153 mPrimitiveCount = count - 2;
1154 break;
1155 default:
1156 UNREACHABLE();
1157 return false;
1158 }
1159
1160 return mPrimitiveCount > 0;
1161 }
1162
getNullColorbuffer(const gl::Context * context,const gl::FramebufferAttachment * depthbuffer,const gl::FramebufferAttachment ** outColorBuffer)1163 gl::Error Renderer9::getNullColorbuffer(const gl::Context *context,
1164 const gl::FramebufferAttachment *depthbuffer,
1165 const gl::FramebufferAttachment **outColorBuffer)
1166 {
1167 ASSERT(depthbuffer);
1168
1169 const gl::Extents &size = depthbuffer->getSize();
1170
1171 // search cached nullcolorbuffers
1172 for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
1173 {
1174 if (mNullColorbufferCache[i].buffer != nullptr &&
1175 mNullColorbufferCache[i].width == size.width &&
1176 mNullColorbufferCache[i].height == size.height)
1177 {
1178 mNullColorbufferCache[i].lruCount = ++mMaxNullColorbufferLRU;
1179 *outColorBuffer = mNullColorbufferCache[i].buffer;
1180 return gl::NoError();
1181 }
1182 }
1183
1184 auto *implFactory = context->getImplementation();
1185
1186 gl::Renderbuffer *nullRenderbuffer = new gl::Renderbuffer(implFactory->createRenderbuffer(), 0);
1187 gl::Error error = nullRenderbuffer->setStorage(context, GL_NONE, size.width, size.height);
1188 if (error.isError())
1189 {
1190 SafeDelete(nullRenderbuffer);
1191 return error;
1192 }
1193
1194 gl::FramebufferAttachment *nullbuffer = new gl::FramebufferAttachment(
1195 context, GL_RENDERBUFFER, GL_NONE, gl::ImageIndex::MakeInvalid(), nullRenderbuffer);
1196
1197 // add nullbuffer to the cache
1198 NullColorbufferCacheEntry *oldest = &mNullColorbufferCache[0];
1199 for (int i = 1; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
1200 {
1201 if (mNullColorbufferCache[i].lruCount < oldest->lruCount)
1202 {
1203 oldest = &mNullColorbufferCache[i];
1204 }
1205 }
1206
1207 delete oldest->buffer;
1208 oldest->buffer = nullbuffer;
1209 oldest->lruCount = ++mMaxNullColorbufferLRU;
1210 oldest->width = size.width;
1211 oldest->height = size.height;
1212
1213 *outColorBuffer = nullbuffer;
1214 return gl::NoError();
1215 }
1216
applyRenderTarget(const gl::Context * context,const gl::FramebufferAttachment * colorAttachment,const gl::FramebufferAttachment * depthStencilAttachment)1217 gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
1218 const gl::FramebufferAttachment *colorAttachment,
1219 const gl::FramebufferAttachment *depthStencilAttachment)
1220 {
1221 const gl::FramebufferAttachment *renderAttachment = colorAttachment;
1222
1223 // if there is no color attachment we must synthesize a NULL colorattachment
1224 // to keep the D3D runtime happy. This should only be possible if depth texturing.
1225 if (renderAttachment == nullptr)
1226 {
1227 ANGLE_TRY(getNullColorbuffer(context, depthStencilAttachment, &renderAttachment));
1228 }
1229 ASSERT(renderAttachment != nullptr);
1230
1231 size_t renderTargetWidth = 0;
1232 size_t renderTargetHeight = 0;
1233 D3DFORMAT renderTargetFormat = D3DFMT_UNKNOWN;
1234
1235 RenderTarget9 *renderTarget = nullptr;
1236 ANGLE_TRY(renderAttachment->getRenderTarget(context, &renderTarget));
1237 ASSERT(renderTarget);
1238
1239 bool renderTargetChanged = false;
1240 unsigned int renderTargetSerial = renderTarget->getSerial();
1241 if (renderTargetSerial != mAppliedRenderTargetSerial)
1242 {
1243 // Apply the render target on the device
1244 IDirect3DSurface9 *renderTargetSurface = renderTarget->getSurface();
1245 ASSERT(renderTargetSurface);
1246
1247 mDevice->SetRenderTarget(0, renderTargetSurface);
1248 SafeRelease(renderTargetSurface);
1249
1250 renderTargetWidth = renderTarget->getWidth();
1251 renderTargetHeight = renderTarget->getHeight();
1252 renderTargetFormat = renderTarget->getD3DFormat();
1253
1254 mAppliedRenderTargetSerial = renderTargetSerial;
1255 renderTargetChanged = true;
1256 }
1257
1258 RenderTarget9 *depthStencilRenderTarget = nullptr;
1259 unsigned int depthStencilSerial = 0;
1260
1261 if (depthStencilAttachment != nullptr)
1262 {
1263 ANGLE_TRY(depthStencilAttachment->getRenderTarget(context, &depthStencilRenderTarget));
1264 ASSERT(depthStencilRenderTarget);
1265
1266 depthStencilSerial = depthStencilRenderTarget->getSerial();
1267 }
1268
1269 if (depthStencilSerial != mAppliedDepthStencilSerial || !mDepthStencilInitialized)
1270 {
1271 unsigned int depthSize = 0;
1272 unsigned int stencilSize = 0;
1273
1274 // Apply the depth stencil on the device
1275 if (depthStencilRenderTarget)
1276 {
1277 IDirect3DSurface9 *depthStencilSurface = depthStencilRenderTarget->getSurface();
1278 ASSERT(depthStencilSurface);
1279
1280 mDevice->SetDepthStencilSurface(depthStencilSurface);
1281 SafeRelease(depthStencilSurface);
1282
1283 depthSize = depthStencilAttachment->getDepthSize();
1284 stencilSize = depthStencilAttachment->getStencilSize();
1285 }
1286 else
1287 {
1288 mDevice->SetDepthStencilSurface(nullptr);
1289 }
1290
1291 mStateManager.updateDepthSizeIfChanged(mDepthStencilInitialized, depthSize);
1292 mStateManager.updateStencilSizeIfChanged(mDepthStencilInitialized, stencilSize);
1293
1294 mAppliedDepthStencilSerial = depthStencilSerial;
1295 mDepthStencilInitialized = true;
1296 }
1297
1298 if (renderTargetChanged || !mRenderTargetDescInitialized)
1299 {
1300 mStateManager.forceSetBlendState();
1301 mStateManager.forceSetScissorState();
1302 mStateManager.setRenderTargetBounds(renderTargetWidth, renderTargetHeight);
1303 mRenderTargetDescInitialized = true;
1304 }
1305
1306 return gl::NoError();
1307 }
1308
applyRenderTarget(const gl::Context * context,const gl::Framebuffer * framebuffer)1309 gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
1310 const gl::Framebuffer *framebuffer)
1311 {
1312 return applyRenderTarget(context, framebuffer->getColorbuffer(0),
1313 framebuffer->getDepthOrStencilbuffer());
1314 }
1315
applyVertexBuffer(const gl::Context * context,GLenum mode,GLint first,GLsizei count,GLsizei instances,TranslatedIndexData *)1316 gl::Error Renderer9::applyVertexBuffer(const gl::Context *context,
1317 GLenum mode,
1318 GLint first,
1319 GLsizei count,
1320 GLsizei instances,
1321 TranslatedIndexData * /*indexInfo*/)
1322 {
1323 const gl::State &state = context->getGLState();
1324 gl::Error error = mVertexDataManager->prepareVertexData(context, first, count,
1325 &mTranslatedAttribCache, instances);
1326 if (error.isError())
1327 {
1328 return error;
1329 }
1330
1331 return mVertexDeclarationCache.applyDeclaration(
1332 mDevice, mTranslatedAttribCache, state.getProgram(), first, instances, &mRepeatDraw);
1333 }
1334
1335 // Applies the indices and element array bindings to the Direct3D 9 device
applyIndexBuffer(const gl::Context * context,const void * indices,GLsizei count,GLenum mode,GLenum type,TranslatedIndexData * indexInfo)1336 gl::Error Renderer9::applyIndexBuffer(const gl::Context *context,
1337 const void *indices,
1338 GLsizei count,
1339 GLenum mode,
1340 GLenum type,
1341 TranslatedIndexData *indexInfo)
1342 {
1343 gl::VertexArray *vao = context->getGLState().getVertexArray();
1344 gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
1345 const auto &lazyIndexRange = context->getParams<gl::HasIndexRange>();
1346
1347 GLenum dstType = GetIndexTranslationDestType(type, lazyIndexRange, false);
1348
1349 ANGLE_TRY(mIndexDataManager->prepareIndexData(context, type, dstType, count, elementArrayBuffer,
1350 indices, indexInfo));
1351
1352 // Directly binding the storage buffer is not supported for d3d9
1353 ASSERT(indexInfo->storage == nullptr);
1354
1355 if (indexInfo->serial != mAppliedIBSerial)
1356 {
1357 IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(indexInfo->indexBuffer);
1358
1359 mDevice->SetIndices(indexBuffer->getBuffer());
1360 mAppliedIBSerial = indexInfo->serial;
1361 }
1362
1363 return gl::NoError();
1364 }
1365
drawArraysImpl(const gl::Context * context,GLenum mode,GLint startVertex,GLsizei count,GLsizei instances)1366 gl::Error Renderer9::drawArraysImpl(const gl::Context *context,
1367 GLenum mode,
1368 GLint startVertex,
1369 GLsizei count,
1370 GLsizei instances)
1371 {
1372 ASSERT(!context->getGLState().isTransformFeedbackActiveUnpaused());
1373
1374 startScene();
1375
1376 if (mode == GL_LINE_LOOP)
1377 {
1378 return drawLineLoop(context, count, GL_NONE, nullptr, 0, nullptr);
1379 }
1380 else if (instances > 0)
1381 {
1382 StaticIndexBufferInterface *countingIB = nullptr;
1383 gl::Error error = getCountingIB(count, &countingIB);
1384 if (error.isError())
1385 {
1386 return error;
1387 }
1388
1389 if (mAppliedIBSerial != countingIB->getSerial())
1390 {
1391 IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(countingIB->getIndexBuffer());
1392
1393 mDevice->SetIndices(indexBuffer->getBuffer());
1394 mAppliedIBSerial = countingIB->getSerial();
1395 }
1396
1397 for (int i = 0; i < mRepeatDraw; i++)
1398 {
1399 mDevice->DrawIndexedPrimitive(mPrimitiveType, 0, 0, count, 0, mPrimitiveCount);
1400 }
1401
1402 return gl::NoError();
1403 }
1404 else // Regular case
1405 {
1406 mDevice->DrawPrimitive(mPrimitiveType, 0, mPrimitiveCount);
1407 return gl::NoError();
1408 }
1409 }
1410
drawElementsImpl(const gl::Context * context,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instances)1411 gl::Error Renderer9::drawElementsImpl(const gl::Context *context,
1412 GLenum mode,
1413 GLsizei count,
1414 GLenum type,
1415 const void *indices,
1416 GLsizei instances)
1417 {
1418 TranslatedIndexData indexInfo;
1419
1420 ANGLE_TRY(applyIndexBuffer(context, indices, count, mode, type, &indexInfo));
1421
1422 const auto &lazyIndexRange = context->getParams<gl::HasIndexRange>();
1423 const gl::IndexRange &indexRange = lazyIndexRange.getIndexRange().value();
1424 size_t vertexCount = indexRange.vertexCount();
1425 ANGLE_TRY(applyVertexBuffer(context, mode, static_cast<GLsizei>(indexRange.start),
1426 static_cast<GLsizei>(vertexCount), instances, &indexInfo));
1427
1428 startScene();
1429
1430 int minIndex = static_cast<int>(indexRange.start);
1431
1432 gl::VertexArray *vao = context->getGLState().getVertexArray();
1433 gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
1434
1435 if (mode == GL_POINTS)
1436 {
1437 return drawIndexedPoints(context, count, type, indices, minIndex, elementArrayBuffer);
1438 }
1439 else if (mode == GL_LINE_LOOP)
1440 {
1441 return drawLineLoop(context, count, type, indices, minIndex, elementArrayBuffer);
1442 }
1443 else
1444 {
1445 for (int i = 0; i < mRepeatDraw; i++)
1446 {
1447 mDevice->DrawIndexedPrimitive(mPrimitiveType, -minIndex, minIndex,
1448 static_cast<UINT>(vertexCount), indexInfo.startIndex,
1449 mPrimitiveCount);
1450 }
1451 return gl::NoError();
1452 }
1453 }
1454
drawLineLoop(const gl::Context * context,GLsizei count,GLenum type,const void * indices,int minIndex,gl::Buffer * elementArrayBuffer)1455 gl::Error Renderer9::drawLineLoop(const gl::Context *context,
1456 GLsizei count,
1457 GLenum type,
1458 const void *indices,
1459 int minIndex,
1460 gl::Buffer *elementArrayBuffer)
1461 {
1462 // Get the raw indices for an indexed draw
1463 if (type != GL_NONE && elementArrayBuffer)
1464 {
1465 BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer);
1466 intptr_t offset = reinterpret_cast<intptr_t>(indices);
1467 const uint8_t *bufferData = nullptr;
1468 gl::Error error = storage->getData(context, &bufferData);
1469 if (error.isError())
1470 {
1471 return error;
1472 }
1473 indices = bufferData + offset;
1474 }
1475
1476 unsigned int startIndex = 0;
1477
1478 if (getNativeExtensions().elementIndexUint)
1479 {
1480 if (!mLineLoopIB)
1481 {
1482 mLineLoopIB = new StreamingIndexBufferInterface(this);
1483 gl::Error error =
1484 mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT);
1485 if (error.isError())
1486 {
1487 SafeDelete(mLineLoopIB);
1488 return error;
1489 }
1490 }
1491
1492 // Checked by Renderer9::applyPrimitiveType
1493 ASSERT(count >= 0);
1494
1495 if (static_cast<unsigned int>(count) + 1 >
1496 (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
1497 {
1498 return gl::OutOfMemory() << "Failed to create a 32-bit looping index buffer for "
1499 "GL_LINE_LOOP, too many indices required.";
1500 }
1501
1502 const unsigned int spaceNeeded =
1503 (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
1504 gl::Error error = mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT);
1505 if (error.isError())
1506 {
1507 return error;
1508 }
1509
1510 void *mappedMemory = nullptr;
1511 unsigned int offset = 0;
1512 error = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
1513 if (error.isError())
1514 {
1515 return error;
1516 }
1517
1518 startIndex = static_cast<unsigned int>(offset) / 4;
1519 unsigned int *data = reinterpret_cast<unsigned int *>(mappedMemory);
1520
1521 switch (type)
1522 {
1523 case GL_NONE: // Non-indexed draw
1524 for (int i = 0; i < count; i++)
1525 {
1526 data[i] = i;
1527 }
1528 data[count] = 0;
1529 break;
1530 case GL_UNSIGNED_BYTE:
1531 for (int i = 0; i < count; i++)
1532 {
1533 data[i] = static_cast<const GLubyte *>(indices)[i];
1534 }
1535 data[count] = static_cast<const GLubyte *>(indices)[0];
1536 break;
1537 case GL_UNSIGNED_SHORT:
1538 for (int i = 0; i < count; i++)
1539 {
1540 data[i] = static_cast<const GLushort *>(indices)[i];
1541 }
1542 data[count] = static_cast<const GLushort *>(indices)[0];
1543 break;
1544 case GL_UNSIGNED_INT:
1545 for (int i = 0; i < count; i++)
1546 {
1547 data[i] = static_cast<const GLuint *>(indices)[i];
1548 }
1549 data[count] = static_cast<const GLuint *>(indices)[0];
1550 break;
1551 default:
1552 UNREACHABLE();
1553 }
1554
1555 error = mLineLoopIB->unmapBuffer();
1556 if (error.isError())
1557 {
1558 return error;
1559 }
1560 }
1561 else
1562 {
1563 if (!mLineLoopIB)
1564 {
1565 mLineLoopIB = new StreamingIndexBufferInterface(this);
1566 gl::Error error =
1567 mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT);
1568 if (error.isError())
1569 {
1570 SafeDelete(mLineLoopIB);
1571 return error;
1572 }
1573 }
1574
1575 // Checked by Renderer9::applyPrimitiveType
1576 ASSERT(count >= 0);
1577
1578 if (static_cast<unsigned int>(count) + 1 >
1579 (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)))
1580 {
1581 return gl::OutOfMemory() << "Failed to create a 16-bit looping index buffer for "
1582 "GL_LINE_LOOP, too many indices required.";
1583 }
1584
1585 const unsigned int spaceNeeded =
1586 (static_cast<unsigned int>(count) + 1) * sizeof(unsigned short);
1587 gl::Error error = mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT);
1588 if (error.isError())
1589 {
1590 return error;
1591 }
1592
1593 void *mappedMemory = nullptr;
1594 unsigned int offset;
1595 error = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
1596 if (error.isError())
1597 {
1598 return error;
1599 }
1600
1601 startIndex = static_cast<unsigned int>(offset) / 2;
1602 unsigned short *data = reinterpret_cast<unsigned short *>(mappedMemory);
1603
1604 switch (type)
1605 {
1606 case GL_NONE: // Non-indexed draw
1607 for (int i = 0; i < count; i++)
1608 {
1609 data[i] = static_cast<unsigned short>(i);
1610 }
1611 data[count] = 0;
1612 break;
1613 case GL_UNSIGNED_BYTE:
1614 for (int i = 0; i < count; i++)
1615 {
1616 data[i] = static_cast<const GLubyte *>(indices)[i];
1617 }
1618 data[count] = static_cast<const GLubyte *>(indices)[0];
1619 break;
1620 case GL_UNSIGNED_SHORT:
1621 for (int i = 0; i < count; i++)
1622 {
1623 data[i] = static_cast<const GLushort *>(indices)[i];
1624 }
1625 data[count] = static_cast<const GLushort *>(indices)[0];
1626 break;
1627 case GL_UNSIGNED_INT:
1628 for (int i = 0; i < count; i++)
1629 {
1630 data[i] = static_cast<unsigned short>(static_cast<const GLuint *>(indices)[i]);
1631 }
1632 data[count] = static_cast<unsigned short>(static_cast<const GLuint *>(indices)[0]);
1633 break;
1634 default:
1635 UNREACHABLE();
1636 }
1637
1638 error = mLineLoopIB->unmapBuffer();
1639 if (error.isError())
1640 {
1641 return error;
1642 }
1643 }
1644
1645 if (mAppliedIBSerial != mLineLoopIB->getSerial())
1646 {
1647 IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(mLineLoopIB->getIndexBuffer());
1648
1649 mDevice->SetIndices(indexBuffer->getBuffer());
1650 mAppliedIBSerial = mLineLoopIB->getSerial();
1651 }
1652
1653 mDevice->DrawIndexedPrimitive(D3DPT_LINESTRIP, -minIndex, minIndex, count, startIndex, count);
1654
1655 return gl::NoError();
1656 }
1657
1658 template <typename T>
drawPoints(IDirect3DDevice9 * device,GLsizei count,const void * indices,int minIndex)1659 static gl::Error drawPoints(IDirect3DDevice9 *device,
1660 GLsizei count,
1661 const void *indices,
1662 int minIndex)
1663 {
1664 for (int i = 0; i < count; i++)
1665 {
1666 unsigned int indexValue =
1667 static_cast<unsigned int>(static_cast<const T *>(indices)[i]) - minIndex;
1668 device->DrawPrimitive(D3DPT_POINTLIST, indexValue, 1);
1669 }
1670
1671 return gl::NoError();
1672 }
1673
drawIndexedPoints(const gl::Context * context,GLsizei count,GLenum type,const void * indices,int minIndex,gl::Buffer * elementArrayBuffer)1674 gl::Error Renderer9::drawIndexedPoints(const gl::Context *context,
1675 GLsizei count,
1676 GLenum type,
1677 const void *indices,
1678 int minIndex,
1679 gl::Buffer *elementArrayBuffer)
1680 {
1681 // Drawing index point lists is unsupported in d3d9, fall back to a regular DrawPrimitive call
1682 // for each individual point. This call is not expected to happen often.
1683
1684 if (elementArrayBuffer)
1685 {
1686 BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer);
1687 intptr_t offset = reinterpret_cast<intptr_t>(indices);
1688
1689 const uint8_t *bufferData = nullptr;
1690 gl::Error error = storage->getData(context, &bufferData);
1691 if (error.isError())
1692 {
1693 return error;
1694 }
1695
1696 indices = bufferData + offset;
1697 }
1698
1699 switch (type)
1700 {
1701 case GL_UNSIGNED_BYTE:
1702 return drawPoints<GLubyte>(mDevice, count, indices, minIndex);
1703 case GL_UNSIGNED_SHORT:
1704 return drawPoints<GLushort>(mDevice, count, indices, minIndex);
1705 case GL_UNSIGNED_INT:
1706 return drawPoints<GLuint>(mDevice, count, indices, minIndex);
1707 default:
1708 UNREACHABLE();
1709 return gl::InternalError();
1710 }
1711 }
1712
getCountingIB(size_t count,StaticIndexBufferInterface ** outIB)1713 gl::Error Renderer9::getCountingIB(size_t count, StaticIndexBufferInterface **outIB)
1714 {
1715 // Update the counting index buffer if it is not large enough or has not been created yet.
1716 if (count <= 65536) // 16-bit indices
1717 {
1718 const unsigned int spaceNeeded = static_cast<unsigned int>(count) * sizeof(unsigned short);
1719
1720 if (!mCountingIB || mCountingIB->getBufferSize() < spaceNeeded)
1721 {
1722 SafeDelete(mCountingIB);
1723 mCountingIB = new StaticIndexBufferInterface(this);
1724 ANGLE_TRY(mCountingIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT));
1725
1726 void *mappedMemory = nullptr;
1727 ANGLE_TRY(mCountingIB->mapBuffer(spaceNeeded, &mappedMemory, nullptr));
1728
1729 unsigned short *data = reinterpret_cast<unsigned short *>(mappedMemory);
1730 for (size_t i = 0; i < count; i++)
1731 {
1732 data[i] = static_cast<unsigned short>(i);
1733 }
1734
1735 ANGLE_TRY(mCountingIB->unmapBuffer());
1736 }
1737 }
1738 else if (getNativeExtensions().elementIndexUint)
1739 {
1740 const unsigned int spaceNeeded = static_cast<unsigned int>(count) * sizeof(unsigned int);
1741
1742 if (!mCountingIB || mCountingIB->getBufferSize() < spaceNeeded)
1743 {
1744 SafeDelete(mCountingIB);
1745 mCountingIB = new StaticIndexBufferInterface(this);
1746 ANGLE_TRY(mCountingIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT));
1747
1748 void *mappedMemory = nullptr;
1749 ANGLE_TRY(mCountingIB->mapBuffer(spaceNeeded, &mappedMemory, nullptr));
1750
1751 unsigned int *data = reinterpret_cast<unsigned int *>(mappedMemory);
1752 for (unsigned int i = 0; i < count; i++)
1753 {
1754 data[i] = i;
1755 }
1756
1757 ANGLE_TRY(mCountingIB->unmapBuffer());
1758 }
1759 }
1760 else
1761 {
1762 return gl::OutOfMemory()
1763 << "Could not create a counting index buffer for glDrawArraysInstanced.";
1764 }
1765
1766 *outIB = mCountingIB;
1767 return gl::NoError();
1768 }
1769
applyShaders(const gl::Context * context,GLenum drawMode)1770 gl::Error Renderer9::applyShaders(const gl::Context *context, GLenum drawMode)
1771 {
1772 const gl::State &state = context->getContextState().getState();
1773 // This method is called single-threaded.
1774 ANGLE_TRY(ensureHLSLCompilerInitialized());
1775
1776 ProgramD3D *programD3D = GetImplAs<ProgramD3D>(state.getProgram());
1777 VertexArray9 *vao = GetImplAs<VertexArray9>(state.getVertexArray());
1778 programD3D->updateCachedInputLayout(vao->getCurrentStateSerial(), state);
1779
1780 ShaderExecutableD3D *vertexExe = nullptr;
1781 ANGLE_TRY(programD3D->getVertexExecutableForCachedInputLayout(&vertexExe, nullptr));
1782
1783 const gl::Framebuffer *drawFramebuffer = state.getDrawFramebuffer();
1784 programD3D->updateCachedOutputLayout(context, drawFramebuffer);
1785
1786 ShaderExecutableD3D *pixelExe = nullptr;
1787 ANGLE_TRY(programD3D->getPixelExecutableForCachedOutputLayout(&pixelExe, nullptr));
1788
1789 IDirect3DVertexShader9 *vertexShader =
1790 (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr);
1791 IDirect3DPixelShader9 *pixelShader =
1792 (pixelExe ? GetAs<ShaderExecutable9>(pixelExe)->getPixelShader() : nullptr);
1793
1794 if (vertexShader != mAppliedVertexShader)
1795 {
1796 mDevice->SetVertexShader(vertexShader);
1797 mAppliedVertexShader = vertexShader;
1798 }
1799
1800 if (pixelShader != mAppliedPixelShader)
1801 {
1802 mDevice->SetPixelShader(pixelShader);
1803 mAppliedPixelShader = pixelShader;
1804 }
1805
1806 // D3D9 has a quirk where creating multiple shaders with the same content
1807 // can return the same shader pointer. Because GL programs store different data
1808 // per-program, checking the program serial guarantees we upload fresh
1809 // uniform data even if our shader pointers are the same.
1810 // https://code.google.com/p/angleproject/issues/detail?id=661
1811 unsigned int programSerial = programD3D->getSerial();
1812 if (programSerial != mAppliedProgramSerial)
1813 {
1814 programD3D->dirtyAllUniforms();
1815 mStateManager.forceSetDXUniformsState();
1816 mAppliedProgramSerial = programSerial;
1817 }
1818
1819 ANGLE_TRY(applyUniforms(programD3D));
1820
1821 // Driver uniforms
1822 mStateManager.setShaderConstants();
1823
1824 return gl::NoError();
1825 }
1826
applyUniforms(ProgramD3D * programD3D)1827 gl::Error Renderer9::applyUniforms(ProgramD3D *programD3D)
1828 {
1829 // Skip updates if we're not dirty. Note that D3D9 cannot have compute.
1830 if (!programD3D->areVertexUniformsDirty() && !programD3D->areFragmentUniformsDirty())
1831 {
1832 return gl::NoError();
1833 }
1834
1835 const auto &uniformArray = programD3D->getD3DUniforms();
1836
1837 for (const D3DUniform *targetUniform : uniformArray)
1838 {
1839 // Built-in uniforms must be skipped.
1840 if (!targetUniform->isReferencedByFragmentShader() &&
1841 !targetUniform->isReferencedByVertexShader())
1842 continue;
1843
1844 const GLfloat *f = reinterpret_cast<const GLfloat *>(targetUniform->firstNonNullData());
1845 const GLint *i = reinterpret_cast<const GLint *>(targetUniform->firstNonNullData());
1846
1847 switch (targetUniform->typeInfo.type)
1848 {
1849 case GL_SAMPLER_2D:
1850 case GL_SAMPLER_CUBE:
1851 case GL_SAMPLER_EXTERNAL_OES:
1852 break;
1853 case GL_BOOL:
1854 case GL_BOOL_VEC2:
1855 case GL_BOOL_VEC3:
1856 case GL_BOOL_VEC4:
1857 applyUniformnbv(targetUniform, i);
1858 break;
1859 case GL_FLOAT:
1860 case GL_FLOAT_VEC2:
1861 case GL_FLOAT_VEC3:
1862 case GL_FLOAT_VEC4:
1863 case GL_FLOAT_MAT2:
1864 case GL_FLOAT_MAT3:
1865 case GL_FLOAT_MAT4:
1866 applyUniformnfv(targetUniform, f);
1867 break;
1868 case GL_INT:
1869 case GL_INT_VEC2:
1870 case GL_INT_VEC3:
1871 case GL_INT_VEC4:
1872 applyUniformniv(targetUniform, i);
1873 break;
1874 default:
1875 UNREACHABLE();
1876 }
1877 }
1878
1879 programD3D->markUniformsClean();
1880 return gl::NoError();
1881 }
1882
applyUniformnfv(const D3DUniform * targetUniform,const GLfloat * v)1883 void Renderer9::applyUniformnfv(const D3DUniform *targetUniform, const GLfloat *v)
1884 {
1885 if (targetUniform->isReferencedByFragmentShader())
1886 {
1887 mDevice->SetPixelShaderConstantF(targetUniform->psRegisterIndex, v,
1888 targetUniform->registerCount);
1889 }
1890
1891 if (targetUniform->isReferencedByVertexShader())
1892 {
1893 mDevice->SetVertexShaderConstantF(targetUniform->vsRegisterIndex, v,
1894 targetUniform->registerCount);
1895 }
1896 }
1897
applyUniformniv(const D3DUniform * targetUniform,const GLint * v)1898 void Renderer9::applyUniformniv(const D3DUniform *targetUniform, const GLint *v)
1899 {
1900 ASSERT(targetUniform->registerCount <= MAX_VERTEX_CONSTANT_VECTORS_D3D9);
1901 GLfloat vector[MAX_VERTEX_CONSTANT_VECTORS_D3D9][4];
1902
1903 for (unsigned int i = 0; i < targetUniform->registerCount; i++)
1904 {
1905 vector[i][0] = (GLfloat)v[4 * i + 0];
1906 vector[i][1] = (GLfloat)v[4 * i + 1];
1907 vector[i][2] = (GLfloat)v[4 * i + 2];
1908 vector[i][3] = (GLfloat)v[4 * i + 3];
1909 }
1910
1911 applyUniformnfv(targetUniform, (GLfloat *)vector);
1912 }
1913
applyUniformnbv(const D3DUniform * targetUniform,const GLint * v)1914 void Renderer9::applyUniformnbv(const D3DUniform *targetUniform, const GLint *v)
1915 {
1916 ASSERT(targetUniform->registerCount <= MAX_VERTEX_CONSTANT_VECTORS_D3D9);
1917 GLfloat vector[MAX_VERTEX_CONSTANT_VECTORS_D3D9][4];
1918
1919 for (unsigned int i = 0; i < targetUniform->registerCount; i++)
1920 {
1921 vector[i][0] = (v[4 * i + 0] == GL_FALSE) ? 0.0f : 1.0f;
1922 vector[i][1] = (v[4 * i + 1] == GL_FALSE) ? 0.0f : 1.0f;
1923 vector[i][2] = (v[4 * i + 2] == GL_FALSE) ? 0.0f : 1.0f;
1924 vector[i][3] = (v[4 * i + 3] == GL_FALSE) ? 0.0f : 1.0f;
1925 }
1926
1927 applyUniformnfv(targetUniform, (GLfloat *)vector);
1928 }
1929
clear(const gl::Context * context,const ClearParameters & clearParams,const gl::FramebufferAttachment * colorBuffer,const gl::FramebufferAttachment * depthStencilBuffer)1930 gl::Error Renderer9::clear(const gl::Context *context,
1931 const ClearParameters &clearParams,
1932 const gl::FramebufferAttachment *colorBuffer,
1933 const gl::FramebufferAttachment *depthStencilBuffer)
1934 {
1935 if (clearParams.colorType != GL_FLOAT)
1936 {
1937 // Clearing buffers with non-float values is not supported by Renderer9 and ES 2.0
1938 UNREACHABLE();
1939 return gl::InternalError();
1940 }
1941
1942 bool clearColor = clearParams.clearColor[0];
1943 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
1944 {
1945 if (clearParams.clearColor[i] != clearColor)
1946 {
1947 // Clearing individual buffers other than buffer zero is not supported by Renderer9 and
1948 // ES 2.0
1949 UNREACHABLE();
1950 return gl::InternalError();
1951 }
1952 }
1953
1954 float depth = gl::clamp01(clearParams.depthValue);
1955 DWORD stencil = clearParams.stencilValue & 0x000000FF;
1956
1957 unsigned int stencilUnmasked = 0x0;
1958 if (clearParams.clearStencil && depthStencilBuffer->getStencilSize() > 0)
1959 {
1960 ASSERT(depthStencilBuffer != nullptr);
1961
1962 RenderTargetD3D *stencilRenderTarget = nullptr;
1963 gl::Error error = depthStencilBuffer->getRenderTarget(context, &stencilRenderTarget);
1964 if (error.isError())
1965 {
1966 return error;
1967 }
1968
1969 RenderTarget9 *stencilRenderTarget9 = GetAs<RenderTarget9>(stencilRenderTarget);
1970 ASSERT(stencilRenderTarget9);
1971
1972 const d3d9::D3DFormat &d3dFormatInfo =
1973 d3d9::GetD3DFormatInfo(stencilRenderTarget9->getD3DFormat());
1974 stencilUnmasked = (0x1 << d3dFormatInfo.stencilBits) - 1;
1975 }
1976
1977 const bool needMaskedStencilClear =
1978 clearParams.clearStencil &&
1979 (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked;
1980
1981 bool needMaskedColorClear = false;
1982 D3DCOLOR color = D3DCOLOR_ARGB(255, 0, 0, 0);
1983 if (clearColor)
1984 {
1985 ASSERT(colorBuffer != nullptr);
1986
1987 RenderTargetD3D *colorRenderTarget = nullptr;
1988 gl::Error error = colorBuffer->getRenderTarget(context, &colorRenderTarget);
1989 if (error.isError())
1990 {
1991 return error;
1992 }
1993
1994 RenderTarget9 *colorRenderTarget9 = GetAs<RenderTarget9>(colorRenderTarget);
1995 ASSERT(colorRenderTarget9);
1996
1997 const gl::InternalFormat &formatInfo = *colorBuffer->getFormat().info;
1998 const d3d9::D3DFormat &d3dFormatInfo =
1999 d3d9::GetD3DFormatInfo(colorRenderTarget9->getD3DFormat());
2000
2001 color =
2002 D3DCOLOR_ARGB(gl::unorm<8>((formatInfo.alphaBits == 0 && d3dFormatInfo.alphaBits > 0)
2003 ? 1.0f
2004 : clearParams.colorF.alpha),
2005 gl::unorm<8>((formatInfo.redBits == 0 && d3dFormatInfo.redBits > 0)
2006 ? 0.0f
2007 : clearParams.colorF.red),
2008 gl::unorm<8>((formatInfo.greenBits == 0 && d3dFormatInfo.greenBits > 0)
2009 ? 0.0f
2010 : clearParams.colorF.green),
2011 gl::unorm<8>((formatInfo.blueBits == 0 && d3dFormatInfo.blueBits > 0)
2012 ? 0.0f
2013 : clearParams.colorF.blue));
2014
2015 if ((formatInfo.redBits > 0 && !clearParams.colorMaskRed) ||
2016 (formatInfo.greenBits > 0 && !clearParams.colorMaskGreen) ||
2017 (formatInfo.blueBits > 0 && !clearParams.colorMaskBlue) ||
2018 (formatInfo.alphaBits > 0 && !clearParams.colorMaskAlpha))
2019 {
2020 needMaskedColorClear = true;
2021 }
2022 }
2023
2024 if (needMaskedColorClear || needMaskedStencilClear)
2025 {
2026 // State which is altered in all paths from this point to the clear call is saved.
2027 // State which is altered in only some paths will be flagged dirty in the case that
2028 // that path is taken.
2029 HRESULT hr;
2030 if (mMaskedClearSavedState == nullptr)
2031 {
2032 hr = mDevice->BeginStateBlock();
2033 ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
2034
2035 mDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
2036 mDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
2037 mDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
2038 mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
2039 mDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
2040 mDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
2041 mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
2042 mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
2043 mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
2044 mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
2045 mDevice->SetPixelShader(nullptr);
2046 mDevice->SetVertexShader(nullptr);
2047 mDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
2048 mDevice->SetStreamSource(0, nullptr, 0, 0);
2049 mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
2050 mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
2051 mDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR);
2052 mDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
2053 mDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR);
2054 mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color);
2055 mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
2056
2057 for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
2058 {
2059 mDevice->SetStreamSourceFreq(i, 1);
2060 }
2061
2062 hr = mDevice->EndStateBlock(&mMaskedClearSavedState);
2063 ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
2064 }
2065
2066 ASSERT(mMaskedClearSavedState != nullptr);
2067
2068 if (mMaskedClearSavedState != nullptr)
2069 {
2070 hr = mMaskedClearSavedState->Capture();
2071 ASSERT(SUCCEEDED(hr));
2072 }
2073
2074 mDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
2075 mDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
2076 mDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
2077 mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
2078 mDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
2079 mDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
2080 mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
2081 mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
2082
2083 if (clearColor)
2084 {
2085 mDevice->SetRenderState(
2086 D3DRS_COLORWRITEENABLE,
2087 gl_d3d9::ConvertColorMask(clearParams.colorMaskRed, clearParams.colorMaskGreen,
2088 clearParams.colorMaskBlue, clearParams.colorMaskAlpha));
2089 }
2090 else
2091 {
2092 mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
2093 }
2094
2095 if (stencilUnmasked != 0x0 && clearParams.clearStencil)
2096 {
2097 mDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
2098 mDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE);
2099 mDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
2100 mDevice->SetRenderState(D3DRS_STENCILREF, stencil);
2101 mDevice->SetRenderState(D3DRS_STENCILWRITEMASK, clearParams.stencilWriteMask);
2102 mDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_REPLACE);
2103 mDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_REPLACE);
2104 mDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
2105 }
2106 else
2107 {
2108 mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
2109 }
2110
2111 mDevice->SetPixelShader(nullptr);
2112 mDevice->SetVertexShader(nullptr);
2113 mDevice->SetFVF(D3DFVF_XYZRHW);
2114 mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
2115 mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
2116 mDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR);
2117 mDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
2118 mDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR);
2119 mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color);
2120 mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
2121
2122 for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
2123 {
2124 mDevice->SetStreamSourceFreq(i, 1);
2125 }
2126
2127 int renderTargetWidth = mStateManager.getRenderTargetWidth();
2128 int renderTargetHeight = mStateManager.getRenderTargetHeight();
2129
2130 float quad[4][4]; // A quadrilateral covering the target, aligned to match the edges
2131 quad[0][0] = -0.5f;
2132 quad[0][1] = renderTargetHeight - 0.5f;
2133 quad[0][2] = 0.0f;
2134 quad[0][3] = 1.0f;
2135
2136 quad[1][0] = renderTargetWidth - 0.5f;
2137 quad[1][1] = renderTargetHeight - 0.5f;
2138 quad[1][2] = 0.0f;
2139 quad[1][3] = 1.0f;
2140
2141 quad[2][0] = -0.5f;
2142 quad[2][1] = -0.5f;
2143 quad[2][2] = 0.0f;
2144 quad[2][3] = 1.0f;
2145
2146 quad[3][0] = renderTargetWidth - 0.5f;
2147 quad[3][1] = -0.5f;
2148 quad[3][2] = 0.0f;
2149 quad[3][3] = 1.0f;
2150
2151 startScene();
2152 mDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float[4]));
2153
2154 if (clearParams.clearDepth)
2155 {
2156 mDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
2157 mDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
2158 mDevice->Clear(0, nullptr, D3DCLEAR_ZBUFFER, color, depth, stencil);
2159 }
2160
2161 if (mMaskedClearSavedState != nullptr)
2162 {
2163 mMaskedClearSavedState->Apply();
2164 }
2165 }
2166 else if (clearColor || clearParams.clearDepth || clearParams.clearStencil)
2167 {
2168 DWORD dxClearFlags = 0;
2169 if (clearColor)
2170 {
2171 dxClearFlags |= D3DCLEAR_TARGET;
2172 }
2173 if (clearParams.clearDepth)
2174 {
2175 dxClearFlags |= D3DCLEAR_ZBUFFER;
2176 }
2177 if (clearParams.clearStencil)
2178 {
2179 dxClearFlags |= D3DCLEAR_STENCIL;
2180 }
2181
2182 mDevice->Clear(0, nullptr, dxClearFlags, color, depth, stencil);
2183 }
2184
2185 return gl::NoError();
2186 }
2187
markAllStateDirty()2188 void Renderer9::markAllStateDirty()
2189 {
2190 mAppliedRenderTargetSerial = 0;
2191 mAppliedDepthStencilSerial = 0;
2192 mDepthStencilInitialized = false;
2193 mRenderTargetDescInitialized = false;
2194
2195 mStateManager.forceSetRasterState();
2196 mStateManager.forceSetDepthStencilState();
2197 mStateManager.forceSetBlendState();
2198 mStateManager.forceSetScissorState();
2199 mStateManager.forceSetViewportState();
2200
2201 ASSERT(mCurVertexSamplerStates.size() == mCurVertexTextures.size());
2202 for (unsigned int i = 0; i < mCurVertexTextures.size(); i++)
2203 {
2204 mCurVertexSamplerStates[i].forceSet = true;
2205 mCurVertexTextures[i] = angle::DirtyPointer;
2206 }
2207
2208 ASSERT(mCurPixelSamplerStates.size() == mCurPixelTextures.size());
2209 for (unsigned int i = 0; i < mCurPixelSamplerStates.size(); i++)
2210 {
2211 mCurPixelSamplerStates[i].forceSet = true;
2212 mCurPixelTextures[i] = angle::DirtyPointer;
2213 }
2214
2215 mAppliedIBSerial = 0;
2216 mAppliedVertexShader = nullptr;
2217 mAppliedPixelShader = nullptr;
2218 mAppliedProgramSerial = 0;
2219 mStateManager.forceSetDXUniformsState();
2220
2221 mVertexDeclarationCache.markStateDirty();
2222 }
2223
releaseDeviceResources()2224 void Renderer9::releaseDeviceResources()
2225 {
2226 for (size_t i = 0; i < mEventQueryPool.size(); i++)
2227 {
2228 SafeRelease(mEventQueryPool[i]);
2229 }
2230 mEventQueryPool.clear();
2231
2232 SafeRelease(mMaskedClearSavedState);
2233
2234 mVertexShaderCache.clear();
2235 mPixelShaderCache.clear();
2236
2237 SafeDelete(mBlit);
2238 SafeDelete(mVertexDataManager);
2239 SafeDelete(mIndexDataManager);
2240 SafeDelete(mLineLoopIB);
2241 SafeDelete(mCountingIB);
2242
2243 for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
2244 {
2245 if (mNullColorbufferCache[i].buffer)
2246 {
2247 mNullColorbufferCache[i].buffer->detach(mDisplay->getProxyContext());
2248 }
2249 SafeDelete(mNullColorbufferCache[i].buffer);
2250 }
2251 }
2252
2253 // set notify to true to broadcast a message to all contexts of the device loss
testDeviceLost()2254 bool Renderer9::testDeviceLost()
2255 {
2256 HRESULT status = getDeviceStatusCode();
2257 return FAILED(status);
2258 }
2259
getDeviceStatusCode()2260 HRESULT Renderer9::getDeviceStatusCode()
2261 {
2262 HRESULT status = D3D_OK;
2263
2264 if (mDeviceEx)
2265 {
2266 status = mDeviceEx->CheckDeviceState(nullptr);
2267 }
2268 else if (mDevice)
2269 {
2270 status = mDevice->TestCooperativeLevel();
2271 }
2272
2273 return status;
2274 }
2275
testDeviceResettable()2276 bool Renderer9::testDeviceResettable()
2277 {
2278 // On D3D9Ex, DEVICELOST represents a hung device that needs to be restarted
2279 // DEVICEREMOVED indicates the device has been stopped and must be recreated
2280 switch (getDeviceStatusCode())
2281 {
2282 case D3DERR_DEVICENOTRESET:
2283 case D3DERR_DEVICEHUNG:
2284 return true;
2285 case D3DERR_DEVICELOST:
2286 return (mDeviceEx != nullptr);
2287 case D3DERR_DEVICEREMOVED:
2288 ASSERT(mDeviceEx != nullptr);
2289 return isRemovedDeviceResettable();
2290 default:
2291 return false;
2292 }
2293 }
2294
resetDevice()2295 bool Renderer9::resetDevice()
2296 {
2297 releaseDeviceResources();
2298
2299 D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
2300
2301 HRESULT result = D3D_OK;
2302 bool lost = testDeviceLost();
2303 bool removedDevice = (getDeviceStatusCode() == D3DERR_DEVICEREMOVED);
2304
2305 // Device Removed is a feature which is only present with D3D9Ex
2306 ASSERT(mDeviceEx != nullptr || !removedDevice);
2307
2308 for (int attempts = 3; lost && attempts > 0; attempts--)
2309 {
2310 if (removedDevice)
2311 {
2312 // Device removed, which may trigger on driver reinstallation,
2313 // may cause a longer wait other reset attempts before the
2314 // system is ready to handle creating a new device.
2315 Sleep(800);
2316 lost = !resetRemovedDevice();
2317 }
2318 else if (mDeviceEx)
2319 {
2320 Sleep(500); // Give the graphics driver some CPU time
2321 result = mDeviceEx->ResetEx(&presentParameters, nullptr);
2322 lost = testDeviceLost();
2323 }
2324 else
2325 {
2326 result = mDevice->TestCooperativeLevel();
2327 while (result == D3DERR_DEVICELOST)
2328 {
2329 Sleep(100); // Give the graphics driver some CPU time
2330 result = mDevice->TestCooperativeLevel();
2331 }
2332
2333 if (result == D3DERR_DEVICENOTRESET)
2334 {
2335 result = mDevice->Reset(&presentParameters);
2336 }
2337 lost = testDeviceLost();
2338 }
2339 }
2340
2341 if (FAILED(result))
2342 {
2343 ERR() << "Reset/ResetEx failed multiple times, " << gl::FmtHR(result);
2344 return false;
2345 }
2346
2347 if (removedDevice && lost)
2348 {
2349 ERR() << "Device lost reset failed multiple times";
2350 return false;
2351 }
2352
2353 // If the device was removed, we already finished re-initialization in resetRemovedDevice
2354 if (!removedDevice)
2355 {
2356 // reset device defaults
2357 if (initializeDevice().isError())
2358 {
2359 return false;
2360 }
2361 }
2362
2363 return true;
2364 }
2365
isRemovedDeviceResettable() const2366 bool Renderer9::isRemovedDeviceResettable() const
2367 {
2368 bool success = false;
2369
2370 #if ANGLE_D3D9EX == ANGLE_ENABLED
2371 IDirect3D9Ex *d3d9Ex = nullptr;
2372 typedef HRESULT(WINAPI * Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex **);
2373 Direct3DCreate9ExFunc Direct3DCreate9ExPtr =
2374 reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex"));
2375
2376 if (Direct3DCreate9ExPtr && SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &d3d9Ex)))
2377 {
2378 D3DCAPS9 deviceCaps;
2379 HRESULT result = d3d9Ex->GetDeviceCaps(mAdapter, mDeviceType, &deviceCaps);
2380 success = SUCCEEDED(result);
2381 }
2382
2383 SafeRelease(d3d9Ex);
2384 #else
2385 ASSERT(UNREACHABLE());
2386 #endif
2387
2388 return success;
2389 }
2390
resetRemovedDevice()2391 bool Renderer9::resetRemovedDevice()
2392 {
2393 // From http://msdn.microsoft.com/en-us/library/windows/desktop/bb172554(v=vs.85).aspx:
2394 // The hardware adapter has been removed. Application must destroy the device, do enumeration of
2395 // adapters and create another Direct3D device. If application continues rendering without
2396 // calling Reset, the rendering calls will succeed. Applies to Direct3D 9Ex only.
2397 release();
2398 return !initialize().isError();
2399 }
2400
getVendorId() const2401 VendorID Renderer9::getVendorId() const
2402 {
2403 return static_cast<VendorID>(mAdapterIdentifier.VendorId);
2404 }
2405
getRendererDescription() const2406 std::string Renderer9::getRendererDescription() const
2407 {
2408 std::ostringstream rendererString;
2409
2410 rendererString << mAdapterIdentifier.Description;
2411 if (getShareHandleSupport())
2412 {
2413 rendererString << " Direct3D9Ex";
2414 }
2415 else
2416 {
2417 rendererString << " Direct3D9";
2418 }
2419
2420 rendererString << " vs_" << D3DSHADER_VERSION_MAJOR(mDeviceCaps.VertexShaderVersion) << "_"
2421 << D3DSHADER_VERSION_MINOR(mDeviceCaps.VertexShaderVersion);
2422 rendererString << " ps_" << D3DSHADER_VERSION_MAJOR(mDeviceCaps.PixelShaderVersion) << "_"
2423 << D3DSHADER_VERSION_MINOR(mDeviceCaps.PixelShaderVersion);
2424
2425 return rendererString.str();
2426 }
2427
getAdapterIdentifier() const2428 DeviceIdentifier Renderer9::getAdapterIdentifier() const
2429 {
2430 DeviceIdentifier deviceIdentifier = {0};
2431 deviceIdentifier.VendorId = static_cast<UINT>(mAdapterIdentifier.VendorId);
2432 deviceIdentifier.DeviceId = static_cast<UINT>(mAdapterIdentifier.DeviceId);
2433 deviceIdentifier.SubSysId = static_cast<UINT>(mAdapterIdentifier.SubSysId);
2434 deviceIdentifier.Revision = static_cast<UINT>(mAdapterIdentifier.Revision);
2435 deviceIdentifier.FeatureLevel = 0;
2436
2437 return deviceIdentifier;
2438 }
2439
getReservedVertexUniformVectors() const2440 unsigned int Renderer9::getReservedVertexUniformVectors() const
2441 {
2442 return d3d9_gl::GetReservedVertexUniformVectors();
2443 }
2444
getReservedFragmentUniformVectors() const2445 unsigned int Renderer9::getReservedFragmentUniformVectors() const
2446 {
2447 return d3d9_gl::GetReservedFragmentUniformVectors();
2448 }
2449
getShareHandleSupport() const2450 bool Renderer9::getShareHandleSupport() const
2451 {
2452 // PIX doesn't seem to support using share handles, so disable them.
2453 return (mD3d9Ex != nullptr) && !gl::DebugAnnotationsActive();
2454 }
2455
getMajorShaderModel() const2456 int Renderer9::getMajorShaderModel() const
2457 {
2458 return D3DSHADER_VERSION_MAJOR(mDeviceCaps.PixelShaderVersion);
2459 }
2460
getMinorShaderModel() const2461 int Renderer9::getMinorShaderModel() const
2462 {
2463 return D3DSHADER_VERSION_MINOR(mDeviceCaps.PixelShaderVersion);
2464 }
2465
getShaderModelSuffix() const2466 std::string Renderer9::getShaderModelSuffix() const
2467 {
2468 return "";
2469 }
2470
getCapsDeclTypes() const2471 DWORD Renderer9::getCapsDeclTypes() const
2472 {
2473 return mDeviceCaps.DeclTypes;
2474 }
2475
getBufferPool(DWORD usage) const2476 D3DPOOL Renderer9::getBufferPool(DWORD usage) const
2477 {
2478 if (mD3d9Ex != nullptr)
2479 {
2480 return D3DPOOL_DEFAULT;
2481 }
2482 else
2483 {
2484 if (!(usage & D3DUSAGE_DYNAMIC))
2485 {
2486 return D3DPOOL_MANAGED;
2487 }
2488 }
2489
2490 return D3DPOOL_DEFAULT;
2491 }
2492
copyImage2D(const gl::Context * context,const gl::Framebuffer * framebuffer,const gl::Rectangle & sourceRect,GLenum destFormat,const gl::Offset & destOffset,TextureStorage * storage,GLint level)2493 gl::Error Renderer9::copyImage2D(const gl::Context *context,
2494 const gl::Framebuffer *framebuffer,
2495 const gl::Rectangle &sourceRect,
2496 GLenum destFormat,
2497 const gl::Offset &destOffset,
2498 TextureStorage *storage,
2499 GLint level)
2500 {
2501 RECT rect;
2502 rect.left = sourceRect.x;
2503 rect.top = sourceRect.y;
2504 rect.right = sourceRect.x + sourceRect.width;
2505 rect.bottom = sourceRect.y + sourceRect.height;
2506
2507 return mBlit->copy2D(context, framebuffer, rect, destFormat, destOffset, storage, level);
2508 }
2509
copyImageCube(const gl::Context * context,const gl::Framebuffer * framebuffer,const gl::Rectangle & sourceRect,GLenum destFormat,const gl::Offset & destOffset,TextureStorage * storage,GLenum target,GLint level)2510 gl::Error Renderer9::copyImageCube(const gl::Context *context,
2511 const gl::Framebuffer *framebuffer,
2512 const gl::Rectangle &sourceRect,
2513 GLenum destFormat,
2514 const gl::Offset &destOffset,
2515 TextureStorage *storage,
2516 GLenum target,
2517 GLint level)
2518 {
2519 RECT rect;
2520 rect.left = sourceRect.x;
2521 rect.top = sourceRect.y;
2522 rect.right = sourceRect.x + sourceRect.width;
2523 rect.bottom = sourceRect.y + sourceRect.height;
2524
2525 return mBlit->copyCube(context, framebuffer, rect, destFormat, destOffset, storage, target,
2526 level);
2527 }
2528
copyImage3D(const gl::Context * context,const gl::Framebuffer * framebuffer,const gl::Rectangle & sourceRect,GLenum destFormat,const gl::Offset & destOffset,TextureStorage * storage,GLint level)2529 gl::Error Renderer9::copyImage3D(const gl::Context *context,
2530 const gl::Framebuffer *framebuffer,
2531 const gl::Rectangle &sourceRect,
2532 GLenum destFormat,
2533 const gl::Offset &destOffset,
2534 TextureStorage *storage,
2535 GLint level)
2536 {
2537 // 3D textures are not available in the D3D9 backend.
2538 UNREACHABLE();
2539 return gl::InternalError();
2540 }
2541
copyImage2DArray(const gl::Context * context,const gl::Framebuffer * framebuffer,const gl::Rectangle & sourceRect,GLenum destFormat,const gl::Offset & destOffset,TextureStorage * storage,GLint level)2542 gl::Error Renderer9::copyImage2DArray(const gl::Context *context,
2543 const gl::Framebuffer *framebuffer,
2544 const gl::Rectangle &sourceRect,
2545 GLenum destFormat,
2546 const gl::Offset &destOffset,
2547 TextureStorage *storage,
2548 GLint level)
2549 {
2550 // 2D array textures are not available in the D3D9 backend.
2551 UNREACHABLE();
2552 return gl::InternalError();
2553 }
2554
copyTexture(const gl::Context * context,const gl::Texture * source,GLint sourceLevel,const gl::Rectangle & sourceRect,GLenum destFormat,const gl::Offset & destOffset,TextureStorage * storage,GLenum destTarget,GLint destLevel,bool unpackFlipY,bool unpackPremultiplyAlpha,bool unpackUnmultiplyAlpha)2555 gl::Error Renderer9::copyTexture(const gl::Context *context,
2556 const gl::Texture *source,
2557 GLint sourceLevel,
2558 const gl::Rectangle &sourceRect,
2559 GLenum destFormat,
2560 const gl::Offset &destOffset,
2561 TextureStorage *storage,
2562 GLenum destTarget,
2563 GLint destLevel,
2564 bool unpackFlipY,
2565 bool unpackPremultiplyAlpha,
2566 bool unpackUnmultiplyAlpha)
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->copyTexture(context, source, sourceLevel, rect, destFormat, destOffset, storage,
2575 destTarget, destLevel, unpackFlipY, unpackPremultiplyAlpha,
2576 unpackUnmultiplyAlpha);
2577 }
2578
copyCompressedTexture(const gl::Context * context,const gl::Texture * source,GLint sourceLevel,TextureStorage * storage,GLint destLevel)2579 gl::Error Renderer9::copyCompressedTexture(const gl::Context *context,
2580 const gl::Texture *source,
2581 GLint sourceLevel,
2582 TextureStorage *storage,
2583 GLint destLevel)
2584 {
2585 UNIMPLEMENTED();
2586 return gl::InternalError();
2587 }
2588
createRenderTarget(int width,int height,GLenum format,GLsizei samples,RenderTargetD3D ** outRT)2589 gl::Error Renderer9::createRenderTarget(int width,
2590 int height,
2591 GLenum format,
2592 GLsizei samples,
2593 RenderTargetD3D **outRT)
2594 {
2595 const d3d9::TextureFormat &d3d9FormatInfo = d3d9::GetTextureFormatInfo(format);
2596
2597 const gl::TextureCaps &textureCaps = getNativeTextureCaps().get(format);
2598 GLuint supportedSamples = textureCaps.getNearestSamples(samples);
2599
2600 IDirect3DTexture9 *texture = nullptr;
2601 IDirect3DSurface9 *renderTarget = nullptr;
2602 if (width > 0 && height > 0)
2603 {
2604 bool requiresInitialization = false;
2605 HRESULT result = D3DERR_INVALIDCALL;
2606
2607 const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(format);
2608 if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0)
2609 {
2610 result = mDevice->CreateDepthStencilSurface(
2611 width, height, d3d9FormatInfo.renderFormat,
2612 gl_d3d9::GetMultisampleType(supportedSamples), 0, FALSE, &renderTarget, nullptr);
2613 }
2614 else
2615 {
2616 requiresInitialization = (d3d9FormatInfo.dataInitializerFunction != nullptr);
2617 if (supportedSamples > 0)
2618 {
2619 result = mDevice->CreateRenderTarget(width, height, d3d9FormatInfo.renderFormat,
2620 gl_d3d9::GetMultisampleType(supportedSamples),
2621 0, FALSE, &renderTarget, nullptr);
2622 }
2623 else
2624 {
2625 result = mDevice->CreateTexture(
2626 width, height, 1, D3DUSAGE_RENDERTARGET, d3d9FormatInfo.texFormat,
2627 getTexturePool(D3DUSAGE_RENDERTARGET), &texture, nullptr);
2628 if (!FAILED(result))
2629 {
2630 result = texture->GetSurfaceLevel(0, &renderTarget);
2631 }
2632 }
2633 }
2634
2635 if (FAILED(result))
2636 {
2637 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
2638 return gl::OutOfMemory() << "Failed to create render target, " << gl::FmtHR(result);
2639 }
2640
2641 if (requiresInitialization)
2642 {
2643 // This format requires that the data be initialized before the render target can be
2644 // used Unfortunately this requires a Get call on the d3d device but it is far better
2645 // than having to mark the render target as lockable and copy data to the gpu.
2646 IDirect3DSurface9 *prevRenderTarget = nullptr;
2647 mDevice->GetRenderTarget(0, &prevRenderTarget);
2648 mDevice->SetRenderTarget(0, renderTarget);
2649 mDevice->Clear(0, nullptr, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 255), 0.0f, 0);
2650 mDevice->SetRenderTarget(0, prevRenderTarget);
2651 }
2652 }
2653
2654 *outRT = new TextureRenderTarget9(texture, 0, renderTarget, format, width, height, 1,
2655 supportedSamples);
2656 return gl::NoError();
2657 }
2658
createRenderTargetCopy(RenderTargetD3D * source,RenderTargetD3D ** outRT)2659 gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT)
2660 {
2661 ASSERT(source != nullptr);
2662
2663 RenderTargetD3D *newRT = nullptr;
2664 gl::Error error = createRenderTarget(source->getWidth(), source->getHeight(),
2665 source->getInternalFormat(), source->getSamples(), &newRT);
2666 if (error.isError())
2667 {
2668 return error;
2669 }
2670
2671 RenderTarget9 *source9 = GetAs<RenderTarget9>(source);
2672 RenderTarget9 *dest9 = GetAs<RenderTarget9>(newRT);
2673
2674 HRESULT result = mDevice->StretchRect(source9->getSurface(), nullptr, dest9->getSurface(),
2675 nullptr, D3DTEXF_NONE);
2676 if (FAILED(result))
2677 {
2678 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
2679 return gl::OutOfMemory() << "Failed to copy render target, " << gl::FmtHR(result);
2680 }
2681
2682 *outRT = newRT;
2683 return gl::NoError();
2684 }
2685
loadExecutable(const uint8_t * function,size_t length,gl::ShaderType type,const std::vector<D3DVarying> & streamOutVaryings,bool separatedOutputBuffers,ShaderExecutableD3D ** outExecutable)2686 gl::Error Renderer9::loadExecutable(const uint8_t *function,
2687 size_t length,
2688 gl::ShaderType type,
2689 const std::vector<D3DVarying> &streamOutVaryings,
2690 bool separatedOutputBuffers,
2691 ShaderExecutableD3D **outExecutable)
2692 {
2693 // Transform feedback is not supported in ES2 or D3D9
2694 ASSERT(streamOutVaryings.empty());
2695
2696 switch (type)
2697 {
2698 case gl::SHADER_VERTEX:
2699 {
2700 IDirect3DVertexShader9 *vshader = nullptr;
2701 gl::Error error = createVertexShader((DWORD *)function, length, &vshader);
2702 if (error.isError())
2703 {
2704 return error;
2705 }
2706 *outExecutable = new ShaderExecutable9(function, length, vshader);
2707 }
2708 break;
2709 case gl::SHADER_FRAGMENT:
2710 {
2711 IDirect3DPixelShader9 *pshader = nullptr;
2712 gl::Error error = createPixelShader((DWORD *)function, length, &pshader);
2713 if (error.isError())
2714 {
2715 return error;
2716 }
2717 *outExecutable = new ShaderExecutable9(function, length, pshader);
2718 }
2719 break;
2720 default:
2721 UNREACHABLE();
2722 return gl::InternalError();
2723 }
2724
2725 return gl::NoError();
2726 }
2727
compileToExecutable(gl::InfoLog & infoLog,const std::string & shaderHLSL,gl::ShaderType type,const std::vector<D3DVarying> & streamOutVaryings,bool separatedOutputBuffers,const angle::CompilerWorkaroundsD3D & workarounds,ShaderExecutableD3D ** outExectuable)2728 gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
2729 const std::string &shaderHLSL,
2730 gl::ShaderType type,
2731 const std::vector<D3DVarying> &streamOutVaryings,
2732 bool separatedOutputBuffers,
2733 const angle::CompilerWorkaroundsD3D &workarounds,
2734 ShaderExecutableD3D **outExectuable)
2735 {
2736 // Transform feedback is not supported in ES2 or D3D9
2737 ASSERT(streamOutVaryings.empty());
2738
2739 std::stringstream profileStream;
2740
2741 switch (type)
2742 {
2743 case gl::SHADER_VERTEX:
2744 profileStream << "vs";
2745 break;
2746 case gl::SHADER_FRAGMENT:
2747 profileStream << "ps";
2748 break;
2749 default:
2750 UNREACHABLE();
2751 return gl::InternalError();
2752 }
2753
2754 profileStream << "_" << ((getMajorShaderModel() >= 3) ? 3 : 2);
2755 profileStream << "_"
2756 << "0";
2757
2758 std::string profile = profileStream.str();
2759
2760 UINT flags = ANGLE_COMPILE_OPTIMIZATION_LEVEL;
2761
2762 if (workarounds.skipOptimization)
2763 {
2764 flags = D3DCOMPILE_SKIP_OPTIMIZATION;
2765 }
2766 else if (workarounds.useMaxOptimization)
2767 {
2768 flags = D3DCOMPILE_OPTIMIZATION_LEVEL3;
2769 }
2770
2771 if (gl::DebugAnnotationsActive())
2772 {
2773 #ifndef NDEBUG
2774 flags = D3DCOMPILE_SKIP_OPTIMIZATION;
2775 #endif
2776
2777 flags |= D3DCOMPILE_DEBUG;
2778 }
2779
2780 // Sometimes D3DCompile will fail with the default compilation flags for complicated shaders
2781 // when it would otherwise pass with alternative options. Try the default flags first and if
2782 // compilation fails, try some alternatives.
2783 std::vector<CompileConfig> configs;
2784 configs.push_back(CompileConfig(flags, "default"));
2785 configs.push_back(CompileConfig(flags | D3DCOMPILE_AVOID_FLOW_CONTROL, "avoid flow control"));
2786 configs.push_back(CompileConfig(flags | D3DCOMPILE_PREFER_FLOW_CONTROL, "prefer flow control"));
2787
2788 ID3DBlob *binary = nullptr;
2789 std::string debugInfo;
2790 gl::Error error = mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, nullptr,
2791 &binary, &debugInfo);
2792 if (error.isError())
2793 {
2794 return error;
2795 }
2796
2797 // It's possible that binary is NULL if the compiler failed in all configurations. Set the
2798 // executable to NULL and return GL_NO_ERROR to signify that there was a link error but the
2799 // internal state is still OK.
2800 if (!binary)
2801 {
2802 *outExectuable = nullptr;
2803 return gl::NoError();
2804 }
2805
2806 error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
2807 binary->GetBufferSize(), type, streamOutVaryings, separatedOutputBuffers,
2808 outExectuable);
2809
2810 SafeRelease(binary);
2811 if (error.isError())
2812 {
2813 return error;
2814 }
2815
2816 if (!debugInfo.empty())
2817 {
2818 (*outExectuable)->appendDebugInfo(debugInfo);
2819 }
2820
2821 return gl::NoError();
2822 }
2823
ensureHLSLCompilerInitialized()2824 gl::Error Renderer9::ensureHLSLCompilerInitialized()
2825 {
2826 return mCompiler.ensureInitialized();
2827 }
2828
createUniformStorage(size_t storageSize)2829 UniformStorageD3D *Renderer9::createUniformStorage(size_t storageSize)
2830 {
2831 return new UniformStorageD3D(storageSize);
2832 }
2833
boxFilter(IDirect3DSurface9 * source,IDirect3DSurface9 * dest)2834 gl::Error Renderer9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
2835 {
2836 return mBlit->boxFilter(source, dest);
2837 }
2838
getTexturePool(DWORD usage) const2839 D3DPOOL Renderer9::getTexturePool(DWORD usage) const
2840 {
2841 if (mD3d9Ex != nullptr)
2842 {
2843 return D3DPOOL_DEFAULT;
2844 }
2845 else
2846 {
2847 if (!(usage & (D3DUSAGE_DEPTHSTENCIL | D3DUSAGE_RENDERTARGET)))
2848 {
2849 return D3DPOOL_MANAGED;
2850 }
2851 }
2852
2853 return D3DPOOL_DEFAULT;
2854 }
2855
copyToRenderTarget(IDirect3DSurface9 * dest,IDirect3DSurface9 * source,bool fromManaged)2856 gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest,
2857 IDirect3DSurface9 *source,
2858 bool fromManaged)
2859 {
2860 ASSERT(source && dest);
2861
2862 HRESULT result = D3DERR_OUTOFVIDEOMEMORY;
2863
2864 if (fromManaged)
2865 {
2866 D3DSURFACE_DESC desc;
2867 source->GetDesc(&desc);
2868
2869 IDirect3DSurface9 *surf = 0;
2870 result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format,
2871 D3DPOOL_SYSTEMMEM, &surf, nullptr);
2872
2873 if (SUCCEEDED(result))
2874 {
2875 ANGLE_TRY(Image9::copyLockableSurfaces(surf, source));
2876 result = mDevice->UpdateSurface(surf, nullptr, dest, nullptr);
2877 SafeRelease(surf);
2878 }
2879 }
2880 else
2881 {
2882 endScene();
2883 result = mDevice->StretchRect(source, nullptr, dest, nullptr, D3DTEXF_NONE);
2884 }
2885
2886 if (FAILED(result))
2887 {
2888 ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
2889 return gl::OutOfMemory() << "Failed to blit internal texture, " << gl::FmtHR(result);
2890 }
2891
2892 return gl::NoError();
2893 }
2894
getRendererClass() const2895 RendererClass Renderer9::getRendererClass() const
2896 {
2897 return RENDERER_D3D9;
2898 }
2899
createImage()2900 ImageD3D *Renderer9::createImage()
2901 {
2902 return new Image9(this);
2903 }
2904
generateMipmap(const gl::Context * context,ImageD3D * dest,ImageD3D * src)2905 gl::Error Renderer9::generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *src)
2906 {
2907 Image9 *src9 = GetAs<Image9>(src);
2908 Image9 *dst9 = GetAs<Image9>(dest);
2909 return Image9::generateMipmap(dst9, src9);
2910 }
2911
generateMipmapUsingD3D(const gl::Context * context,TextureStorage * storage,const gl::TextureState & textureState)2912 gl::Error Renderer9::generateMipmapUsingD3D(const gl::Context *context,
2913 TextureStorage *storage,
2914 const gl::TextureState &textureState)
2915 {
2916 UNREACHABLE();
2917 return gl::NoError();
2918 }
2919
copyImage(const gl::Context * context,ImageD3D * dest,ImageD3D * source,const gl::Rectangle & sourceRect,const gl::Offset & destOffset,bool unpackFlipY,bool unpackPremultiplyAlpha,bool unpackUnmultiplyAlpha)2920 gl::Error Renderer9::copyImage(const gl::Context *context,
2921 ImageD3D *dest,
2922 ImageD3D *source,
2923 const gl::Rectangle &sourceRect,
2924 const gl::Offset &destOffset,
2925 bool unpackFlipY,
2926 bool unpackPremultiplyAlpha,
2927 bool unpackUnmultiplyAlpha)
2928 {
2929 Image9 *dest9 = GetAs<Image9>(dest);
2930 Image9 *src9 = GetAs<Image9>(source);
2931 return Image9::CopyImage(context, dest9, src9, sourceRect, destOffset, unpackFlipY,
2932 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
2933 }
2934
createTextureStorage2D(SwapChainD3D * swapChain)2935 TextureStorage *Renderer9::createTextureStorage2D(SwapChainD3D *swapChain)
2936 {
2937 SwapChain9 *swapChain9 = GetAs<SwapChain9>(swapChain);
2938 return new TextureStorage9_2D(this, swapChain9);
2939 }
2940
createTextureStorageEGLImage(EGLImageD3D * eglImage,RenderTargetD3D * renderTargetD3D)2941 TextureStorage *Renderer9::createTextureStorageEGLImage(EGLImageD3D *eglImage,
2942 RenderTargetD3D *renderTargetD3D)
2943 {
2944 return new TextureStorage9_EGLImage(this, eglImage, GetAs<RenderTarget9>(renderTargetD3D));
2945 }
2946
createTextureStorageExternal(egl::Stream * stream,const egl::Stream::GLTextureDescription & desc)2947 TextureStorage *Renderer9::createTextureStorageExternal(
2948 egl::Stream *stream,
2949 const egl::Stream::GLTextureDescription &desc)
2950 {
2951 UNIMPLEMENTED();
2952 return nullptr;
2953 }
2954
createTextureStorage2D(GLenum internalformat,bool renderTarget,GLsizei width,GLsizei height,int levels,bool hintLevelZeroOnly)2955 TextureStorage *Renderer9::createTextureStorage2D(GLenum internalformat,
2956 bool renderTarget,
2957 GLsizei width,
2958 GLsizei height,
2959 int levels,
2960 bool hintLevelZeroOnly)
2961 {
2962 return new TextureStorage9_2D(this, internalformat, renderTarget, width, height, levels);
2963 }
2964
createTextureStorageCube(GLenum internalformat,bool renderTarget,int size,int levels,bool hintLevelZeroOnly)2965 TextureStorage *Renderer9::createTextureStorageCube(GLenum internalformat,
2966 bool renderTarget,
2967 int size,
2968 int levels,
2969 bool hintLevelZeroOnly)
2970 {
2971 return new TextureStorage9_Cube(this, internalformat, renderTarget, size, levels,
2972 hintLevelZeroOnly);
2973 }
2974
createTextureStorage3D(GLenum internalformat,bool renderTarget,GLsizei width,GLsizei height,GLsizei depth,int levels)2975 TextureStorage *Renderer9::createTextureStorage3D(GLenum internalformat,
2976 bool renderTarget,
2977 GLsizei width,
2978 GLsizei height,
2979 GLsizei depth,
2980 int levels)
2981 {
2982 // 3D textures are not supported by the D3D9 backend.
2983 UNREACHABLE();
2984
2985 return nullptr;
2986 }
2987
createTextureStorage2DArray(GLenum internalformat,bool renderTarget,GLsizei width,GLsizei height,GLsizei depth,int levels)2988 TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat,
2989 bool renderTarget,
2990 GLsizei width,
2991 GLsizei height,
2992 GLsizei depth,
2993 int levels)
2994 {
2995 // 2D array textures are not supported by the D3D9 backend.
2996 UNREACHABLE();
2997
2998 return nullptr;
2999 }
3000
createTextureStorage2DMultisample(GLenum internalformat,GLsizei width,GLsizei height,int levels,int samples,bool fixedSampleLocations)3001 TextureStorage *Renderer9::createTextureStorage2DMultisample(GLenum internalformat,
3002 GLsizei width,
3003 GLsizei height,
3004 int levels,
3005 int samples,
3006 bool fixedSampleLocations)
3007 {
3008 // 2D multisampled textures are not supported by the D3D9 backend.
3009 UNREACHABLE();
3010
3011 return NULL;
3012 }
3013
getLUID(LUID * adapterLuid) const3014 bool Renderer9::getLUID(LUID *adapterLuid) const
3015 {
3016 adapterLuid->HighPart = 0;
3017 adapterLuid->LowPart = 0;
3018
3019 if (mD3d9Ex)
3020 {
3021 mD3d9Ex->GetAdapterLUID(mAdapter, adapterLuid);
3022 return true;
3023 }
3024
3025 return false;
3026 }
3027
getVertexConversionType(gl::VertexFormatType vertexFormatType) const3028 VertexConversionType Renderer9::getVertexConversionType(gl::VertexFormatType vertexFormatType) const
3029 {
3030 return d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatType).conversionType;
3031 }
3032
getVertexComponentType(gl::VertexFormatType vertexFormatType) const3033 GLenum Renderer9::getVertexComponentType(gl::VertexFormatType vertexFormatType) const
3034 {
3035 return d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatType).componentType;
3036 }
3037
getVertexSpaceRequired(const gl::VertexAttribute & attrib,const gl::VertexBinding & binding,GLsizei count,GLsizei instances) const3038 gl::ErrorOrResult<unsigned int> Renderer9::getVertexSpaceRequired(const gl::VertexAttribute &attrib,
3039 const gl::VertexBinding &binding,
3040 GLsizei count,
3041 GLsizei instances) const
3042 {
3043 if (!attrib.enabled)
3044 {
3045 return 16u;
3046 }
3047
3048 gl::VertexFormatType vertexFormatType = gl::GetVertexFormatType(attrib, GL_FLOAT);
3049 const d3d9::VertexFormat &d3d9VertexInfo =
3050 d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatType);
3051
3052 unsigned int elementCount = 0;
3053 const unsigned int divisor = binding.getDivisor();
3054 if (instances == 0 || divisor == 0)
3055 {
3056 elementCount = static_cast<unsigned int>(count);
3057 }
3058 else
3059 {
3060 // Round up to divisor, if possible
3061 elementCount = UnsignedCeilDivide(static_cast<unsigned int>(instances), divisor);
3062 }
3063
3064 if (d3d9VertexInfo.outputElementSize > std::numeric_limits<unsigned int>::max() / elementCount)
3065 {
3066 return gl::OutOfMemory() << "New vertex buffer size would result in an overflow.";
3067 }
3068
3069 return static_cast<unsigned int>(d3d9VertexInfo.outputElementSize) * elementCount;
3070 }
3071
generateCaps(gl::Caps * outCaps,gl::TextureCapsMap * outTextureCaps,gl::Extensions * outExtensions,gl::Limitations * outLimitations) const3072 void Renderer9::generateCaps(gl::Caps *outCaps,
3073 gl::TextureCapsMap *outTextureCaps,
3074 gl::Extensions *outExtensions,
3075 gl::Limitations *outLimitations) const
3076 {
3077 d3d9_gl::GenerateCaps(mD3d9, mDevice, mDeviceType, mAdapter, outCaps, outTextureCaps,
3078 outExtensions, outLimitations);
3079 }
3080
generateWorkarounds() const3081 angle::WorkaroundsD3D Renderer9::generateWorkarounds() const
3082 {
3083 return d3d9::GenerateWorkarounds();
3084 }
3085
getEGLDevice(DeviceImpl ** device)3086 egl::Error Renderer9::getEGLDevice(DeviceImpl **device)
3087 {
3088 if (mEGLDevice == nullptr)
3089 {
3090 ASSERT(mDevice != nullptr);
3091 mEGLDevice = new DeviceD3D();
3092 egl::Error error = mEGLDevice->initialize(reinterpret_cast<void *>(mDevice),
3093 EGL_D3D9_DEVICE_ANGLE, EGL_FALSE);
3094
3095 if (error.isError())
3096 {
3097 SafeDelete(mEGLDevice);
3098 return error;
3099 }
3100 }
3101
3102 *device = static_cast<DeviceImpl *>(mEGLDevice);
3103 return egl::NoError();
3104 }
3105
CurSamplerState()3106 Renderer9::CurSamplerState::CurSamplerState()
3107 : forceSet(true), baseLevel(std::numeric_limits<size_t>::max()), samplerState()
3108 {
3109 }
3110
genericDrawElements(const gl::Context * context,GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instances)3111 gl::Error Renderer9::genericDrawElements(const gl::Context *context,
3112 GLenum mode,
3113 GLsizei count,
3114 GLenum type,
3115 const void *indices,
3116 GLsizei instances)
3117 {
3118 const auto &data = context->getContextState();
3119 gl::Program *program = context->getGLState().getProgram();
3120 ASSERT(program != nullptr);
3121 ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
3122 bool usesPointSize = programD3D->usesPointSize();
3123
3124 programD3D->updateSamplerMapping();
3125
3126 if (!applyPrimitiveType(mode, count, usesPointSize))
3127 {
3128 return gl::NoError();
3129 }
3130
3131 ANGLE_TRY(updateState(context, mode));
3132 ANGLE_TRY(applyTextures(context));
3133 ANGLE_TRY(applyShaders(context, mode));
3134
3135 if (!skipDraw(data.getState(), mode))
3136 {
3137 ANGLE_TRY(drawElementsImpl(context, mode, count, type, indices, instances));
3138 }
3139
3140 return gl::NoError();
3141 }
3142
genericDrawArrays(const gl::Context * context,GLenum mode,GLint first,GLsizei count,GLsizei instances)3143 gl::Error Renderer9::genericDrawArrays(const gl::Context *context,
3144 GLenum mode,
3145 GLint first,
3146 GLsizei count,
3147 GLsizei instances)
3148 {
3149 gl::Program *program = context->getGLState().getProgram();
3150 ASSERT(program != nullptr);
3151 ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
3152 bool usesPointSize = programD3D->usesPointSize();
3153
3154 programD3D->updateSamplerMapping();
3155
3156 if (!applyPrimitiveType(mode, count, usesPointSize))
3157 {
3158 return gl::NoError();
3159 }
3160
3161 ANGLE_TRY(updateState(context, mode));
3162 ANGLE_TRY(applyVertexBuffer(context, mode, first, count, instances, nullptr));
3163 ANGLE_TRY(applyTextures(context));
3164 ANGLE_TRY(applyShaders(context, mode));
3165
3166 if (!skipDraw(context->getGLState(), mode))
3167 {
3168 ANGLE_TRY(drawArraysImpl(context, mode, first, count, instances));
3169 }
3170
3171 return gl::NoError();
3172 }
3173
createDefaultFramebuffer(const gl::FramebufferState & state)3174 FramebufferImpl *Renderer9::createDefaultFramebuffer(const gl::FramebufferState &state)
3175 {
3176 return new Framebuffer9(state, this);
3177 }
3178
getMaxSupportedESVersion() const3179 gl::Version Renderer9::getMaxSupportedESVersion() const
3180 {
3181 return gl::Version(2, 0);
3182 }
3183
clearRenderTarget(RenderTargetD3D * renderTarget,const gl::ColorF & clearColorValue,const float clearDepthValue,const unsigned int clearStencilValue)3184 gl::Error Renderer9::clearRenderTarget(RenderTargetD3D *renderTarget,
3185 const gl::ColorF &clearColorValue,
3186 const float clearDepthValue,
3187 const unsigned int clearStencilValue)
3188 {
3189 D3DCOLOR color =
3190 D3DCOLOR_ARGB(gl::unorm<8>(clearColorValue.alpha), gl::unorm<8>(clearColorValue.red),
3191 gl::unorm<8>(clearColorValue.green), gl::unorm<8>(clearColorValue.blue));
3192 float depth = clearDepthValue;
3193 DWORD stencil = clearStencilValue & 0x000000FF;
3194
3195 unsigned int renderTargetSerial = renderTarget->getSerial();
3196 RenderTarget9 *renderTarget9 = GetAs<RenderTarget9>(renderTarget);
3197 IDirect3DSurface9 *renderTargetSurface = renderTarget9->getSurface();
3198 ASSERT(renderTargetSurface);
3199
3200 DWORD dxClearFlags = 0;
3201
3202 const gl::InternalFormat &internalFormatInfo =
3203 gl::GetSizedInternalFormatInfo(renderTarget->getInternalFormat());
3204 if (internalFormatInfo.depthBits > 0 || internalFormatInfo.stencilBits > 0)
3205 {
3206 dxClearFlags = D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL;
3207 if (mAppliedDepthStencilSerial != renderTargetSerial)
3208 {
3209 mDevice->SetDepthStencilSurface(renderTargetSurface);
3210 }
3211 }
3212 else
3213 {
3214 dxClearFlags = D3DCLEAR_TARGET;
3215 if (mAppliedRenderTargetSerial != renderTargetSerial)
3216 {
3217 mDevice->SetRenderTarget(0, renderTargetSurface);
3218 }
3219 }
3220 SafeRelease(renderTargetSurface);
3221
3222 D3DVIEWPORT9 viewport;
3223 viewport.X = 0;
3224 viewport.Y = 0;
3225 viewport.Width = renderTarget->getWidth();
3226 viewport.Height = renderTarget->getHeight();
3227 mDevice->SetViewport(&viewport);
3228
3229 mDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
3230
3231 mDevice->Clear(0, nullptr, dxClearFlags, color, depth, stencil);
3232
3233 markAllStateDirty();
3234
3235 return gl::NoError();
3236 }
3237
canSelectViewInVertexShader() const3238 bool Renderer9::canSelectViewInVertexShader() const
3239 {
3240 return false;
3241 }
3242
3243 // For each Direct3D sampler of either the pixel or vertex stage,
3244 // looks up the corresponding OpenGL texture image unit and texture type,
3245 // and sets the texture and its addressing/filtering state (or NULL when inactive).
3246 // Sampler mapping needs to be up-to-date on the program object before this is called.
applyTextures(const gl::Context * context,gl::SamplerType shaderType)3247 gl::Error Renderer9::applyTextures(const gl::Context *context, gl::SamplerType shaderType)
3248 {
3249 const auto &glState = context->getGLState();
3250 const auto &caps = context->getCaps();
3251 ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
3252
3253 ASSERT(!programD3D->isSamplerMappingDirty());
3254
3255 // TODO(jmadill): Use the Program's sampler bindings.
3256 const auto &completeTextures = glState.getCompleteTextureCache();
3257
3258 unsigned int samplerRange = programD3D->getUsedSamplerRange(shaderType);
3259 for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
3260 {
3261 GLint textureUnit = programD3D->getSamplerMapping(shaderType, samplerIndex, caps);
3262 ASSERT(textureUnit != -1);
3263 gl::Texture *texture = completeTextures[textureUnit];
3264
3265 // A nullptr texture indicates incomplete.
3266 if (texture)
3267 {
3268 gl::Sampler *samplerObject = glState.getSampler(textureUnit);
3269
3270 const gl::SamplerState &samplerState =
3271 samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState();
3272
3273 ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, texture, samplerState));
3274 ANGLE_TRY(setTexture(context, shaderType, samplerIndex, texture));
3275 }
3276 else
3277 {
3278 GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex);
3279
3280 // Texture is not sampler complete or it is in use by the framebuffer. Bind the
3281 // incomplete texture.
3282 gl::Texture *incompleteTexture = nullptr;
3283 ANGLE_TRY(getIncompleteTexture(context, textureType, &incompleteTexture));
3284 ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture,
3285 incompleteTexture->getSamplerState()));
3286 ANGLE_TRY(setTexture(context, shaderType, samplerIndex, incompleteTexture));
3287 }
3288 }
3289
3290 // Set all the remaining textures to NULL
3291 size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? caps.maxTextureImageUnits
3292 : caps.maxVertexTextureImageUnits;
3293
3294 // TODO(jmadill): faster way?
3295 for (size_t samplerIndex = samplerRange; samplerIndex < samplerCount; samplerIndex++)
3296 {
3297 ANGLE_TRY(setTexture(context, shaderType, static_cast<int>(samplerIndex), nullptr));
3298 }
3299
3300 return gl::NoError();
3301 }
3302
applyTextures(const gl::Context * context)3303 gl::Error Renderer9::applyTextures(const gl::Context *context)
3304 {
3305 ANGLE_TRY(applyTextures(context, gl::SAMPLER_VERTEX));
3306 ANGLE_TRY(applyTextures(context, gl::SAMPLER_PIXEL));
3307 return gl::NoError();
3308 }
3309
3310 } // namespace rx
3311