Code/CryEngine/RenderDll/XRenderD3D9/DeviceManager/D3D11/DeviceCommandListCommon_D3D11.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "../DeviceObjects.h"
   5 #include "../../../Common/ReverseDepth.h"
   6
   7 #include "DeviceCommandListCommon_D3D11.h"
   8 #include "DeviceObjects_D3D11.h"
   9 #include "DeviceResourceSet_D3D11.h"
  10 #include "DevicePSO_D3D11.h"
  11
  12 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  13
  14 #if !defined(CRY_PLATFORM_ORBIS)
  15
  16 CDeviceTimestampGroup::CDeviceTimestampGroup()
  17         : m_numTimestamps(0)
  18         , m_pDisjointQuery(nullptr)
  19         , m_frequency(0L)
  20         , m_measurable(false)
  21         , m_measured(false)
  22 {
  23         m_timestampQueries.fill(nullptr);
  24         m_timeValues.fill(0);
  25 }
  26
  27 CDeviceTimestampGroup::~CDeviceTimestampGroup()
  28 {
  29         SAFE_RELEASE(m_pDisjointQuery);
  30         for (uint32 i = 0; i < m_timestampQueries.size(); i++)
  31         {
  32                 SAFE_RELEASE(m_timestampQueries[i]);
  33         }
  34 }
  35
  36 void CDeviceTimestampGroup::Init()
  37 {
  38         D3D11_QUERY_DESC queryTimestampDesc = { D3D11_QUERY_TIMESTAMP, 0 };
  39         D3D11_QUERY_DESC queryDisjointDesc = { D3D11_QUERY_TIMESTAMP_DISJOINT, 0 };
  40
  41         for (uint32 i = 0; i < m_timestampQueries.size(); i++)
  42         {
  43                 gcpRendD3D->GetDevice().CreateQuery(&queryTimestampDesc, &m_timestampQueries[i]);
  44         }
  45         gcpRendD3D->GetDevice().CreateQuery(&queryDisjointDesc, &m_pDisjointQuery);
  46 }
  47
  48 void CDeviceTimestampGroup::BeginMeasurement()
  49 {
  50         m_numTimestamps = 0;
  51         m_frequency = 0;
  52         m_measurable = false;
  53         m_measured = false;
  54
  55         gcpRendD3D->GetDeviceContext().Begin(m_pDisjointQuery);
  56 }
  57
  58 void CDeviceTimestampGroup::EndMeasurement()
  59 {
  60         gcpRendD3D->GetDeviceContext().End(m_pDisjointQuery);
  61
  62         m_measurable = true;
  63 }
  64
  65 uint32 CDeviceTimestampGroup::IssueTimestamp(CDeviceCommandList* pCommandList)
  66 {
  67         assert(m_numTimestamps < m_timestampQueries.size());
  68         gcpRendD3D->GetDeviceContext().End(m_timestampQueries[m_numTimestamps]);
  69         m_timeValues[m_numTimestamps] = 0;
  70
  71         return (m_numTimestamps + 1) < m_timestampQueries.size() ? m_numTimestamps++ : m_numTimestamps;
  72 }
  73
  74 bool CDeviceTimestampGroup::ResolveTimestamps()
  75 {
  76         if (!m_measurable)
  77                 return false;
  78         if (m_measured)
  79                 return true;
  80
  81         // Don't ask twice (API violation)
  82         if (!m_frequency)
  83         {
  84                 D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData;
  85                 if (gcpRendD3D->GetDeviceContext().GetData(m_pDisjointQuery, &disjointData, m_pDisjointQuery->GetDataSize(), 0) == S_OK)
  86                 {
  87                         m_frequency = disjointData.Frequency;
  88                 }
  89                 else
  90                 {
  91                         m_frequency = 0;
  92                         return false;
  93                 }
  94         }
  95
  96         int i = m_numTimestamps;
  97         while (--i >= 0)
  98         {
  99                 // Don't ask twice (API violation)
 100                 if (!m_timeValues[i])
 101                 {
 102                         if (gcpRendD3D->GetDeviceContext().GetData(m_timestampQueries[i], &m_timeValues[i], m_timestampQueries[i]->GetDataSize(), 0) != S_OK)
 103                         {
 104                                 m_timeValues[i] = 0;
 105                                 return false;
 106                         }
 107                 }
 108         }
 109
 110         return m_measured = true;
 111 }
 112
 113 #endif
 114
 115
 116
 117 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 118 CDeviceNvidiaCommandInterfaceImpl* CDeviceCommandListImpl::GetNvidiaCommandInterfaceImpl()
 119 {
 120         if (gcpRendD3D->m_bVendorLibInitialized && (gRenDev->GetFeatures() & RFT_HW_NVIDIA))
 121         {
 122                 return reinterpret_cast<CDeviceNvidiaCommandInterfaceImpl*>(this);
 123         }
 124
 125         return nullptr;
 126 }
 127
 128 void CDeviceCommandListImpl::SetProfilerMarker(const char* label)
 129 {
 130         PROFILE_LABEL_GPU(label);
 131 }
 132
 133 void CDeviceCommandListImpl::BeginProfilerEvent(const char* label)
 134 {
 135         PROFILE_LABEL_PUSH_GPU(label);
 136 }
 137
 138 void CDeviceCommandListImpl::EndProfilerEvent(const char* label)
 139 {
 140         PROFILE_LABEL_POP_GPU(label);
 141 }
 142
 143 void CDeviceCommandListImpl::ClearStateImpl(bool bOutputMergerOnly) const
 144 {
 145         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 146
 147         if (rd->GetDeviceContext().IsValid())
 148         {
 149                 D3DDepthSurface* pDSV = 0;
 150                 D3DSurface*      pRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = { 0 };
 151
 152                 if (bOutputMergerOnly)
 153                         rd->GetDeviceContext().OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, pRTVs, pDSV);
 154                 else
 155                         rd->GetDeviceContext().ClearState();
 156         }
 157
 158         rd->m_DevMan.ClearState();
 159 }
 160
 161 void CDeviceCommandListImpl::ResetImpl()
 162 {
 163         const uint8 InvalidShaderPointer = (uint8)(uint64)CDeviceResourceSet_DX11::InvalidPointer;
 164         CRY_ASSERT((InvalidShaderPointer & 0x1) != 0);
 165
 166         memset(m_sharedState.shader, InvalidShaderPointer, sizeof(m_sharedState.shader));
 167         memset(m_sharedState.shaderResourceView, InvalidShaderPointer, sizeof(m_sharedState.shaderResourceView));
 168         memset(m_sharedState.samplerState, InvalidShaderPointer, sizeof(m_sharedState.samplerState));
 169         memset(m_sharedState.constantBuffer, InvalidShaderPointer, sizeof(m_sharedState.constantBuffer));
 170         m_sharedState.validShaderStages = EShaderStage_All;
 171
 172         m_sharedState.numSRVs.fill(0);
 173         m_sharedState.numSamplers.fill(0);
 174
 175         UINT_PTR invalidPtr = UINT_PTR(~0u);
 176         m_graphicsState.custom.depthStencilState = nullptr;
 177         m_graphicsState.custom.rasterizerState = nullptr;
 178         m_graphicsState.custom.rasterizerStateIndex = 0;
 179         m_graphicsState.custom.blendState = nullptr;
 180         m_graphicsState.custom.inputLayout = reinterpret_cast<ID3D11InputLayout*>(invalidPtr);
 181         m_graphicsState.custom.topology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;
 182         m_graphicsState.custom.bDepthStencilStateDirty = true;
 183         m_graphicsState.custom.depthConstBias = 0.0f;
 184         m_graphicsState.custom.depthSlopeBias = 0.0f;
 185         m_graphicsState.custom.depthBiasClamp = 0.0f;
 186         m_graphicsState.custom.bRasterizerStateDirty = true;
 187
 188         m_computeState.custom.boundUAVs = 0;
 189 }
 190
 191 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 192 // *INDENT-OFF*
 193 static_assert(
 194         (1 << eHWSC_Vertex  ) == EShaderStage_Vertex   &&
 195         (1 << eHWSC_Pixel   ) == EShaderStage_Pixel    &&
 196         (1 << eHWSC_Geometry) == EShaderStage_Geometry &&
 197         (1 << eHWSC_Domain  ) == EShaderStage_Domain   &&
 198         (1 << eHWSC_Hull    ) == EShaderStage_Hull,
 199         "EShaderStage should have bits corresponding with EHWShaderClass");
 200
 201 static_assert(
 202         eHWSC_Vertex   == CSubmissionQueue_DX11::TYPE_VS &&
 203         eHWSC_Pixel    == CSubmissionQueue_DX11::TYPE_PS &&
 204         eHWSC_Geometry == CSubmissionQueue_DX11::TYPE_GS &&
 205         eHWSC_Domain   == CSubmissionQueue_DX11::TYPE_DS &&
 206         eHWSC_Hull     == CSubmissionQueue_DX11::TYPE_HS &&
 207         eHWSC_Compute  == CSubmissionQueue_DX11::TYPE_CS,
 208         "SHADER_TYPE enumeration should match EHWShaderClass for performance reasons");
 209
 210 static inline void BindShader(EHWShaderClass shaderClass, ID3D11Resource* pBin)
 211 {
 212         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 213         rd->m_DevMan.BindShader(static_cast<CSubmissionQueue_DX11::SHADER_TYPE>(shaderClass), pBin);
 214 }
 215
 216 static inline void BindSRV(EHWShaderClass shaderClass, ID3D11ShaderResourceView* pSrv, uint32 slot)
 217 {
 218         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 219         rd->m_DevMan.BindSRV(static_cast<CSubmissionQueue_DX11::SHADER_TYPE>(shaderClass), pSrv, slot);
 220 }
 221
 222 static inline void BindUAV(EHWShaderClass shaderClass, ID3D11UnorderedAccessView* pUAV, uint32 slot)
 223 {
 224         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 225         rd->m_DevMan.BindUAV(static_cast<CSubmissionQueue_DX11::SHADER_TYPE>(shaderClass), pUAV, 0, slot);
 226 }
 227
 228 static inline void BindSampler(EHWShaderClass shaderClass, ID3D11SamplerState* pSamplerState, uint32 slot)
 229 {
 230         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 231         rd->m_DevMan.BindSampler(static_cast<CSubmissionQueue_DX11::SHADER_TYPE>(shaderClass), pSamplerState, slot);
 232 }
 233
 234 static inline void BindConstantBuffer(EHWShaderClass shaderClass, D3DBuffer* pBuffer, EConstantBufferShaderSlot slot)
 235 {
 236         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 237         rd->m_DevMan.BindConstantBuffer(static_cast<CSubmissionQueue_DX11::SHADER_TYPE>(shaderClass), pBuffer, slot);
 238 }
 239
 240 static inline void BindConstantBuffer(EHWShaderClass shaderClass, D3DBuffer* pBuffer, EConstantBufferShaderSlot slot, uint32 offset, uint32 size)
 241 {
 242         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 243         rd->m_DevMan.BindConstantBuffer(static_cast<CSubmissionQueue_DX11::SHADER_TYPE>(shaderClass), pBuffer, slot, offset, size);
 244 }
 245 // *INDENT-ON*
 246
 247 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 248 void CDeviceGraphicsCommandInterfaceImpl::BeginRenderPassImpl(const CDeviceRenderPass& renderPass, const D3DRectangle& renderArea)
 249 {
 250         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 251         rd->GetDeviceContext().OMSetRenderTargets(renderPass.m_RenderTargetCount, renderPass.m_RenderTargetViews.data(), renderPass.m_pDepthStencilView);
 252 }
 253
 254 void CDeviceGraphicsCommandInterfaceImpl::SetViewportsImpl(uint32 vpCount, const D3DViewPort* pViewports)
 255 {
 256         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 257         rd->GetDeviceContext().RSSetViewports(vpCount, pViewports);
 258 }
 259
 260 void CDeviceGraphicsCommandInterfaceImpl::SetScissorRectsImpl(uint32 rcCount, const D3DRectangle* pRects)
 261 {
 262         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 263         rd->GetDeviceContext().RSSetScissorRects(rcCount, pRects);
 264 }
 265
 266 void CDeviceGraphicsCommandInterfaceImpl::SetPipelineStateImpl(const CDeviceGraphicsPSO* devicePSO)
 267 {
 268         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 269         const CDeviceGraphicsPSO_DX11* pDevicePSO = reinterpret_cast<const CDeviceGraphicsPSO_DX11*>(devicePSO);
 270
 271         // RasterState, BlendState
 272         if (m_graphicsState.custom.blendState.Set(pDevicePSO->m_pBlendState.get()))
 273         {
 274                 rd->m_DevMan.SetBlendState(pDevicePSO->m_pBlendState, NULL, 0xffffffff);
 275         }
 276
 277         // Rasterizer state: NOTE - we don't know the final depth bias values yet so only mark dirty here and set in actual draw call
 278         if (m_graphicsState.custom.rasterizerState.Set(pDevicePSO->m_pRasterizerState.get()))
 279         {
 280                 m_graphicsState.custom.rasterizerStateIndex = pDevicePSO->m_RasterizerStateIndex;
 281                 m_graphicsState.custom.bRasterizerStateDirty = true;
 282         }
 283
 284         // Depth stencil state: NOTE - we don't know the final stencil ref value yet so only mark dirty here and set in actual draw call
 285         if (m_graphicsState.custom.depthStencilState.Set(pDevicePSO->m_pDepthStencilState.get()))
 286         {
 287                 m_graphicsState.custom.bDepthStencilStateDirty = true;
 288         }
 289
 290         // input layout and topology
 291         if (m_graphicsState.custom.inputLayout.Set(pDevicePSO->m_pInputLayout.get()))   rd->m_DevMan.BindVtxDecl(pDevicePSO->m_pInputLayout);
 292         if (m_graphicsState.custom.topology.Set(pDevicePSO->m_PrimitiveTopology))       rd->m_DevMan.BindTopology(pDevicePSO->m_PrimitiveTopology);
 293
 294         // Shaders and update valid shader mask
 295         m_sharedState.validShaderStages = EShaderStage_None;
 296
 297         const std::array<void*, eHWSC_Num>& shaders = pDevicePSO->m_pDeviceShaders;
 298         for (EHWShaderClass shaderClass = eHWSC_Vertex; shaderClass != eHWSC_NumGfx; shaderClass = EHWShaderClass(shaderClass + 1))
 299         {
 300                 m_sharedState.validShaderStages |= SHADERSTAGE_FROM_SHADERCLASS_CONDITIONAL(shaderClass, shaders[shaderClass] ? 1 : 0);
 301
 302                 if (m_sharedState.shader[shaderClass].Set(shaders[shaderClass]))
 303                 {
 304                         BindShader(shaderClass, (ID3D11Resource*)shaders[shaderClass]);
 305                 }
 306         }
 307
 308         m_sharedState.srvs = pDevicePSO->m_SRVs;
 309         m_sharedState.samplers = pDevicePSO->m_Samplers;
 310
 311         m_sharedState.numSRVs = pDevicePSO->m_NumSRVs;
 312         m_sharedState.numSamplers = pDevicePSO->m_NumSamplers;
 313 }
 314
 315 void CDeviceGraphicsCommandInterfaceImpl::SetResourcesImpl(uint32 bindSlot, const CDeviceResourceSet* pResources)
 316 {
 317         auto pResourcesDX11 = reinterpret_cast<const CDeviceResourceSet_DX11*>(pResources);
 318
 319         if (pResources->GetFlags() & CDeviceResourceSet::EFlags_ForceSetAllState)
 320         {
 321                 SetResources_All(pResourcesDX11);
 322         }
 323         else
 324         {
 325                 SetResources_RequestedByShaderOnly(pResourcesDX11);
 326         }
 327 }
 328
 329 void CDeviceGraphicsCommandInterfaceImpl::SetResources_RequestedByShaderOnly(const CDeviceResourceSet* pResources)
 330 {
 331         auto pResourcesDX11 = reinterpret_cast<const CDeviceResourceSet_DX11*>(pResources);
 332
 333         // Shader stages are ordered by usage-frequency and loop exists according to usage-frequency (VS+PS fast, etc.)
 334         int validShaderStages = m_sharedState.validShaderStages;
 335         for (EHWShaderClass shaderClass = eHWSC_Vertex; validShaderStages; shaderClass = EHWShaderClass(shaderClass + 1), validShaderStages >>= 1)
 336         {
 337                 if (validShaderStages & 1)
 338                 {
 339                         // Bind SRVs
 340                         // if (!pResourcesDX11->compiledSRVs.empty()) // currently this is always the case
 341                         {
 342                                 for (int i = 0; i < m_sharedState.numSRVs[shaderClass]; ++i)
 343                                 {
 344                                         uint8 srvSlot = m_sharedState.srvs[shaderClass][i];
 345                                         ID3D11ShaderResourceView* pSrv = pResourcesDX11->compiledSRVs[shaderClass][srvSlot];
 346
 347                                         if (pSrv != CDeviceResourceSet_DX11::InvalidPointer)
 348                                         {
 349                                                 if (m_sharedState.shaderResourceView[shaderClass][srvSlot].Set(pSrv))
 350                                                 {
 351                                                         BindSRV(shaderClass, pSrv, srvSlot);
 352                                                 }
 353                                         }
 354                                 }
 355                         }
 356
 357                         // Bind Samplers
 358                         // if (!pResourcesDX11->compiledSamplers.empty()) // currently this is always the case
 359                         {
 360                                 for (int i = 0; i < m_sharedState.numSamplers[shaderClass]; ++i)
 361                                 {
 362                                         uint8 samplerSlot = m_sharedState.samplers[shaderClass][i];
 363                                         ID3D11SamplerState* pSamplerState = pResourcesDX11->compiledSamplers[shaderClass][samplerSlot];
 364
 365                                         if (pSamplerState != CDeviceResourceSet_DX11::InvalidPointer)
 366                                         {
 367                                                 if (m_sharedState.samplerState[shaderClass][samplerSlot].Set(pSamplerState))
 368                                                 {
 369                                                         BindSampler(shaderClass, pSamplerState, samplerSlot);
 370                                                 }
 371                                         }
 372                                 }
 373                         }
 374
 375                         // Bind constant buffers
 376                         for (int i = 0; i < pResourcesDX11->numCompiledCBs[shaderClass]; ++i)
 377                         {
 378                                 const CDeviceResourceSet_DX11::SCompiledConstantBuffer& cb = pResourcesDX11->compiledCBs[shaderClass][i];
 379                                 if (m_sharedState.constantBuffer[shaderClass][cb.slot].Set(cb.code))
 380                                 {
 381                                         BindConstantBuffer(shaderClass, cb.pBuffer, cb.slot, cb.offset, cb.size);
 382                                 }
 383                         }
 384                 }
 385         }
 386
 387         // Bind UAVs
 388         for (int i = 0; i < pResourcesDX11->numCompiledUAVs; ++i)
 389         {
 390                 const CDeviceResourceSet_DX11::SCompiledUAV& uav = pResourcesDX11->compiledUAVs[i];
 391                 if (validShaderStages & uav.shaderStage)
 392                 {
 393                         BindUAV(uav.shaderStage, uav.pUav, uav.slot);
 394                 }
 395         }
 396 }
 397
 398 void CDeviceGraphicsCommandInterfaceImpl::SetResources_All(const CDeviceResourceSet* pResources)
 399 {
 400         auto pResourcesDX11 = reinterpret_cast<const CDeviceResourceSet_DX11*>(pResources);
 401
 402         for (EHWShaderClass shaderClass = eHWSC_Vertex; shaderClass != eHWSC_NumGfx; shaderClass = EHWShaderClass(shaderClass + 1))
 403         {
 404                 // Bind SRVs
 405                 for (int slot = pResourcesDX11->firstCompiledSRVs[shaderClass]; slot <= pResourcesDX11->lastCompiledSRVs[shaderClass]; ++slot)
 406                 {
 407                         ID3D11ShaderResourceView* pSrv = pResourcesDX11->compiledSRVs[shaderClass][slot];
 408
 409                         if (pSrv != CDeviceResourceSet_DX11::InvalidPointer)
 410                         {
 411                                 if (m_sharedState.shaderResourceView[shaderClass][slot].Set(pSrv))
 412                                 {
 413                                         BindSRV(shaderClass, pSrv, slot);
 414                                 }
 415                         }
 416                 }
 417
 418                 // Bind Samplers
 419                 for (int slot = pResourcesDX11->firstCompiledSamplers[shaderClass]; slot <= pResourcesDX11->lastCompiledSamplers[shaderClass]; ++slot)
 420                 {
 421                         ID3D11SamplerState* pSamplerState = pResourcesDX11->compiledSamplers[shaderClass][slot];
 422
 423                         if (pSamplerState != CDeviceResourceSet_DX11::InvalidPointer)
 424                         {
 425                                 if (m_sharedState.samplerState[shaderClass][slot].Set(pSamplerState))
 426                                 {
 427                                         BindSampler(shaderClass, pSamplerState, slot);
 428                                 }
 429                         }
 430                 }
 431
 432                 // Bind constant buffers
 433                 for (int i = 0; i < pResourcesDX11->numCompiledCBs[shaderClass]; ++i)
 434                 {
 435                         const CDeviceResourceSet_DX11::SCompiledConstantBuffer& cb = pResourcesDX11->compiledCBs[shaderClass][i];
 436                         if (m_sharedState.constantBuffer[shaderClass][cb.slot].Set(cb.code))
 437                         {
 438                                 BindConstantBuffer(shaderClass, cb.pBuffer, cb.slot, cb.offset, cb.size);
 439                         }
 440                 }
 441         }
 442
 443         // Bind UAVs
 444         for (int i = 0; i < pResourcesDX11->numCompiledUAVs; ++i)
 445         {
 446                 const CDeviceResourceSet_DX11::SCompiledUAV& uav = pResourcesDX11->compiledUAVs[i];
 447                 BindUAV(uav.shaderStage, uav.pUav, uav.slot);
 448         }
 449 }
 450 // *INDENT-ON*
 451
 452 void CDeviceGraphicsCommandInterfaceImpl::ApplyDepthStencilState()
 453 {
 454         if (m_graphicsState.custom.bDepthStencilStateDirty)
 455         {
 456                 gcpRendD3D->m_DevMan.SetDepthStencilState(m_graphicsState.custom.depthStencilState.cachedValue, m_graphicsState.stencilRef.cachedValue);
 457                 m_graphicsState.custom.bDepthStencilStateDirty = false;
 458         }
 459 }
 460
 461 void CDeviceGraphicsCommandInterfaceImpl::ApplyRasterizerState()
 462 {
 463         if (m_graphicsState.custom.bRasterizerStateDirty)
 464         {
 465                 auto pRasterizerState = m_graphicsState.custom.rasterizerState.cachedValue;
 466
 467                 if (m_graphicsState.custom.depthConstBias != 0.0f || m_graphicsState.custom.depthSlopeBias != 0.0f)
 468                 {
 469                         auto rsDesc = CDeviceStatesManagerDX11::GetInstance()->m_StatesRS[m_graphicsState.custom.rasterizerStateIndex].Desc;
 470                         rsDesc.DepthBias = int(m_graphicsState.custom.depthConstBias);
 471                         rsDesc.SlopeScaledDepthBias = m_graphicsState.custom.depthSlopeBias;
 472                         rsDesc.DepthBiasClamp = m_graphicsState.custom.depthBiasClamp;
 473
 474                         uint32 newRasterizerStateIndex = CDeviceStatesManagerDX11::GetInstance()->GetOrCreateRasterState(rsDesc);
 475                         if (newRasterizerStateIndex != uint32(-1))
 476                         {
 477                                 pRasterizerState = CDeviceStatesManagerDX11::GetInstance()->m_StatesRS[newRasterizerStateIndex].pState;
 478                         }
 479                 }
 480
 481                 gcpRendD3D->m_DevMan.SetRasterState(pRasterizerState);
 482                 m_graphicsState.custom.bRasterizerStateDirty = false;
 483         }
 484 }
 485
 486 void CDeviceGraphicsCommandInterfaceImpl::SetInlineConstantBufferImpl(uint32 bindSlot, const CConstantBuffer* pBuffer, EConstantBufferShaderSlot shaderSlot, EShaderStage shaderStages)
 487 {
 488         // Shader stages are ordered by usage-frequency and loop exists according to usage-frequency (VS+PS fast, etc.)
 489         int validShaderStages = shaderStages;
 490         for (EHWShaderClass shaderClass = eHWSC_Vertex; validShaderStages; shaderClass = EHWShaderClass(shaderClass + 1), validShaderStages >>= 1)
 491         {
 492                 if (validShaderStages & 1)
 493                         SetInlineConstantBufferImpl(bindSlot, pBuffer, shaderSlot, shaderClass);
 494         }
 495 }
 496
 497 void CDeviceGraphicsCommandInterfaceImpl::SetInlineConstantBufferImpl(uint32 bindSlot, const CConstantBuffer* pBuffer, EConstantBufferShaderSlot shaderSlot, EHWShaderClass shaderClass)
 498 {
 499         if (m_sharedState.constantBuffer[shaderClass][shaderSlot].Set(pBuffer->GetCode()))
 500         {
 501                 buffer_size_t offset, size;
 502                 D3DBuffer* pBufferDX11 = pBuffer->GetD3D(&offset, &size);
 503
 504                 BindConstantBuffer(shaderClass, pBufferDX11, shaderSlot, offset, size);
 505         }
 506 }
 507
 508 void CDeviceGraphicsCommandInterfaceImpl::SetInlineShaderResourceImpl(uint32 bindSlot, const CDeviceBuffer* pBuffer, EShaderResourceShaderSlot shaderSlot, EShaderStage shaderStages, ResourceViewHandle resourceViewID)
 509 {
 510         // Shader stages are ordered by usage-frequency and loop exists according to usage-frequency (VS+PS fast, etc.)
 511         int validShaderStages = shaderStages;
 512         for (EHWShaderClass shaderClass = eHWSC_Vertex; validShaderStages; shaderClass = EHWShaderClass(shaderClass + 1), validShaderStages >>= 1)
 513         {
 514                 if (validShaderStages & 1)
 515                         SetInlineShaderResourceImpl(bindSlot, pBuffer, shaderSlot, shaderClass, resourceViewID);
 516         }
 517 }
 518
 519 void CDeviceGraphicsCommandInterfaceImpl::SetInlineShaderResourceImpl(uint32 bindSlot, const CDeviceBuffer* pBuffer, EShaderResourceShaderSlot shaderSlot, EHWShaderClass shaderClass, ResourceViewHandle resourceViewID)
 520 {
 521         D3DShaderResource* pBufferViewDX11 = pBuffer->LookupSRV(resourceViewID);
 522
 523         if (m_sharedState.shaderResourceView[shaderClass][shaderSlot].Set(pBufferViewDX11))
 524         {
 525                 BindSRV(shaderClass, pBufferViewDX11, shaderSlot);
 526         }
 527 }
 528
 529 void CDeviceGraphicsCommandInterfaceImpl::SetVertexBuffersImpl(uint32 numStreams, uint32 lastStreamSlot, const CDeviceInputStream* vertexStreams)
 530 {
 531         for (uint32 s = 0; s < numStreams; ++s)
 532         {
 533                 const CDeviceInputStream& current = vertexStreams[s];
 534
 535                 CRY_ASSERT(current.hStream != ~0u);
 536                 {
 537                         buffer_size_t offset;
 538                         D3DBuffer* buffer = gcpRendD3D.m_DevBufMan.GetD3D(current.hStream, &offset);
 539
 540                         gcpRendD3D.m_DevMan.BindVB(buffer, current.nSlot, offset, current.nStride);
 541                 }
 542         }
 543 }
 544
 545 void CDeviceGraphicsCommandInterfaceImpl::SetIndexBufferImpl(const CDeviceInputStream* indexStream)
 546 {
 547         const CDeviceInputStream& current = indexStream[0];
 548
 549         CRY_ASSERT(current.hStream != ~0u);
 550         {
 551                 buffer_size_t offset;
 552                 D3DBuffer* buffer = gcpRendD3D.m_DevBufMan.GetD3D(current.hStream, &offset);
 553
 554 #if !defined(SUPPORT_FLEXIBLE_INDEXBUFFER)
 555                 gcpRendD3D.m_DevMan.BindIB(buffer, offset, DXGI_FORMAT_R16_UINT);
 556 #else
 557                 gcpRendD3D.m_DevMan.BindIB(buffer, offset, (DXGI_FORMAT)current.nStride);
 558 #endif
 559         }
 560 }
 561
 562 void CDeviceGraphicsCommandInterfaceImpl::SetStencilRefImpl(uint8 stencilRefValue)
 563 {
 564         m_graphicsState.custom.bDepthStencilStateDirty = true;
 565 }
 566
 567 void CDeviceGraphicsCommandInterfaceImpl::SetDepthBiasImpl(float constBias, float slopeBias, float biasClamp)
 568 {
 569         m_graphicsState.custom.depthConstBias = constBias;
 570         m_graphicsState.custom.depthSlopeBias = slopeBias;
 571         m_graphicsState.custom.depthBiasClamp = biasClamp;
 572
 573         m_graphicsState.custom.bRasterizerStateDirty = true;
 574 }
 575
 576 void CDeviceGraphicsCommandInterfaceImpl::DrawImpl(uint32 VertexCountPerInstance, uint32 InstanceCount, uint32 StartVertexLocation, uint32 StartInstanceLocation)
 577 {
 578         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 579
 580         ApplyDepthStencilState();
 581         ApplyRasterizerState();
 582
 583         if (InstanceCount > 1 || StartInstanceLocation > 0)
 584         {
 585                 rd->m_DevMan.DrawInstanced(VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation);
 586         }
 587         else
 588         {
 589                 rd->m_DevMan.Draw(VertexCountPerInstance, StartVertexLocation);
 590         }
 591 }
 592
 593 void CDeviceGraphicsCommandInterfaceImpl::DrawIndexedImpl(uint32 IndexCountPerInstance, uint32 InstanceCount, uint32 StartIndexLocation, int BaseVertexLocation, uint32 StartInstanceLocation)
 594 {
 595         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 596
 597 #if !defined(SUPPORT_FLEXIBLE_INDEXBUFFER)
 598         STATIC_CHECK(false, "NOT IMPLEMENTED");
 599 #endif
 600
 601         ApplyDepthStencilState();
 602         ApplyRasterizerState();
 603
 604         if (InstanceCount > 1 || StartInstanceLocation > 0)
 605         {
 606                 rd->m_DevMan.DrawIndexedInstanced(IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation);
 607         }
 608         else
 609         {
 610                 rd->m_DevMan.DrawIndexed(IndexCountPerInstance, StartIndexLocation, BaseVertexLocation);
 611         }
 612 }
 613
 614 void CDeviceGraphicsCommandInterfaceImpl::ClearSurfaceImpl(D3DSurface* pView, const float color[4], UINT numRects, const D3D11_RECT* pRects)
 615 {
 616 #if (CRY_RENDERER_DIRECT3D >= 111)
 617         gcpRendD3D->GetDeviceContext().ClearView(pView, color, numRects, pRects);
 618 #else
 619         CRY_ASSERT(numRects == 0); // not supported on dx11
 620         gcpRendD3D->GetDeviceContext().ClearRenderTargetView(pView, color);
 621 #endif
 622 }
 623
 624 void CDeviceGraphicsCommandInterfaceImpl::ClearSurfaceImpl(D3DDepthSurface* pView, int clearFlags, float depth, uint8 stencil, uint32 numRects, const D3D11_RECT* pRects)
 625 {
 626         CRY_ASSERT(numRects == 0); // not supported on dx11
 627         gcpRendD3D->GetDeviceContext().ClearDepthStencilView(pView, D3D11_CLEAR_FLAG(clearFlags), depth, stencil);
 628 }
 629
 630 void CDeviceGraphicsCommandInterfaceImpl::DiscardContentsImpl(D3DResource* pResource, uint32 numRects, const D3D11_RECT* pRects)
 631 {
 632 #if (CRY_RENDERER_DIRECT3D >= 111)
 633         CRY_ASSERT(numRects == 0); // not supported on dx11.1
 634         gcpRendD3D->GetDeviceContext().DiscardResource(pResource);
 635 #endif
 636 }
 637
 638 void CDeviceGraphicsCommandInterfaceImpl::DiscardContentsImpl(D3DBaseView* pView, uint32 numRects, const D3D11_RECT* pRects)
 639 {
 640 #if (CRY_RENDERER_DIRECT3D >= 111)
 641         if (numRects)
 642                 gcpRendD3D->GetDeviceContext().DiscardView1(pView, numRects, pRects);
 643         else
 644                 gcpRendD3D->GetDeviceContext().DiscardView(pView);
 645 #endif
 646 }
 647
 648 void CDeviceGraphicsCommandInterfaceImpl::BeginOcclusionQueryImpl(D3DOcclusionQuery* pQuery)
 649 {
 650         gcpRendD3D->GetDeviceContext().Begin(pQuery);
 651 }
 652
 653 void CDeviceGraphicsCommandInterfaceImpl::EndOcclusionQueryImpl(D3DOcclusionQuery* pQuery)
 654 {
 655         gcpRendD3D->GetDeviceContext().End(pQuery);
 656 }
 657
 658 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 659 void CDeviceComputeCommandInterfaceImpl::SetPipelineStateImpl(const CDeviceComputePSO* pDevicePSO)
 660 {
 661         const CDeviceComputePSO_DX11* pDevicePsoDX11 = reinterpret_cast<const CDeviceComputePSO_DX11*>(pDevicePSO);
 662
 663         // Shader
 664         const std::array<void*, eHWSC_Num>& shaders = pDevicePsoDX11->m_pDeviceShaders;
 665         BindShader(eHWSC_Compute, (ID3D11Resource*)shaders[eHWSC_Compute]);
 666 }
 667
 668 void CDeviceComputeCommandInterfaceImpl::SetResourcesImpl(uint32 bindSlot, const CDeviceResourceSet* pResources)
 669 {
 670         auto pResourcesDX11 = reinterpret_cast<const CDeviceResourceSet_DX11*>(pResources);
 671
 672         // Bind SRVs
 673         for (int slot = 0; slot < pResourcesDX11->compiledSRVs[eHWSC_Compute].size(); ++slot)
 674         {
 675                 ID3D11ShaderResourceView* pSrv = pResourcesDX11->compiledSRVs[eHWSC_Compute][slot];
 676
 677                 if (pSrv != CDeviceResourceSet_DX11::InvalidPointer)
 678                 {
 679                         if (m_sharedState.shaderResourceView[eHWSC_Compute][slot].Set(pSrv))
 680                         {
 681                                 BindSRV(eHWSC_Compute, pSrv, slot);
 682                         }
 683                 }
 684         }
 685
 686         // Bind Samplers
 687         for (int slot = 0; slot < pResourcesDX11->compiledSamplers[eHWSC_Compute].size(); ++slot)
 688         {
 689                 ID3D11SamplerState* pSamplerState = pResourcesDX11->compiledSamplers[eHWSC_Compute][slot];
 690
 691                 if (pSamplerState != CDeviceResourceSet_DX11::InvalidPointer)
 692                 {
 693                         if (m_sharedState.samplerState[eHWSC_Compute][slot].Set(pSamplerState))
 694                         {
 695                                 BindSampler(eHWSC_Compute, pSamplerState, slot);
 696                         }
 697                 }
 698         }
 699
 700         // Bind constant buffers
 701         for (int i = 0; i < pResourcesDX11->numCompiledCBs[eHWSC_Compute]; ++i)
 702         {
 703                 const CDeviceResourceSet_DX11::SCompiledConstantBuffer& cb = pResourcesDX11->compiledCBs[eHWSC_Compute][i];
 704                 if (m_sharedState.constantBuffer[eHWSC_Compute][cb.slot].Set(cb.code))
 705                 {
 706                         BindConstantBuffer(eHWSC_Compute, cb.pBuffer, cb.slot, cb.offset, cb.size);
 707                 }
 708         }
 709
 710         // Bind UAVs
 711         for (int i = 0; i < pResourcesDX11->numCompiledUAVs; ++i)
 712         {
 713                 const CDeviceResourceSet_DX11::SCompiledUAV& uav = pResourcesDX11->compiledUAVs[i];
 714                 BindUAV(uav.shaderStage, uav.pUav, uav.slot);
 715
 716                 m_computeState.custom.boundUAVs[uav.slot] = true;
 717         }
 718 }
 719
 720 void CDeviceComputeCommandInterfaceImpl::SetInlineConstantBufferImpl(uint32 bindSlot, const CConstantBuffer* pBuffer, EConstantBufferShaderSlot shaderSlot)
 721 {
 722         if (m_sharedState.constantBuffer[eHWSC_Compute][shaderSlot].Set(pBuffer->GetCode()))
 723         {
 724                 BindConstantBuffer(eHWSC_Compute, pBuffer->GetD3D(), shaderSlot);
 725         }
 726 }
 727
 728 void CDeviceComputeCommandInterfaceImpl::SetInlineShaderResourceImpl(uint32 bindSlot, const CDeviceBuffer* pBuffer, EShaderResourceShaderSlot shaderSlot, ResourceViewHandle resourceViewID)
 729 {
 730         D3DShaderResource* pBufferViewDX11 = pBuffer->LookupSRV(resourceViewID);
 731
 732         if (m_sharedState.shaderResourceView[eHWSC_Compute][shaderSlot].Set(pBufferViewDX11))
 733         {
 734                 BindSRV(eHWSC_Compute, pBufferViewDX11, shaderSlot);
 735         }
 736 }
 737
 738 void CDeviceComputeCommandInterfaceImpl::SetInlineConstantsImpl(uint32 bindSlot, uint32 constantCount, float* pConstants)
 739 {
 740         __debugbreak();
 741 }
 742
 743 void CDeviceComputeCommandInterfaceImpl::DispatchImpl(uint32 X, uint32 Y, uint32 Z)
 744 {
 745         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 746         rd->m_DevMan.Dispatch(X, Y, Z);
 747
 748         if (m_computeState.custom.boundUAVs.any())
 749         {
 750                 for (int i = 0; i < m_computeState.custom.boundUAVs.size(); ++i)
 751                 {
 752                         if (m_computeState.custom.boundUAVs[i])
 753                         {
 754                                 BindUAV(eHWSC_Compute, nullptr, i);
 755                         }
 756                 }
 757
 758                 rd->m_DevMan.CommitDeviceStates();
 759
 760                 m_computeState.custom.boundUAVs = 0;
 761                 memset(m_computeState.pResourceSets, 0x0, sizeof(m_computeState.pResourceSets));
 762         }
 763 }
 764
 765 void CDeviceComputeCommandInterfaceImpl::ClearUAVImpl(D3DUAV* pView, const FLOAT Values[4], UINT NumRects, const D3D11_RECT* pRects)
 766 {
 767 #if (CRY_RENDERER_DIRECT3D >= 120)
 768         gcpRendD3D->GetDeviceContext().ClearRectsUnorderedAccessViewFloat(pView, Values, NumRects, pRects);
 769 #else
 770         CRY_ASSERT(NumRects == 0); // not supported on dx11
 771         gcpRendD3D->GetDeviceContext().ClearUnorderedAccessViewFloat(pView, Values);
 772 #endif
 773 }
 774
 775 void CDeviceComputeCommandInterfaceImpl::ClearUAVImpl(D3DUAV* pView, const UINT Values[4], UINT NumRects, const D3D11_RECT* pRects)
 776 {
 777 #if (CRY_RENDERER_DIRECT3D >= 120)
 778         gcpRendD3D->GetDeviceContext().ClearRectsUnorderedAccessViewUint(pView, Values, NumRects, pRects);
 779 #else
 780         CRY_ASSERT(NumRects == 0); // not supported on dx11
 781         gcpRendD3D->GetDeviceContext().ClearUnorderedAccessViewUint(pView, Values);
 782 #endif
 783 }
 784
 785 void CDeviceComputeCommandInterfaceImpl::DiscardUAVContentsImpl(D3DResource* pResource, uint32 numRects, const D3D11_RECT* pRects)
 786 {
 787 #if (CRY_RENDERER_DIRECT3D >= 111)
 788         CRY_ASSERT(numRects == 0); // not supported on dx11.1
 789         gcpRendD3D->GetDeviceContext().DiscardResource(pResource);
 790 #endif
 791 }
 792
 793 void CDeviceComputeCommandInterfaceImpl::DiscardUAVContentsImpl(D3DBaseView* pView, uint32 numRects, const D3D11_RECT* pRects)
 794 {
 795 #if (CRY_RENDERER_DIRECT3D >= 111)
 796         if (numRects)
 797                 gcpRendD3D->GetDeviceContext().DiscardView1(pView, numRects, pRects);
 798         else
 799                 gcpRendD3D->GetDeviceContext().DiscardView(pView);
 800 #endif
 801 }
 802
 803 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 804 void CDeviceNvidiaCommandInterfaceImpl::SetModifiedWModeImpl(bool enabled, uint32 numViewports, const float* pA, const float* pB)
 805 {
 806         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 807         rd->GetDeviceContext().SetModifiedWMode(enabled, numViewports, pA, pB);
 808 }
 809
 810 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 811 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceBuffer* pSrc, CDeviceBuffer* pDst)
 812 {
 813         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 814         rd->GetDeviceContext().CopyResource(pDst->GetBaseBuffer(), pSrc->GetBaseBuffer());
 815 }
 816
 817 void CDeviceCopyCommandInterfaceImpl::CopyImpl(D3DBuffer* pSrc, D3DBuffer* pDst)
 818 {
 819         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 820         rd->GetDeviceContext().CopyResource(pDst, pSrc);
 821 }
 822
 823 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceTexture* pSrc, CDeviceTexture* pDst)
 824 {
 825         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 826         rd->GetDeviceContext().CopyResource(pDst->GetBaseTexture(), pSrc->GetBaseTexture());
 827 }
 828
 829 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceTexture* pSrc, D3DTexture* pDst)
 830 {
 831         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 832         rd->GetDeviceContext().CopyResource(pDst, pSrc->GetBaseTexture());
 833 }
 834
 835 void CDeviceCopyCommandInterfaceImpl::CopyImpl(D3DTexture* pSrc, D3DTexture* pDst)
 836 {
 837         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 838         rd->GetDeviceContext().CopyResource(pDst, pSrc);
 839 }
 840
 841 void CDeviceCopyCommandInterfaceImpl::CopyImpl(D3DTexture* pSrc, CDeviceTexture* pDst)
 842 {
 843         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 844         rd->GetDeviceContext().CopyResource(pDst->GetBaseTexture(), pSrc);
 845 }
 846
 847 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceBuffer* pSrc, CDeviceBuffer* pDst, const SResourceRegionMapping& region)
 848 {
 849         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 850         D3D11_BOX box = { region.SourceOffset.Left, region.SourceOffset.Top, region.SourceOffset.Front, region.SourceOffset.Left + region.Extent.Width, region.SourceOffset.Top + region.Extent.Height, region.SourceOffset.Front + region.Extent.Depth };
 851
 852 #if (CRY_RENDERER_DIRECT3D >= 111)
 853         rd->GetDeviceContext().CopySubresourcesRegion1(pDst->GetBaseBuffer(), region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc->GetBaseBuffer(), region.SourceOffset.Subresource, &box, region.Flags, region.Extent.Subresources);
 854 #else
 855         rd->GetDeviceContext().CopySubresourcesRegion(pDst->GetBaseBuffer(), region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc->GetBaseBuffer(), region.SourceOffset.Subresource, &box, region.Extent.Subresources);
 856 #endif
 857 }
 858
 859 void CDeviceCopyCommandInterfaceImpl::CopyImpl(D3DBuffer* pSrc, D3DBuffer* pDst, const SResourceRegionMapping& region)
 860 {
 861         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 862         D3D11_BOX box = { region.SourceOffset.Left, region.SourceOffset.Top, region.SourceOffset.Front, region.SourceOffset.Left + region.Extent.Width, region.SourceOffset.Top + region.Extent.Height, region.SourceOffset.Front + region.Extent.Depth };
 863
 864 #if (CRY_RENDERER_DIRECT3D >= 111)
 865         rd->GetDeviceContext().CopySubresourcesRegion1(pDst, region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc, region.SourceOffset.Subresource, &box, region.Flags, region.Extent.Subresources);
 866 #else
 867         rd->GetDeviceContext().CopySubresourcesRegion(pDst, region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc, region.SourceOffset.Subresource, &box, region.Extent.Subresources);
 868 #endif
 869 }
 870
 871 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceTexture* pSrc, CDeviceTexture* pDst, const SResourceRegionMapping& region)
 872 {
 873         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 874         D3D11_BOX box = { region.SourceOffset.Left, region.SourceOffset.Top, region.SourceOffset.Front, region.SourceOffset.Left + region.Extent.Width, region.SourceOffset.Top + region.Extent.Height, region.SourceOffset.Front + region.Extent.Depth };
 875
 876         // If CopySubresourceRegion is used with Multisampled or D3D11_BIND_DEPTH_STENCIL Resources, then the whole Subresource must be copied. DstX, DstY, and DstZ must all be 0, while pSrcBox must be NULL.
 877         D3D11_BOX* pBox = &box;
 878         if (pSrc->IsResolvable())
 879         {
 880                 pBox = nullptr;
 881
 882                 CRY_ASSERT(region.DestinationOffset.Left == 0);
 883                 CRY_ASSERT(region.DestinationOffset.Top == 0);
 884                 CRY_ASSERT(region.DestinationOffset.Front == 0);
 885         }
 886
 887 #if (CRY_RENDERER_DIRECT3D >= 111)
 888         rd->GetDeviceContext().CopySubresourcesRegion1(pDst->GetBaseTexture(), region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc->GetBaseTexture(), region.SourceOffset.Subresource, pBox, region.Flags, region.Extent.Subresources);
 889 #else
 890         rd->GetDeviceContext().CopySubresourcesRegion(pDst->GetBaseTexture(), region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc->GetBaseTexture(), region.SourceOffset.Subresource, pBox, region.Extent.Subresources);
 891 #endif
 892 }
 893
 894 void CDeviceCopyCommandInterfaceImpl::CopyImpl(D3DTexture* pSrc, CDeviceTexture* pDst, const SResourceRegionMapping& region)
 895 {
 896         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 897         D3D11_BOX box = { region.SourceOffset.Left, region.SourceOffset.Top, region.SourceOffset.Front, region.SourceOffset.Left + region.Extent.Width, region.SourceOffset.Top + region.Extent.Height, region.SourceOffset.Front + region.Extent.Depth };
 898
 899 #if (CRY_RENDERER_DIRECT3D >= 111)
 900         rd->GetDeviceContext().CopySubresourcesRegion1(pDst->GetBaseTexture(), region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc, region.SourceOffset.Subresource, &box, region.Flags, region.Extent.Subresources);
 901 #else
 902         rd->GetDeviceContext().CopySubresourcesRegion(pDst->GetBaseTexture(), region.DestinationOffset.Subresource, region.DestinationOffset.Left, region.DestinationOffset.Top, region.DestinationOffset.Front, pSrc, region.SourceOffset.Subresource, &box, region.Extent.Subresources);
 903 #endif
 904 }
 905
 906 void CDeviceCopyCommandInterfaceImpl::CopyImpl(const void* pSrc, CConstantBuffer* pDst, const SResourceMemoryAlignment& memoryLayout)
 907 {
 908         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 909         rd->GetDeviceContext().UpdateSubresource(pDst->GetD3D(), 0, nullptr, pSrc, 0, 0);
 910 }
 911
 912 void CDeviceCopyCommandInterfaceImpl::CopyImpl(const void* pSrc, CDeviceBuffer* pDst, const SResourceMemoryAlignment& memoryLayout)
 913 {
 914         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 915         rd->GetDeviceContext().UpdateSubresource(pDst->GetBaseBuffer(), 0, nullptr, pSrc, memoryLayout.rowStride, memoryLayout.planeStride);
 916 }
 917
 918 void CDeviceCopyCommandInterfaceImpl::CopyImpl(const void* pSrc, CDeviceTexture* pDst, const SResourceMemoryAlignment& memoryLayout)
 919 {
 920         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 921         rd->GetDeviceContext().UpdateSubresource(pDst->GetBaseTexture(), 0, nullptr, pSrc, memoryLayout.rowStride, memoryLayout.planeStride);
 922 }
 923
 924 void CDeviceCopyCommandInterfaceImpl::CopyImpl(const void* pSrc, CConstantBuffer* pDst, const SResourceMemoryMapping& region)
 925 {
 926         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 927         CRY_ASSERT((region.Extent.Subresources == 1) && ((region.ResourceOffset.Left == 0) || (CRY_RENDERER_DIRECT3D >= 111))); // TODO: batch
 928         D3D11_BOX box = { region.ResourceOffset.Left, region.ResourceOffset.Top, region.ResourceOffset.Front, region.ResourceOffset.Left + region.Extent.Width, region.ResourceOffset.Top + region.Extent.Height, region.ResourceOffset.Front + region.Extent.Depth };
 929 #if (CRY_RENDERER_DIRECT3D >= 111)
 930         rd->GetDeviceContext().UpdateSubresource1(pDst->GetD3D(), region.ResourceOffset.Subresource, CRY_RENDERER_DIRECT3D >= 111 ? &box : nullptr, pSrc, region.MemoryLayout.rowStride, region.MemoryLayout.planeStride, region.Flags);
 931 #else
 932         rd->GetDeviceContext().UpdateSubresource(pDst->GetD3D(), region.ResourceOffset.Subresource, CRY_RENDERER_DIRECT3D >= 111 ? &box : nullptr, pSrc, region.MemoryLayout.rowStride, region.MemoryLayout.planeStride);
 933 #endif
 934 }
 935
 936 void CDeviceCopyCommandInterfaceImpl::CopyImpl(const void* pSrc, CDeviceBuffer* pDst, const SResourceMemoryMapping& region)
 937 {
 938         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 939         CRY_ASSERT((region.Extent.Subresources == 1) && (CRY_RENDERER_DIRECT3D < 111)); // TODO: batch
 940         D3D11_BOX box = { region.ResourceOffset.Left, region.ResourceOffset.Top, region.ResourceOffset.Front, region.ResourceOffset.Left + region.Extent.Width, region.ResourceOffset.Top + region.Extent.Height, region.ResourceOffset.Front + region.Extent.Depth };
 941 #if (CRY_RENDERER_DIRECT3D >= 111)
 942         rd->GetDeviceContext().UpdateSubresource1(pDst->GetBaseBuffer(), region.ResourceOffset.Subresource, &box, pSrc, region.MemoryLayout.rowStride, region.MemoryLayout.planeStride, region.Flags);
 943 #else
 944         rd->GetDeviceContext().UpdateSubresource(pDst->GetBaseBuffer(), region.ResourceOffset.Subresource, &box, pSrc, region.MemoryLayout.rowStride, region.MemoryLayout.planeStride);
 945 #endif
 946 }
 947
 948 void CDeviceCopyCommandInterfaceImpl::CopyImpl(const void* pSrc, CDeviceTexture* pDst, const SResourceMemoryMapping& region)
 949 {
 950         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 951         CRY_ASSERT(region.Extent.Subresources == 1); // TODO: batch
 952         D3D11_BOX box = { region.ResourceOffset.Left, region.ResourceOffset.Top, region.ResourceOffset.Front, region.ResourceOffset.Left + region.Extent.Width, region.ResourceOffset.Top + region.Extent.Height, region.ResourceOffset.Front + region.Extent.Depth };
 953 #if (CRY_RENDERER_DIRECT3D >= 111)
 954         rd->GetDeviceContext().UpdateSubresource1(pDst->GetBaseTexture(), region.ResourceOffset.Subresource, &box, pSrc, region.MemoryLayout.rowStride, region.MemoryLayout.planeStride, region.Flags);
 955 #else
 956         rd->GetDeviceContext().UpdateSubresource(pDst->GetBaseTexture(), region.ResourceOffset.Subresource, &box, pSrc, region.MemoryLayout.rowStride, region.MemoryLayout.planeStride);
 957 #endif
 958 }
 959
 960 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceBuffer* pSrc, void* pDst, const SResourceMemoryAlignment& memoryLayout)
 961 {
 962         assert(0);
 963 }
 964
 965 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceTexture* pSrc, void* pDst, const SResourceMemoryAlignment& memoryLayout)
 966 {
 967         assert(0);
 968 }
 969
 970 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceBuffer* pSrc, void* pDst, const SResourceMemoryMapping& region)
 971 {
 972         assert(0);
 973 }
 974
 975 void CDeviceCopyCommandInterfaceImpl::CopyImpl(CDeviceTexture* pSrc, void* pDst, const SResourceMemoryMapping& region)
 976 {
 977         assert(0);
 978 }