UE4阴影初始化【1】

已于 2022-04-03 00:03:52 修改
阅读量1.6k 收藏 2
点赞数
分类专栏： # UE4之阴影 文章标签： ue4 阴影初始化
于 2022-03-31 01:15:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sh15285118586/article/details/123861566
版权

开始位置：Runtime/Renderer/Private/DefferredShadingRenderer.cpp

void FDeferredShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
{
    bool bDoInitViewAftersPrepass = false;
	{
		SCOPED_GPU_STAT(RHICmdList, VisibilityCommands);
		bDoInitViewAftersPrepass = InitViews(RHICmdList, BasePassDepthStencilAccess, ILCTaskData)
}

bool FDeferredShadingSceneRenderer::InitViews(FRHICommandListImmediate& RHICmdList, FExclusiveDepthStencil::Type BasePassDepthStencilAccess, struct FILCUpdatePrimTaskData& ILCTaskData)
{
	SCOPED_NAMED_EVENT(FDeferredShadingSceneRenderer_InitViews, FColor::Emerald);
	SCOPE_CYCLE_COUNTER(STAT_InitViewsTime);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(InitViews_Scene);
	check(RHICmdList.IsOutsideRenderPass());

	PreVisibilityFrameSetup(RHICmdList);

	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);

	{
		// This is to init the ViewUniformBuffer before rendering for the Niagara compute shader.
		// This needs to run before ComputeViewVisibility() is called, but the views normally initialize the ViewUniformBuffer after that (at the end of this method).
		if (FXSystem && FXSystem->RequiresEarlyViewUniformBuffer() && Views.IsValidIndex(0))
		{
			Views[0].InitRHIResources();
			FXSystem->PostInitViews(RHICmdList, Views[0].ViewUniformBuffer, Views[0].AllowGPUParticleUpdate() && !ViewFamily.EngineShowFlags.HitProxies);
		}
	}
	
	FViewVisibleCommandsPerView ViewCommandsPerView;
	ViewCommandsPerView.SetNum(Views.Num());

	ComputeViewVisibility(RHICmdList, BasePassDepthStencilAccess, ViewCommandsPerView, DynamicIndexBufferForInitViews, DynamicVertexBufferForInitViews, DynamicReadBufferForInitViews);

	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);

	// This has to happen before Scene->IndirectLightingCache.UpdateCache, since primitives in View.IndirectShadowPrimitives need ILC updates
	CreateIndirectCapsuleShadows();

	// This must happen before we start initialising and using views.
	UpdateSkyIrradianceGpuBuffer(RHICmdList);

	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);

	// Initialise Sky/View resources before the view global uniform buffer is built.
	if (ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags))
	{
		InitSkyAtmosphereForViews(RHICmdList);
	}

	PostVisibilityFrameSetup(ILCTaskData);
	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);

	FVector AverageViewPosition(0);

	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
	{		
		FViewInfo& View = Views[ViewIndex];
		AverageViewPosition += View.ViewMatrices.GetViewOrigin() / Views.Num();
	}

	bool bDoInitViewAftersPrepass = !!GDoInitViewsLightingAfterPrepass;

	if (!bDoInitViewAftersPrepass)
	{
		InitViewsPossiblyAfterPrepass(RHICmdList, ILCTaskData);
	}

	{
		QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_InitRHIResources);
		// initialize per-view uniform buffer.
		for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
		{
			FViewInfo& View = Views[ViewIndex];

			if (View.ViewState)
			{
				if (!View.ViewState->ForwardLightingResources)
				{
					View.ViewState->ForwardLightingResources.Reset(new FForwardLightingViewResources());
				}

				View.ForwardLightingResources = View.ViewState->ForwardLightingResources.Get();
			}
			else
			{
				View.ForwardLightingResourcesStorage.Reset(new FForwardLightingViewResources());
				View.ForwardLightingResources = View.ForwardLightingResourcesStorage.Get();
			}

#if RHI_RAYTRACING
			View.IESLightProfileResource = View.ViewState ? &View.ViewState->IESLightProfileResources : nullptr;
#endif
			// Set the pre-exposure before initializing the constant buffers.
			if (View.ViewState)
			{
				View.ViewState->UpdatePreExposure(View);
			}

			// Initialize the view's RHI resources.
			View.InitRHIResources();
		}
	}

	SetupVolumetricFog();

	{
		QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_OnStartRender);
		OnStartRender(RHICmdList);
	}

	return bDoInitViewAftersPrepass;
}

