xbmc/rendering/dx/RenderSystemDX.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8 #include "RenderSystemDX.h"
   9
  10 #include "application/Application.h"
  11
  12 #include <mutex>
  13 #if defined(TARGET_WINDOWS_DESKTOP)
  14 #include "cores/RetroPlayer/process/windows/RPProcessInfoWin.h"
  15 #include "cores/RetroPlayer/rendering/VideoRenderers/RPWinRenderer.h"
  16 #endif
  17 #include "cores/VideoPlayer/DVDCodecs/DVDFactoryCodec.h"
  18 #include "cores/VideoPlayer/DVDCodecs/Video/DXVA.h"
  19 #if defined(TARGET_WINDOWS_STORE)
  20 #include "cores/VideoPlayer/Process/windows/ProcessInfoWin10.h"
  21 #else
  22 #include "cores/VideoPlayer/Process/windows/ProcessInfoWin.h"
  23 #endif
  24 #include "cores/VideoPlayer/VideoRenderers/RenderFactory.h"
  25 #include "cores/VideoPlayer/VideoRenderers/WinRenderer.h"
  26 #include "cores/VideoPlayer/VideoRenderers/RenderManager.h"
  27 #include "guilib/D3DResource.h"
  28 #include "guilib/GUIShaderDX.h"
  29 #include "guilib/GUITextureD3D.h"
  30 #include "guilib/GUIWindowManager.h"
  31 #include "utils/MathUtils.h"
  32 #include "utils/log.h"
  33
  34 #include <DirectXPackedVector.h>
  35
  36 extern "C" {
  37 #include <libavutil/pixfmt.h>
  38 }
  39
  40 using namespace KODI;
  41 using namespace DirectX;
  42 using namespace DirectX::PackedVector;
  43 using namespace Microsoft::WRL;
  44 using namespace std::chrono_literals;
  45
  46 CRenderSystemDX::CRenderSystemDX() : CRenderSystemBase()
  47 {
  48   m_bVSync = true;
  49
  50   memset(&m_viewPort, 0, sizeof m_viewPort);
  51   memset(&m_scissor, 0, sizeof m_scissor);
  52 }
  53
  54 CRenderSystemDX::~CRenderSystemDX() = default;
  55
  56 bool CRenderSystemDX::InitRenderSystem()
  57 {
  58   m_bVSync = true;
  59
  60   // check various device capabilities
  61   CheckDeviceCaps();
  62
  63   if (!CreateStates() || !InitGUIShader())
  64     return false;
  65
  66   m_bRenderCreated = true;
  67   m_deviceResources->RegisterDeviceNotify(this);
  68
  69   // register platform dependent objects
  70 #if defined(TARGET_WINDOWS_STORE)
  71   VIDEOPLAYER::CProcessInfoWin10::Register();
  72 #else
  73   VIDEOPLAYER::CProcessInfoWin::Register();
  74 #endif
  75   CDVDFactoryCodec::ClearHWAccels();
  76   DXVA::CDecoder::Register();
  77   VIDEOPLAYER::CRendererFactory::ClearRenderer();
  78   CWinRenderer::Register();
  79 #if defined(TARGET_WINDOWS_DESKTOP)
  80   RETRO::CRPProcessInfoWin::Register();
  81   RETRO::CRPProcessInfoWin::RegisterRendererFactory(new RETRO::CWinRendererFactory);
  82 #endif
  83   m_viewPort = m_deviceResources->GetScreenViewport();
  84   RestoreViewPort();
  85
  86   auto outputSize = m_deviceResources->GetOutputSize();
  87   // set camera to center of screen
  88   CPoint camPoint = { outputSize.Width * 0.5f, outputSize.Height * 0.5f };
  89   SetCameraPosition(camPoint, outputSize.Width, outputSize.Height);
  90
  91   const DXGI_ADAPTER_DESC AIdentifier = m_deviceResources->GetAdapterDesc();
  92   m_RenderRenderer = KODI::PLATFORM::WINDOWS::FromW(AIdentifier.Description);
  93   uint32_t version = 0;
  94   for (uint32_t decimal = m_deviceResources->GetDeviceFeatureLevel() >> 8, round = 0; decimal > 0; decimal >>= 4, ++round)
  95     version += (decimal % 16) * std::pow(10, round);
  96   m_RenderVersion = StringUtils::Format("{:.1f}", static_cast<float>(version) / 10.0f);
  97
  98   CGUITextureD3D::Register();
  99
 100   return true;
 101 }
 102
 103 void CRenderSystemDX::OnResize()
 104 {
 105   if (!m_bRenderCreated)
 106     return;
 107
 108   auto outputSize = m_deviceResources->GetOutputSize();
 109
 110   // set camera to center of screen
 111   CPoint camPoint = { outputSize.Width * 0.5f, outputSize.Height * 0.5f };
 112   SetCameraPosition(camPoint, outputSize.Width, outputSize.Height);
 113
 114   CheckInterlacedStereoView();
 115 }
 116
 117 bool CRenderSystemDX::IsFormatSupport(DXGI_FORMAT format, unsigned int usage) const
 118 {
 119   ComPtr<ID3D11Device1> pD3DDev = m_deviceResources->GetD3DDevice();
 120   UINT supported;
 121   pD3DDev->CheckFormatSupport(format, &supported);
 122   return (supported & usage) != 0;
 123 }
 124
 125 bool CRenderSystemDX::DestroyRenderSystem()
 126 {
 127   std::unique_lock<CCriticalSection> lock(m_resourceSection);
 128
 129   if (m_pGUIShader)
 130   {
 131     m_pGUIShader->End();
 132     delete m_pGUIShader;
 133     m_pGUIShader = nullptr;
 134   }
 135   m_rightEyeTex.Release();
 136   m_BlendEnableState = nullptr;
 137   m_BlendDisableState = nullptr;
 138   m_RSScissorDisable = nullptr;
 139   m_RSScissorEnable = nullptr;
 140   m_depthStencilState = nullptr;
 141
 142   return true;
 143 }
 144
 145 void CRenderSystemDX::CheckInterlacedStereoView()
 146 {
 147   RENDER_STEREO_MODE stereoMode = CServiceBroker::GetWinSystem()->GetGfxContext().GetStereoMode();
 148
 149   if ( m_rightEyeTex.Get()
 150     && RENDER_STEREO_MODE_INTERLACED    != stereoMode
 151     && RENDER_STEREO_MODE_CHECKERBOARD  != stereoMode)
 152   {
 153     m_rightEyeTex.Release();
 154   }
 155
 156   if ( !m_rightEyeTex.Get()
 157     && ( RENDER_STEREO_MODE_INTERLACED   == stereoMode
 158       || RENDER_STEREO_MODE_CHECKERBOARD == stereoMode))
 159   {
 160     const auto outputSize = m_deviceResources->GetOutputSize();
 161     DXGI_FORMAT texFormat = m_deviceResources->GetBackBuffer().GetFormat();
 162     if (!m_rightEyeTex.Create(outputSize.Width, outputSize.Height, 1, D3D11_USAGE_DEFAULT, texFormat))
 163     {
 164       CLog::Log(LOGERROR, "{} - Failed to create right eye buffer.", __FUNCTION__);
 165       CServiceBroker::GetWinSystem()->GetGfxContext().SetStereoMode(RENDER_STEREO_MODE_SPLIT_HORIZONTAL); // try fallback to split horizontal
 166     }
 167     else
 168       m_deviceResources->Unregister(&m_rightEyeTex); // we will handle its health
 169   }
 170 }
 171
 172 bool CRenderSystemDX::CreateStates()
 173 {
 174   auto m_pD3DDev = m_deviceResources->GetD3DDevice();
 175   auto m_pContext = m_deviceResources->GetD3DContext();
 176
 177   if (!m_pD3DDev)
 178     return false;
 179
 180   m_BlendEnableState = nullptr;
 181   m_BlendDisableState = nullptr;
 182
 183   // Initialize the description of the stencil state.
 184   D3D11_DEPTH_STENCIL_DESC depthStencilDesc = {};
 185
 186   // Set up the description of the stencil state.
 187   depthStencilDesc.DepthEnable = false;
 188   depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
 189   depthStencilDesc.DepthFunc = D3D11_COMPARISON_NEVER;
 190   depthStencilDesc.StencilEnable = false;
 191   depthStencilDesc.StencilReadMask = 0xFF;
 192   depthStencilDesc.StencilWriteMask = 0xFF;
 193
 194   // Stencil operations if pixel is front-facing.
 195   depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
 196   depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
 197   depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
 198   depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 199
 200   // Stencil operations if pixel is back-facing.
 201   depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
 202   depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
 203   depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
 204   depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 205
 206   // Create the depth stencil state.
 207   HRESULT hr = m_pD3DDev->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
 208   if(FAILED(hr))
 209     return false;
 210
 211   // Set the depth stencil state.
 212   m_pContext->OMSetDepthStencilState(m_depthStencilState.Get(), 0);
 213
 214   D3D11_RASTERIZER_DESC rasterizerState;
 215   rasterizerState.CullMode = D3D11_CULL_NONE;
 216   rasterizerState.FillMode = D3D11_FILL_SOLID;// DEBUG - D3D11_FILL_WIREFRAME
 217   rasterizerState.FrontCounterClockwise = false;
 218   rasterizerState.DepthBias = 0;
 219   rasterizerState.DepthBiasClamp = 0.0f;
 220   rasterizerState.DepthClipEnable = true;
 221   rasterizerState.SlopeScaledDepthBias = 0.0f;
 222   rasterizerState.ScissorEnable = false;
 223   rasterizerState.MultisampleEnable = false;
 224   rasterizerState.AntialiasedLineEnable = false;
 225
 226   if (FAILED(m_pD3DDev->CreateRasterizerState(&rasterizerState, &m_RSScissorDisable)))
 227     return false;
 228
 229   rasterizerState.ScissorEnable = true;
 230   if (FAILED(m_pD3DDev->CreateRasterizerState(&rasterizerState, &m_RSScissorEnable)))
 231     return false;
 232
 233   m_pContext->RSSetState(m_RSScissorDisable.Get()); // by default
 234
 235   D3D11_BLEND_DESC blendState = {};
 236   blendState.RenderTarget[0].BlendEnable = true;
 237   blendState.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; // D3D11_BLEND_SRC_ALPHA;
 238   blendState.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; // D3D11_BLEND_INV_SRC_ALPHA;
 239   blendState.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
 240   blendState.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
 241   blendState.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
 242   blendState.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
 243   blendState.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
 244
 245   m_pD3DDev->CreateBlendState(&blendState, &m_BlendEnableState);
 246
 247   blendState.RenderTarget[0].BlendEnable = false;
 248   m_pD3DDev->CreateBlendState(&blendState, &m_BlendDisableState);
 249
 250   // by default
 251   m_pContext->OMSetBlendState(m_BlendEnableState.Get(), nullptr, 0xFFFFFFFF);
 252   m_BlendEnabled = true;
 253
 254   return true;
 255 }
 256
 257 void CRenderSystemDX::PresentRender(bool rendered, bool videoLayer)
 258 {
 259   if (!m_bRenderCreated)
 260     return;
 261
 262   if ( rendered
 263     && ( m_stereoMode == RENDER_STEREO_MODE_INTERLACED
 264       || m_stereoMode == RENDER_STEREO_MODE_CHECKERBOARD))
 265   {
 266     auto m_pContext = m_deviceResources->GetD3DContext();
 267
 268     // all views prepared, let's merge them before present
 269     m_pContext->OMSetRenderTargets(1, m_deviceResources->GetBackBuffer().GetAddressOfRTV(), m_deviceResources->GetDSV());
 270
 271     auto outputSize = m_deviceResources->GetOutputSize();
 272     CRect destRect = { 0.0f, 0.0f, float(outputSize.Width), float(outputSize.Height) };
 273
 274     SHADER_METHOD method = RENDER_STEREO_MODE_INTERLACED == m_stereoMode
 275                            ? SHADER_METHOD_RENDER_STEREO_INTERLACED_RIGHT
 276                            : SHADER_METHOD_RENDER_STEREO_CHECKERBOARD_RIGHT;
 277     SetAlphaBlendEnable(true);
 278     CD3DTexture::DrawQuad(destRect, 0, &m_rightEyeTex, nullptr, method);
 279     CD3DHelper::PSClearShaderResources(m_pContext);
 280   }
 281
 282   // time for decoder that may require the context
 283   {
 284     std::unique_lock<CCriticalSection> lock(m_decoderSection);
 285     XbmcThreads::EndTime<> timer;
 286     timer.Set(5ms);
 287     while (!m_decodingTimer.IsTimePast() && !timer.IsTimePast())
 288     {
 289       m_decodingEvent.wait(lock, 1ms);
 290     }
 291   }
 292
 293   PresentRenderImpl(rendered);
 294 }
 295
 296 void CRenderSystemDX::RequestDecodingTime()
 297 {
 298   std::unique_lock<CCriticalSection> lock(m_decoderSection);
 299   m_decodingTimer.Set(3ms);
 300 }
 301
 302 void CRenderSystemDX::ReleaseDecodingTime()
 303 {
 304   std::unique_lock<CCriticalSection> lock(m_decoderSection);
 305   m_decodingTimer.SetExpired();
 306   m_decodingEvent.notify();
 307 }
 308
 309 bool CRenderSystemDX::BeginRender()
 310 {
 311   if (!m_bRenderCreated)
 312     return false;
 313
 314   m_limitedColorRange = CServiceBroker::GetWinSystem()->UseLimitedColor();
 315   m_inScene = m_deviceResources->Begin();
 316   return m_inScene;
 317 }
 318
 319 bool CRenderSystemDX::EndRender()
 320 {
 321   m_inScene = false;
 322
 323   if (!m_bRenderCreated)
 324     return false;
 325
 326   return true;
 327 }
 328
 329 bool CRenderSystemDX::ClearBuffers(KODI::UTILS::COLOR::Color color)
 330 {
 331   if (!m_bRenderCreated)
 332     return false;
 333
 334   float fColor[4];
 335   CD3DHelper::XMStoreColor(fColor, color);
 336   ID3D11RenderTargetView* pRTView = m_deviceResources->GetBackBuffer().GetRenderTarget();
 337
 338   if ( m_stereoMode != RENDER_STEREO_MODE_OFF
 339     && m_stereoMode != RENDER_STEREO_MODE_MONO)
 340   {
 341     // if stereo anaglyph/tab/sbs, data was cleared when left view was rendered
 342     if (m_stereoView == RENDER_STEREO_VIEW_RIGHT)
 343     {
 344       // execute command's queue
 345       m_deviceResources->FinishCommandList();
 346
 347       // do not clear RT for anaglyph modes
 348       if ( m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_GREEN_MAGENTA
 349         || m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_RED_CYAN
 350         || m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_YELLOW_BLUE)
 351       {
 352         pRTView = nullptr;
 353       }
 354       // for interlaced/checkerboard clear view for right texture
 355       else if (m_stereoMode == RENDER_STEREO_MODE_INTERLACED
 356             || m_stereoMode == RENDER_STEREO_MODE_CHECKERBOARD)
 357       {
 358         pRTView = m_rightEyeTex.GetRenderTarget();
 359       }
 360     }
 361   }
 362
 363   if (pRTView == nullptr)
 364     return true;
 365
 366   auto outputSize = m_deviceResources->GetOutputSize();
 367   CRect clRect(0.0f, 0.0f,
 368     static_cast<float>(outputSize.Width),
 369     static_cast<float>(outputSize.Height));
 370
 371   // Unlike Direct3D 9, D3D11 ClearRenderTargetView always clears full extent of the resource view.
 372   // Viewport and scissor settings are not applied. So clear RT by drawing full sized rect with clear color
 373   if (m_ScissorsEnabled && m_scissor != clRect)
 374   {
 375     bool alphaEnabled = m_BlendEnabled;
 376     if (alphaEnabled)
 377       SetAlphaBlendEnable(false);
 378
 379     CGUITextureD3D::DrawQuad(clRect, color);
 380
 381     if (alphaEnabled)
 382       SetAlphaBlendEnable(true);
 383   }
 384   else
 385     m_deviceResources->ClearRenderTarget(pRTView, fColor);
 386
 387   m_deviceResources->ClearDepthStencil();
 388   return true;
 389 }
 390
 391 void CRenderSystemDX::CaptureStateBlock()
 392 {
 393   if (!m_bRenderCreated)
 394     return;
 395 }
 396
 397 void CRenderSystemDX::ApplyStateBlock()
 398 {
 399   if (!m_bRenderCreated)
 400     return;
 401
 402   auto m_pContext = m_deviceResources->GetD3DContext();
 403
 404   m_pContext->RSSetState(m_ScissorsEnabled ? m_RSScissorEnable.Get() : m_RSScissorDisable.Get());
 405   m_pContext->OMSetDepthStencilState(m_depthStencilState.Get(), 0);
 406   float factors[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
 407   m_pContext->OMSetBlendState(m_BlendEnabled ? m_BlendEnableState.Get() : m_BlendDisableState.Get(), factors, 0xFFFFFFFF);
 408
 409   m_pGUIShader->ApplyStateBlock();
 410 }
 411
 412 void CRenderSystemDX::SetCameraPosition(const CPoint &camera, int screenWidth, int screenHeight, float stereoFactor)
 413 {
 414   if (!m_bRenderCreated)
 415     return;
 416
 417   // grab the viewport dimensions and location
 418   float w = m_viewPort.Width * 0.5f;
 419   float h = m_viewPort.Height * 0.5f;
 420
 421   XMFLOAT2 offset = XMFLOAT2(camera.x - screenWidth*0.5f, camera.y - screenHeight*0.5f);
 422
 423   // world view.  Until this is moved onto the GPU (via a vertex shader for instance), we set it to the identity here.
 424   m_pGUIShader->SetWorld(XMMatrixIdentity());
 425
 426   // Initialize the view matrix camera view.
 427   // Multiply the Y coord by -1 then translate so that everything is relative to the camera position.
 428   XMMATRIX flipY = XMMatrixScaling(1.0, -1.0f, 1.0f);
 429   XMMATRIX translate = XMMatrixTranslation(-(w + offset.x - stereoFactor), -(h + offset.y), 2 * h);
 430   m_pGUIShader->SetView(XMMatrixMultiply(translate, flipY));
 431
 432   // projection onto screen space
 433   m_pGUIShader->SetProjection(XMMatrixPerspectiveOffCenterLH((-w - offset.x)*0.5f, (w - offset.x)*0.5f, (-h + offset.y)*0.5f, (h + offset.y)*0.5f, h, 100 * h));
 434 }
 435
 436 void CRenderSystemDX::Project(float &x, float &y, float &z)
 437 {
 438   if (!m_bRenderCreated)
 439     return;
 440
 441   m_pGUIShader->Project(x, y, z);
 442 }
 443
 444 CRect CRenderSystemDX::GetBackBufferRect()
 445 {
 446   auto outputSize = m_deviceResources->GetOutputSize();
 447   return CRect(0.f, 0.f, static_cast<float>(outputSize.Width), static_cast<float>(outputSize.Height));
 448 }
 449
 450 void CRenderSystemDX::GetViewPort(CRect& viewPort)
 451 {
 452   if (!m_bRenderCreated)
 453     return;
 454
 455   viewPort.x1 = m_viewPort.TopLeftX;
 456   viewPort.y1 = m_viewPort.TopLeftY;
 457   viewPort.x2 = m_viewPort.TopLeftX + m_viewPort.Width;
 458   viewPort.y2 = m_viewPort.TopLeftY + m_viewPort.Height;
 459 }
 460
 461 void CRenderSystemDX::SetViewPort(const CRect& viewPort)
 462 {
 463   if (!m_bRenderCreated)
 464     return;
 465
 466   m_viewPort.MinDepth   = 0.0f;
 467   m_viewPort.MaxDepth   = 1.0f;
 468   m_viewPort.TopLeftX   = viewPort.x1;
 469   m_viewPort.TopLeftY   = viewPort.y1;
 470   m_viewPort.Width      = viewPort.x2 - viewPort.x1;
 471   m_viewPort.Height     = viewPort.y2 - viewPort.y1;
 472
 473   m_deviceResources->SetViewPort(m_viewPort);
 474   m_pGUIShader->SetViewPort(m_viewPort);
 475 }
 476
 477 void CRenderSystemDX::RestoreViewPort()
 478 {
 479   if (!m_bRenderCreated)
 480     return;
 481
 482   m_deviceResources->SetViewPort(m_viewPort);
 483   m_pGUIShader->SetViewPort(m_viewPort);
 484 }
 485
 486 bool CRenderSystemDX::ScissorsCanEffectClipping()
 487 {
 488   if (!m_bRenderCreated)
 489     return false;
 490
 491   return m_pGUIShader != nullptr && m_pGUIShader->HardwareClipIsPossible();
 492 }
 493
 494 CRect CRenderSystemDX::ClipRectToScissorRect(const CRect &rect)
 495 {
 496   if (!m_bRenderCreated)
 497     return CRect();
 498
 499   float xFactor = m_pGUIShader->GetClipXFactor();
 500   float xOffset = m_pGUIShader->GetClipXOffset();
 501   float yFactor = m_pGUIShader->GetClipYFactor();
 502   float yOffset = m_pGUIShader->GetClipYOffset();
 503
 504   return CRect(rect.x1 * xFactor + xOffset,
 505                rect.y1 * yFactor + yOffset,
 506                rect.x2 * xFactor + xOffset,
 507                rect.y2 * yFactor + yOffset);
 508 }
 509
 510 void CRenderSystemDX::SetScissors(const CRect& rect)
 511 {
 512   if (!m_bRenderCreated)
 513     return;
 514
 515   auto m_pContext = m_deviceResources->GetD3DContext();
 516
 517   m_scissor = rect;
 518   CD3D11_RECT scissor(MathUtils::round_int(rect.x1)
 519                     , MathUtils::round_int(rect.y1)
 520                     , MathUtils::round_int(rect.x2)
 521                     , MathUtils::round_int(rect.y2));
 522
 523   m_pContext->RSSetScissorRects(1, &scissor);
 524   m_pContext->RSSetState(m_RSScissorEnable.Get());
 525   m_ScissorsEnabled = true;
 526 }
 527
 528 void CRenderSystemDX::ResetScissors()
 529 {
 530   if (!m_bRenderCreated)
 531     return;
 532
 533   auto m_pContext = m_deviceResources->GetD3DContext();
 534   auto outputSize = m_deviceResources->GetOutputSize();
 535
 536   m_scissor.SetRect(0.0f, 0.0f,
 537     static_cast<float>(outputSize.Width),
 538     static_cast<float>(outputSize.Height));
 539
 540   m_pContext->RSSetState(m_RSScissorDisable.Get());
 541   m_ScissorsEnabled = false;
 542 }
 543
 544 void CRenderSystemDX::OnDXDeviceLost()
 545 {
 546   CRenderSystemDX::DestroyRenderSystem();
 547 }
 548
 549 void CRenderSystemDX::OnDXDeviceRestored()
 550 {
 551   CRenderSystemDX::InitRenderSystem();
 552 }
 553
 554 void CRenderSystemDX::SetStereoMode(RENDER_STEREO_MODE mode, RENDER_STEREO_VIEW view)
 555 {
 556   CRenderSystemBase::SetStereoMode(mode, view);
 557
 558   if (!m_bRenderCreated)
 559     return;
 560
 561   auto m_pContext = m_deviceResources->GetD3DContext();
 562
 563   UINT writeMask = D3D11_COLOR_WRITE_ENABLE_ALL;
 564   if(m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_RED_CYAN)
 565   {
 566     if(m_stereoView == RENDER_STEREO_VIEW_LEFT)
 567       writeMask = D3D11_COLOR_WRITE_ENABLE_RED;
 568     else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT)
 569       writeMask = D3D11_COLOR_WRITE_ENABLE_BLUE | D3D11_COLOR_WRITE_ENABLE_GREEN;
 570   }
 571   if(m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_GREEN_MAGENTA)
 572   {
 573     if(m_stereoView == RENDER_STEREO_VIEW_LEFT)
 574       writeMask = D3D11_COLOR_WRITE_ENABLE_GREEN;
 575     else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT)
 576       writeMask = D3D11_COLOR_WRITE_ENABLE_BLUE | D3D11_COLOR_WRITE_ENABLE_RED;
 577   }
 578   if (m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_YELLOW_BLUE)
 579   {
 580     if (m_stereoView == RENDER_STEREO_VIEW_LEFT)
 581       writeMask = D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN;
 582     else if (m_stereoView == RENDER_STEREO_VIEW_RIGHT)
 583       writeMask = D3D11_COLOR_WRITE_ENABLE_BLUE;
 584   }
 585   if ( RENDER_STEREO_MODE_INTERLACED    == m_stereoMode
 586     || RENDER_STEREO_MODE_CHECKERBOARD  == m_stereoMode)
 587   {
 588     if (m_stereoView == RENDER_STEREO_VIEW_RIGHT)
 589     {
 590       m_pContext->OMSetRenderTargets(1, m_rightEyeTex.GetAddressOfRTV(), m_deviceResources->GetDSV());
 591     }
 592   }
 593   else if (RENDER_STEREO_MODE_HARDWAREBASED == m_stereoMode)
 594   {
 595     m_deviceResources->SetStereoIdx(m_stereoView == RENDER_STEREO_VIEW_RIGHT ? 1 : 0);
 596
 597     m_pContext->OMSetRenderTargets(1, m_deviceResources->GetBackBuffer().GetAddressOfRTV(), m_deviceResources->GetDSV());
 598   }
 599
 600   auto m_pD3DDev = m_deviceResources->GetD3DDevice();
 601
 602   D3D11_BLEND_DESC desc;
 603   m_BlendEnableState->GetDesc(&desc);
 604   // update blend state
 605   if (desc.RenderTarget[0].RenderTargetWriteMask != writeMask)
 606   {
 607     m_BlendDisableState = nullptr;
 608     m_BlendEnableState = nullptr;
 609
 610     desc.RenderTarget[0].RenderTargetWriteMask = writeMask;
 611     m_pD3DDev->CreateBlendState(&desc, &m_BlendEnableState);
 612
 613     desc.RenderTarget[0].BlendEnable = false;
 614     m_pD3DDev->CreateBlendState(&desc, &m_BlendDisableState);
 615
 616     float blendFactors[] = { 0.0f, 0.0f, 0.0f, 0.0f };
 617     m_pContext->OMSetBlendState(m_BlendEnabled ? m_BlendEnableState.Get() : m_BlendDisableState.Get(), blendFactors, 0xFFFFFFFF);
 618   }
 619 }
 620
 621 bool CRenderSystemDX::SupportsStereo(RENDER_STEREO_MODE mode) const
 622 {
 623   switch (mode)
 624   {
 625     case RENDER_STEREO_MODE_ANAGLYPH_RED_CYAN:
 626     case RENDER_STEREO_MODE_ANAGLYPH_GREEN_MAGENTA:
 627     case RENDER_STEREO_MODE_ANAGLYPH_YELLOW_BLUE:
 628     case RENDER_STEREO_MODE_INTERLACED:
 629     case RENDER_STEREO_MODE_CHECKERBOARD:
 630       return true;
 631     case RENDER_STEREO_MODE_HARDWAREBASED:
 632       return m_deviceResources->IsStereoAvailable();
 633     default:
 634       return CRenderSystemBase::SupportsStereo(mode);
 635   }
 636 }
 637
 638 void CRenderSystemDX::FlushGPU() const
 639 {
 640   if (!m_bRenderCreated)
 641     return;
 642
 643   m_deviceResources->FinishCommandList();
 644   m_deviceResources->GetImmediateContext()->Flush();
 645 }
 646
 647 bool CRenderSystemDX::InitGUIShader()
 648 {
 649   delete m_pGUIShader;
 650   m_pGUIShader = nullptr;
 651
 652   m_pGUIShader = new CGUIShaderDX();
 653   if (!m_pGUIShader->Initialize())
 654   {
 655     CLog::LogF(LOGERROR, "Failed to initialize GUI shader.");
 656     return false;
 657   }
 658
 659   m_pGUIShader->ApplyStateBlock();
 660   return true;
 661 }
 662
 663 void CRenderSystemDX::SetAlphaBlendEnable(bool enable)
 664 {
 665   if (!m_bRenderCreated)
 666     return;
 667
 668   m_deviceResources->GetD3DContext()->OMSetBlendState(enable ? m_BlendEnableState.Get() : m_BlendDisableState.Get(), nullptr, 0xFFFFFFFF);
 669   m_BlendEnabled = enable;
 670 }
 671
 672 CD3DTexture& CRenderSystemDX::GetBackBuffer()
 673 {
 674   if (m_stereoView == RENDER_STEREO_VIEW_RIGHT && m_rightEyeTex.Get())
 675     return m_rightEyeTex;
 676
 677   return m_deviceResources->GetBackBuffer();
 678 }
 679
 680 void CRenderSystemDX::CheckDeviceCaps()
 681 {
 682   const auto feature_level = m_deviceResources->GetDeviceFeatureLevel();
 683   if (feature_level < D3D_FEATURE_LEVEL_9_3)
 684     m_maxTextureSize = D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION;
 685   else if (feature_level < D3D_FEATURE_LEVEL_10_0)
 686     m_maxTextureSize = D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION;
 687   else if (feature_level < D3D_FEATURE_LEVEL_11_0)
 688     m_maxTextureSize = D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION;
 689   else
 690     // 11_x and greater feature level. Limit this size to avoid memory overheads
 691     m_maxTextureSize = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION >> 1;
 692 }
 693
 694 bool CRenderSystemDX::SupportsNPOT(bool dxt) const
 695 {
 696   // MSDN says:
 697   // At feature levels 9_1, 9_2 and 9_3, the display device supports the use
 698   // of 2D textures with dimensions that are not powers of two under two conditions:
 699   // 1) only one MIP-map level for each texture can be created - we are using both 1 and 0 mipmap levels
 700   // 2) no wrap sampler modes for textures are allowed - we are using clamp everywhere
 701   // At feature levels 10_0, 10_1 and 11_0, the display device unconditionally supports the use of 2D textures with dimensions that are not powers of two.
 702   // taking in account first condition we setup caps NPOT for FE > 9.x only
 703   return m_deviceResources->GetDeviceFeatureLevel() > D3D_FEATURE_LEVEL_9_3 ? true : false;
 704 }