devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

UE4阴影初始化【3】_ue4 wholescene split

作者：小蓝xlanll | 2024-02-16 06:24:35

赞

踩

ue4 wholescene split

FSceneRenderer::InitDynamicShadows（）

        CreateWholeSceneProjectedShadow（）

  1. void FSceneRenderer::CreateWholeSceneProjectedShadow(
  2. 	FLightSceneInfo* LightSceneInfo,
  3. 	uint32& InOutNumPointShadowCachesUpdatedThisFrame,
  4. 	uint32& InOutNumSpotShadowCachesUpdatedThisFrame)
  5. {
  6. 	SCOPE_CYCLE_COUNTER(STAT_CreateWholeSceneProjectedShadow);
  7. 	FVisibleLightInfo& VisibleLightInfo = VisibleLightInfos[LightSceneInfo->Id];
  8.  
  9. 	// early out if shadow resoluion scale is zero
  10. 	if (CVarResolutionScaleZeroDisablesSm.GetValueOnRenderThread() != 0 && LightSceneInfo->Proxy->GetShadowResolutionScale() <= 0.0f)
  11. 	{
  12. 		return;
  13. 	}
  14.  
  15. 	// Try to create a whole-scene projected shadow initializer for the light.
  16. 	TArray<FWholeSceneProjectedShadowInitializer, TInlineAllocator<6> > ProjectedShadowInitializers;
  17. 	if (LightSceneInfo->Proxy->GetWholeSceneProjectedShadowInitializer(ViewFamily, ProjectedShadowInitializers))
  18. 	{
  19. 		FSceneRenderTargets& SceneContext_ConstantsOnly = FSceneRenderTargets::Get_FrameConstantsOnly();
  20.  
  21. 		checkSlow(ProjectedShadowInitializers.Num() > 0);
  22.  
  23. 		// Shadow resolution constants.
  24. 		const uint32 ShadowBorder = ProjectedShadowInitializers[0].bOnePassPointLightShadow ? 0 : SHADOW_BORDER;
  25. 		const uint32 EffectiveDoubleShadowBorder = ShadowBorder * 2;
  26. 		const uint32 MinShadowResolution = FMath::Max<int32>(0, CVarMinShadowResolution.GetValueOnRenderThread());
  27. 		const int32 MaxShadowResolutionSetting = GetCachedScalabilityCVars().MaxShadowResolution;
  28. 		const FIntPoint ShadowBufferResolution = SceneContext_ConstantsOnly.GetShadowDepthTextureResolution();
  29. 		const uint32 MaxShadowResolution = FMath::Min(MaxShadowResolutionSetting, ShadowBufferResolution.X) - EffectiveDoubleShadowBorder;
  30. 		const uint32 MaxShadowResolutionY = FMath::Min(MaxShadowResolutionSetting, ShadowBufferResolution.Y) - EffectiveDoubleShadowBorder;
  31. 		const uint32 ShadowFadeResolution = FMath::Max<int32>(0, CVarShadowFadeResolution.GetValueOnRenderThread());
  32.  
  33. 		// Compute the maximum resolution required for the shadow by any view. Also keep track of the unclamped resolution for fading.
  34. 		float MaxDesiredResolution = 0;
  35. 		TArray<float, TInlineAllocator<2> > FadeAlphas;
  36. 		float MaxFadeAlpha = 0;
  37. 		bool bStaticSceneOnly = false;
  38. 		bool bAnyViewIsSceneCapture = false;
  39.  
  40. 		for(int32 ViewIndex = 0, ViewCount = Views.Num(); ViewIndex < ViewCount; ++ViewIndex)
  41. 		{
  42. 			const FViewInfo& View = Views[ViewIndex];
  43.  
  44. 			const float ScreenRadius = LightSceneInfo->Proxy->GetEffectiveScreenRadius(View.ShadowViewMatrices);
  45.  
  46. 			// Determine the amount of shadow buffer resolution needed for this view.
  47. 			float UnclampedResolution = 1.0f;
  48.  
  49. 			switch (LightSceneInfo->Proxy->GetLightType())
  50. 			{
  51. 			case LightType_Point:
  52. 				UnclampedResolution = ScreenRadius * CVarShadowTexelsPerPixelPointlight.GetValueOnRenderThread();
  53. 				break;
  54. 			case LightType_Spot:
  55. 				UnclampedResolution = ScreenRadius * CVarShadowTexelsPerPixelSpotlight.GetValueOnRenderThread();
  56. 				break;
  57. 			case LightType_Rect:
  58. 				UnclampedResolution = ScreenRadius * CVarShadowTexelsPerPixelRectlight.GetValueOnRenderThread();
  59. 				break;
  60. 			default:
  61. 				// directional lights are not handled here
  62. 				checkf(false, TEXT("Unexpected LightType %d appears in CreateWholeSceneProjectedShadow %s"),
  63. 					(int32)LightSceneInfo->Proxy->GetLightType(),
  64. 					*LightSceneInfo->Proxy->GetComponentName().ToString());
  65. 			}
  66.  
  67. 			// Compute FadeAlpha before ShadowResolutionScale contribution (artists want to modify the softness of the shadow, not change the fade ranges)
  68. 			const float FadeAlpha = CalculateShadowFadeAlpha( UnclampedResolution, ShadowFadeResolution, MinShadowResolution ) * LightSceneInfo->Proxy->GetShadowAmount();
  69. 			MaxFadeAlpha = FMath::Max(MaxFadeAlpha, FadeAlpha);
  70. 			FadeAlphas.Add(FadeAlpha);
  71.  
  72. 			const float ShadowResolutionScale = LightSceneInfo->Proxy->GetShadowResolutionScale();
  73.  
  74. 			float ClampedResolution = UnclampedResolution;
  75.  
  76. 			if (ShadowResolutionScale > 1.0f)
  77. 			{
  78. 				// Apply ShadowResolutionScale before the MaxShadowResolution clamp if raising the resolution
  79. 				ClampedResolution *= ShadowResolutionScale;
  80. 			}
  81.  
  82. 			ClampedResolution = FMath::Min<float>(ClampedResolution, MaxShadowResolution);
  83.  
  84. 			if (ShadowResolutionScale <= 1.0f)
  85. 			{
  86. 				// Apply ShadowResolutionScale after the MaxShadowResolution clamp if lowering the resolution
  87. 				// Artists want to modify the softness of the shadow with ShadowResolutionScale
  88. 				ClampedResolution *= ShadowResolutionScale;
  89. 			}
  90.  
  91. 			MaxDesiredResolution = FMath::Max(
  92. 				MaxDesiredResolution,
  93. 				FMath::Max<float>(
  94. 					ClampedResolution,
  95. 					FMath::Min<float>(MinShadowResolution, ShadowBufferResolution.X - EffectiveDoubleShadowBorder)
  96. 					)
  97. 				);
  98.  
  99. 			bStaticSceneOnly = bStaticSceneOnly || View.bStaticSceneOnly;
  100. 			bAnyViewIsSceneCapture = bAnyViewIsSceneCapture || View.bIsSceneCapture;
  101. 		}
  102.  
  103. 		if (MaxFadeAlpha > 1.0f / 256.0f)
  104. 		{
  105. 			Scene->FlushAsyncLightPrimitiveInteractionCreation();
  106.  
  107. 			for (int32 ShadowIndex = 0, ShadowCount = ProjectedShadowInitializers.Num(); ShadowIndex < ShadowCount; ShadowIndex++)
  108. 			{
  109. 				FWholeSceneProjectedShadowInitializer& ProjectedShadowInitializer = ProjectedShadowInitializers[ShadowIndex];
  110.  
  111. 				// Round down to the nearest power of two so that resolution changes are always doubling or halving the resolution, which increases filtering stability
  112. 				// Use the max resolution if the desired resolution is larger than that
  113. 				// FMath::CeilLogTwo(MaxDesiredResolution + 1.0f) instead of FMath::CeilLogTwo(MaxDesiredResolution) because FMath::CeilLogTwo takes
  114. 				// an uint32 as argument and this causes MaxDesiredResolution get truncated. For example, if MaxDesiredResolution is 256.1f,
  115. 				// FMath::CeilLogTwo returns 8 but the next line of code expects a 9 to work correctly
  116. 				int32 RoundedDesiredResolution = FMath::Max<int32>((1 << (FMath::CeilLogTwo(MaxDesiredResolution + 1.0f) - 1)) - ShadowBorder * 2, 1);
  117. 				int32 SizeX = MaxDesiredResolution >= MaxShadowResolution ? MaxShadowResolution : RoundedDesiredResolution;
  118. 				int32 SizeY = MaxDesiredResolution >= MaxShadowResolutionY ? MaxShadowResolutionY : RoundedDesiredResolution;
  119.  
  120. 				if (ProjectedShadowInitializer.bOnePassPointLightShadow)
  121. 				{
  122. 					// Round to a resolution that is supported for one pass point light shadows
  123. 					SizeX = SizeY = SceneContext_ConstantsOnly.GetCubeShadowDepthZResolution(SceneContext_ConstantsOnly.GetCubeShadowDepthZIndex(MaxDesiredResolution));
  124. 				}
  125.  
  126. 				int32 NumShadowMaps = 1;
  127. 				EShadowDepthCacheMode CacheMode[2] = { SDCM_Uncached, SDCM_Uncached };
  128.  
  129. 				if (!bAnyViewIsSceneCapture && !ProjectedShadowInitializer.bRayTracedDistanceField)
  130. 				{
  131. 					FIntPoint ShadowMapSize(SizeX + ShadowBorder * 2, SizeY + ShadowBorder * 2);
  132.  
  133. 					ComputeWholeSceneShadowCacheModes(
  134. 						LightSceneInfo,
  135. 						ProjectedShadowInitializer.bOnePassPointLightShadow,
  136. 						ViewFamily.CurrentRealTime,
  137. 						MaxDesiredResolution,
  138. 						FIntPoint(MaxShadowResolution, MaxShadowResolutionY),
  139. 						Scene,
  140. 						// Below are in-out or out parameters. They can change
  141. 						ProjectedShadowInitializer,
  142. 						ShadowMapSize,
  143. 						InOutNumPointShadowCachesUpdatedThisFrame,
  144. 						InOutNumSpotShadowCachesUpdatedThisFrame,
  145. 						NumShadowMaps,
  146. 						CacheMode);
  147.  
  148. 					SizeX = ShadowMapSize.X - ShadowBorder * 2;
  149. 					SizeY = ShadowMapSize.Y - ShadowBorder * 2;
  150. 				}
  151.  
  152. 				for (int32 CacheModeIndex = 0; CacheModeIndex < NumShadowMaps; CacheModeIndex++)
  153. 				{
  154. 					// Create the projected shadow info.
  155. 					FProjectedShadowInfo* ProjectedShadowInfo = new(FMemStack::Get(), 1, 16) FProjectedShadowInfo;
  156.  
  157. 					ProjectedShadowInfo->SetupWholeSceneProjection(
  158. 						LightSceneInfo,
  159. 						NULL,
  160. 						ProjectedShadowInitializer,
  161. 						SizeX,
  162. 						SizeY,
  163. 						ShadowBorder,
  164. 						false	// no RSM
  165. 						);
  166.  
  167. 					ProjectedShadowInfo->CacheMode = CacheMode[CacheModeIndex];
  168. 					ProjectedShadowInfo->FadeAlphas = FadeAlphas;
  169.  
  170. 					VisibleLightInfo.MemStackProjectedShadows.Add(ProjectedShadowInfo);
  171.  
  172. 					if (ProjectedShadowInitializer.bOnePassPointLightShadow)
  173. 					{
  174. 						const static FVector CubeDirections[6] =
  175. 						{
  176. 							FVector(-1, 0, 0),
  177. 							FVector(1, 0, 0),
  178. 							FVector(0, -1, 0),
  179. 							FVector(0, 1, 0),
  180. 							FVector(0, 0, -1),
  181. 							FVector(0, 0, 1)
  182. 						};
  183.  
  184. 						const static FVector UpVectors[6] =
  185. 						{
  186. 							FVector(0, 1, 0),
  187. 							FVector(0, 1, 0),
  188. 							FVector(0, 0, -1),
  189. 							FVector(0, 0, 1),
  190. 							FVector(0, 1, 0),
  191. 							FVector(0, 1, 0)
  192. 						};
  193.  
  194. 						const FLightSceneProxy& LightProxy = *(ProjectedShadowInfo->GetLightSceneInfo().Proxy);
  195.  
  196. 						const FMatrix FaceProjection = FPerspectiveMatrix(PI / 4.0f, 1, 1, 1, LightProxy.GetRadius());
  197.  
  198. 						// Light projection and bounding volume is set up relative to the light position
  199. 						// the view pre-translation (relative to light) is added later, when rendering & sampling.
  200. 						const FVector LightPosition = ProjectedShadowInitializer.WorldToLight.GetOrigin();
  201.  
  202. 						ProjectedShadowInfo->OnePassShadowViewMatrices.Empty(6);
  203. 						ProjectedShadowInfo->OnePassShadowViewProjectionMatrices.Empty(6);
  204. 						const FMatrix ScaleMatrix = FScaleMatrix(FVector(1, -1, 1));
  205.  
  206. 						// fill in the caster frustum with the far plane from every face
  207. 						ProjectedShadowInfo->CasterFrustum.Planes.Empty();
  208. 						for (int32 FaceIndex = 0; FaceIndex < 6; FaceIndex++)
  209. 						{
  210. 							// Create a view projection matrix for each cube face
  211. 							const FMatrix WorldToLightMatrix = FLookFromMatrix(LightPosition, CubeDirections[FaceIndex], UpVectors[FaceIndex]) * ScaleMatrix;
  212. 							ProjectedShadowInfo->OnePassShadowViewMatrices.Add(WorldToLightMatrix);
  213. 							const FMatrix ShadowViewProjectionMatrix = WorldToLightMatrix * FaceProjection;
  214. 							ProjectedShadowInfo->OnePassShadowViewProjectionMatrices.Add(ShadowViewProjectionMatrix);
  215. 							// Add plane representing cube face to bounding volume
  216. 							ProjectedShadowInfo->CasterFrustum.Planes.Add(FPlane(CubeDirections[FaceIndex], LightProxy.GetRadius()));
  217. 						}
  218. 						ProjectedShadowInfo->CasterFrustum.Init();
  219. 					}
  220.  
  221. 					// Ray traced shadows use the GPU managed distance field object buffers, no CPU culling should be used
  222. 					if (!ProjectedShadowInfo->bRayTracedDistanceField)
  223. 					{
  224. 						// Build light-view convex hulls for shadow caster culling
  225. 						FLightViewFrustumConvexHulls LightViewFrustumConvexHulls;
  226. 						if (CacheMode[CacheModeIndex] != SDCM_StaticPrimitivesOnly)
  227. 						{
  228. 							FVector const& LightOrigin = LightSceneInfo->Proxy->GetOrigin();
  229. 							BuildLightViewFrustumConvexHulls(LightOrigin, Views, LightViewFrustumConvexHulls);
  230. 						}
  231.  
  232. 						bool bCastCachedShadowFromMovablePrimitives = GCachedShadowsCastFromMovablePrimitives || LightSceneInfo->Proxy->GetForceCachedShadowsForMovablePrimitives();
  233. 						if (CacheMode[CacheModeIndex] != SDCM_StaticPrimitivesOnly 
  234. 							&& (CacheMode[CacheModeIndex] != SDCM_MovablePrimitivesOnly || bCastCachedShadowFromMovablePrimitives))
  235. 						{
  236. 							// Add all the shadow casting primitives affected by the light to the shadow's subject primitive list.
  237. 							for (FLightPrimitiveInteraction* Interaction = LightSceneInfo->GetDynamicInteractionOftenMovingPrimitiveList(false);
  238. 								Interaction;
  239. 								Interaction = Interaction->GetNextPrimitive())
  240. 							{
  241. 								if (Interaction->HasShadow()
  242. 									// If the primitive only wants to cast a self shadow don't include it in whole scene shadows.
  243. 									&& !Interaction->CastsSelfShadowOnly()
  244. 									&& (!bStaticSceneOnly || Interaction->GetPrimitiveSceneInfo()->Proxy->HasStaticLighting()))
  245. 								{
  246. 									FBoxSphereBounds const& Bounds = Interaction->GetPrimitiveSceneInfo()->Proxy->GetBounds();
  247. 									if (IntersectsConvexHulls(LightViewFrustumConvexHulls, Bounds))
  248. 									{
  249. 										ProjectedShadowInfo->AddSubjectPrimitive(Interaction->GetPrimitiveSceneInfo(), &Views, FeatureLevel, false);
  250. 									}
  251. 								}
  252. 							}
  253. 						}
  254. 						
  255. 						if (CacheMode[CacheModeIndex] != SDCM_MovablePrimitivesOnly)
  256. 						{
  257. 							// Add all the shadow casting primitives affected by the light to the shadow's subject primitive list.
  258. 							for (FLightPrimitiveInteraction* Interaction = LightSceneInfo->GetDynamicInteractionStaticPrimitiveList(false);
  259. 								Interaction;
  260. 								Interaction = Interaction->GetNextPrimitive())
  261. 							{
  262. 								if (Interaction->HasShadow()
  263. 									// If the primitive only wants to cast a self shadow don't include it in whole scene shadows.
  264. 									&& !Interaction->CastsSelfShadowOnly()
  265. 									&& (!bStaticSceneOnly || Interaction->GetPrimitiveSceneInfo()->Proxy->HasStaticLighting()))
  266. 								{
  267. 									FBoxSphereBounds const& Bounds = Interaction->GetPrimitiveSceneInfo()->Proxy->GetBounds();
  268. 									if (IntersectsConvexHulls(LightViewFrustumConvexHulls, Bounds))
  269. 									{
  270. 										ProjectedShadowInfo->AddSubjectPrimitive(Interaction->GetPrimitiveSceneInfo(), &Views, FeatureLevel, false);
  271. 									}
  272. 								}
  273. 							}
  274. 						}
  275. 					}
  276.  
  277. 					bool bRenderShadow = true;
  278. 					
  279. 					if (CacheMode[CacheModeIndex] == SDCM_StaticPrimitivesOnly)
  280. 					{
  281. 						const bool bHasStaticPrimitives = ProjectedShadowInfo->HasSubjectPrims();
  282. 						bRenderShadow = bHasStaticPrimitives;
  283. 						FCachedShadowMapData& CachedShadowMapData = Scene->CachedShadowMaps.FindChecked(ProjectedShadowInfo->GetLightSceneInfo().Id);
  284. 						CachedShadowMapData.bCachedShadowMapHasPrimitives = bHasStaticPrimitives;
  285. 					}
  286.  
  287. 					if (bRenderShadow)
  288. 					{
  289. 						VisibleLightInfo.AllProjectedShadows.Add(ProjectedShadowInfo);
  290. 					}
  291. 				}
  292. 			}
  293. 		}
  294. 	}
  295. }

  1. void FProjectedShadowInfo::AddSubjectPrimitive(FPrimitiveSceneInfo* PrimitiveSceneInfo, TArray<FViewInfo>* ViewArray, ERHIFeatureLevel::Type FeatureLevel, bool bRecordShadowSubjectsForMobileShading)
  2. {
  3. 	// Ray traced shadows use the GPU managed distance field object buffers, no CPU culling should be used
  4. 	check(!bRayTracedDistanceField);
  5.  
  6. 	if (!ReceiverPrimitives.Contains(PrimitiveSceneInfo)
  7. 		// Far cascade only casts from primitives marked for it
  8. 		&& (!CascadeSettings.bFarShadowCascade || PrimitiveSceneInfo->Proxy->CastsFarShadow()))
  9. 	{
  10. 		const FPrimitiveSceneProxy* Proxy = PrimitiveSceneInfo->Proxy;
  11.  
  12. 		TArray<FViewInfo*, TInlineAllocator<1> > Views;
  13. 		const bool bWholeSceneDirectionalShadow = IsWholeSceneDirectionalShadow();
  14.  
  15. 		if (bWholeSceneDirectionalShadow)
  16. 		{
  17. 			Views.Add(DependentView);
  18. 		}
  19. 		else
  20. 		{
  21. 			checkf(ViewArray,
  22. 				TEXT("bWholeSceneShadow=%d, CascadeSettings.ShadowSplitIndex=%d, bDirectionalLight=%s"),
  23. 				bWholeSceneShadow ? TEXT("true") : TEXT("false"),
  24. 				CascadeSettings.ShadowSplitIndex,
  25. 				bDirectionalLight ? TEXT("true") : TEXT("false"));
  26.  
  27. 			for (int32 ViewIndex = 0; ViewIndex < ViewArray->Num(); ViewIndex++)
  28. 			{
  29. 				Views.Add(&(*ViewArray)[ViewIndex]);
  30. 			}
  31. 		}
  32.  
  33. 		bool bOpaque = false;
  34. 		bool bTranslucentRelevance = false;
  35. 		bool bShadowRelevance = false;
  36.  
  37. 		uint32 ViewMask = 0;
  38. 		int32 PrimitiveId = PrimitiveSceneInfo->GetIndex();
  39.  
  40. 		for (int32 ViewIndex = 0, Num = Views.Num(); ViewIndex < Num; ViewIndex++)
  41. 		{
  42. 			FViewInfo& CurrentView = *Views[ViewIndex];
  43. 			FPrimitiveViewRelevance& ViewRelevance = CurrentView.PrimitiveViewRelevanceMap[PrimitiveId];
  44.  
  45. 			if (!ViewRelevance.bInitializedThisFrame)
  46. 			{
  47. 				if( CurrentView.IsPerspectiveProjection() )
  48. 				{
  49. 					// Compute the distance between the view and the primitive.
  50. 					float DistanceSquared = (Proxy->GetBounds().Origin - CurrentView.ShadowViewMatrices.GetViewOrigin()).SizeSquared();
  51.  
  52. 					bool bIsDistanceCulled = CurrentView.IsDistanceCulled(
  53. 						DistanceSquared,
  54. 						Proxy->GetMinDrawDistance(),
  55. 						Proxy->GetMaxDrawDistance(),
  56. 						PrimitiveSceneInfo
  57. 						);
  58. 					if( bIsDistanceCulled )
  59. 					{
  60. 						continue;
  61. 					}
  62. 				}
  63.  
  64. 				// Respect HLOD visibility which can hide child LOD primitives
  65. 				if (CurrentView.ViewState &&
  66. 					CurrentView.ViewState->HLODVisibilityState.IsValidPrimitiveIndex(PrimitiveId) &&
  67. 					CurrentView.ViewState->HLODVisibilityState.IsNodeForcedHidden(PrimitiveId))
  68. 				{
  69. 					continue;
  70. 				}
  71.  
  72. 				if ((CurrentView.ShowOnlyPrimitives.IsSet() &&
  73. 					!CurrentView.ShowOnlyPrimitives->Contains(PrimitiveSceneInfo->Proxy->GetPrimitiveComponentId())) ||
  74. 					CurrentView.HiddenPrimitives.Contains(PrimitiveSceneInfo->Proxy->GetPrimitiveComponentId()))
  75. 				{
  76. 					continue;
  77. 				}
  78.  
  79. 				// Compute the subject primitive's view relevance since it wasn't cached
  80. 				// Update the main view's PrimitiveViewRelevanceMap
  81. 				ViewRelevance = PrimitiveSceneInfo->Proxy->GetViewRelevance(&CurrentView);
  82.  
  83. 				ViewMask |= (1 << ViewIndex);
  84. 			}
  85.  
  86. 			bOpaque |= ViewRelevance.bOpaque || ViewRelevance.bMasked;
  87. 			bTranslucentRelevance |= ViewRelevance.HasTranslucency() && !ViewRelevance.bMasked;
  88. 			bShadowRelevance |= ViewRelevance.bShadowRelevance;
  89. 		}
  90.  
  91. 		if (bShadowRelevance)
  92. 		{
  93. 			// Update the primitive component's last render time. Allows the component to update when using bCastWhenHidden.
  94. 			const float CurrentWorldTime = Views[0]->Family->CurrentWorldTime;
  95. 			PrimitiveSceneInfo->UpdateComponentLastRenderTime(CurrentWorldTime, /*bUpdateLastRenderTimeOnScreen=*/false);
  96.  
  97. 			if (PrimitiveSceneInfo->NeedsUniformBufferUpdate())
  98. 			{
  99. 				for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
  100. 				{
  101. 					// Main view visible primitives are processed on parallel tasks, updating uniform buffer them here will cause a race condition.
  102. 					check(!Views[ViewIndex]->PrimitiveVisibilityMap[PrimitiveSceneInfo->GetIndex()]);
  103. 				}
  104.  
  105. 				PrimitiveSceneInfo->ConditionalUpdateUniformBuffer(FRHICommandListExecutor::GetImmediateCommandList());
  106. 			}
  107.  
  108. 			if (PrimitiveSceneInfo->NeedsUpdateStaticMeshes())
  109. 			{
  110. 				// Need to defer to next InitViews, as main view visible primitives are processed on parallel tasks and calling 
  111. 				// CacheMeshDrawCommands may resize CachedDrawLists/CachedMeshDrawCommandStateBuckets causing a crash.
  112. 				PrimitiveSceneInfo->BeginDeferredUpdateStaticMeshesWithoutVisibilityCheck();
  113. 			}
  114. 		}
  115.  
  116. 		if (bOpaque && bShadowRelevance)
  117. 		{
  118. 			const FBoxSphereBounds& Bounds = Proxy->GetBounds();
  119. 			bool bDrawingStaticMeshes = false;
  120.  
  121. 			if (PrimitiveSceneInfo->StaticMeshes.Num() > 0)
  122. 			{
  123. 				for (int32 ViewIndex = 0, ViewCount = Views.Num(); ViewIndex < ViewCount; ViewIndex++)
  124. 				{
  125. 					FViewInfo& CurrentView = *Views[ViewIndex];
  126.  
  127. 					const float DistanceSquared = ( Bounds.Origin - CurrentView.ShadowViewMatrices.GetViewOrigin() ).SizeSquared();
  128.  
  129. 					if (bWholeSceneShadow)
  130. 					{
  131. 						const float LODScaleSquared = FMath::Square(CurrentView.LODDistanceFactor);
  132. 						const bool bDrawShadowDepth = FMath::Square(Bounds.SphereRadius) > FMath::Square(GMinScreenRadiusForShadowCaster) * DistanceSquared * LODScaleSquared;
  133. 						if( !bDrawShadowDepth )
  134. 						{
  135. 							// cull object if it's too small to be considered as shadow caster
  136. 							continue;
  137. 						}
  138. 					}
  139.  
  140. 					// Update visibility for meshes which weren't visible in the main views or were visible with static relevance
  141. 					if (!CurrentView.PrimitiveVisibilityMap[PrimitiveId] || CurrentView.PrimitiveViewRelevanceMap[PrimitiveId].bStaticRelevance)
  142. 					{
  143. 						bDrawingStaticMeshes |= ShouldDrawStaticMeshes(CurrentView, PrimitiveSceneInfo);						
  144. 					}
  145. 				}
  146. 			}
  147.  
  148. 			if (bDrawingStaticMeshes)
  149. 			{
  150. 				if (bRecordShadowSubjectsForMobileShading)
  151. 				{
  152. 					DependentView->VisibleLightInfos[GetLightSceneInfo().Id].MobileCSMSubjectPrimitives.AddSubjectPrimitive(PrimitiveSceneInfo, PrimitiveId);
  153. 				}
  154. 			}
  155. 			else
  156. 			{
  157. 				// Add the primitive to the subject primitive list.
  158. 				DynamicSubjectPrimitives.Add(PrimitiveSceneInfo);
  159.  
  160. 				if (bRecordShadowSubjectsForMobileShading)
  161. 				{
  162. 					DependentView->VisibleLightInfos[GetLightSceneInfo().Id].MobileCSMSubjectPrimitives.AddSubjectPrimitive(PrimitiveSceneInfo, PrimitiveId);
  163. 				}
  164. 			}
  165. 		}
  166.  
  167. 		// Add translucent shadow casting primitives to SubjectTranslucentPrimitives
  168. 		if (bTranslucentRelevance && bShadowRelevance)
  169. 		{
  170. 			SubjectTranslucentPrimitives.Add(PrimitiveSceneInfo);
  171. 		}
  172. 	}
  173. }
  1. bool FProjectedShadowInfo::ShouldDrawStaticMeshes(FViewInfo& InCurrentView, FPrimitiveSceneInfo* InPrimitiveSceneInfo)
  2. {
  3. 	bool WholeSceneDirectionalShadow = IsWholeSceneDirectionalShadow();
  4. 	bool bDrawingStaticMeshes = false;
  5. 	int32 PrimitiveId = InPrimitiveSceneInfo->GetIndex();
  6.  
  7. 	{
  8. 		const int32 ForcedLOD = (InCurrentView.Family->EngineShowFlags.LOD) ? (GetCVarForceLODShadow() != -1 ? GetCVarForceLODShadow() : GetCVarForceLOD()) : -1;
  9. 		const FLODMask* VisibilePrimitiveLODMask = nullptr;
  10.  
  11. 		if (InCurrentView.PrimitivesLODMask[PrimitiveId].ContainsLOD(MAX_int8)) // only calculate it if it's not set
  12. 		{
  13. 			FLODMask ViewLODToRender;
  14. 			float MeshScreenSizeSquared = 0;
  15. 			const int8 CurFirstLODIdx = InPrimitiveSceneInfo->Proxy->GetCurrentFirstLODIdx_RenderThread();
  16.  
  17. 			const FBoxSphereBounds& Bounds = InPrimitiveSceneInfo->Proxy->GetBounds();
  18. 			const float LODScale = InCurrentView.LODDistanceFactor * GetCachedScalabilityCVars().StaticMeshLODDistanceScale;
  19. 			ViewLODToRender = ComputeLODForMeshes(InPrimitiveSceneInfo->StaticMeshRelevances, InCurrentView, Bounds.Origin, Bounds.SphereRadius, ForcedLOD, MeshScreenSizeSquared, CurFirstLODIdx, LODScale);
  20.  
  21. 			InCurrentView.PrimitivesLODMask[PrimitiveId] = ViewLODToRender;
  22. 		}
  23.  
  24. 		VisibilePrimitiveLODMask = &InCurrentView.PrimitivesLODMask[PrimitiveId];
  25. 		check(VisibilePrimitiveLODMask != nullptr);
  26.  
  27. 		FLODMask ShadowLODToRender = *VisibilePrimitiveLODMask;
  28.  
  29. 		// Use lowest LOD for PreShadow
  30. 		if (bReflectiveShadowmap || (bPreShadow && GPreshadowsForceLowestLOD))
  31. 		{
  32. 			int8 LODToRenderScan = -MAX_int8;
  33. 			FLODMask LODToRender;
  34.  
  35. 			for (int32 Index = 0; Index < InPrimitiveSceneInfo->StaticMeshRelevances.Num(); Index++)
  36. 			{
  37. 				LODToRenderScan = FMath::Max<int8>(InPrimitiveSceneInfo->StaticMeshRelevances[Index].LODIndex, LODToRenderScan);
  38. 			}
  39. 			if (LODToRenderScan != -MAX_int8)
  40. 			{
  41. 				ShadowLODToRender.SetLOD(LODToRenderScan);
  42. 			}
  43. 		}
  44.  
  45. 		if (CascadeSettings.bFarShadowCascade)
  46. 		{
  47. 			extern ENGINE_API int32 GFarShadowStaticMeshLODBias;
  48. 			int8 LODToRenderScan = ShadowLODToRender.DitheredLODIndices[0] + GFarShadowStaticMeshLODBias;
  49.  
  50. 			for (int32 Index = InPrimitiveSceneInfo->StaticMeshRelevances.Num() - 1; Index >= 0; Index--)
  51. 			{
  52. 				if (LODToRenderScan == InPrimitiveSceneInfo->StaticMeshRelevances[Index].LODIndex)
  53. 				{
  54. 					ShadowLODToRender.SetLOD(LODToRenderScan);
  55. 					break;
  56. 				}
  57. 			}
  58. 		}
  59.  
  60. 		if (WholeSceneDirectionalShadow)
  61. 		{
  62. 			// Don't cache if it requires per view per mesh state for distance cull fade.
  63. 			const bool bIsPrimitiveDistanceCullFading = InCurrentView.PotentiallyFadingPrimitiveMap[InPrimitiveSceneInfo->GetIndex()];
  64. 			const bool bCanCache = !bIsPrimitiveDistanceCullFading && !InPrimitiveSceneInfo->NeedsUpdateStaticMeshes();
  65.  
  66. 			for (int32 MeshIndex = 0; MeshIndex < InPrimitiveSceneInfo->StaticMeshRelevances.Num(); MeshIndex++)
  67. 			{
  68. 				const FStaticMeshBatchRelevance& StaticMeshRelevance = InPrimitiveSceneInfo->StaticMeshRelevances[MeshIndex];
  69. 				const FStaticMeshBatch& StaticMesh = InPrimitiveSceneInfo->StaticMeshes[MeshIndex];
  70.  
  71. 				if ((StaticMeshRelevance.CastShadow || (bSelfShadowOnly && StaticMeshRelevance.bUseForDepthPass)) && ShadowLODToRender.ContainsLOD(StaticMeshRelevance.LODIndex))
  72. 				{
  73. 					if (GetShadowDepthType() == CSMShadowDepthType && bCanCache)
  74. 					{
  75. 						AddCachedMeshDrawCommandsForPass(
  76. 							PrimitiveId,
  77. 							InPrimitiveSceneInfo,
  78. 							StaticMeshRelevance,
  79. 							StaticMesh,
  80. 							InPrimitiveSceneInfo->Scene,
  81. 							EMeshPass::CSMShadowDepth,
  82. 							ShadowDepthPassVisibleCommands,
  83. 							SubjectMeshCommandBuildRequests,
  84. 							NumSubjectMeshCommandBuildRequestElements);
  85. 					}
  86. 					else
  87. 					{
  88. 						NumSubjectMeshCommandBuildRequestElements += StaticMeshRelevance.NumElements;
  89. 						SubjectMeshCommandBuildRequests.Add(&StaticMesh);
  90. 					}
  91.  
  92. 					bDrawingStaticMeshes = true;
  93. 				}
  94. 			}
  95. 		}
  96. 		else
  97. 		{
  98. 			for (int32 MeshIndex = 0; MeshIndex < InPrimitiveSceneInfo->StaticMeshRelevances.Num(); MeshIndex++)
  99. 			{
  100. 				const FStaticMeshBatchRelevance& StaticMeshRelevance = InPrimitiveSceneInfo->StaticMeshRelevances[MeshIndex];
  101. 				const FStaticMeshBatch& StaticMesh = InPrimitiveSceneInfo->StaticMeshes[MeshIndex];
  102.  
  103. 				if ((StaticMeshRelevance.CastShadow || (bSelfShadowOnly && StaticMeshRelevance.bUseForDepthPass)) && ShadowLODToRender.ContainsLOD(StaticMeshRelevance.LODIndex))
  104. 				{
  105. 					NumSubjectMeshCommandBuildRequestElements += StaticMeshRelevance.NumElements;
  106. 					SubjectMeshCommandBuildRequests.Add(&StaticMesh);
  107.  
  108. 					bDrawingStaticMeshes = true;
  109. 				}
  110. 			}
  111. 		}
  112. 	}
  113.  
  114. 	return bDrawingStaticMeshes;
  115. }

  1. void FProjectedShadowInfo::AddCachedMeshDrawCommandsForPass(
  2. 	int32 PrimitiveIndex,
  3. 	const FPrimitiveSceneInfo* InPrimitiveSceneInfo,
  4. 	const FStaticMeshBatchRelevance& RESTRICT StaticMeshRelevance,
  5. 	const FStaticMeshBatch& StaticMesh,
  6. 	const FScene* Scene,
  7. 	EMeshPass::Type PassType,
  8. 	FMeshCommandOneFrameArray& VisibleMeshCommands,
  9. 	TArray<const FStaticMeshBatch*, SceneRenderingAllocator>& MeshCommandBuildRequests,
  10. 	int32& NumMeshCommandBuildRequestElements)
  11. {
  12. 	const EShadingPath ShadingPath = Scene->GetShadingPath();
  13. 	const bool bUseCachedMeshCommand = UseCachedMeshDrawCommands()
  14. 		&& !!(FPassProcessorManager::GetPassFlags(ShadingPath, PassType) & EMeshPassFlags::CachedMeshCommands)
  15. 		&& StaticMeshRelevance.bSupportsCachingMeshDrawCommands;
  16.  
  17. 	if (bUseCachedMeshCommand)
  18. 	{
  19. 		const int32 StaticMeshCommandInfoIndex = StaticMeshRelevance.GetStaticMeshCommandInfoIndex(PassType);
  20. 		if (StaticMeshCommandInfoIndex >= 0)
  21. 		{
  22. 			const FCachedMeshDrawCommandInfo& CachedMeshDrawCommand = InPrimitiveSceneInfo->StaticMeshCommandInfos[StaticMeshCommandInfoIndex];
  23. 			const FCachedPassMeshDrawList& SceneDrawList = Scene->CachedDrawLists[PassType];
  24. 			const FMeshDrawCommand* MeshDrawCommand = CachedMeshDrawCommand.StateBucketId >= 0
  25. 					? &Scene->CachedMeshDrawCommandStateBuckets[PassType].GetByElementId(CachedMeshDrawCommand.StateBucketId).Key
  26. 					: &SceneDrawList.MeshDrawCommands[CachedMeshDrawCommand.CommandIndex];
  27.  
  28. 			FVisibleMeshDrawCommand NewVisibleMeshDrawCommand;
  29.  
  30. 			NewVisibleMeshDrawCommand.Setup(
  31. 				MeshDrawCommand,
  32. 				PrimitiveIndex,
  33. 				PrimitiveIndex,
  34. 				CachedMeshDrawCommand.StateBucketId,
  35. 				CachedMeshDrawCommand.MeshFillMode,
  36. 				CachedMeshDrawCommand.MeshCullMode,
  37. 				CachedMeshDrawCommand.SortKey);
  38.  
  39. 			VisibleMeshCommands.Add(NewVisibleMeshDrawCommand);
  40. 		}
  41. 	}
  42. 	else
  43. 	{
  44. 		NumMeshCommandBuildRequestElements += StaticMeshRelevance.NumElements;
  45. 		MeshCommandBuildRequests.Add(&StaticMesh);
  46. 	}
  47. }
  1. FORCEINLINE_DEBUGGABLE void Setup(
  2. 		const FMeshDrawCommand* InMeshDrawCommand,
  3. 		int32 InDrawPrimitiveId,
  4. 		int32 InScenePrimitiveId,
  5. 		int32 InStateBucketId,
  6. 		ERasterizerFillMode InMeshFillMode,
  7. 		ERasterizerCullMode InMeshCullMode,
  8. 		FMeshDrawCommandSortKey InSortKey)
  9. 	{
  10. 		MeshDrawCommand = InMeshDrawCommand;
  11. 		DrawPrimitiveId = InDrawPrimitiveId;
  12. 		ScenePrimitiveId = InScenePrimitiveId;
  13. 		PrimitiveIdBufferOffset = -1;
  14. 		StateBucketId = InStateBucketId;
  15. 		MeshFillMode = InMeshFillMode;
  16. 		MeshCullMode = InMeshCullMode;
  17. 		SortKey = InSortKey;
  18. 	}
  1. class FMeshDrawCommand
  2. {
  3. public:
  4. 	
  5. 	/**
  6. 	 * Resource bindings
  7. 	 */
  8. 	FMeshDrawShaderBindings ShaderBindings;
  9. 	FVertexInputStreamArray VertexStreams;
  10. 	FRHIIndexBuffer* IndexBuffer;
  11.  
  12. 	/**
  13. 	 * PSO
  14. 	 */
  15. 	FGraphicsMinimalPipelineStateId CachedPipelineId;
  16.  
  17. 	/**
  18. 	 * Draw command parameters
  19. 	 */
  20. 	uint32 FirstIndex;
  21. 	uint32 NumPrimitives;
  22. 	uint32 NumInstances;
  23.  
  24. 	union
  25. 	{
  26. 		struct 
  27. 		{
  28. 			uint32 BaseVertexIndex;
  29. 			uint32 NumVertices;
  30. 		} VertexParams;
  31. 		
  32. 		struct  
  33. 		{
  34. 			FRHIVertexBuffer* Buffer;
  35. 			uint32 Offset;
  36. 		} IndirectArgs;
  37. 	};
  38.  
  39. 	int8 PrimitiveIdStreamIndex;
  40.  
  41. 	/** Non-pipeline state */
  42. 	uint8 StencilRef;
  43.  
  44. 	FMeshDrawCommand() {};
  45. 	FMeshDrawCommand(FMeshDrawCommand&& Other) = default;
  46. 	FMeshDrawCommand(const FMeshDrawCommand& Other) = default;
  47. 	FMeshDrawCommand& operator=(const FMeshDrawCommand& Other) = default;
  48. 	FMeshDrawCommand& operator=(FMeshDrawCommand&& Other) = default; 
  49.  
  50. 	bool MatchesForDynamicInstancing(const FMeshDrawCommand& Rhs) const
  51. 	{
  52. 		return CachedPipelineId == Rhs.CachedPipelineId
  53. 			&& StencilRef == Rhs.StencilRef
  54. 			&& ShaderBindings.MatchesForDynamicInstancing(Rhs.ShaderBindings)
  55. 			&& VertexStreams == Rhs.VertexStreams
  56. 			&& PrimitiveIdStreamIndex == Rhs.PrimitiveIdStreamIndex
  57. 			&& IndexBuffer == Rhs.IndexBuffer
  58. 			&& FirstIndex == Rhs.FirstIndex
  59. 			&& NumPrimitives == Rhs.NumPrimitives
  60. 			&& NumInstances == Rhs.NumInstances
  61. 			&& ((NumPrimitives > 0 && VertexParams.BaseVertexIndex == Rhs.VertexParams.BaseVertexIndex && VertexParams.NumVertices == Rhs.VertexParams.NumVertices)
  62. 				|| (NumPrimitives == 0 && IndirectArgs.Buffer == Rhs.IndirectArgs.Buffer && IndirectArgs.Offset == Rhs.IndirectArgs.Offset));
  63. 	}
  64.  
  65. 	uint32 GetDynamicInstancingHash() const
  66. 	{
  67. 		//add and initialize any leftover padding within the struct to avoid unstable keys
  68. 		struct FHashKey
  69. 		{
  70. 			uint32 IndexBuffer;
  71. 			uint32 VertexBuffers = 0;
  72. 		    uint32 VertexStreams = 0;
  73. 			uint32 PipelineId;
  74. 			uint32 DynamicInstancingHash;
  75. 			uint32 FirstIndex;
  76. 			uint32 NumPrimitives;
  77. 			uint32 NumInstances;
  78. 			uint32 IndirectArgsBufferOrBaseVertexIndex;
  79. 			uint32 NumVertices;
  80. 			uint32 StencilRefAndPrimitiveIdStreamIndex;
  81.  
  82. 			static inline uint32 PointerHash(const void* Key)
  83. 			{
  84. #if PLATFORM_64BITS
  85. 				// Ignoring the lower 4 bits since they are likely zero anyway.
  86. 				// Higher bits are more significant in 64 bit builds.
  87. 				return reinterpret_cast<UPTRINT>(Key) >> 4;
  88. #else
  89. 				return reinterpret_cast<UPTRINT>(Key);
  90. #endif
  91. 			};
  92.  
  93. 			static inline uint32 HashCombine(uint32 A, uint32 B)
  94. 			{
  95. 				return A ^ (B + 0x9e3779b9 + (A << 6) + (A >> 2));
  96. 			}
  97. 		} HashKey;
  98.  
  99. 		HashKey.PipelineId = CachedPipelineId.GetId();
  100. 		HashKey.StencilRefAndPrimitiveIdStreamIndex = StencilRef | (PrimitiveIdStreamIndex << 8);
  101. 		HashKey.DynamicInstancingHash = ShaderBindings.GetDynamicInstancingHash();
  102.  
  103. 		for (int index = 0; index < VertexStreams.Num(); index++)
  104. 		{
  105. 			const FVertexInputStream& VertexInputStream = VertexStreams[index];
  106. 			const uint32 StreamIndex = VertexInputStream.StreamIndex;
  107. 			const uint32 Offset = VertexInputStream.Offset;
  108.  
  109. 			uint32 Packed = (StreamIndex << 28) | Offset;
  110. 			HashKey.VertexStreams = FHashKey::HashCombine(HashKey.VertexStreams, Packed);
  111. 			HashKey.VertexBuffers = FHashKey::HashCombine(HashKey.VertexBuffers, FHashKey::PointerHash(VertexInputStream.VertexBuffer));
  112. 		}
  113.  
  114. 		HashKey.IndexBuffer = FHashKey::PointerHash(IndexBuffer);
  115. 		HashKey.FirstIndex = FirstIndex;
  116. 		HashKey.NumPrimitives = NumPrimitives;
  117. 		HashKey.NumInstances = NumInstances;
  118.  
  119. 		if (NumPrimitives > 0)
  120. 		{
  121. 			HashKey.IndirectArgsBufferOrBaseVertexIndex = VertexParams.BaseVertexIndex;
  122. 			HashKey.NumVertices = VertexParams.NumVertices;
  123. 		}
  124. 		else
  125. 		{
  126. 			HashKey.IndirectArgsBufferOrBaseVertexIndex = FHashKey::PointerHash(IndirectArgs.Buffer);
  127. 			HashKey.NumVertices = IndirectArgs.Offset;
  128. 		}		
  129.  
  130. 		return uint32(CityHash64((char*)&HashKey, sizeof(FHashKey)));
  131. 	}
  132.  
  133. 	/** Sets shaders on the mesh draw command and allocates room for the shader bindings. */
  134. 	RENDERER_API void SetShaders(FRHIVertexDeclaration* VertexDeclaration, const FMeshProcessorShaders& Shaders, FGraphicsMinimalPipelineStateInitializer& PipelineState);
  135.  
  136. 	inline void SetStencilRef(uint32 InStencilRef)
  137. 	{
  138. 		StencilRef = InStencilRef;
  139. 		// Verify no overflow
  140. 		checkSlow((uint32)StencilRef == InStencilRef);
  141. 	}
  142.  
  143. 	/** Called when the mesh draw command is complete. */
  144. 	RENDERER_API void SetDrawParametersAndFinalize(
  145. 		const FMeshBatch& MeshBatch, 
  146. 		int32 BatchElementIndex,
  147. 		FGraphicsMinimalPipelineStateId PipelineId,
  148. 		const FMeshProcessorShaders* ShadersForDebugging);
  149.  
  150. 	void Finalize(FGraphicsMinimalPipelineStateId PipelineId, const FMeshProcessorShaders* ShadersForDebugging)
  151. 	{
  152. 		CachedPipelineId = PipelineId;
  153. 		ShaderBindings.Finalize(ShadersForDebugging);	
  154. 	}
  155.  
  156. 	/** Submits commands to the RHI Commandlist to draw the MeshDrawCommand. */
  157. 	static void SubmitDraw(
  158. 		const FMeshDrawCommand& RESTRICT MeshDrawCommand, 
  159. 		const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
  160. 		FRHIVertexBuffer* ScenePrimitiveIdsBuffer,
  161. 		int32 PrimitiveIdOffset,
  162. 		uint32 InstanceFactor,
  163. 		FRHICommandList& CommandList, 
  164. 		class FMeshDrawCommandStateCache& RESTRICT StateCache);
  165.  
  166. 	FORCENOINLINE friend uint32 GetTypeHash( const FMeshDrawCommand& Other )
  167. 	{
  168. 		return Other.CachedPipelineId.GetId();
  169. 	}
  170. #if MESH_DRAW_COMMAND_DEBUG_DATA
  171. 	RENDERER_API void SetDebugData(const FPrimitiveSceneProxy* PrimitiveSceneProxy, const FMaterial* Material, const FMaterialRenderProxy* MaterialRenderProxy, const FMeshProcessorShaders& UntypedShaders, const FVertexFactory* VertexFactory);
  172. #else
  173. 	void SetDebugData(const FPrimitiveSceneProxy* PrimitiveSceneProxy, const FMaterial* Material, const FMaterialRenderProxy* MaterialRenderProxy, const FMeshProcessorShaders& UntypedShaders, const FVertexFactory* VertexFactory){}
  174. #endif
  175.  
  176. 	SIZE_T GetAllocatedSize() const
  177. 	{
  178. 		return ShaderBindings.GetAllocatedSize() + VertexStreams.GetAllocatedSize();
  179. 	}
  180.  
  181. 	SIZE_T GetDebugDataSize() const
  182. 	{
  183. #if MESH_DRAW_COMMAND_DEBUG_DATA
  184. 		return sizeof(DebugData);
  185. #endif
  186. 		return 0;
  187. 	}
  188.  
  189. #if MESH_DRAW_COMMAND_DEBUG_DATA
  190. 	void ClearDebugPrimitiveSceneProxy() const
  191. 	{
  192. 		DebugData.PrimitiveSceneProxyIfNotUsingStateBuckets = nullptr;
  193. 	}
  194. private:
  195. 	mutable FMeshDrawCommandDebugData DebugData;
  196. #endif
  197. };