void FDeferredShadingSceneRenderer::InitViewsPossiblyAfterPrepass(FRHICommandListImmediate& RHICmdList, struct FILCUpdatePrimTaskData& ILCTaskData)
{
	SCOPED_NAMED_EVENT(FDeferredShadingSceneRenderer_InitViewsPossiblyAfterPrepass, FColor::Emerald);
	SCOPE_CYCLE_COUNTER(STAT_InitViewsPossiblyAfterPrepass);

	if (ViewFamily.EngineShowFlags.DynamicShadows 
		&& !IsSimpleForwardShadingEnabled(ShaderPlatform)
		&& !ViewFamily.EngineShowFlags.HitProxies)
	{
		// Setup dynamic shadows.
		InitDynamicShadows(RHICmdList, DynamicIndexBufferForInitShadows, DynamicVertexBufferForInitShadows, DynamicReadBufferForInitShadows);

		RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
	}

	// If parallel ILC update is disabled, then process it in place.
	if (ViewFamily.EngineShowFlags.HitProxies == 0
		&& Scene->PrecomputedLightVolumes.Num() > 0
		&& !(GILCUpdatePrimTaskEnabled && FPlatformProcess::SupportsMultithreading()))
	{
		QUICK_SCOPE_CYCLE_COUNTER(STAT_PostVisibilityFrameSetup_IndirectLightingCache_Update);
		check(!ILCTaskData.TaskRef.IsValid());
		Scene->IndirectLightingCache.UpdateCache(Scene, *this, true);
	}

	// If we kicked off ILC update via task, wait and finalize.
	if (ILCTaskData.TaskRef.IsValid())
	{
		Scene->IndirectLightingCache.FinalizeCacheUpdates(Scene, *this, ILCTaskData);
	}

	{
		QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_UpdatePrimitiveIndirectLightingCacheBuffers);
		// Now that the indirect lighting cache is updated, we can update the primitive precomputed lighting buffers.
		UpdatePrimitiveIndirectLightingCacheBuffers();
	}

	SeparateTranslucencyDimensions = UpdateTranslucencyTimers(RHICmdList, Views);

	SetupSceneReflectionCaptureBuffer(RHICmdList);
}

 InitDynamicShadows的主要过程，如下：

  • 根据view、场景光源、控制台变量初始化阴影相关标记。

  • 遍历场景所有光源（Scene->Lights），执行以下操作：

    • 如果光源没有开启阴影或阴影质量太小，或者光源在所有view都不可见，忽略之，不执行阴影投射。

    • 如果是点光源全景阴影，则将该光源组件名字加入Scene的UsedWholeScenePointLightNames列表中。

    • 如果符合全景阴影的创建条件，调用CreateWholeSceneProjectedShadow：

      • 初始化阴影数据，计算阴影所需的分辨率、过渡因子（FadeAlpha）等。
      • 若过渡因子太小（小于1/256），则直接返回。
      • 遍历光源的投射阴影数量，每次都执行分辨率计算、位置（SizeX、SizeY）计算、需创建的阴影图数量等。
        • 根据阴影图数量创建同等个数的FProjectedShadowInfo阴影实例，对每个阴影实例：
          • 设置全景投射参数（视锥体边界、变换矩阵、深度、深度偏移等）、过渡因子、缓存模式等。
          • 加入VisibleLightInfo.MemStackProjectedShadows列表；如果是单通道点光源阴影，填充阴影实例的cubemap6个面的数据（视图投影矩阵、包围盒、远近裁剪面等），并初始化锥体。
          • 对非光追距离场阴影，执行CPU侧裁剪。构建光源视图的凸面体，再遍历光源的移动图元列表，调用IntersectsConvexHulls让光源包围盒和图元包围盒求交测试，相交的那些图元才会添加到阴影实例的主体图元列表中。对光源的静态图元做相似的操作。
          • 最后将需要渲染的阴影实例加入VisibleLightInfo.AllProjectedShadows列表中。

    • 针对两类光源（移动和固定的光源、尚未构建的静态光源）创建CSM（级联阴影）。调用AddViewDependentWholeSceneShadowsForView创建视图关联的CSM：

      • 遍历所有view，针对每个view：
        • 如果不是主view，直接跳过后续步骤。
        • 获取视图相关的全景投影数量，创建同等数量的FProjectedShadowInfo阴影实例，给每个阴影实例设置全景投影参数，最后添加到阴影实例列表和待裁剪列表中。

    • 处理交互阴影（指光源和图元之间的影响，包含PerObject阴影、透明阴影、自阴影等），遍历光源的动态和静态图元，给每个图元调用SetupInteractionShadows设置交互阴影：

      • 处理光源附加根组件，设置相关标记。如果存在附加根组件，跳过后续步骤。
      • 如果需要创建阴影实例，则调用CreatePerObjectProjectedShadow创建逐物体阴影：
        • 遍历所有view，收集阴影相关的标记。
        • 如果本帧不可见且下一帧也没有潜在可见，则直接返回，跳过后续的阴影创建和设置。
        • 没有有效的阴影组图元，直接返回。
        • 计算阴影的各类数据（阴影视锥、分辨率、可见性标记、图集位置等）。
        • 若过渡因子（FadeAlpha）小于某个阈值（1.0/256.0），直接返回。
        • 符合阴影创建条件且是不透明阴影，则创和设置建阴影实例，加入VisibleLightInfo.MemStackProjectedShadows列表中。如果本帧可见则加入到阴影实例的主体图元列表，如果下一帧潜在可见则加入到VisibleLightInfo.OccludedPerObjectShadows的实例中。
        • 符合阴影创建条件且是半透明阴影，执行上步骤类似操作。

  • 调用InitProjectedShadowVisibility执行阴影可见性判定：

    • 遍历场景的所有光源，针对每个光源：
      • 分配视图内的投射阴影可见性和关联的容器。
      • 遍历可见光源所有的阴影实例，针对每个阴影实例：
        • 保存阴影索引。
        • 遍历所有view，针对每个view：
          • 处理视图关联的阴影，跳过那些不在视图视锥内的光源。
          • 计算主体图元的视图关联数据，断阴影是否被遮挡，设置阴影可见性标记。
          • 如果阴影可见且不是RSM，利用FViewElementPDI绘制阴影锥体。

  • 调用UpdatePreshadowCache清理旧的预计算阴影，尝试增加新的到缓存中：

    • 初始化纹理布局。
    • 遍历所有缓存的预阴影, 删除不在此帧渲染的实例。
    • 收集可以被缓存的PreShadow列表。
    • 对PreShadow从大到小排序（更大的PreShadow在渲染深度时会有更多的物体）。
    • 遍历所有未缓存的PreShadow，尝试从纹理布局中给PreShadow找空间，若找到，则设置相关数据并添加到Scene->CachedPreshadows列表中。

  • 调用GatherShadowPrimitives收集图元列表，以处理不同类型的阴影：

    • 如果没有PreShadow且没有视图关联的全景阴影（ViewDependentWholeSceneShadows），则直接返回。
    • 如果允许八叉树遍历（GUseOctreeForShadowCulling决定），利用八叉树遍历Scene->PrimitiveOctree，针对每个孩子节点：
      • 检查孩子节点是否至少在一个阴影（包含PreShadow和视图相关的全景阴影）内，如果是，则push到节点容器中。
      • 如果图元节点的元素大于0，从FMemStack创建一个FGatherShadowPrimitivesPacket实例，将该节点的相关数据存入其中，添加到FGatherShadowPrimitivesPacket实例列表中。
    • 如果是非八叉树遍历模式，则线性遍历图元，创建FGatherShadowPrimitivesPacket并加入到列表中。
    • 利用ParallelFor并行地过滤掉和阴影不相交的图元，收集和阴影相交的图元。
    • 收集最后阶段，将受阴影影响的图元加入阴影实例的SubjectPrimitive列表中，清理之前申请的资源。

  • 调用AllocateShadowDepthTargets分配阴影图所需的渲染纹理：

    • 初始化不同类型的指定了分配器的阴影列表。
    • 遍历所有光源，针对每个光源：
      • 遍历光源的所有阴影实例，针对每个阴影实例：
        • 检测阴影是否至少在一个view中可见。
        • 检测阴影缓存模式为可移动图元时的条件可见性。
        • 其它特殊的可见性判断。
        • 如果阴影可见，根据不同类型加入到不同的阴影实例列表中。
      • 排序级联阴影，因为在级联之间的混合要求是有序的。
      • 调用AllocateCSMDepthTargets分配CSM深度渲染纹理。
      • 处理PreShadow。
      • 依次分配点光源cubemap、RSM、缓存的聚光灯、逐物体、透明阴影的渲染纹理。
      • 更新透明阴影图的uniform buffer。
      • 删除完全没有被使用的阴影缓存。

  • 调用GatherShadowDynamicMeshElements收集阴影的动态网格元素：

    • 遍历所有阴影图图集（ShadowMapAtlases），收集每个图集内的所有阴影实例的网格元素。
    • 遍历所有RSM阴影图图集（RSMAtlases），收集每个图集内的所有阴影实例的网格元素。
    • 遍历所有点光源立方体阴影图（ShadowMapCubemaps），收集每个立方体阴影图内的所有阴影实例的网格元素。
    • 遍历所有PreShadow缓存的阴影图（PreshadowCache），收集阴影实例的网格元素。
    • 遍历所有透明物体阴影图图集（TranslucencyShadowMapAtlases），收集每个图集内的所有阴影实例的网格元素。

