Code/CryEngine/RenderDll/XRenderD3D9/GraphicsPipeline/ClipVolumes.cpp

   1 // Copyright 2001-2015 Crytek GmbH. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "ClipVolumes.h"
   5 #include "DriverD3D.h"
   6 #include "VolumetricFog.h"
   7
   8 struct SPrimitiveConstants
   9 {
  10         Matrix44 transformMatrix;
  11         Vec4     projRatioScreenScale;
  12         Vec4     blendPlane0;
  13         Vec4     blendPlane1;
  14 };
  15
  16 struct SPrimitiveVolFogConstants
  17 {
  18         Matrix44 transformMatrix;
  19         uint32   sliceIndex[4];
  20 };
  21
  22 CClipVolumesStage::CClipVolumesStage()
  23         : m_nShaderParamCount(0)
  24         , m_pBlendValuesRT(nullptr)
  25         , m_pDepthTarget(nullptr)
  26         , m_pClipVolumeStencilVolumeTex(nullptr)
  27         , m_cleared(MAX_GPU_NUM)
  28         , m_nearDepth(-1.0f)
  29         , m_raymarchDistance(0.0f)
  30         , m_bClipVolumesValid(false)
  31         , m_bBlendPassReady(false)
  32         , m_bOutdoorVisible(false)
  33 {
  34         ZeroArray(m_clipVolumeShaderParams);
  35 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
  36         memset(&m_depthTargetVolFog, 0, sizeof(m_depthTargetVolFog));
  37 #endif
  38 }
  39
  40 CClipVolumesStage::~CClipVolumesStage()
  41 {
  42         SAFE_RELEASE(m_pClipVolumeStencilVolumeTex);
  43 #ifndef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
  44         for (auto& pTex : m_pClipVolumeStencilVolumeTexArray)
  45         {
  46                 SAFE_RELEASE(pTex);
  47         }
  48 #endif
  49 }
  50
  51 void CClipVolumesStage::Init()
  52 {
  53         m_stencilPass.SetFlags(CPrimitiveRenderPass::ePassFlags_VrProjectionPass);
  54         m_blendValuesPass.SetFlags(CPrimitiveRenderPass::ePassFlags_VrProjectionPass);
  55         m_stencilResolvePass.SetFlags(CPrimitiveRenderPass::ePassFlags_VrProjectionPass);
  56
  57 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
  58         m_volumetricStencilPass.SetFlags(CPrimitiveRenderPass::ePassFlags_None);
  59 #endif
  60
  61         for (int i = 0; i < MaxDeferredClipVolumes; ++i)
  62         {
  63                 // Stencil pass: two primitives per clip volume, both share the same constant buffer
  64                 {
  65                         CConstantBufferPtr pCB = gcpRendD3D->m_DevBufMan.CreateConstantBuffer(sizeof(SPrimitiveConstants));
  66
  67                         m_stencilPrimitives[2 * i + 0].SetInlineConstantBuffer(eConstantBufferShaderSlot_PerBatch, pCB, EShaderStage_Vertex);
  68                         m_stencilPrimitives[2 * i + 1].SetInlineConstantBuffer(eConstantBufferShaderSlot_PerBatch, pCB, EShaderStage_Vertex);
  69
  70 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
  71                         pCB = gcpRendD3D->m_DevBufMan.CreateConstantBuffer(sizeof(SPrimitiveVolFogConstants));
  72                         m_stencilPrimitivesVolFog[2 * i + 0].SetInlineConstantBuffer(eConstantBufferShaderSlot_PerBatch, pCB, EShaderStage_Geometry | EShaderStage_Vertex);
  73                         m_stencilPrimitivesVolFog[2 * i + 1].SetInlineConstantBuffer(eConstantBufferShaderSlot_PerBatch, pCB, EShaderStage_Geometry | EShaderStage_Vertex);
  74 #endif
  75                 }
  76
  77                 // Blend values pass: one primitive per clip volume, shared CB for vertex and pixel shader
  78                 {
  79                         CConstantBufferPtr pCB = gcpRendD3D->m_DevBufMan.CreateConstantBuffer(sizeof(SPrimitiveConstants));
  80
  81                         m_blendPrimitives[i].SetInlineConstantBuffer(eConstantBufferShaderSlot_PerBatch, pCB, EShaderStage_Pixel | EShaderStage_Vertex);
  82                 }
  83
  84         }
  85
  86         // TODO: move this texture to intra-view-shared data structure after removing old graphics pipeline.
  87 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
  88         const uint32 flags = FT_NOMIPS | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL;
  89 #else
  90         const uint32 flags = FT_NOMIPS | FT_DONT_STREAM | FT_USAGE_RENDERTARGET;
  91 #endif
  92         CRY_ASSERT(m_pClipVolumeStencilVolumeTex == nullptr);
  93         m_pClipVolumeStencilVolumeTex = CTexture::GetOrCreateTextureObject("$VolFogClipVolumeStencil", 0, 0, 0, eTT_2D, flags, eTF_Unknown);
  94 }
  95
  96 void CClipVolumesStage::Prepare(CRenderView* pRenderView)
  97 {
  98         m_nShaderParamCount = 0;
  99         m_bClipVolumesValid = false;
 100         m_bOutdoorVisible = false;
 101
 102         m_pBlendValuesRT = CTexture::s_ptexVelocity;
 103         m_pDepthTarget = gcpRendD3D->m_pZTexture;
 104
 105         D3DViewPort viewport;
 106         viewport.TopLeftX = viewport.TopLeftY = 0.0f;
 107         viewport.Width = (float)m_pBlendValuesRT->GetWidth();
 108         viewport.Height = (float)m_pBlendValuesRT->GetHeight();
 109         viewport.MinDepth = 0.0f;
 110         viewport.MaxDepth = 1.0f;
 111
 112         m_stencilPass.SetDepthTarget(m_pDepthTarget);
 113         m_stencilPass.SetViewport(viewport);
 114         m_stencilPass.BeginAddingPrimitives();
 115
 116         m_blendValuesPass.SetRenderTarget(0, m_pBlendValuesRT);
 117         m_blendValuesPass.SetDepthTarget(m_pDepthTarget);
 118         m_blendValuesPass.SetViewport(viewport);
 119         m_blendValuesPass.BeginAddingPrimitives();
 120
 121         PrepareVolumetricFog();
 122         if (gcpRendD3D->m_bVolumetricFogEnabled)
 123         {
 124 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
 125                 m_volumetricStencilPass.BeginAddingPrimitives();
 126 #else
 127                 for (auto& pass : m_volumetricStencilPassArray)
 128                         pass->BeginAddingPrimitives();
 129 #endif
 130         }
 131
 132         const uint32 StencilStateInitialMarkup =
 133           STENC_FUNC(FSS_STENCFUNC_GEQUAL) |
 134           STENCOP_FAIL(FSS_STENCOP_KEEP) |
 135           STENCOP_ZFAIL(FSS_STENCOP_REPLACE) |
 136           STENCOP_PASS(FSS_STENCOP_KEEP);
 137
 138         const uint32 StencilStateInsideOutsideMarkup =
 139           STENC_FUNC(FSS_STENCFUNC_GEQUAL) |
 140           STENCOP_FAIL(FSS_STENCOP_KEEP) |
 141           STENCOP_ZFAIL(FSS_STENCOP_INVERT) |
 142           STENCOP_PASS(FSS_STENCOP_KEEP);
 143
 144         const uint32 StencilStateTest =
 145           STENC_FUNC(FSS_STENCFUNC_EQUAL) |
 146           STENCOP_FAIL(FSS_STENCOP_KEEP) |
 147           STENCOP_ZFAIL(FSS_STENCOP_KEEP) |
 148           STENCOP_PASS(FSS_STENCOP_KEEP);
 149
 150         const uint8 StencilReadWriteMask = 0xFF & ~BIT_STENCIL_RESERVED;
 151
 152         static CCryNameTSCRC techStencil = "ClipVolumeStencil";
 153         static CCryNameTSCRC techPortalBlend = "ClipVolumeBlendValue";
 154
 155         static ICVar* pPortalsBlendCVar = iConsole->GetCVar("e_PortalsBlend");
 156         const bool bRenderPortalBlendValues = pPortalsBlendCVar->GetIVal() > 0;
 157         const bool bRenderVisAreas = CRenderer::CV_r_VisAreaClipLightsPerPixel > 0;
 158
 159         const auto& clipVolumes = pRenderView->GetClipVolumes();
 160         CStandardGraphicsPipeline::SViewInfo viewInfo[2];
 161         int viewInfoCount = gcpRendD3D->GetGraphicsPipeline().GetViewInfo(viewInfo);
 162         const CRenderCamera& rc = *(viewInfo[0].pRenderCamera);
 163         const bool bReverseDepth = (viewInfo[0].flags & CStandardGraphicsPipeline::SViewInfo::eFlags_ReverseDepth) != 0;
 164
 165         Vec2 projRatio;
 166         float zn = rc.fNear;
 167         float zf = rc.fFar;
 168         projRatio.x = bReverseDepth ? zn / (zn - zf) : zf / (zf - zn);
 169         projRatio.y = bReverseDepth ? zn / (zf - zn) : zn / (zn - zf);
 170
 171 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
 172         static CCryNameTSCRC techStencilVolFog = "ClipVolumeStencilVolFog";
 173         const Vec3 cameraFrontVec = rc.vZ;
 174         SCGParamsPF& PF = gcpRendD3D->m_cEF.m_PF[gcpRendD3D->m_RP.m_nProcessThreadID];
 175         const float raymarchStart = PF.pVolumetricFogSamplingParams.x;
 176         const float invRaymarchDistance = PF.pVolumetricFogSamplingParams.y;
 177         const int32 volFogDepthNum = CVolumetricFogStage::GetVolumeTextureDepthSize();
 178         const float fVolFogDepthNum = static_cast<float>(volFogDepthNum);
 179         const int32 maxDepthSliceNum = 64; // this must exactly match to ClipVolumeVolFogGS shader's limitation.
 180 #endif
 181
 182         m_nShaderParamCount = 0;
 183         for (int i = 0; i < VisAreasOutdoorStencilOffset; ++i)
 184         {
 185                 uint32 nFlags = IClipVolume::eClipVolumeConnectedToOutdoor | IClipVolume::eClipVolumeAffectedBySun;
 186                 m_clipVolumeShaderParams[m_nShaderParamCount++] = Vec4(gEnv->p3DEngine->GetSkyColor() * gcpRendD3D->m_fAdaptedSceneScaleLBuffer, alias_cast<float>(nFlags));
 187         }
 188
 189         for (const auto& volume : clipVolumes)
 190         {
 191                 // Update shader params
 192                 const uint32 paramIndex = volume.nStencilRef + 1;
 193                 CRY_ASSERT(paramIndex >= VisAreasOutdoorStencilOffset);
 194
 195                 if (paramIndex < MaxDeferredClipVolumes)
 196                 {
 197                         uint32 nData =
 198                           (volume.blendInfo[1].blendID + 1) << 24 |
 199                           (volume.blendInfo[0].blendID + 1) << 16 |
 200                           volume.nFlags;
 201
 202                         m_clipVolumeShaderParams[paramIndex] = Vec4(0, 0, 0, alias_cast<float>(nData));
 203                         m_bOutdoorVisible |= volume.nFlags & IClipVolume::eClipVolumeConnectedToOutdoor ? true : false;
 204
 205                         m_nShaderParamCount = max(m_nShaderParamCount, paramIndex + 1);
 206                 }
 207         }
 208
 209         // Create stencil and blend pass primitives
 210         for (int i = clipVolumes.size() - 1; i >= 0; --i)
 211         {
 212                 const SDeferredClipVolume& volume = clipVolumes[i];
 213                 if (volume.m_pRenderMesh && volume.nStencilRef < MaxDeferredClipVolumes)
 214                 {
 215                         if ((volume.nFlags & IClipVolume::eClipVolumeIsVisArea) != 0 && !bRenderVisAreas)
 216                                 continue;
 217
 218                         CRY_ASSERT(((volume.nStencilRef + 1) & (BIT_STENCIL_RESERVED | BIT_STENCIL_INSIDE_CLIPVOLUME)) == 0);
 219                         const int stencilRef = ~(volume.nStencilRef + 1) & ~(BIT_STENCIL_RESERVED | BIT_STENCIL_INSIDE_CLIPVOLUME);
 220
 221                         buffer_handle_t hVertexStream = ~0u;
 222                         buffer_handle_t hIndexStream = ~0u;
 223                         CRenderMesh* pRenderMesh = nullptr;
 224
 225                         if (pRenderMesh = reinterpret_cast<CRenderMesh*>(volume.m_pRenderMesh.get()))
 226                         {
 227                                 hVertexStream = pRenderMesh->_GetVBStream(VSF_GENERAL);
 228                                 hIndexStream = pRenderMesh->_GetIBStream();
 229
 230                                 if (hVertexStream != ~0u && hIndexStream != ~0u)
 231                                 {
 232                                         // Initial markup
 233                                         CRenderPrimitive& primInit = m_stencilPrimitives[2 * i + 0];
 234                                         primInit.SetTechnique(CShaderMan::s_shDeferredShading, techStencil, 0);
 235                                         primInit.SetRenderState((bReverseDepth ? GS_DEPTHFUNC_GEQUAL : GS_DEPTHFUNC_LEQUAL) | GS_STENCIL);
 236                                         primInit.SetCustomVertexStream(hVertexStream, pRenderMesh->_GetVertexFormat(), pRenderMesh->GetStreamStride(VSF_GENERAL));
 237                                         primInit.SetCustomIndexStream(hIndexStream, (sizeof(vtx_idx) == 2 ? Index16 : Index32));
 238                                         primInit.SetCullMode(eCULL_Front);
 239                                         primInit.SetStencilState(StencilStateInitialMarkup, stencilRef, StencilReadWriteMask, StencilReadWriteMask);
 240                                         primInit.SetDrawInfo(eptTriangleList, 0, 0, pRenderMesh->_GetNumInds());
 241                                         primInit.Compile(m_stencilPass);
 242
 243                                         // Update constant buffer. NOTE: buffer is assigned to preallocated primitives
 244                                         auto& constantManager = primInit.GetConstantManager();
 245
 246                                         auto constants = constantManager.BeginTypedConstantUpdate<SPrimitiveConstants>(eConstantBufferShaderSlot_PerBatch, EShaderStage_Vertex);
 247                                         constants->transformMatrix = Matrix44(volume.mWorldTM.GetTransposed()) * viewInfo[0].cameraProjMatrix;
 248
 249                                         if (viewInfoCount > 1)
 250                                         {
 251                                                 constants.BeginStereoOverride();
 252                                                 constants->transformMatrix = Matrix44(volume.mWorldTM.GetTransposed()) * viewInfo[1].cameraProjMatrix;
 253                                         }
 254
 255                                         constantManager.EndTypedConstantUpdate(constants);
 256
 257                                         // Inside/outside test
 258                                         CRenderPrimitive& primMarkup = m_stencilPrimitives[2 * i + 1];
 259                                         primMarkup.SetTechnique(CShaderMan::s_shDeferredShading, techStencil, 0);
 260                                         primMarkup.SetRenderState((bReverseDepth ? GS_DEPTHFUNC_GEQUAL : GS_DEPTHFUNC_LEQUAL) | GS_STENCIL);
 261                                         primMarkup.SetCustomVertexStream(hVertexStream, pRenderMesh->_GetVertexFormat(), pRenderMesh->GetStreamStride(VSF_GENERAL));
 262                                         primMarkup.SetCustomIndexStream(hIndexStream, (sizeof(vtx_idx) == 2 ? Index16 : Index32));
 263                                         primMarkup.SetCullMode(eCULL_None);
 264                                         primMarkup.SetStencilState(StencilStateInsideOutsideMarkup, ~stencilRef, StencilReadWriteMask, StencilReadWriteMask);
 265                                         primMarkup.SetDrawInfo(eptTriangleList, 0, 0, pRenderMesh->_GetNumInds());
 266                                         primMarkup.Compile(m_stencilPass);
 267
 268                                         m_stencilPass.AddPrimitive(&primInit);
 269                                         m_stencilPass.AddPrimitive(&primMarkup);
 270
 271                                         if (gcpRendD3D->m_bVolumetricFogEnabled)
 272                                         {
 273 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
 274                                                 // calculate min depth index of volumetric fog coordinate.
 275                                                 const float radius = volume.mAABB.GetRadius();
 276                                                 const float distToCenter = -rc.WorldToCamZ(volume.mAABB.GetCenter());
 277                                                 const float minW = max(distToCenter - radius, 0.0f);
 278                                                 float fMinDepthIndex = fVolFogDepthNum * CVolumetricFogStage::GetDepthTexcoordFromLinearDepthScaled(minW, raymarchStart, invRaymarchDistance, fVolFogDepthNum);
 279                                                 fMinDepthIndex = max(0.0f, floorf(fMinDepthIndex));
 280                                                 int32 minDepthIndex = static_cast<int32>(fMinDepthIndex);
 281                                                 minDepthIndex = max(min(minDepthIndex, volFogDepthNum - 1), 0);
 282
 283                                                 // prepare primitive for volumetric fog when it's in the range of volumetric fog.
 284                                                 if (minDepthIndex < volFogDepthNum)
 285                                                 {
 286                                                         // Initial markup
 287                                                         CRenderPrimitive& primInit = m_stencilPrimitivesVolFog[2 * i + 0];
 288                                                         primInit.SetTechnique(CShaderMan::s_shDeferredShading, techStencilVolFog, 0);
 289                                                         primInit.SetRenderState((bReverseDepth ? GS_DEPTHFUNC_GEQUAL : GS_DEPTHFUNC_LEQUAL) | GS_STENCIL);
 290                                                         primInit.SetCustomVertexStream(hVertexStream, pRenderMesh->_GetVertexFormat(), pRenderMesh->GetStreamStride(VSF_GENERAL));
 291                                                         primInit.SetCustomIndexStream(hIndexStream, (sizeof(vtx_idx) == 2 ? Index16 : Index32));
 292                                                         primInit.SetCullMode(eCULL_Front);
 293                                                         primInit.SetStencilState(StencilStateInitialMarkup, stencilRef, StencilReadWriteMask, StencilReadWriteMask);
 294                                                         primInit.SetDrawInfo(eptTriangleList, 0, 0, pRenderMesh->_GetNumInds());
 295                                                         primInit.Compile(m_volumetricStencilPass);
 296
 297                                                         // Update constant buffer. NOTE: buffer is assigned to preallocated primitives
 298                                                         auto& constantManager = primInit.GetConstantManager();
 299
 300                                                         auto constants = constantManager.BeginTypedConstantUpdate<SPrimitiveVolFogConstants>(eConstantBufferShaderSlot_PerBatch, EShaderStage_Geometry | EShaderStage_Vertex);
 301                                                         constants->transformMatrix = Matrix44(volume.mWorldTM.GetTransposed()) * viewInfo[0].cameraProjMatrix;
 302
 303                                                         // calculate max depth index of volumetric fog coordinate.
 304                                                         const float maxW = max(distToCenter + radius, 0.0f);
 305                                                         float fMaxDepthIndex = fVolFogDepthNum * CVolumetricFogStage::GetDepthTexcoordFromLinearDepthScaled(maxW, raymarchStart, invRaymarchDistance, fVolFogDepthNum);
 306                                                         fMaxDepthIndex = max(0.0f, ceilf(fMaxDepthIndex));
 307                                                         int32 maxDepthIndex = static_cast<int32>(fMaxDepthIndex);
 308
 309                                                         maxDepthIndex = max(maxDepthIndex, 0);
 310                                                         maxDepthIndex = min(maxDepthIndex, minDepthIndex + maxDepthSliceNum);
 311                                                         maxDepthIndex = min(maxDepthIndex, volFogDepthNum);
 312
 313                                                         constants->sliceIndex[0] = minDepthIndex;
 314                                                         constants->sliceIndex[1] = maxDepthIndex;
 315
 316                                                         if (viewInfoCount > 1)
 317                                                         {
 318                                                                 constants.BeginStereoOverride();
 319                                                                 constants->transformMatrix = Matrix44(volume.mWorldTM.GetTransposed()) * viewInfo[1].cameraProjMatrix;
 320                                                                 constants->sliceIndex[0] = minDepthIndex;
 321                                                                 constants->sliceIndex[1] = maxDepthIndex;
 322                                                         }
 323
 324                                                         constantManager.EndTypedConstantUpdate(constants);
 325
 326                                                         // Inside/outside test
 327                                                         CRenderPrimitive& primMarkup = m_stencilPrimitivesVolFog[2 * i + 1];
 328                                                         primMarkup.SetTechnique(CShaderMan::s_shDeferredShading, techStencilVolFog, 0);
 329                                                         primMarkup.SetRenderState((bReverseDepth ? GS_DEPTHFUNC_GEQUAL : GS_DEPTHFUNC_LEQUAL) | GS_STENCIL);
 330                                                         primMarkup.SetCustomVertexStream(hVertexStream, pRenderMesh->_GetVertexFormat(), pRenderMesh->GetStreamStride(VSF_GENERAL));
 331                                                         primMarkup.SetCustomIndexStream(hIndexStream, (sizeof(vtx_idx) == 2 ? Index16 : Index32));
 332                                                         primMarkup.SetCullMode(eCULL_None);
 333                                                         primMarkup.SetStencilState(StencilStateInsideOutsideMarkup, ~stencilRef, StencilReadWriteMask, StencilReadWriteMask);
 334                                                         primMarkup.SetDrawInfo(eptTriangleList, 0, 0, pRenderMesh->_GetNumInds());
 335                                                         primMarkup.Compile(m_volumetricStencilPass);
 336
 337                                                         m_volumetricStencilPass.AddPrimitive(&primInit);
 338                                                         m_volumetricStencilPass.AddPrimitive(&primMarkup);
 339                                                 }
 340 #else
 341                                                 for (auto& pass : m_volumetricStencilPassArray)
 342                                                 {
 343                                                         pass->AddPrimitive(&primInit);
 344                                                         pass->AddPrimitive(&primMarkup);
 345                                                 }
 346 #endif
 347                                         }
 348                                 }
 349                         }
 350
 351                         // Blend values
 352                         if (bRenderPortalBlendValues && (volume.nFlags & IClipVolume::eClipVolumeBlend))
 353                         {
 354                                 const int stencilTestRef = BIT_STENCIL_INSIDE_CLIPVOLUME + volume.nStencilRef + 1;
 355
 356                                 CRenderPrimitive& primBlend = m_blendPrimitives[i];
 357                                 primBlend.SetTechnique(CShaderMan::s_shDeferredShading, techPortalBlend, CVrProjectionManager::Instance()->GetRTFlags());
 358                                 primBlend.SetRenderState(GS_STENCIL | GS_NODEPTHTEST | GS_NOCOLMASK_R | GS_NOCOLMASK_B | GS_NOCOLMASK_A);
 359                                 primBlend.SetTexture(3, CTexture::s_ptexZTarget);
 360                                 primBlend.SetCullMode(eCULL_Front);
 361                                 primBlend.SetStencilState(StencilStateTest, stencilTestRef, StencilReadWriteMask, StencilReadWriteMask);
 362                                 primBlend.Compile(m_blendValuesPass);
 363
 364                                 auto& constantManager = primBlend.GetConstantManager();
 365                                 auto constants = constantManager.BeginTypedConstantUpdate<SPrimitiveConstants>(eConstantBufferShaderSlot_PerBatch, EShaderStage_Pixel | EShaderStage_Vertex);
 366
 367                                 constants->projRatioScreenScale = Vec4(projRatio.x, projRatio.y, 1.0f / m_pBlendValuesRT->GetWidth(), 1.0f / m_pBlendValuesRT->GetHeight());
 368                                 constants->blendPlane0 = viewInfo[0].invCameraProjMatrix * volume.blendInfo[0].blendPlane;
 369                                 constants->blendPlane1 = viewInfo[0].invCameraProjMatrix * volume.blendInfo[1].blendPlane;
 370
 371                                 if (hVertexStream != ~0u && hIndexStream != ~0u)
 372                                 {
 373                                         constants->transformMatrix = Matrix44(volume.mWorldTM.GetTransposed()) * viewInfo[0].cameraProjMatrix;
 374
 375                                         primBlend.SetCustomVertexStream(hVertexStream, pRenderMesh->_GetVertexFormat(), pRenderMesh->GetStreamStride(VSF_GENERAL));
 376                                         primBlend.SetCustomIndexStream(hIndexStream, (sizeof(vtx_idx) == 2 ? Index16 : Index32));
 377                                         primBlend.SetDrawInfo(eptTriangleList, 0, 0, pRenderMesh->_GetNumInds());
 378                                 }
 379                                 else
 380                                 {
 381                                         constants->transformMatrix = Matrix44(IDENTITY);
 382
 383                                         primBlend.SetPrimitiveType(CRenderPrimitive::ePrim_Triangle);
 384                                         primBlend.SetDrawInfo(eptTriangleList, 0, 0, 3);
 385                                 }
 386
 387                                 if (viewInfoCount > 1)
 388                                 {
 389                                         constants.BeginStereoOverride();
 390                                         constants->blendPlane0 = viewInfo[1].invCameraProjMatrix * volume.blendInfo[0].blendPlane;
 391                                         constants->blendPlane1 = viewInfo[1].invCameraProjMatrix * volume.blendInfo[1].blendPlane;
 392
 393                                         if (hVertexStream != ~0u && hIndexStream != ~0u)
 394                                                 constants->transformMatrix = Matrix44(volume.mWorldTM.GetTransposed()) * viewInfo[1].cameraProjMatrix;
 395
 396                                 }
 397
 398                                 constantManager.EndTypedConstantUpdate(constants);
 399
 400                                 m_blendValuesPass.AddPrimitive(&primBlend);
 401                         }
 402                 }
 403         }
 404 }
 405
 406 void CClipVolumesStage::Execute()
 407 {
 408         PROFILE_LABEL_SCOPE("CLIPVOLUMES");
 409
 410         // Render clip volumes to stencil
 411         m_stencilPass.Execute();
 412
 413         // Render portal blend values
 414         m_blendValuesPass.Execute();
 415
 416         // Resolve final stencil buffer
 417         {
 418                 static CCryNameTSCRC techResolveStencil("ResolveStencil");
 419
 420                 m_stencilResolvePass.SetPrimitiveFlags(CRenderPrimitive::eFlags_None);
 421                 m_stencilResolvePass.SetTechnique(CShaderMan::s_shDeferredShading, techResolveStencil, 0);
 422                 m_stencilResolvePass.SetRenderTarget(0, m_pBlendValuesRT);
 423                 m_stencilResolvePass.SetState(GS_NODEPTHTEST | GS_NOCOLMASK_G | GS_NOCOLMASK_B | GS_NOCOLMASK_A);
 424                 m_stencilResolvePass.SetTexture(4, m_pDepthTarget, EDefaultResourceViews::StencilOnly);
 425                 m_stencilResolvePass.BeginConstantUpdate();
 426                 m_stencilResolvePass.Execute();
 427         }
 428
 429         ExecuteVolumetricFog();
 430
 431         m_bClipVolumesValid = true;
 432 }
 433
 434 CTexture* CClipVolumesStage::GetClipVolumeStencilVolumeTexture() const
 435 {
 436         return m_pClipVolumeStencilVolumeTex;
 437 }
 438
 439 void CClipVolumesStage::PrepareVolumetricFog()
 440 {
 441         if (gcpRendD3D->m_bVolumetricFogEnabled)
 442         {
 443                 const int32 screenWidth = gcpRendD3D->GetWidth();
 444                 const int32 screenHeight = gcpRendD3D->GetHeight();
 445
 446                 // size for view frustum aligned volume texture.
 447                 const int32 scaledWidth = CVolumetricFogStage::GetVolumeTextureSize(screenWidth, CRenderer::CV_r_VolumetricFogTexScale);
 448                 const int32 scaledHeight = CVolumetricFogStage::GetVolumeTextureSize(screenHeight, CRenderer::CV_r_VolumetricFogTexScale);
 449                 const int32 depth = CVolumetricFogStage::GetVolumeTextureDepthSize();
 450
 451                 D3DViewPort viewport;
 452                 viewport.TopLeftX = viewport.TopLeftY = 0.0f;
 453                 viewport.Width = static_cast<float>(scaledWidth);
 454                 viewport.Height = static_cast<float>(scaledHeight);
 455                 viewport.MinDepth = 0.0f;
 456                 viewport.MaxDepth = 1.0f;
 457
 458 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
 459                 CRY_ASSERT(m_pClipVolumeStencilVolumeTex);
 460                 if (m_pClipVolumeStencilVolumeTex
 461                     && (m_pClipVolumeStencilVolumeTex->GetWidth() != scaledWidth
 462                         || m_pClipVolumeStencilVolumeTex->GetHeight() != scaledHeight
 463                         || !CTexture::IsTextureExist(m_pClipVolumeStencilVolumeTex))
 464                     || m_depthTargetArrayVolFog.empty()
 465                     || m_depthTargetArrayVolFog.size() != depth)
 466                 {
 467                         m_volumetricStencilPass.SetViewport(viewport);
 468
 469                         // create jittered depth passes
 470                         {
 471                                 for (int32 i = 0; i < m_jitteredDepthPassArray.size(); ++i)
 472                                 {
 473                                         m_jitteredDepthPassArray[i].reset();
 474                                 }
 475
 476                                 m_jitteredDepthPassArray.resize(depth);
 477
 478                                 for (int32 i = 0; i < depth; ++i)
 479                                 {
 480                                         m_jitteredDepthPassArray[i] = stl::make_unique<CFullscreenPass>();
 481                                         m_jitteredDepthPassArray[i]->SetViewport(viewport);
 482                                         m_jitteredDepthPassArray[i]->SetFlags(CPrimitiveRenderPass::ePassFlags_None);
 483                                 }
 484                         }
 485
 486                         m_depthTargetArrayVolFog.clear();
 487                         m_depthTargetArrayVolFog.resize(depth);
 488
 489                         const uint32 commonFlags = FT_NOMIPS | FT_DONT_STREAM | FT_DONT_RELEASE;
 490                         const uint32 rtFlags = commonFlags | FT_USAGE_RENDERTARGET;
 491                         const uint32 dsFlags = commonFlags | FT_USAGE_DEPTHSTENCIL;
 492                         const int32 w = scaledWidth;
 493                         const int32 h = scaledHeight;
 494                         const int32 d = depth;
 495                         ETEX_Format format = eTF_D24S8;
 496                         CTexture* pTex = CTexture::GetOrCreateTextureArray("$VolFogClipVolumeStencil", w, h, d, 1, eTT_2DArray, dsFlags, format);
 497
 498                         if (pTex == nullptr
 499                             || m_pClipVolumeStencilVolumeTex != pTex // texture name must exactly match the name when creating texture object.
 500                             || pTex->GetFlags() & FT_FAILED)
 501                         {
 502                                 CryFatalError("Couldn't allocate texture.");
 503                         }
 504
 505                         // DSV to clear stencil buffer.
 506                         m_depthTargetVolFog = m_pClipVolumeStencilVolumeTex;
 507
 508                         // separate DSVs to write jittering depth.
 509                         for (int32 i = 0; i < m_depthTargetArrayVolFog.size(); ++i)
 510                         {
 511                                 SResourceView sliceView = SResourceView::DepthStencilView(DeviceFormats::ConvertFromTexFormat(m_depthTargetVolFog->GetDstFormat()), i, 1, 0);
 512                                 m_depthTargetArrayVolFog[i] = m_depthTargetVolFog->GetDevTexture()->GetOrCreateResourceViewHandle(sliceView); // separate DSV
 513                         }
 514
 515                         // set depth target before AddPrimitive() is called.
 516                         m_volumetricStencilPass.SetDepthTarget(m_depthTargetVolFog);
 517
 518                         // this buffer is managed explicitly on multi GPU.
 519                         m_pClipVolumeStencilVolumeTex->DisableMgpuSync();
 520
 521                         // need to clear depth buffer.
 522                         const int32 safeMargin = 2; // workaround: shader isn't activated in initial several frames.
 523                         m_cleared = gcpRendD3D->GetActiveGPUCount() + safeMargin;
 524                 }
 525 #else
 526                 CRY_ASSERT(m_pClipVolumeStencilVolumeTex);
 527                 if (m_pClipVolumeStencilVolumeTex
 528                     && (m_pClipVolumeStencilVolumeTex->GetWidth() != scaledWidth
 529                         || m_pClipVolumeStencilVolumeTex->GetHeight() != scaledHeight
 530                         || !CTexture::IsTextureExist(m_pClipVolumeStencilVolumeTex))
 531                     || m_depthTargetArrayVolFog.empty()
 532                     || m_depthTargetArrayVolFog.size() != depth)
 533                 {
 534                         // create volume stencil passes
 535                         {
 536                                 for (int32 i = 0; i < m_volumetricStencilPassArray.size(); ++i)
 537                                 {
 538                                         m_volumetricStencilPassArray[i].reset();
 539                                 }
 540
 541                                 m_volumetricStencilPassArray.resize(depth);
 542
 543                                 for (int32 i = 0; i < depth; ++i)
 544                                 {
 545                                         m_volumetricStencilPassArray[i] = stl::make_unique<CFullscreenPass>();
 546                                         m_volumetricStencilPassArray[i]->SetViewport(viewport);
 547                                         m_volumetricStencilPassArray[i]->SetFlags(CPrimitiveRenderPass::ePassFlags_None);
 548                                 }
 549                         }
 550
 551                         // create stencil resolve passes
 552                         {
 553                                 for (int32 i = 0; i < m_resolveVolumetricStencilPassArray.size(); ++i)
 554                                 {
 555                                         m_resolveVolumetricStencilPassArray[i].reset();
 556                                 }
 557
 558                                 m_resolveVolumetricStencilPassArray.resize(depth);
 559
 560                                 for (int32 i = 0; i < depth; ++i)
 561                                 {
 562                                         m_resolveVolumetricStencilPassArray[i] = stl::make_unique<CFullscreenPass>();
 563                                         m_resolveVolumetricStencilPassArray[i]->SetViewport(viewport);
 564                                         m_resolveVolumetricStencilPassArray[i]->SetFlags(CPrimitiveRenderPass::ePassFlags_None);
 565                                 }
 566                         }
 567
 568                         // create jittered depth passes
 569                         {
 570                                 for (int32 i = 0; i < m_jitteredDepthPassArray.size(); ++i)
 571                                 {
 572                                         m_jitteredDepthPassArray[i].reset();
 573                                 }
 574
 575                                 m_jitteredDepthPassArray.resize(depth);
 576
 577                                 for (int32 i = 0; i < depth; ++i)
 578                                 {
 579                                         m_jitteredDepthPassArray[i] = stl::make_unique<CFullscreenPass>();
 580                                         m_jitteredDepthPassArray[i]->SetViewport(viewport);
 581                                         m_jitteredDepthPassArray[i]->SetFlags(CPrimitiveRenderPass::ePassFlags_None);
 582                                 }
 583                         }
 584
 585                         const int32 w = scaledWidth;
 586                         const int32 h = scaledHeight;
 587                         const int32 d = depth;
 588
 589                         // create depth stencil textures
 590                         {
 591                                 const uint32 commonFlags = FT_NOMIPS | FT_DONT_STREAM | FT_DONT_RELEASE;
 592                                 const uint32 rtFlags = commonFlags | FT_USAGE_RENDERTARGET;
 593                                 ETEX_Format format = eTF_R8;
 594
 595                                 CTexture* pTex = CTexture::GetOrCreateTextureArray("$VolFogClipVolumeStencil", w, h, d, 1, eTT_2D, rtFlags, format);
 596
 597                                 if (pTex == nullptr
 598                                     || m_pClipVolumeStencilVolumeTex != pTex // texture name must exactly match the name when creating texture object.
 599                                     || pTex->GetFlags() & FT_FAILED)
 600                                 {
 601                                         CryFatalError("Couldn't allocate texture.");
 602                                 }
 603
 604                                 size_t size = m_pClipVolumeStencilVolumeTexArray.size();
 605
 606                                 for (uint32 i = 0; i < size; ++i)
 607                                 {
 608                                         SAFE_RELEASE(m_pClipVolumeStencilVolumeTexArray[i]);
 609                                 }
 610
 611                                 m_pClipVolumeStencilVolumeTexArray.resize(depth);
 612
 613                                 const uint32 dsFlags = commonFlags | FT_USAGE_RENDERTARGET | FT_USAGE_DEPTHSTENCIL;
 614                                 ETEX_Format depthFormat = eTF_D24S8;
 615
 616                                 for (uint32 i = 0; i < depth; ++i)
 617                                 {
 618                                         CTexture* pTex = new CTexture(dsFlags);
 619                                         if (!(pTex->Create2DTexture(w, h, 1, dsFlags, nullptr, depthFormat)))
 620                                         {
 621                                                 CryFatalError("Couldn't allocate texture.");
 622                                         }
 623
 624                                         m_pClipVolumeStencilVolumeTexArray[i] = pTex;
 625                                 }
 626                         }
 627
 628                         // create depth targets
 629                         {
 630                                 m_depthTargetArrayVolFog.clear();
 631                                 m_depthTargetArrayVolFog.resize(depth);
 632
 633                                 for (int32 i = 0; i < m_depthTargetArrayVolFog.size(); ++i)
 634                                 {
 635                                         auto& depthTarget = m_depthTargetArrayVolFog[i];
 636                                         CTexture* pTex = m_pClipVolumeStencilVolumeTexArray[i];
 637
 638                                         // this buffer is managed explicitly on multi GPU.
 639                                         pTex->DisableMgpuSync();
 640
 641                                         // set depth target before AddPrimitive() is called.
 642                                         m_volumetricStencilPassArray[i]->SetDepthTarget(pTex);
 643                                 }
 644                         }
 645
 646                         // need to clear depth buffer.
 647                         const int32 safeMargin = 2; // workaround: shader isn't activated in initial several frames.
 648                         m_cleared = gcpRendD3D->GetActiveGPUCount() + safeMargin;
 649                 }
 650 #endif
 651         }
 652 }
 653
 654 void CClipVolumesStage::ExecuteVolumetricFog()
 655 {
 656         CD3D9Renderer* const __restrict rd = gcpRendD3D;
 657         SRenderPipeline& rp(rd->m_RP);
 658         auto nThreadID = rp.m_nProcessThreadID;
 659
 660         if (rd->m_bVolumetricFogEnabled && rp.m_TI[nThreadID].m_FS.m_bEnable)
 661         {
 662                 PROFILE_LABEL_SCOPE("CLIPVOLUMES FOR VOLUMETRIC FOG");
 663
 664                 const bool bReverseDepth = (rp.m_TI[rp.m_nProcessThreadID].m_PersFlags & RBPF_REVERSE_DEPTH) != 0;
 665                 const float nearDepth = bReverseDepth ? 1.0f : 0.0f;
 666                 const float raymarchDistance = gRenDev->m_cEF.m_PF[rp.m_nProcessThreadID].pVolumetricFogDistanceParams.w;
 667
 668                 if (m_nearDepth != nearDepth
 669                     || (0.25f < abs(m_raymarchDistance - raymarchDistance)))
 670                 {
 671                         // store values to observe the change.
 672                         m_nearDepth = nearDepth;
 673                         m_raymarchDistance = raymarchDistance;
 674
 675                         // need to clear depth buffer.
 676                         m_cleared = (m_cleared > 0) ? m_cleared : rd->GetActiveGPUCount();
 677                 }
 678
 679                 auto maxDSVCount = m_depthTargetArrayVolFog.size();
 680                 const float fFar = rd->GetRCamera().fFar;
 681                 const float fNear = rd->GetRCamera().fNear;
 682                 const float factor0 = fFar / (fFar - fNear);
 683                 const float factor1 = fNear * -factor0;
 684                 bool valid = true;
 685
 686 #ifdef FEATURE_RENDER_CLIPVOLUME_GEOMETRY_SHADER
 687                 if (m_cleared > 0)
 688                 {
 689                         rd->FX_ClearTarget(m_depthTargetVolFog->GetDevTexture()->LookupDSV(EDefaultResourceViews::DepthStencil), CLEAR_STENCIL | CLEAR_ZBUFFER, 0.0f, 0);
 690
 691                         // write jittering depth.
 692                         for (int32 i = 0; i < maxDSVCount; ++i)
 693                         {
 694                                 // separate DSV
 695                                 auto& depthTargetView = m_depthTargetArrayVolFog[i];
 696                                 auto& pass = m_jitteredDepthPassArray[i];
 697
 698                                 static CCryNameTSCRC shaderName("StoreJitteringDepthToClipVolumeDepth");
 699                                 pass->SetPrimitiveFlags(CRenderPrimitive::eFlags_ReflectShaderConstants_PS);
 700                                 pass->SetTechnique(CShaderMan::s_shDeferredShading, shaderName, 0);
 701                                 pass->SetState(GS_DEPTHWRITE | GS_DEPTHFUNC_NOTEQUAL);
 702                                 pass->SetDepthTarget(m_depthTargetVolFog, depthTargetView);
 703
 704                                 pass->BeginConstantUpdate();
 705
 706                                 static CCryNameR paramDepth("ParamDepth");
 707                                 const Vec4 vParamDepth(static_cast<float>(i), factor1, factor0, nearDepth);
 708                                 pass->SetConstant(paramDepth, vParamDepth, eHWSC_Pixel);
 709
 710                                 bool success = pass->Execute();
 711
 712                                 valid = valid && success;
 713                         }
 714                 }
 715                 else
 716                 {
 717                         rd->FX_ClearTarget(m_depthTargetVolFog->GetDevTexture()->LookupDSV(EDefaultResourceViews::DepthStencil), CLEAR_STENCIL, 0.0f, 0);
 718                 }
 719
 720                 // Render clip volumes to single DSV for depth stencil texture array.
 721                 m_volumetricStencilPass.Execute();
 722 #else
 723                 if (m_cleared > 0)
 724                 {
 725                         for (int32 i = 0; i < maxDSVCount; ++i)
 726                         {
 727                                 CTexture* const pTex = m_pClipVolumeStencilVolumeTexArray[i];
 728                                 auto& depthTarget = m_depthTargetArrayVolFog[i];
 729
 730                                 D3DDepthSurface* pDSV = pTex->GetDevTexture()->LookupDSV(depthTarget);
 731                                 rd->FX_ClearTarget(pDSV, CLEAR_STENCIL | CLEAR_ZBUFFER, 0.0f, 0);
 732
 733                                 auto& pass = m_jitteredDepthPassArray[i];
 734
 735                                 // write jittering depth.
 736                                 static CCryNameTSCRC shaderName("StoreJitteringDepthToClipVolumeDepth");
 737                                 pass->SetPrimitiveFlags(CRenderPrimitive::eFlags_ReflectShaderConstants_PS);
 738                                 pass->SetTechnique(CShaderMan::s_shDeferredShading, shaderName, 0);
 739                                 pass->SetState(GS_DEPTHWRITE | GS_DEPTHFUNC_NOTEQUAL);
 740                                 pass->SetDepthTarget(pTex, depthTarget);
 741
 742                                 pass->BeginConstantUpdate();
 743
 744                                 static CCryNameR paramDepth("ParamDepth");
 745                                 const Vec4 vParamDepth(static_cast<float>(i), factor1, factor0, nearDepth);
 746                                 pass->SetConstant(paramDepth, vParamDepth, eHWSC_Pixel);
 747
 748                                 bool success = pass->Execute();
 749
 750                                 valid = valid && success;
 751                         }
 752                 }
 753                 else
 754                 {
 755                         for (int32 i = 0; i < maxDSVCount; ++i)
 756                         {
 757                                 CTexture* const pTex = m_pClipVolumeStencilVolumeTexArray[i];
 758                                 auto& depthTarget = m_depthTargetArrayVolFog[i];
 759
 760                                 D3DDepthSurface* pDSV = pTex->GetDevTexture()->LookupDSV(depthTarget);
 761                                 rd->FX_ClearTarget(pDSV, CLEAR_STENCIL, 0.0f, 0);
 762                         }
 763                 }
 764
 765                 // Render clip volumes.
 766                 for (int32 i = 0; i < maxDSVCount; ++i)
 767                 {
 768                         CTexture* const pTex = m_pClipVolumeStencilVolumeTexArray[i];
 769                         auto& depthTarget = m_depthTargetArrayVolFog[i];
 770                         auto& pass = m_volumetricStencilPassArray[i];
 771
 772                         pass->SetDepthTarget(pTex, depthTarget);
 773                         pass->Execute();
 774                 }
 775
 776                 // Resolve stencil
 777                 static CCryNameTSCRC techResolveStencil("ResolveStencilVolFog");
 778                 for (int32 i = 0; i < maxDSVCount; ++i)
 779                 {
 780                         auto renderTargetView = SResourceView::RenderTargetView(DeviceFormats::ConvertFromTexFormat(m_pClipVolumeStencilVolumeTex->GetDstFormat()), i, 1, 0, false);
 781                         ResourceViewHandle rtvHandle = m_pClipVolumeStencilVolumeTex->GetDevTexture()->GetOrCreateResourceViewHandle(renderTargetView);
 782
 783                         CTexture* const pTex = m_pClipVolumeStencilVolumeTexArray[i];
 784                         auto stencilOnlyView = SResourceView::ShaderResourceView(DeviceFormats::ConvertFromTexFormat(pTex->GetDstFormat()),
 785                                                                                  0, -1, 0, -1, false, false, SResourceView::eSRV_StencilOnly);
 786                         ResourceViewHandle srvHandle = pTex->GetDevTexture()->GetOrCreateResourceViewHandle(stencilOnlyView);
 787
 788                         auto& pPass = m_resolveVolumetricStencilPassArray[i];
 789                         pPass->SetPrimitiveFlags(CRenderPrimitive::eFlags_None);
 790                         pPass->SetTechnique(CShaderMan::s_shDeferredShading, techResolveStencil, 0);
 791                         pPass->SetRenderTarget(0, m_pClipVolumeStencilVolumeTex, rtvHandle);
 792                         pPass->SetState(GS_NODEPTHTEST);
 793                         pPass->SetTexture(4, pTex, srvHandle);
 794                         pPass->BeginConstantUpdate();
 795                         pPass->Execute();
 796                 }
 797 #endif
 798
 799                 if (valid)
 800                 {
 801                         m_cleared = (m_cleared > 0) ? (m_cleared - 1) : 0;
 802                 }
 803         }
 804 }