src/third_party/angle/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp

   1 #include "precompiled.h"
   2 //
   3 // Copyright (c) 2012-2014 The ANGLE Project Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style license that can be
   5 // found in the LICENSE file.
   6 //
   7
   8 // Renderer11.cpp: Implements a back-end specific class for the D3D11 renderer.
   9
  10 #include "libGLESv2/main.h"
  11 #include "common/utilities.h"
  12 #include "libGLESv2/Buffer.h"
  13 #include "libGLESv2/FramebufferAttachment.h"
  14 #include "libGLESv2/ProgramBinary.h"
  15 #include "libGLESv2/Framebuffer.h"
  16 #include "libGLESv2/renderer/d3d/TextureD3D.h"
  17 #include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
  18 #include "libGLESv2/renderer/d3d/d3d11/RenderTarget11.h"
  19 #include "libGLESv2/renderer/d3d/d3d11/renderer11_utils.h"
  20 #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h"
  21 #include "libGLESv2/renderer/d3d/d3d11/ShaderExecutable11.h"
  22 #include "libGLESv2/renderer/d3d/d3d11/SwapChain11.h"
  23 #include "libGLESv2/renderer/d3d/d3d11/Image11.h"
  24 #include "libGLESv2/renderer/d3d/d3d11/VertexBuffer11.h"
  25 #include "libGLESv2/renderer/d3d/d3d11/IndexBuffer11.h"
  26 #include "libGLESv2/renderer/d3d/d3d11/Buffer11.h"
  27 #include "libGLESv2/renderer/d3d/VertexDataManager.h"
  28 #include "libGLESv2/renderer/d3d/IndexDataManager.h"
  29 #include "libGLESv2/renderer/d3d/d3d11/TextureStorage11.h"
  30 #include "libGLESv2/renderer/d3d/d3d11/Query11.h"
  31 #include "libGLESv2/renderer/d3d/d3d11/Fence11.h"
  32 #include "libGLESv2/renderer/d3d/d3d11/Blit11.h"
  33 #include "libGLESv2/renderer/d3d/d3d11/Clear11.h"
  34 #include "libGLESv2/renderer/d3d/d3d11/PixelTransfer11.h"
  35 #include "libGLESv2/renderer/d3d/d3d11/VertexArray11.h"
  36 #include "libGLESv2/renderer/d3d/d3d11/Buffer11.h"
  37 #include "libEGL/Display.h"
  38
  39 // Enable ANGLE_SKIP_DXGI_1_2_CHECK if there is not a possibility of using cross-process
  40 // HWNDs or the Windows 7 Platform Update (KB2670838) is expected to be installed.
  41 #ifndef ANGLE_SKIP_DXGI_1_2_CHECK
  42 #define ANGLE_SKIP_DXGI_1_2_CHECK 0
  43 #endif
  44
  45 #ifdef _DEBUG
  46 // this flag enables suppressing some spurious warnings that pop up in certain WebGL samples
  47 // and conformance tests. to enable all warnings, remove this define.
  48 #define ANGLE_SUPPRESS_D3D11_HAZARD_WARNINGS 1
  49 #endif
  50
  51 namespace rx
  52 {
  53 static const DXGI_FORMAT RenderTargetFormats[] =
  54     {
  55         DXGI_FORMAT_B8G8R8A8_UNORM,
  56         DXGI_FORMAT_R8G8B8A8_UNORM
  57     };
  58
  59 static const DXGI_FORMAT DepthStencilFormats[] =
  60     {
  61         DXGI_FORMAT_UNKNOWN,
  62         DXGI_FORMAT_D24_UNORM_S8_UINT,
  63         DXGI_FORMAT_D16_UNORM
  64     };
  65
  66 enum
  67 {
  68     MAX_TEXTURE_IMAGE_UNITS_VTF_SM4 = 16
  69 };
  70
  71 Renderer11::Renderer11(egl::Display *display, EGLNativeDisplayType hDc, EGLint requestedDisplay)
  72     : Renderer(display),
  73       mDc(hDc),
  74       mRequestedDisplay(requestedDisplay)
  75 {
  76     mVertexDataManager = NULL;
  77     mIndexDataManager = NULL;
  78
  79     mLineLoopIB = NULL;
  80     mTriangleFanIB = NULL;
  81
  82     mBlit = NULL;
  83     mPixelTransfer = NULL;
  84
  85     mClear = NULL;
  86
  87     mSyncQuery = NULL;
  88
  89     mD3d11Module = NULL;
  90     mDxgiModule = NULL;
  91
  92     mDeviceLost = false;
  93
  94     mDevice = NULL;
  95     mDeviceContext = NULL;
  96     mDxgiAdapter = NULL;
  97     mDxgiFactory = NULL;
  98
  99     mDriverConstantBufferVS = NULL;
 100     mDriverConstantBufferPS = NULL;
 101
 102     mAppliedVertexShader = NULL;
 103     mAppliedGeometryShader = NULL;
 104     mCurPointGeometryShader = NULL;
 105     mAppliedPixelShader = NULL;
 106 }
 107
 108 Renderer11::~Renderer11()
 109 {
 110     release();
 111 }
 112
 113 Renderer11 *Renderer11::makeRenderer11(Renderer *renderer)
 114 {
 115     ASSERT(HAS_DYNAMIC_TYPE(rx::Renderer11*, renderer));
 116     return static_cast<rx::Renderer11*>(renderer);
 117 }
 118
 119 #ifndef __d3d11_1_h__
 120 #define D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET ((D3D11_MESSAGE_ID)3146081)
 121 #endif
 122
 123 EGLint Renderer11::initialize()
 124 {
 125     if (!mCompiler.initialize())
 126     {
 127         return EGL_NOT_INITIALIZED;
 128     }
 129
 130     mDxgiModule = LoadLibrary(TEXT("dxgi.dll"));
 131     mD3d11Module = LoadLibrary(TEXT("d3d11.dll"));
 132
 133     if (mD3d11Module == NULL || mDxgiModule == NULL)
 134     {
 135         ERR("Could not load D3D11 or DXGI library - aborting!\n");
 136         return EGL_NOT_INITIALIZED;
 137     }
 138
 139     // create the D3D11 device
 140     ASSERT(mDevice == NULL);
 141     PFN_D3D11_CREATE_DEVICE D3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE)GetProcAddress(mD3d11Module, "D3D11CreateDevice");
 142
 143     if (D3D11CreateDevice == NULL)
 144     {
 145         ERR("Could not retrieve D3D11CreateDevice address - aborting!\n");
 146         return EGL_NOT_INITIALIZED;
 147     }
 148
 149     D3D_FEATURE_LEVEL featureLevels[] =
 150     {
 151         D3D_FEATURE_LEVEL_11_0,
 152         D3D_FEATURE_LEVEL_10_1,
 153         D3D_FEATURE_LEVEL_10_0,
 154     };
 155
 156     D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_HARDWARE;
 157     if (mRequestedDisplay == EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE)
 158     {
 159         driverType = D3D_DRIVER_TYPE_WARP;
 160     }
 161
 162     HRESULT result = S_OK;
 163
 164 #ifdef _DEBUG
 165     result = D3D11CreateDevice(NULL,
 166                                driverType,
 167                                NULL,
 168                                D3D11_CREATE_DEVICE_DEBUG,
 169                                featureLevels,
 170                                ArraySize(featureLevels),
 171                                D3D11_SDK_VERSION,
 172                                &mDevice,
 173                                &mFeatureLevel,
 174                                &mDeviceContext);
 175
 176     if (!mDevice || FAILED(result))
 177     {
 178         ERR("Failed creating Debug D3D11 device - falling back to release runtime.\n");
 179     }
 180
 181     if (!mDevice || FAILED(result))
 182 #endif
 183     {
 184         result = D3D11CreateDevice(NULL,
 185                                    driverType,
 186                                    NULL,
 187                                    0,
 188                                    featureLevels,
 189                                    ArraySize(featureLevels),
 190                                    D3D11_SDK_VERSION,
 191                                    &mDevice,
 192                                    &mFeatureLevel,
 193                                    &mDeviceContext);
 194
 195         if (!mDevice || FAILED(result))
 196         {
 197             ERR("Could not create D3D11 device - aborting!\n");
 198             return EGL_NOT_INITIALIZED;   // Cleanup done by destructor through glDestroyRenderer
 199         }
 200     }
 201
 202 #if !ANGLE_SKIP_DXGI_1_2_CHECK
 203     // In order to create a swap chain for an HWND owned by another process, DXGI 1.2 is required.
 204     // The easiest way to check is to query for a IDXGIDevice2.
 205     bool requireDXGI1_2 = false;
 206     HWND hwnd = WindowFromDC(mDc);
 207     if (hwnd)
 208     {
 209         DWORD currentProcessId = GetCurrentProcessId();
 210         DWORD wndProcessId;
 211         GetWindowThreadProcessId(hwnd, &wndProcessId);
 212         requireDXGI1_2 = (currentProcessId != wndProcessId);
 213     }
 214     else
 215     {
 216         requireDXGI1_2 = true;
 217     }
 218
 219     if (requireDXGI1_2)
 220     {
 221         IDXGIDevice2 *dxgiDevice2 = NULL;
 222         result = mDevice->QueryInterface(__uuidof(IDXGIDevice2), (void**)&dxgiDevice2);
 223         if (FAILED(result))
 224         {
 225             ERR("DXGI 1.2 required to present to HWNDs owned by another process.\n");
 226             return EGL_NOT_INITIALIZED;
 227         }
 228         SafeRelease(dxgiDevice2);
 229     }
 230 #endif
 231
 232     IDXGIDevice *dxgiDevice = NULL;
 233     result = mDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);
 234
 235     if (FAILED(result))
 236     {
 237         ERR("Could not query DXGI device - aborting!\n");
 238         return EGL_NOT_INITIALIZED;
 239     }
 240
 241     result = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&mDxgiAdapter);
 242
 243     if (FAILED(result))
 244     {
 245         ERR("Could not retrieve DXGI adapter - aborting!\n");
 246         return EGL_NOT_INITIALIZED;
 247     }
 248
 249     SafeRelease(dxgiDevice);
 250
 251     mDxgiAdapter->GetDesc(&mAdapterDescription);
 252     memset(mDescription, 0, sizeof(mDescription));
 253     wcstombs(mDescription, mAdapterDescription.Description, sizeof(mDescription) - 1);
 254
 255     result = mDxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&mDxgiFactory);
 256
 257     if (!mDxgiFactory || FAILED(result))
 258     {
 259         ERR("Could not create DXGI factory - aborting!\n");
 260         return EGL_NOT_INITIALIZED;
 261     }
 262
 263     // Disable some spurious D3D11 debug warnings to prevent them from flooding the output log
 264 #if defined(ANGLE_SUPPRESS_D3D11_HAZARD_WARNINGS) && defined(_DEBUG)
 265     ID3D11InfoQueue *infoQueue;
 266     result = mDevice->QueryInterface(__uuidof(ID3D11InfoQueue),  (void **)&infoQueue);
 267
 268     if (SUCCEEDED(result))
 269     {
 270         D3D11_MESSAGE_ID hideMessages[] =
 271         {
 272             D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET
 273         };
 274
 275         D3D11_INFO_QUEUE_FILTER filter = {0};
 276         filter.DenyList.NumIDs = ArraySize(hideMessages);
 277         filter.DenyList.pIDList = hideMessages;
 278
 279         infoQueue->AddStorageFilterEntries(&filter);
 280         SafeRelease(infoQueue);
 281     }
 282 #endif
 283
 284     initializeDevice();
 285
 286     return EGL_SUCCESS;
 287 }
 288
 289 // do any one-time device initialization
 290 // NOTE: this is also needed after a device lost/reset
 291 // to reset the scene status and ensure the default states are reset.
 292 void Renderer11::initializeDevice()
 293 {
 294     mStateCache.initialize(mDevice);
 295     mInputLayoutCache.initialize(mDevice, mDeviceContext);
 296
 297     ASSERT(!mVertexDataManager && !mIndexDataManager);
 298     mVertexDataManager = new VertexDataManager(this);
 299     mIndexDataManager = new IndexDataManager(this);
 300
 301     ASSERT(!mBlit);
 302     mBlit = new Blit11(this);
 303
 304     ASSERT(!mClear);
 305     mClear = new Clear11(this);
 306
 307     ASSERT(!mPixelTransfer);
 308     mPixelTransfer = new PixelTransfer11(this);
 309
 310     markAllStateDirty();
 311 }
 312
 313 int Renderer11::generateConfigs(ConfigDesc **configDescList)
 314 {
 315     unsigned int numRenderFormats = ArraySize(RenderTargetFormats);
 316     unsigned int numDepthFormats = ArraySize(DepthStencilFormats);
 317     (*configDescList) = new ConfigDesc[numRenderFormats * numDepthFormats];
 318     int numConfigs = 0;
 319
 320     for (unsigned int formatIndex = 0; formatIndex < numRenderFormats; formatIndex++)
 321     {
 322         const d3d11::DXGIFormat &renderTargetFormatInfo = d3d11::GetDXGIFormatInfo(RenderTargetFormats[formatIndex]);
 323         const gl::TextureCaps &renderTargetFormatCaps = getRendererTextureCaps().get(renderTargetFormatInfo.internalFormat);
 324         if (renderTargetFormatCaps.renderable)
 325         {
 326             for (unsigned int depthStencilIndex = 0; depthStencilIndex < numDepthFormats; depthStencilIndex++)
 327             {
 328                 const d3d11::DXGIFormat &depthStencilFormatInfo = d3d11::GetDXGIFormatInfo(DepthStencilFormats[depthStencilIndex]);
 329                 const gl::TextureCaps &depthStencilFormatCaps = getRendererTextureCaps().get(depthStencilFormatInfo.internalFormat);
 330                 if (depthStencilFormatCaps.renderable || DepthStencilFormats[depthStencilIndex] == DXGI_FORMAT_UNKNOWN)
 331                 {
 332                     ConfigDesc newConfig;
 333                     newConfig.renderTargetFormat = renderTargetFormatInfo.internalFormat;
 334                     newConfig.depthStencilFormat = depthStencilFormatInfo.internalFormat;
 335                     newConfig.multiSample = 0;     // FIXME: enumerate multi-sampling
 336                     newConfig.fastConfig = true;   // Assume all DX11 format conversions to be fast
 337                     newConfig.es3Capable = true;
 338
 339                     (*configDescList)[numConfigs++] = newConfig;
 340                 }
 341             }
 342         }
 343     }
 344
 345     return numConfigs;
 346 }
 347
 348 void Renderer11::deleteConfigs(ConfigDesc *configDescList)
 349 {
 350     delete [] (configDescList);
 351 }
 352
 353 void Renderer11::sync(bool block)
 354 {
 355     if (block)
 356     {
 357         HRESULT result;
 358
 359         if (!mSyncQuery)
 360         {
 361             D3D11_QUERY_DESC queryDesc;
 362             queryDesc.Query = D3D11_QUERY_EVENT;
 363             queryDesc.MiscFlags = 0;
 364
 365             result = mDevice->CreateQuery(&queryDesc, &mSyncQuery);
 366             ASSERT(SUCCEEDED(result));
 367         }
 368
 369         mDeviceContext->End(mSyncQuery);
 370         mDeviceContext->Flush();
 371
 372         do
 373         {
 374             result = mDeviceContext->GetData(mSyncQuery, NULL, 0, D3D11_ASYNC_GETDATA_DONOTFLUSH);
 375
 376             // Keep polling, but allow other threads to do something useful first
 377             Sleep(0);
 378
 379             if (testDeviceLost(true))
 380             {
 381                 return;
 382             }
 383         }
 384         while (result == S_FALSE);
 385     }
 386     else
 387     {
 388         mDeviceContext->Flush();
 389     }
 390 }
 391
 392 SwapChain *Renderer11::createSwapChain(HWND window, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat)
 393 {
 394     return new rx::SwapChain11(this, window, shareHandle, backBufferFormat, depthBufferFormat);
 395 }
 396
 397 void Renderer11::generateSwizzle(gl::Texture *texture)
 398 {
 399     if (texture)
 400     {
 401         TextureStorageInterface *texStorage = texture->getNativeTexture();
 402         if (texStorage)
 403         {
 404             TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage->getStorageInstance());
 405
 406             storage11->generateSwizzles(texture->getSamplerState().swizzleRed,
 407                                         texture->getSamplerState().swizzleGreen,
 408                                         texture->getSamplerState().swizzleBlue,
 409                                         texture->getSamplerState().swizzleAlpha);
 410         }
 411     }
 412 }
 413
 414 void Renderer11::setSamplerState(gl::SamplerType type, int index, const gl::SamplerState &samplerState)
 415 {
 416     if (type == gl::SAMPLER_PIXEL)
 417     {
 418         if (index < 0 || index >= gl::MAX_TEXTURE_IMAGE_UNITS)
 419         {
 420             ERR("Pixel shader sampler index %i is not valid.", index);
 421             return;
 422         }
 423
 424         if (mForceSetPixelSamplerStates[index] || memcmp(&samplerState, &mCurPixelSamplerStates[index], sizeof(gl::SamplerState)) != 0)
 425         {
 426             ID3D11SamplerState *dxSamplerState = mStateCache.getSamplerState(samplerState);
 427
 428             if (!dxSamplerState)
 429             {
 430                 ERR("NULL sampler state returned by RenderStateCache::getSamplerState, setting the default"
 431                     "sampler state for pixel shaders at slot %i.", index);
 432             }
 433
 434             mDeviceContext->PSSetSamplers(index, 1, &dxSamplerState);
 435
 436             mCurPixelSamplerStates[index] = samplerState;
 437         }
 438
 439         mForceSetPixelSamplerStates[index] = false;
 440     }
 441     else if (type == gl::SAMPLER_VERTEX)
 442     {
 443         if (index < 0 || index >= (int)getMaxVertexTextureImageUnits())
 444         {
 445             ERR("Vertex shader sampler index %i is not valid.", index);
 446             return;
 447         }
 448
 449         if (mForceSetVertexSamplerStates[index] || memcmp(&samplerState, &mCurVertexSamplerStates[index], sizeof(gl::SamplerState)) != 0)
 450         {
 451             ID3D11SamplerState *dxSamplerState = mStateCache.getSamplerState(samplerState);
 452
 453             if (!dxSamplerState)
 454             {
 455                 ERR("NULL sampler state returned by RenderStateCache::getSamplerState, setting the default"
 456                     "sampler state for vertex shaders at slot %i.", index);
 457             }
 458
 459             mDeviceContext->VSSetSamplers(index, 1, &dxSamplerState);
 460
 461             mCurVertexSamplerStates[index] = samplerState;
 462         }
 463
 464         mForceSetVertexSamplerStates[index] = false;
 465     }
 466     else UNREACHABLE();
 467 }
 468
 469 void Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *texture)
 470 {
 471     ID3D11ShaderResourceView *textureSRV = NULL;
 472     bool forceSetTexture = false;
 473
 474     if (texture)
 475     {
 476         TextureImpl* textureImpl = texture->getImplementation();
 477
 478         TextureStorageInterface *texStorage = textureImpl->getNativeTexture();
 479         if (texStorage)
 480         {
 481             TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage->getStorageInstance());
 482             gl::SamplerState samplerState;
 483             texture->getSamplerStateWithNativeOffset(&samplerState);
 484             textureSRV = storage11->getSRV(samplerState);
 485         }
 486
 487         // If we get NULL back from getSRV here, something went wrong in the texture class and we're unexpectedly
 488         // missing the shader resource view
 489         ASSERT(textureSRV != NULL);
 490
 491         forceSetTexture = textureImpl->hasDirtyImages();
 492         textureImpl->resetDirty();
 493     }
 494
 495     if (type == gl::SAMPLER_PIXEL)
 496     {
 497         if (index < 0 || index >= gl::MAX_TEXTURE_IMAGE_UNITS)
 498         {
 499             ERR("Pixel shader sampler index %i is not valid.", index);
 500             return;
 501         }
 502
 503         if (forceSetTexture || mCurPixelSRVs[index] != textureSRV)
 504         {
 505             mDeviceContext->PSSetShaderResources(index, 1, &textureSRV);
 506         }
 507
 508         mCurPixelSRVs[index] = textureSRV;
 509     }
 510     else if (type == gl::SAMPLER_VERTEX)
 511     {
 512         if (index < 0 || index >= (int)getMaxVertexTextureImageUnits())
 513         {
 514             ERR("Vertex shader sampler index %i is not valid.", index);
 515             return;
 516         }
 517
 518         if (forceSetTexture || mCurVertexSRVs[index] != textureSRV)
 519         {
 520             mDeviceContext->VSSetShaderResources(index, 1, &textureSRV);
 521         }
 522
 523         mCurVertexSRVs[index] = textureSRV;
 524     }
 525     else UNREACHABLE();
 526 }
 527
 528 bool Renderer11::setUniformBuffers(const gl::Buffer *vertexUniformBuffers[], const gl::Buffer *fragmentUniformBuffers[])
 529 {
 530     for (unsigned int uniformBufferIndex = 0; uniformBufferIndex < gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS; uniformBufferIndex++)
 531     {
 532         const gl::Buffer *uniformBuffer = vertexUniformBuffers[uniformBufferIndex];
 533         if (uniformBuffer)
 534         {
 535             Buffer11 *bufferStorage = Buffer11::makeBuffer11(uniformBuffer->getImplementation());
 536             ID3D11Buffer *constantBuffer = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
 537
 538             if (!constantBuffer)
 539             {
 540                 return false;
 541             }
 542
 543             if (mCurrentConstantBufferVS[uniformBufferIndex] != bufferStorage->getSerial())
 544             {
 545                 mDeviceContext->VSSetConstantBuffers(getReservedVertexUniformBuffers() + uniformBufferIndex,
 546                                                      1, &constantBuffer);
 547                 mCurrentConstantBufferVS[uniformBufferIndex] = bufferStorage->getSerial();
 548             }
 549         }
 550     }
 551
 552     for (unsigned int uniformBufferIndex = 0; uniformBufferIndex < gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS; uniformBufferIndex++)
 553     {
 554         const gl::Buffer *uniformBuffer = fragmentUniformBuffers[uniformBufferIndex];
 555         if (uniformBuffer)
 556         {
 557             Buffer11 *bufferStorage = Buffer11::makeBuffer11(uniformBuffer->getImplementation());
 558             ID3D11Buffer *constantBuffer = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
 559
 560             if (!constantBuffer)
 561             {
 562                 return false;
 563             }
 564
 565             if (mCurrentConstantBufferPS[uniformBufferIndex] != bufferStorage->getSerial())
 566             {
 567                 mDeviceContext->PSSetConstantBuffers(getReservedFragmentUniformBuffers() + uniformBufferIndex,
 568                                                      1, &constantBuffer);
 569                 mCurrentConstantBufferPS[uniformBufferIndex] = bufferStorage->getSerial();
 570             }
 571         }
 572     }
 573
 574     return true;
 575 }
 576
 577 void Renderer11::setRasterizerState(const gl::RasterizerState &rasterState)
 578 {
 579     if (mForceSetRasterState || memcmp(&rasterState, &mCurRasterState, sizeof(gl::RasterizerState)) != 0)
 580     {
 581         ID3D11RasterizerState *dxRasterState = mStateCache.getRasterizerState(rasterState, mScissorEnabled);
 582         if (!dxRasterState)
 583         {
 584             ERR("NULL rasterizer state returned by RenderStateCache::getRasterizerState, setting the default"
 585                 "rasterizer state.");
 586         }
 587
 588         mDeviceContext->RSSetState(dxRasterState);
 589
 590         mCurRasterState = rasterState;
 591     }
 592
 593     mForceSetRasterState = false;
 594 }
 595
 596 void Renderer11::setBlendState(gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::ColorF &blendColor,
 597                                unsigned int sampleMask)
 598 {
 599     if (mForceSetBlendState ||
 600         memcmp(&blendState, &mCurBlendState, sizeof(gl::BlendState)) != 0 ||
 601         memcmp(&blendColor, &mCurBlendColor, sizeof(gl::ColorF)) != 0 ||
 602         sampleMask != mCurSampleMask)
 603     {
 604         ID3D11BlendState *dxBlendState = mStateCache.getBlendState(framebuffer, blendState);
 605         if (!dxBlendState)
 606         {
 607             ERR("NULL blend state returned by RenderStateCache::getBlendState, setting the default "
 608                 "blend state.");
 609         }
 610
 611         float blendColors[4] = {0.0f};
 612         if (blendState.sourceBlendRGB != GL_CONSTANT_ALPHA && blendState.sourceBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA &&
 613             blendState.destBlendRGB != GL_CONSTANT_ALPHA && blendState.destBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA)
 614         {
 615             blendColors[0] = blendColor.red;
 616             blendColors[1] = blendColor.green;
 617             blendColors[2] = blendColor.blue;
 618             blendColors[3] = blendColor.alpha;
 619         }
 620         else
 621         {
 622             blendColors[0] = blendColor.alpha;
 623             blendColors[1] = blendColor.alpha;
 624             blendColors[2] = blendColor.alpha;
 625             blendColors[3] = blendColor.alpha;
 626         }
 627
 628         mDeviceContext->OMSetBlendState(dxBlendState, blendColors, sampleMask);
 629
 630         mCurBlendState = blendState;
 631         mCurBlendColor = blendColor;
 632         mCurSampleMask = sampleMask;
 633     }
 634
 635     mForceSetBlendState = false;
 636 }
 637
 638 void Renderer11::setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
 639                                       int stencilBackRef, bool frontFaceCCW)
 640 {
 641     if (mForceSetDepthStencilState ||
 642         memcmp(&depthStencilState, &mCurDepthStencilState, sizeof(gl::DepthStencilState)) != 0 ||
 643         stencilRef != mCurStencilRef || stencilBackRef != mCurStencilBackRef)
 644     {
 645         ASSERT(depthStencilState.stencilWritemask == depthStencilState.stencilBackWritemask);
 646         ASSERT(stencilRef == stencilBackRef);
 647         ASSERT(depthStencilState.stencilMask == depthStencilState.stencilBackMask);
 648
 649         ID3D11DepthStencilState *dxDepthStencilState = mStateCache.getDepthStencilState(depthStencilState);
 650         if (!dxDepthStencilState)
 651         {
 652             ERR("NULL depth stencil state returned by RenderStateCache::getDepthStencilState, "
 653                 "setting the default depth stencil state.");
 654         }
 655
 656         // Max D3D11 stencil reference value is 0xFF, corresponding to the max 8 bits in a stencil buffer
 657         // GL specifies we should clamp the ref value to the nearest bit depth when doing stencil ops
 658         META_ASSERT(D3D11_DEFAULT_STENCIL_READ_MASK == 0xFF);
 659         META_ASSERT(D3D11_DEFAULT_STENCIL_WRITE_MASK == 0xFF);
 660         UINT dxStencilRef = std::min<UINT>(stencilRef, 0xFFu);
 661
 662         mDeviceContext->OMSetDepthStencilState(dxDepthStencilState, dxStencilRef);
 663
 664         mCurDepthStencilState = depthStencilState;
 665         mCurStencilRef = stencilRef;
 666         mCurStencilBackRef = stencilBackRef;
 667     }
 668
 669     mForceSetDepthStencilState = false;
 670 }
 671
 672 void Renderer11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
 673 {
 674     if (mForceSetScissor || memcmp(&scissor, &mCurScissor, sizeof(gl::Rectangle)) != 0 ||
 675         enabled != mScissorEnabled)
 676     {
 677         if (enabled)
 678         {
 679             D3D11_RECT rect;
 680             rect.left = std::max(0, scissor.x);
 681             rect.top = std::max(0, scissor.y);
 682             rect.right = scissor.x + std::max(0, scissor.width);
 683             rect.bottom = scissor.y + std::max(0, scissor.height);
 684
 685             mDeviceContext->RSSetScissorRects(1, &rect);
 686         }
 687
 688         if (enabled != mScissorEnabled)
 689         {
 690             mForceSetRasterState = true;
 691         }
 692
 693         mCurScissor = scissor;
 694         mScissorEnabled = enabled;
 695     }
 696
 697     mForceSetScissor = false;
 698 }
 699
 700 bool Renderer11::setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
 701                              bool ignoreViewport)
 702 {
 703     gl::Rectangle actualViewport = viewport;
 704     float actualZNear = gl::clamp01(zNear);
 705     float actualZFar = gl::clamp01(zFar);
 706     if (ignoreViewport)
 707     {
 708         actualViewport.x = 0;
 709         actualViewport.y = 0;
 710         actualViewport.width = mRenderTargetDesc.width;
 711         actualViewport.height = mRenderTargetDesc.height;
 712         actualZNear = 0.0f;
 713         actualZFar = 1.0f;
 714     }
 715
 716     const gl::Caps& caps = getRendererCaps();
 717
 718     // Clamp width and height first to the gl maximum, then clamp further if we extend past the D3D maximum bounds
 719     D3D11_VIEWPORT dxViewport;
 720     dxViewport.TopLeftX = gl::clamp(actualViewport.x, -static_cast<int>(caps.maxViewportWidth), static_cast<int>(caps.maxViewportWidth));
 721     dxViewport.TopLeftY = gl::clamp(actualViewport.y, -static_cast<int>(caps.maxViewportHeight), static_cast<int>(caps.maxViewportHeight));
 722     dxViewport.Width = gl::clamp(actualViewport.width, 0, static_cast<int>(caps.maxViewportWidth - dxViewport.TopLeftX));
 723     dxViewport.Height = gl::clamp(actualViewport.height, 0, static_cast<int>(caps.maxViewportHeight - dxViewport.TopLeftY));
 724     dxViewport.MinDepth = actualZNear;
 725     dxViewport.MaxDepth = actualZFar;
 726
 727     if (dxViewport.Width <= 0 || dxViewport.Height <= 0)
 728     {
 729         return false;   // Nothing to render
 730     }
 731
 732     bool viewportChanged = mForceSetViewport || memcmp(&actualViewport, &mCurViewport, sizeof(gl::Rectangle)) != 0 ||
 733                            actualZNear != mCurNear || actualZFar != mCurFar;
 734
 735     if (viewportChanged)
 736     {
 737         mDeviceContext->RSSetViewports(1, &dxViewport);
 738
 739         mCurViewport = actualViewport;
 740         mCurNear = actualZNear;
 741         mCurFar = actualZFar;
 742
 743         mPixelConstants.viewCoords[0] = actualViewport.width  * 0.5f;
 744         mPixelConstants.viewCoords[1] = actualViewport.height * 0.5f;
 745         mPixelConstants.viewCoords[2] = actualViewport.x + (actualViewport.width  * 0.5f);
 746         mPixelConstants.viewCoords[3] = actualViewport.y + (actualViewport.height * 0.5f);
 747
 748         mPixelConstants.depthFront[0] = (actualZFar - actualZNear) * 0.5f;
 749         mPixelConstants.depthFront[1] = (actualZNear + actualZFar) * 0.5f;
 750
 751         mVertexConstants.depthRange[0] = actualZNear;
 752         mVertexConstants.depthRange[1] = actualZFar;
 753         mVertexConstants.depthRange[2] = actualZFar - actualZNear;
 754
 755         mPixelConstants.depthRange[0] = actualZNear;
 756         mPixelConstants.depthRange[1] = actualZFar;
 757         mPixelConstants.depthRange[2] = actualZFar - actualZNear;
 758     }
 759
 760     mForceSetViewport = false;
 761     return true;
 762 }
 763
 764 bool Renderer11::applyPrimitiveType(GLenum mode, GLsizei count)
 765 {
 766     D3D11_PRIMITIVE_TOPOLOGY primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
 767
 768     GLsizei minCount = 0;
 769
 770     switch (mode)
 771     {
 772       case GL_POINTS:         primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_POINTLIST;   minCount = 1; break;
 773       case GL_LINES:          primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_LINELIST;      minCount = 2; break;
 774       case GL_LINE_LOOP:      primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP;     minCount = 2; break;
 775       case GL_LINE_STRIP:     primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP;     minCount = 2; break;
 776       case GL_TRIANGLES:      primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;  minCount = 3; break;
 777       case GL_TRIANGLE_STRIP: primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; minCount = 3; break;
 778           // emulate fans via rewriting index buffer
 779       case GL_TRIANGLE_FAN:   primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;  minCount = 3; break;
 780       default:
 781         UNREACHABLE();
 782         return false;
 783     }
 784
 785     if (primitiveTopology != mCurrentPrimitiveTopology)
 786     {
 787         mDeviceContext->IASetPrimitiveTopology(primitiveTopology);
 788         mCurrentPrimitiveTopology = primitiveTopology;
 789     }
 790
 791     return count >= minCount;
 792 }
 793
 794 bool Renderer11::applyRenderTarget(gl::Framebuffer *framebuffer)
 795 {
 796     // Get the color render buffer and serial
 797     // Also extract the render target dimensions and view
 798     unsigned int renderTargetWidth = 0;
 799     unsigned int renderTargetHeight = 0;
 800     GLenum renderTargetFormat = 0;
 801     unsigned int renderTargetSerials[gl::IMPLEMENTATION_MAX_DRAW_BUFFERS] = {0};
 802     ID3D11RenderTargetView* framebufferRTVs[gl::IMPLEMENTATION_MAX_DRAW_BUFFERS] = {NULL};
 803     bool missingColorRenderTarget = true;
 804
 805     for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
 806     {
 807         const GLenum drawBufferState = framebuffer->getDrawBufferState(colorAttachment);
 808         gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(colorAttachment);
 809
 810         if (colorbuffer && drawBufferState != GL_NONE)
 811         {
 812             // the draw buffer must be either "none", "back" for the default buffer or the same index as this color (in order)
 813             ASSERT(drawBufferState == GL_BACK || drawBufferState == (GL_COLOR_ATTACHMENT0_EXT + colorAttachment));
 814
 815             // check for zero-sized default framebuffer, which is a special case.
 816             // in this case we do not wish to modify any state and just silently return false.
 817             // this will not report any gl error but will cause the calling method to return.
 818             if (colorbuffer->getWidth() == 0 || colorbuffer->getHeight() == 0)
 819             {
 820                 return false;
 821             }
 822
 823             renderTargetSerials[colorAttachment] = colorbuffer->getSerial();
 824
 825             // Extract the render target dimensions and view
 826             RenderTarget11 *renderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
 827             if (!renderTarget)
 828             {
 829                 ERR("render target pointer unexpectedly null.");
 830                 return false;
 831             }
 832
 833             framebufferRTVs[colorAttachment] = renderTarget->getRenderTargetView();
 834             if (!framebufferRTVs[colorAttachment])
 835             {
 836                 ERR("render target view pointer unexpectedly null.");
 837                 return false;
 838             }
 839
 840             if (missingColorRenderTarget)
 841             {
 842                 renderTargetWidth = colorbuffer->getWidth();
 843                 renderTargetHeight = colorbuffer->getHeight();
 844                 renderTargetFormat = colorbuffer->getActualFormat();
 845                 missingColorRenderTarget = false;
 846             }
 847
 848             // TODO: Detect if this color buffer is already bound as a texture and unbind it first to prevent
 849             //       D3D11 warnings.
 850         }
 851     }
 852
 853     // Get the depth stencil render buffer and serials
 854     gl::FramebufferAttachment *depthStencil = framebuffer->getDepthbuffer();
 855     unsigned int depthbufferSerial = 0;
 856     unsigned int stencilbufferSerial = 0;
 857     if (depthStencil)
 858     {
 859         depthbufferSerial = depthStencil->getSerial();
 860     }
 861     else if (framebuffer->getStencilbuffer())
 862     {
 863         depthStencil = framebuffer->getStencilbuffer();
 864         stencilbufferSerial = depthStencil->getSerial();
 865     }
 866
 867     ID3D11DepthStencilView* framebufferDSV = NULL;
 868     if (depthStencil)
 869     {
 870         RenderTarget11 *depthStencilRenderTarget = RenderTarget11::makeRenderTarget11(depthStencil->getDepthStencil());
 871         if (!depthStencilRenderTarget)
 872         {
 873             ERR("render target pointer unexpectedly null.");
 874             SafeRelease(framebufferRTVs);
 875             return false;
 876         }
 877
 878         framebufferDSV = depthStencilRenderTarget->getDepthStencilView();
 879         if (!framebufferDSV)
 880         {
 881             ERR("depth stencil view pointer unexpectedly null.");
 882             SafeRelease(framebufferRTVs);
 883             return false;
 884         }
 885
 886         // If there is no render buffer, the width, height and format values come from
 887         // the depth stencil
 888         if (missingColorRenderTarget)
 889         {
 890             renderTargetWidth = depthStencil->getWidth();
 891             renderTargetHeight = depthStencil->getHeight();
 892             renderTargetFormat = depthStencil->getActualFormat();
 893         }
 894     }
 895
 896     // Apply the render target and depth stencil
 897     if (!mRenderTargetDescInitialized || !mDepthStencilInitialized ||
 898         memcmp(renderTargetSerials, mAppliedRenderTargetSerials, sizeof(renderTargetSerials)) != 0 ||
 899         depthbufferSerial != mAppliedDepthbufferSerial ||
 900         stencilbufferSerial != mAppliedStencilbufferSerial)
 901     {
 902         mDeviceContext->OMSetRenderTargets(getRendererCaps().maxDrawBuffers, framebufferRTVs, framebufferDSV);
 903
 904         mRenderTargetDesc.width = renderTargetWidth;
 905         mRenderTargetDesc.height = renderTargetHeight;
 906         mRenderTargetDesc.format = renderTargetFormat;
 907         mForceSetViewport = true;
 908         mForceSetScissor = true;
 909         mForceSetBlendState = true;
 910
 911         if (!mDepthStencilInitialized)
 912         {
 913             mForceSetRasterState = true;
 914         }
 915
 916         for (unsigned int rtIndex = 0; rtIndex < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; rtIndex++)
 917         {
 918             mAppliedRenderTargetSerials[rtIndex] = renderTargetSerials[rtIndex];
 919         }
 920         mAppliedDepthbufferSerial = depthbufferSerial;
 921         mAppliedStencilbufferSerial = stencilbufferSerial;
 922         mRenderTargetDescInitialized = true;
 923         mDepthStencilInitialized = true;
 924     }
 925
 926     invalidateFramebufferSwizzles(framebuffer);
 927
 928     return true;
 929 }
 930
 931 GLenum Renderer11::applyVertexBuffer(gl::ProgramBinary *programBinary, const gl::VertexAttribute vertexAttributes[], const gl::VertexAttribCurrentValueData currentValues[],
 932                                      GLint first, GLsizei count, GLsizei instances)
 933 {
 934     TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS];
 935     GLenum err = mVertexDataManager->prepareVertexData(vertexAttributes, currentValues, programBinary, first, count, attributes, instances);
 936     if (err != GL_NO_ERROR)
 937     {
 938         return err;
 939     }
 940
 941     return mInputLayoutCache.applyVertexBuffers(attributes, programBinary);
 942 }
 943
 944 GLenum Renderer11::applyIndexBuffer(const GLvoid *indices, gl::Buffer *elementArrayBuffer, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo)
 945 {
 946     GLenum err = mIndexDataManager->prepareIndexData(type, count, elementArrayBuffer, indices, indexInfo);
 947
 948     if (err == GL_NO_ERROR)
 949     {
 950         ID3D11Buffer *buffer = NULL;
 951         DXGI_FORMAT bufferFormat = (indexInfo->indexType == GL_UNSIGNED_INT) ? DXGI_FORMAT_R32_UINT : DXGI_FORMAT_R16_UINT;
 952
 953         if (indexInfo->storage)
 954         {
 955             Buffer11 *storage = Buffer11::makeBuffer11(indexInfo->storage);
 956             buffer = storage->getBuffer(BUFFER_USAGE_INDEX);
 957         }
 958         else
 959         {
 960             IndexBuffer11* indexBuffer = IndexBuffer11::makeIndexBuffer11(indexInfo->indexBuffer);
 961             buffer = indexBuffer->getBuffer();
 962         }
 963
 964         if (buffer != mAppliedIB || bufferFormat != mAppliedIBFormat || indexInfo->startOffset != mAppliedIBOffset)
 965         {
 966             mDeviceContext->IASetIndexBuffer(buffer, bufferFormat, indexInfo->startOffset);
 967
 968             mAppliedIB = buffer;
 969             mAppliedIBFormat = bufferFormat;
 970             mAppliedIBOffset = indexInfo->startOffset;
 971         }
 972     }
 973
 974     return err;
 975 }
 976
 977 void Renderer11::applyTransformFeedbackBuffers(gl::Buffer *transformFeedbackBuffers[], GLintptr offsets[])
 978 {
 979     ID3D11Buffer* d3dBuffers[gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS];
 980     UINT d3dOffsets[gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS];
 981     bool requiresUpdate = false;
 982     for (size_t i = 0; i < gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
 983     {
 984         if (transformFeedbackBuffers[i])
 985         {
 986             Buffer11 *storage = Buffer11::makeBuffer11(transformFeedbackBuffers[i]->getImplementation());
 987             ID3D11Buffer *buffer = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
 988
 989             d3dBuffers[i] = buffer;
 990             d3dOffsets[i] = (mAppliedTFBuffers[i] != buffer) ? static_cast<UINT>(offsets[i]) : -1;
 991         }
 992         else
 993         {
 994             d3dBuffers[i] = NULL;
 995             d3dOffsets[i] = 0;
 996         }
 997
 998         if (d3dBuffers[i] != mAppliedTFBuffers[i] || offsets[i] != mAppliedTFOffsets[i])
 999         {
1000             requiresUpdate = true;
1001         }
1002     }
1003
1004     if (requiresUpdate)
1005     {
1006         mDeviceContext->SOSetTargets(ArraySize(d3dBuffers), d3dBuffers, d3dOffsets);
1007         for (size_t i = 0; i < gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
1008         {
1009             mAppliedTFBuffers[i] = d3dBuffers[i];
1010             mAppliedTFOffsets[i] = offsets[i];
1011         }
1012     }
1013 }
1014
1015 void Renderer11::drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive)
1016 {
1017     if (mode == GL_POINTS && transformFeedbackActive)
1018     {
1019         // Since point sprites are generated with a geometry shader, too many vertices will
1020         // be written if transform feedback is active.  To work around this, draw only the points
1021         // with the stream out shader and no pixel shader to feed the stream out buffers and then
1022         // draw again with the point sprite geometry shader to rasterize the point sprites.
1023
1024         mDeviceContext->PSSetShader(NULL, NULL, 0);
1025
1026         if (instances > 0)
1027         {
1028             mDeviceContext->DrawInstanced(count, instances, 0, 0);
1029         }
1030         else
1031         {
1032             mDeviceContext->Draw(count, 0);
1033         }
1034
1035         mDeviceContext->GSSetShader(mCurPointGeometryShader, NULL, 0);
1036         mDeviceContext->PSSetShader(mAppliedPixelShader, NULL, 0);
1037
1038         if (instances > 0)
1039         {
1040             mDeviceContext->DrawInstanced(count, instances, 0, 0);
1041         }
1042         else
1043         {
1044             mDeviceContext->Draw(count, 0);
1045         }
1046
1047         mDeviceContext->GSSetShader(mAppliedGeometryShader, NULL, 0);
1048     }
1049     else if (mode == GL_LINE_LOOP)
1050     {
1051         drawLineLoop(count, GL_NONE, NULL, 0, NULL);
1052     }
1053     else if (mode == GL_TRIANGLE_FAN)
1054     {
1055         drawTriangleFan(count, GL_NONE, NULL, 0, NULL, instances);
1056     }
1057     else if (instances > 0)
1058     {
1059         mDeviceContext->DrawInstanced(count, instances, 0, 0);
1060     }
1061     else
1062     {
1063         mDeviceContext->Draw(count, 0);
1064     }
1065 }
1066
1067 void Renderer11::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
1068                               gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances)
1069 {
1070     if (mode == GL_LINE_LOOP)
1071     {
1072         drawLineLoop(count, type, indices, indexInfo.minIndex, elementArrayBuffer);
1073     }
1074     else if (mode == GL_TRIANGLE_FAN)
1075     {
1076         drawTriangleFan(count, type, indices, indexInfo.minIndex, elementArrayBuffer, instances);
1077     }
1078     else if (instances > 0)
1079     {
1080         mDeviceContext->DrawIndexedInstanced(count, instances, 0, -static_cast<int>(indexInfo.minIndex), 0);
1081     }
1082     else
1083     {
1084         mDeviceContext->DrawIndexed(count, 0, -static_cast<int>(indexInfo.minIndex));
1085     }
1086 }
1087
1088 void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer)
1089 {
1090     // Get the raw indices for an indexed draw
1091     if (type != GL_NONE && elementArrayBuffer)
1092     {
1093         gl::Buffer *indexBuffer = elementArrayBuffer;
1094         BufferImpl *storage = indexBuffer->getImplementation();
1095         intptr_t offset = reinterpret_cast<intptr_t>(indices);
1096         indices = static_cast<const GLubyte*>(storage->getData()) + offset;
1097     }
1098
1099     if (!mLineLoopIB)
1100     {
1101         mLineLoopIB = new StreamingIndexBufferInterface(this);
1102         if (!mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
1103         {
1104             delete mLineLoopIB;
1105             mLineLoopIB = NULL;
1106
1107             ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP.");
1108             return gl::error(GL_OUT_OF_MEMORY);
1109         }
1110     }
1111
1112     // Checked by Renderer11::applyPrimitiveType
1113     ASSERT(count >= 0);
1114
1115     if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
1116     {
1117         ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP, too many indices required.");
1118         return gl::error(GL_OUT_OF_MEMORY);
1119     }
1120
1121     const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
1122     if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
1123     {
1124         ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
1125         return gl::error(GL_OUT_OF_MEMORY);
1126     }
1127
1128     void* mappedMemory = NULL;
1129     unsigned int offset;
1130     if (!mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset))
1131     {
1132         ERR("Could not map index buffer for GL_LINE_LOOP.");
1133         return gl::error(GL_OUT_OF_MEMORY);
1134     }
1135
1136     unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
1137     unsigned int indexBufferOffset = offset;
1138
1139     switch (type)
1140     {
1141       case GL_NONE:   // Non-indexed draw
1142         for (int i = 0; i < count; i++)
1143         {
1144             data[i] = i;
1145         }
1146         data[count] = 0;
1147         break;
1148       case GL_UNSIGNED_BYTE:
1149         for (int i = 0; i < count; i++)
1150         {
1151             data[i] = static_cast<const GLubyte*>(indices)[i];
1152         }
1153         data[count] = static_cast<const GLubyte*>(indices)[0];
1154         break;
1155       case GL_UNSIGNED_SHORT:
1156         for (int i = 0; i < count; i++)
1157         {
1158             data[i] = static_cast<const GLushort*>(indices)[i];
1159         }
1160         data[count] = static_cast<const GLushort*>(indices)[0];
1161         break;
1162       case GL_UNSIGNED_INT:
1163         for (int i = 0; i < count; i++)
1164         {
1165             data[i] = static_cast<const GLuint*>(indices)[i];
1166         }
1167         data[count] = static_cast<const GLuint*>(indices)[0];
1168         break;
1169       default: UNREACHABLE();
1170     }
1171
1172     if (!mLineLoopIB->unmapBuffer())
1173     {
1174         ERR("Could not unmap index buffer for GL_LINE_LOOP.");
1175         return gl::error(GL_OUT_OF_MEMORY);
1176     }
1177
1178     IndexBuffer11 *indexBuffer = IndexBuffer11::makeIndexBuffer11(mLineLoopIB->getIndexBuffer());
1179     ID3D11Buffer *d3dIndexBuffer = indexBuffer->getBuffer();
1180     DXGI_FORMAT indexFormat = indexBuffer->getIndexFormat();
1181
1182     if (mAppliedIB != d3dIndexBuffer || mAppliedIBFormat != indexFormat || mAppliedIBOffset != indexBufferOffset)
1183     {
1184         mDeviceContext->IASetIndexBuffer(d3dIndexBuffer, indexFormat, indexBufferOffset);
1185         mAppliedIB = d3dIndexBuffer;
1186         mAppliedIBFormat = indexFormat;
1187         mAppliedIBOffset = indexBufferOffset;
1188     }
1189
1190     mDeviceContext->DrawIndexed(count + 1, 0, -minIndex);
1191 }
1192
1193 void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer, int instances)
1194 {
1195     // Get the raw indices for an indexed draw
1196     if (type != GL_NONE && elementArrayBuffer)
1197     {
1198         gl::Buffer *indexBuffer = elementArrayBuffer;
1199         BufferImpl *storage = indexBuffer->getImplementation();
1200         intptr_t offset = reinterpret_cast<intptr_t>(indices);
1201         indices = static_cast<const GLubyte*>(storage->getData()) + offset;
1202     }
1203
1204     if (!mTriangleFanIB)
1205     {
1206         mTriangleFanIB = new StreamingIndexBufferInterface(this);
1207         if (!mTriangleFanIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
1208         {
1209             delete mTriangleFanIB;
1210             mTriangleFanIB = NULL;
1211
1212             ERR("Could not create a scratch index buffer for GL_TRIANGLE_FAN.");
1213             return gl::error(GL_OUT_OF_MEMORY);
1214         }
1215     }
1216
1217     // Checked by Renderer11::applyPrimitiveType
1218     ASSERT(count >= 3);
1219
1220     const unsigned int numTris = count - 2;
1221
1222     if (numTris > (std::numeric_limits<unsigned int>::max() / (sizeof(unsigned int) * 3)))
1223     {
1224         ERR("Could not create a scratch index buffer for GL_TRIANGLE_FAN, too many indices required.");
1225         return gl::error(GL_OUT_OF_MEMORY);
1226     }
1227
1228     const unsigned int spaceNeeded = (numTris * 3) * sizeof(unsigned int);
1229     if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
1230     {
1231         ERR("Could not reserve enough space in scratch index buffer for GL_TRIANGLE_FAN.");
1232         return gl::error(GL_OUT_OF_MEMORY);
1233     }
1234
1235     void* mappedMemory = NULL;
1236     unsigned int offset;
1237     if (!mTriangleFanIB->mapBuffer(spaceNeeded, &mappedMemory, &offset))
1238     {
1239         ERR("Could not map scratch index buffer for GL_TRIANGLE_FAN.");
1240         return gl::error(GL_OUT_OF_MEMORY);
1241     }
1242
1243     unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
1244     unsigned int indexBufferOffset = offset;
1245
1246     switch (type)
1247     {
1248       case GL_NONE:   // Non-indexed draw
1249         for (unsigned int i = 0; i < numTris; i++)
1250         {
1251             data[i*3 + 0] = 0;
1252             data[i*3 + 1] = i + 1;
1253             data[i*3 + 2] = i + 2;
1254         }
1255         break;
1256       case GL_UNSIGNED_BYTE:
1257         for (unsigned int i = 0; i < numTris; i++)
1258         {
1259             data[i*3 + 0] = static_cast<const GLubyte*>(indices)[0];
1260             data[i*3 + 1] = static_cast<const GLubyte*>(indices)[i + 1];
1261             data[i*3 + 2] = static_cast<const GLubyte*>(indices)[i + 2];
1262         }
1263         break;
1264       case GL_UNSIGNED_SHORT:
1265         for (unsigned int i = 0; i < numTris; i++)
1266         {
1267             data[i*3 + 0] = static_cast<const GLushort*>(indices)[0];
1268             data[i*3 + 1] = static_cast<const GLushort*>(indices)[i + 1];
1269             data[i*3 + 2] = static_cast<const GLushort*>(indices)[i + 2];
1270         }
1271         break;
1272       case GL_UNSIGNED_INT:
1273         for (unsigned int i = 0; i < numTris; i++)
1274         {
1275             data[i*3 + 0] = static_cast<const GLuint*>(indices)[0];
1276             data[i*3 + 1] = static_cast<const GLuint*>(indices)[i + 1];
1277             data[i*3 + 2] = static_cast<const GLuint*>(indices)[i + 2];
1278         }
1279         break;
1280       default: UNREACHABLE();
1281     }
1282
1283     if (!mTriangleFanIB->unmapBuffer())
1284     {
1285         ERR("Could not unmap scratch index buffer for GL_TRIANGLE_FAN.");
1286         return gl::error(GL_OUT_OF_MEMORY);
1287     }
1288
1289     IndexBuffer11 *indexBuffer = IndexBuffer11::makeIndexBuffer11(mTriangleFanIB->getIndexBuffer());
1290     ID3D11Buffer *d3dIndexBuffer = indexBuffer->getBuffer();
1291     DXGI_FORMAT indexFormat = indexBuffer->getIndexFormat();
1292
1293     if (mAppliedIB != d3dIndexBuffer || mAppliedIBFormat != indexFormat || mAppliedIBOffset != indexBufferOffset)
1294     {
1295         mDeviceContext->IASetIndexBuffer(d3dIndexBuffer, indexFormat, indexBufferOffset);
1296         mAppliedIB = d3dIndexBuffer;
1297         mAppliedIBFormat = indexFormat;
1298         mAppliedIBOffset = indexBufferOffset;
1299     }
1300
1301     if (instances > 0)
1302     {
1303         mDeviceContext->DrawIndexedInstanced(numTris * 3, instances, 0, -minIndex, 0);
1304     }
1305     else
1306     {
1307         mDeviceContext->DrawIndexed(numTris * 3, 0, -minIndex);
1308     }
1309 }
1310
1311 void Renderer11::applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
1312                               bool rasterizerDiscard, bool transformFeedbackActive)
1313 {
1314     ShaderExecutable *vertexExe = programBinary->getVertexExecutableForInputLayout(inputLayout);
1315     ShaderExecutable *pixelExe = programBinary->getPixelExecutableForFramebuffer(framebuffer);
1316     ShaderExecutable *geometryExe = programBinary->getGeometryExecutable();
1317
1318     ID3D11VertexShader *vertexShader = (vertexExe ? ShaderExecutable11::makeShaderExecutable11(vertexExe)->getVertexShader() : NULL);
1319
1320     ID3D11PixelShader *pixelShader = NULL;
1321     // Skip pixel shader if we're doing rasterizer discard.
1322     if (!rasterizerDiscard)
1323     {
1324         pixelShader = (pixelExe ? ShaderExecutable11::makeShaderExecutable11(pixelExe)->getPixelShader() : NULL);
1325     }
1326
1327     ID3D11GeometryShader *geometryShader = NULL;
1328     if (transformFeedbackActive)
1329     {
1330         geometryShader = (vertexExe ? ShaderExecutable11::makeShaderExecutable11(vertexExe)->getStreamOutShader() : NULL);
1331     }
1332     else if (mCurRasterState.pointDrawMode)
1333     {
1334         geometryShader = (geometryExe ? ShaderExecutable11::makeShaderExecutable11(geometryExe)->getGeometryShader() : NULL);
1335     }
1336
1337     bool dirtyUniforms = false;
1338
1339     if (vertexShader != mAppliedVertexShader)
1340     {
1341         mDeviceContext->VSSetShader(vertexShader, NULL, 0);
1342         mAppliedVertexShader = vertexShader;
1343         dirtyUniforms = true;
1344     }
1345
1346     if (geometryShader != mAppliedGeometryShader)
1347     {
1348         mDeviceContext->GSSetShader(geometryShader, NULL, 0);
1349         mAppliedGeometryShader = geometryShader;
1350         dirtyUniforms = true;
1351     }
1352
1353     if (geometryExe && mCurRasterState.pointDrawMode)
1354     {
1355         mCurPointGeometryShader = ShaderExecutable11::makeShaderExecutable11(geometryExe)->getGeometryShader();
1356     }
1357     else
1358     {
1359         mCurPointGeometryShader = NULL;
1360     }
1361
1362     if (pixelShader != mAppliedPixelShader)
1363     {
1364         mDeviceContext->PSSetShader(pixelShader, NULL, 0);
1365         mAppliedPixelShader = pixelShader;
1366         dirtyUniforms = true;
1367     }
1368
1369     if (dirtyUniforms)
1370     {
1371         programBinary->dirtyAllUniforms();
1372     }
1373 }
1374
1375 void Renderer11::applyUniforms(const gl::ProgramBinary &programBinary)
1376 {
1377     const std::vector<gl::LinkedUniform*> &uniformArray = programBinary.getUniforms();
1378
1379     unsigned int totalRegisterCountVS = 0;
1380     unsigned int totalRegisterCountPS = 0;
1381
1382     bool vertexUniformsDirty = false;
1383     bool pixelUniformsDirty = false;
1384
1385     for (size_t uniformIndex = 0; uniformIndex < uniformArray.size(); uniformIndex++)
1386     {
1387         const gl::LinkedUniform &uniform = *uniformArray[uniformIndex];
1388
1389         if (uniform.isReferencedByVertexShader() && !uniform.isSampler())
1390         {
1391             totalRegisterCountVS += uniform.registerCount;
1392             vertexUniformsDirty = (vertexUniformsDirty || uniform.dirty);
1393         }
1394
1395         if (uniform.isReferencedByFragmentShader() && !uniform.isSampler())
1396         {
1397             totalRegisterCountPS += uniform.registerCount;
1398             pixelUniformsDirty = (pixelUniformsDirty || uniform.dirty);
1399         }
1400     }
1401
1402     const UniformStorage11 *vertexUniformStorage = UniformStorage11::makeUniformStorage11(&programBinary.getVertexUniformStorage());
1403     const UniformStorage11 *fragmentUniformStorage = UniformStorage11::makeUniformStorage11(&programBinary.getFragmentUniformStorage());
1404     ASSERT(vertexUniformStorage);
1405     ASSERT(fragmentUniformStorage);
1406
1407     ID3D11Buffer *vertexConstantBuffer = vertexUniformStorage->getConstantBuffer();
1408     ID3D11Buffer *pixelConstantBuffer = fragmentUniformStorage->getConstantBuffer();
1409
1410     float (*mapVS)[4] = NULL;
1411     float (*mapPS)[4] = NULL;
1412
1413     if (totalRegisterCountVS > 0 && vertexUniformsDirty)
1414     {
1415         D3D11_MAPPED_SUBRESOURCE map = {0};
1416         HRESULT result = mDeviceContext->Map(vertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
1417         UNUSED_ASSERTION_VARIABLE(result);
1418         ASSERT(SUCCEEDED(result));
1419         mapVS = (float(*)[4])map.pData;
1420     }
1421
1422     if (totalRegisterCountPS > 0 && pixelUniformsDirty)
1423     {
1424         D3D11_MAPPED_SUBRESOURCE map = {0};
1425         HRESULT result = mDeviceContext->Map(pixelConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
1426         UNUSED_ASSERTION_VARIABLE(result);
1427         ASSERT(SUCCEEDED(result));
1428         mapPS = (float(*)[4])map.pData;
1429     }
1430
1431     for (size_t uniformIndex = 0; uniformIndex < uniformArray.size(); uniformIndex++)
1432     {
1433         gl::LinkedUniform *uniform = uniformArray[uniformIndex];
1434
1435         if (!uniform->isSampler())
1436         {
1437             unsigned int componentCount = (4 - uniform->registerElement);
1438
1439             // we assume that uniforms from structs are arranged in struct order in our uniforms list. otherwise we would
1440             // overwrite previously written regions of memory.
1441
1442             if (uniform->isReferencedByVertexShader() && mapVS)
1443             {
1444                 memcpy(&mapVS[uniform->vsRegisterIndex][uniform->registerElement], uniform->data, uniform->registerCount * sizeof(float) * componentCount);
1445             }
1446
1447             if (uniform->isReferencedByFragmentShader() && mapPS)
1448             {
1449                 memcpy(&mapPS[uniform->psRegisterIndex][uniform->registerElement], uniform->data, uniform->registerCount * sizeof(float) * componentCount);
1450             }
1451         }
1452     }
1453
1454     if (mapVS)
1455     {
1456         mDeviceContext->Unmap(vertexConstantBuffer, 0);
1457     }
1458
1459     if (mapPS)
1460     {
1461         mDeviceContext->Unmap(pixelConstantBuffer, 0);
1462     }
1463
1464     if (mCurrentVertexConstantBuffer != vertexConstantBuffer)
1465     {
1466         mDeviceContext->VSSetConstantBuffers(0, 1, &vertexConstantBuffer);
1467         mCurrentVertexConstantBuffer = vertexConstantBuffer;
1468     }
1469
1470     if (mCurrentPixelConstantBuffer != pixelConstantBuffer)
1471     {
1472         mDeviceContext->PSSetConstantBuffers(0, 1, &pixelConstantBuffer);
1473         mCurrentPixelConstantBuffer = pixelConstantBuffer;
1474     }
1475
1476     // Driver uniforms
1477     if (!mDriverConstantBufferVS)
1478     {
1479         D3D11_BUFFER_DESC constantBufferDescription = {0};
1480         constantBufferDescription.ByteWidth = sizeof(dx_VertexConstants);
1481         constantBufferDescription.Usage = D3D11_USAGE_DEFAULT;
1482         constantBufferDescription.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
1483         constantBufferDescription.CPUAccessFlags = 0;
1484         constantBufferDescription.MiscFlags = 0;
1485         constantBufferDescription.StructureByteStride = 0;
1486
1487         HRESULT result = mDevice->CreateBuffer(&constantBufferDescription, NULL, &mDriverConstantBufferVS);
1488         UNUSED_ASSERTION_VARIABLE(result);
1489         ASSERT(SUCCEEDED(result));
1490
1491         mDeviceContext->VSSetConstantBuffers(1, 1, &mDriverConstantBufferVS);
1492     }
1493
1494     if (!mDriverConstantBufferPS)
1495     {
1496         D3D11_BUFFER_DESC constantBufferDescription = {0};
1497         constantBufferDescription.ByteWidth = sizeof(dx_PixelConstants);
1498         constantBufferDescription.Usage = D3D11_USAGE_DEFAULT;
1499         constantBufferDescription.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
1500         constantBufferDescription.CPUAccessFlags = 0;
1501         constantBufferDescription.MiscFlags = 0;
1502         constantBufferDescription.StructureByteStride = 0;
1503
1504         HRESULT result = mDevice->CreateBuffer(&constantBufferDescription, NULL, &mDriverConstantBufferPS);
1505         UNUSED_ASSERTION_VARIABLE(result);
1506         ASSERT(SUCCEEDED(result));
1507
1508         mDeviceContext->PSSetConstantBuffers(1, 1, &mDriverConstantBufferPS);
1509     }
1510
1511     if (memcmp(&mVertexConstants, &mAppliedVertexConstants, sizeof(dx_VertexConstants)) != 0)
1512     {
1513         mDeviceContext->UpdateSubresource(mDriverConstantBufferVS, 0, NULL, &mVertexConstants, 16, 0);
1514         memcpy(&mAppliedVertexConstants, &mVertexConstants, sizeof(dx_VertexConstants));
1515     }
1516
1517     if (memcmp(&mPixelConstants, &mAppliedPixelConstants, sizeof(dx_PixelConstants)) != 0)
1518     {
1519         mDeviceContext->UpdateSubresource(mDriverConstantBufferPS, 0, NULL, &mPixelConstants, 16, 0);
1520         memcpy(&mAppliedPixelConstants, &mPixelConstants, sizeof(dx_PixelConstants));
1521     }
1522
1523     // needed for the point sprite geometry shader
1524     if (mCurrentGeometryConstantBuffer != mDriverConstantBufferPS)
1525     {
1526         mDeviceContext->GSSetConstantBuffers(0, 1, &mDriverConstantBufferPS);
1527         mCurrentGeometryConstantBuffer = mDriverConstantBufferPS;
1528     }
1529 }
1530
1531 void Renderer11::clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer)
1532 {
1533     mClear->clearFramebuffer(clearParams, frameBuffer);
1534     invalidateFramebufferSwizzles(frameBuffer);
1535 }
1536
1537 void Renderer11::markAllStateDirty()
1538 {
1539     for (unsigned int rtIndex = 0; rtIndex < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; rtIndex++)
1540     {
1541         mAppliedRenderTargetSerials[rtIndex] = 0;
1542     }
1543     mAppliedDepthbufferSerial = 0;
1544     mAppliedStencilbufferSerial = 0;
1545     mDepthStencilInitialized = false;
1546     mRenderTargetDescInitialized = false;
1547
1548     for (int i = 0; i < gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS; i++)
1549     {
1550         mForceSetVertexSamplerStates[i] = true;
1551         mCurVertexSRVs[i] = NULL;
1552     }
1553     for (int i = 0; i < gl::MAX_TEXTURE_IMAGE_UNITS; i++)
1554     {
1555         mForceSetPixelSamplerStates[i] = true;
1556         mCurPixelSRVs[i] = NULL;
1557     }
1558
1559     mForceSetBlendState = true;
1560     mForceSetRasterState = true;
1561     mForceSetDepthStencilState = true;
1562     mForceSetScissor = true;
1563     mForceSetViewport = true;
1564
1565     mAppliedIB = NULL;
1566     mAppliedIBFormat = DXGI_FORMAT_UNKNOWN;
1567     mAppliedIBOffset = 0;
1568
1569     mAppliedVertexShader = NULL;
1570     mAppliedGeometryShader = NULL;
1571     mCurPointGeometryShader = NULL;
1572     mAppliedPixelShader = NULL;
1573
1574     for (size_t i = 0; i < gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
1575     {
1576         mAppliedTFBuffers[i] = NULL;
1577         mAppliedTFOffsets[i] = 0;
1578     }
1579
1580     memset(&mAppliedVertexConstants, 0, sizeof(dx_VertexConstants));
1581     memset(&mAppliedPixelConstants, 0, sizeof(dx_PixelConstants));
1582
1583     mInputLayoutCache.markDirty();
1584
1585     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS; i++)
1586     {
1587         mCurrentConstantBufferVS[i] = -1;
1588         mCurrentConstantBufferPS[i] = -1;
1589     }
1590
1591     mCurrentVertexConstantBuffer = NULL;
1592     mCurrentPixelConstantBuffer = NULL;
1593     mCurrentGeometryConstantBuffer = NULL;
1594
1595     mCurrentPrimitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
1596 }
1597
1598 void Renderer11::releaseDeviceResources()
1599 {
1600     mStateCache.clear();
1601     mInputLayoutCache.clear();
1602
1603     SafeDelete(mVertexDataManager);
1604     SafeDelete(mIndexDataManager);
1605     SafeDelete(mLineLoopIB);
1606     SafeDelete(mTriangleFanIB);
1607     SafeDelete(mBlit);
1608     SafeDelete(mClear);
1609     SafeDelete(mPixelTransfer);
1610
1611     SafeRelease(mDriverConstantBufferVS);
1612     SafeRelease(mDriverConstantBufferPS);
1613     SafeRelease(mSyncQuery);
1614 }
1615
1616 void Renderer11::notifyDeviceLost()
1617 {
1618     mDeviceLost = true;
1619     mDisplay->notifyDeviceLost();
1620 }
1621
1622 bool Renderer11::isDeviceLost()
1623 {
1624     return mDeviceLost;
1625 }
1626
1627 // set notify to true to broadcast a message to all contexts of the device loss
1628 bool Renderer11::testDeviceLost(bool notify)
1629 {
1630     bool isLost = false;
1631
1632     // GetRemovedReason is used to test if the device is removed
1633     HRESULT result = mDevice->GetDeviceRemovedReason();
1634     isLost = d3d11::isDeviceLostError(result);
1635
1636     if (isLost)
1637     {
1638         // Log error if this is a new device lost event
1639         if (mDeviceLost == false)
1640         {
1641             ERR("The D3D11 device was removed: 0x%08X", result);
1642         }
1643
1644         // ensure we note the device loss --
1645         // we'll probably get this done again by notifyDeviceLost
1646         // but best to remember it!
1647         // Note that we don't want to clear the device loss status here
1648         // -- this needs to be done by resetDevice
1649         mDeviceLost = true;
1650         if (notify)
1651         {
1652             notifyDeviceLost();
1653         }
1654     }
1655
1656     return isLost;
1657 }
1658
1659 bool Renderer11::testDeviceResettable()
1660 {
1661     // determine if the device is resettable by creating a dummy device
1662     PFN_D3D11_CREATE_DEVICE D3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE)GetProcAddress(mD3d11Module, "D3D11CreateDevice");
1663
1664     if (D3D11CreateDevice == NULL)
1665     {
1666         return false;
1667     }
1668
1669     D3D_FEATURE_LEVEL featureLevels[] =
1670     {
1671         D3D_FEATURE_LEVEL_11_0,
1672         D3D_FEATURE_LEVEL_10_1,
1673         D3D_FEATURE_LEVEL_10_0,
1674     };
1675
1676     ID3D11Device* dummyDevice;
1677     D3D_FEATURE_LEVEL dummyFeatureLevel;
1678     ID3D11DeviceContext* dummyContext;
1679
1680     HRESULT result = D3D11CreateDevice(NULL,
1681                                        D3D_DRIVER_TYPE_HARDWARE,
1682                                        NULL,
1683                                        #if defined(_DEBUG)
1684                                        D3D11_CREATE_DEVICE_DEBUG,
1685                                        #else
1686                                        0,
1687                                        #endif
1688                                        featureLevels,
1689                                        ArraySize(featureLevels),
1690                                        D3D11_SDK_VERSION,
1691                                        &dummyDevice,
1692                                        &dummyFeatureLevel,
1693                                        &dummyContext);
1694
1695     if (!mDevice || FAILED(result))
1696     {
1697         return false;
1698     }
1699
1700     SafeRelease(dummyContext);
1701     SafeRelease(dummyDevice);
1702
1703     return true;
1704 }
1705
1706 void Renderer11::release()
1707 {
1708     releaseDeviceResources();
1709
1710     SafeRelease(mDxgiFactory);
1711     SafeRelease(mDxgiAdapter);
1712
1713     if (mDeviceContext)
1714     {
1715         mDeviceContext->ClearState();
1716         mDeviceContext->Flush();
1717         SafeRelease(mDeviceContext);
1718     }
1719
1720     SafeRelease(mDevice);
1721
1722     if (mD3d11Module)
1723     {
1724         FreeLibrary(mD3d11Module);
1725         mD3d11Module = NULL;
1726     }
1727
1728     if (mDxgiModule)
1729     {
1730         FreeLibrary(mDxgiModule);
1731         mDxgiModule = NULL;
1732     }
1733
1734     mCompiler.release();
1735 }
1736
1737 bool Renderer11::resetDevice()
1738 {
1739     // recreate everything
1740     release();
1741     EGLint result = initialize();
1742
1743     if (result != EGL_SUCCESS)
1744     {
1745         ERR("Could not reinitialize D3D11 device: %08X", result);
1746         return false;
1747     }
1748
1749     mDeviceLost = false;
1750
1751     return true;
1752 }
1753
1754 DWORD Renderer11::getAdapterVendor() const
1755 {
1756     return mAdapterDescription.VendorId;
1757 }
1758
1759 std::string Renderer11::getRendererDescription() const
1760 {
1761     std::ostringstream rendererString;
1762
1763     rendererString << mDescription;
1764     rendererString << " Direct3D11";
1765
1766     rendererString << " vs_" << getMajorShaderModel() << "_" << getMinorShaderModel();
1767     rendererString << " ps_" << getMajorShaderModel() << "_" << getMinorShaderModel();
1768
1769     return rendererString.str();
1770 }
1771
1772 GUID Renderer11::getAdapterIdentifier() const
1773 {
1774     // Use the adapter LUID as our adapter ID
1775     // This number is local to a machine is only guaranteed to be unique between restarts
1776     META_ASSERT(sizeof(LUID) <= sizeof(GUID));
1777     GUID adapterId = {0};
1778     memcpy(&adapterId, &mAdapterDescription.AdapterLuid, sizeof(LUID));
1779     return adapterId;
1780 }
1781
1782 unsigned int Renderer11::getMaxVertexTextureImageUnits() const
1783 {
1784     META_ASSERT(MAX_TEXTURE_IMAGE_UNITS_VTF_SM4 <= gl::IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
1785     switch (mFeatureLevel)
1786     {
1787       case D3D_FEATURE_LEVEL_11_0:
1788       case D3D_FEATURE_LEVEL_10_1:
1789       case D3D_FEATURE_LEVEL_10_0:
1790         return MAX_TEXTURE_IMAGE_UNITS_VTF_SM4;
1791       default: UNREACHABLE();
1792         return 0;
1793     }
1794 }
1795
1796 unsigned int Renderer11::getMaxCombinedTextureImageUnits() const
1797 {
1798     return gl::MAX_TEXTURE_IMAGE_UNITS + getMaxVertexTextureImageUnits();
1799 }
1800
1801 unsigned int Renderer11::getReservedVertexUniformVectors() const
1802 {
1803     return 0;   // Driver uniforms are stored in a separate constant buffer
1804 }
1805
1806 unsigned int Renderer11::getReservedFragmentUniformVectors() const
1807 {
1808     return 0;   // Driver uniforms are stored in a separate constant buffer
1809 }
1810
1811 unsigned int Renderer11::getMaxVertexUniformVectors() const
1812 {
1813     META_ASSERT(MAX_VERTEX_UNIFORM_VECTORS_D3D11 <= D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT);
1814     ASSERT(mFeatureLevel >= D3D_FEATURE_LEVEL_10_0);
1815     return MAX_VERTEX_UNIFORM_VECTORS_D3D11;
1816 }
1817
1818 unsigned int Renderer11::getMaxFragmentUniformVectors() const
1819 {
1820     META_ASSERT(MAX_FRAGMENT_UNIFORM_VECTORS_D3D11 <= D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT);
1821     ASSERT(mFeatureLevel >= D3D_FEATURE_LEVEL_10_0);
1822     return MAX_FRAGMENT_UNIFORM_VECTORS_D3D11;
1823 }
1824
1825 unsigned int Renderer11::getMaxVaryingVectors() const
1826 {
1827     META_ASSERT(gl::IMPLEMENTATION_MAX_VARYING_VECTORS == D3D11_VS_OUTPUT_REGISTER_COUNT);
1828     META_ASSERT(D3D11_VS_OUTPUT_REGISTER_COUNT <= D3D11_PS_INPUT_REGISTER_COUNT);
1829     META_ASSERT(D3D10_VS_OUTPUT_REGISTER_COUNT <= D3D10_PS_INPUT_REGISTER_COUNT);
1830     switch (mFeatureLevel)
1831     {
1832       case D3D_FEATURE_LEVEL_11_0:
1833         return D3D11_VS_OUTPUT_REGISTER_COUNT - getReservedVaryings();
1834       case D3D_FEATURE_LEVEL_10_1:
1835         return D3D10_1_VS_OUTPUT_REGISTER_COUNT - getReservedVaryings();
1836       case D3D_FEATURE_LEVEL_10_0:
1837         return D3D10_VS_OUTPUT_REGISTER_COUNT - getReservedVaryings();
1838       default: UNREACHABLE();
1839         return 0;
1840     }
1841 }
1842
1843 unsigned int Renderer11::getMaxVertexShaderUniformBuffers() const
1844 {
1845     META_ASSERT(gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS >= D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT &&
1846                 gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS >= D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT);
1847
1848     switch (mFeatureLevel)
1849     {
1850       case D3D_FEATURE_LEVEL_11_0:
1851         return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - getReservedVertexUniformBuffers();
1852       case D3D_FEATURE_LEVEL_10_1:
1853       case D3D_FEATURE_LEVEL_10_0:
1854         return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - getReservedVertexUniformBuffers();
1855       default: UNREACHABLE();
1856         return 0;
1857     }
1858 }
1859
1860 unsigned int Renderer11::getMaxFragmentShaderUniformBuffers() const
1861 {
1862     META_ASSERT(gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS >= D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT &&
1863                 gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS >= D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT);
1864
1865     switch (mFeatureLevel)
1866     {
1867       case D3D_FEATURE_LEVEL_11_0:
1868         return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - getReservedFragmentUniformBuffers();
1869       case D3D_FEATURE_LEVEL_10_1:
1870       case D3D_FEATURE_LEVEL_10_0:
1871         return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - getReservedFragmentUniformBuffers();
1872       default: UNREACHABLE();
1873         return 0;
1874     }
1875 }
1876
1877 unsigned int Renderer11::getReservedVertexUniformBuffers() const
1878 {
1879     // we reserve one buffer for the application uniforms, and one for driver uniforms
1880     return 2;
1881 }
1882
1883 unsigned int Renderer11::getReservedFragmentUniformBuffers() const
1884 {
1885     // we reserve one buffer for the application uniforms, and one for driver uniforms
1886     return 2;
1887 }
1888
1889 unsigned int Renderer11::getReservedVaryings() const
1890 {
1891     // We potentially reserve varyings for gl_Position, dx_Position, gl_FragCoord and gl_PointSize
1892     return 4;
1893 }
1894
1895
1896 unsigned int Renderer11::getMaxTransformFeedbackBuffers() const
1897 {
1898     META_ASSERT(gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS >= D3D11_SO_BUFFER_SLOT_COUNT &&
1899                 gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS >= D3D10_SO_BUFFER_SLOT_COUNT);
1900
1901     switch (mFeatureLevel)
1902     {
1903       case D3D_FEATURE_LEVEL_11_0:
1904         return D3D11_SO_BUFFER_SLOT_COUNT;
1905       case D3D_FEATURE_LEVEL_10_1:
1906         return D3D10_1_SO_BUFFER_SLOT_COUNT;
1907       case D3D_FEATURE_LEVEL_10_0:
1908         return D3D10_SO_BUFFER_SLOT_COUNT;
1909       default: UNREACHABLE();
1910         return 0;
1911     }
1912 }
1913
1914 unsigned int Renderer11::getMaxTransformFeedbackSeparateComponents() const
1915 {
1916     switch (mFeatureLevel)
1917     {
1918       case D3D_FEATURE_LEVEL_11_0:
1919         return getMaxTransformFeedbackInterleavedComponents() / getMaxTransformFeedbackBuffers();
1920       case D3D_FEATURE_LEVEL_10_1:
1921       case D3D_FEATURE_LEVEL_10_0:
1922         // D3D 10 and 10.1 only allow one output per output slot if an output slot other than zero
1923         // is used.
1924         return 4;
1925       default: UNREACHABLE();
1926         return 0;
1927     }
1928 }
1929
1930 unsigned int Renderer11::getMaxTransformFeedbackInterleavedComponents() const
1931 {
1932     return (getMaxVaryingVectors() * 4);
1933 }
1934
1935 unsigned int Renderer11::getMaxUniformBufferSize() const
1936 {
1937     // Each component is a 4-element vector of 4-byte units (floats)
1938     const unsigned int bytesPerComponent = 4 * sizeof(float);
1939
1940     switch (mFeatureLevel)
1941     {
1942       case D3D_FEATURE_LEVEL_11_0:
1943         return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent;
1944       case D3D_FEATURE_LEVEL_10_1:
1945       case D3D_FEATURE_LEVEL_10_0:
1946         return D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent;
1947       default: UNREACHABLE();
1948         return 0;
1949     }
1950 }
1951
1952 bool Renderer11::getShareHandleSupport() const
1953 {
1954     // We only currently support share handles with BGRA surfaces, because
1955     // chrome needs BGRA. Once chrome fixes this, we should always support them.
1956     // PIX doesn't seem to support using share handles, so disable them.
1957     return getRendererExtensions().textureFormatBGRA8888 && !gl::perfActive();
1958 }
1959
1960 bool Renderer11::getPostSubBufferSupport() const
1961 {
1962     // D3D11 does not support present with dirty rectangles until D3D11.1 and DXGI 1.2.
1963     return false;
1964 }
1965
1966 int Renderer11::getMaxRecommendedElementsIndices() const
1967 {
1968     META_ASSERT(D3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP == 32);
1969     META_ASSERT(D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP == 32);
1970
1971     // D3D11 allows up to 2^32 elements, but we report max signed int for convenience.
1972     return std::numeric_limits<GLint>::max();
1973 }
1974
1975 int Renderer11::getMaxRecommendedElementsVertices() const
1976 {
1977     META_ASSERT(D3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXP == 32);
1978     META_ASSERT(D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP == 32);
1979
1980     // D3D11 allows up to 2^32 elements, but we report max signed int for convenience.
1981     return std::numeric_limits<GLint>::max();
1982 }
1983
1984 int Renderer11::getMajorShaderModel() const
1985 {
1986     switch (mFeatureLevel)
1987     {
1988       case D3D_FEATURE_LEVEL_11_0: return D3D11_SHADER_MAJOR_VERSION;   // 5
1989       case D3D_FEATURE_LEVEL_10_1: return D3D10_1_SHADER_MAJOR_VERSION; // 4
1990       case D3D_FEATURE_LEVEL_10_0: return D3D10_SHADER_MAJOR_VERSION;   // 4
1991       default: UNREACHABLE();      return 0;
1992     }
1993 }
1994
1995 int Renderer11::getMinorShaderModel() const
1996 {
1997     switch (mFeatureLevel)
1998     {
1999       case D3D_FEATURE_LEVEL_11_0: return D3D11_SHADER_MINOR_VERSION;   // 0
2000       case D3D_FEATURE_LEVEL_10_1: return D3D10_1_SHADER_MINOR_VERSION; // 1
2001       case D3D_FEATURE_LEVEL_10_0: return D3D10_SHADER_MINOR_VERSION;   // 0
2002       default: UNREACHABLE();      return 0;
2003     }
2004 }
2005
2006 int Renderer11::getMinSwapInterval() const
2007 {
2008     return 0;
2009 }
2010
2011 int Renderer11::getMaxSwapInterval() const
2012 {
2013     return 4;
2014 }
2015
2016 bool Renderer11::copyToRenderTarget(TextureStorageInterface2D *dest, TextureStorageInterface2D *source)
2017 {
2018     if (source && dest)
2019     {
2020         TextureStorage11_2D *source11 = TextureStorage11_2D::makeTextureStorage11_2D(source->getStorageInstance());
2021         TextureStorage11_2D *dest11 = TextureStorage11_2D::makeTextureStorage11_2D(dest->getStorageInstance());
2022
2023         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
2024
2025         dest11->invalidateSwizzleCache();
2026
2027         return true;
2028     }
2029
2030     return false;
2031 }
2032
2033 bool Renderer11::copyToRenderTarget(TextureStorageInterfaceCube *dest, TextureStorageInterfaceCube *source)
2034 {
2035     if (source && dest)
2036     {
2037         TextureStorage11_Cube *source11 = TextureStorage11_Cube::makeTextureStorage11_Cube(source->getStorageInstance());
2038         TextureStorage11_Cube *dest11 = TextureStorage11_Cube::makeTextureStorage11_Cube(dest->getStorageInstance());
2039
2040         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
2041
2042         dest11->invalidateSwizzleCache();
2043
2044         return true;
2045     }
2046
2047     return false;
2048 }
2049
2050 bool Renderer11::copyToRenderTarget(TextureStorageInterface3D *dest, TextureStorageInterface3D *source)
2051 {
2052     if (source && dest)
2053     {
2054         TextureStorage11_3D *source11 = TextureStorage11_3D::makeTextureStorage11_3D(source->getStorageInstance());
2055         TextureStorage11_3D *dest11 = TextureStorage11_3D::makeTextureStorage11_3D(dest->getStorageInstance());
2056
2057         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
2058
2059         dest11->invalidateSwizzleCache();
2060
2061         return true;
2062     }
2063
2064     return false;
2065 }
2066
2067 bool Renderer11::copyToRenderTarget(TextureStorageInterface2DArray *dest, TextureStorageInterface2DArray *source)
2068 {
2069     if (source && dest)
2070     {
2071         TextureStorage11_2DArray *source11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(source->getStorageInstance());
2072         TextureStorage11_2DArray *dest11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(dest->getStorageInstance());
2073
2074         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
2075
2076         dest11->invalidateSwizzleCache();
2077
2078         return true;
2079     }
2080
2081     return false;
2082 }
2083
2084 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
2085                            GLint xoffset, GLint yoffset, TextureStorageInterface2D *storage, GLint level)
2086 {
2087     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
2088     if (!colorbuffer)
2089     {
2090         ERR("Failed to retrieve the color buffer from the frame buffer.");
2091         return gl::error(GL_OUT_OF_MEMORY, false);
2092     }
2093
2094     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
2095     if (!sourceRenderTarget)
2096     {
2097         ERR("Failed to retrieve the render target from the frame buffer.");
2098         return gl::error(GL_OUT_OF_MEMORY, false);
2099     }
2100
2101     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
2102     if (!source)
2103     {
2104         ERR("Failed to retrieve the render target view from the render target.");
2105         return gl::error(GL_OUT_OF_MEMORY, false);
2106     }
2107
2108     TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage->getStorageInstance());
2109     if (!storage11)
2110     {
2111         ERR("Failed to retrieve the texture storage from the destination.");
2112         return gl::error(GL_OUT_OF_MEMORY, false);
2113     }
2114
2115     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(level));
2116     if (!destRenderTarget)
2117     {
2118         ERR("Failed to retrieve the render target from the destination storage.");
2119         return gl::error(GL_OUT_OF_MEMORY, false);
2120     }
2121
2122     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
2123     if (!dest)
2124     {
2125         ERR("Failed to retrieve the render target view from the destination render target.");
2126         return gl::error(GL_OUT_OF_MEMORY, false);
2127     }
2128
2129     gl::Box sourceArea(sourceRect.x, sourceRect.y, 0, sourceRect.width, sourceRect.height, 1);
2130     gl::Extents sourceSize(sourceRenderTarget->getWidth(), sourceRenderTarget->getHeight(), 1);
2131
2132     gl::Box destArea(xoffset, yoffset, 0, sourceRect.width, sourceRect.height, 1);
2133     gl::Extents destSize(destRenderTarget->getWidth(), destRenderTarget->getHeight(), 1);
2134
2135     // Use nearest filtering because source and destination are the same size for the direct
2136     // copy
2137     bool ret = mBlit->copyTexture(source, sourceArea, sourceSize, dest, destArea, destSize, NULL,
2138                                   destFormat, GL_NEAREST);
2139
2140     storage11->invalidateSwizzleCacheLevel(level);
2141
2142     return ret;
2143 }
2144
2145 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
2146                            GLint xoffset, GLint yoffset, TextureStorageInterfaceCube *storage, GLenum target, GLint level)
2147 {
2148     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
2149     if (!colorbuffer)
2150     {
2151         ERR("Failed to retrieve the color buffer from the frame buffer.");
2152         return gl::error(GL_OUT_OF_MEMORY, false);
2153     }
2154
2155     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
2156     if (!sourceRenderTarget)
2157     {
2158         ERR("Failed to retrieve the render target from the frame buffer.");
2159         return gl::error(GL_OUT_OF_MEMORY, false);
2160     }
2161
2162     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
2163     if (!source)
2164     {
2165         ERR("Failed to retrieve the render target view from the render target.");
2166         return gl::error(GL_OUT_OF_MEMORY, false);
2167     }
2168
2169     TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage->getStorageInstance());
2170     if (!storage11)
2171     {
2172         ERR("Failed to retrieve the texture storage from the destination.");
2173         return gl::error(GL_OUT_OF_MEMORY, false);
2174     }
2175
2176     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTargetFace(target, level));
2177     if (!destRenderTarget)
2178     {
2179         ERR("Failed to retrieve the render target from the destination storage.");
2180         return gl::error(GL_OUT_OF_MEMORY, false);
2181     }
2182
2183     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
2184     if (!dest)
2185     {
2186         ERR("Failed to retrieve the render target view from the destination render target.");
2187         return gl::error(GL_OUT_OF_MEMORY, false);
2188     }
2189
2190     gl::Box sourceArea(sourceRect.x, sourceRect.y, 0, sourceRect.width, sourceRect.height, 1);
2191     gl::Extents sourceSize(sourceRenderTarget->getWidth(), sourceRenderTarget->getHeight(), 1);
2192
2193     gl::Box destArea(xoffset, yoffset, 0, sourceRect.width, sourceRect.height, 1);
2194     gl::Extents destSize(destRenderTarget->getWidth(), destRenderTarget->getHeight(), 1);
2195
2196     // Use nearest filtering because source and destination are the same size for the direct
2197     // copy
2198     bool ret = mBlit->copyTexture(source, sourceArea, sourceSize, dest, destArea, destSize, NULL,
2199                                   destFormat, GL_NEAREST);
2200
2201     storage11->invalidateSwizzleCacheLevel(level);
2202
2203     return ret;
2204 }
2205
2206 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
2207                            GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface3D *storage, GLint level)
2208 {
2209     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
2210     if (!colorbuffer)
2211     {
2212         ERR("Failed to retrieve the color buffer from the frame buffer.");
2213         return gl::error(GL_OUT_OF_MEMORY, false);
2214     }
2215
2216     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
2217     if (!sourceRenderTarget)
2218     {
2219         ERR("Failed to retrieve the render target from the frame buffer.");
2220         return gl::error(GL_OUT_OF_MEMORY, false);
2221     }
2222
2223     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
2224     if (!source)
2225     {
2226         ERR("Failed to retrieve the render target view from the render target.");
2227         return gl::error(GL_OUT_OF_MEMORY, false);
2228     }
2229
2230     TextureStorage11_3D *storage11 = TextureStorage11_3D::makeTextureStorage11_3D(storage->getStorageInstance());
2231     if (!storage11)
2232     {
2233         ERR("Failed to retrieve the texture storage from the destination.");
2234         return gl::error(GL_OUT_OF_MEMORY, false);
2235     }
2236
2237     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTargetLayer(level, zOffset));
2238     if (!destRenderTarget)
2239     {
2240         ERR("Failed to retrieve the render target from the destination storage.");
2241         return gl::error(GL_OUT_OF_MEMORY, false);
2242     }
2243
2244     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
2245     if (!dest)
2246     {
2247         ERR("Failed to retrieve the render target view from the destination render target.");
2248         return gl::error(GL_OUT_OF_MEMORY, false);
2249     }
2250
2251     gl::Box sourceArea(sourceRect.x, sourceRect.y, 0, sourceRect.width, sourceRect.height, 1);
2252     gl::Extents sourceSize(sourceRenderTarget->getWidth(), sourceRenderTarget->getHeight(), 1);
2253
2254     gl::Box destArea(xoffset, yoffset, 0, sourceRect.width, sourceRect.height, 1);
2255     gl::Extents destSize(destRenderTarget->getWidth(), destRenderTarget->getHeight(), 1);
2256
2257     // Use nearest filtering because source and destination are the same size for the direct
2258     // copy
2259     bool ret = mBlit->copyTexture(source, sourceArea, sourceSize, dest, destArea, destSize, NULL,
2260                                   destFormat, GL_NEAREST);
2261
2262     storage11->invalidateSwizzleCacheLevel(level);
2263
2264     return ret;
2265 }
2266
2267 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
2268                            GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface2DArray *storage, GLint level)
2269 {
2270     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
2271     if (!colorbuffer)
2272     {
2273         ERR("Failed to retrieve the color buffer from the frame buffer.");
2274         return gl::error(GL_OUT_OF_MEMORY, false);
2275     }
2276
2277     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
2278     if (!sourceRenderTarget)
2279     {
2280         ERR("Failed to retrieve the render target from the frame buffer.");
2281         return gl::error(GL_OUT_OF_MEMORY, false);
2282     }
2283
2284     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
2285     if (!source)
2286     {
2287         ERR("Failed to retrieve the render target view from the render target.");
2288         return gl::error(GL_OUT_OF_MEMORY, false);
2289     }
2290
2291     TextureStorage11_2DArray *storage11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(storage->getStorageInstance());
2292     if (!storage11)
2293     {
2294         SafeRelease(source);
2295         ERR("Failed to retrieve the texture storage from the destination.");
2296         return gl::error(GL_OUT_OF_MEMORY, false);
2297     }
2298
2299     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTargetLayer(level, zOffset));
2300     if (!destRenderTarget)
2301     {
2302         SafeRelease(source);
2303         ERR("Failed to retrieve the render target from the destination storage.");
2304         return gl::error(GL_OUT_OF_MEMORY, false);
2305     }
2306
2307     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
2308     if (!dest)
2309     {
2310         ERR("Failed to retrieve the render target view from the destination render target.");
2311         return gl::error(GL_OUT_OF_MEMORY, false);
2312     }
2313
2314     gl::Box sourceArea(sourceRect.x, sourceRect.y, 0, sourceRect.width, sourceRect.height, 1);
2315     gl::Extents sourceSize(sourceRenderTarget->getWidth(), sourceRenderTarget->getHeight(), 1);
2316
2317     gl::Box destArea(xoffset, yoffset, 0, sourceRect.width, sourceRect.height, 1);
2318     gl::Extents destSize(destRenderTarget->getWidth(), destRenderTarget->getHeight(), 1);
2319
2320     // Use nearest filtering because source and destination are the same size for the direct
2321     // copy
2322     bool ret = mBlit->copyTexture(source, sourceArea, sourceSize, dest, destArea, destSize, NULL,
2323                                   destFormat, GL_NEAREST);
2324
2325     storage11->invalidateSwizzleCacheLevel(level);
2326
2327     return ret;
2328 }
2329
2330 void Renderer11::unapplyRenderTargets()
2331 {
2332     setOneTimeRenderTarget(NULL);
2333 }
2334
2335 void Renderer11::setOneTimeRenderTarget(ID3D11RenderTargetView *renderTargetView)
2336 {
2337     ID3D11RenderTargetView *rtvArray[gl::IMPLEMENTATION_MAX_DRAW_BUFFERS] = {NULL};
2338
2339     rtvArray[0] = renderTargetView;
2340
2341     mDeviceContext->OMSetRenderTargets(getRendererCaps().maxDrawBuffers, rtvArray, NULL);
2342
2343     // Do not preserve the serial for this one-time-use render target
2344     for (unsigned int rtIndex = 0; rtIndex < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; rtIndex++)
2345     {
2346         mAppliedRenderTargetSerials[rtIndex] = 0;
2347     }
2348 }
2349
2350 RenderTarget *Renderer11::createRenderTarget(SwapChain *swapChain, bool depth)
2351 {
2352     SwapChain11 *swapChain11 = SwapChain11::makeSwapChain11(swapChain);
2353     RenderTarget11 *renderTarget = NULL;
2354
2355     if (depth)
2356     {
2357         // Note: depth stencil may be NULL for 0 sized surfaces
2358         renderTarget = new RenderTarget11(this, swapChain11->getDepthStencil(),
2359                                           swapChain11->getDepthStencilTexture(),
2360                                           swapChain11->getDepthStencilShaderResource(),
2361                                           swapChain11->getWidth(), swapChain11->getHeight(), 1);
2362     }
2363     else
2364     {
2365         // Note: render target may be NULL for 0 sized surfaces
2366         renderTarget = new RenderTarget11(this, swapChain11->getRenderTarget(),
2367                                           swapChain11->getOffscreenTexture(),
2368                                           swapChain11->getRenderTargetShaderResource(),
2369                                           swapChain11->getWidth(), swapChain11->getHeight(), 1);
2370     }
2371     return renderTarget;
2372 }
2373
2374 RenderTarget *Renderer11::createRenderTarget(int width, int height, GLenum format, GLsizei samples)
2375 {
2376     RenderTarget11 *renderTarget = new RenderTarget11(this, width, height, format, samples);
2377     return renderTarget;
2378 }
2379
2380 ShaderExecutable *Renderer11::loadExecutable(const void *function, size_t length, rx::ShaderType type,
2381                                              const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
2382                                              bool separatedOutputBuffers)
2383 {
2384     ShaderExecutable11 *executable = NULL;
2385     HRESULT result;
2386
2387     switch (type)
2388     {
2389       case rx::SHADER_VERTEX:
2390         {
2391             ID3D11VertexShader *vertexShader = NULL;
2392             ID3D11GeometryShader *streamOutShader = NULL;
2393
2394             result = mDevice->CreateVertexShader(function, length, NULL, &vertexShader);
2395             ASSERT(SUCCEEDED(result));
2396
2397             if (transformFeedbackVaryings.size() > 0)
2398             {
2399                 std::vector<D3D11_SO_DECLARATION_ENTRY> soDeclaration;
2400                 for (size_t i = 0; i < transformFeedbackVaryings.size(); i++)
2401                 {
2402                     const gl::LinkedVarying &varying = transformFeedbackVaryings[i];
2403                     GLenum transposedType = gl::TransposeMatrixType(varying.type);
2404
2405                     for (size_t j = 0; j < varying.semanticIndexCount; j++)
2406                     {
2407                         D3D11_SO_DECLARATION_ENTRY entry = { 0 };
2408                         entry.Stream = 0;
2409                         entry.SemanticName = varying.semanticName.c_str();
2410                         entry.SemanticIndex = varying.semanticIndex + j;
2411                         entry.StartComponent = 0;
2412                         entry.ComponentCount = gl::VariableColumnCount(transposedType);
2413                         entry.OutputSlot = (separatedOutputBuffers ? i : 0);
2414                         soDeclaration.push_back(entry);
2415                     }
2416                 }
2417
2418                 result = mDevice->CreateGeometryShaderWithStreamOutput(function, length, soDeclaration.data(), soDeclaration.size(),
2419                                                                        NULL, 0, 0, NULL, &streamOutShader);
2420                 ASSERT(SUCCEEDED(result));
2421             }
2422
2423             if (vertexShader)
2424             {
2425                 executable = new ShaderExecutable11(function, length, vertexShader, streamOutShader);
2426             }
2427         }
2428         break;
2429       case rx::SHADER_PIXEL:
2430         {
2431             ID3D11PixelShader *pixelShader = NULL;
2432
2433             result = mDevice->CreatePixelShader(function, length, NULL, &pixelShader);
2434             ASSERT(SUCCEEDED(result));
2435
2436             if (pixelShader)
2437             {
2438                 executable = new ShaderExecutable11(function, length, pixelShader);
2439             }
2440         }
2441         break;
2442       case rx::SHADER_GEOMETRY:
2443         {
2444             ID3D11GeometryShader *geometryShader = NULL;
2445
2446             result = mDevice->CreateGeometryShader(function, length, NULL, &geometryShader);
2447             ASSERT(SUCCEEDED(result));
2448
2449             if (geometryShader)
2450             {
2451                 executable = new ShaderExecutable11(function, length, geometryShader);
2452             }
2453         }
2454         break;
2455       default:
2456         UNREACHABLE();
2457         break;
2458     }
2459
2460     return executable;
2461 }
2462
2463 ShaderExecutable *Renderer11::compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, rx::ShaderType type,
2464                                                   const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
2465                                                   bool separatedOutputBuffers, D3DWorkaroundType workaround)
2466 {
2467     const char *profileType = NULL;
2468     switch (type)
2469     {
2470       case rx::SHADER_VERTEX:
2471         profileType = "vs";
2472         break;
2473       case rx::SHADER_PIXEL:
2474         profileType = "ps";
2475         break;
2476       case rx::SHADER_GEOMETRY:
2477         profileType = "gs";
2478         break;
2479       default:
2480         UNREACHABLE();
2481         return NULL;
2482     }
2483
2484     const char *profileVersion = NULL;
2485     switch (mFeatureLevel)
2486     {
2487       case D3D_FEATURE_LEVEL_11_0:
2488         profileVersion = "5_0";
2489         break;
2490       case D3D_FEATURE_LEVEL_10_1:
2491         profileVersion = "4_1";
2492         break;
2493       case D3D_FEATURE_LEVEL_10_0:
2494         profileVersion = "4_0";
2495         break;
2496       default:
2497         UNREACHABLE();
2498         return NULL;
2499     }
2500
2501     char profile[32];
2502     snprintf(profile, ArraySize(profile), "%s_%s", profileType, profileVersion);
2503
2504     UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL0;
2505
2506     if (gl::perfActive())
2507     {
2508 #ifndef NDEBUG
2509         flags = D3DCOMPILE_SKIP_OPTIMIZATION;
2510 #endif
2511
2512         flags |= D3DCOMPILE_DEBUG;
2513
2514         std::string sourcePath = getTempPath();
2515         std::string sourceText = std::string("#line 2 \"") + sourcePath + std::string("\"\n\n") + std::string(shaderHLSL);
2516         writeFile(sourcePath.c_str(), sourceText.c_str(), sourceText.size());
2517     }
2518
2519     // Sometimes D3DCompile will fail with the default compilation flags for complicated shaders when it would otherwise pass with alternative options.
2520     // Try the default flags first and if compilation fails, try some alternatives.
2521     const UINT extraFlags[] =
2522     {
2523         flags,
2524         flags | D3DCOMPILE_SKIP_VALIDATION,
2525         flags | D3DCOMPILE_SKIP_OPTIMIZATION
2526     };
2527
2528     const static char *extraFlagNames[] =
2529     {
2530         "default",
2531         "skip validation",
2532         "skip optimization"
2533     };
2534
2535     int attempts = ArraySize(extraFlags);
2536
2537     ID3DBlob *binary = (ID3DBlob*)mCompiler.compileToBinary(infoLog, shaderHLSL, profile, extraFlags, extraFlagNames, attempts);
2538     if (!binary)
2539     {
2540         return NULL;
2541     }
2542
2543     ShaderExecutable *executable = loadExecutable((DWORD *)binary->GetBufferPointer(), binary->GetBufferSize(), type,
2544                                                   transformFeedbackVaryings, separatedOutputBuffers);
2545     SafeRelease(binary);
2546
2547     return executable;
2548 }
2549
2550 rx::UniformStorage *Renderer11::createUniformStorage(size_t storageSize)
2551 {
2552     return new UniformStorage11(this, storageSize);
2553 }
2554
2555 VertexBuffer *Renderer11::createVertexBuffer()
2556 {
2557     return new VertexBuffer11(this);
2558 }
2559
2560 IndexBuffer *Renderer11::createIndexBuffer()
2561 {
2562     return new IndexBuffer11(this);
2563 }
2564
2565 BufferImpl *Renderer11::createBuffer()
2566 {
2567     return new Buffer11(this);
2568 }
2569
2570 VertexArrayImpl *Renderer11::createVertexArray()
2571 {
2572     return new VertexArray11(this);
2573 }
2574
2575 QueryImpl *Renderer11::createQuery(GLenum type)
2576 {
2577     return new Query11(this, type);
2578 }
2579
2580 FenceImpl *Renderer11::createFence()
2581 {
2582     return new Fence11(this);
2583 }
2584
2585 bool Renderer11::supportsFastCopyBufferToTexture(GLenum internalFormat) const
2586 {
2587     ASSERT(getRendererExtensions().pixelBufferObject);
2588
2589     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat);
2590     const d3d11::TextureFormat &d3d11FormatInfo = d3d11::GetTextureFormatInfo(internalFormat);
2591     const d3d11::DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(d3d11FormatInfo.texFormat);
2592
2593     // sRGB formats do not work with D3D11 buffer SRVs
2594     if (internalFormatInfo.colorEncoding == GL_SRGB)
2595     {
2596         return false;
2597     }
2598
2599     // We cannot support direct copies to non-color-renderable formats
2600     if (d3d11FormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN)
2601     {
2602         return false;
2603     }
2604
2605     // We skip all 3-channel formats since sometimes format support is missing
2606     if (internalFormatInfo.componentCount == 3)
2607     {
2608         return false;
2609     }
2610
2611     // We don't support formats which we can't represent without conversion
2612     if (dxgiFormatInfo.internalFormat != internalFormat)
2613     {
2614         return false;
2615     }
2616
2617     return true;
2618 }
2619
2620 bool Renderer11::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTarget *destRenderTarget,
2621                                          GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea)
2622 {
2623     ASSERT(supportsFastCopyBufferToTexture(destinationFormat));
2624     return mPixelTransfer->copyBufferToTexture(unpack, offset, destRenderTarget, destinationFormat, sourcePixelsType, destArea);
2625 }
2626
2627 bool Renderer11::getRenderTargetResource(gl::FramebufferAttachment *colorbuffer, unsigned int *subresourceIndex, ID3D11Texture2D **resource)
2628 {
2629     ASSERT(colorbuffer != NULL);
2630
2631     RenderTarget11 *renderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
2632     if (renderTarget)
2633     {
2634         *subresourceIndex = renderTarget->getSubresourceIndex();
2635
2636         ID3D11RenderTargetView *colorBufferRTV = renderTarget->getRenderTargetView();
2637         if (colorBufferRTV)
2638         {
2639             ID3D11Resource *textureResource = NULL;
2640             colorBufferRTV->GetResource(&textureResource);
2641
2642             if (textureResource)
2643             {
2644                 HRESULT result = textureResource->QueryInterface(__uuidof(ID3D11Texture2D), (void**)resource);
2645                 SafeRelease(textureResource);
2646
2647                 if (SUCCEEDED(result))
2648                 {
2649                     return true;
2650                 }
2651                 else
2652                 {
2653                     ERR("Failed to extract the ID3D11Texture2D from the render target resource, "
2654                         "HRESULT: 0x%X.", result);
2655                 }
2656             }
2657         }
2658     }
2659
2660     return false;
2661 }
2662
2663 bool Renderer11::blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
2664                           const gl::Rectangle *scissor, bool blitRenderTarget, bool blitDepth, bool blitStencil, GLenum filter)
2665 {
2666     if (blitRenderTarget)
2667     {
2668         gl::FramebufferAttachment *readBuffer = readTarget->getReadColorbuffer();
2669
2670         if (!readBuffer)
2671         {
2672             ERR("Failed to retrieve the read buffer from the read framebuffer.");
2673             return gl::error(GL_OUT_OF_MEMORY, false);
2674         }
2675
2676         RenderTarget *readRenderTarget = readBuffer->getRenderTarget();
2677
2678         for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
2679         {
2680             if (drawTarget->isEnabledColorAttachment(colorAttachment))
2681             {
2682                 gl::FramebufferAttachment *drawBuffer = drawTarget->getColorbuffer(colorAttachment);
2683
2684                 if (!drawBuffer)
2685                 {
2686                     ERR("Failed to retrieve the draw buffer from the draw framebuffer.");
2687                     return gl::error(GL_OUT_OF_MEMORY, false);
2688                 }
2689
2690                 RenderTarget *drawRenderTarget = drawBuffer->getRenderTarget();
2691
2692                 if (!blitRenderbufferRect(readRect, drawRect, readRenderTarget, drawRenderTarget, filter, scissor,
2693                                           blitRenderTarget, false, false))
2694                 {
2695                     return false;
2696                 }
2697             }
2698         }
2699     }
2700
2701     if (blitDepth || blitStencil)
2702     {
2703         gl::FramebufferAttachment *readBuffer = readTarget->getDepthOrStencilbuffer();
2704         gl::FramebufferAttachment *drawBuffer = drawTarget->getDepthOrStencilbuffer();
2705
2706         if (!readBuffer)
2707         {
2708             ERR("Failed to retrieve the read depth-stencil buffer from the read framebuffer.");
2709             return gl::error(GL_OUT_OF_MEMORY, false);
2710         }
2711
2712         if (!drawBuffer)
2713         {
2714             ERR("Failed to retrieve the draw depth-stencil buffer from the draw framebuffer.");
2715             return gl::error(GL_OUT_OF_MEMORY, false);
2716         }
2717
2718         RenderTarget *readRenderTarget = readBuffer->getDepthStencil();
2719         RenderTarget *drawRenderTarget = drawBuffer->getDepthStencil();
2720
2721         if (!blitRenderbufferRect(readRect, drawRect, readRenderTarget, drawRenderTarget, filter, scissor,
2722                                   false, blitDepth, blitStencil))
2723         {
2724             return false;
2725         }
2726     }
2727
2728     invalidateFramebufferSwizzles(drawTarget);
2729
2730     return true;
2731 }
2732
2733 void Renderer11::readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
2734                             GLenum type, GLuint outputPitch, const gl::PixelPackState &pack, void* pixels)
2735 {
2736     ID3D11Texture2D *colorBufferTexture = NULL;
2737     unsigned int subresourceIndex = 0;
2738
2739     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
2740
2741     if (colorbuffer && getRenderTargetResource(colorbuffer, &subresourceIndex, &colorBufferTexture))
2742     {
2743         gl::Rectangle area;
2744         area.x = x;
2745         area.y = y;
2746         area.width = width;
2747         area.height = height;
2748
2749         if (pack.pixelBuffer.get() != NULL)
2750         {
2751             rx::Buffer11 *packBufferStorage = Buffer11::makeBuffer11(pack.pixelBuffer.get()->getImplementation());
2752             PackPixelsParams packParams(area, format, type, outputPitch, pack, reinterpret_cast<ptrdiff_t>(pixels));
2753             packBufferStorage->packPixels(colorBufferTexture, subresourceIndex, packParams);
2754         }
2755         else
2756         {
2757             readTextureData(colorBufferTexture, subresourceIndex, area, format, type, outputPitch, pack, pixels);
2758         }
2759
2760         SafeRelease(colorBufferTexture);
2761     }
2762 }
2763
2764 Image *Renderer11::createImage()
2765 {
2766     return new Image11();
2767 }
2768
2769 void Renderer11::generateMipmap(Image *dest, Image *src)
2770 {
2771     Image11 *dest11 = Image11::makeImage11(dest);
2772     Image11 *src11 = Image11::makeImage11(src);
2773     Image11::generateMipmap(dest11, src11);
2774 }
2775
2776 TextureStorage *Renderer11::createTextureStorage2D(SwapChain *swapChain)
2777 {
2778     SwapChain11 *swapChain11 = SwapChain11::makeSwapChain11(swapChain);
2779     return new TextureStorage11_2D(this, swapChain11);
2780 }
2781
2782 TextureStorage *Renderer11::createTextureStorage2D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
2783 {
2784     return new TextureStorage11_2D(this, internalformat, renderTarget, width, height, levels);
2785 }
2786
2787 TextureStorage *Renderer11::createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels)
2788 {
2789     return new TextureStorage11_Cube(this, internalformat, renderTarget, size, levels);
2790 }
2791
2792 TextureStorage *Renderer11::createTextureStorage3D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels)
2793 {
2794     return new TextureStorage11_3D(this, internalformat, renderTarget, width, height, depth, levels);
2795 }
2796
2797 TextureStorage *Renderer11::createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels)
2798 {
2799     return new TextureStorage11_2DArray(this, internalformat, renderTarget, width, height, depth, levels);
2800 }
2801
2802 Texture2DImpl *Renderer11::createTexture2D()
2803 {
2804     return new TextureD3D_2D(this);
2805 }
2806
2807 TextureCubeImpl *Renderer11::createTextureCube()
2808 {
2809     return new TextureD3D_Cube(this);
2810 }
2811
2812 Texture3DImpl *Renderer11::createTexture3D()
2813 {
2814     return new TextureD3D_3D(this);
2815 }
2816
2817 Texture2DArrayImpl *Renderer11::createTexture2DArray()
2818 {
2819     return new TextureD3D_2DArray(this);
2820 }
2821
2822 void Renderer11::readTextureData(ID3D11Texture2D *texture, unsigned int subResource, const gl::Rectangle &area, GLenum format,
2823                                  GLenum type, GLuint outputPitch, const gl::PixelPackState &pack, void *pixels)
2824 {
2825     ASSERT(area.width >= 0);
2826     ASSERT(area.height >= 0);
2827
2828     D3D11_TEXTURE2D_DESC textureDesc;
2829     texture->GetDesc(&textureDesc);
2830
2831     // Clamp read region to the defined texture boundaries, preventing out of bounds reads
2832     // and reads of uninitialized data.
2833     gl::Rectangle safeArea;
2834     safeArea.x      = gl::clamp(area.x, 0, static_cast<int>(textureDesc.Width));
2835     safeArea.y      = gl::clamp(area.y, 0, static_cast<int>(textureDesc.Height));
2836     safeArea.width  = gl::clamp(area.width + std::min(area.x, 0), 0,
2837                                 static_cast<int>(textureDesc.Width) - safeArea.x);
2838     safeArea.height = gl::clamp(area.height + std::min(area.y, 0), 0,
2839                                 static_cast<int>(textureDesc.Height) - safeArea.y);
2840
2841     ASSERT(safeArea.x >= 0 && safeArea.y >= 0);
2842     ASSERT(safeArea.x + safeArea.width  <= static_cast<int>(textureDesc.Width));
2843     ASSERT(safeArea.y + safeArea.height <= static_cast<int>(textureDesc.Height));
2844
2845     if (safeArea.width == 0 || safeArea.height == 0)
2846     {
2847         // no work to do
2848         return;
2849     }
2850
2851     D3D11_TEXTURE2D_DESC stagingDesc;
2852     stagingDesc.Width = safeArea.width;
2853     stagingDesc.Height = safeArea.height;
2854     stagingDesc.MipLevels = 1;
2855     stagingDesc.ArraySize = 1;
2856     stagingDesc.Format = textureDesc.Format;
2857     stagingDesc.SampleDesc.Count = 1;
2858     stagingDesc.SampleDesc.Quality = 0;
2859     stagingDesc.Usage = D3D11_USAGE_STAGING;
2860     stagingDesc.BindFlags = 0;
2861     stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
2862     stagingDesc.MiscFlags = 0;
2863
2864     ID3D11Texture2D* stagingTex = NULL;
2865     HRESULT result = mDevice->CreateTexture2D(&stagingDesc, NULL, &stagingTex);
2866     if (FAILED(result))
2867     {
2868         ERR("Failed to create staging texture for readPixels, HRESULT: 0x%X.", result);
2869         return;
2870     }
2871
2872     ID3D11Texture2D* srcTex = NULL;
2873     if (textureDesc.SampleDesc.Count > 1)
2874     {
2875         D3D11_TEXTURE2D_DESC resolveDesc;
2876         resolveDesc.Width = textureDesc.Width;
2877         resolveDesc.Height = textureDesc.Height;
2878         resolveDesc.MipLevels = 1;
2879         resolveDesc.ArraySize = 1;
2880         resolveDesc.Format = textureDesc.Format;
2881         resolveDesc.SampleDesc.Count = 1;
2882         resolveDesc.SampleDesc.Quality = 0;
2883         resolveDesc.Usage = D3D11_USAGE_DEFAULT;
2884         resolveDesc.BindFlags = 0;
2885         resolveDesc.CPUAccessFlags = 0;
2886         resolveDesc.MiscFlags = 0;
2887
2888         result = mDevice->CreateTexture2D(&resolveDesc, NULL, &srcTex);
2889         if (FAILED(result))
2890         {
2891             ERR("Failed to create resolve texture for readPixels, HRESULT: 0x%X.", result);
2892             SafeRelease(stagingTex);
2893             return;
2894         }
2895
2896         mDeviceContext->ResolveSubresource(srcTex, 0, texture, subResource, textureDesc.Format);
2897         subResource = 0;
2898     }
2899     else
2900     {
2901         srcTex = texture;
2902         srcTex->AddRef();
2903     }
2904
2905     D3D11_BOX srcBox;
2906     srcBox.left   = static_cast<UINT>(safeArea.x);
2907     srcBox.right  = static_cast<UINT>(safeArea.x + safeArea.width);
2908     srcBox.top    = static_cast<UINT>(safeArea.y);
2909     srcBox.bottom = static_cast<UINT>(safeArea.y + safeArea.height);
2910     srcBox.front  = 0;
2911     srcBox.back   = 1;
2912
2913     mDeviceContext->CopySubresourceRegion(stagingTex, 0, 0, 0, 0, srcTex, subResource, &srcBox);
2914
2915     SafeRelease(srcTex);
2916
2917     PackPixelsParams packParams(safeArea, format, type, outputPitch, pack, 0);
2918     packPixels(stagingTex, packParams, pixels);
2919
2920     SafeRelease(stagingTex);
2921 }
2922
2923 void Renderer11::packPixels(ID3D11Texture2D *readTexture, const PackPixelsParams &params, void *pixelsOut)
2924 {
2925     D3D11_TEXTURE2D_DESC textureDesc;
2926     readTexture->GetDesc(&textureDesc);
2927
2928     D3D11_MAPPED_SUBRESOURCE mapping;
2929     HRESULT hr = mDeviceContext->Map(readTexture, 0, D3D11_MAP_READ, 0, &mapping);
2930     UNUSED_ASSERTION_VARIABLE(hr);
2931     ASSERT(SUCCEEDED(hr));
2932
2933     unsigned char *source;
2934     int inputPitch;
2935     if (params.pack.reverseRowOrder)
2936     {
2937         source = static_cast<unsigned char*>(mapping.pData) + mapping.RowPitch * (params.area.height - 1);
2938         inputPitch = -static_cast<int>(mapping.RowPitch);
2939     }
2940     else
2941     {
2942         source = static_cast<unsigned char*>(mapping.pData);
2943         inputPitch = static_cast<int>(mapping.RowPitch);
2944     }
2945
2946     const d3d11::DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(textureDesc.Format);
2947     const gl::InternalFormat &sourceFormatInfo = gl::GetInternalFormatInfo(dxgiFormatInfo.internalFormat);
2948     if (sourceFormatInfo.format == params.format && sourceFormatInfo.type == params.type)
2949     {
2950         unsigned char *dest = static_cast<unsigned char*>(pixelsOut) + params.offset;
2951         for (int y = 0; y < params.area.height; y++)
2952         {
2953             memcpy(dest + y * params.outputPitch, source + y * inputPitch, params.area.width * sourceFormatInfo.pixelBytes);
2954         }
2955     }
2956     else
2957     {
2958         const d3d11::DXGIFormat &sourceDXGIFormatInfo = d3d11::GetDXGIFormatInfo(textureDesc.Format);
2959         ColorCopyFunction fastCopyFunc = sourceDXGIFormatInfo.getFastCopyFunction(params.format, params.type);
2960
2961         const gl::FormatType &destFormatTypeInfo = gl::GetFormatTypeInfo(params.format, params.type);
2962         const gl::InternalFormat &destFormatInfo = gl::GetInternalFormatInfo(destFormatTypeInfo.internalFormat);
2963
2964         if (fastCopyFunc)
2965         {
2966             // Fast copy is possible through some special function
2967             for (int y = 0; y < params.area.height; y++)
2968             {
2969                 for (int x = 0; x < params.area.width; x++)
2970                 {
2971                     void *dest = static_cast<unsigned char*>(pixelsOut) + params.offset + y * params.outputPitch + x * destFormatInfo.pixelBytes;
2972                     void *src = static_cast<unsigned char*>(source) + y * inputPitch + x * sourceFormatInfo.pixelBytes;
2973
2974                     fastCopyFunc(src, dest);
2975                 }
2976             }
2977         }
2978         else
2979         {
2980             unsigned char temp[16]; // Maximum size of any Color<T> type used.
2981             META_ASSERT(sizeof(temp) >= sizeof(gl::ColorF)  &&
2982                         sizeof(temp) >= sizeof(gl::ColorUI) &&
2983                         sizeof(temp) >= sizeof(gl::ColorI));
2984
2985             for (int y = 0; y < params.area.height; y++)
2986             {
2987                 for (int x = 0; x < params.area.width; x++)
2988                 {
2989                     void *dest = static_cast<unsigned char*>(pixelsOut) + params.offset + y * params.outputPitch + x * destFormatInfo.pixelBytes;
2990                     void *src = static_cast<unsigned char*>(source) + y * inputPitch + x * sourceFormatInfo.pixelBytes;
2991
2992                     // readFunc and writeFunc will be using the same type of color, CopyTexImage
2993                     // will not allow the copy otherwise.
2994                     sourceDXGIFormatInfo.colorReadFunction(src, temp);
2995                     destFormatTypeInfo.colorWriteFunction(temp, dest);
2996                 }
2997             }
2998         }
2999     }
3000
3001     mDeviceContext->Unmap(readTexture, 0);
3002 }
3003
3004 bool Renderer11::blitRenderbufferRect(const gl::Rectangle &readRect, const gl::Rectangle &drawRect, RenderTarget *readRenderTarget,
3005                                       RenderTarget *drawRenderTarget, GLenum filter, const gl::Rectangle *scissor,
3006                                       bool colorBlit, bool depthBlit, bool stencilBlit)
3007 {
3008     // Since blitRenderbufferRect is called for each render buffer that needs to be blitted,
3009     // it should never be the case that both color and depth/stencil need to be blitted at
3010     // at the same time.
3011     ASSERT(colorBlit != (depthBlit || stencilBlit));
3012
3013     bool result = true;
3014
3015     RenderTarget11 *drawRenderTarget11 = RenderTarget11::makeRenderTarget11(drawRenderTarget);
3016     if (!drawRenderTarget)
3017     {
3018         ERR("Failed to retrieve the draw render target from the draw framebuffer.");
3019         return gl::error(GL_OUT_OF_MEMORY, false);
3020     }
3021
3022     ID3D11Resource *drawTexture = drawRenderTarget11->getTexture();
3023     unsigned int drawSubresource = drawRenderTarget11->getSubresourceIndex();
3024     ID3D11RenderTargetView *drawRTV = drawRenderTarget11->getRenderTargetView();
3025     ID3D11DepthStencilView *drawDSV = drawRenderTarget11->getDepthStencilView();
3026
3027     RenderTarget11 *readRenderTarget11 = RenderTarget11::makeRenderTarget11(readRenderTarget);
3028     if (!readRenderTarget)
3029     {
3030         ERR("Failed to retrieve the read render target from the read framebuffer.");
3031         return gl::error(GL_OUT_OF_MEMORY, false);
3032     }
3033
3034     ID3D11Resource *readTexture = NULL;
3035     ID3D11ShaderResourceView *readSRV = NULL;
3036     unsigned int readSubresource = 0;
3037     if (readRenderTarget->getSamples() > 0)
3038     {
3039         ID3D11Resource *unresolvedResource = readRenderTarget11->getTexture();
3040         ID3D11Texture2D *unresolvedTexture = d3d11::DynamicCastComObject<ID3D11Texture2D>(unresolvedResource);
3041
3042         if (unresolvedTexture)
3043         {
3044             readTexture = resolveMultisampledTexture(unresolvedTexture, readRenderTarget11->getSubresourceIndex());
3045             readSubresource = 0;
3046
3047             SafeRelease(unresolvedTexture);
3048
3049             HRESULT hresult = mDevice->CreateShaderResourceView(readTexture, NULL, &readSRV);
3050             if (FAILED(hresult))
3051             {
3052                 SafeRelease(readTexture);
3053                 return gl::error(GL_OUT_OF_MEMORY, false);
3054             }
3055         }
3056     }
3057     else
3058     {
3059         readTexture = readRenderTarget11->getTexture();
3060         readTexture->AddRef();
3061         readSubresource = readRenderTarget11->getSubresourceIndex();
3062         readSRV = readRenderTarget11->getShaderResourceView();
3063         readSRV->AddRef();
3064     }
3065
3066     if (!readTexture || !readSRV)
3067     {
3068         SafeRelease(readTexture);
3069         SafeRelease(readSRV);
3070         ERR("Failed to retrieve the read render target view from the read render target.");
3071         return gl::error(GL_OUT_OF_MEMORY, false);
3072     }
3073
3074     gl::Extents readSize(readRenderTarget->getWidth(), readRenderTarget->getHeight(), 1);
3075     gl::Extents drawSize(drawRenderTarget->getWidth(), drawRenderTarget->getHeight(), 1);
3076
3077     bool scissorNeeded = scissor && gl::ClipRectangle(drawRect, *scissor, NULL);
3078
3079     bool wholeBufferCopy = !scissorNeeded &&
3080                            readRect.x == 0 && readRect.width == readSize.width &&
3081                            readRect.y == 0 && readRect.height == readSize.height &&
3082                            drawRect.x == 0 && drawRect.width == drawSize.width &&
3083                            drawRect.y == 0 && drawRect.height == drawSize.height;
3084
3085     bool stretchRequired = readRect.width != drawRect.width || readRect.height != drawRect.height;
3086
3087     bool flipRequired = readRect.width < 0 || readRect.height < 0 || drawRect.width < 0 || drawRect.height < 0;
3088
3089     bool outOfBounds = readRect.x < 0 || readRect.x + readRect.width > readSize.width ||
3090                        readRect.y < 0 || readRect.y + readRect.height > readSize.height ||
3091                        drawRect.x < 0 || drawRect.x + drawRect.width > drawSize.width ||
3092                        drawRect.y < 0 || drawRect.y + drawRect.height > drawSize.height;
3093
3094     const gl::InternalFormat &actualFormatInfo = gl::GetInternalFormatInfo(drawRenderTarget->getActualFormat());
3095     bool partialDSBlit = (actualFormatInfo.depthBits > 0 && depthBlit) != (actualFormatInfo.stencilBits > 0 && stencilBlit);
3096
3097     if (readRenderTarget11->getActualFormat() == drawRenderTarget->getActualFormat() &&
3098         !stretchRequired && !outOfBounds && !flipRequired && !partialDSBlit &&
3099         (!(depthBlit || stencilBlit) || wholeBufferCopy))
3100     {
3101         UINT dstX = drawRect.x;
3102         UINT dstY = drawRect.y;
3103
3104         D3D11_BOX readBox;
3105         readBox.left = readRect.x;
3106         readBox.right = readRect.x + readRect.width;
3107         readBox.top = readRect.y;
3108         readBox.bottom = readRect.y + readRect.height;
3109         readBox.front = 0;
3110         readBox.back = 1;
3111
3112         if (scissorNeeded)
3113         {
3114             // drawRect is guaranteed to have positive width and height because stretchRequired is false.
3115             ASSERT(drawRect.width >= 0 || drawRect.height >= 0);
3116
3117             if (drawRect.x < scissor->x)
3118             {
3119                 dstX = scissor->x;
3120                 readBox.left += (scissor->x - drawRect.x);
3121             }
3122             if (drawRect.y < scissor->y)
3123             {
3124                 dstY = scissor->y;
3125                 readBox.top += (scissor->y - drawRect.y);
3126             }
3127             if (drawRect.x + drawRect.width > scissor->x + scissor->width)
3128             {
3129                 readBox.right -= ((drawRect.x + drawRect.width) - (scissor->x + scissor->width));
3130             }
3131             if (drawRect.y + drawRect.height > scissor->y + scissor->height)
3132             {
3133                 readBox.bottom -= ((drawRect.y + drawRect.height) - (scissor->y + scissor->height));
3134             }
3135         }
3136
3137         // D3D11 needs depth-stencil CopySubresourceRegions to have a NULL pSrcBox
3138         // We also require complete framebuffer copies for depth-stencil blit.
3139         D3D11_BOX *pSrcBox = wholeBufferCopy ? NULL : &readBox;
3140
3141         mDeviceContext->CopySubresourceRegion(drawTexture, drawSubresource, dstX, dstY, 0,
3142                                               readTexture, readSubresource, pSrcBox);
3143         result = true;
3144     }
3145     else
3146     {
3147         gl::Box readArea(readRect.x, readRect.y, 0, readRect.width, readRect.height, 1);
3148         gl::Box drawArea(drawRect.x, drawRect.y, 0, drawRect.width, drawRect.height, 1);
3149
3150         if (depthBlit && stencilBlit)
3151         {
3152             result = mBlit->copyDepthStencil(readTexture, readSubresource, readArea, readSize,
3153                                              drawTexture, drawSubresource, drawArea, drawSize,
3154                                              scissor);
3155         }
3156         else if (depthBlit)
3157         {
3158             result = mBlit->copyDepth(readSRV, readArea, readSize, drawDSV, drawArea, drawSize,
3159                                       scissor);
3160         }
3161         else if (stencilBlit)
3162         {
3163             result = mBlit->copyStencil(readTexture, readSubresource, readArea, readSize,
3164                                         drawTexture, drawSubresource, drawArea, drawSize,
3165                                         scissor);
3166         }
3167         else
3168         {
3169             GLenum format = gl::GetInternalFormatInfo(drawRenderTarget->getInternalFormat()).format;
3170             result = mBlit->copyTexture(readSRV, readArea, readSize, drawRTV, drawArea, drawSize,
3171                                         scissor, format, filter);
3172         }
3173     }
3174
3175     SafeRelease(readTexture);
3176     SafeRelease(readSRV);
3177
3178     return result;
3179 }
3180
3181 ID3D11Texture2D *Renderer11::resolveMultisampledTexture(ID3D11Texture2D *source, unsigned int subresource)
3182 {
3183     D3D11_TEXTURE2D_DESC textureDesc;
3184     source->GetDesc(&textureDesc);
3185
3186     if (textureDesc.SampleDesc.Count > 1)
3187     {
3188         D3D11_TEXTURE2D_DESC resolveDesc;
3189         resolveDesc.Width = textureDesc.Width;
3190         resolveDesc.Height = textureDesc.Height;
3191         resolveDesc.MipLevels = 1;
3192         resolveDesc.ArraySize = 1;
3193         resolveDesc.Format = textureDesc.Format;
3194         resolveDesc.SampleDesc.Count = 1;
3195         resolveDesc.SampleDesc.Quality = 0;
3196         resolveDesc.Usage = textureDesc.Usage;
3197         resolveDesc.BindFlags = textureDesc.BindFlags;
3198         resolveDesc.CPUAccessFlags = 0;
3199         resolveDesc.MiscFlags = 0;
3200
3201         ID3D11Texture2D *resolveTexture = NULL;
3202         HRESULT result = mDevice->CreateTexture2D(&resolveDesc, NULL, &resolveTexture);
3203         if (FAILED(result))
3204         {
3205             ERR("Failed to create a multisample resolve texture, HRESULT: 0x%X.", result);
3206             return NULL;
3207         }
3208
3209         mDeviceContext->ResolveSubresource(resolveTexture, 0, source, subresource, textureDesc.Format);
3210         return resolveTexture;
3211     }
3212     else
3213     {
3214         source->AddRef();
3215         return source;
3216     }
3217 }
3218
3219 void Renderer11::invalidateFBOAttachmentSwizzles(gl::FramebufferAttachment *attachment, int mipLevel)
3220 {
3221     ASSERT(attachment->isTexture());
3222     TextureStorage *texStorage = attachment->getTextureStorage();
3223     if (texStorage)
3224     {
3225         TextureStorage11 *texStorage11 = TextureStorage11::makeTextureStorage11(texStorage);
3226         if (!texStorage11)
3227         {
3228             ERR("texture storage pointer unexpectedly null.");
3229             return;
3230         }
3231
3232         texStorage11->invalidateSwizzleCacheLevel(mipLevel);
3233     }
3234 }
3235
3236 void Renderer11::invalidateFramebufferSwizzles(gl::Framebuffer *framebuffer)
3237 {
3238     for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
3239     {
3240         gl::FramebufferAttachment *attachment = framebuffer->getColorbuffer(colorAttachment);
3241         if (attachment && attachment->isTexture())
3242         {
3243             invalidateFBOAttachmentSwizzles(attachment, attachment->mipLevel());
3244         }
3245     }
3246
3247     gl::FramebufferAttachment *depthAttachment = framebuffer->getDepthbuffer();
3248     if (depthAttachment && depthAttachment->isTexture())
3249     {
3250         invalidateFBOAttachmentSwizzles(depthAttachment, depthAttachment->mipLevel());
3251     }
3252
3253     gl::FramebufferAttachment *stencilAttachment = framebuffer->getStencilbuffer();
3254     if (stencilAttachment && stencilAttachment->isTexture())
3255     {
3256         invalidateFBOAttachmentSwizzles(stencilAttachment, stencilAttachment->mipLevel());
3257     }
3258 }
3259
3260 bool Renderer11::getLUID(LUID *adapterLuid) const
3261 {
3262     adapterLuid->HighPart = 0;
3263     adapterLuid->LowPart = 0;
3264
3265     if (!mDxgiAdapter)
3266     {
3267         return false;
3268     }
3269
3270     DXGI_ADAPTER_DESC adapterDesc;
3271     if (FAILED(mDxgiAdapter->GetDesc(&adapterDesc)))
3272     {
3273         return false;
3274     }
3275
3276     *adapterLuid = adapterDesc.AdapterLuid;
3277     return true;
3278 }
3279
3280 rx::VertexConversionType Renderer11::getVertexConversionType(const gl::VertexFormat &vertexFormat) const
3281 {
3282     return d3d11::GetVertexFormatInfo(vertexFormat).conversionType;
3283 }
3284
3285 GLenum Renderer11::getVertexComponentType(const gl::VertexFormat &vertexFormat) const
3286 {
3287     return d3d11::GetDXGIFormatInfo(d3d11::GetVertexFormatInfo(vertexFormat).nativeFormat).componentType;
3288 }
3289
3290 void Renderer11::generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const
3291 {
3292     d3d11_gl::GenerateCaps(mDevice, outCaps, outTextureCaps, outExtensions);
3293 }
3294
3295 }