阴影初始化总结完了，由此可知阴影的处理非常非常复杂，涉及的逻辑和优化技术甚多。这里粗略总结一下阴影初始化阶段涉及的优化技巧：

  • 利用物体（视图、光源、阴影、图元）的简单形状做相交测试，剔除不相交的阴影元素。
  • 利用各类标记（物体、视图、控制台、全局变量等等）及衍生标记，剔除不符合的阴影元素。
  • 利用中间数据（过渡因子、屏幕尺寸大小、深度值等等）剔除不符合的阴影元素。
  • 特殊数据结构（纹理布局、阴影图集、八叉树、连续线性数组）和遍历方式（并行、八叉树、线性）提升执行效果。
  • 充分利用缓存（PreShadowCache、潜在可见性等）减少渲染效果。
  • 对阴影类型进行排序，减少渲染状态切换，减少CPU和GPU交互数据，提升缓存命中率。
  • 不同粒度的遮挡剔除。
void FSceneRenderer::InitDynamicShadows(FRHICommandListImmediate& RHICmdList, FGlobalDynamicIndexBuffer& DynamicIndexBuffer, FGlobalDynamicVertexBuffer& DynamicVertexBuffer, FGlobalDynamicReadBuffer& DynamicReadBuffer)
{
	SCOPE_CYCLE_COUNTER(STAT_DynamicShadowSetupTime);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(InitViews_Shadows);
	SCOPED_NAMED_EVENT(FSceneRenderer_InitDynamicShadows, FColor::Magenta);

	const bool bMobile = FeatureLevel < ERHIFeatureLevel::SM5;

	bool bStaticSceneOnly = false;

	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
	{
		FViewInfo& View = Views[ViewIndex];
		bStaticSceneOnly = bStaticSceneOnly || View.bStaticSceneOnly;
	}

	const bool bProjectEnablePointLightShadows = Scene->ReadOnlyCVARCache.bEnablePointLightShadows && !bMobile; // Point light shadow is unsupported on mobile for now.
	const bool bProjectEnableMovableDirectionLightShadows = !bMobile || Scene->ReadOnlyCVARCache.bMobileAllowMovableDirectionalLights;
	const bool bProjectEnableMovableSpotLightShadows = !bMobile || Scene->ReadOnlyCVARCache.bMobileEnableMovableSpotlightsShadow;

	uint32 NumPointShadowCachesUpdatedThisFrame = 0;
	uint32 NumSpotShadowCachesUpdatedThisFrame = 0;

	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> PreShadows;
	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> ViewDependentWholeSceneShadows;
	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> ViewDependentWholeSceneShadowsThatNeedCulling;
	{
		SCOPE_CYCLE_COUNTER(STAT_InitDynamicShadowsTime);
		CSV_SCOPED_TIMING_STAT_EXCLUSIVE(ShadowInitDynamic);

		for (TSparseArray<FLightSceneInfoCompact>::TConstIterator LightIt(Scene->Lights); LightIt; ++LightIt)
		{
			const FLightSceneInfoCompact& LightSceneInfoCompact = *LightIt;
			FLightSceneInfo* LightSceneInfo = LightSceneInfoCompact.LightSceneInfo;

			FScopeCycleCounter Context(LightSceneInfo->Proxy->GetStatId());

			FVisibleLightInfo& VisibleLightInfo = VisibleLightInfos[LightSceneInfo->Id];

			const FLightOcclusionType OcclusionType = GetLightOcclusionType(LightSceneInfoCompact);
			if (OcclusionType != FLightOcclusionType::Shadowmap)
				continue;

			// Only consider lights that may have shadows.
			if ((LightSceneInfoCompact.bCastStaticShadow || LightSceneInfoCompact.bCastDynamicShadow) && GetShadowQuality() > 0)
			{
				// see if the light is visible in any view
				bool bIsVisibleInAnyView = false;

				for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
				{
					// View frustums are only checked when lights have visible primitives or have modulated shadows,
					// so we don't need to check for that again here
					bIsVisibleInAnyView = LightSceneInfo->ShouldRenderLight(Views[ViewIndex]);

					if (bIsVisibleInAnyView) 
					{
						break;
					}
				}

				if (bIsVisibleInAnyView)
				{
					static const auto AllowStaticLightingVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowStaticLighting"));
					const bool bAllowStaticLighting = (!AllowStaticLightingVar || AllowStaticLightingVar->GetValueOnRenderThread() != 0);
					const bool bPointLightShadow = LightSceneInfoCompact.LightType == LightType_Point || LightSceneInfoCompact.LightType == LightType_Rect;
					const bool bDirectionalLightShadow = LightSceneInfoCompact.LightType == LightType_Directional;
					const bool bSpotLightShadow = LightSceneInfoCompact.LightType == LightType_Spot;

					// Only create whole scene shadows for lights that don't precompute shadowing (movable lights)
					const bool bShouldCreateShadowForMovableLight = 
						LightSceneInfoCompact.bCastDynamicShadow
						&& (!LightSceneInfo->Proxy->HasStaticShadowing() || !bAllowStaticLighting);

					const bool bCreateShadowForMovableLight = 
						bShouldCreateShadowForMovableLight
						&& (!bPointLightShadow || bProjectEnablePointLightShadows)
						&& (!bDirectionalLightShadow || bProjectEnableMovableDirectionLightShadows)
						&& (!bSpotLightShadow || bProjectEnableMovableSpotLightShadows);

					// Also create a whole scene shadow for lights with precomputed shadows that are unbuilt
					const bool bShouldCreateShadowToPreviewStaticLight =
						LightSceneInfo->Proxy->HasStaticShadowing()
						&& LightSceneInfoCompact.bCastStaticShadow
						&& !LightSceneInfo->IsPrecomputedLightingValid();						

					const bool bCreateShadowToPreviewStaticLight = 
						bShouldCreateShadowToPreviewStaticLight						
						&& (!bPointLightShadow || bProjectEnablePointLightShadows)
						// Stationary point light and spot light shadow are unsupported on mobile
						&& (!bMobile || bDirectionalLightShadow);

					// Create a whole scene shadow for lights that want static shadowing but didn't get assigned to a valid shadowmap channel due to overlap
					const bool bShouldCreateShadowForOverflowStaticShadowing =
						LightSceneInfo->Proxy->HasStaticShadowing()
						&& !LightSceneInfo->Proxy->HasStaticLighting()
						&& LightSceneInfoCompact.bCastStaticShadow
						&& LightSceneInfo->IsPrecomputedLightingValid()
						&& LightSceneInfo->Proxy->GetShadowMapChannel() == INDEX_NONE;

					const bool bCreateShadowForOverflowStaticShadowing =
						bShouldCreateShadowForOverflowStaticShadowing
						&& (!bPointLightShadow || bProjectEnablePointLightShadows)
						// Stationary point light and spot light shadow are unsupported on mobile
						&& (!bMobile || bDirectionalLightShadow);

					const bool bPointLightWholeSceneShadow = (bShouldCreateShadowForMovableLight || bShouldCreateShadowForOverflowStaticShadowing || bShouldCreateShadowToPreviewStaticLight) && bPointLightShadow;
					if (bPointLightWholeSceneShadow)
					{						
						UsedWholeScenePointLightNames.Add(LightSceneInfoCompact.LightSceneInfo->Proxy->GetComponentName());
					}

					if (bCreateShadowForMovableLight || bCreateShadowToPreviewStaticLight || bCreateShadowForOverflowStaticShadowing)
					{
						// Try to create a whole scene projected shadow.
						CreateWholeSceneProjectedShadow(LightSceneInfo, NumPointShadowCachesUpdatedThisFrame, NumSpotShadowCachesUpdatedThisFrame);
					}

					// Allow movable and stationary lights to create CSM, or static lights that are unbuilt
					if ((!LightSceneInfo->Proxy->HasStaticLighting() && LightSceneInfoCompact.bCastDynamicShadow) || bCreateShadowToPreviewStaticLight)
					{
						static_assert(UE_ARRAY_COUNT(Scene->MobileDirectionalLights) == 3, "All array entries for MobileDirectionalLights must be checked");
						if( !bMobile ||
							((LightSceneInfo->Proxy->UseCSMForDynamicObjects() || LightSceneInfo->Proxy->IsMovable()) 
								// Mobile uses the scene's MobileDirectionalLights only for whole scene shadows.
								&& (LightSceneInfo == Scene->MobileDirectionalLights[0] || LightSceneInfo == Scene->MobileDirectionalLights[1] || LightSceneInfo == Scene->MobileDirectionalLights[2])))
						{
							AddViewDependentWholeSceneShadowsForView(ViewDependentWholeSceneShadows, ViewDependentWholeSceneShadowsThatNeedCulling, VisibleLightInfo, *LightSceneInfo);
						}

						if( !bMobile || (LightSceneInfo->Proxy->CastsModulatedShadows() && !LightSceneInfo->Proxy->UseCSMForDynamicObjects()))
						{
							Scene->FlushAsyncLightPrimitiveInteractionCreation();

							const TArray<FLightPrimitiveInteraction*>* InteractionShadowPrimitives = LightSceneInfo->GetInteractionShadowPrimitives(false);

							if (InteractionShadowPrimitives)
							{
								const int32 NumPrims = InteractionShadowPrimitives->Num();
								for (int32 Idx = 0; Idx < NumPrims; ++Idx)
								{
									SetupInteractionShadows(RHICmdList, (*InteractionShadowPrimitives)[Idx], VisibleLightInfo, bStaticSceneOnly, ViewDependentWholeSceneShadows, PreShadows);
								}
							}
							else
							{
								// Look for individual primitives with a dynamic shadow.
								for (FLightPrimitiveInteraction* Interaction = LightSceneInfo->GetDynamicInteractionOftenMovingPrimitiveList(false);
									Interaction;
									Interaction = Interaction->GetNextPrimitive()
									)
								{
									SetupInteractionShadows(RHICmdList, Interaction, VisibleLightInfo, bStaticSceneOnly, ViewDependentWholeSceneShadows, PreShadows);
								}

								for (FLightPrimitiveInteraction* Interaction = LightSceneInfo->GetDynamicInteractionStaticPrimitiveList(false);
									Interaction;
									Interaction = Interaction->GetNextPrimitive()
									)
								{
									SetupInteractionShadows(RHICmdList, Interaction, VisibleLightInfo, bStaticSceneOnly, ViewDependentWholeSceneShadows, PreShadows);
								}
							}
						}
					}
				}
			}
		}

		CSV_CUSTOM_STAT(LightCount, UpdatedShadowMaps, float(NumPointShadowCachesUpdatedThisFrame + NumSpotShadowCachesUpdatedThisFrame), ECsvCustomStatOp::Set);
		CSV_CUSTOM_STAT_GLOBAL(ShadowCacheUsageMB, (float(Scene->GetCachedWholeSceneShadowMapsSize()) / 1024) / 1024, ECsvCustomStatOp::Set);

		// Calculate visibility of the projected shadows.
		InitProjectedShadowVisibility(RHICmdList);
	}

	// Clear old preshadows and attempt to add new ones to the cache
	UpdatePreshadowCache(FSceneRenderTargets::Get(RHICmdList));

	// Gathers the list of primitives used to draw various shadow types
	GatherShadowPrimitives(PreShadows, ViewDependentWholeSceneShadowsThatNeedCulling, bStaticSceneOnly);

	AllocateShadowDepthTargets(RHICmdList);

	// Generate mesh element arrays from shadow primitive arrays
	GatherShadowDynamicMeshElements(DynamicIndexBuffer, DynamicVertexBuffer, DynamicReadBuffer);

}

