?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
!IB (Renderer) Reduce number of resources in mobile pipeline so we don't exceed Mali...
[CRYENGINE.git] / Code / CryEngine / RenderDll / Common / RendererResources.cpp
blob57338132db2f02d53f8ff17e27e3b613a4775dcc
1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "StdAfx.h"
4 #include <CryRenderer/IFlares.h>
5 #include "RendererResources.h"
6 #include "Renderer.h"
7 #include "Textures/Texture.h" // CTexture
8
9 #include "../XRenderD3D9/D3DDeferredShading.h" // CDeferredShading
10 #include "../XRenderD3D9/D3DPostProcess.h" // SD3DPostEffectsUtils
11
12 #include "RendElements/FlareSoftOcclusionQuery.h" // CFlareSoftOcclusionQuery
13
14 ////////////////////////////////////////////////////////////////////////////////////////////////////
15 ////////////////////////////////////////////////////////////////////////////////////////////////////
16
17 // render targets info - first gather list of hdr targets, sort by size and create after
18 struct SRenderTargetInfo
19 {
20 SRenderTargetInfo() : nWidth(0), nHeight(0), cClearColor(Clr_Empty), Format(eTF_Unknown), nFlags(0), lplpStorage(0), nPitch(0), fPriority(0.0f), nCustomID(0)
21 {};
22
23 uint32 nWidth;
24 uint32 nHeight;
25 ColorF cClearColor;
26 ETEX_Format Format;
27 uint32 nFlags;
28 CTexture** lplpStorage;
29 char szName[64];
30 uint32 nPitch;
31 float fPriority;
32 int32 nCustomID;
33 };
34
35 struct RenderTargetSizeSort
36 {
37 bool operator()(const SRenderTargetInfo& drtStart, const SRenderTargetInfo& drtEnd) { return (drtStart.nPitch * drtStart.fPriority) > (drtEnd.nPitch * drtEnd.fPriority); }
38 };
39
40 class SRenderTargetPool
41 {
42
43 public:
44
45 void AddRenderTarget(uint32 nWidth, uint32 nHeight, const ColorF& cClear, ETEX_Format Format, float fPriority, const char* szName, CTexture** pStorage, uint32 nFlags = 0, int32 nCustomID = -1, bool bDynamicTex = 0);
46 bool CreateRenderTargetList();
47 void ClearRenderTargetList()
48 {
49 m_pRenderTargets.clear();
50 }
51
52 static SRenderTargetPool* GetInstance()
53 {
54 static SRenderTargetPool pInstance;
55 return &pInstance;
56 }
57
58 private:
59
60 std::vector<SRenderTargetInfo> m_pRenderTargets;
61 };
62
63 void SRenderTargetPool::AddRenderTarget(uint32 nWidth, uint32 nHeight, const ColorF& cClear, ETEX_Format Format, float fPriority, const char* szName, CTexture** pStorage, uint32 nFlags, int32 nCustomID, bool bDynamicTex)
64 {
65 SRenderTargetInfo drt;
66
67 drt.nWidth = nWidth;
68 drt.nHeight = nHeight;
69 drt.cClearColor = cClear;
70 drt.nFlags = FT_USAGE_RENDERTARGET | FT_DONT_STREAM | nFlags;
71 drt.Format = Format;
72 drt.fPriority = fPriority;
73 drt.lplpStorage = pStorage;
74 drt.nCustomID = nCustomID;
75 drt.nPitch = nWidth * CTexture::BytesPerPixel(Format);
76
77 cry_strcpy(drt.szName, szName);
78
79 m_pRenderTargets.push_back(drt);
80 }
81
82 bool SRenderTargetPool::CreateRenderTargetList()
83 {
84 std::sort(m_pRenderTargets.begin(), m_pRenderTargets.end(), RenderTargetSizeSort());
85
86 for (uint32 t = 0; t < m_pRenderTargets.size(); ++t)
87 {
88 SRenderTargetInfo& drt = m_pRenderTargets[t];
89 CTexture*& pTex = (*drt.lplpStorage);
90
91 if (!pTex && !(pTex = CTexture::GetOrCreateRenderTarget(drt.szName, drt.nWidth, drt.nHeight, drt.cClearColor, eTT_2D, drt.nFlags, drt.Format, drt.nCustomID)))
92 continue;
93
94 pTex->SetFlags(drt.nFlags);
95 pTex->SetWidth(drt.nWidth);
96 pTex->SetHeight(drt.nHeight);
97 pTex->CreateRenderTarget(drt.Format, drt.cClearColor);
98
99 if (!(pTex->GetFlags() & FT_FAILED))
100 {
101 // Clear render target surface before using it
102 pTex->Clear();
103 }
104 }
105
106 m_pRenderTargets.clear();
107
108 return true;
109 }
110
111 ////////////////////////////////////////////////////////////////////////////////////////////////////
112 ////////////////////////////////////////////////////////////////////////////////////////////////////
113
114 SPixFormatSupport CRendererResources::s_hwTexFormatSupport;
115
116 CTexture* CRendererResources::s_ptexNoTexture;
117 CTexture* CRendererResources::s_ptexNoTextureCM;
118 CTexture* CRendererResources::s_ptexWhite;
119 CTexture* CRendererResources::s_ptexGray;
120 CTexture* CRendererResources::s_ptexBlack;
121 CTexture* CRendererResources::s_ptexBlackAlpha;
122 CTexture* CRendererResources::s_ptexBlackCM;
123 CTexture* CRendererResources::s_ptexDefaultProbeCM;
124 CTexture* CRendererResources::s_ptexDefaultMergedDetail;
125 CTexture* CRendererResources::s_ptexFlatBump;
126 #if !defined(_RELEASE)
127 CTexture* CRendererResources::s_ptexMipMapDebug;
128 CTexture* CRendererResources::s_ptexColorBlue;
129 CTexture* CRendererResources::s_ptexColorCyan;
130 CTexture* CRendererResources::s_ptexColorGreen;
131 CTexture* CRendererResources::s_ptexColorPurple;
132 CTexture* CRendererResources::s_ptexColorRed;
133 CTexture* CRendererResources::s_ptexColorWhite;
134 CTexture* CRendererResources::s_ptexColorYellow;
135 CTexture* CRendererResources::s_ptexColorOrange;
136 CTexture* CRendererResources::s_ptexColorMagenta;
137 #endif
138 CTexture* CRendererResources::s_ptexPaletteDebug;
139 CTexture* CRendererResources::s_ptexPaletteTexelsPerMeter;
140 CTexture* CRendererResources::s_ptexIconShaderCompiling;
141 CTexture* CRendererResources::s_ptexIconStreaming;
142 CTexture* CRendererResources::s_ptexIconStreamingTerrainTexture;
143 CTexture* CRendererResources::s_ptexIconNavigationProcessing;
144 CTexture* CRendererResources::s_ptexMipColors_Diffuse;
145 CTexture* CRendererResources::s_ptexMipColors_Bump;
146 CTexture* CRendererResources::s_ptexShadowJitterMap;
147 CTexture* CRendererResources::s_ptexEnvironmentBRDF;
148 CTexture* CRendererResources::s_ptexScreenNoiseMap;
149 CTexture* CRendererResources::s_ptexDissolveNoiseMap;
150 CTexture* CRendererResources::s_ptexNoise3D;
151 CTexture* CRendererResources::s_ptexGrainFilterMap;
152 CTexture* CRendererResources::s_ptexFilmGrainMap;
153 CTexture* CRendererResources::s_ptexVignettingMap;
154 CTexture* CRendererResources::s_ptexAOJitter;
155 CTexture* CRendererResources::s_ptexAOVOJitter;
156 CTexture* CRendererResources::s_ptexFromRE[8];
157 CTexture* CRendererResources::s_ptexShadowID[8];
158 CTexture* CRendererResources::s_ptexShadowMask;
159 CTexture* CRendererResources::s_ptexCachedShadowMap[MAX_GSM_LODS_NUM];
160 CTexture* CRendererResources::s_ptexNearestShadowMap;
161 CTexture* CRendererResources::s_ptexHeightMapAO[2];
162 CTexture* CRendererResources::s_ptexHeightMapAODepth[2];
163 CTexture* CRendererResources::s_ptexFromRE_FromContainer[2];
164 CTexture* CRendererResources::s_ptexFromObj;
165 CTexture* CRendererResources::s_ptexRT_2D;
166 CTexture* CRendererResources::s_ptexNormalsFitting;
167 CTexture* CRendererResources::s_ptexPerlinNoiseMap;
168
169 CTexture* CRendererResources::s_ptexSceneNormalsMap;
170 CTexture* CRendererResources::s_ptexSceneNormalsBent;
171 CTexture* CRendererResources::s_ptexAOColorBleed;
172 CTexture* CRendererResources::s_ptexSceneDiffuse;
173 CTexture* CRendererResources::s_ptexSceneSpecular;
174
175 CTexture* CRendererResources::s_ptexSceneSelectionIDs;
176
177 CTexture* CRendererResources::s_ptexWindGrid;
178
179 #if defined(DURANGO_USE_ESRAM)
180 CTexture* CRendererResources::s_ptexSceneSpecularESRAM;
181 #endif
182
183 // Post-process related textures
184 CTexture* CRendererResources::s_ptexBackBuffer = NULL;
185 CTexture* CRendererResources::s_ptexModelHudBuffer;
186 CTexture* CRendererResources::s_ptexCached3DHud;
187 CTexture* CRendererResources::s_ptexCached3DHudScaled;
188 CTexture* CRendererResources::s_ptexBackBufferScaled[3];
189 CTexture* CRendererResources::s_ptexBackBufferScaledTemp[2];
190 CTexture* CRendererResources::s_ptexPrevFrameScaled;
191
192 CTexture* CRendererResources::s_ptexWaterOcean;
193 CTexture* CRendererResources::s_ptexWaterVolumeTemp[2];
194 CTexture* CRendererResources::s_ptexWaterVolumeDDN;
195 CTexture* CRendererResources::s_ptexWaterVolumeRefl[2] = { NULL };
196 CTexture* CRendererResources::s_ptexWaterCaustics[2] = { NULL };
197 CTexture* CRendererResources::s_ptexRainOcclusion;
198 CTexture* CRendererResources::s_ptexRainSSOcclusion[2];
199
200 CTexture* CRendererResources::s_ptexRT_ShadowPool;
201 CTexture* CRendererResources::s_ptexFarPlane;
202 CTexture* CRendererResources::s_ptexCloudsLM;
203
204 CTexture* CRendererResources::s_ptexSceneTarget = NULL;
205 CTexture* CRendererResources::s_ptexSceneTargetR11G11B10F[2] = { NULL };
206 CTexture* CRendererResources::s_ptexSceneDiffuseTmp;
207 CTexture* CRendererResources::s_ptexSceneSpecularTmp;
208 CTexture* CRendererResources::s_ptexSceneDepthScaled[3];
209 CTexture* CRendererResources::s_ptexLinearDepth;
210 CTexture* CRendererResources::s_ptexLinearDepthReadBack[4];
211 CTexture* CRendererResources::s_ptexLinearDepthDownSample[4];
212 CTexture* CRendererResources::s_ptexLinearDepthScaled[3];
213 CTexture* CRendererResources::s_ptexHDRTarget;
214 CTexture* CRendererResources::s_ptexVelocity;
215 CTexture* CRendererResources::s_ptexVelocityTiles[3] = { NULL };
216 CTexture* CRendererResources::s_ptexVelocityObjects[2] = { NULL };
217 CTexture* CRendererResources::s_ptexHDRTargetPrev = NULL;
218 CTexture* CRendererResources::s_ptexHDRTargetScaled[4];
219 CTexture* CRendererResources::s_ptexHDRTargetScaledTmp[4];
220 CTexture* CRendererResources::s_ptexHDRTargetScaledTempRT[4];
221 CTexture* CRendererResources::s_ptexHDRDofLayers[2];
222 CTexture* CRendererResources::s_ptexSceneCoC[MIN_DOF_COC_K] = { NULL };
223 CTexture* CRendererResources::s_ptexSceneCoCTemp = NULL;
224 CTexture* CRendererResources::s_ptexHDRTempBloom[2];
225 CTexture* CRendererResources::s_ptexHDRFinalBloom;
226 CTexture* CRendererResources::s_ptexHDRAdaptedLuminanceCur[8];
227 int CRendererResources::s_nCurLumTextureIndex;
228 CTexture* CRendererResources::s_ptexCurLumTexture;
229 CTexture* CRendererResources::s_ptexHDRToneMaps[NUM_HDR_TONEMAP_TEXTURES];
230 CTexture* CRendererResources::s_ptexHDRMeasuredLuminance[MAX_GPU_NUM];
231 CTexture* CRendererResources::s_ptexHDRMeasuredLuminanceDummy;
232 CTexture* CRendererResources::s_ptexColorChart;
233
234 CTexture* CRendererResources::s_ptexFlaresOcclusionRing[MAX_OCCLUSION_READBACK_TEXTURES] = { NULL };
235 CTexture* CRendererResources::s_ptexFlaresGather = NULL;
236
237 CTexture* CRendererResources::s_pTexNULL = 0;
238
239 CTexture* CRendererResources::s_ptexVolumetricFog = NULL;
240 CTexture* CRendererResources::s_ptexVolCloudShadow = NULL;
241
242 #if defined(VOLUMETRIC_FOG_SHADOWS)
243 CTexture* CRendererResources::s_ptexVolFogShadowBuf[2] = { 0 };
244 #endif
245
246 SEnvTexture CRendererResources::s_EnvTexts[MAX_ENVTEXTURES];
247
248 TArray<SEnvTexture> CRendererResources::s_CustomRT_2D;
249
250 TArray<CTexture> CRendererResources::s_ShaderTemplates(EFTT_MAX);
251 bool CRendererResources::s_ShaderTemplatesInitialized = false;
252
253 ETEX_Format CRendererResources::s_eTFZ = eTF_R32F;
254
255 ////////////////////////////////////////////////////////////////////////////////////////////////////
256 ////////////////////////////////////////////////////////////////////////////////////////////////////
257
258 bool CRendererResources::m_bLoadedSystem = false;
259
260 void CRendererResources::UnloadDefaultSystemTextures(bool bFinalRelease)
261 {
262 // Keep these valid - if any textures failed to load and also leaked across the shutdown,
263 // they'll be left with a dangling dev texture pointer otherwise.
264 //SAFE_RELEASE_FORCE(s_ptexNoTexture);
265 //SAFE_RELEASE_FORCE(s_ptexNoTextureCM);
266 //SAFE_RELEASE_FORCE(s_ptexWhite);
267 //SAFE_RELEASE_FORCE(s_ptexGray);
268 //SAFE_RELEASE_FORCE(s_ptexBlack);
269 //SAFE_RELEASE_FORCE(s_ptexBlackAlpha);
270 //SAFE_RELEASE_FORCE(s_ptexBlackCM);
271 //SAFE_RELEASE_FORCE(s_ptexFlatBump);
272 #if !defined(_RELEASE)
273 //SAFE_RELEASE_FORCE(s_ptexDefaultMergedDetail);
274 //SAFE_RELEASE_FORCE(s_ptexMipMapDebug);
275 //SAFE_RELEASE_FORCE(s_ptexColorBlue);
276 //SAFE_RELEASE_FORCE(s_ptexColorCyan);
277 //SAFE_RELEASE_FORCE(s_ptexColorGreen);
278 //SAFE_RELEASE_FORCE(s_ptexColorPurple);
279 //SAFE_RELEASE_FORCE(s_ptexColorRed);
280 //SAFE_RELEASE_FORCE(s_ptexColorWhite);
281 //SAFE_RELEASE_FORCE(s_ptexColorYellow);
282 //SAFE_RELEASE_FORCE(s_ptexColorMagenta);
283 //SAFE_RELEASE_FORCE(s_ptexColorOrange);
284 #endif
285 //SAFE_RELEASE_FORCE(s_ptexPaletteDebug);
286 //SAFE_RELEASE_FORCE(s_ptexShadowJitterMap);
287 //SAFE_RELEASE_FORCE(s_ptexEnvironmentBRDF);
288 //SAFE_RELEASE_FORCE(s_ptexScreenNoiseMap);
289 //SAFE_RELEASE_FORCE(s_ptexDissolveNoiseMap);
290 //SAFE_RELEASE_FORCE(s_ptexNoise3D);
291 //SAFE_RELEASE_FORCE(s_ptexGrainFilterMap);
292 //SAFE_RELEASE_FORCE(s_ptexFilmGrainMap);
293 //SAFE_RELEASE_FORCE(s_ptexVignettingMap);
294 //SAFE_RELEASE_FORCE(s_ptexAOJitter);
295 //SAFE_RELEASE_FORCE(s_ptexAOVOJitter);
296 SAFE_RELEASE_FORCE(s_ptexRT_2D);
297 SAFE_RELEASE_FORCE(s_ptexCloudsLM);
298
299 //SAFE_RELEASE_FORCE(s_ptexHitAreaRT[0]);
300 //SAFE_RELEASE_FORCE(s_ptexHitAreaRT[1]);
301
302 SAFE_RELEASE_FORCE(s_ptexVolumetricFog);
303 SAFE_RELEASE_FORCE(s_ptexVolCloudShadow);
304
305 uint32 i;
306 for (i = 0; i < 8; i++)
307 {
308 //SAFE_RELEASE_FORCE(s_ptexFromRE[i]);
309 }
310 for (i = 0; i < 8; i++)
311 {
312 SAFE_RELEASE_FORCE(s_ptexShadowID[i]);
313 }
314
315 for (i = 0; i < 2; i++)
316 {
317 //SAFE_RELEASE_FORCE(s_ptexFromRE_FromContainer[i]);
318 }
319
320 SAFE_RELEASE_FORCE(s_ptexColorChart);
321
322 SAFE_RELEASE_FORCE(s_ptexWindGrid);
323
324 for (i = 0; i < MAX_ENVTEXTURES; i++)
325 {
326 s_EnvTexts[i].Release();
327 }
328 //m_EnvTexTemp.Release();
329
330 SAFE_RELEASE_FORCE(s_ptexMipColors_Diffuse);
331 SAFE_RELEASE_FORCE(s_ptexMipColors_Bump);
332 SAFE_RELEASE_FORCE(s_ptexRT_ShadowPool);
333 SAFE_RELEASE_FORCE(s_ptexFarPlane);
334
335 s_CustomRT_2D.Free();
336 //s_ShaderTemplates.Free();
337
338 // release targets pools
339 //SDynTexture_Shadow::ShutDown();
340 SDynTexture::ShutDown();
341 SDynTexture2::ShutDown();
342
343 //ReleaseSystemTargets();
344
345 m_bLoadedSystem = false;
346 }
347
348 void CRendererResources::LoadDefaultSystemTextures()
349 {
350 LOADING_TIME_PROFILE_SECTION;
351
352 char str[256];
353 int i;
354
355 MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Engine textures");
356
357 if (!m_bLoadedSystem)
358 {
359 m_bLoadedSystem = true;
360
361 const float clearDepth = Clr_FarPlane_Rev.r;
362 const uint8 clearStencil = Val_Stencil;
363 const ColorF clearValues = ColorF(clearDepth, FLOAT(clearStencil), 0.f, 0.f);
364
365 // Textures loaded directly from file
366 struct
367 {
368 CTexture*& pTexture;
369 const char* szFileName;
370 uint32 flags;
371 }
372 texturesFromFile[] =
373 {
374 { s_ptexWhite, "%ENGINE%/EngineAssets/Textures/White.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
375 { s_ptexBlack, "%ENGINE%/EngineAssets/Textures/Black.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
376 { s_ptexBlackAlpha, "%ENGINE%/EngineAssets/Textures/BlackAlpha.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
377 { s_ptexBlackCM, "%ENGINE%/EngineAssets/Textures/BlackCM.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
378 { s_ptexGray, "%ENGINE%/EngineAssets/Textures/Grey.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
379 { s_ptexDefaultMergedDetail, "%ENGINE%/EngineAssets/Textures/GreyAlpha.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
380 { s_ptexDefaultProbeCM, "%ENGINE%/EngineAssets/Shading/defaultProbe_cm.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
381 { s_ptexFlatBump, "%ENGINE%/EngineAssets/Textures/White_ddn.dds", FT_DONT_RELEASE | FT_DONT_STREAM | FT_TEX_NORMAL_MAP },
382 { s_ptexPaletteDebug, "%ENGINE%/EngineAssets/Textures/palletteInst.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
383 { s_ptexPaletteTexelsPerMeter, "%ENGINE%/EngineAssets/Textures/TexelsPerMeterGrad.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
384 { s_ptexIconShaderCompiling, "%ENGINE%/EngineAssets/Icons/ShaderCompiling.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
385 { s_ptexIconStreaming, "%ENGINE%/EngineAssets/Icons/Streaming.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
386 { s_ptexIconStreamingTerrainTexture, "%ENGINE%/EngineAssets/Icons/StreamingTerrain.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
387 { s_ptexIconNavigationProcessing, "%ENGINE%/EngineAssets/Icons/NavigationProcessing.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
388 { s_ptexShadowJitterMap, "%ENGINE%/EngineAssets/Textures/rotrandom.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
389 { s_ptexEnvironmentBRDF, "%ENGINE%/EngineAssets/Shading/environmentBRDF.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
390 { s_ptexScreenNoiseMap, "%ENGINE%/EngineAssets/Textures/JumpNoiseHighFrequency_x27y19.dds", FT_DONT_RELEASE | FT_DONT_STREAM | FT_NOMIPS },
391 { s_ptexDissolveNoiseMap, "%ENGINE%/EngineAssets/Textures/noise.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
392 { s_ptexNoise3D, "%ENGINE%/EngineAssets/Textures/noise3d.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
393 { s_ptexGrainFilterMap, "%ENGINE%/EngineAssets/ScreenSpace/grain_bayer_mul.tif", FT_DONT_RELEASE | FT_DONT_STREAM | FT_NOMIPS },
394 { s_ptexFilmGrainMap, "%ENGINE%/EngineAssets/ScreenSpace/film_grain.dds", FT_DONT_RELEASE | FT_DONT_STREAM | FT_NOMIPS },
395 { s_ptexVignettingMap, "%ENGINE%/EngineAssets/Shading/vignetting.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
396 { s_ptexAOJitter, "%ENGINE%/EngineAssets/ScreenSpace/PointsOnSphere4x4.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
397 { s_ptexAOVOJitter, "%ENGINE%/EngineAssets/ScreenSpace/PointsOnSphereVO4x4.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
398 { s_ptexNormalsFitting, "%ENGINE%/EngineAssets/ScreenSpace/NormalsFitting.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
399 { s_ptexPerlinNoiseMap, "%ENGINE%/EngineAssets/Textures/perlinNoise2D.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
400
401 #if !defined(_RELEASE)
402 { s_ptexNoTexture, "%ENGINE%/EngineAssets/TextureMsg/ReplaceMe.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
403 { s_ptexNoTextureCM, "%ENGINE%/EngineAssets/TextureMsg/ReplaceMeCM.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
404 { s_ptexMipMapDebug, "%ENGINE%/EngineAssets/TextureMsg/MipMapDebug.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
405 { s_ptexColorBlue, "%ENGINE%/EngineAssets/TextureMsg/color_Blue.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
406 { s_ptexColorCyan, "%ENGINE%/EngineAssets/TextureMsg/color_Cyan.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
407 { s_ptexColorGreen, "%ENGINE%/EngineAssets/TextureMsg/color_Green.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
408 { s_ptexColorPurple, "%ENGINE%/EngineAssets/TextureMsg/color_Purple.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
409 { s_ptexColorRed, "%ENGINE%/EngineAssets/TextureMsg/color_Red.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
410 { s_ptexColorWhite, "%ENGINE%/EngineAssets/TextureMsg/color_White.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
411 { s_ptexColorYellow, "%ENGINE%/EngineAssets/TextureMsg/color_Yellow.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
412 { s_ptexColorOrange, "%ENGINE%/EngineAssets/TextureMsg/color_Orange.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
413 { s_ptexColorMagenta, "%ENGINE%/EngineAssets/TextureMsg/color_Magenta.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
414 #else
415 { s_ptexNoTexture, "%ENGINE%/EngineAssets/Textures/Grey.dds", FT_DONT_RELEASE | FT_DONT_STREAM },
416 { s_ptexNoTextureCM, "%ENGINE%/EngineAssets/Shading/defaultProbe_cm.tif", FT_DONT_RELEASE | FT_DONT_STREAM },
417 #endif
418 };
419
420 for (int t = 0; t < CRY_ARRAY_COUNT(texturesFromFile); ++t)
421 {
422 if (!texturesFromFile[t].pTexture)
423 {
424 texturesFromFile[t].pTexture = CTexture::ForName(texturesFromFile[t].szFileName, texturesFromFile[t].flags, eTF_Unknown);
425
426 if (texturesFromFile[t].pTexture->GetFlags() & FT_FAILED)
427 {
428 CryFatalError("Default system texture \"%s\" failed to load, please make sure the engine.pak or the engine folder is available.", texturesFromFile[t].szFileName);
429 }
430
431 if (!texturesFromFile[t].pTexture || !texturesFromFile[t].pTexture->IsLoaded() || !texturesFromFile[t].pTexture->GetDevTexture())
432 {
433 CryFatalError("Can't open %s texture file.", texturesFromFile[t].szFileName);
434 }
435 }
436 }
437
438 // Associate dummy NULL-resource with s_pTexNULL
439 s_pTexNULL = new CTexture(FT_DONT_RELEASE | FT_DONT_STREAM, Clr_Transparent, CDeviceTexture::Associate(s_ptexBlackAlpha->GetLayout(), nullptr));
440
441 // Default Template textures
442 int nRTFlags = FT_DONT_RELEASE | FT_DONT_STREAM | FT_STATE_CLAMP | FT_USAGE_RENDERTARGET;
443 s_ptexMipColors_Diffuse = CTexture::GetOrCreateTextureObject("$MipColors_Diffuse", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_MIPCOLORS_DIFFUSE);
444 s_ptexMipColors_Bump = CTexture::GetOrCreateTextureObject("$MipColors_Bump", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_MIPCOLORS_BUMP);
445
446 s_ptexRT_2D = CTexture::GetOrCreateTextureObject("$RT_2D", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_RT_2D);
447
448 s_ptexRainOcclusion = CTexture::GetOrCreateTextureObject("$RainOcclusion", RAIN_OCC_MAP_SIZE, RAIN_OCC_MAP_SIZE, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_R8G8B8A8);
449 s_ptexRainSSOcclusion[0] = CTexture::GetOrCreateTextureObject("$RainSSOcclusion0", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
450 s_ptexRainSSOcclusion[1] = CTexture::GetOrCreateTextureObject("$RainSSOcclusion1", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
451
452 //s_ptexHitAreaRT[0] = CTexture::CreateTextureObject("$HitEffectAccumBuffRT_0", 128, 128, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
453 //s_ptexHitAreaRT[1] = CTexture::CreateTextureObject("$HitEffectAccumBuffRT_1", 128, 128, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
454
455 s_ptexWindGrid = CTexture::GetOrCreateTextureObject("WindGrid", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown, TO_WINDGRID);
456 if (!CTexture::IsTextureExist(s_ptexWindGrid))
457 {
458 s_ptexWindGrid->Create2DTexture(256, 256, 1, FT_DONT_RELEASE | FT_DONT_STREAM, nullptr, eTF_R16G16F);
459 }
460
461 s_ptexLinearDepthReadBack[0] = CTexture::GetOrCreateTextureObject("$ZTargetReadBack0", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
462 s_ptexLinearDepthReadBack[1] = CTexture::GetOrCreateTextureObject("$ZTargetReadBack1", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
463 s_ptexLinearDepthReadBack[2] = CTexture::GetOrCreateTextureObject("$ZTargetReadBack2", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
464 s_ptexLinearDepthReadBack[3] = CTexture::GetOrCreateTextureObject("$ZTargetReadBack3", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
465
466 s_ptexLinearDepthDownSample[0] = CTexture::GetOrCreateTextureObject("$ZTargetDownSample0", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
467 s_ptexLinearDepthDownSample[1] = CTexture::GetOrCreateTextureObject("$ZTargetDownSample1", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
468 s_ptexLinearDepthDownSample[2] = CTexture::GetOrCreateTextureObject("$ZTargetDownSample2", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
469 s_ptexLinearDepthDownSample[3] = CTexture::GetOrCreateTextureObject("$ZTargetDownSample3", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_Unknown);
470
471 s_ptexRT_ShadowPool = CTexture::GetOrCreateTextureObject("$RT_ShadowPool", 0, 0, 1, eTT_2D, FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, eTF_Unknown);
472 s_ptexFarPlane = CTexture::GetOrCreateTextureObject("$FarPlane", 8, 8, 1, eTT_2D, FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, eTF_Unknown);
473
474 if (!s_ptexModelHudBuffer)
475 s_ptexModelHudBuffer = CTexture::GetOrCreateTextureObject("$ModelHud", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_MODELHUD);
476
477 // if (!s_ptexBackBuffer)
478 {
479 s_ptexSceneTarget = CTexture::GetOrCreateTextureObject("$SceneTarget", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_SCENE_TARGET);
480
481 s_ptexSceneTargetR11G11B10F[0] = CTexture::GetOrCreateTextureObject("$SceneTargetR11G11B10F_0", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
482 s_ptexSceneTargetR11G11B10F[1] = CTexture::GetOrCreateTextureObject("$SceneTargetR11G11B10F_1", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
483
484 s_ptexVelocity = CTexture::GetOrCreateTextureObject("$Velocity", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
485 s_ptexVelocityTiles[0] = CTexture::GetOrCreateTextureObject("$VelocityTilesTmp0", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
486 s_ptexVelocityTiles[1] = CTexture::GetOrCreateTextureObject("$VelocityTilesTmp1", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
487 s_ptexVelocityTiles[2] = CTexture::GetOrCreateTextureObject("$VelocityTiles", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
488 s_ptexVelocityObjects[0] = CTexture::GetOrCreateTextureObject("$VelocityObjects", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_USAGE_UNORDERED_ACCESS, eTF_Unknown, -1);
489 // Only used for VR, but we need to support runtime switching
490 s_ptexVelocityObjects[1] = CTexture::GetOrCreateTextureObject("$VelocityObjects_R", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_USAGE_UNORDERED_ACCESS, eTF_Unknown, -1);
491
492 s_ptexBackBuffer = CTexture::GetOrCreateTextureObject("$BackBuffer", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_BACKBUFFERMAP);
493
494 s_ptexPrevFrameScaled = CTexture::GetOrCreateTextureObject("$PrevFrameScale", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
495
496 s_ptexBackBufferScaled[0] = CTexture::GetOrCreateTextureObject("$BackBufferScaled_d2", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_BACKBUFFERSCALED_D2);
497 s_ptexBackBufferScaled[1] = CTexture::GetOrCreateTextureObject("$BackBufferScaled_d4", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_BACKBUFFERSCALED_D4);
498 s_ptexBackBufferScaled[2] = CTexture::GetOrCreateTextureObject("$BackBufferScaled_d8", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_BACKBUFFERSCALED_D8);
499
500 s_ptexBackBufferScaledTemp[0] = CTexture::GetOrCreateTextureObject("$BackBufferScaledTemp_d2", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
501 s_ptexBackBufferScaledTemp[1] = CTexture::GetOrCreateTextureObject("$BackBufferScaledTemp_d4", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, -1);
502
503 s_ptexSceneNormalsMap = CTexture::GetOrCreateTextureObject("$SceneNormalsMap", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8, TO_SCENE_NORMALMAP);
504 s_ptexSceneNormalsBent = CTexture::GetOrCreateTextureObject("$SceneNormalsBent", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8);
505 s_ptexSceneDiffuse = CTexture::GetOrCreateTextureObject("$SceneDiffuse", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8);
506 s_ptexSceneSpecular = CTexture::GetOrCreateTextureObject("$SceneSpecular", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8);
507 #if defined(DURANGO_USE_ESRAM)
508 s_ptexSceneSpecularESRAM = CTexture::GetOrCreateTextureObject("$SceneSpecularESRAM", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8);
509 #endif
510 s_ptexSceneDiffuseTmp = CTexture::GetOrCreateTextureObject("$SceneDiffuseTmp", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8, TO_SCENE_DIFFUSE_ACC);
511 s_ptexSceneSpecularTmp = CTexture::GetOrCreateTextureObject("$SceneSpecularTmp", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8, TO_SCENE_SPECULAR_ACC);
512 s_ptexShadowMask = CTexture::GetOrCreateTextureObject("$ShadowMask", 0, 0, 1, eTT_2DArray, nRTFlags, eTF_R8, TO_SHADOWMASK);
513
514 s_ptexFlaresGather = CTexture::GetOrCreateTextureObject("$FlaresGather", 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8);
515 for (i = 0; i < MAX_OCCLUSION_READBACK_TEXTURES; i++)
516 {
517 cry_sprintf(str, "$FlaresOcclusion_%d", i);
518 s_ptexFlaresOcclusionRing[i] = CTexture::GetOrCreateTextureObject(str, 0, 0, 1, eTT_2D, nRTFlags, eTF_R8G8B8A8);
519 }
520
521 // fixme: get texture resolution from CREWaterOcean
522 // TODO: make s_ptexWaterVolumeTemp an array texture
523 s_ptexWaterOcean = CTexture::GetOrCreateTextureObject("$WaterOceanMap", 64, 64, 1, eTT_2D, FT_DONT_RELEASE | FT_NOMIPS | FT_DONT_STREAM, eTF_Unknown, TO_WATEROCEANMAP);
524 s_ptexWaterVolumeTemp[0] = CTexture::GetOrCreateTextureObject("$WaterVolumeTemp_0", 64, 64, 1, eTT_2D, /*FT_DONT_RELEASE |*/ FT_NOMIPS | FT_DONT_STREAM, eTF_Unknown);
525 s_ptexWaterVolumeTemp[1] = CTexture::GetOrCreateTextureObject("$WaterVolumeTemp_1", 64, 64, 1, eTT_2D, /*FT_DONT_RELEASE |*/ FT_NOMIPS | FT_DONT_STREAM, eTF_Unknown);
526 s_ptexWaterVolumeDDN = CTexture::GetOrCreateTextureObject("$WaterVolumeDDN", 64, 64, 1, eTT_2D, /*FT_DONT_RELEASE |*/ FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_FORCE_MIPS, eTF_Unknown, TO_WATERVOLUMEMAP);
527 s_ptexWaterVolumeRefl[0] = CTexture::GetOrCreateTextureObject("$WaterVolumeRefl", 64, 64, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_FORCE_MIPS, eTF_Unknown, TO_WATERVOLUMEREFLMAP);
528 s_ptexWaterVolumeRefl[1] = CTexture::GetOrCreateTextureObject("$WaterVolumeReflPrev", 64, 64, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_FORCE_MIPS, eTF_Unknown, TO_WATERVOLUMEREFLMAPPREV);
529 s_ptexWaterCaustics[0] = CTexture::GetOrCreateTextureObject("$WaterVolumeCaustics", 512, 512, 1, eTT_2D, /*FT_DONT_RELEASE |*/ FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_WATERVOLUMECAUSTICSMAP);
530 s_ptexWaterCaustics[1] = CTexture::GetOrCreateTextureObject("$WaterVolumeCausticsTemp", 512, 512, 1, eTT_2D, /*FT_DONT_RELEASE |*/ FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_WATERVOLUMECAUSTICSMAPTEMP);
531
532 s_ptexSceneDepthScaled[0] = CTexture::GetOrCreateTextureObject("$SceneDepthScaled", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, eTF_Unknown);
533 s_ptexSceneDepthScaled[1] = CTexture::GetOrCreateTextureObject("$SceneDepthScaled2", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, eTF_Unknown);
534 s_ptexSceneDepthScaled[2] = CTexture::GetOrCreateTextureObject("$SceneDepthScaled3", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, eTF_Unknown);
535
536 s_ptexLinearDepth = CTexture::GetOrCreateTextureObject("$ZTarget", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
537 s_ptexLinearDepthScaled[0] = CTexture::GetOrCreateTextureObject("$ZTargetScaled", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_DOWNSCALED_ZTARGET_FOR_AO);
538 s_ptexLinearDepthScaled[1] = CTexture::GetOrCreateTextureObject("$ZTargetScaled2", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_QUARTER_ZTARGET_FOR_AO);
539 s_ptexLinearDepthScaled[2] = CTexture::GetOrCreateTextureObject("$ZTargetScaled3", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown);
540 }
541
542 s_ptexSceneSelectionIDs = CTexture::GetOrCreateTextureObject("$SceneSelectionIDs", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_R32F);
543
544 s_ptexHDRTarget = CTexture::GetOrCreateTextureObject("$HDRTarget", 0, 0, 1, eTT_2D, nRTFlags, eTF_Unknown);
545
546 // Create dummy texture object for terrain and clouds lightmap
547 s_ptexCloudsLM = CTexture::GetOrCreateTextureObject("$CloudsLM", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_CLOUDS_LM);
548
549 for (i = 0; i < 8; i++)
550 {
551 cry_sprintf(str, "$FromRE_%d", i);
552 if (!s_ptexFromRE[i])
553 s_ptexFromRE[i] = CTexture::GetOrCreateTextureObject(str, 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_FROMRE0 + i);
554 }
555
556 for (i = 0; i < 8; i++)
557 {
558 cry_sprintf(str, "$ShadowID_%d", i);
559 s_ptexShadowID[i] = CTexture::GetOrCreateTextureObject(str, 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_SHADOWID0 + i);
560 }
561
562 for (i = 0; i < 2; i++)
563 {
564 cry_sprintf(str, "$FromRE%d_FromContainer", i);
565 if (!s_ptexFromRE_FromContainer[i])
566 s_ptexFromRE_FromContainer[i] = CTexture::GetOrCreateTextureObject(str, 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_FROMRE0_FROM_CONTAINER + i);
567 }
568
569 s_ptexColorChart = CTexture::GetOrCreateTextureObject("$ColorChart", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_Unknown, TO_COLORCHART);
570
571 for (i = 0; i < EFTT_MAX; i++)
572 {
573 new(&s_ShaderTemplates[i])CTexture(FT_DONT_RELEASE);
574 s_ShaderTemplates[i].SetCustomID(EFTT_DIFFUSE + i);
575 s_ShaderTemplates[i].SetFlags(FT_DONT_RELEASE);
576 }
577 s_ShaderTemplatesInitialized = true;
578
579 s_ptexVolumetricFog = CTexture::GetOrCreateTextureObject("$VolFogInscattering", 0, 0, 0, eTT_3D, FT_NOMIPS | FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_UNORDERED_ACCESS, eTF_Unknown);
580 s_ptexVolCloudShadow = CTexture::GetOrCreateTextureObject("$VolCloudShadows", 0, 0, 0, eTT_3D, FT_NOMIPS | FT_USAGE_UNORDERED_ACCESS, eTF_Unknown);
581
582 #if CRY_PLATFORM_DURANGO && DURANGO_USE_ESRAM
583 // Assign ESRAM offsets
584 if (CRenderer::CV_r_useESRAM)
585 {
586 // Precomputed offsets, using xg library and aligned to 4k
587 // 1600x900 RGBA16F: 11894784
588 // 1600x900 RGBA8: 5955584
589
590 if (gRenDev->GetWidth() <= 1600 && gRenDev->GetHeight() <= 900)
591 {
592 s_ptexHDRTarget->SetESRAMOffset(0);
593 s_ptexSceneSpecularESRAM->SetESRAMOffset(0);
594 s_ptexSceneNormalsMap->SetESRAMOffset(11894784 + 5955584 * 0);
595 s_ptexSceneDiffuse->SetESRAMOffset(11894784 + 5955584 * 1);
596 // Depth target uses: 11894784 + 5955584 * 2
597 }
598 else
599 {
600 iLog->LogError("Disabling ESRAM since resolution is larger than 1600x900");
601 assert(0);
602 }
603 }
604 #endif
605 }
606
607 }
608
609 ////////////////////////////////////////////////////////////////////////////////////////////////////
610 ////////////////////////////////////////////////////////////////////////////////////////////////////
611
612 void CRendererResources::CreateSystemTargets(int resourceWidth, int resourceHeight)
613 {
614 if (!resourceWidth ) resourceWidth = s_resourceWidth;
615 if (!resourceHeight) resourceHeight = s_resourceHeight;
616
617 if (!resourceWidth ) resourceWidth = s_renderWidth;
618 if (!resourceHeight) resourceHeight = s_renderHeight;
619
620 CRY_ASSERT(resourceWidth);
621 CRY_ASSERT(resourceHeight);
622
623 if (!gcpRendD3D->m_bSystemTargetsInit)
624 {
625 const bool bR11G11B10FAvailable = s_hwTexFormatSupport.IsFormatSupported(eTF_R11G11B10F);
626 ETEX_Format nHDRFormat = CRenderer::CV_r_HDRTexFormat == 0 && bR11G11B10FAvailable ? eTF_R11G11B10F : eTF_R16G16B16A16F;
627
628 // Create ZTarget
629 CreateDepthMaps(resourceWidth, resourceHeight);
630
631 // Create scene targets
632 CreateSceneMaps(nHDRFormat, resourceWidth, resourceHeight);
633
634 // Create HDR targets
635 CreateHDRMaps(resourceWidth, resourceHeight);
636
637 // Allocate cached shadow maps if required
638 CreateCachedShadowMaps();
639
640 // Allocate the nearest shadow map if required
641 CreateNearestShadowMap();
642
643 // Create post effects targets
644 CreatePostFXMaps(resourceWidth, resourceHeight);
645
646 // Create deferred lighting targets
647 CreateDeferredMaps(resourceWidth, resourceHeight);
648
649 s_resourceWidth = resourceWidth;
650 s_resourceHeight = resourceHeight;
651
652 gcpRendD3D->m_bSystemTargetsInit = 1;
653 }
654 }
655
656 void CRendererResources::ResizeSystemTargets(int renderWidth, int renderHeight)
657 {
658 int resourceWidth = s_resourceWidth;
659 int resourceHeight = s_resourceHeight;
660
661 #if 0
662 if (resourceWidth < renderWidth ||
663 resourceHeight < renderHeight)
664 {
665 resourceWidth = std::max(resourceWidth , renderWidth);
666 resourceHeight = std::max(resourceHeight, renderHeight);
667 #else
668 if (resourceWidth != renderWidth ||
669 resourceHeight != renderHeight)
670 {
671 resourceWidth = renderWidth;
672 resourceHeight = renderHeight;
673 #endif
674 const bool bR11G11B10FAvailable = s_hwTexFormatSupport.IsFormatSupported(eTF_R11G11B10F);
675 ETEX_Format nHDRFormat = (CRenderer::CV_r_HDRTexFormat == 0 && bR11G11B10FAvailable) ? eTF_R11G11B10F : eTF_R16G16B16A16F;
676
677 // Resize ZTarget
678 CreateDepthMaps(resourceWidth, resourceHeight);
679
680 // Resize scene targets
681 CreateSceneMaps(nHDRFormat, resourceWidth, resourceHeight);
682
683 // Resize HDR targets
684 CreateHDRMaps(resourceWidth, resourceHeight);
685
686 // Resize post effects targets
687 CreatePostFXMaps(resourceWidth, resourceHeight);
688
689 // Resize deferred lighting targets
690 CreateDeferredMaps(resourceWidth, resourceHeight);
691
692 s_resourceWidth = resourceWidth;
693 s_resourceHeight = resourceHeight;
694 }
695 }
696
697 void CRendererResources::DestroySystemTargets()
698 {
699 if (gcpRendD3D->m_bSystemTargetsInit)
700 {
701 DestroyDepthMaps();
702 DestroySceneMaps();
703 DestroyHDRMaps();
704 DestroyCachedShadowMaps();
705 DestroyNearestShadowMap();
706 DestroyDeferredMaps();
707 DestroyPostFXMaps();
708
709 SAFE_RELEASE(s_ptexWaterVolumeTemp[0]);
710 SAFE_RELEASE(s_ptexWaterVolumeTemp[1]);
711 SAFE_RELEASE_FORCE(s_ptexWaterOcean);
712
713 SAFE_RELEASE_FORCE(s_ptexSceneNormalsMap);
714 SAFE_RELEASE_FORCE(s_ptexSceneNormalsBent);
715 SAFE_RELEASE_FORCE(s_ptexSceneDiffuse);
716 SAFE_RELEASE_FORCE(s_ptexSceneSpecular);
717 SAFE_RELEASE_FORCE(s_ptexSceneSelectionIDs);
718 #if defined(DURANGO_USE_ESRAM)
719 SAFE_RELEASE(s_ptexSceneSpecularESRAM);
720 #endif
721 SAFE_RELEASE_FORCE(s_ptexSceneDiffuseTmp);
722 SAFE_RELEASE_FORCE(s_ptexSceneSpecularTmp);
723
724 s_resourceWidth = 0;
725 s_resourceHeight = 0;
726
727 gcpRendD3D->m_bSystemTargetsInit = 0;
728 }
729 }
730
731 ////////////////////////////////////////////////////////////////////////////////////////////////////
732 ////////////////////////////////////////////////////////////////////////////////////////////////////
733
734 void CRendererResources::CreateDepthMaps(int resourceWidth, int resourceHeight)
735 {
736 const ETEX_Format preferredDepthFormat =
737 gRenDev->GetDepthBpp() == 32 ? eTF_D32FS8 :
738 gRenDev->GetDepthBpp() == 24 ? eTF_D24S8 :
739 gRenDev->GetDepthBpp() == 8 ? eTF_D16S8 : eTF_D16;
740 const ETEX_Format eTFZ = s_eTFZ =
741 preferredDepthFormat == eTF_D32FS8 ? eTF_R32F :
742 preferredDepthFormat == eTF_D24S8 ? eTF_R32F :
743 preferredDepthFormat == eTF_D16S8 ? eTF_R16 : eTF_R16;
744
745 const uint32 nDSFlags = FT_DONT_STREAM | FT_DONT_RELEASE | FT_USAGE_DEPTHSTENCIL;
746 const uint32 nRTFlags = FT_DONT_STREAM | FT_DONT_RELEASE | FT_USAGE_RENDERTARGET;
747
748 s_ptexLinearDepth->SetFlags(nRTFlags);
749 s_ptexLinearDepth->SetWidth(resourceWidth);
750 s_ptexLinearDepth->SetHeight(resourceHeight);
751 s_ptexLinearDepth->CreateRenderTarget(eTFZ, ColorF(1.0f, 1.0f, 1.0f, 1.0f));
752
753 }
754
755 void CRendererResources::DestroyDepthMaps()
756 {
757 SAFE_RELEASE_FORCE(s_ptexLinearDepth);
758 }
759
760 //==================================================================================================
761
762 void CRendererResources::CreateSceneMaps(ETEX_Format eTF, int resourceWidth, int resourceHeight)
763 {
764 const int32 nWidth = resourceWidth;
765 const int32 nHeight = resourceHeight;
766 uint32 nFlags = FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_USAGE_UNORDERED_ACCESS;
767
768 if (!s_ptexSceneTarget)
769 s_ptexSceneTarget = CTexture::GetOrCreateRenderTarget("$SceneTarget", nWidth, nHeight, Clr_Empty, eTT_2D, nFlags, eTF, TO_SCENE_TARGET);
770 else
771 {
772 s_ptexSceneTarget->SetFlags(nFlags);
773 s_ptexSceneTarget->SetWidth(nWidth);
774 s_ptexSceneTarget->SetHeight(nHeight);
775 s_ptexSceneTarget->CreateRenderTarget(eTF, Clr_Empty);
776 }
777
778 nFlags &= ~(FT_USAGE_MSAA | FT_USAGE_UNORDERED_ACCESS);
779
780 // This RT used for all post processes passes and shadow mask (group 0) as well
781 if (!CTexture::IsTextureExist(s_ptexBackBuffer))
782 s_ptexBackBuffer = CTexture::GetOrCreateRenderTarget("$BackBuffer", nWidth, nHeight, Clr_Empty, eTT_2D, nFlags | FT_USAGE_ALLOWREADSRGB, eTF_R8G8B8A8, TO_BACKBUFFERMAP);
783 else
784 {
785 s_ptexBackBuffer->SetFlags(nFlags | FT_USAGE_ALLOWREADSRGB);
786 s_ptexBackBuffer->SetWidth(nWidth);
787 s_ptexBackBuffer->SetHeight(nHeight);
788 s_ptexBackBuffer->CreateRenderTarget(eTF_R8G8B8A8, Clr_Empty);
789 }
790
791 nFlags &= ~(FT_USAGE_MSAA | FT_USAGE_UNORDERED_ACCESS);
792
793 // This RT can be used by the Render3DModelMgr if the buffer needs to be persistent
794 if (CRenderer::CV_r_UsePersistentRTForModelHUD > 0)
795 {
796 if (!CTexture::IsTextureExist(s_ptexModelHudBuffer))
797 s_ptexModelHudBuffer = CTexture::GetOrCreateRenderTarget("$ModelHUD", nWidth, nHeight, Clr_Transparent, eTT_2D, nFlags, eTF_R8G8B8A8);
798 else
799 {
800 s_ptexModelHudBuffer->SetFlags(nFlags);
801 s_ptexModelHudBuffer->SetWidth(nWidth);
802 s_ptexModelHudBuffer->SetHeight(nHeight);
803 s_ptexModelHudBuffer->CreateRenderTarget(eTF_R8G8B8A8, Clr_Transparent);
804 }
805 }
806
807 if (gEnv->IsEditor())
808 {
809 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneSelectionIDs", s_ptexSceneSelectionIDs, nWidth, nHeight, Clr_Transparent, false, false, eTF_R32F, -1, nFlags);
810 }
811 }
812
813 void CRendererResources::DestroySceneMaps()
814 {
815 SAFE_RELEASE(s_ptexSceneTarget);
816 SAFE_RELEASE(s_ptexBackBuffer);
817
818 if (CRenderer::CV_r_UsePersistentRTForModelHUD > 0)
819 {
820 SAFE_RELEASE(s_ptexModelHudBuffer);
821 }
822
823 if (gEnv->IsEditor())
824 {
825 SAFE_RELEASE(s_ptexSceneSelectionIDs);
826 }
827 }
828
829 //==================================================================================================
830
831 void CRendererResources::CreateDeferredMaps(int resourceWidth, int resourceHeight)
832 {
833 Vec2i resolution = Vec2i(resourceWidth, resourceHeight);
834
835 static uint32 nPrevLBuffersFmt = CRenderer::CV_r_DeferredShadingLBuffersFmt;
836 // if (!s_ptexSceneNormalsMap ||
837 // !s_ptexSceneNormalsMap->GetDevTexture() ||
838 // s_ptexSceneNormalsMap->GetDevTexture()->IsMSAAChanged()
839 // || s_ptexSceneNormalsMap->GetWidth() != resolution.x
840 // || s_ptexSceneNormalsMap->GetHeight() != resolution.y
841 // || nPrevLBuffersFmt != CRenderer::CV_r_DeferredShadingLBuffersFmt
842 // || (gRenDev->IsStereoEnabled() && !s_ptexVelocityObjects[1]->GetDevTexture()))
843 {
844 nPrevLBuffersFmt = CRenderer::CV_r_DeferredShadingLBuffersFmt;
845
846 const int width = resolution.x, width_r2 = (width + 1) / 2, width_r4 = (width_r2 + 1) / 2, width_r8 = (width_r4 + 1) / 2;
847 const int height = resolution.y, height_r2 = (height + 1) / 2, height_r4 = (height_r2 + 1) / 2, height_r8 = (height_r4 + 1) / 2;
848
849 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneNormalsMap", s_ptexSceneNormalsMap, width, height, Clr_Unknown, true, false, eTF_R8G8B8A8, TO_SCENE_NORMALMAP, FT_USAGE_ALLOWREADSRGB);
850 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneNormalsBent", s_ptexSceneNormalsBent, width, height, Clr_Median, true, false, eTF_R8G8B8A8);
851 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$AOColorBleed", s_ptexAOColorBleed, width_r8, height_r8, Clr_Unknown, true, false, eTF_R8G8B8A8);
852
853 ETEX_Format preferredDepthFormat =
854 gRenDev->GetDepthBpp() == 32 ? eTF_D32FS8 :
855 gRenDev->GetDepthBpp() == 24 ? eTF_D24S8 :
856 gRenDev->GetDepthBpp() == 8 ? eTF_D16S8 : eTF_D16;
857 ETEX_Format fmtZScaled = eTF_R16G16B16A16F;
858 ETEX_Format nTexFormat = eTF_R16G16B16A16F;
859 #if CRY_PLATFORM_WINDOWS || CRY_PLATFORM_APPLE || CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID
860 if (CRenderer::CV_r_DeferredShadingLBuffersFmt == 1)
861 nTexFormat = eTF_R11G11B10F;
862 #endif
863
864 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneDiffuseTmp", s_ptexSceneDiffuseTmp, width, height, Clr_Empty, true, false, eTF_R8G8B8A8);
865 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneSpecularTmp", s_ptexSceneSpecularTmp, width, height, Clr_Empty, true, false, eTF_R8G8B8A8);
866
867 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneDiffuse", s_ptexSceneDiffuse, width, height, Clr_Empty, true, false, eTF_R8G8B8A8, -1, FT_USAGE_ALLOWREADSRGB);
868 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneSpecular", s_ptexSceneSpecular, width, height, Clr_Empty, true, false, eTF_R8G8B8A8, -1, FT_USAGE_ALLOWREADSRGB);
869 #if defined(DURANGO_USE_ESRAM)
870 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$SceneSpecularESRAM", s_ptexSceneSpecularESRAM, width, height, Clr_Empty, true, false, eTF_R8G8B8A8, -1);
871 #endif
872
873 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$VelocityObjects", s_ptexVelocityObjects[0], width, height, Clr_Transparent, true, false, eTF_R16G16F, -1, FT_USAGE_UNORDERED_ACCESS);
874 if (gRenDev->IsStereoEnabled())
875 {
876 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$VelocityObject_R", s_ptexVelocityObjects[1], width, height, Clr_Transparent, true, false, eTF_R16G16F, -1, FT_USAGE_UNORDERED_ACCESS);
877 }
878
879 SD3DPostEffectsUtils::GetOrCreateDepthStencil("$SceneDepthScaled" , s_ptexSceneDepthScaled[0], width_r2, height_r2, Clr_FarPlane_Rev, false, false, preferredDepthFormat, -1, FT_USAGE_DEPTHSTENCIL);
880 SD3DPostEffectsUtils::GetOrCreateDepthStencil("$SceneDepthScaled2", s_ptexSceneDepthScaled[1], width_r4, height_r4, Clr_FarPlane_Rev, false, false, preferredDepthFormat, -1, FT_USAGE_DEPTHSTENCIL);
881 SD3DPostEffectsUtils::GetOrCreateDepthStencil("$SceneDepthScaled3", s_ptexSceneDepthScaled[2], width_r8, height_r8, Clr_FarPlane_Rev, false, false, preferredDepthFormat, -1, FT_USAGE_DEPTHSTENCIL);
882
883 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$ZTargetScaled" , s_ptexLinearDepthScaled[0], width_r2, height_r2, ColorF(1.0f, 1.0f, 1.0f, 1.0f), 1, 0, fmtZScaled, TO_DOWNSCALED_ZTARGET_FOR_AO);
884 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$ZTargetScaled2", s_ptexLinearDepthScaled[1], width_r4, height_r4, ColorF(1.0f, 1.0f, 1.0f, 1.0f), 1, 0, fmtZScaled, TO_QUARTER_ZTARGET_FOR_AO);
885 SD3DPostEffectsUtils::GetOrCreateRenderTarget("$ZTargetScaled3", s_ptexLinearDepthScaled[2], width_r8, height_r8, ColorF(1.0f, 1.0f, 1.0f, 1.0f), 1, 0, fmtZScaled);
886 }
887
888 // Pre-create shadow pool
889 IF(gcpRendD3D->m_pRT->IsRenderThread() && gEnv->p3DEngine, 1)
890 {
891 //init shadow pool size
892 static ICVar* p_e_ShadowsPoolSize = iConsole->GetCVar("e_ShadowsPoolSize");
893 gcpRendD3D->m_nShadowPoolHeight = p_e_ShadowsPoolSize->GetIVal();
894 gcpRendD3D->m_nShadowPoolWidth = gcpRendD3D->m_nShadowPoolHeight; //square atlas
895
896 ETEX_Format eShadTF = gcpRendD3D->CV_r_shadowtexformat == 1 ? eTF_D16 : eTF_D32F;
897 s_ptexRT_ShadowPool->Invalidate(gcpRendD3D->m_nShadowPoolWidth, gcpRendD3D->m_nShadowPoolHeight, eShadTF);
898 if (!CTexture::IsTextureExist(s_ptexRT_ShadowPool))
899 {
900 s_ptexRT_ShadowPool->CreateDepthStencil(eTF_Unknown, ColorF(1.0f, 5, 0.f, 0.f));
901 }
902 }
903
904 // shadow mask
905 {
906 if (s_ptexShadowMask)
907 s_ptexShadowMask->Invalidate(resolution.x, resolution.y, eTF_R8);
908
909 if (!CTexture::IsTextureExist(s_ptexShadowMask))
910 {
911 const int nArraySize = gcpRendD3D->CV_r_ShadowCastingLightsMaxCount;
912 s_ptexShadowMask = CTexture::GetOrCreateTextureArray("$ShadowMask", resolution.x, resolution.y, nArraySize, 1, eTT_2DArray, FT_DONT_STREAM | FT_USAGE_RENDERTARGET, eTF_R8, TO_SHADOWMASK);
913 }
914 }
915
916 // height map AO mask
917 if (CRenderer::CV_r_HeightMapAO > 0)
918 {
919 const int shift = clamp_tpl(3 - CRenderer::CV_r_HeightMapAO, 0, 2);
920
921 int hmaoWidth = resolution.x;
922 int hmaoHeight = resolution.y;
923 for (int i = 0; i < shift; i++)
924 {
925 hmaoWidth = (hmaoWidth + 1) / 2;
926 hmaoHeight = (hmaoHeight + 1) / 2;
927 }
928
929 for (int i = 0; i < 2; ++i)
930 {
931 if (s_ptexHeightMapAO[i])
932 s_ptexHeightMapAO[i]->Invalidate(hmaoWidth, hmaoHeight, eTF_R8G8);
933
934 if (!CTexture::IsTextureExist(s_ptexHeightMapAO[i]))
935 {
936 char buf[128];
937 cry_sprintf(buf, "$HeightMapAO_%d", i);
938
939 SD3DPostEffectsUtils::GetOrCreateRenderTarget(buf, s_ptexHeightMapAO[i], hmaoWidth, hmaoHeight, Clr_Neutral, true, false, eTF_R8G8);
940 }
941 }
942 }
943 }
944
945 void CRendererResources::DestroyDeferredMaps()
946 {
947 SAFE_RELEASE(s_ptexSceneNormalsMap);
948 SAFE_RELEASE(s_ptexSceneNormalsBent);
949 SAFE_RELEASE(s_ptexAOColorBleed);
950 SAFE_RELEASE(s_ptexSceneDiffuseTmp);
951 SAFE_RELEASE(s_ptexSceneSpecularTmp);
952 SAFE_RELEASE(s_ptexSceneDiffuse);
953 SAFE_RELEASE(s_ptexSceneSpecular);
954 #if defined(DURANGO_USE_ESRAM)
955 SAFE_RELEASE(s_ptexSceneSpecularESRAM);
956 #endif
957 SAFE_RELEASE(s_ptexVelocityObjects[0]);
958 SAFE_RELEASE(s_ptexVelocityObjects[1]);
959 SAFE_RELEASE(s_ptexLinearDepthScaled[0]);
960 SAFE_RELEASE(s_ptexLinearDepthScaled[1]);
961 SAFE_RELEASE(s_ptexLinearDepthScaled[2]);
962 SAFE_RELEASE(s_ptexSceneDepthScaled[0]);
963 SAFE_RELEASE(s_ptexSceneDepthScaled[1]);
964 SAFE_RELEASE(s_ptexSceneDepthScaled[2]);
965
966 // shadow pool
967 // shadow mask
968 SAFE_RELEASE(s_ptexRT_ShadowPool);
969 SAFE_RELEASE(s_ptexShadowMask);
970
971 // height map AO mask
972 SAFE_RELEASE(s_ptexHeightMapAO[0]);
973 SAFE_RELEASE(s_ptexHeightMapAO[1]);
974 }
975
976 //==================================================================================================
977
978 void CRendererResources::CreateHDRMaps(int resourceWidth, int resourceHeight)
979 {
980 CD3D9Renderer* r = gcpRendD3D;
981 SRenderTargetPool* pHDRPostProcess = SRenderTargetPool::GetInstance();
982
983 const int width = resourceWidth, width_r2 = (width + 1) / 2, width_r4 = (width_r2 + 1) / 2, width_r8 = (width_r4 + 1) / 2, width_r16 = (width_r8 + 1) / 2;
984 const int height = resourceHeight, height_r2 = (height + 1) / 2, height_r4 = (height_r2 + 1) / 2, height_r8 = (height_r4 + 1) / 2, height_r16 = (height_r8 + 1) / 2;
985
986 pHDRPostProcess->ClearRenderTargetList();
987
988 const bool bR11G11B10FAvailable = s_hwTexFormatSupport.IsFormatSupported(eTF_R11G11B10F);
989 ETEX_Format nHDRFormat = (CRenderer::CV_r_HDRTexFormat == 0 && bR11G11B10FAvailable) ? eTF_R11G11B10F : eTF_R16G16B16A16F;
990
991 uint32 nHDRTargetFlags = FT_DONT_RELEASE;
992 uint32 nHDRTargetFlagsUAV = nHDRTargetFlags | (FT_USAGE_UNORDERED_ACCESS); // UAV required for tiled deferred shading
993 pHDRPostProcess->AddRenderTarget(width, height, Clr_Unknown, nHDRFormat, 1.0f, "$HDRTarget", &s_ptexHDRTarget, nHDRTargetFlagsUAV);
994
995 #if !CRY_MOBILE_PIPELINE && !defined(CRY_PLATFORM_MOBILE)
996 pHDRPostProcess->AddRenderTarget(width, height, Clr_Unknown, eTF_R11G11B10F, 1.0f, "$HDRTargetPrev", &s_ptexHDRTargetPrev);
997
998 // Scaled versions of the HDR scene texture
999 pHDRPostProcess->AddRenderTarget(width_r2, height_r2, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaled0", &s_ptexHDRTargetScaled[0], FT_DONT_RELEASE);
1000 pHDRPostProcess->AddRenderTarget(width_r2, height_r2, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTmp0", &s_ptexHDRTargetScaledTmp[0], FT_DONT_RELEASE);
1001 pHDRPostProcess->AddRenderTarget(width_r2, height_r2, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTempRT0", &s_ptexHDRTargetScaledTempRT[0], FT_DONT_RELEASE);
1002
1003 pHDRPostProcess->AddRenderTarget(width_r4, height_r4, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaled1", &s_ptexHDRTargetScaled[1], FT_DONT_RELEASE);
1004 pHDRPostProcess->AddRenderTarget(width_r4, height_r4, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTmp1", &s_ptexHDRTargetScaledTmp[1], FT_DONT_RELEASE);
1005 pHDRPostProcess->AddRenderTarget(width_r4, height_r4, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTempRT1", &s_ptexHDRTargetScaledTempRT[1], FT_DONT_RELEASE);
1006
1007 pHDRPostProcess->AddRenderTarget(width_r4, height_r4, Clr_Unknown, eTF_R11G11B10F, 0.9f, "$HDRTempBloom0", &s_ptexHDRTempBloom[0], FT_DONT_RELEASE);
1008 pHDRPostProcess->AddRenderTarget(width_r4, height_r4, Clr_Unknown, eTF_R11G11B10F, 0.9f, "$HDRTempBloom1", &s_ptexHDRTempBloom[1], FT_DONT_RELEASE);
1009 pHDRPostProcess->AddRenderTarget(width_r4, height_r4, Clr_Unknown, eTF_R11G11B10F, 0.9f, "$HDRFinalBloom", &s_ptexHDRFinalBloom, FT_DONT_RELEASE);
1010
1011 pHDRPostProcess->AddRenderTarget(width_r8, height_r8, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaled2", &s_ptexHDRTargetScaled[2], FT_DONT_RELEASE);
1012 pHDRPostProcess->AddRenderTarget(width_r8, height_r8, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTempRT2", &s_ptexHDRTargetScaledTempRT[2], FT_DONT_RELEASE);
1013
1014 pHDRPostProcess->AddRenderTarget(width_r16, height_r16, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaled3", &s_ptexHDRTargetScaled[3], FT_DONT_RELEASE);
1015 pHDRPostProcess->AddRenderTarget(width_r16, height_r16, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTmp3", &s_ptexHDRTargetScaledTmp[3], FT_DONT_RELEASE);
1016 pHDRPostProcess->AddRenderTarget(width_r16, height_r16, Clr_Unknown, nHDRFormat, 0.9f, "$HDRTargetScaledTempRT3", &s_ptexHDRTargetScaledTempRT[3], FT_DONT_RELEASE);
1017
1018 for (int i = 0; i < 8; i++)
1019 {
1020 char szName[256];
1021 sprintf(szName, "$HDRAdaptedLuminanceCur_%d", i);
1022 pHDRPostProcess->AddRenderTarget(1, 1, Clr_White, eTF_R16G16F, 0.1f, szName, &s_ptexHDRAdaptedLuminanceCur[i], FT_DONT_RELEASE);
1023 }
1024
1025 pHDRPostProcess->AddRenderTarget(width, height, Clr_Unknown, eTF_R11G11B10F, 1.0f, "$SceneTargetR11G11B10F_0", &s_ptexSceneTargetR11G11B10F[0], nHDRTargetFlagsUAV);
1026 pHDRPostProcess->AddRenderTarget(width, height, Clr_Unknown, eTF_R11G11B10F, 1.0f, "$SceneTargetR11G11B10F_1", &s_ptexSceneTargetR11G11B10F[1], nHDRTargetFlags);
1027 #endif
1028
1029 pHDRPostProcess->AddRenderTarget(width, height, Clr_Unknown, eTF_R8G8B8A8, 0.1f, "$Velocity", &s_ptexVelocity, FT_DONT_RELEASE);
1030 pHDRPostProcess->AddRenderTarget(20, height, Clr_Unknown, eTF_R8G8B8A8, 0.1f, "$VelocityTilesTmp0", &s_ptexVelocityTiles[0], FT_DONT_RELEASE);
1031 pHDRPostProcess->AddRenderTarget(20, 20, Clr_Unknown, eTF_R8G8B8A8, 0.1f, "$VelocityTilesTmp1", &s_ptexVelocityTiles[1], FT_DONT_RELEASE);
1032 pHDRPostProcess->AddRenderTarget(20, 20, Clr_Unknown, eTF_R8G8B8A8, 0.1f, "$VelocityTiles", &s_ptexVelocityTiles[2], FT_DONT_RELEASE);
1033
1034
1035 #if !CRY_MOBILE_PIPELINE && !defined(CRY_PLATFORM_MOBILE)
1036 pHDRPostProcess->AddRenderTarget(width_r2, height_r2, Clr_Unknown, nHDRFormat, 0.9f, "$HDRDofLayerNear", &s_ptexHDRDofLayers[0], FT_DONT_RELEASE);
1037 pHDRPostProcess->AddRenderTarget(width_r2, height_r2, Clr_Unknown, nHDRFormat, 0.9f, "$HDRDofLayerFar", &s_ptexHDRDofLayers[1], FT_DONT_RELEASE);
1038 pHDRPostProcess->AddRenderTarget(width_r2, height_r2, Clr_Unknown, eTF_R16G16F, 1.0f, "$MinCoC_0_Temp", &s_ptexSceneCoCTemp, FT_DONT_RELEASE);
1039 for (int i = 0; i < MIN_DOF_COC_K; i++)
1040 {
1041 char szName[256];
1042 cry_sprintf(szName, "$MinCoC_%d", i);
1043 pHDRPostProcess->AddRenderTarget(width_r2 / (i + 1), height_r2 / (i + 1), Clr_Unknown, eTF_R16G16F, 0.1f, szName, &s_ptexSceneCoC[i], FT_DONT_RELEASE, -1, true);
1044 }
1045
1046 // TODO: make it a MIP-mapped resource and/or use compute
1047 // Luminance rt
1048 for (int i = 0; i < NUM_HDR_TONEMAP_TEXTURES; i++)
1049 {
1050 char szName[256];
1051 int iSampleLen = 1 << (2 * i);
1052 cry_sprintf(szName, "$HDRToneMap_%d", i);
1053
1054 pHDRPostProcess->AddRenderTarget(iSampleLen, iSampleLen, Clr_Dark, eTF_R16G16F, 0.7f, szName, &s_ptexHDRToneMaps[i], FT_DONT_RELEASE | (i == 0 ? FT_STAGE_READBACK : 0));
1055 }
1056
1057 s_ptexHDRMeasuredLuminanceDummy = CTexture::GetOrCreateTextureObject("$HDRMeasuredLum_Dummy", 0, 0, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM, eTF_R16G16F, TO_HDR_MEASURED_LUMINANCE);
1058 for (int i = 0; i < MAX_GPU_NUM; ++i)
1059 {
1060 char szName[256];
1061 cry_sprintf(szName, "$HDRMeasuredLum_%d", i);
1062 s_ptexHDRMeasuredLuminance[i] = CTexture::GetOrCreate2DTexture(szName, 1, 1, 0, FT_DONT_RELEASE | FT_DONT_STREAM, NULL, eTF_R16G16F);
1063 }
1064 #endif
1065
1066 pHDRPostProcess->CreateRenderTargetList();
1067
1068 r->m_vSceneLuminanceInfo = Vec4(1.0f, 1.0f, 1.0f, 1.0f);
1069 r->m_fAdaptedSceneScaleLBuffer = r->m_fAdaptedSceneScale = r->m_fScotopicSceneScale = 1.0f;
1070 }
1071
1072 void CRendererResources::DestroyHDRMaps()
1073 {
1074 int i;
1075
1076 SAFE_RELEASE_FORCE(s_ptexHDRTarget);
1077 SAFE_RELEASE_FORCE(s_ptexHDRTargetPrev);
1078 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaled[0]);
1079 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaled[1]);
1080 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaled[2]);
1081 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaled[3]);
1082
1083 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTmp[0]);
1084 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTmp[1]);
1085 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTmp[3]);
1086
1087 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTempRT[0]);
1088 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTempRT[1]);
1089 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTempRT[2]);
1090 SAFE_RELEASE_FORCE(s_ptexHDRTargetScaledTempRT[3]);
1091
1092 SAFE_RELEASE_FORCE(s_ptexHDRTempBloom[0]);
1093 SAFE_RELEASE_FORCE(s_ptexHDRTempBloom[1]);
1094 SAFE_RELEASE_FORCE(s_ptexHDRFinalBloom);
1095
1096 for (i = 0; i < 8; i++)
1097 {
1098 SAFE_RELEASE_FORCE(s_ptexHDRAdaptedLuminanceCur[i]);
1099 }
1100
1101 for (i = 0; i < NUM_HDR_TONEMAP_TEXTURES; i++)
1102 {
1103 SAFE_RELEASE_FORCE(s_ptexHDRToneMaps[i]);
1104 }
1105 SAFE_RELEASE_FORCE(s_ptexHDRMeasuredLuminanceDummy);
1106 for (i = 0; i < MAX_GPU_NUM; ++i)
1107 {
1108 SAFE_RELEASE_FORCE(s_ptexHDRMeasuredLuminance[i]);
1109 }
1110
1111 s_ptexCurLumTexture = NULL;
1112
1113 SAFE_RELEASE_FORCE(s_ptexVelocity);
1114 SAFE_RELEASE_FORCE(s_ptexVelocityTiles[0]);
1115 SAFE_RELEASE_FORCE(s_ptexVelocityTiles[1]);
1116 SAFE_RELEASE_FORCE(s_ptexVelocityTiles[2]);
1117
1118 SAFE_RELEASE_FORCE(s_ptexHDRDofLayers[0]);
1119 SAFE_RELEASE_FORCE(s_ptexHDRDofLayers[1]);
1120 SAFE_RELEASE_FORCE(s_ptexSceneCoCTemp);
1121 for (i = 0; i < MIN_DOF_COC_K; i++)
1122 {
1123 SAFE_RELEASE_FORCE(s_ptexSceneCoC[i]);
1124 }
1125 }
1126
1127 //==================================================================================================
1128
1129 bool CRendererResources::CreatePostFXMaps(int resourceWidth, int resourceHeight)
1130 {
1131 #if !defined(CRY_PLATFORM_MOBILE)
1132 const bool bCreateCaustics = (CRenderer::CV_r_watervolumecaustics && CRenderer::CV_r_watercaustics && CRenderer::CV_r_watercausticsdeferred) && !CTexture::IsTextureExist(s_ptexWaterCaustics[0]);
1133
1134 const int width = resourceWidth, width_r2 = (width + 1) / 2, width_r4 = (width_r2 + 1) / 2, width_r8 = (width_r4 + 1) / 2;
1135 const int height = resourceHeight, height_r2 = (height + 1) / 2, height_r4 = (height_r2 + 1) / 2, height_r8 = (height_r4 + 1) / 2;
1136
1137 if (!s_ptexBackBufferScaled[0] ||
1138 s_ptexBackBufferScaled[0]->GetWidth() != width_r2 ||
1139 s_ptexBackBufferScaled[0]->GetHeight() != height_r2 ||
1140 bCreateCaustics)
1141 {
1142 assert(gRenDev);
1143
1144 SPostEffectsUtils::GetOrCreateRenderTarget("$Cached3DHud", s_ptexCached3DHud, width, height, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1145 SPostEffectsUtils::GetOrCreateRenderTarget("$Cached3DHudDownsampled", s_ptexCached3DHudScaled, width_r4, height_r4, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1146
1147 // Scaled versions of the scene target
1148 SPostEffectsUtils::GetOrCreateRenderTarget("$BackBufferScaled_d2", s_ptexBackBufferScaled[0], width_r2, height_r2, Clr_Unknown, 1, 0, eTF_R8G8B8A8, TO_BACKBUFFERSCALED_D2, FT_DONT_RELEASE);
1149
1150 // Ghosting requires data overframes, need to handle for each GPU in MGPU mode
1151 SPostEffectsUtils::GetOrCreateRenderTarget("$PrevFrameScaled", s_ptexPrevFrameScaled, width_r2, height_r2, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1152
1153 SPostEffectsUtils::GetOrCreateRenderTarget("$BackBufferScaledTemp_d2", s_ptexBackBufferScaledTemp[0], width_r2, height_r2, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1154 SPostEffectsUtils::GetOrCreateRenderTarget("$WaterVolumeRefl", s_ptexWaterVolumeRefl[0], width_r2, height_r2, Clr_Unknown, 1, true, eTF_R11G11B10F, TO_WATERVOLUMEREFLMAP, FT_DONT_RELEASE);
1155 SPostEffectsUtils::GetOrCreateRenderTarget("$WaterVolumeReflPrev", s_ptexWaterVolumeRefl[1], width_r2, height_r2, Clr_Unknown, 1, true, eTF_R11G11B10F, TO_WATERVOLUMEREFLMAPPREV, FT_DONT_RELEASE);
1156
1157 // s_ptexWaterVolumeRefl[0]->DisableMgpuSync();
1158 // s_ptexWaterVolumeRefl[1]->DisableMgpuSync();
1159
1160 SPostEffectsUtils::GetOrCreateRenderTarget("$BackBufferScaled_d4", s_ptexBackBufferScaled[1], width_r4, height_r4, Clr_Unknown, 1, 0, eTF_R8G8B8A8, TO_BACKBUFFERSCALED_D4, FT_DONT_RELEASE);
1161 SPostEffectsUtils::GetOrCreateRenderTarget("$BackBufferScaledTemp_d4", s_ptexBackBufferScaledTemp[1], width_r4, height_r4, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1162
1163 SPostEffectsUtils::GetOrCreateRenderTarget("$BackBufferScaled_d8", s_ptexBackBufferScaled[2], width_r8, height_r8, Clr_Unknown, 1, 0, eTF_R8G8B8A8, TO_BACKBUFFERSCALED_D8, FT_DONT_RELEASE);
1164
1165 SPostEffectsUtils::GetOrCreateRenderTarget("$RainSSOcclusion0", s_ptexRainSSOcclusion[0], width_r8, height_r8, Clr_Unknown, 1, false, eTF_R8G8B8A8);
1166 SPostEffectsUtils::GetOrCreateRenderTarget("$RainSSOcclusion1", s_ptexRainSSOcclusion[1], width_r8, height_r8, Clr_Unknown, 1, false, eTF_R8G8B8A8);
1167
1168 if (CRenderer::CV_r_watervolumecaustics && CRenderer::CV_r_watercaustics && CRenderer::CV_r_watercausticsdeferred)
1169 {
1170 const int nCausticRes = clamp_tpl(CRenderer::CV_r_watervolumecausticsresolution, 256, 4096);
1171 SPostEffectsUtils::GetOrCreateRenderTarget("$WaterVolumeCaustics", s_ptexWaterCaustics[0], nCausticRes, nCausticRes, Clr_Unknown, 1, false, eTF_R8G8B8A8, TO_WATERVOLUMECAUSTICSMAP);
1172 SPostEffectsUtils::GetOrCreateRenderTarget("$WaterVolumeCausticsTemp", s_ptexWaterCaustics[1], nCausticRes, nCausticRes, Clr_Unknown, 1, false, eTF_R8G8B8A8, TO_WATERVOLUMECAUSTICSMAPTEMP);
1173 }
1174 else
1175 {
1176 SAFE_RELEASE(s_ptexWaterCaustics[0]);
1177 SAFE_RELEASE(s_ptexWaterCaustics[1]);
1178 }
1179
1180 #if defined(VOLUMETRIC_FOG_SHADOWS)
1181 int fogShadowBufDiv = (CRenderer::CV_r_FogShadows == 2) ? 4 : 2;
1182 SPostEffectsUtils::GetOrCreateRenderTarget("$VolFogShadowBuf0", s_ptexVolFogShadowBuf[0], width / fogShadowBufDiv, height / fogShadowBufDiv, Clr_Unknown, 1, 0, eTF_R8G8B8A8, TO_VOLFOGSHADOW_BUF);
1183 SPostEffectsUtils::GetOrCreateRenderTarget("$VolFogShadowBuf1", s_ptexVolFogShadowBuf[1], width / fogShadowBufDiv, height / fogShadowBufDiv, Clr_Unknown, 1, 0, eTF_R8G8B8A8);
1184 #endif
1185
1186 // TODO: Only create necessary RTs for minimal ring?
1187 char str[256];
1188 for (int i = 0, end = gcpRendD3D->GetActiveGPUCount() * MAX_FRAMES_IN_FLIGHT; i < end; i++)
1189 {
1190 sprintf(str, "$FlaresOcclusion_%d", i);
1191 SPostEffectsUtils::GetOrCreateRenderTarget(str, s_ptexFlaresOcclusionRing[i], CFlareSoftOcclusionQuery::s_nIDColMax, CFlareSoftOcclusionQuery::s_nIDRowMax, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE | FT_STAGE_READBACK);
1192 }
1193
1194 SPostEffectsUtils::GetOrCreateRenderTarget("$FlaresGather", s_ptexFlaresGather, CFlareSoftOcclusionQuery::s_nGatherTextureWidth, CFlareSoftOcclusionQuery::s_nGatherTextureHeight, Clr_Unknown, 1, 0, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1195 }
1196
1197 /*
1198 * The following textures do not need to be recreated on resize
1199 */
1200
1201 if (!CTexture::IsTextureExist(s_ptexRainOcclusion))
1202 SPostEffectsUtils::GetOrCreateRenderTarget("$RainOcclusion", s_ptexRainOcclusion, RAIN_OCC_MAP_SIZE, RAIN_OCC_MAP_SIZE, Clr_Neutral, false, false, eTF_R8G8B8A8, -1, FT_DONT_RELEASE);
1203
1204 if (!CTexture::IsTextureExist(s_ptexWaterVolumeDDN))
1205 {
1206 SPostEffectsUtils::GetOrCreateRenderTarget("$WaterVolumeDDN", s_ptexWaterVolumeDDN, 64, 64, Clr_Unknown, 1, true, eTF_R16G16B16A16F, TO_WATERVOLUMEMAP);
1207 //s_ptexWaterVolumeDDN->DisableMgpuSync();
1208 }
1209 #endif
1210
1211 return 1;
1212 }
1213
1214 void CRendererResources::DestroyPostFXMaps()
1215 {
1216 SAFE_RELEASE_FORCE(s_ptexBackBufferScaled[0]);
1217 SAFE_RELEASE_FORCE(s_ptexBackBufferScaled[1]);
1218 SAFE_RELEASE_FORCE(s_ptexBackBufferScaled[2]);
1219
1220 SAFE_RELEASE_FORCE(s_ptexBackBufferScaledTemp[0]);
1221 SAFE_RELEASE_FORCE(s_ptexBackBufferScaledTemp[1]);
1222
1223 SAFE_RELEASE(s_ptexWaterVolumeDDN);
1224 SAFE_RELEASE_FORCE(s_ptexWaterVolumeRefl[0]);
1225 SAFE_RELEASE_FORCE(s_ptexWaterVolumeRefl[1]);
1226 SAFE_RELEASE(s_ptexWaterCaustics[0]);
1227 SAFE_RELEASE(s_ptexWaterCaustics[1]);
1228
1229 SAFE_RELEASE_FORCE(s_ptexCached3DHud);
1230 SAFE_RELEASE_FORCE(s_ptexCached3DHudScaled);
1231
1232 SAFE_RELEASE_FORCE(s_ptexPrevFrameScaled);
1233
1234 SAFE_RELEASE(s_ptexRainSSOcclusion[0]);
1235 SAFE_RELEASE(s_ptexRainSSOcclusion[1]);
1236 SAFE_RELEASE_FORCE(s_ptexRainOcclusion);
1237
1238 #if defined(VOLUMETRIC_FOG_SHADOWS)
1239 SAFE_RELEASE(s_ptexVolFogShadowBuf[0]);
1240 SAFE_RELEASE(s_ptexVolFogShadowBuf[1]);
1241 #endif
1242
1243 for (int i = 0; i < MAX_OCCLUSION_READBACK_TEXTURES; i++)
1244 SAFE_RELEASE_FORCE(s_ptexFlaresOcclusionRing[i]);
1245
1246 SAFE_RELEASE_FORCE(s_ptexFlaresGather);
1247 }
1248
1249 //==================================================================================================
1250
1251 void CRendererResources::CreateCachedShadowMaps()
1252 {
1253 StaticArray<int, MAX_GSM_LODS_NUM> nResolutions = gRenDev->GetCachedShadowsResolution();
1254
1255 // parse shadow resolutions from cvar
1256 {
1257 int nCurPos = 0;
1258 int nCurRes = 0;
1259
1260 string strResolutions = gEnv->pConsole->GetCVar("r_ShadowsCacheResolutions")->GetString();
1261 string strCurRes = strResolutions.Tokenize(" ,;-\t", nCurPos);
1262
1263 if (!strCurRes.empty())
1264 {
1265 nResolutions.fill(0);
1266
1267 while (!strCurRes.empty())
1268 {
1269 int nRes = atoi(strCurRes.c_str());
1270 nResolutions[nCurRes] = clamp_tpl(nRes, 0, 16384);
1271
1272 strCurRes = strResolutions.Tokenize(" ,;-\t", nCurPos);
1273 ++nCurRes;
1274 }
1275
1276 gRenDev->SetCachedShadowsResolution(nResolutions);
1277 }
1278 }
1279
1280 const ETEX_Format texFormat = CRendererCVars::CV_r_ShadowsCacheFormat == 0 ? eTF_D32F : eTF_D16;
1281 const int cachedShadowsStart = clamp_tpl(CRendererCVars::CV_r_ShadowsCache, 0, MAX_GSM_LODS_NUM - 1);
1282
1283 int gsmCascadeCount = gEnv->pSystem->GetConfigSpec() == CONFIG_LOW_SPEC ? 4 : 5;
1284 if (ICVar* pGsmLodsVar = gEnv->pConsole->GetCVar("e_GsmLodsNum"))
1285 gsmCascadeCount = pGsmLodsVar->GetIVal();
1286 const int cachedCascadesCount = cachedShadowsStart > 0 ? clamp_tpl(gsmCascadeCount - cachedShadowsStart + 1, 0, MAX_GSM_LODS_NUM) : 0;
1287
1288 for (int i = 0; i < MAX_GSM_LODS_NUM; ++i)
1289 {
1290 CTexture*& pTx = s_ptexCachedShadowMap[i];
1291
1292 if (!pTx)
1293 {
1294 char szName[32];
1295 cry_sprintf(szName, "CachedShadowMap_%d", i);
1296
1297 pTx = CTexture::GetOrCreateTextureObject(szName, nResolutions[i], nResolutions[i], 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, texFormat);
1298 }
1299
1300 pTx->Invalidate(nResolutions[i], nResolutions[i], texFormat);
1301
1302 // delete existing texture in case it's not needed anymore
1303 if (CTexture::IsTextureExist(pTx) && nResolutions[i] == 0)
1304 pTx->ReleaseDeviceTexture(false);
1305
1306 // allocate texture directly for all cached cascades
1307 if (!CTexture::IsTextureExist(pTx) && nResolutions[i] > 0 && i < cachedCascadesCount)
1308 {
1309 CryLog("Allocating shadow map cache %d x %d: %.2f MB", nResolutions[i], nResolutions[i], sqr(nResolutions[i]) * CTexture::BitsPerPixel(texFormat) / (1024.f * 1024.f * 8.f));
1310 pTx->CreateDepthStencil(texFormat, ColorF(1.0f, 1.0f, 1.0f, 1.0f));
1311 }
1312 }
1313
1314 // height map AO
1315 if (CRendererCVars::CV_r_HeightMapAO)
1316 {
1317 const int nTexRes = (int)clamp_tpl(CRendererCVars::CV_r_HeightMapAOResolution, 0.f, 16384.f);
1318 ETEX_Format texFormatMips = texFormat == eTF_D32F ? eTF_R32F : eTF_R16;
1319 // Allow non-supported SNORM/UNORM to fall back to a FLOAT format with slightly less precision
1320 texFormatMips = CRendererResources::s_hwTexFormatSupport.GetLessPreciseFormatSupported(texFormatMips);
1321
1322 if (!s_ptexHeightMapAODepth[0])
1323 {
1324 s_ptexHeightMapAODepth[0] = CTexture::GetOrCreateTextureObject("HeightMapAO_Depth_0", nTexRes, nTexRes, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, texFormat);
1325 s_ptexHeightMapAODepth[1] = CTexture::GetOrCreateTextureObject("HeightMapAO_Depth_1", nTexRes, nTexRes, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_RENDERTARGET | FT_FORCE_MIPS, texFormatMips);
1326 }
1327
1328 s_ptexHeightMapAODepth[0]->Invalidate(nTexRes, nTexRes, texFormat);
1329 s_ptexHeightMapAODepth[1]->Invalidate(nTexRes, nTexRes, texFormatMips);
1330
1331 if (!CTexture::IsTextureExist(s_ptexHeightMapAODepth[0]) && nTexRes > 0)
1332 {
1333 s_ptexHeightMapAODepth[0]->CreateDepthStencil(texFormat , ColorF(1.0f, 1.0f, 1.0f, 1.0f));
1334 s_ptexHeightMapAODepth[1]->CreateRenderTarget(texFormatMips, ColorF(1.0f, 1.0f, 1.0f, 1.0f));
1335 }
1336 }
1337
1338 if (ShadowFrustumMGPUCache* pShadowMGPUCache = gRenDev->GetShadowFrustumMGPUCache())
1339 {
1340 pShadowMGPUCache->nUpdateMaskRT = 0;
1341 pShadowMGPUCache->nUpdateMaskMT = 0;
1342 }
1343 }
1344
1345 void CRendererResources::DestroyCachedShadowMaps()
1346 {
1347 for (int i = 0; i < MAX_GSM_LODS_NUM; ++i)
1348 {
1349 SAFE_RELEASE_FORCE(s_ptexCachedShadowMap[i]);
1350 }
1351
1352 SAFE_RELEASE_FORCE(s_ptexHeightMapAODepth[0]);
1353 SAFE_RELEASE_FORCE(s_ptexHeightMapAODepth[1]);
1354 }
1355
1356 //==================================================================================================
1357
1358 void CRendererResources::CreateNearestShadowMap()
1359 {
1360 const int texResolution = CRendererCVars::CV_r_ShadowsNearestMapResolution;
1361 const ETEX_Format texFormat = CRendererCVars::CV_r_shadowtexformat == 0 ? eTF_D32F : eTF_D16;
1362
1363 s_ptexNearestShadowMap = CTexture::GetOrCreateTextureObject("NearestShadowMap", texResolution, texResolution, 1, eTT_2D, FT_DONT_RELEASE | FT_DONT_STREAM | FT_USAGE_DEPTHSTENCIL, texFormat);
1364 }
1365
1366 void CRendererResources::DestroyNearestShadowMap()
1367 {
1368 SAFE_RELEASE_FORCE(s_ptexNearestShadowMap);
1369 }
1370
1371 ////////////////////////////////////////////////////////////////////////////////////////////////////
1372 ////////////////////////////////////////////////////////////////////////////////////////////////////
1373 // The rules:
1374 //
1375 // #renderResolution can be whole multiples of #outputResolution (super-sampling)
1376 // #outputResolution can be [1 to 2] factor of #displayResolution (dynamic downscale)
1377 //
1378 // See @CD3D9Renderer::CalculateResolutions
1379
1380 int CRendererResources::s_resourceWidth = 0, CRendererResources::s_resourceHeight = 0;
1381 int CRendererResources::s_renderWidth = 0, CRendererResources::s_renderHeight = 0;
1382 int CRendererResources::s_renderMinDim = 0, CRendererResources::s_renderArea = 0;
1383 int CRendererResources::s_outputWidth = 0, CRendererResources::s_outputHeight = 0;
1384 int CRendererResources::s_displayWidth = 0, CRendererResources::s_displayHeight = 0;
1385
1386 void CRendererResources::OnRenderResolutionChanged(int renderWidth, int renderHeight)
1387 {
1388 if (s_renderWidth != renderWidth ||
1389 s_renderHeight != renderHeight)
1390 {
1391 if (gcpRendD3D->m_bSystemTargetsInit)
1392 ResizeSystemTargets(renderWidth, renderHeight);
1393
1394 // Stereo resources are used as temporary targets for deferred shaded viewports
1395 gcpRendD3D->GetS3DRend().OnResolutionChanged(renderWidth, renderHeight);
1396
1397 s_renderWidth = renderWidth;
1398 s_renderHeight = renderHeight;
1399 s_renderMinDim = std::min(renderWidth, renderHeight);
1400 s_renderArea = renderWidth * renderHeight;
1401 }
1402 }
1403
1404 void CRendererResources::OnOutputResolutionChanged(int outputWidth, int outputHeight)
1405 {
1406 if (s_outputWidth != outputWidth ||
1407 s_outputHeight != outputHeight)
1408 {
1409 s_outputWidth = outputWidth;
1410 s_outputHeight = outputHeight;
1411 }
1412 }
1413
1414 void CRendererResources::OnDisplayResolutionChanged(int displayWidth, int displayHeight)
1415 {
1416 if (s_displayWidth != displayWidth ||
1417 s_displayHeight != displayHeight)
1418 {
1419 s_displayWidth = displayWidth;
1420 s_displayHeight = displayHeight;
1421 }
1422 }
1423
1424 ////////////////////////////////////////////////////////////////////////////////////////////////////
1425 ////////////////////////////////////////////////////////////////////////////////////////////////////
1426
1427 void CRendererResources::Clear()
1428 {
1429 // Clear core render targets on shut down, just to be sure
1430 // they are in a sane state for next render and prevent flicks
1431 CTexture* clearTextures[] =
1432 {
1433 s_ptexSceneNormalsMap,
1434 s_ptexSceneDiffuse,
1435 s_ptexSceneSpecular,
1436 s_ptexSceneDiffuseTmp,
1437 s_ptexSceneSpecularTmp,
1438 s_ptexBackBuffer,
1439 s_ptexSceneTarget,
1440 s_ptexLinearDepth,
1441 s_ptexHDRTarget
1442 };
1443
1444 for (auto pTex : clearTextures)
1445 {
1446 if (CTexture::IsTextureExist(pTex))
1447 {
1448 CClearSurfacePass::Execute(pTex, Clr_Empty);
1449 }
1450 }
1451 }
1452
1453 void CRendererResources::ShutDown()
1454 {
1455 UnloadDefaultSystemTextures(true);
1456
1457 if (CRenderer::CV_r_releaseallresourcesonexit)
1458 {
1459 // To avoid crash on ShutDown
1460 s_ptexSceneNormalsMap = NULL;
1461 s_ptexSceneDiffuse = NULL;
1462 s_ptexSceneSpecular = NULL;
1463 s_ptexSceneDiffuseTmp = NULL;
1464 s_ptexSceneSpecularTmp = NULL;
1465 s_ptexBackBuffer = NULL;
1466 s_ptexSceneTarget = NULL;
1467 s_ptexLinearDepth = NULL;
1468 s_ptexHDRTarget = NULL;
1469 }
1470
1471 if (s_ShaderTemplatesInitialized)
1472 {
1473 for (int i = 0; i < EFTT_MAX; i++)
1474 {
1475 s_ShaderTemplates[i].~CTexture();
1476 }
1477 }
1478 s_ShaderTemplates.Free();
1479
1480 SAFE_DELETE(s_pTexNULL);
1481 }
1482
1483 ////////////////////////////////////////////////////////////////////////////////////////////////////
1484 ////////////////////////////////////////////////////////////////////////////////////////////////////
1485
1486 size_t CRendererResources::m_RTallocs = 0;
1487 size_t CRendererResources::m_DTallocs = 0;
1488
1489 CTexture* CRendererResources::CreateDepthTarget(int nWidth, int nHeight, const ColorF& cClear, ETEX_Format eTF)
1490 {
1491 const ETEX_Format preferredDepthFormat = eTF == eTF_Unknown ?
1492 gRenDev->GetDepthBpp() == 32 ? eTF_D32FS8 :
1493 gRenDev->GetDepthBpp() == 24 ? eTF_D24S8 :
1494 gRenDev->GetDepthBpp() == 8 ? eTF_D16S8 : eTF_D16 : eTF;
1495
1496 char pName[128]; // Create unique names for every allocation, otherwise name-matches would occur in GetOrCreateDepthStencil()
1497 cry_sprintf(pName, "$DepthStencil%8x", ++m_DTallocs);
1498 auto pTarget = CTexture::GetOrCreateDepthStencil(pName, nWidth, nHeight, cClear, eTT_2D, FT_USAGE_TEMPORARY | FT_NOMIPS, preferredDepthFormat);
1499
1500 #if !defined(RELEASE) && CRY_PLATFORM_WINDOWS
1501 pTarget->GetDevTexture()->Get2DTexture()->SetPrivateData(WKPDID_D3DDebugObjectName, strlen("Dynamically requested Depth-Target"), "Dynamically requested Depth-Target");
1502 #endif
1503
1504 return pTarget;
1505 }
1506
1507 CTexture* CRendererResources::CreateRenderTarget(int nWidth, int nHeight, const ColorF& cClear, ETEX_Format eTF)
1508 {
1509 char pName[128]; // Create unique names for every allocation, otherwise name-matches would occur in GetOrCreateRenderTarget()
1510 cry_sprintf(pName, "$RenderTarget%8x", ++m_RTallocs);
1511 auto pTarget = CTexture::GetOrCreateRenderTarget(pName, nWidth, nHeight, cClear, eTT_2D, FT_USAGE_TEMPORARY | FT_NOMIPS, eTF);
1512
1513 #if !defined(RELEASE) && CRY_PLATFORM_WINDOWS
1514 pTarget->GetDevTexture()->Get2DTexture()->SetPrivateData(WKPDID_D3DDebugObjectName, strlen("Dynamically requested Color-Target"), "Dynamically requested Color-Target");
1515 #endif
1516
1517 return pTarget;
1518 }
1519
1520 ////////////////////////////////////////////////////////////////////////////////////////////////////
1521 ////////////////////////////////////////////////////////////////////////////////////////////////////
1522
1523 Ang3 sDeltAngles(Ang3& Ang0, Ang3& Ang1)
1524 {
1525 Ang3 out;
1526 for (int i = 0; i < 3; i++)
1527 {
1528 float a0 = Ang0[i];
1529 a0 = (float)((360.0 / 65536) * ((int)(a0 * (65536 / 360.0)) & 65535)); // angmod
1530 float a1 = Ang1[i];
1531 a1 = (float)((360.0 / 65536) * ((int)(a1 * (65536 / 360.0)) & 65535));
1532 out[i] = a0 - a1;
1533 }
1534 return out;
1535 }
1536
1537 SEnvTexture* CRendererResources::FindSuitableEnvTex(Vec3& Pos, Ang3& Angs, bool bMustExist, int RendFlags, bool bUseExistingREs, CShader* pSH, CShaderResources* pRes, CRenderObject* pObj, bool bReflect, CRenderElement* pRE, bool* bMustUpdate, const SRenderingPassInfo* pPassInfo)
1538 {
1539 SEnvTexture* cm = NULL;
1540 float time0 = iTimer->GetAsyncCurTime();
1541
1542 int i;
1543 float distO = 999999;
1544 float adist = 999999;
1545 int firstForUse = -1;
1546 int firstFree = -1;
1547 Vec3 objPos;
1548 if (bMustUpdate)
1549 *bMustUpdate = false;
1550 if (!pObj)
1551 bReflect = false;
1552 else
1553 {
1554 if (bReflect)
1555 {
1556 Plane pl;
1557 pRE->mfGetPlane(pl);
1558 objPos = pl.MirrorPosition(Vec3(0, 0, 0));
1559 }
1560 else if (pRE)
1561 pRE->mfCenter(objPos, pObj, *pPassInfo);
1562 else
1563 {
1564 CRY_ASSERT(!pPassInfo);
1565 CRY_ASSERT(!gcpRendD3D->m_pRT->IsRenderThread());
1566 objPos = pObj->GetMatrix(*pPassInfo).GetTranslation();
1567 }
1568 }
1569 float dist = 999999;
1570 for (i = 0; i < MAX_ENVTEXTURES; i++)
1571 {
1572 SEnvTexture* cur = &s_EnvTexts[i];
1573 if (cur->m_bReflected != bReflect)
1574 continue;
1575 float s = (cur->m_CamPos - Pos).GetLengthSquared();
1576 Ang3 angDelta = sDeltAngles(Angs, cur->m_Angle);
1577 float a = angDelta.x * angDelta.x + angDelta.y * angDelta.y + angDelta.z * angDelta.z;
1578 float so = 0;
1579 if (bReflect)
1580 so = (cur->m_ObjPos - objPos).GetLengthSquared();
1581 if (s <= dist && a <= adist && so <= distO)
1582 {
1583 dist = s;
1584 adist = a;
1585 distO = so;
1586 firstForUse = i;
1587 if (!so && !s && !a)
1588 break;
1589 }
1590 if (cur->m_pTex && !cur->m_pTex->m_pTexture && firstFree < 0)
1591 firstFree = i;
1592 }
1593 if (bMustExist && firstForUse >= 0)
1594 return &s_EnvTexts[firstForUse];
1595 if (bReflect)
1596 dist = distO;
1597
1598 float curTime = iTimer->GetCurrTime();
1599 int nUpdate = -2;
1600 float fTimeInterval = dist * CRenderer::CV_r_envtexupdateinterval + CRenderer::CV_r_envtexupdateinterval * 0.5f;
1601 float fDelta = curTime - s_EnvTexts[firstForUse].m_TimeLastUpdated;
1602 if (bMustExist)
1603 nUpdate = -2;
1604 else if (dist > MAX_ENVTEXSCANDIST)
1605 {
1606 if (firstFree >= 0)
1607 nUpdate = firstFree;
1608 else
1609 nUpdate = -1;
1610 }
1611 else if (fDelta > fTimeInterval)
1612 nUpdate = firstForUse;
1613 if (nUpdate == -2 && firstForUse >= 0)
1614 {
1615 // No need to update (Up to date)
1616 return &s_EnvTexts[firstForUse];
1617 }
1618 if (nUpdate >= 0 && !s_EnvTexts[nUpdate].m_pTex)
1619 return NULL;
1620 if (nUpdate >= 0)
1621 {
1622 if (!s_EnvTexts[nUpdate].m_pTex->m_pTexture || SRenderStatistics::Write().m_fEnvTextUpdateTime < 0.1f)
1623 {
1624 int n = nUpdate;
1625 s_EnvTexts[n].m_TimeLastUpdated = curTime;
1626 s_EnvTexts[n].m_CamPos = Pos;
1627 s_EnvTexts[n].m_Angle = Angs;
1628 s_EnvTexts[n].m_ObjPos = objPos;
1629 s_EnvTexts[n].m_bReflected = bReflect;
1630 if (bMustUpdate)
1631 *bMustUpdate = true;
1632 }
1633 SRenderStatistics::Write().m_fEnvTextUpdateTime += iTimer->GetAsyncCurTime() - time0;
1634 return &s_EnvTexts[nUpdate];
1635 }
1636
1637 dist = 0;
1638 firstForUse = -1;
1639 for (i = 0; i < MAX_ENVTEXTURES; i++)
1640 {
1641 SEnvTexture* cur = &s_EnvTexts[i];
1642 if (dist < curTime - cur->m_TimeLastUpdated && !cur->m_bInprogress)
1643 {
1644 dist = curTime - cur->m_TimeLastUpdated;
1645 firstForUse = i;
1646 }
1647 }
1648 if (firstForUse < 0)
1649 {
1650 return NULL;
1651 }
1652 int n = firstForUse;
1653 s_EnvTexts[n].m_TimeLastUpdated = curTime;
1654 s_EnvTexts[n].m_CamPos = Pos;
1655 s_EnvTexts[n].m_ObjPos = objPos;
1656 s_EnvTexts[n].m_Angle = Angs;
1657 s_EnvTexts[n].m_bReflected = bReflect;
1658 if (bMustUpdate)
1659 *bMustUpdate = true;
1660
1661 SRenderStatistics::Write().m_fEnvTextUpdateTime += iTimer->GetAsyncCurTime() - time0;
1662 return &s_EnvTexts[n];
1663
1664 }
CRYENGINE is a powerful real-time game development platform created by Crytek.