MeshPassProcessor.cpp

  1. void FCachedPassMeshDrawListContext::FinalizeCommand(
  2. 	const FMeshBatch& MeshBatch, 
  3. 	int32 BatchElementIndex,
  4. 	int32 DrawPrimitiveId,
  5. 	int32 ScenePrimitiveId,
  6. 	ERasterizerFillMode MeshFillMode,
  7. 	ERasterizerCullMode MeshCullMode,
  8. 	FMeshDrawCommandSortKey SortKey,
  9. 	const FGraphicsMinimalPipelineStateInitializer& PipelineState,
  10. 	const FMeshProcessorShaders* ShadersForDebugging,
  11. 	FMeshDrawCommand& MeshDrawCommand)
  12. {
  13. 	// disabling this by default as it incurs a high cost in perf captures due to sheer volume.  Recommendation is to re-enable locally if you need to profile this particular code.
  14. 	// QUICK_SCOPE_CYCLE_COUNTER(STAT_FinalizeCachedMeshDrawCommand);
  15.  
  16. 	FGraphicsMinimalPipelineStateId PipelineId = FGraphicsMinimalPipelineStateId::GetPersistentId(PipelineState);
  17.  
  18. 	MeshDrawCommand.SetDrawParametersAndFinalize(MeshBatch, BatchElementIndex, PipelineId, ShadersForDebugging);
  19.  
  20. 	if (UseGPUScene(GMaxRHIShaderPlatform, GMaxRHIFeatureLevel))
  21. 		{
  22. 		Experimental::FHashElementId SetId;
  23. 		auto hash = CachedMeshDrawCommandStateBuckets.ComputeHash(MeshDrawCommand);
  24. 		{
  25. 			FScopeLock Lock(&CachedMeshDrawCommandLock);
  26.  
  27. #if UE_BUILD_DEBUG
  28. 			FMeshDrawCommand MeshDrawCommandDebug = FMeshDrawCommand(MeshDrawCommand);
  29. 			check(MeshDrawCommandDebug.ShaderBindings.GetDynamicInstancingHash() == MeshDrawCommand.ShaderBindings.GetDynamicInstancingHash());
  30. 			check(MeshDrawCommandDebug.GetDynamicInstancingHash() == MeshDrawCommand.GetDynamicInstancingHash());
  31. #endif
  32. 			SetId = CachedMeshDrawCommandStateBuckets.FindOrAddIdByHash(hash, MeshDrawCommand, FMeshDrawCommandCount());
  33. 			CachedMeshDrawCommandStateBuckets.GetByElementId(SetId).Value.Num++;
  34.  
  35. #if MESH_DRAW_COMMAND_DEBUG_DATA
  36. 			if (CachedMeshDrawCommandStateBuckets.GetByElementId(SetId).Value.Num == 1)
  37. 			{
  38. 			MeshDrawCommand.ClearDebugPrimitiveSceneProxy(); //When using State Buckets multiple PrimitiveSceneProxies use the same MeshDrawCommand, so The PrimitiveSceneProxy pointer can't be stored.
  39. 			}
  40. #endif
  41. 		}
  42.  
  43. 		check(CommandInfo.StateBucketId == -1);
  44. 		CommandInfo.StateBucketId = SetId.GetIndex();
  45. 		check(CommandInfo.CommandIndex == -1);
  46. 	}
  47. 	else
  48. 	{
  49. 		check(CommandInfo.CommandIndex == -1);
  50. 		FScopeLock Lock(&CachedMeshDrawCommandLock);
  51. 		// Only one FMeshDrawCommand supported per FStaticMesh in a pass
  52. 		// Allocate at lowest free index so that 'r.DoLazyStaticMeshUpdate' can shrink the TSparseArray more effectively
  53. 		CommandInfo.CommandIndex = CachedDrawLists.MeshDrawCommands.EmplaceAtLowestFreeIndex(CachedDrawLists.LowestFreeIndexSearchStart, MeshDrawCommand);
  54. 	}
  55.  
  56. 	CommandInfo.SortKey = SortKey;
  57. 	CommandInfo.MeshFillMode = MeshFillMode;
  58. 	CommandInfo.MeshCullMode = MeshCullMode;
  59. }
  1. void FMeshDrawCommand::SetDrawParametersAndFinalize(
  2. 	const FMeshBatch& MeshBatch, 
  3. 	int32 BatchElementIndex,
  4. 	FGraphicsMinimalPipelineStateId PipelineId,
  5. 	const FMeshProcessorShaders* ShadersForDebugging)
  6. {
  7. 	const FMeshBatchElement& BatchElement = MeshBatch.Elements[BatchElementIndex];
  8.  
  9. 	check(!BatchElement.IndexBuffer || (BatchElement.IndexBuffer && BatchElement.IndexBuffer->IsInitialized() && BatchElement.IndexBuffer->IndexBufferRHI));
  10. 	checkSlow(!BatchElement.bIsInstanceRuns);
  11. 	IndexBuffer = BatchElement.IndexBuffer ? BatchElement.IndexBuffer->IndexBufferRHI.GetReference() : nullptr;
  12. 	FirstIndex = BatchElement.FirstIndex;
  13. 	NumPrimitives = BatchElement.NumPrimitives;
  14. 	NumInstances = BatchElement.NumInstances;
  15.  
  16. 	if (NumPrimitives > 0)
  17. 	{
  18. 		VertexParams.BaseVertexIndex = BatchElement.BaseVertexIndex;
  19. 		VertexParams.NumVertices = BatchElement.MaxVertexIndex - BatchElement.MinVertexIndex + 1;
  20. 		checkf(!BatchElement.IndirectArgsBuffer, TEXT("FMeshBatchElement::NumPrimitives must be set to 0 when a IndirectArgsBuffer is used"));
  21. 	}
  22. 	else
  23. 	{
  24. 		checkf(BatchElement.IndirectArgsBuffer, TEXT("It is only valid to set BatchElement.NumPrimitives == 0 when a IndirectArgsBuffer is used"));
  25. 		IndirectArgs.Buffer = BatchElement.IndirectArgsBuffer;
  26. 		IndirectArgs.Offset = BatchElement.IndirectArgsOffset;
  27. 	}
  28.  
  29. 	Finalize(PipelineId, ShadersForDebugging);
  30. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/91463
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号