参考：剖析虚幻渲染体系（05）- 光源和阴影 - 0向往0 - 博客园

enum class FLightOcclusionType : uint8
{
	Shadowmap,
	Raytraced,
};

FLightOcclusionType GetLightOcclusionType(const FLightSceneInfoCompact& LightInfo)
{
#if RHI_RAYTRACING
	return ShouldRenderRayTracingShadowsForLight(LightInfo) ? FLightOcclusionType::Raytraced : FLightOcclusionType::Shadowmap;
#else
	return FLightOcclusionType::Shadowmap;
#endif
}

bool ShouldRenderRayTracingShadowsForLight(const FLightSceneInfoCompact& LightInfo)
{
	return ShouldRenderRayTracingShadows() && LightInfo.bCastRaytracedShadow
		&& ShouldRenderRayTracingShadowsForLightType((ELightComponentType)LightInfo.LightType);
}

sh15285118586
关注
专栏目录
UE4官方文档学习笔记材质篇——彩色半透明阴影
L人青的博客
01-03 6062
一、半透明阴影颜色 1、“半透明阴影颜色”术语用于说明阴影在穿过对象时如何拾取对象的颜色（也称为传播）。 2、穿过材质的光线量由材质的不透明度值（介于 0 与 1 之间）及投射到材质的光线量确定。 例如，如果不透明度设置为 0，那么材质的彩色阴影不会有光线传播。如果不透明值设置为 1，那么它将是完全不透明物。 二、材质设置 1、可以使用的“照亮”和“不照亮”混合模式是：半透明、递...
UE4官网教程 风格化效果
weixin_56378575的博客
09-29 1930
（本篇文章为官网视频风格化操作文字版简述，内容相对不完整且不具备解释性，建议一边看视频一边结合本文章进行操作） 1.利用基础颜色实现扁平化渲染 模式面板中点击视觉效果 点击后期处理体积（post process Volume） 拖入控制面板 细节面板 后期处理体积设置-无限范围打开 镜头-曝光 勾选最高亮度最低亮度 将二者值设为同一个值 发现明亮部位和阴影部分眼部适应被关闭 渲染-动态模糊关闭（传统动画无动态模糊） 渲染-后期处理体积设置-可混合物（1.光线传播体积可混合物2.资源引用：允
UE4阴影【类说明】
一个字
04-09 1103
struct FSortedShadowMapAtlas { FShadowMapRenderTargetsRefCounted RenderTargets; TArray<FProjectedShadowInfo*, SceneRenderingAllocator> Shadows; }; struct FSortedShadowMaps { /** Visible shadows sorted by their shadow depth map render target. */ .
UE4_材质_使用彩色半透明阴影
最新发布
Growthofnotes的博客
07-02 773
学习笔记，不喜勿喷！侵权立删，祝愿大美临沂生活越来越好！本教程将介绍如何配置虚幻引擎来投射彩色半透明阴影。此功能在许多应用中都很有用，常见例子就是透过彩色玻璃窗的彩色光。
UE4使用Shadow Map实现实时阴影和体积光
chen_da_le的博客
06-28 1256
自定义节点中写入以下代码i < Step;if(!
UE4阴影渲染-Shader-ShadowDepthPixelShader.usf
一个字
05-14 513
// Copyright Epic Games, Inc. All Rights Reserved. /*============================================================================= ShadowDepthPixelShader.usf: Pixel shader for writing shadow depth. =======================================================.
UE4阴影渲染-Shader-ShadowDepthVertexShader.usf
一个字
05-14 600
// Copyright Epic Games, Inc. All Rights Reserved. /*============================================================================= ShadowDepthVertexShader.usf: Vertex shader for writing shadow depth. =====================================================.
UE4-Settings:使用C ++在UE4中进行永久图形设置
05-04
5. **初始化加载（Initialization & Loading）**：游戏启动时，SettingsManager从存储位置加载设置，确保游戏以玩家上次离开时的状态运行。 6. **用户界面集成（UI Integration）**：将这些设置集成到游戏的GUI中，...
UE4蓝图翻翻乐项目
02-15
在UE4中，蓝图是一种可视化编程工具，它允许非程序员通过拖拽节点和连接线来创建逻辑，这极大地降低了游戏开发的门槛。蓝图分为Actor蓝图、Component蓝图和Function蓝图等类型，本项目中主要会用到Actor蓝图，因为它...
ue4 改变枢轴位置_UE4-构建更好的静态网格体
weixin_39999222的博客
11-22 1762
在本文中，我们会讨论包括系统单位、三角面数量、材质ID、枢轴点，我们会学习什么是光照贴图，然后介绍如何创建光照贴图。我们将学习碰撞网格体的创建和使用，细节层级或 LOD，最后介绍如何限制过度绘制。1.系统单位无论你使用哪种数字内容创建软件（DCC），创建对象前你需要先确定系统单位。本文中，我将使用 3d Studio Max，不过我涉及到的原理适用于所有数字内容创建软件。首先，我们需要确保将系统单...
Chango的数学Shader世界（十六）RayTrace三维分形（一）—— ue4中最简单的RayMarch
qq_41524721的博客
09-21 1364
目的： 最近接触一些分形Shader。自己实现了一个2D fbm，感觉很好看。然后又看到人家三维的分形，看起来很棒，心里痒痒。 影视大作和网上一堆令人惊叹的分形艺术，我也不再多说了。 本篇旨在对在ue4中实现分形的第一步，RayTrace和RayMarch加以具体解释，然后给出一个最简单的RayMarch材质，便于读者扩展。 （RayMarch一个球形“云”） 参考...
gradle-preshadow-plugin:一个 Gradle 插件，允许在编译之前 * 隐藏外部库
06-01
Preshadow Gradle 插件 Gradle 的 Preshadow 插件与插件非常相似（它实际上是基于它的），有一个很大的区别：库在编译之前会被隐藏。 您将获得一个新的“伪依赖”，其中包含所有隐藏代码，您将针对隐藏代码编写自己的源代码： 代替 import org.objectweb.asm.ClassWriter 你会写 import my.shadowed.asm.ClassWriter 如何使用 只需应用插件： buildscript { repositories { jcentral() } dependencies { classpath group:'ch.raffael.gradlePlugins.preshadow', name:'preshadow', version:'1.0' } }
Unity半透明物体+投射阴影+接受阴影
enternalstar的博客
07-31 7975
【前置】 水流动效果+透明 物体实现半透明有透明度测试和透明度混合两种方式，不同方式接受和投射阴影的方式有所差别。 【透明度测试阴影效果图】 正方体的阴影一部分打在了水平面上，一部分在白色平面上。由于透明度测试使得水平面的右半部分为完全透明，所以白色平面会接收到正方体的阴影。 水平面用的纹理贴图本身是完全不透明的物体，为了避免在透明度测试中完全透明和完全不透明的情况，用了下面的一张透明度纹理来代替水平面的透明通道 【透明度测试阴影代码】 Shader "Custom/WaterFlow
UE4 UE5 3DUI Widget半透明渲染模糊和重影问题
筱语零落的博客
06-28 9014
UE5场景中3D的半透明widget在移动或旋转时会出现重影，导致渲染效果很模糊，还有widget本身在场景中渲染比较模糊的问题。本文主要是提出对UE5中widget半透明渲染模糊和重影问题的解决方案。
UE4 小笔记
weixin_30814329的博客
04-24 379
1，设置postprocess材质时使用Add or Update Blendable 　　用Make PostprocessSetting会报警告，因为C++代码中没有设置为BlueprintReadWrite.Remove后处理材质Make 一个 没有材质的postprocesssetting再设置就行 2，Get All Actors of Class会返回指定类的所有Actor...
UE4优化流程
yanghaile的博客
04-15 418
只讨论GPU瓶颈，CPU一般是tick问题，具体根据项目代码研究。
虚幻四引擎学习之C++编程（一）
xiewenzhao123的博客
06-08 5289
最近因为ACM省赛以及参加笔试面试等原因，许久没有更新博客，由于实习公司的原因，最近开始看虚幻四引擎的官方文档，这篇博客是对官方文档中C++编程部分第一人称FPS部分的代码分析和总结。 一、GameMode GameMode又称游戏模式（其实就是翻译过来），它存在的意义是制定游戏的规则，比如龟兔赛跑，其规则就是谁先到达终点谁就获胜，它仅存在于服务器上。 在官方文档的第一人称FPS教程部分
UE4阴影初始化【2】
一个字
05-04 662
void FProjectedShadowInfo::GatherDynamicMeshElements(FSceneRenderer& Renderer, FVisibleLightInfo& VisibleLightInfo, TArray<const FSceneView*>& ReusedViewsArray, FGlobalDynamicIndexBuffer& DynamicIndexBuffer, FGlobalDynamicVertexBuff.
UE4 HTTP网络请求与蓝图可视化教程
蓝图可视化是UE4的一大特色，通过蓝图系统，开发者无需编写C++代码就能实现许多功能。在本资源中，HTTP请求功能被集成到蓝图节点中，提供了ConnectByArray、ConnectByMap和ConnectByURL等静态函数，允许开发者直观地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值