6417 lines
245 KiB
C++
6417 lines
245 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "SceneVisibility.h"
|
|
#include "SceneVisibilityPrivate.h"
|
|
#include "CoreMinimal.h"
|
|
#include "ComputeWorkerInterface.h"
|
|
#include "HAL/ThreadSafeCounter.h"
|
|
#include "Stats/Stats.h"
|
|
#include "Misc/MemStack.h"
|
|
#include "HAL/IConsoleManager.h"
|
|
#include "Misc/App.h"
|
|
#include "EngineDefines.h"
|
|
#include "EngineGlobals.h"
|
|
#include "EngineStats.h"
|
|
#include "RHIDefinitions.h"
|
|
#include "SceneTypes.h"
|
|
#include "SceneInterface.h"
|
|
#include "RendererInterface.h"
|
|
#include "PrimitiveViewRelevance.h"
|
|
#include "Materials/Material.h"
|
|
#include "MaterialShared.h"
|
|
#include "PrimitiveDrawingUtils.h"
|
|
#include "ScenePrivateBase.h"
|
|
#include "PostProcess/SceneRenderTargets.h"
|
|
#include "SceneCore.h"
|
|
#include "SceneOcclusion.h"
|
|
#include "LightSceneInfo.h"
|
|
#include "SceneRendering.h"
|
|
#include "DeferredShadingRenderer.h"
|
|
#include "DynamicPrimitiveDrawing.h"
|
|
#include "FXSystem.h"
|
|
#include "PostProcess/PostProcessing.h"
|
|
#include "SceneView.h"
|
|
#include "SkyAtmosphereRendering.h"
|
|
#include "Engine/LODActor.h"
|
|
#include "GPUScene.h"
|
|
#include "TranslucentRendering.h"
|
|
#include "TranslucentLighting.h"
|
|
#include "Async/ParallelFor.h"
|
|
#include "HairStrands/HairStrandsRendering.h"
|
|
#include "HairStrands/HairStrandsData.h"
|
|
#include "RectLightSceneProxy.h"
|
|
#include "Math/Halton.h"
|
|
#include "ProfilingDebugging/CountersTrace.h"
|
|
#include "Algo/Unique.h"
|
|
#include "InstanceCulling/InstanceCullingManager.h"
|
|
#include "InstanceCulling/InstanceCullingOcclusionQuery.h"
|
|
#include "PostProcess/TemporalAA.h"
|
|
#include "RayTracing/RayTracingInstanceCulling.h"
|
|
#include "RayTracing/RayTracing.h"
|
|
#include "HeterogeneousVolumes/HeterogeneousVolumes.h"
|
|
#include "RendererModule.h"
|
|
#include "SceneViewExtension.h"
|
|
#include "RenderCore.h"
|
|
#include "UnrealEngine.h"
|
|
#include "VT/VirtualTextureSystem.h"
|
|
#include "NaniteSceneProxy.h"
|
|
#include "ViewDebug.h"
|
|
#include "DecalRenderingCommon.h"
|
|
#include "CompositionLighting/PostProcessDeferredDecals.h"
|
|
#include "DecalRenderingShared.h"
|
|
|
|
bool GDistanceCullToSphereEdge = true;
|
|
static FAutoConsoleVariableRef CVarDistanceCullToSphereEdge(
|
|
TEXT("r.DistanceCullToSphereEdge"),
|
|
GDistanceCullToSphereEdge,
|
|
TEXT("If true frustum cull will check distance to bounding sphere edge rather than origin."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static float GWireframeCullThreshold = 5.0f;
|
|
static FAutoConsoleVariableRef CVarWireframeCullThreshold(
|
|
TEXT("r.WireframeCullThreshold"),
|
|
GWireframeCullThreshold,
|
|
TEXT("Threshold below which objects in ortho wireframe views will be culled."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
float GMinScreenRadiusForLights = 0.03f;
|
|
static FAutoConsoleVariableRef CVarMinScreenRadiusForLights(
|
|
TEXT("r.MinScreenRadiusForLights"),
|
|
GMinScreenRadiusForLights,
|
|
TEXT("Threshold below which lights will be culled."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
float GMinScreenRadiusForDepthPrepass = 0.03f;
|
|
static FAutoConsoleVariableRef CVarMinScreenRadiusForDepthPrepass(
|
|
TEXT("r.MinScreenRadiusForDepthPrepass"),
|
|
GMinScreenRadiusForDepthPrepass,
|
|
TEXT("Threshold below which meshes will be culled from depth only pass."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static TAutoConsoleVariable<int32> CVarTemporalAASamples(
|
|
TEXT("r.TemporalAASamples"),
|
|
8,
|
|
TEXT("Number of jittered positions for temporal AA (4, 8=default, 16, 32, 64)."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<int32> CVarTemporalAAScaleSamples(
|
|
TEXT("r.TemporalAAScaleSamples"),
|
|
1,
|
|
TEXT("Whether or not to scale the number of jittered positions for temporal AA when upsampling to maintain a consistent density."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<int32> CVarInvertTemporalJitterX(
|
|
TEXT("r.InvertTemporalJitterX"),
|
|
0,
|
|
TEXT("Whether or not to invert the X value of jittered positions for temporal AA."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<int32> CVarInvertTemporalJitterY(
|
|
TEXT("r.InvertTemporalJitterY"),
|
|
0,
|
|
TEXT("Whether or not to invert the Y value of jittered positions for temporal AA."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static int32 GHZBOcclusion = 0;
|
|
static FAutoConsoleVariableRef CVarHZBOcclusion(
|
|
TEXT("r.HZBOcclusion"),
|
|
GHZBOcclusion,
|
|
TEXT("Defines which occlusion system is used.\n")
|
|
TEXT(" 0: Hardware occlusion queries\n")
|
|
TEXT(" 1: Use HZB occlusion system (default, less GPU and CPU cost, more conservative results)")
|
|
TEXT(" 2: Force HZB occlusion system (overrides rendering platform preferences)"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
int32 GOcclusionFeedback_Enable = 0;
|
|
static FAutoConsoleVariableRef CVarOcclusionFeedback_Enable(
|
|
TEXT("r.OcclusionFeedback.Enable"),
|
|
GOcclusionFeedback_Enable,
|
|
TEXT("Whether to enable occlusion system based on a rendering feedback. Currently works only with a mobile rendering\n"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static int32 GVisualizeOccludedPrimitives = 0;
|
|
static FAutoConsoleVariableRef CVarVisualizeOccludedPrimitives(
|
|
TEXT("r.VisualizeOccludedPrimitives"),
|
|
GVisualizeOccludedPrimitives,
|
|
TEXT("Draw boxes for all occluded primitives.\n")
|
|
TEXT(" 0: Do not draw bounding boxes for occluded primitives (default).\n")
|
|
TEXT(" 1: Draw the primitive bounding boxes for all occluded primitives.\n")
|
|
TEXT(" 2: Draw the primitive bounding boxes for all occluded primitives after expansion. See r.Expand*BBoxes* for expansion.\n"),
|
|
ECVF_RenderThreadSafe | ECVF_Cheat
|
|
);
|
|
|
|
static int32 GVisualizePrimitiveBBoxes = 0;
|
|
static FAutoConsoleVariableRef CVarVisualizePrimitiveBBoxes(
|
|
TEXT("r.VisualizePrimitiveBBoxes"),
|
|
GVisualizePrimitiveBBoxes,
|
|
TEXT("Draw boxes for all primitives.\n")
|
|
TEXT(" 0: Do not draw bounding boxes for all primitives (default).\n")
|
|
TEXT(" 1: Draw bounding boxes only after expansion. See r.Expand*BBoxes for expansion.\n")
|
|
TEXT(" 2: Draw bounding boxes for both before expansion and after expansion."),
|
|
ECVF_RenderThreadSafe | ECVF_Cheat
|
|
);
|
|
|
|
static int32 GAllowSubPrimitiveQueries = 1;
|
|
static FAutoConsoleVariableRef CVarAllowSubPrimitiveQueries(
|
|
TEXT("r.AllowSubPrimitiveQueries"),
|
|
GAllowSubPrimitiveQueries,
|
|
TEXT("Enables sub primitive queries, currently only used by hierarchical instanced static meshes. 1: Enable, 0 Disabled. When disabled, one query is used for the entire proxy."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
RENDERER_API TAutoConsoleVariable<float> CVarStaticMeshLODDistanceScale(
|
|
TEXT("r.StaticMeshLODDistanceScale"),
|
|
1.0f,
|
|
TEXT("Scale factor for the distance used in computing discrete LOD for static meshes. (defaults to 1)\n")
|
|
TEXT("(higher values make LODs transition earlier, e.g., 2 is twice as fast / half the distance)"),
|
|
ECVF_Scalability | ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<float> CVarAutomaticViewMipBiasMin(
|
|
TEXT("r.ViewTextureMipBias.Min"),
|
|
-2.0f,
|
|
TEXT("Automatic view mip bias's minimum value (default to -2)."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<float> CVarAutomaticViewMipBiasOffset(
|
|
TEXT("r.ViewTextureMipBias.Offset"),
|
|
-0.3,
|
|
TEXT("Automatic view mip bias's constant offset (default to -0.3)."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<int32> CVarAutomaticViewMipBiasQuantization(
|
|
TEXT("r.ViewTextureMipBias.Quantization"),
|
|
1024,
|
|
TEXT("Quantization step count to use for automatic view mip bias, measured between -4.0f and 4.0f.\n")
|
|
TEXT("Lowering this can significantly reduce unique sampler states when Dynamic Resolution is active."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static int32 GILCUpdatePrimTaskEnabled = 1;
|
|
|
|
static FAutoConsoleVariableRef CVarILCUpdatePrimitivesTask(
|
|
TEXT("r.Cache.UpdatePrimsTaskEnabled"),
|
|
GILCUpdatePrimTaskEnabled,
|
|
TEXT("Enable threading for ILC primitive update. Will overlap with the rest the end of InitViews."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
int32 GEarlyInitDynamicShadows = 1;
|
|
static FAutoConsoleVariableRef CVarEarlyInitDynamicShadows(
|
|
TEXT("r.EarlyInitDynamicShadows"),
|
|
GEarlyInitDynamicShadows,
|
|
TEXT("Starts shadow culling tasks earlier in the frame."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static int32 GFramesNotOcclusionTestedToExpandBBoxes = 5;
|
|
static FAutoConsoleVariableRef CVarFramesNotOcclusionTestedToExpandBBoxes(
|
|
TEXT("r.GFramesNotOcclusionTestedToExpandBBoxes"),
|
|
GFramesNotOcclusionTestedToExpandBBoxes,
|
|
TEXT("If we don't occlusion test a primitive for this many frames, then we expand the BBox when we do occlusion test it for a few frames. See also r.ExpandNewlyOcclusionTestedBBoxesAmount, r.FramesToExpandNewlyOcclusionTestedBBoxes"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static int32 GFramesToExpandNewlyOcclusionTestedBBoxes = 2;
|
|
static FAutoConsoleVariableRef CVarFramesToExpandNewlyOcclusionTestedBBoxes(
|
|
TEXT("r.FramesToExpandNewlyOcclusionTestedBBoxes"),
|
|
GFramesToExpandNewlyOcclusionTestedBBoxes,
|
|
TEXT("If we don't occlusion test a primitive for r.GFramesNotOcclusionTestedToExpandBBoxes frames, then we expand the BBox when we do occlusion test it for this number of frames. See also r.GFramesNotOcclusionTestedToExpandBBoxes, r.ExpandNewlyOcclusionTestedBBoxesAmount"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static float GExpandNewlyOcclusionTestedBBoxesAmount = 0.0f;
|
|
static FAutoConsoleVariableRef CVarExpandNewlyOcclusionTestedBBoxesAmount(
|
|
TEXT("r.ExpandNewlyOcclusionTestedBBoxesAmount"),
|
|
GExpandNewlyOcclusionTestedBBoxesAmount,
|
|
TEXT("If we don't occlusion test a primitive for r.GFramesNotOcclusionTestedToExpandBBoxes frames, then we expand the BBox when we do occlusion test it for a few frames by this amount. See also r.FramesToExpandNewlyOcclusionTestedBBoxes, r.GFramesNotOcclusionTestedToExpandBBoxes."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static float GExpandAllTestedBBoxesAmount = 0.0f;
|
|
static FAutoConsoleVariableRef CVarExpandAllTestedBBoxesAmount(
|
|
TEXT("r.ExpandAllOcclusionTestedBBoxesAmount"),
|
|
GExpandAllTestedBBoxesAmount,
|
|
TEXT("Amount to expand all occlusion test bounds by.\n")
|
|
TEXT("This variable can be applied in conjunction with r.ExpandNewlyOcclusionTestedBBoxesScreenSpace and r.ExpandAllOcclusionTestedBBoxesScreenSpace. This variable always applies before those two.\n"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
// TODO: UE-273143 This is the start of a significant refactor in the way that objects get culled.
|
|
// The previous implementation took cvars to determine how much all bounding boxes should expand in world space.
|
|
// The current implementation extends this to expand by a screen space amount (in pixels).
|
|
// The idealized ultimate solution would take into account camera positional and/or angular velocity, over the previous n frames,
|
|
// and extrapolate to determine the size at which bboxes should expand (in the event that they are likely to become unoccluded in the next m frames).
|
|
|
|
static float GExpandNewlyOcclusionTestedBBoxesScreenSpace = 0.0f;
|
|
static FAutoConsoleVariableRef CVarExpandNewlyOcclusionTestedBBoxesScreenSpace(
|
|
TEXT("r.ExpandNewlyOcclusionTestedBBoxesScreenSpace"),
|
|
GExpandNewlyOcclusionTestedBBoxesScreenSpace,
|
|
TEXT("If we don't occlusion test a primitive for r.GFramesNotOcclusionTestedToExpandBBoxes frames, then we expand the BBox when we do occlusion test it for a few frames by this amount. See also r.FramesToExpandNewlyOcclusionTestedBBoxes, r.GFramesNotOcclusionTestedToExpandBBoxes."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static float GExpandAllTestedBBoxesScreenSpace = 0.0f;
|
|
static FAutoConsoleVariableRef CVarExpandAllTestedBBoxesScreenSpace(
|
|
TEXT("r.ExpandAllOcclusionTestedBBoxesScreenSpace"),
|
|
GExpandAllTestedBBoxesScreenSpace,
|
|
TEXT("Screen space amount in pixels to increase the occlusion test of BBoxes by.\n")
|
|
TEXT("This variable can be applied in conjunction with r.ExpandNewlyOcclusionTestedBBoxesAmount and r.ExpandAllOcclusionTestedBBoxesAmount. This variable always applies after those two.\n"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static float GNeverOcclusionTestDistance = 0.0f;
|
|
static FAutoConsoleVariableRef CVarNeverOcclusionTestDistance(
|
|
TEXT("r.NeverOcclusionTestDistance"),
|
|
GNeverOcclusionTestDistance,
|
|
TEXT("When the distance between the viewpoint and the bounding sphere center is less than this, never occlusion cull."),
|
|
ECVF_RenderThreadSafe | ECVF_Scalability
|
|
);
|
|
|
|
static int32 GForceSceneHasDecals = 0;
|
|
static FAutoConsoleVariableRef CVarForceSceneHasDecals(
|
|
TEXT("r.ForceSceneHasDecals"),
|
|
GForceSceneHasDecals,
|
|
TEXT("Whether to always assume that scene has decals, so we don't switch depth state conditionally. This can significantly reduce total number of PSOs at a minor GPU cost."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static float GCameraCutTranslationThreshold = 10000.0f;
|
|
static FAutoConsoleVariableRef CVarCameraCutTranslationThreshold(
|
|
TEXT("r.CameraCutTranslationThreshold"),
|
|
GCameraCutTranslationThreshold,
|
|
TEXT("The maximum camera translation disatance in centimeters allowed between two frames before a camera cut is automatically inserted."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
float GOverlayMaterialMaxDrawDistanceOverride = 0.0f;
|
|
static FAutoConsoleVariableRef CVarGMaterialOverlayMaxDistanceOverride(
|
|
TEXT("r.OverlayMaterialMaxDrawDistanceOverride"),
|
|
GOverlayMaterialMaxDrawDistanceOverride,
|
|
TEXT("Override the max draw distance for an Overlay Material. Any value greater than 0 will trigger the override."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
/** Distance fade cvars */
|
|
static int32 GDisableLODFade = false;
|
|
static FAutoConsoleVariableRef CVarDisableLODFade( TEXT("r.DisableLODFade"), GDisableLODFade, TEXT("Disable fading for distance culling"), ECVF_RenderThreadSafe );
|
|
|
|
static float GFadeTime = 0.25f;
|
|
static FAutoConsoleVariableRef CVarLODFadeTime( TEXT("r.LODFadeTime"), GFadeTime, TEXT("How long LOD takes to fade (in seconds)."), ECVF_RenderThreadSafe );
|
|
|
|
static float GDistanceFadeMaxTravel = 1000.0f;
|
|
static FAutoConsoleVariableRef CVarDistanceFadeMaxTravel( TEXT("r.DistanceFadeMaxTravel"), GDistanceFadeMaxTravel, TEXT("Max distance that the player can travel during the fade time."), ECVF_RenderThreadSafe );
|
|
|
|
extern int32 GVisibilitySkipAlwaysVisible;
|
|
|
|
static int32 GVisibilityTaskSchedule = 1;
|
|
static FAutoConsoleVariableRef CVarVisibilityTaskSchedule(
|
|
TEXT("r.Visibility.TaskSchedule"),
|
|
GVisibilityTaskSchedule,
|
|
TEXT("Controls how the visibility task graph is scheduled.")
|
|
TEXT("0: Work is primarily done on the render thread with the potential for parallel help;")
|
|
TEXT("1: Work is done on an async task graph (if supported by platform);"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static int32 GFrustumCullNumPrimitivesPerTask = 0;
|
|
static FAutoConsoleVariableRef CVarFrustumCullNumPrimitivesPerTask(
|
|
TEXT("r.Visibility.FrustumCull.NumPrimitivesPerTask"),
|
|
GFrustumCullNumPrimitivesPerTask,
|
|
TEXT("Assigns a fixed number of primitives for each frustum cull task.")
|
|
TEXT(" 0: Automatic;")
|
|
TEXT(">0: Fixed number of primitives per task (clamped to fixed limits);"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static bool GFrustumCullEnabled = true;
|
|
static FAutoConsoleVariableRef CVarFrustumCullEnable(
|
|
TEXT("r.Visibility.FrustumCull.Enabled"),
|
|
GFrustumCullEnabled,
|
|
TEXT("Enables frustum culling."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static bool GFrustumCullUseOctree = false;
|
|
static FAutoConsoleVariableRef CVarFrustumCullUseOctree(
|
|
TEXT("r.Visibility.FrustumCull.UseOctree"),
|
|
GFrustumCullUseOctree,
|
|
TEXT("Use the octree for visibility calculations."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static bool GFrustumCullUseSphereTestFirst = false;
|
|
static FAutoConsoleVariableRef CVarFrustumCullUseSphereTestFirst(
|
|
TEXT("r.Visibility.FrustumCull.UseSphereTestFirst"),
|
|
GFrustumCullUseSphereTestFirst,
|
|
TEXT("Performance tweak. Uses a sphere cull before and in addition to a box for frustum culling."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static bool GFrustumCullUseFastIntersect = true;
|
|
static FAutoConsoleVariableRef CVarFrustumCullUseFastIntersect(
|
|
TEXT("r.Visibility.FrustumCull.UseFastIntersect"),
|
|
GFrustumCullUseFastIntersect,
|
|
TEXT("Use optimized 8 plane fast intersection code if we have 8 permuted planes."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static int32 GOcclusionCullMaxQueriesPerTask = 0;
|
|
static FAutoConsoleVariableRef CVarOcclusionCullMaxQueriesPerTask(
|
|
TEXT("r.Visibility.OcclusionCull.MaxQueriesPerTask"),
|
|
GOcclusionCullMaxQueriesPerTask,
|
|
TEXT("Assigns a fixed number of occlusion queries for each occlusion cull task.")
|
|
TEXT(" 0: Automatic;")
|
|
TEXT(">0: Fixed number of occlusion queries per task;"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
static int32 GNumDynamicMeshElementTasks = 4;
|
|
static FAutoConsoleVariableRef CVarNumDynamicMeshElementTasks(
|
|
TEXT("r.Visibility.DynamicMeshElements.NumMainViewTasks"),
|
|
GNumDynamicMeshElementTasks,
|
|
TEXT("Controls the number of gather dynamic mesh elements tasks to run asynchronously during view visibility."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
inline uint32 GetNumDynamicMeshElementTasks()
|
|
{
|
|
if (!IsParallelGatherDynamicMeshElementsEnabled())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return FMath::Clamp<int32>(GNumDynamicMeshElementTasks, 0, LowLevelTasks::FScheduler::Get().GetNumWorkers());
|
|
}
|
|
|
|
static bool GOcclusionCullEnabled = true;
|
|
static FAutoConsoleVariableRef CVarOcclusionCullEnable(
|
|
// TODO: Move to r.Visibility.OcclusionCull.Enable. Still several explicit references.
|
|
TEXT("r.AllowOcclusionQueries"),
|
|
GOcclusionCullEnabled,
|
|
TEXT("Enables hardware occlusion culling."),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
bool DoOcclusionQueries(const FSceneViewFamily& ViewFamily)
|
|
{
|
|
return GOcclusionCullEnabled && !ViewFamily.EngineShowFlags.DisableOcclusionQueries;
|
|
}
|
|
|
|
bool FSceneRenderer::DoOcclusionQueries() const
|
|
{
|
|
return ::DoOcclusionQueries(ViewFamily);
|
|
}
|
|
|
|
static int32 GRelevanceNumPrimitivesPerPacket = 0;
|
|
static FAutoConsoleVariableRef CVarRelevanceNumPrimitivesPerPacket(
|
|
TEXT("r.Visibility.Relevance.NumPrimitivesPerPacket"),
|
|
GRelevanceNumPrimitivesPerPacket,
|
|
TEXT("Assigns a fixed number of primitives for each relevance packet.")
|
|
TEXT(" 0: Automatic;")
|
|
TEXT(">0: Fixed number of primitives per packet (clamped to fixed limits);"),
|
|
ECVF_RenderThreadSafe
|
|
);
|
|
|
|
float GLightMaxDrawDistanceScale = 1.0f;
|
|
static FAutoConsoleVariableRef CVarLightMaxDrawDistanceScale(
|
|
TEXT("r.LightMaxDrawDistanceScale"),
|
|
GLightMaxDrawDistanceScale,
|
|
TEXT("Scale applied to the MaxDrawDistance of lights. Useful for fading out local lights more aggressively on some platforms."),
|
|
ECVF_Scalability | ECVF_RenderThreadSafe
|
|
);
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
|
|
static TAutoConsoleVariable<int32> CVarTAADebugOverrideTemporalIndex(
|
|
TEXT("r.TemporalAA.Debug.OverrideTemporalIndex"), -1,
|
|
TEXT("Override the temporal index for debugging purposes."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<float> CVarFreezeTemporalSequences(
|
|
TEXT("r.Test.FreezeTemporalSequences"), 0,
|
|
TEXT("Freezes all temporal sequences."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<float> CVarFreezeTemporalHistories(
|
|
TEXT("r.Test.FreezeTemporalHistories"), 0,
|
|
TEXT("Freezes all temporal histories as well as the temporal sequence."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
static TAutoConsoleVariable<float> CVarFreezeTemporalHistoriesProgress(
|
|
TEXT("r.Test.FreezeTemporalHistories.Progress"), 0,
|
|
TEXT("Progress the temporal histories by one frame when modified."),
|
|
ECVF_RenderThreadSafe);
|
|
|
|
#endif
|
|
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_NumProcessedPrimitives, TEXT("Scene/Visibility/NumProcessedPrimitives"));
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_FrustumCull_NumCulledPrimitives, TEXT("Scene/Visibility/FrustumCull/NumCulledPrimitives"));
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_FrustumCull_NumPrimitivesPerTask, TEXT("Scene/Visibility/FrustumCull/NumPrimitivesPerTask"));
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_OcclusionCull_NumTestedQueries, TEXT("Scene/Visibility/OcclusionCull/NumTestedQueries"));
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_OcclusionCull_NumCulledPrimitives, TEXT("Scene/Visibility/OcclusionCull/NumCulledPrimitives"));
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_Relevance_NumPrimitivesPerPacket, TEXT("Scene/Visibility/Relevance/NumPrimitivesPerPacket"));
|
|
TRACE_DECLARE_INT_COUNTER(Scene_Visibility_Relevance_NumPrimitivesProcessed, TEXT("Scene/Visibility/Relevance/NumPrimitivesProcessed"));
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
IVisibilityTaskData* LaunchVisibilityTasks(FRHICommandListImmediate& RHICmdList, FSceneRenderer& SceneRenderer, const UE::Tasks::FTask& BeginInitVisibilityPrerequisites)
|
|
{
|
|
FVisibilityTaskData* TaskData = SceneRenderer.Allocator.Create<FVisibilityTaskData>(RHICmdList, SceneRenderer);
|
|
TaskData->LaunchVisibilityTasks(BeginInitVisibilityPrerequisites);
|
|
return TaskData;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool FViewInfo::IsDistanceCulled( float DistanceSquared, float MinDrawDistance, float InMaxDrawDistance, const FPrimitiveSceneInfo* PrimitiveSceneInfo)
|
|
{
|
|
bool bMayBeFading;
|
|
bool bFadingIn;
|
|
bool bDistanceCulled = IsDistanceCulled_AnyThread(DistanceSquared, MinDrawDistance, InMaxDrawDistance, PrimitiveSceneInfo, bMayBeFading, bFadingIn);
|
|
|
|
if (bMayBeFading)
|
|
{
|
|
bDistanceCulled = UpdatePrimitiveFadingState(PrimitiveSceneInfo, bFadingIn);
|
|
}
|
|
|
|
return bDistanceCulled;
|
|
}
|
|
|
|
bool FViewInfo::IsDistanceCulled_AnyThread(float DistanceSquared, float InMinDrawDistance, float InMaxDrawDistance, const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool& bOutMayBeFading, bool& bOutFadingIn) const
|
|
{
|
|
const float MaxDrawDistanceScale = GetCachedScalabilityCVars().ViewDistanceScale;
|
|
const float FadeRadius = GDisableLODFade ? 0.0f : GDistanceFadeMaxTravel;
|
|
const float MaxDrawDistance = InMaxDrawDistance * MaxDrawDistanceScale;
|
|
const float MinDrawDistance = InMinDrawDistance * MaxDrawDistanceScale;
|
|
|
|
bool bHasMaxDrawDistance = InMaxDrawDistance != FLT_MAX;
|
|
bool bHasMinDrawDistance = InMinDrawDistance > 0;
|
|
bOutMayBeFading = false;
|
|
|
|
|
|
if (!bHasMaxDrawDistance && !bHasMinDrawDistance)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If cull distance is disabled, always show (except foliage)
|
|
if (Family->EngineShowFlags.DistanceCulledPrimitives && !PrimitiveSceneInfo->Proxy->IsDetailMesh())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// The primitive is always culled if it exceeds the max fade distance.
|
|
if ((bHasMaxDrawDistance && DistanceSquared > FMath::Square(MaxDrawDistance + FadeRadius)) || (bHasMinDrawDistance && DistanceSquared < FMath::Square(MinDrawDistance)))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
const bool bDistanceCulled = bHasMaxDrawDistance && (DistanceSquared > FMath::Square(MaxDrawDistance));
|
|
const bool bMayBeFading = bHasMaxDrawDistance && (DistanceSquared > FMath::Square(MaxDrawDistance - FadeRadius));
|
|
|
|
if (!GDisableLODFade && bMayBeFading && State != NULL && !bDisableDistanceBasedFadeTransitions && PrimitiveSceneInfo->Proxy->IsUsingDistanceCullFade())
|
|
{
|
|
// Don't update primitive fading state yet because current thread may be not render thread
|
|
bOutMayBeFading = true;
|
|
bOutFadingIn = !bDistanceCulled;
|
|
}
|
|
|
|
return bDistanceCulled && !bOutMayBeFading;
|
|
}
|
|
|
|
inline bool IntersectBox8Plane(const FVector& InOrigin, const FVector& InExtent, const FPlane*PermutedPlanePtr)
|
|
{
|
|
// this removes a lot of the branches as we know there's 8 planes
|
|
// copied directly out of ConvexVolume.cpp
|
|
const VectorRegister Origin = VectorLoadFloat3(&InOrigin);
|
|
const VectorRegister Extent = VectorLoadFloat3(&InExtent);
|
|
|
|
const VectorRegister PlanesX_0 = VectorLoadAligned(&PermutedPlanePtr[0]);
|
|
const VectorRegister PlanesY_0 = VectorLoadAligned(&PermutedPlanePtr[1]);
|
|
const VectorRegister PlanesZ_0 = VectorLoadAligned(&PermutedPlanePtr[2]);
|
|
const VectorRegister PlanesW_0 = VectorLoadAligned(&PermutedPlanePtr[3]);
|
|
|
|
const VectorRegister PlanesX_1 = VectorLoadAligned(&PermutedPlanePtr[4]);
|
|
const VectorRegister PlanesY_1 = VectorLoadAligned(&PermutedPlanePtr[5]);
|
|
const VectorRegister PlanesZ_1 = VectorLoadAligned(&PermutedPlanePtr[6]);
|
|
const VectorRegister PlanesW_1 = VectorLoadAligned(&PermutedPlanePtr[7]);
|
|
|
|
// Splat origin into 3 vectors
|
|
VectorRegister OrigX = VectorReplicate(Origin, 0);
|
|
VectorRegister OrigY = VectorReplicate(Origin, 1);
|
|
VectorRegister OrigZ = VectorReplicate(Origin, 2);
|
|
// Splat the already abs Extent for the push out calculation
|
|
VectorRegister AbsExtentX = VectorReplicate(Extent, 0);
|
|
VectorRegister AbsExtentY = VectorReplicate(Extent, 1);
|
|
VectorRegister AbsExtentZ = VectorReplicate(Extent, 2);
|
|
|
|
// Calculate the distance (x * x) + (y * y) + (z * z) - w
|
|
VectorRegister DistX_0 = VectorMultiply(OrigX, PlanesX_0);
|
|
VectorRegister DistY_0 = VectorMultiplyAdd(OrigY, PlanesY_0, DistX_0);
|
|
VectorRegister DistZ_0 = VectorMultiplyAdd(OrigZ, PlanesZ_0, DistY_0);
|
|
VectorRegister Distance_0 = VectorSubtract(DistZ_0, PlanesW_0);
|
|
// Now do the push out FMath::Abs(x * x) + FMath::Abs(y * y) + FMath::Abs(z * z)
|
|
VectorRegister PushX_0 = VectorMultiply(AbsExtentX, VectorAbs(PlanesX_0));
|
|
VectorRegister PushY_0 = VectorMultiplyAdd(AbsExtentY, VectorAbs(PlanesY_0), PushX_0);
|
|
VectorRegister PushOut_0 = VectorMultiplyAdd(AbsExtentZ, VectorAbs(PlanesZ_0), PushY_0);
|
|
|
|
// Check for completely outside
|
|
if (VectorAnyGreaterThan(Distance_0, PushOut_0))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Calculate the distance (x * x) + (y * y) + (z * z) - w
|
|
VectorRegister DistX_1 = VectorMultiply(OrigX, PlanesX_1);
|
|
VectorRegister DistY_1 = VectorMultiplyAdd(OrigY, PlanesY_1, DistX_1);
|
|
VectorRegister DistZ_1 = VectorMultiplyAdd(OrigZ, PlanesZ_1, DistY_1);
|
|
VectorRegister Distance_1 = VectorSubtract(DistZ_1, PlanesW_1);
|
|
// Now do the push out FMath::Abs(x * x) + FMath::Abs(y * y) + FMath::Abs(z * z)
|
|
VectorRegister PushX_1 = VectorMultiply(AbsExtentX, VectorAbs(PlanesX_1));
|
|
VectorRegister PushY_1 = VectorMultiplyAdd(AbsExtentY, VectorAbs(PlanesY_1), PushX_1);
|
|
VectorRegister PushOut_1 = VectorMultiplyAdd(AbsExtentZ, VectorAbs(PlanesZ_1), PushY_1);
|
|
|
|
// Check for completely outside
|
|
if (VectorAnyGreaterThan(Distance_1, PushOut_1))
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
struct FFrustumCullingFlags
|
|
{
|
|
bool bShouldVisibilityCull;
|
|
bool bUseCustomCulling;
|
|
bool bUseSphereTestFirst;
|
|
bool bUseFastIntersect;
|
|
bool bUseVisibilityOctree;
|
|
bool bHasHiddenPrimitives;
|
|
bool bHasShowOnlyPrimitives;
|
|
};
|
|
|
|
// Returns true if the frustum and bounds intersect
|
|
inline bool IsPrimitiveVisible(FViewInfo& View, const FPlane* PermutedPlanePtr, const FConvexVolume& ViewCullingFrustum, const FPrimitiveBounds& Bounds, int32 VisibilityId, FFrustumCullingFlags Flags)
|
|
{
|
|
// The custom culling and sphere culling are additional tests, meaning that if they pass, the
|
|
// remaining culling tests will still be performed. If any of the tests fail, then the primitive
|
|
// is culled, and the remaining tests do not need be performed
|
|
|
|
if (Flags.bUseCustomCulling && !View.CustomVisibilityQuery->IsVisible(VisibilityId, FBoxSphereBounds(Bounds.BoxSphereBounds.Origin, Bounds.BoxSphereBounds.BoxExtent, Bounds.BoxSphereBounds.SphereRadius)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (Flags.bUseSphereTestFirst && !ViewCullingFrustum.IntersectSphere(Bounds.BoxSphereBounds.Origin, Bounds.BoxSphereBounds.SphereRadius))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (Flags.bUseFastIntersect)
|
|
{
|
|
return IntersectBox8Plane(Bounds.BoxSphereBounds.Origin, Bounds.BoxSphereBounds.BoxExtent, PermutedPlanePtr);
|
|
}
|
|
else
|
|
{
|
|
return ViewCullingFrustum.IntersectBox(Bounds.BoxSphereBounds.Origin, Bounds.BoxSphereBounds.BoxExtent);
|
|
}
|
|
}
|
|
|
|
inline bool IsPrimitiveHidden(const FScene& Scene, FViewInfo& View, int32 PrimitiveIndex, FFrustumCullingFlags Flags)
|
|
{
|
|
// If any primitives are explicitly hidden, remove them now.
|
|
if (Flags.bHasHiddenPrimitives && View.HiddenPrimitives.Contains(Scene.PrimitiveComponentIds[PrimitiveIndex]))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// If the view has any show only primitives, hide everything else
|
|
if (Flags.bHasShowOnlyPrimitives && !View.ShowOnlyPrimitives->Contains(Scene.PrimitiveComponentIds[PrimitiveIndex]))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#if RHI_RAYTRACING
|
|
|
|
inline bool ShouldCullForRayTracing(const FScene& Scene, FViewInfo& View, int32 PrimitiveIndex)
|
|
{
|
|
const FRayTracingCullingParameters& RayTracingCullingParameters = View.RayTracingCullingParameters;
|
|
|
|
if (RayTracing::CullPrimitiveByFlags(RayTracingCullingParameters, &Scene, PrimitiveIndex))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
const bool bIsFarFieldPrimitive = EnumHasAnyFlags(Scene.PrimitiveRayTracingFlags[PrimitiveIndex], ERayTracingPrimitiveFlags::FarField);
|
|
const Experimental::FHashElementId GroupId = Scene.PrimitiveRayTracingGroupIds[PrimitiveIndex];
|
|
|
|
if (RayTracingCullingParameters.bCullUsingGroupIds && GroupId.IsValid())
|
|
{
|
|
const FBoxSphereBounds& GroupBounds = Scene.PrimitiveRayTracingGroups.GetByElementId(GroupId).Value.Bounds;
|
|
const float GroupMinDrawDistance = Scene.PrimitiveRayTracingGroups.GetByElementId(GroupId).Value.MinDrawDistance;
|
|
return RayTracing::ShouldCullBounds(RayTracingCullingParameters, GroupBounds, GroupMinDrawDistance, bIsFarFieldPrimitive);
|
|
}
|
|
else
|
|
{
|
|
const FPrimitiveBounds& RESTRICT Bounds = Scene.PrimitiveBounds[PrimitiveIndex];
|
|
return RayTracing::ShouldCullBounds(RayTracingCullingParameters, Bounds.BoxSphereBounds, Bounds.MinDrawDistance, bIsFarFieldPrimitive);
|
|
}
|
|
};
|
|
#endif //RHI_RAYTRACING
|
|
|
|
inline void ComputeDistances(const FPrimitiveBounds& Bounds, const FVector& ViewOriginForDistanceCulling, float& OutClosestDistSq, float& OutFurthestDistSq)
|
|
{
|
|
float Dist = (Bounds.BoxSphereBounds.Origin - ViewOriginForDistanceCulling).Length();
|
|
float ClosestDist = Dist - Bounds.BoxSphereBounds.SphereRadius;
|
|
float FurthestDist = Dist + Bounds.BoxSphereBounds.SphereRadius;
|
|
|
|
OutClosestDistSq = Dist >= Bounds.BoxSphereBounds.SphereRadius ? FMath::Square(ClosestDist) : 0;
|
|
OutFurthestDistSq = FMath::Square(FurthestDist);
|
|
}
|
|
|
|
static void CullOctree(const FScene& Scene, FViewInfo& View, const FFrustumCullingFlags& Flags, FSceneBitArray& OutVisibleNodes, const FConvexVolume& ViewCullingFrustum)
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(SceneVisibility_CullOctree);
|
|
|
|
// Two bits per octree node, 1st bit is Inside Frustum, 2nd bit is Outside Frustum
|
|
OutVisibleNodes.Init(false, Scene.PrimitiveOctree.GetNumNodes() * 2);
|
|
|
|
Scene.PrimitiveOctree.FindNodesWithPredicate(
|
|
[&View, &OutVisibleNodes, &Flags, &ViewCullingFrustum](FScenePrimitiveOctree::FNodeIndex ParentNodeIndex, FScenePrimitiveOctree::FNodeIndex NodeIndex, const FBoxCenterAndExtent& NodeBounds)
|
|
{
|
|
// If the parent node is completely contained there is no need to test containment
|
|
if (ParentNodeIndex != INDEX_NONE && !OutVisibleNodes[(ParentNodeIndex * 2) + 1])
|
|
{
|
|
OutVisibleNodes[NodeIndex * 2] = true;
|
|
OutVisibleNodes[NodeIndex * 2 + 1] = false;
|
|
return true;
|
|
}
|
|
|
|
const FPlane* PermutedPlanePtr = ViewCullingFrustum.PermutedPlanes.GetData();
|
|
bool bIntersects = false;
|
|
|
|
if (Flags.bUseFastIntersect)
|
|
{
|
|
bIntersects = IntersectBox8Plane(NodeBounds.Center, NodeBounds.Extent, PermutedPlanePtr);
|
|
}
|
|
else
|
|
{
|
|
bIntersects = ViewCullingFrustum.IntersectBox(NodeBounds.Center, NodeBounds.Extent);
|
|
}
|
|
|
|
if (bIntersects)
|
|
{
|
|
OutVisibleNodes[NodeIndex * 2] = true;
|
|
OutVisibleNodes[NodeIndex * 2 + 1] = ViewCullingFrustum.GetBoxIntersectionOutcode(NodeBounds.Center, NodeBounds.Extent).GetOutside();
|
|
}
|
|
|
|
return bIntersects;
|
|
},
|
|
[](FScenePrimitiveOctree::FNodeIndex /*ParentNodeIndex*/, FScenePrimitiveOctree::FNodeIndex /*NodeIndex*/, const FBoxCenterAndExtent& /*NodeBounds*/)
|
|
{
|
|
|
|
});
|
|
}
|
|
|
|
static void UpdateAlwaysVisible(const FScene& Scene, FViewInfo& View, FFrustumCullingFlags Flags, const FVisibilityTaskConfig& TaskConfig, int32 TaskIndex, float CurrentWorldTime)
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_AlwaysVisible_Loop);
|
|
|
|
check(Scene.PrimitivesAlwaysVisibleOffset != ~0u);
|
|
const int32 BitArrayNumInner = TaskConfig.NumVisiblePrimitives;
|
|
const int32 StartWord = int32(Scene.PrimitivesAlwaysVisibleOffset) / NumBitsPerDWORD;
|
|
const int32 TaskWordOffset = TaskIndex * TaskConfig.AlwaysVisible.NumWordsPerTask;
|
|
|
|
uint32* RESTRICT VisWords = View.PrimitiveVisibilityMap.GetData();
|
|
#if RHI_RAYTRACING
|
|
uint32* RESTRICT RTWords = View.PrimitiveRayTracingVisibilityMap.GetData();
|
|
|
|
const bool bRayTracingEnabled = IsRayTracingEnabled(View.GetShaderPlatform()) && View.IsRayTracingAllowedForView();
|
|
#endif
|
|
|
|
for (int32 WordIndex = TaskWordOffset; WordIndex < TaskWordOffset + int32(TaskConfig.AlwaysVisible.NumWordsPerTask) && WordIndex * NumBitsPerDWORD < BitArrayNumInner; ++WordIndex)
|
|
{
|
|
uint32 Mask = 0x1;
|
|
|
|
uint32 VisBits = 0;
|
|
#if RHI_RAYTRACING
|
|
uint32 RayTracingBits = 0;
|
|
#endif
|
|
|
|
for (int32 BitSubIndex = 0; BitSubIndex < NumBitsPerDWORD && WordIndex * NumBitsPerDWORD + BitSubIndex < BitArrayNumInner; ++BitSubIndex, Mask <<= 1)
|
|
{
|
|
const int32 Index = (StartWord + WordIndex) * NumBitsPerDWORD + BitSubIndex;
|
|
VisBits |= Mask;
|
|
|
|
#if RHI_RAYTRACING
|
|
if (bRayTracingEnabled && !IsPrimitiveHidden(Scene, View, Index, Flags) && !ShouldCullForRayTracing(Scene, View, Index))
|
|
{
|
|
RayTracingBits |= Mask;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
VisWords[StartWord + WordIndex] = VisBits;
|
|
|
|
#if RHI_RAYTRACING
|
|
if (RayTracingBits)
|
|
{
|
|
RTWords[StartWord + WordIndex] = RayTracingBits;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static int32 FrustumCull(const FScene& Scene, FViewInfo& View, FFrustumCullingFlags Flags, float MaxDrawDistanceScale, const FHLODVisibilityState* const HLODState, const FSceneBitArray* VisibleNodes, const FVisibilityTaskConfig& TaskConfig, int32 TaskIndex)
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_FrustumCull_Loop);
|
|
|
|
bool bDisableLODFade = GDisableLODFade || View.bDisableDistanceBasedFadeTransitions;
|
|
const FPlane* PermutedPlanePtr = View.GetCullingFrustum().PermutedPlanes.GetData();
|
|
const FConvexVolume& ViewCullingFrustum = View.GetCullingFrustum();
|
|
FVector ViewOriginForDistanceCulling = View.CullingOrigin;
|
|
float FadeRadius = bDisableLODFade ? 0.0f : GDistanceFadeMaxTravel;
|
|
uint8 CustomVisibilityFlags = EOcclusionFlags::CanBeOccluded | EOcclusionFlags::HasPrecomputedVisibility;
|
|
|
|
int32 BitArrayNumInner = TaskConfig.NumTestedPrimitives;
|
|
|
|
uint32 NumPrimitivesCulledForTask = 0;
|
|
|
|
// Primitives may be explicitly removed from stereo views when using mono
|
|
const int32 TaskWordOffset = TaskIndex * TaskConfig.FrustumCull.NumWordsPerTask;
|
|
|
|
uint32* RESTRICT VisWords = View.PrimitiveVisibilityMap.GetData();
|
|
uint32* RESTRICT FadeWords = View.PotentiallyFadingPrimitiveMap.GetData();
|
|
#if RHI_RAYTRACING
|
|
uint32* RESTRICT RTWords = View.PrimitiveRayTracingVisibilityMap.GetData();
|
|
|
|
const bool bRayTracingEnabled = IsRayTracingEnabled(View.GetShaderPlatform()) && View.IsRayTracingAllowedForView();
|
|
#endif
|
|
|
|
for (int32 WordIndex = TaskWordOffset; WordIndex < TaskWordOffset + int32(TaskConfig.FrustumCull.NumWordsPerTask) && WordIndex * NumBitsPerDWORD < BitArrayNumInner; WordIndex++)
|
|
{
|
|
uint32 Mask = 0x1;
|
|
uint32 VisBits = 0;
|
|
uint32 FadingBits = 0;
|
|
#if RHI_RAYTRACING
|
|
uint32 RayTracingBits = 0;
|
|
#endif
|
|
|
|
// If visibility culling is disabled, make sure to use the existing visibility state
|
|
if (!Flags.bShouldVisibilityCull)
|
|
{
|
|
VisBits = VisWords[WordIndex];
|
|
}
|
|
|
|
for (int32 BitSubIndex = 0; BitSubIndex < NumBitsPerDWORD && WordIndex * NumBitsPerDWORD + BitSubIndex < BitArrayNumInner; BitSubIndex++, Mask <<= 1)
|
|
{
|
|
int32 Index = WordIndex * NumBitsPerDWORD + BitSubIndex;
|
|
bool bPrimitiveIsHidden = IsPrimitiveHidden(Scene, View, Index, Flags);
|
|
bool bIsVisible = Flags.bShouldVisibilityCull ? true : (VisBits & Mask) == Mask;
|
|
|
|
bIsVisible = bIsVisible && !bPrimitiveIsHidden;
|
|
|
|
#if RHI_RAYTRACING
|
|
bool bIsVisibleInRayTracing = true;
|
|
|
|
if (bPrimitiveIsHidden || !bRayTracingEnabled || ShouldCullForRayTracing(Scene, View, Index))
|
|
{
|
|
bIsVisibleInRayTracing = false;
|
|
}
|
|
#endif
|
|
|
|
const FPrimitiveBounds& RESTRICT Bounds = Scene.PrimitiveBounds[Index];
|
|
|
|
// Zero sized bounds indicates that we are not visible.
|
|
bIsVisible &= Bounds.BoxSphereBounds.SphereRadius > 0;
|
|
|
|
if (Flags.bShouldVisibilityCull && bIsVisible)
|
|
{
|
|
bool bShouldDistanceCull = true;
|
|
bool bPartiallyOutside = true;
|
|
bool bShouldFrustumCull = true;
|
|
|
|
// Fading HLODs and their children must be visible, objects hidden by HLODs can be culled
|
|
if (HLODState)
|
|
{
|
|
if (HLODState->IsNodeForcedVisible(Index))
|
|
{
|
|
bShouldDistanceCull = false;
|
|
}
|
|
else if (HLODState->IsNodeForcedHidden(Index))
|
|
{
|
|
bIsVisible = false;
|
|
}
|
|
}
|
|
|
|
// Frustum first
|
|
bShouldFrustumCull = bShouldFrustumCull && bIsVisible;
|
|
if (bShouldFrustumCull)
|
|
{
|
|
if (Flags.bUseVisibilityOctree)
|
|
{
|
|
// If the parent octree node was completely contained by the frustum, there is no need do an additional frustum test on the primitive bounds
|
|
// If the parent octree node is partially in the frustum, perform an additional test on the primitive bounds
|
|
uint32 OctreeNodeIndex = Scene.PrimitiveOctreeIndex[Index];
|
|
|
|
bIsVisible = (*VisibleNodes)[OctreeNodeIndex * 2];
|
|
bPartiallyOutside = (*VisibleNodes)[OctreeNodeIndex * 2 + 1];
|
|
}
|
|
|
|
if (bIsVisible)
|
|
{
|
|
int32 VisibilityId = INDEX_NONE;
|
|
|
|
if (Flags.bUseCustomCulling &&
|
|
((Scene.PrimitiveOcclusionFlags[Index] & CustomVisibilityFlags) == CustomVisibilityFlags))
|
|
{
|
|
VisibilityId = Scene.PrimitiveSceneProxies[Index]->GetVisibilityId();
|
|
}
|
|
|
|
bIsVisible = !bPartiallyOutside || IsPrimitiveVisible(View, PermutedPlanePtr, ViewCullingFrustum, Bounds, VisibilityId, Flags);
|
|
}
|
|
}
|
|
|
|
// Distance cull if frustum cull passed
|
|
bShouldDistanceCull = bShouldDistanceCull && bIsVisible;
|
|
if (bShouldDistanceCull)
|
|
{
|
|
// If cull distance is disabled, always show the primitive (except foliage)
|
|
if (View.Family->EngineShowFlags.DistanceCulledPrimitives
|
|
&& !Scene.PrimitiveSceneProxies[Index]->IsDetailMesh()) // Proxy call is intentionally behind the DistancedCulledPrimitives check to prevent an expensive memory read
|
|
{
|
|
bShouldDistanceCull = false;
|
|
}
|
|
}
|
|
|
|
if (bShouldDistanceCull)
|
|
{
|
|
// Preserve infinite draw distance
|
|
bool bHasMaxDrawDistance = Bounds.MaxCullDistance < FLT_MAX;
|
|
bool bHasMinDrawDistance = Bounds.MinDrawDistance > 0;
|
|
|
|
if (bHasMaxDrawDistance || bHasMinDrawDistance)
|
|
{
|
|
float MaxDrawDistance = Bounds.MaxCullDistance * MaxDrawDistanceScale;
|
|
float MinDrawDistanceSq = FMath::Square(Bounds.MinDrawDistance * MaxDrawDistanceScale);
|
|
float ClosestDistSquared, FurthestDistSquared;
|
|
|
|
if (GDistanceCullToSphereEdge)
|
|
{
|
|
ComputeDistances(Bounds, ViewOriginForDistanceCulling, ClosestDistSquared, FurthestDistSquared);
|
|
}
|
|
else
|
|
{
|
|
ClosestDistSquared = FurthestDistSquared = FVector::DistSquared(Bounds.BoxSphereBounds.Origin, ViewOriginForDistanceCulling);
|
|
}
|
|
|
|
// Always test the fade in distance. If a primitive was set to always draw, it may need to be faded in.
|
|
if (bHasMaxDrawDistance)
|
|
{
|
|
float MaxFadeDistanceSquared = FMath::Square(MaxDrawDistance + FadeRadius);
|
|
float MinFadeDistanceSquared = FMath::Square(MaxDrawDistance - FadeRadius);
|
|
if ((ClosestDistSquared < MaxFadeDistanceSquared && ClosestDistSquared > MinFadeDistanceSquared)
|
|
&& Scene.PrimitiveSceneProxies[Index]->IsUsingDistanceCullFade()) // Proxy call is intentionally behind the fade check to prevent an expensive memory read
|
|
{
|
|
FadingBits |= Mask;
|
|
}
|
|
}
|
|
|
|
// Check for distance culling first
|
|
const bool bFarDistanceCulled = bHasMaxDrawDistance && (ClosestDistSquared > FMath::Square(MaxDrawDistance));
|
|
const bool bNearDistanceCulled = bHasMinDrawDistance && (FurthestDistSquared < MinDrawDistanceSq);
|
|
|
|
bool bIsDistanceCulled = bNearDistanceCulled || bFarDistanceCulled;
|
|
|
|
if (bIsDistanceCulled)
|
|
{
|
|
bIsVisible = false;
|
|
}
|
|
|
|
#if RHI_RAYTRACING
|
|
if (bFarDistanceCulled)
|
|
{
|
|
bIsVisibleInRayTracing = false;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bIsVisible)
|
|
{
|
|
// The primitive is visible!
|
|
VisBits |= Mask;
|
|
}
|
|
else
|
|
{
|
|
++NumPrimitivesCulledForTask;
|
|
}
|
|
|
|
#if RHI_RAYTRACING
|
|
if (bIsVisibleInRayTracing)
|
|
{
|
|
RayTracingBits |= Mask;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (Flags.bShouldVisibilityCull && FadingBits)
|
|
{
|
|
FadeWords[WordIndex] = FadingBits;
|
|
}
|
|
|
|
if (Flags.bShouldVisibilityCull && VisBits)
|
|
{
|
|
VisWords[WordIndex] = VisBits;
|
|
}
|
|
|
|
#if RHI_RAYTRACING
|
|
if (RayTracingBits)
|
|
{
|
|
RTWords[WordIndex] = RayTracingBits;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return NumPrimitivesCulledForTask;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void ClearStalePrimitiveFadingStates(FViewInfo& View, FSceneViewState* ViewState)
|
|
{
|
|
if (!ViewState)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const uint32 PrevFrameNumber = ViewState->PrevFrameNumber;
|
|
const float CurrentRealTime = View.Family->Time.GetRealTimeSeconds();
|
|
|
|
// First clear any stale fading states.
|
|
for (FPrimitiveFadingStateMap::TIterator It(ViewState->PrimitiveFadingStates); It; ++It)
|
|
{
|
|
FPrimitiveFadingState& FadingState = It.Value();
|
|
if (FadingState.FrameNumber != PrevFrameNumber ||
|
|
(IsValidRef(FadingState.UniformBuffer) && CurrentRealTime >= FadingState.EndTime))
|
|
{
|
|
It.RemoveCurrent();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void UpdatePrimitiveFadingStateHelper(FPrimitiveFadingState& FadingState, const FViewInfo& View, bool bVisible)
|
|
{
|
|
if (FadingState.bValid)
|
|
{
|
|
if (FadingState.bIsVisible != bVisible)
|
|
{
|
|
float CurrentRealTime = View.Family->Time.GetRealTimeSeconds();
|
|
|
|
// Need to kick off a fade, so make sure that we have fading state for that
|
|
if (!IsValidRef(FadingState.UniformBuffer))
|
|
{
|
|
// Primitive is not currently fading. Start a new fade!
|
|
FadingState.EndTime = CurrentRealTime + GFadeTime;
|
|
|
|
if (bVisible)
|
|
{
|
|
// Fading in
|
|
// (Time - StartTime) / FadeTime
|
|
FadingState.FadeTimeScaleBias.X = 1.0f / GFadeTime;
|
|
FadingState.FadeTimeScaleBias.Y = -CurrentRealTime / GFadeTime;
|
|
}
|
|
else
|
|
{
|
|
// Fading out
|
|
// 1 - (Time - StartTime) / FadeTime
|
|
FadingState.FadeTimeScaleBias.X = -1.0f / GFadeTime;
|
|
FadingState.FadeTimeScaleBias.Y = 1.0f + CurrentRealTime / GFadeTime;
|
|
}
|
|
|
|
FDistanceCullFadeUniformShaderParameters Uniforms;
|
|
Uniforms.FadeTimeScaleBias = FVector2f(FadingState.FadeTimeScaleBias); // LWC_TODO: Precision loss
|
|
FadingState.UniformBuffer = FDistanceCullFadeUniformBufferRef::CreateUniformBufferImmediate(Uniforms, UniformBuffer_MultiFrame);
|
|
}
|
|
else
|
|
{
|
|
// Reverse fading direction but maintain current opacity
|
|
// Solve for d: a*x+b = -a*x+d
|
|
FadingState.FadeTimeScaleBias.Y = 2.0f * CurrentRealTime * FadingState.FadeTimeScaleBias.X + FadingState.FadeTimeScaleBias.Y;
|
|
FadingState.FadeTimeScaleBias.X = -FadingState.FadeTimeScaleBias.X;
|
|
|
|
if (bVisible)
|
|
{
|
|
// Fading in
|
|
// Solve for x: a*x+b = 1
|
|
FadingState.EndTime = (1.0f - FadingState.FadeTimeScaleBias.Y) / FadingState.FadeTimeScaleBias.X;
|
|
}
|
|
else
|
|
{
|
|
// Fading out
|
|
// Solve for x: a*x+b = 0
|
|
FadingState.EndTime = -FadingState.FadeTimeScaleBias.Y / FadingState.FadeTimeScaleBias.X;
|
|
}
|
|
|
|
FDistanceCullFadeUniformShaderParameters Uniforms;
|
|
Uniforms.FadeTimeScaleBias = FVector2f(FadingState.FadeTimeScaleBias); // LWC_TODO: Precision loss
|
|
FadingState.UniformBuffer = FDistanceCullFadeUniformBufferRef::CreateUniformBufferImmediate(Uniforms, UniformBuffer_MultiFrame);
|
|
}
|
|
}
|
|
}
|
|
|
|
FadingState.FrameNumber = View.Family->FrameNumber;
|
|
FadingState.bIsVisible = bVisible;
|
|
FadingState.bValid = true;
|
|
}
|
|
|
|
static void UpdatePrimitiveFading(const FScene& Scene, FViewInfo& View, FSceneViewState* ViewState, FPrimitiveRange PrimitiveRange)
|
|
{
|
|
if (!ViewState)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SCOPE_CYCLE_COUNTER(STAT_UpdatePrimitiveFading);
|
|
|
|
#if RHI_RAYTRACING
|
|
const bool bRayTracingEnabled = IsRayTracingEnabled(View.GetShaderPlatform()) && View.IsRayTracingAllowedForView();
|
|
#endif
|
|
|
|
// Should we allow fading transitions at all this frame? For frames where the camera moved
|
|
// a large distance or where we haven't rendered a view in awhile, it's best to disable
|
|
// fading so users don't see unexpected object transitions.
|
|
if (!GDisableLODFade && !View.bDisableDistanceBasedFadeTransitions)
|
|
{
|
|
// Do a pass over potentially fading primitives and update their states.
|
|
for (FSceneSetBitIterator BitIt(View.PotentiallyFadingPrimitiveMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
bool bVisible = View.PrimitiveVisibilityMap.AccessCorrespondingBit(BitIt);
|
|
FPrimitiveFadingState& FadingState = ViewState->PrimitiveFadingStates.FindOrAdd(Scene.PrimitiveComponentIds[BitIt.GetIndex()]);
|
|
UpdatePrimitiveFadingStateHelper(FadingState, View, bVisible);
|
|
FRHIUniformBuffer* UniformBuffer = FadingState.UniformBuffer;
|
|
if (UniformBuffer && !bVisible)
|
|
{
|
|
// If the primitive is fading out make sure it remains visible.
|
|
View.PrimitiveVisibilityMap.AccessCorrespondingBit(BitIt) = true;
|
|
|
|
#if RHI_RAYTRACING
|
|
// Cannot just assume the ray tracing visibility will be true, so a complete recalculation for its culling needs to happen
|
|
// This should be a very rare occurrence, so the hit is not worrisome.
|
|
// TODO: Could this be moved into the actual culling phase?
|
|
|
|
if (bRayTracingEnabled && !ShouldCullForRayTracing(Scene, View, BitIt.GetIndex()))
|
|
{
|
|
View.PrimitiveRayTracingVisibilityMap.AccessCorrespondingBit(BitIt) = true;
|
|
}
|
|
#endif
|
|
}
|
|
View.PrimitiveFadeUniformBuffers[BitIt.GetIndex()] = UniformBuffer;
|
|
View.PrimitiveFadeUniformBufferMap[BitIt.GetIndex()] = UniformBuffer != nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FViewInfo::UpdatePrimitiveFadingState(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bFadingIn)
|
|
{
|
|
// Update distance-based visibility and fading state if it has not already been updated.
|
|
const int32 PrimitiveIndex = PrimitiveSceneInfo->GetIndex();
|
|
const FRelativeBitReference PrimitiveBit(PrimitiveIndex);
|
|
bool bStillFading = false;
|
|
|
|
if (!PotentiallyFadingPrimitiveMap.AccessCorrespondingBit(PrimitiveBit))
|
|
{
|
|
FPrimitiveFadingState& FadingState = ((FSceneViewState*)State)->PrimitiveFadingStates.FindOrAdd(PrimitiveSceneInfo->PrimitiveComponentId);
|
|
UpdatePrimitiveFadingStateHelper(FadingState, *this, bFadingIn);
|
|
FRHIUniformBuffer* UniformBuffer = FadingState.UniformBuffer;
|
|
bStillFading = UniformBuffer != nullptr;
|
|
PrimitiveFadeUniformBuffers[PrimitiveIndex] = UniformBuffer;
|
|
PrimitiveFadeUniformBufferMap[PrimitiveIndex] = UniformBuffer != nullptr;
|
|
PotentiallyFadingPrimitiveMap.AccessCorrespondingBit(PrimitiveBit) = true;
|
|
}
|
|
|
|
// If we're still fading then make sure the object is still drawn, even if it's beyond the max draw distance
|
|
return !bFadingIn && !bStillFading;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FFilterStaticMeshesForViewData::FFilterStaticMeshesForViewData(FViewInfo& View)
|
|
{
|
|
ViewOrigin = View.ViewMatrices.GetViewOrigin();
|
|
|
|
// outside of the loop to be more efficient
|
|
ForcedLODLevel = (View.Family->EngineShowFlags.LOD) ? GetCVarForceLOD() : 0;
|
|
|
|
LODScale = CVarStaticMeshLODDistanceScale.GetValueOnRenderThread() * View.LODDistanceFactor;
|
|
|
|
MinScreenRadiusForDepthPrepassSquared = GMinScreenRadiusForDepthPrepass * GMinScreenRadiusForDepthPrepass;
|
|
|
|
bFullEarlyZPass = ShouldForceFullDepthPass(View.GetShaderPlatform());
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FDrawCommandRelevancePacket::FDrawCommandRelevancePacket()
|
|
{
|
|
bUseCachedMeshDrawCommands = UseCachedMeshDrawCommands();
|
|
|
|
for (int32 PassIndex = 0; PassIndex < EMeshPass::Num; ++PassIndex)
|
|
{
|
|
NumDynamicBuildRequestElements[PassIndex] = 0;
|
|
}
|
|
}
|
|
|
|
void FDrawCommandRelevancePacket::AddCommandsForMesh(
|
|
int32 PrimitiveIndex,
|
|
const FPrimitiveSceneInfo* InPrimitiveSceneInfo,
|
|
const FStaticMeshBatchRelevance& RESTRICT StaticMeshRelevance,
|
|
const FStaticMeshBatch& RESTRICT StaticMesh,
|
|
EMeshDrawCommandCullingPayloadFlags CullingPayloadFlags,
|
|
const FScene& Scene,
|
|
bool bCanCache,
|
|
EMeshPass::Type PassType)
|
|
{
|
|
const bool bIsNaniteMesh = Scene.PrimitiveFlagsCompact[PrimitiveIndex].bIsNaniteMesh;
|
|
if (bIsNaniteMesh && Scene.PrimitivesAlwaysVisibleOffset != ~0u)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const EShadingPath ShadingPath = GetFeatureLevelShadingPath(Scene.GetFeatureLevel());
|
|
const bool bUseCachedMeshCommand = bUseCachedMeshDrawCommands
|
|
&& !!(FPassProcessorManager::GetPassFlags(ShadingPath, PassType) & EMeshPassFlags::CachedMeshCommands)
|
|
&& StaticMeshRelevance.bSupportsCachingMeshDrawCommands
|
|
&& bCanCache;
|
|
|
|
if (bUseCachedMeshCommand)
|
|
{
|
|
const int32 StaticMeshCommandInfoIndex = StaticMeshRelevance.GetStaticMeshCommandInfoIndex(PassType);
|
|
if (StaticMeshCommandInfoIndex >= 0)
|
|
{
|
|
const FCachedMeshDrawCommandInfo& CachedMeshDrawCommand = InPrimitiveSceneInfo->StaticMeshCommandInfos[StaticMeshCommandInfoIndex];
|
|
const FCachedPassMeshDrawList& SceneDrawList = Scene.CachedDrawLists[PassType];
|
|
|
|
// AddUninitialized_GetRef()
|
|
VisibleCachedDrawCommands[(uint32)PassType].AddUninitialized();
|
|
FVisibleMeshDrawCommand& NewVisibleMeshDrawCommand = VisibleCachedDrawCommands[(uint32)PassType].Last();
|
|
|
|
const FMeshDrawCommand* MeshDrawCommand = CachedMeshDrawCommand.StateBucketId >= 0
|
|
? &Scene.CachedMeshDrawCommandStateBuckets[PassType].GetByElementId(CachedMeshDrawCommand.StateBucketId).Key
|
|
: &SceneDrawList.MeshDrawCommands[CachedMeshDrawCommand.CommandIndex];
|
|
|
|
NewVisibleMeshDrawCommand.Setup(
|
|
MeshDrawCommand,
|
|
InPrimitiveSceneInfo->GetMDCIdInfo(),
|
|
CachedMeshDrawCommand.StateBucketId,
|
|
CachedMeshDrawCommand.MeshFillMode,
|
|
CachedMeshDrawCommand.MeshCullMode,
|
|
CachedMeshDrawCommand.Flags,
|
|
CachedMeshDrawCommand.SortKey,
|
|
CachedMeshDrawCommand.CullingPayload,
|
|
CullingPayloadFlags);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NumDynamicBuildRequestElements[PassType] += StaticMeshRelevance.NumElements;
|
|
DynamicBuildRequests[PassType].Add(&StaticMesh);
|
|
DynamicBuildFlags[PassType].Add(CullingPayloadFlags);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FRelevancePacket::FRelevancePacket(
|
|
FVisibilityTaskData& InTaskData,
|
|
const FViewInfo& InView,
|
|
int32 InViewIndex,
|
|
const FFilterStaticMeshesForViewData& InViewData,
|
|
uint8* InMarkMasks,
|
|
const UE::Tasks::FTask& InPrerequisitesTask)
|
|
: CurrentWorldTime(InView.Family->Time.GetWorldTimeSeconds())
|
|
, DeltaWorldTime(InView.Family->Time.GetDeltaWorldTimeSeconds())
|
|
, TaskData(InTaskData)
|
|
, TaskConfig(InTaskData.TaskConfig)
|
|
, Scene(TaskData.Scene)
|
|
, View(InView)
|
|
, ViewCommands(TaskData.DynamicMeshElements.ViewCommandsPerView[InViewIndex])
|
|
, ViewBit(1 << InViewIndex)
|
|
, ViewData(InViewData)
|
|
, DynamicPrimitiveViewMasks(TaskData.DynamicMeshElements.PrimitiveViewMasks)
|
|
, MarkMasks(InMarkMasks)
|
|
, PrerequisitesTask(InPrerequisitesTask)
|
|
, Input(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, NotDrawRelevant(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, TranslucentSelfShadowPrimitives(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, VisibleDynamicPrimitivesWithSimpleLights(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, DirtyIndirectLightingCacheBufferPrimitives(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, NaniteCustomDepthInstances(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, PrimitivesLODMask(TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, bAddLightmapDensityCommands(TaskData.bAddLightmapDensityCommands)
|
|
{}
|
|
|
|
void FRelevancePacket::LaunchComputeRelevanceTask()
|
|
{
|
|
check(!bComputeRelevanceTaskLaunched);
|
|
|
|
if (!Input.IsEmpty())
|
|
{
|
|
bComputeRelevanceTaskLaunched = true;
|
|
|
|
if (TaskData.DynamicMeshElements.CommandPipe)
|
|
{
|
|
TaskData.DynamicMeshElements.CommandPipe->AddNumCommands(1);
|
|
}
|
|
|
|
ComputeRelevanceTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [this]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
FDynamicPrimitiveIndexList DynamicPrimitiveIndexList;
|
|
ComputeRelevance(DynamicPrimitiveIndexList);
|
|
|
|
if (TaskData.DynamicMeshElements.CommandPipe)
|
|
{
|
|
if (DynamicPrimitiveIndexList.IsEmpty())
|
|
{
|
|
TaskData.DynamicMeshElements.CommandPipe->ReleaseNumCommands(1);
|
|
}
|
|
else
|
|
{
|
|
TaskData.DynamicMeshElements.CommandPipe->EnqueueCommand(MoveTemp(DynamicPrimitiveIndexList));
|
|
}
|
|
}
|
|
|
|
}, PrerequisitesTask, TaskConfig.Relevance.ComputeRelevanceTaskPriority);
|
|
}
|
|
}
|
|
|
|
void FRelevancePacket::Finalize()
|
|
{
|
|
FViewInfo& WriteView = const_cast<FViewInfo&>(View);
|
|
FViewCommands& WriteViewCommands = const_cast<FViewCommands&>(ViewCommands);
|
|
const EShadingPath ShadingPath = GetFeatureLevelShadingPath(Scene.GetFeatureLevel());
|
|
|
|
for (int32 BitIndex : NotDrawRelevant.Prims)
|
|
{
|
|
WriteView.PrimitiveVisibilityMap[BitIndex] = false;
|
|
}
|
|
|
|
TaskConfig.Relevance.NumPrimitivesProcessed += Input.Prims.Num();
|
|
|
|
#if WITH_EDITOR
|
|
WriteView.EditorVisualizeLevelInstancesNanite.Append(EditorVisualizeLevelInstancesNanite);
|
|
WriteView.EditorSelectedInstancesNanite.Append(EditorSelectedInstancesNanite);
|
|
WriteView.EditorSelectedInstancesNanite.Append(EditorOverlaidInstancesNanite);
|
|
WriteView.EditorSelectedNaniteHitProxyIds.Append(EditorSelectedNaniteHitProxyIds);
|
|
#endif
|
|
|
|
WriteView.ShadingModelMaskInView |= CombinedShadingModelMask;
|
|
WriteView.bUsesGlobalDistanceField |= bUsesGlobalDistanceField;
|
|
WriteView.bUsesLightingChannels |= bUsesLightingChannels;
|
|
WriteView.bTranslucentSurfaceLighting |= bTranslucentSurfaceLighting;
|
|
WriteView.bSceneHasSkyMaterial |= bSceneHasSkyMaterial;
|
|
WriteView.bHasSingleLayerWaterMaterial |= bHasSingleLayerWaterMaterial;
|
|
WriteView.bUsesSecondStageDepthPass |= bUsesSecondStageDepthPass && ShadingPath != EShadingPath::Mobile;
|
|
VisibleDynamicPrimitivesWithSimpleLights.AppendTo(WriteView.VisibleDynamicPrimitivesWithSimpleLights);
|
|
WriteView.NumVisibleDynamicPrimitives += NumVisibleDynamicPrimitives;
|
|
WriteView.NumVisibleDynamicEditorPrimitives += NumVisibleDynamicEditorPrimitives;
|
|
WriteView.TranslucentPrimCount.Append(TranslucentPrimCount);
|
|
WriteView.bHasDistortionPrimitives |= bHasDistortionPrimitives;
|
|
WriteView.bHasCustomDepthPrimitives |= bHasCustomDepthPrimitives;
|
|
WriteView.CustomDepthStencilValues.Append(CustomDepthStencilValues);
|
|
NaniteCustomDepthInstances.AppendTo(WriteView.NaniteCustomDepthInstances);
|
|
WriteView.bUsesCustomDepth |= bUsesCustomDepth;
|
|
WriteView.bUsesMotionVectorWorldOffset |= bUsesMotionVectorWorldOffset;
|
|
WriteView.bUsesCustomStencil |= bUsesCustomStencil;
|
|
WriteView.SubstrateViewData.MaxClosurePerPixel = FMath::Max(WriteView.SubstrateViewData.MaxClosurePerPixel, 8u - FMath::CountLeadingZeros8(SubstrateClosureCountMask));
|
|
WriteView.SubstrateViewData.MaxBytesPerPixel = FMath::Max(WriteView.SubstrateViewData.MaxBytesPerPixel, SubstrateUintPerPixel * 4u);
|
|
WriteView.SubstrateViewData.UsesTileTypeMask |= SubstrateTileTypeMask;
|
|
WriteView.SubstrateViewData.bUsesAnisotropy |= bUsesAnisotropy;
|
|
DirtyIndirectLightingCacheBufferPrimitives.AppendTo(WriteView.DirtyIndirectLightingCacheBufferPrimitives);
|
|
|
|
WriteView.VolumetricMeshBatches.Append(VolumetricMeshBatches);
|
|
WriteView.HeterogeneousVolumesMeshBatches.Append(HeterogeneousVolumesMeshBatches);
|
|
WriteView.SkyMeshBatches.Append(SkyMeshBatches);
|
|
WriteView.SortedTrianglesMeshBatches.Append(SortedTrianglesMeshBatches);
|
|
|
|
for (FPrimitiveLODMask PrimitiveLODMask : PrimitivesLODMask.Prims)
|
|
{
|
|
WriteView.PrimitivesLODMask[PrimitiveLODMask.PrimitiveIndex] = PrimitiveLODMask.LODMask;
|
|
}
|
|
|
|
for (int32 PassIndex = 0; PassIndex < EMeshPass::Num; PassIndex++)
|
|
{
|
|
if (PassIndex == EMeshPass::NaniteMeshPass && Scene.PrimitivesAlwaysVisibleOffset != ~0u)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FPassDrawCommandArray& SrcCommands = DrawCommandPacket.VisibleCachedDrawCommands[PassIndex];
|
|
FMeshCommandOneFrameArray& DstCommands = WriteViewCommands.MeshCommands[PassIndex];
|
|
if (SrcCommands.Num() > 0)
|
|
{
|
|
static_assert(sizeof(SrcCommands[0]) == sizeof(DstCommands[0]), "Memcpy sizes must match.");
|
|
const int32 PrevNum = DstCommands.AddUninitialized(SrcCommands.Num());
|
|
FMemory::Memcpy(&DstCommands[PrevNum], &SrcCommands[0], SrcCommands.Num() * sizeof(SrcCommands[0]));
|
|
}
|
|
|
|
FPassDrawCommandBuildRequestArray& SrcRequests = DrawCommandPacket.DynamicBuildRequests[PassIndex];
|
|
TArray<const FStaticMeshBatch*, SceneRenderingAllocator>& DstRequests = WriteViewCommands.DynamicMeshCommandBuildRequests[PassIndex];
|
|
if (SrcRequests.Num() > 0)
|
|
{
|
|
static_assert(sizeof(SrcRequests[0]) == sizeof(DstRequests[0]), "Memcpy sizes must match.");
|
|
const int32 PrevNum = DstRequests.AddUninitialized(SrcRequests.Num());
|
|
FMemory::Memcpy(&DstRequests[PrevNum], &SrcRequests[0], SrcRequests.Num() * sizeof(SrcRequests[0]));
|
|
}
|
|
|
|
FPassDrawCommandBuildFlagsArray& SrcFlags = DrawCommandPacket.DynamicBuildFlags[PassIndex];
|
|
TArray<EMeshDrawCommandCullingPayloadFlags, SceneRenderingAllocator>& DstFlags = WriteViewCommands.DynamicMeshCommandBuildFlags[PassIndex];
|
|
if (SrcFlags.Num() > 0)
|
|
{
|
|
static_assert(sizeof(SrcFlags[0]) == sizeof(DstFlags[0]), "Memcpy sizes must match.");
|
|
const int32 PrevNum = DstFlags.AddUninitialized(SrcFlags.Num());
|
|
FMemory::Memcpy(&DstFlags[PrevNum], &SrcFlags[0], SrcFlags.Num() * sizeof(SrcFlags[0]));
|
|
}
|
|
|
|
WriteViewCommands.NumDynamicMeshCommandBuildRequestElements[PassIndex] += DrawCommandPacket.NumDynamicBuildRequestElements[PassIndex];
|
|
}
|
|
|
|
// Prepare translucent self shadow uniform buffers.
|
|
for (int32 PrimitiveIndex : TranslucentSelfShadowPrimitives.Prims)
|
|
{
|
|
FUniformBufferRHIRef& UniformBuffer = WriteView.TranslucentSelfShadowUniformBufferMap.FindOrAdd(PrimitiveIndex);
|
|
|
|
if (!UniformBuffer)
|
|
{
|
|
FTranslucentSelfShadowUniformParameters Parameters;
|
|
SetupTranslucentSelfShadowUniformParameters(nullptr, Parameters);
|
|
UniformBuffer = FTranslucentSelfShadowUniformParameters::CreateUniformBuffer(Parameters, EUniformBufferUsage::UniformBuffer_SingleFrame);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FRelevancePacket::ComputeRelevance(FDynamicPrimitiveIndexList& DynamicPrimitiveIndexList)
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(ComputeViewRelevance);
|
|
SCOPE_CYCLE_COUNTER(STAT_ComputeViewRelevance);
|
|
|
|
CombinedShadingModelMask = 0;
|
|
SubstrateUintPerPixel = 0;
|
|
SubstrateTileTypeMask = 0;
|
|
bUsesAnisotropy = false;
|
|
SubstrateClosureCountMask = 0;
|
|
bSceneHasSkyMaterial = 0;
|
|
bHasSingleLayerWaterMaterial = 0;
|
|
bUsesSecondStageDepthPass = 0;
|
|
bUsesGlobalDistanceField = false;
|
|
bUsesLightingChannels = false;
|
|
bTranslucentSurfaceLighting = false;
|
|
const EShadingPath ShadingPath = GetFeatureLevelShadingPath(Scene.GetFeatureLevel());
|
|
const bool bHairStrandsEnabled = IsHairStrandsEnabled(EHairStrandsShaderType::All, Scene.GetShaderPlatform());
|
|
const bool bIsTLVUsingVoxelMarking = IsTranslucencyLightingVolumeUsingVoxelMarking();
|
|
|
|
int32 NumVisibleStaticMeshElements = 0;
|
|
FViewInfo& WriteView = const_cast<FViewInfo&>(View);
|
|
const FSceneViewState* ViewState = (FSceneViewState*)View.State;
|
|
const bool bMobileMaskedInEarlyPass = (ShadingPath == EShadingPath::Mobile) && Scene.EarlyZPassMode == DDM_MaskedOnly;
|
|
const bool bMobileBasePassAlwaysUsesCSM = (ShadingPath == EShadingPath::Mobile) && MobileBasePassAlwaysUsesCSM(Scene.GetShaderPlatform());
|
|
const bool bVelocityPassWritesDepth = Scene.EarlyZPassMode == DDM_AllOpaqueNoVelocity;
|
|
const bool bIsTranslucentHoldoutEnabled = IsPrimitiveAlphaHoldoutEnabled(View);
|
|
const bool bIsTranslucentClippedDepthEnabled = NeedTSRThinGeometryDetectionPass(View);
|
|
const bool bHLODActive = Scene.SceneLODHierarchy.IsActive();
|
|
const bool bRenderCustomDepth = (ShadingPath == EShadingPath::Mobile) ? FMobileSceneRenderer::ShouldRenderCustomDepth(View) : true;
|
|
const bool bMobileSupportsSM5MaterialNodes = MobileSupportsSM5MaterialNodes(View.GetShaderPlatform());
|
|
const FHLODVisibilityState* const HLODState = bHLODActive && ViewState ? &ViewState->HLODVisibilityState : nullptr;
|
|
float MaxDrawDistanceScale = GetCachedScalabilityCVars().ViewDistanceScale;
|
|
MaxDrawDistanceScale *= GetCachedScalabilityCVars().CalculateFieldOfViewDistanceScale(View.DesiredFOV);
|
|
|
|
const auto AddEditorDynamicPrimitive = [this, &DynamicPrimitiveIndexList](int32 PrimitiveIndex)
|
|
{
|
|
#if WITH_EDITOR
|
|
if (GIsEditor)
|
|
{
|
|
++NumVisibleDynamicEditorPrimitives;
|
|
|
|
if (DynamicPrimitiveViewMasks)
|
|
{
|
|
FPlatformAtomics::InterlockedOr((volatile int8*)&DynamicPrimitiveViewMasks->EditorPrimitives[PrimitiveIndex], ViewBit);
|
|
}
|
|
else
|
|
{
|
|
DynamicPrimitiveIndexList.EditorPrimitives.Emplace(PrimitiveIndex, ViewBit);
|
|
}
|
|
}
|
|
#endif
|
|
};
|
|
|
|
const auto AddDynamicPrimitive = [this, &DynamicPrimitiveIndexList](int32 PrimitiveIndex)
|
|
{
|
|
++NumVisibleDynamicPrimitives;
|
|
|
|
if (DynamicPrimitiveViewMasks)
|
|
{
|
|
FPlatformAtomics::InterlockedOr((volatile int8*)&DynamicPrimitiveViewMasks->Primitives[PrimitiveIndex], ViewBit);
|
|
}
|
|
else
|
|
{
|
|
DynamicPrimitiveIndexList.Primitives.Emplace(PrimitiveIndex, ViewBit);
|
|
}
|
|
};
|
|
|
|
for (int32 InputPrimsIndex = 0; InputPrimsIndex < Input.Prims.Num(); ++InputPrimsIndex)
|
|
{
|
|
int32 BitIndex = Input.Prims[InputPrimsIndex];
|
|
|
|
if (InputPrimsIndex + 1 < Input.Prims.Num())
|
|
{
|
|
int32 NextBitIndex = Input.Prims[InputPrimsIndex + 1];
|
|
|
|
// Prefetch the next primitive / proxy pair for the next loop.
|
|
FPlatformMisc::Prefetch(Scene.Primitives[NextBitIndex]);
|
|
FPlatformMisc::Prefetch(Scene.PrimitiveSceneProxies[NextBitIndex]);
|
|
}
|
|
|
|
FPrimitiveSceneInfo* PrimitiveSceneInfo = Scene.Primitives[BitIndex];
|
|
FPrimitiveViewRelevance& ViewRelevance = const_cast<FPrimitiveViewRelevance&>(View.PrimitiveViewRelevanceMap[BitIndex]);
|
|
|
|
const FPrimitiveSceneProxy* PrimitiveSceneProxy = PrimitiveSceneInfo->Proxy;
|
|
|
|
// Prefetch the scene data and static mesh relevance array now while we call GetViewRelevance to reduce memory waits.
|
|
FPlatformMisc::Prefetch(PrimitiveSceneInfo->StaticMeshRelevances.GetData());
|
|
FPlatformMisc::Prefetch(PrimitiveSceneInfo->GetSceneData());
|
|
|
|
ViewRelevance = PrimitiveSceneProxy->GetViewRelevance(&View);
|
|
ViewRelevance.bInitializedThisFrame = true;
|
|
|
|
const bool bStaticRelevance = ViewRelevance.bStaticRelevance;
|
|
const bool bDrawRelevance = ViewRelevance.bDrawRelevance;
|
|
const bool bDynamicRelevance = ViewRelevance.bDynamicRelevance;
|
|
const bool bShadowRelevance = ViewRelevance.bShadowRelevance;
|
|
const bool bEditorRelevance = ViewRelevance.bEditorPrimitiveRelevance;
|
|
const bool bEditorVisualizeLevelInstanceRelevance = ViewRelevance.bEditorVisualizeLevelInstanceRelevance;
|
|
const bool bEditorSelectionRelevance = ViewRelevance.bEditorStaticSelectionRelevance;
|
|
const bool bTranslucentRelevance = ViewRelevance.HasTranslucency();
|
|
const bool bHairStrandsRelevance = bHairStrandsEnabled && ViewRelevance.bHairStrands;
|
|
|
|
if (View.bIsReflectionCapture && !PrimitiveSceneProxy->IsVisibleInReflectionCaptures())
|
|
{
|
|
NotDrawRelevant.AddPrim(BitIndex);
|
|
continue;
|
|
}
|
|
|
|
if (bStaticRelevance && (bDrawRelevance || bShadowRelevance))
|
|
{
|
|
const FDesiredLODLevel DesiredLODLevel = PrimitiveSceneProxy->GetDesiredLODLevel_RenderThread(&View);
|
|
|
|
int32 PrimitiveIndex = BitIndex;
|
|
const FPrimitiveBounds& Bounds = Scene.PrimitiveBounds[PrimitiveIndex];
|
|
const bool bIsPrimitiveDistanceCullFading = View.PrimitiveFadeUniformBufferMap[PrimitiveIndex];
|
|
|
|
check(DesiredLODLevel.LOD >= 0);
|
|
float MeshScreenSizeSquared = 0;
|
|
|
|
FLODMask LODToRender;
|
|
|
|
if (DesiredLODLevel.IsFixed())
|
|
{
|
|
LODToRender.SetLOD(DesiredLODLevel.LOD);
|
|
}
|
|
else
|
|
{
|
|
LODToRender = ComputeLODForMeshes(PrimitiveSceneInfo->StaticMeshRelevances, View, Bounds.BoxSphereBounds.Origin, Bounds.BoxSphereBounds.SphereRadius, PrimitiveSceneInfo->GpuLodInstanceRadius, ViewData.ForcedLODLevel, MeshScreenSizeSquared, DesiredLODLevel.LOD, ViewData.LODScale);
|
|
}
|
|
|
|
PrimitivesLODMask.AddPrim(FRelevancePacket::FPrimitiveLODMask(PrimitiveIndex, LODToRender));
|
|
|
|
const bool bIsHLODFading = HLODState ? HLODState->IsNodeFading(PrimitiveIndex) : false;
|
|
const bool bIsHLODFadingOut = HLODState ? HLODState->IsNodeFadingOut(PrimitiveIndex) : false;
|
|
const bool bIsLODDithered = LODToRender.IsDithered();
|
|
const bool bIsLODRange = LODToRender.IsLODRange();
|
|
|
|
float DistanceSquared = (Bounds.BoxSphereBounds.Origin - ViewData.ViewOrigin).SizeSquared();
|
|
const float LODFactorDistanceSquared = DistanceSquared * FMath::Square(ViewData.LODScale);
|
|
const bool bDrawDepthOnly = ViewData.bFullEarlyZPass || ((ShadingPath != EShadingPath::Mobile) && (FMath::Square(Bounds.BoxSphereBounds.SphereRadius) > GMinScreenRadiusForDepthPrepass * GMinScreenRadiusForDepthPrepass * LODFactorDistanceSquared));
|
|
|
|
const int32 NumStaticMeshes = PrimitiveSceneInfo->StaticMeshRelevances.Num();
|
|
for (int32 MeshIndex = 0; MeshIndex < NumStaticMeshes; MeshIndex++)
|
|
{
|
|
const FStaticMeshBatchRelevance& StaticMeshRelevance = PrimitiveSceneInfo->StaticMeshRelevances[MeshIndex];
|
|
const FStaticMeshBatch& StaticMesh = PrimitiveSceneInfo->StaticMeshes[MeshIndex];
|
|
|
|
if (StaticMeshRelevance.bOverlayMaterial && !View.Family->EngineShowFlags.DistanceCulledPrimitives)
|
|
{
|
|
// Overlay mesh can have its own cull distance that is shorter than primitive cull distance
|
|
float OverlayMaterialMaxDrawDistance = GOverlayMaterialMaxDrawDistanceOverride > 0.0f ? GOverlayMaterialMaxDrawDistanceOverride : StaticMeshRelevance.ScreenSize;
|
|
if (OverlayMaterialMaxDrawDistance > 0.f && OverlayMaterialMaxDrawDistance != FLT_MAX)
|
|
{
|
|
if (DistanceSquared > FMath::Square(OverlayMaterialMaxDrawDistance * MaxDrawDistanceScale))
|
|
{
|
|
// distance culled
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
int8 StaticMeshLODIndex = StaticMeshRelevance.GetLODIndex();
|
|
if (LODToRender.ContainsLOD(StaticMeshLODIndex))
|
|
{
|
|
uint8 MarkMask = 0;
|
|
bool bHiddenByHLODFade = false; // Hide mesh LOD levels that HLOD is substituting
|
|
|
|
if (bIsHLODFading)
|
|
{
|
|
if (bIsHLODFadingOut)
|
|
{
|
|
if (bIsLODDithered && LODToRender.LODIndex1 == StaticMeshLODIndex)
|
|
{
|
|
bHiddenByHLODFade = true;
|
|
}
|
|
else
|
|
{
|
|
MarkMask |= EMarkMaskBits::StaticMeshFadeOutDitheredLODMapMask;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bIsLODDithered && LODToRender.LODIndex0 == StaticMeshLODIndex)
|
|
{
|
|
bHiddenByHLODFade = true;
|
|
}
|
|
else
|
|
{
|
|
MarkMask |= EMarkMaskBits::StaticMeshFadeInDitheredLODMapMask;
|
|
}
|
|
}
|
|
}
|
|
else if (bIsLODDithered)
|
|
{
|
|
if (LODToRender.LODIndex0 == StaticMeshLODIndex)
|
|
{
|
|
MarkMask |= EMarkMaskBits::StaticMeshFadeOutDitheredLODMapMask;
|
|
}
|
|
else
|
|
{
|
|
MarkMask |= EMarkMaskBits::StaticMeshFadeInDitheredLODMapMask;
|
|
}
|
|
}
|
|
|
|
// Don't cache if it requires per view per mesh state for LOD dithering or distance cull fade.
|
|
const bool bIsMeshDitheringLOD = StaticMeshRelevance.bDitheredLODTransition && (MarkMask & (EMarkMaskBits::StaticMeshFadeOutDitheredLODMapMask | EMarkMaskBits::StaticMeshFadeInDitheredLODMapMask));
|
|
const bool bCanCache = !bIsPrimitiveDistanceCullFading && !bIsMeshDitheringLOD;
|
|
|
|
// When we apply LOD selection on GPU we submit a range of LODs and then cull each one according to screen size.
|
|
// At both ends of a LOD range we only want to cull by screen size in one direction. This ensures that all possible screen sizes map to one LOD in the range.
|
|
EMeshDrawCommandCullingPayloadFlags CullingPayloadFlags = EMeshDrawCommandCullingPayloadFlags::Default;
|
|
CullingPayloadFlags |= bIsLODRange && !LODToRender.IsMaxLODInRange(StaticMeshRelevance.GetLODIndex()) ? EMeshDrawCommandCullingPayloadFlags::MinScreenSizeCull : (EMeshDrawCommandCullingPayloadFlags)0;
|
|
CullingPayloadFlags |= bIsLODRange && !LODToRender.IsMinLODInRange(StaticMeshRelevance.GetLODIndex()) ? EMeshDrawCommandCullingPayloadFlags::MaxScreenSizeCull : (EMeshDrawCommandCullingPayloadFlags)0;
|
|
|
|
if (ViewRelevance.bDrawRelevance)
|
|
{
|
|
if ((StaticMeshRelevance.bUseForMaterial || StaticMeshRelevance.bUseAsOccluder)
|
|
&& (ViewRelevance.bRenderInMainPass || ViewRelevance.bRenderCustomDepth || ViewRelevance.bRenderInDepthPass)
|
|
&& !bHiddenByHLODFade)
|
|
{
|
|
// Add velocity commands first to track for case where velocity pass writes depth.
|
|
bool bIsMeshInVelocityPass = false;
|
|
if (StaticMeshRelevance.bUseForMaterial && ViewRelevance.bRenderInMainPass)
|
|
{
|
|
if (ViewRelevance.HasVelocity())
|
|
{
|
|
if (FVelocityMeshProcessor::PrimitiveHasVelocityForView(View, PrimitiveSceneProxy))
|
|
{
|
|
if (ViewRelevance.bVelocityRelevance &&
|
|
FOpaqueVelocityMeshProcessor::PrimitiveCanHaveVelocity(View.GetShaderPlatform(), PrimitiveSceneProxy) &&
|
|
FOpaqueVelocityMeshProcessor::PrimitiveHasVelocityForFrame(View.GetShaderPlatform(), PrimitiveSceneProxy))
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::Velocity);
|
|
bIsMeshInVelocityPass = true;
|
|
|
|
if (PrimitiveSceneProxy->AnyMaterialUsesMotionVectorWorldOffset())
|
|
{
|
|
bUsesMotionVectorWorldOffset = true;
|
|
}
|
|
}
|
|
|
|
if (ViewRelevance.bOutputsTranslucentVelocity &&
|
|
FTranslucentVelocityMeshProcessor::PrimitiveCanHaveVelocity(View.GetShaderPlatform(), PrimitiveSceneProxy) &&
|
|
FTranslucentVelocityMeshProcessor::PrimitiveHasVelocityForFrame(PrimitiveSceneProxy))
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucentVelocity);
|
|
|
|
// Only Before DoF Translucency needs this pass
|
|
const bool bAnyMaterialUsesTemporalResponsiveness = PrimitiveSceneProxy->AnyMaterialUsesTemporalResponsiveness();
|
|
if (ViewRelevance.bNormalTranslucency && bIsTranslucentClippedDepthEnabled && bAnyMaterialUsesTemporalResponsiveness)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucentVelocityClippedDepth);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add depth commands.
|
|
if (StaticMeshRelevance.bUseForDepthPass && (bDrawDepthOnly || (bMobileMaskedInEarlyPass && ViewRelevance.bMasked)))
|
|
{
|
|
if (!(bIsMeshInVelocityPass && bVelocityPassWritesDepth))
|
|
{
|
|
if (ViewRelevance.bRenderInSecondStageDepthPass && ShadingPath != EShadingPath::Mobile)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::SecondStageDepthPass);
|
|
}
|
|
else
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::DepthPass);
|
|
}
|
|
}
|
|
#if RHI_RAYTRACING
|
|
// Only used by ray traced shadows
|
|
if (IsRayTracingEnabled() && View.bHasRayTracingShadows && View.IsRayTracingAllowedForView())
|
|
{
|
|
if (MarkMask & EMarkMaskBits::StaticMeshFadeOutDitheredLODMapMask)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::DitheredLODFadingOutMaskPass);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Mark static mesh as visible for rendering
|
|
if (StaticMeshRelevance.bUseForMaterial && (ViewRelevance.bRenderInMainPass || ViewRelevance.bRenderCustomDepth))
|
|
{
|
|
// Specific logic for mobile packets
|
|
if (ShadingPath == EShadingPath::Mobile)
|
|
{
|
|
if (StaticMeshRelevance.bUseSingleLayerWaterMaterial && bMobileSupportsSM5MaterialNodes)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::SingleLayerWaterPass);
|
|
}
|
|
// Skydome must not be added to base pass bucket
|
|
else if (!StaticMeshRelevance.bUseSkyMaterial)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::BasePass);
|
|
if (!bMobileBasePassAlwaysUsesCSM)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::MobileBasePassCSM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::SkyPass);
|
|
}
|
|
// bUseSingleLayerWaterMaterial is added to BasePass on Mobile. No need to add it to SingleLayerWaterPass
|
|
|
|
MarkMask |= EMarkMaskBits::StaticMeshVisibilityMapMask;
|
|
}
|
|
else // Regular shading path
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::BasePass);
|
|
MarkMask |= EMarkMaskBits::StaticMeshVisibilityMapMask;
|
|
|
|
if (StaticMeshRelevance.bUseSkyMaterial)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::SkyPass);
|
|
}
|
|
if (StaticMeshRelevance.bUseSingleLayerWaterMaterial)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::SingleLayerWaterPass);
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::SingleLayerWaterDepthPrepass);
|
|
}
|
|
}
|
|
|
|
if (StaticMeshRelevance.bUseAnisotropy)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::AnisotropyPass);
|
|
}
|
|
|
|
if (ViewRelevance.bRenderCustomDepth && bRenderCustomDepth)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::CustomDepth);
|
|
}
|
|
|
|
if (bAddLightmapDensityCommands)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::LightmapDensity);
|
|
}
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
else if (View.Family->UseDebugViewPS())
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::DebugViewMode);
|
|
}
|
|
#endif
|
|
|
|
#if WITH_EDITOR
|
|
if (StaticMeshRelevance.bSelectable)
|
|
{
|
|
if (View.bAllowTranslucentPrimitivesInHitProxy)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::HitProxy);
|
|
}
|
|
else
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::HitProxyOpaqueOnly);
|
|
}
|
|
}
|
|
#endif
|
|
++NumVisibleStaticMeshElements;
|
|
|
|
INC_DWORD_STAT_BY(STAT_StaticMeshTriangles, StaticMesh.GetNumPrimitives());
|
|
}
|
|
}
|
|
|
|
if (StaticMeshRelevance.bUseForMaterial
|
|
&& ViewRelevance.HasTranslucency()
|
|
&& !ViewRelevance.bEditorPrimitiveRelevance
|
|
&& ViewRelevance.bRenderInMainPass)
|
|
{
|
|
if (View.Family->AllowTranslucencyAfterDOF())
|
|
{
|
|
if ((ViewRelevance.bNormalTranslucency || (View.AutoBeforeDOFTranslucencyBoundary > 0.0f && ViewRelevance.bSeparateTranslucency)))
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyStandard);
|
|
}
|
|
|
|
if ((ViewRelevance.bNormalTranslucency || (View.AutoBeforeDOFTranslucencyBoundary > 0.0f && ViewRelevance.bSeparateTranslucency)) && ViewRelevance.bTranslucencyModulate && View.Family->AllowStandardTranslucencySeparated())
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyStandardModulate);
|
|
}
|
|
|
|
if (ViewRelevance.bSeparateTranslucency)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyAfterDOF);
|
|
}
|
|
|
|
if (ViewRelevance.bSeparateTranslucency && ViewRelevance.bTranslucencyModulate)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyAfterDOFModulate);
|
|
}
|
|
|
|
if (ViewRelevance.bPostMotionBlurTranslucency)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyAfterMotionBlur);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, everything is rendered in a single bucket. This is not related to whether DOF is currently enabled or not.
|
|
// When using all translucency, Standard and AfterDOF are sorted together instead of being rendered like 2 buckets.
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyAll);
|
|
}
|
|
|
|
if (bIsTranslucentHoldoutEnabled)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::TranslucencyHoldout);
|
|
}
|
|
|
|
if (ViewRelevance.bTranslucentSurfaceLighting || bIsTLVUsingVoxelMarking)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::LumenTranslucencyRadianceCacheMark);
|
|
}
|
|
|
|
if (ViewRelevance.bTranslucentSurfaceLighting)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::LumenFrontLayerTranslucencyGBuffer);
|
|
}
|
|
|
|
if (ViewRelevance.bDistortion)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::Distortion);
|
|
}
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
if (ViewRelevance.bEditorVisualizeLevelInstanceRelevance)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::EditorLevelInstance);
|
|
}
|
|
|
|
if (ViewRelevance.bEditorStaticSelectionRelevance)
|
|
{
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, EMeshPass::EditorSelection);
|
|
}
|
|
#endif
|
|
|
|
if (ViewRelevance.bHasVolumeMaterialDomain)
|
|
{
|
|
if (ShouldRenderMeshBatchWithHeterogeneousVolumes(&StaticMesh, PrimitiveSceneProxy, View.FeatureLevel))
|
|
{
|
|
HeterogeneousVolumesMeshBatches.AddUninitialized(1);
|
|
FVolumetricMeshBatch& BatchAndProxy = HeterogeneousVolumesMeshBatches.Last();
|
|
BatchAndProxy.Mesh = &StaticMesh;
|
|
BatchAndProxy.Proxy = PrimitiveSceneProxy;
|
|
}
|
|
else
|
|
{
|
|
VolumetricMeshBatches.AddUninitialized(1);
|
|
FVolumetricMeshBatch& BatchAndProxy = VolumetricMeshBatches.Last();
|
|
BatchAndProxy.Mesh = &StaticMesh;
|
|
BatchAndProxy.Proxy = PrimitiveSceneProxy;
|
|
}
|
|
}
|
|
|
|
if (ViewRelevance.bUsesSkyMaterial)
|
|
{
|
|
SkyMeshBatches.AddUninitialized(1);
|
|
FSkyMeshBatch& BatchAndProxy = SkyMeshBatches.Last();
|
|
BatchAndProxy.Mesh = &StaticMesh;
|
|
BatchAndProxy.Proxy = PrimitiveSceneProxy;
|
|
BatchAndProxy.bVisibleInMainPass = ViewRelevance.bRenderInMainPass;
|
|
BatchAndProxy.bVisibleInRealTimeSkyCapture = PrimitiveSceneInfo->bVisibleInRealTimeSkyCapture;
|
|
}
|
|
|
|
if (ViewRelevance.HasTranslucency() && PrimitiveSceneProxy->SupportsSortedTriangles()) // Need to check material as well
|
|
{
|
|
SortedTrianglesMeshBatches.AddUninitialized(1);
|
|
FSortedTrianglesMeshBatch& BatchAndProxy = SortedTrianglesMeshBatches.Last();
|
|
BatchAndProxy.Mesh = &StaticMesh;
|
|
BatchAndProxy.Proxy = PrimitiveSceneProxy;
|
|
}
|
|
|
|
// FIXME: Now if a primitive has one batch with a decal material all primitive mesh batches will be added as decals
|
|
// Because ViewRelevance is a sum of all material relevances in the primitive
|
|
if (ViewRelevance.bRenderInMainPass && ViewRelevance.bDecal && StaticMeshRelevance.bUseForMaterial)
|
|
{
|
|
for (uint8 DecalRenderTargetMode = 0; DecalRenderTargetMode < (uint8)EDecalRenderTargetMode::Num; ++DecalRenderTargetMode)
|
|
{
|
|
if (DecalRendering::IsCompatibleWithRenderTargetMode(StaticMeshRelevance.DecalRenderTargetModeMask, (EDecalRenderTargetMode)DecalRenderTargetMode))
|
|
{
|
|
EMeshPass::Type DecalMeshPassType = DecalRendering::GetMeshPassType((EDecalRenderTargetMode)DecalRenderTargetMode);
|
|
DrawCommandPacket.AddCommandsForMesh(PrimitiveIndex, PrimitiveSceneInfo, StaticMeshRelevance, StaticMesh, CullingPayloadFlags, Scene, bCanCache, DecalMeshPassType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (MarkMask)
|
|
{
|
|
MarkMasks[StaticMeshRelevance.Id] = MarkMask;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bDrawRelevance)
|
|
{
|
|
NotDrawRelevant.AddPrim(BitIndex);
|
|
continue;
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
auto CollectNaniteInstanceDraws = [](
|
|
const FPrimitiveSceneInfo& PrimitiveSceneInfo,
|
|
const FPrimitiveSceneProxy* PrimitiveSceneProxy,
|
|
TArray<Nanite::FInstanceDraw>& OutSelectedInstanceDraws,
|
|
TArray<Nanite::FInstanceDraw>* OutOverlaidInstanceDraws,
|
|
TArray<uint32>* OutSelectedInstanceHitProxyIDs,
|
|
bool bSelectedInstancesOnly
|
|
)
|
|
{
|
|
if (!PrimitiveSceneProxy->IsNaniteMesh())
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto* NaniteProxy = static_cast<const Nanite::FSceneProxyBase*>(PrimitiveSceneProxy);
|
|
|
|
if (bSelectedInstancesOnly)
|
|
{
|
|
if (!NaniteProxy->IsSelected() && !NaniteProxy->WantsEditorEffects())
|
|
{
|
|
// We're only concerned with selected instances or those with editor effects
|
|
return;
|
|
}
|
|
if (NaniteProxy->IsSelected() && !NaniteProxy->HasSelectedInstances() && OutSelectedInstanceHitProxyIDs != nullptr)
|
|
{
|
|
// Primitive is selected but not individual instances, so just add the primitive's hit proxy IDs
|
|
for (auto& HitProxyId : NaniteProxy->GetHitProxyIds())
|
|
{
|
|
const uint32 HitProxyID = HitProxyId.GetColor().ToPackedABGR();
|
|
OutSelectedInstanceHitProxyIDs->Add(HitProxyID);
|
|
}
|
|
}
|
|
}
|
|
|
|
const FInstanceSceneDataBuffers* InstanceSceneDataBuffers = PrimitiveSceneInfo.GetInstanceSceneDataBuffers();
|
|
const bool bCollectInstanceHitProxyIds = bSelectedInstancesOnly &&
|
|
NaniteProxy->HasSelectedInstances() &&
|
|
OutSelectedInstanceHitProxyIDs != nullptr &&
|
|
InstanceSceneDataBuffers != nullptr &&
|
|
!InstanceSceneDataBuffers->IsInstanceDataGPUOnly();
|
|
const bool bOverlaidDraws = OutOverlaidInstanceDraws &&
|
|
NaniteProxy->WantsEditorEffects() &&
|
|
!NaniteProxy->IsSelected();
|
|
|
|
const int32 MaxInstances = PrimitiveSceneInfo.GetNumInstanceSceneDataEntries();
|
|
TArray<Nanite::FInstanceDraw>& OutDrawArray = bOverlaidDraws ? *OutOverlaidInstanceDraws : OutSelectedInstanceDraws;
|
|
OutDrawArray.Reserve(OutDrawArray.Num() + MaxInstances);
|
|
|
|
for (int32 Idx = 0; Idx < MaxInstances; ++Idx)
|
|
{
|
|
if (bCollectInstanceHitProxyIds)
|
|
{
|
|
FInstanceSceneDataBuffers::FReadView ProxyData = InstanceSceneDataBuffers->GetReadView();
|
|
// If we have per-instance editor data, exclude instance draws of unselected instances
|
|
// draws of unselected instances
|
|
if (ProxyData.InstanceEditorData.IsValidIndex(Idx))
|
|
{
|
|
FColor HitProxyColor;
|
|
bool bSelected;
|
|
FInstanceEditorData::Unpack(ProxyData.InstanceEditorData[Idx], HitProxyColor, bSelected);
|
|
if (!bSelected)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const uint32 HitProxyID = HitProxyColor.ToPackedABGR();
|
|
OutSelectedInstanceHitProxyIDs->Add(HitProxyID);
|
|
}
|
|
}
|
|
|
|
OutDrawArray.Add(
|
|
Nanite::FInstanceDraw {
|
|
uint32(PrimitiveSceneInfo.GetInstanceSceneDataOffset() + Idx),
|
|
0u
|
|
}
|
|
);
|
|
}
|
|
};
|
|
|
|
if (bEditorVisualizeLevelInstanceRelevance)
|
|
{
|
|
CollectNaniteInstanceDraws(*PrimitiveSceneInfo, PrimitiveSceneProxy, EditorVisualizeLevelInstancesNanite, nullptr, nullptr, false);
|
|
}
|
|
|
|
if (bEditorSelectionRelevance)
|
|
{
|
|
CollectNaniteInstanceDraws(*PrimitiveSceneInfo, PrimitiveSceneProxy, EditorSelectedInstancesNanite, &EditorOverlaidInstancesNanite, &EditorSelectedNaniteHitProxyIds, true);
|
|
}
|
|
#endif
|
|
|
|
if (bEditorRelevance)
|
|
{
|
|
AddEditorDynamicPrimitive(BitIndex);
|
|
}
|
|
else if(bDynamicRelevance)
|
|
{
|
|
AddDynamicPrimitive(BitIndex);
|
|
|
|
if (ViewRelevance.bHasSimpleLights)
|
|
{
|
|
VisibleDynamicPrimitivesWithSimpleLights.AddPrim(PrimitiveSceneInfo);
|
|
}
|
|
}
|
|
// Filter with !bStaticRelevance to avoid regular/non-strands geometry to be added two times.
|
|
else if (!bStaticRelevance && bHairStrandsRelevance)
|
|
{
|
|
AddDynamicPrimitive(BitIndex);
|
|
}
|
|
|
|
if (bTranslucentRelevance && !bEditorRelevance && ViewRelevance.bRenderInMainPass)
|
|
{
|
|
if (View.Family->AllowTranslucencyAfterDOF())
|
|
{
|
|
if ((ViewRelevance.bNormalTranslucency || (View.AutoBeforeDOFTranslucencyBoundary > 0.0f && ViewRelevance.bSeparateTranslucency)))
|
|
{
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_TranslucencyStandard, ViewRelevance.bUsesSceneColorCopy);
|
|
}
|
|
|
|
if ((ViewRelevance.bNormalTranslucency || (View.AutoBeforeDOFTranslucencyBoundary > 0.0f && ViewRelevance.bSeparateTranslucency)) && ViewRelevance.bTranslucencyModulate && View.Family->AllowStandardTranslucencySeparated())
|
|
{
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_TranslucencyStandardModulate, ViewRelevance.bUsesSceneColorCopy);
|
|
}
|
|
|
|
if (ViewRelevance.bSeparateTranslucency)
|
|
{
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_TranslucencyAfterDOF, ViewRelevance.bUsesSceneColorCopy);
|
|
}
|
|
|
|
if (ViewRelevance.bSeparateTranslucency && ViewRelevance.bTranslucencyModulate)
|
|
{
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_TranslucencyAfterDOFModulate, ViewRelevance.bUsesSceneColorCopy);
|
|
}
|
|
|
|
if (ViewRelevance.bPostMotionBlurTranslucency)
|
|
{
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_TranslucencyAfterMotionBlur, ViewRelevance.bUsesSceneColorCopy);
|
|
}
|
|
}
|
|
else // Otherwise, everything is rendered in a single bucket. This is not related to whether DOF is currently enabled or not.
|
|
{
|
|
// When using all translucency, Standard and AfterDOF are sorted together instead of being rendered like 2 buckets.
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_AllTranslucency, ViewRelevance.bUsesSceneColorCopy);
|
|
}
|
|
|
|
if (bIsTranslucentHoldoutEnabled)
|
|
{
|
|
TranslucentPrimCount.Add(ETranslucencyPass::TPT_TranslucencyHoldout, true); // use scene copy
|
|
}
|
|
|
|
if (ViewRelevance.bDistortion)
|
|
{
|
|
bHasDistortionPrimitives = true;
|
|
}
|
|
}
|
|
|
|
CombinedShadingModelMask |= ViewRelevance.ShadingModelMask;
|
|
SubstrateUintPerPixel = FMath::Max(SubstrateUintPerPixel, uint8(ViewRelevance.SubstrateUintPerPixel));
|
|
SubstrateTileTypeMask |= ViewRelevance.SubstrateTileTypeMask;
|
|
bUsesAnisotropy |= ViewRelevance.bUsesAnisotropy;
|
|
SubstrateClosureCountMask |= ViewRelevance.SubstrateClosureCountMask;
|
|
bUsesGlobalDistanceField |= ViewRelevance.bUsesGlobalDistanceField;
|
|
bUsesLightingChannels |= ViewRelevance.bUsesLightingChannels;
|
|
bTranslucentSurfaceLighting |= ViewRelevance.bTranslucentSurfaceLighting;
|
|
bUsesCustomDepth |= (ViewRelevance.CustomDepthStencilUsageMask & 1) > 0;
|
|
bUsesCustomStencil |= (ViewRelevance.CustomDepthStencilUsageMask & (1 << 1)) > 0;
|
|
bSceneHasSkyMaterial |= ViewRelevance.bUsesSkyMaterial;
|
|
bHasSingleLayerWaterMaterial |= ViewRelevance.bUsesSingleLayerWaterMaterial;
|
|
bUsesSecondStageDepthPass |= ViewRelevance.bRenderInSecondStageDepthPass && ShadingPath!=EShadingPath::Mobile;
|
|
|
|
if (ViewRelevance.bRenderCustomDepth)
|
|
{
|
|
bHasCustomDepthPrimitives = true;
|
|
CustomDepthStencilValues.Add(PrimitiveSceneInfo->Proxy->GetCustomDepthStencilValue());
|
|
|
|
if (PrimitiveSceneInfo->Proxy->IsNaniteMesh())
|
|
{
|
|
check(PrimitiveSceneInfo->IsIndexValid());
|
|
NaniteCustomDepthInstances.AddPrim(
|
|
FPrimitiveInstanceRange {
|
|
PrimitiveSceneInfo->GetIndex(),
|
|
PrimitiveSceneInfo->GetInstanceSceneDataOffset(),
|
|
PrimitiveSceneInfo->GetNumInstanceSceneDataEntries()
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
extern bool GUseTranslucencyShadowDepths;
|
|
if (GUseTranslucencyShadowDepths && ViewRelevance.bTranslucentSelfShadow)
|
|
{
|
|
TranslucentSelfShadowPrimitives.AddPrim(BitIndex);
|
|
}
|
|
|
|
PrimitiveSceneInfo->LastRenderTime = CurrentWorldTime;
|
|
|
|
// Update the last component render time only if we know for certain the primitive is un-occluded.
|
|
if ((View.PrimitiveDefinitelyUnoccludedMap[BitIndex] || View.Family->EngineShowFlags.Wireframe) && !PrimitiveSceneProxy->IsAlwaysVisible())
|
|
{
|
|
const bool bUpdateLastRenderTimeOnScreen = true;
|
|
PrimitiveSceneInfo->UpdateComponentLastRenderTime(CurrentWorldTime, bUpdateLastRenderTimeOnScreen);
|
|
}
|
|
|
|
// Cache the nearest reflection proxy if needed
|
|
if (PrimitiveSceneInfo->NeedsReflectionCaptureUpdate())
|
|
{
|
|
// mobile should not have any outstanding reflection capture update requests at this point, except for when lighting isn't rebuilt
|
|
PrimitiveSceneInfo->CacheReflectionCaptures();
|
|
}
|
|
|
|
if (PrimitiveSceneInfo->NeedsIndirectLightingCacheBufferUpdate())
|
|
{
|
|
DirtyIndirectLightingCacheBufferPrimitives.AddPrim(PrimitiveSceneInfo);
|
|
}
|
|
}
|
|
|
|
static_assert(sizeof(WriteView.NumVisibleStaticMeshElements) == sizeof(int32), "Atomic is the wrong size");
|
|
FPlatformAtomics::InterlockedAdd((volatile int32*)&WriteView.NumVisibleStaticMeshElements, NumVisibleStaticMeshElements);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FComputeAndMarkRelevance::FComputeAndMarkRelevance(FVisibilityTaskData& InTaskData, FScene& InScene, FViewInfo& InView, uint8 InViewIndex, const UE::Tasks::FTask& InPrerequisitesTask)
|
|
: TaskData(InTaskData)
|
|
, Scene(InScene)
|
|
, View(InView)
|
|
, ViewCommands(TaskData.DynamicMeshElements.ViewCommandsPerView[InViewIndex])
|
|
, ViewIndex(InViewIndex)
|
|
, ViewData(View)
|
|
, NumMeshes(Scene.StaticMeshes.GetMaxIndex())
|
|
, NumPrimitivesPerPacket(InTaskData.TaskConfig.Relevance.NumPrimitivesPerPacket)
|
|
, PrerequisitesTask(InPrerequisitesTask)
|
|
, bLaunchOnAddPrimitive(TaskData.TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel)
|
|
, bFinished(!bLaunchOnAddPrimitive)
|
|
{
|
|
MarkMasks = (uint8*)TaskData.Allocator.Malloc(NumMeshes + 31, 8); // some padding to simplify the high speed transpose
|
|
FMemory::Memzero(MarkMasks, NumMeshes + 31);
|
|
Packets.Reserve(InTaskData.TaskConfig.Relevance.NumEstimatedPackets);
|
|
CreateRelevancePacket();
|
|
}
|
|
|
|
void FComputeAndMarkRelevance::AddPrimitives(FPrimitiveIndexList&& PrimitiveIndexList)
|
|
{
|
|
if (PrimitiveIndexList.Num() == NumPrimitivesPerPacket)
|
|
{
|
|
// Create a one-off packet that will take all the primitives.
|
|
FRelevancePacket* Packet = CreateRelevancePacket();
|
|
Packet->Input.Prims = MoveTemp(PrimitiveIndexList);
|
|
|
|
if (bLaunchOnAddPrimitive)
|
|
{
|
|
Packet->LaunchComputeRelevanceTask();
|
|
}
|
|
|
|
// Put the previous last packet that was in progress back in the last slot.
|
|
Swap(Packets[Packets.Num() - 1], Packets[Packets.Num() - 2]);
|
|
}
|
|
|
|
else
|
|
{
|
|
for (int32 Index : PrimitiveIndexList)
|
|
{
|
|
AddPrimitive(Index);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FComputeAndMarkRelevance::AddPrimitive(int32 Index)
|
|
{
|
|
FRelevancePacket* Packet = Packets.Last();
|
|
|
|
if (Packet->Input.AddPrim(Index); Packet->Input.IsFull())
|
|
{
|
|
if (bLaunchOnAddPrimitive)
|
|
{
|
|
Packet->LaunchComputeRelevanceTask();
|
|
}
|
|
CreateRelevancePacket();
|
|
}
|
|
}
|
|
|
|
void FComputeAndMarkRelevance::Finish(UE::Tasks::FTaskEvent& ComputeRelevanceTaskEvent)
|
|
{
|
|
check(!bFinished);
|
|
bFinished = true;
|
|
|
|
SCOPED_NAMED_EVENT(FinishRelevance, FColor::Magenta);
|
|
|
|
Packets.Last()->LaunchComputeRelevanceTask();
|
|
|
|
for (FRelevancePacket* Packet : Packets)
|
|
{
|
|
if (Packet->bComputeRelevanceTaskLaunched)
|
|
{
|
|
ComputeRelevanceTaskEvent.AddPrerequisites(Packet->ComputeRelevanceTask);
|
|
}
|
|
}
|
|
|
|
ComputeRelevanceTaskEvent.Trigger();
|
|
}
|
|
|
|
void FComputeAndMarkRelevance::Finalize()
|
|
{
|
|
check(bFinished && !bFinalized);
|
|
bFinalized = true;
|
|
PrerequisitesTask.Wait();
|
|
|
|
if (!bLaunchOnAddPrimitive)
|
|
{
|
|
ParallelFor(Packets.Num(), [this](int32 Index)
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
FDynamicPrimitiveIndexList DynamicPrimitiveIndexList;
|
|
|
|
FRelevancePacket* Packet = Packets[Index];
|
|
Packet->ComputeRelevance(DynamicPrimitiveIndexList);
|
|
});
|
|
}
|
|
|
|
SCOPED_NAMED_EVENT(FinalizeRelevance, FColor::Magenta);
|
|
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_ComputeAndMarkRelevanceForViewParallel_Finalize);
|
|
|
|
for (int32 PassIndex = 0; PassIndex < EMeshPass::Num; PassIndex++)
|
|
{
|
|
int32 NumVisibleCachedMeshDrawCommands = 0;
|
|
int32 NumDynamicBuildRequests = 0;
|
|
int32 NumDynamicBuildFlags = 0;
|
|
|
|
for (auto Packet : Packets)
|
|
{
|
|
NumVisibleCachedMeshDrawCommands += Packet->DrawCommandPacket.VisibleCachedDrawCommands[PassIndex].Num();
|
|
NumDynamicBuildRequests += Packet->DrawCommandPacket.DynamicBuildRequests[PassIndex].Num();
|
|
NumDynamicBuildFlags += Packet->DrawCommandPacket.DynamicBuildFlags[PassIndex].Num();
|
|
}
|
|
|
|
ViewCommands.MeshCommands[PassIndex].Reserve(NumVisibleCachedMeshDrawCommands);
|
|
ViewCommands.DynamicMeshCommandBuildRequests[PassIndex].Reserve(NumDynamicBuildRequests);
|
|
ViewCommands.DynamicMeshCommandBuildFlags[PassIndex].Reserve(NumDynamicBuildFlags);
|
|
check(NumDynamicBuildRequests == NumDynamicBuildFlags);
|
|
}
|
|
|
|
View.DirtyIndirectLightingCacheBufferPrimitivesMutex.Lock();
|
|
|
|
for (auto Packet : Packets)
|
|
{
|
|
Packet->Finalize();
|
|
delete Packet;
|
|
}
|
|
|
|
View.DirtyIndirectLightingCacheBufferPrimitivesMutex.Unlock();
|
|
|
|
Packets.Empty();
|
|
|
|
// Finalize Nanite materials
|
|
if (TaskData.bAddNaniteRelevance)
|
|
{
|
|
// This needs to complete before InitViews runs so that combined primitive/material relevance has been computed for Nanite
|
|
Scene.WaitForCacheNaniteMaterialBinsTask();
|
|
|
|
FViewInfo& WriteView = View;
|
|
{
|
|
const FNaniteShadingPipelines& ShadingPipelines = Scene.NaniteShadingPipelines[ENaniteMeshPass::BasePass];
|
|
const FPrimitiveViewRelevance& CombinedRelevance = ShadingPipelines.CombinedRelevance;
|
|
|
|
WriteView.ShadingModelMaskInView |= CombinedRelevance.ShadingModelMask;
|
|
WriteView.bUsesGlobalDistanceField |= CombinedRelevance.bUsesGlobalDistanceField;
|
|
WriteView.bUsesLightingChannels |= CombinedRelevance.bUsesLightingChannels;
|
|
WriteView.bSceneHasSkyMaterial |= CombinedRelevance.bUsesSkyMaterial;
|
|
WriteView.bHasDistortionPrimitives |= CombinedRelevance.bDistortion;
|
|
WriteView.bHasCustomDepthPrimitives |= CombinedRelevance.bRenderCustomDepth;
|
|
WriteView.bUsesCustomDepth |= (CombinedRelevance.CustomDepthStencilUsageMask & 1) > 0;
|
|
WriteView.bUsesCustomStencil |= (CombinedRelevance.CustomDepthStencilUsageMask & (1 << 1)) > 0;
|
|
WriteView.SubstrateViewData.MaxClosurePerPixel = FMath::Max(WriteView.SubstrateViewData.MaxClosurePerPixel, 8u - FMath::CountLeadingZeros8(CombinedRelevance.SubstrateClosureCountMask));
|
|
WriteView.SubstrateViewData.MaxBytesPerPixel = FMath::Max(WriteView.SubstrateViewData.MaxBytesPerPixel, CombinedRelevance.SubstrateUintPerPixel * 4u);
|
|
WriteView.SubstrateViewData.UsesTileTypeMask |= CombinedRelevance.SubstrateTileTypeMask;
|
|
WriteView.SubstrateViewData.bUsesAnisotropy |= CombinedRelevance.bUsesAnisotropy;
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACE_COUNTER_SET(Scene_Visibility_Relevance_NumPrimitivesProcessed, TaskData.TaskConfig.Relevance.NumPrimitivesProcessed);
|
|
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_ComputeAndMarkRelevanceForViewParallel_TransposeMeshBits);
|
|
check(View.StaticMeshVisibilityMap.Num() == NumMeshes &&
|
|
View.StaticMeshFadeOutDitheredLODMap.Num() == NumMeshes &&
|
|
View.StaticMeshFadeInDitheredLODMap.Num() == NumMeshes
|
|
);
|
|
uint32* RESTRICT StaticMeshVisibilityMap_Words = View.StaticMeshVisibilityMap.GetData();
|
|
uint32* RESTRICT StaticMeshFadeOutDitheredLODMap_Words = View.StaticMeshFadeOutDitheredLODMap.GetData();
|
|
uint32* RESTRICT StaticMeshFadeInDitheredLODMap_Words = View.StaticMeshFadeInDitheredLODMap.GetData();
|
|
const uint64* RESTRICT MarkMasks64 = (const uint64 * RESTRICT)MarkMasks;
|
|
const uint8* RESTRICT MarkMasks8 = MarkMasks;
|
|
for (uint32 BaseIndex = 0; BaseIndex < NumMeshes; BaseIndex += 32)
|
|
{
|
|
uint32 StaticMeshVisibilityMap_Word = 0;
|
|
uint32 StaticMeshFadeOutDitheredLODMap_Word = 0;
|
|
uint32 StaticMeshFadeInDitheredLODMap_Word = 0;
|
|
uint32 Mask = 1;
|
|
bool bAny = false;
|
|
for (int32 QWordIndex = 0; QWordIndex < 4; QWordIndex++)
|
|
{
|
|
if (*MarkMasks64++)
|
|
{
|
|
for (int32 ByteIndex = 0; ByteIndex < 8; ByteIndex++, Mask <<= 1, MarkMasks8++)
|
|
{
|
|
uint8 MaskMask = *MarkMasks8;
|
|
StaticMeshVisibilityMap_Word |= (MaskMask & EMarkMaskBits::StaticMeshVisibilityMapMask) ? Mask : 0;
|
|
StaticMeshFadeOutDitheredLODMap_Word |= (MaskMask & EMarkMaskBits::StaticMeshFadeOutDitheredLODMapMask) ? Mask : 0;
|
|
StaticMeshFadeInDitheredLODMap_Word |= (MaskMask & EMarkMaskBits::StaticMeshFadeInDitheredLODMapMask) ? Mask : 0;
|
|
}
|
|
bAny = true;
|
|
}
|
|
else
|
|
{
|
|
MarkMasks8 += 8;
|
|
Mask <<= 8;
|
|
}
|
|
}
|
|
if (bAny)
|
|
{
|
|
checkSlow(!*StaticMeshVisibilityMap_Words && !*StaticMeshFadeOutDitheredLODMap_Words && !*StaticMeshFadeInDitheredLODMap_Words);
|
|
*StaticMeshVisibilityMap_Words = StaticMeshVisibilityMap_Word;
|
|
*StaticMeshFadeOutDitheredLODMap_Words = StaticMeshFadeOutDitheredLODMap_Word;
|
|
*StaticMeshFadeInDitheredLODMap_Words = StaticMeshFadeInDitheredLODMap_Word;
|
|
}
|
|
StaticMeshVisibilityMap_Words++;
|
|
StaticMeshFadeOutDitheredLODMap_Words++;
|
|
StaticMeshFadeInDitheredLODMap_Words++;
|
|
}
|
|
|
|
if (View.bIsSinglePassStereo)
|
|
{
|
|
check(View.StereoPass != EStereoscopicPass::eSSP_SECONDARY); // Secondary views should not calculate relevance
|
|
if (const FViewInfo* SecondaryViewConst = View.GetInstancedView())
|
|
{
|
|
FViewInfo* SecondaryView = const_cast<FViewInfo*>(SecondaryViewConst);
|
|
SecondaryView->PrimitiveVisibilityMap = View.PrimitiveVisibilityMap;
|
|
SecondaryView->PrimitiveRayTracingVisibilityMap = View.PrimitiveRayTracingVisibilityMap;
|
|
SecondaryView->PrimitiveDefinitelyUnoccludedMap = View.PrimitiveDefinitelyUnoccludedMap;
|
|
SecondaryView->PrimitiveViewRelevanceMap = View.PrimitiveViewRelevanceMap;
|
|
SecondaryView->StaticMeshVisibilityMap = View.StaticMeshVisibilityMap;
|
|
SecondaryView->PrimitivesLODMask = View.PrimitivesLODMask;
|
|
SecondaryView->NumVisibleDynamicPrimitives = View.NumVisibleDynamicPrimitives;
|
|
SecondaryView->NumVisibleDynamicEditorPrimitives = View.NumVisibleDynamicEditorPrimitives;
|
|
|
|
SecondaryView->ShadingModelMaskInView = View.ShadingModelMaskInView;
|
|
SecondaryView->bUsesGlobalDistanceField = View.bUsesGlobalDistanceField;
|
|
SecondaryView->bUsesLightingChannels = View.bUsesLightingChannels;
|
|
SecondaryView->bTranslucentSurfaceLighting = View.bTranslucentSurfaceLighting;
|
|
SecondaryView->bSceneHasSkyMaterial = View.bSceneHasSkyMaterial;
|
|
SecondaryView->bHasSingleLayerWaterMaterial = View.bHasSingleLayerWaterMaterial;
|
|
SecondaryView->bUsesSecondStageDepthPass = View.bUsesSecondStageDepthPass;
|
|
SecondaryView->TranslucentPrimCount = View.TranslucentPrimCount;
|
|
SecondaryView->bHasDistortionPrimitives = View.bHasDistortionPrimitives;
|
|
SecondaryView->bHasCustomDepthPrimitives = View.bHasCustomDepthPrimitives;
|
|
SecondaryView->CustomDepthStencilValues = View.CustomDepthStencilValues;
|
|
SecondaryView->bUsesCustomDepth = View.bUsesCustomDepth;
|
|
SecondaryView->bUsesCustomStencil = View.bUsesCustomStencil;
|
|
SecondaryView->SubstrateViewData.MaxClosurePerPixel = View.SubstrateViewData.MaxClosurePerPixel;
|
|
SecondaryView->SubstrateViewData.MaxBytesPerPixel = View.SubstrateViewData.MaxClosurePerPixel;
|
|
SecondaryView->SubstrateViewData.UsesTileTypeMask = View.SubstrateViewData.UsesTileTypeMask;
|
|
SecondaryView->SubstrateViewData.bUsesAnisotropy = View.SubstrateViewData.bUsesAnisotropy;
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void ComputeDynamicMeshRelevance(
|
|
EShadingPath ShadingPath,
|
|
bool bAddLightmapDensityCommands,
|
|
bool bIsTLVUsingVoxelMarking,
|
|
const FPrimitiveViewRelevance& ViewRelevance,
|
|
const FMeshBatchAndRelevance& MeshBatch,
|
|
FViewInfo& View,
|
|
FMeshPassMask& PassMask,
|
|
FPrimitiveSceneInfo* PrimitiveSceneInfo,
|
|
const FPrimitiveBounds& Bounds)
|
|
{
|
|
const int32 NumElements = MeshBatch.Mesh->Elements.Num();
|
|
const bool bIsTranslucentClippedDepthEnabled = NeedTSRThinGeometryDetectionPass(View);
|
|
|
|
if (ViewRelevance.bDrawRelevance && (ViewRelevance.bRenderInMainPass || ViewRelevance.bRenderCustomDepth || ViewRelevance.bRenderInDepthPass))
|
|
{
|
|
if (ViewRelevance.bRenderInSecondStageDepthPass && ShadingPath != EShadingPath::Mobile)
|
|
{
|
|
PassMask.Set(EMeshPass::SecondStageDepthPass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::SecondStageDepthPass] += NumElements;
|
|
}
|
|
else
|
|
{
|
|
PassMask.Set(EMeshPass::DepthPass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::DepthPass] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bRenderInMainPass || ViewRelevance.bRenderCustomDepth)
|
|
{
|
|
PassMask.Set(EMeshPass::BasePass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::BasePass] += NumElements;
|
|
|
|
if (ViewRelevance.bUsesSkyMaterial)
|
|
{
|
|
PassMask.Set(EMeshPass::SkyPass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::SkyPass] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bUsesAnisotropy)
|
|
{
|
|
PassMask.Set(EMeshPass::AnisotropyPass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::AnisotropyPass] += NumElements;
|
|
}
|
|
|
|
if (ShadingPath == EShadingPath::Mobile)
|
|
{
|
|
PassMask.Set(EMeshPass::MobileBasePassCSM);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::MobileBasePassCSM] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bRenderCustomDepth)
|
|
{
|
|
PassMask.Set(EMeshPass::CustomDepth);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::CustomDepth] += NumElements;
|
|
}
|
|
|
|
if (bAddLightmapDensityCommands)
|
|
{
|
|
PassMask.Set(EMeshPass::LightmapDensity);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::LightmapDensity] += NumElements;
|
|
}
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
else if (View.Family->UseDebugViewPS())
|
|
{
|
|
PassMask.Set(EMeshPass::DebugViewMode);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::DebugViewMode] += NumElements;
|
|
}
|
|
#endif
|
|
|
|
#if WITH_EDITOR
|
|
if (View.bAllowTranslucentPrimitivesInHitProxy)
|
|
{
|
|
PassMask.Set(EMeshPass::HitProxy);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::HitProxy] += NumElements;
|
|
}
|
|
else
|
|
{
|
|
PassMask.Set(EMeshPass::HitProxyOpaqueOnly);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::HitProxyOpaqueOnly] += NumElements;
|
|
}
|
|
#endif
|
|
|
|
if (ViewRelevance.bVelocityRelevance)
|
|
{
|
|
PassMask.Set(EMeshPass::Velocity);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::Velocity] += NumElements;
|
|
|
|
if (MeshBatch.PrimitiveSceneProxy->AnyMaterialUsesMotionVectorWorldOffset())
|
|
{
|
|
View.bUsesMotionVectorWorldOffset = true;
|
|
}
|
|
}
|
|
|
|
if (ViewRelevance.bOutputsTranslucentVelocity)
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucentVelocity);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucentVelocity] += NumElements;
|
|
const bool bAnyMaterialUsesTemporalResponsiveness = MeshBatch.PrimitiveSceneProxy->AnyMaterialUsesTemporalResponsiveness();
|
|
if (ViewRelevance.bNormalTranslucency && bIsTranslucentClippedDepthEnabled && bAnyMaterialUsesTemporalResponsiveness)
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucentVelocityClippedDepth);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucentVelocityClippedDepth] += NumElements;
|
|
}
|
|
}
|
|
|
|
if (ViewRelevance.bUsesSingleLayerWaterMaterial)
|
|
{
|
|
PassMask.Set(EMeshPass::SingleLayerWaterPass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::SingleLayerWaterPass] += NumElements;
|
|
PassMask.Set(EMeshPass::SingleLayerWaterDepthPrepass);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::SingleLayerWaterDepthPrepass] += NumElements;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ViewRelevance.HasTranslucency()
|
|
&& !ViewRelevance.bEditorPrimitiveRelevance
|
|
&& ViewRelevance.bRenderInMainPass)
|
|
{
|
|
if (View.Family->AllowTranslucencyAfterDOF())
|
|
{
|
|
if ((ViewRelevance.bNormalTranslucency || (View.AutoBeforeDOFTranslucencyBoundary > 0.0f && ViewRelevance.bSeparateTranslucency)))
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyStandard);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyStandard] += NumElements;
|
|
}
|
|
|
|
if ((ViewRelevance.bNormalTranslucency || (View.AutoBeforeDOFTranslucencyBoundary > 0.0f && ViewRelevance.bSeparateTranslucency)) && ViewRelevance.bTranslucencyModulate && View.Family->AllowStandardTranslucencySeparated())
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyStandardModulate);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyStandardModulate] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bSeparateTranslucency)
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyAfterDOF);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyAfterDOF] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bSeparateTranslucency && ViewRelevance.bTranslucencyModulate)
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyAfterDOFModulate);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyAfterDOFModulate] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bPostMotionBlurTranslucency)
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyAfterMotionBlur);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyAfterMotionBlur] += NumElements;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyAll);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyAll] += NumElements;
|
|
}
|
|
|
|
{
|
|
PassMask.Set(EMeshPass::TranslucencyHoldout);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::TranslucencyHoldout] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bTranslucentSurfaceLighting || bIsTLVUsingVoxelMarking)
|
|
{
|
|
PassMask.Set(EMeshPass::LumenTranslucencyRadianceCacheMark);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::LumenTranslucencyRadianceCacheMark] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bTranslucentSurfaceLighting)
|
|
{
|
|
PassMask.Set(EMeshPass::LumenFrontLayerTranslucencyGBuffer);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::LumenFrontLayerTranslucencyGBuffer] += NumElements;
|
|
}
|
|
|
|
if (ViewRelevance.bDistortion)
|
|
{
|
|
PassMask.Set(EMeshPass::Distortion);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::Distortion] += NumElements;
|
|
}
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
if (ViewRelevance.bDrawRelevance)
|
|
{
|
|
PassMask.Set(EMeshPass::EditorSelection);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::EditorSelection] += NumElements;
|
|
|
|
PassMask.Set(EMeshPass::EditorLevelInstance);
|
|
View.NumVisibleDynamicMeshElements[EMeshPass::EditorLevelInstance] += NumElements;
|
|
}
|
|
|
|
// Hair strands are not rendered into the base pass (bRenderInMainPass=0) and so this
|
|
// adds a special pass for allowing hair strands to be selectable.
|
|
if (ViewRelevance.bHairStrands)
|
|
{
|
|
const EMeshPass::Type MeshPassType = View.bAllowTranslucentPrimitivesInHitProxy ? EMeshPass::HitProxy : EMeshPass::HitProxyOpaqueOnly;
|
|
PassMask.Set(MeshPassType);
|
|
View.NumVisibleDynamicMeshElements[MeshPassType] += NumElements;
|
|
}
|
|
#endif
|
|
|
|
if (ViewRelevance.bHasVolumeMaterialDomain)
|
|
{
|
|
if (ShouldRenderMeshBatchWithHeterogeneousVolumes(MeshBatch.Mesh, MeshBatch.PrimitiveSceneProxy, View.FeatureLevel))
|
|
{
|
|
View.HeterogeneousVolumesMeshBatches.AddUninitialized(1);
|
|
FVolumetricMeshBatch& BatchAndProxy = View.HeterogeneousVolumesMeshBatches.Last();
|
|
BatchAndProxy.Mesh = MeshBatch.Mesh;
|
|
BatchAndProxy.Proxy = MeshBatch.PrimitiveSceneProxy;
|
|
}
|
|
else
|
|
{
|
|
View.VolumetricMeshBatches.AddUninitialized(1);
|
|
FVolumetricMeshBatch& BatchAndProxy = View.VolumetricMeshBatches.Last();
|
|
BatchAndProxy.Mesh = MeshBatch.Mesh;
|
|
BatchAndProxy.Proxy = MeshBatch.PrimitiveSceneProxy;
|
|
}
|
|
}
|
|
|
|
if (ViewRelevance.bUsesSkyMaterial)
|
|
{
|
|
View.SkyMeshBatches.AddUninitialized(1);
|
|
FSkyMeshBatch& BatchAndProxy = View.SkyMeshBatches.Last();
|
|
BatchAndProxy.Mesh = MeshBatch.Mesh;
|
|
BatchAndProxy.Proxy = MeshBatch.PrimitiveSceneProxy;
|
|
BatchAndProxy.bVisibleInMainPass = ViewRelevance.bRenderInMainPass;
|
|
BatchAndProxy.bVisibleInRealTimeSkyCapture = PrimitiveSceneInfo->bVisibleInRealTimeSkyCapture;
|
|
}
|
|
|
|
if (ViewRelevance.HasTranslucency() && PrimitiveSceneInfo->Proxy->SupportsSortedTriangles())
|
|
{
|
|
View.SortedTrianglesMeshBatches.AddUninitialized(1);
|
|
FSortedTrianglesMeshBatch& BatchAndProxy = View.SortedTrianglesMeshBatches.Last();
|
|
BatchAndProxy.Mesh = MeshBatch.Mesh;
|
|
BatchAndProxy.Proxy = MeshBatch.PrimitiveSceneProxy;
|
|
}
|
|
|
|
if (ViewRelevance.bRenderInMainPass && ViewRelevance.bDecal)
|
|
{
|
|
// DecalRenderTargetModeMask could be cached in FMeshBatchAndRelevance as well
|
|
const FMaterial& Material = MeshBatch.Mesh->MaterialRenderProxy->GetIncompleteMaterialWithFallback(View.FeatureLevel);
|
|
uint8 DecalRenderTargetModeMask = DecalRendering::GetDecalRenderTargetModeMask(Material, View.FeatureLevel);
|
|
for (uint8 DecalRenderTargetMode = 0; DecalRenderTargetMode < (uint8)EDecalRenderTargetMode::Num; ++DecalRenderTargetMode)
|
|
{
|
|
if (DecalRendering::IsCompatibleWithRenderTargetMode(DecalRenderTargetModeMask, (EDecalRenderTargetMode)DecalRenderTargetMode))
|
|
{
|
|
EMeshPass::Type DecalMeshPassType = DecalRendering::GetMeshPassType((EDecalRenderTargetMode)DecalRenderTargetMode);
|
|
PassMask.Set(DecalMeshPassType);
|
|
View.NumVisibleDynamicMeshElements[DecalMeshPassType] += NumElements;
|
|
}
|
|
}
|
|
}
|
|
|
|
const bool bIsHairStrandsCompatible = ViewRelevance.bHairStrands && IsHairStrandsEnabled(EHairStrandsShaderType::All, View.GetShaderPlatform());
|
|
if (bIsHairStrandsCompatible)
|
|
{
|
|
// Disable bCheckLengthScaleInitialize when running hit proxy as LengthScale is not initialized
|
|
const bool bCheckLengthScale = !View.Family->EngineShowFlags.HitProxies;
|
|
if (HairStrands::IsHairStrandsVF(MeshBatch.Mesh) && HairStrands::IsHairVisible(MeshBatch, bCheckLengthScale))
|
|
{
|
|
View.HairStrandsMeshElements.AddUninitialized(1);
|
|
FMeshBatchAndRelevance& BatchAndProxy = View.HairStrandsMeshElements.Last();
|
|
BatchAndProxy = MeshBatch;
|
|
}
|
|
|
|
if (HairStrands::IsHairCardsVF(MeshBatch.Mesh) && ViewRelevance.bRenderInMainPass)
|
|
{
|
|
View.HairCardsMeshElements.AddUninitialized(1);
|
|
FMeshBatchAndRelevance& BatchAndProxy = View.HairCardsMeshElements.Last();
|
|
BatchAndProxy = MeshBatch;
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FGPUOcclusionPacket::FGPUOcclusionPacket(FVisibilityViewPacket& InViewPacket, const FGPUOcclusionState& InOcclusionState)
|
|
: ViewPacket(InViewPacket)
|
|
, View(ViewPacket.View)
|
|
, ViewState(*ViewPacket.ViewState)
|
|
, ViewElementPDI(ViewPacket.ViewElementPDI)
|
|
, HZBOcclusionTests(ViewState.HZBOcclusionTests)
|
|
, OcclusionFeedback(ViewState.OcclusionFeedback)
|
|
, PrimitiveOcclusionHistorySet(ViewState.Occlusion.PrimitiveOcclusionHistorySet)
|
|
, Scene(ViewPacket.Scene)
|
|
, OcclusionState(InOcclusionState)
|
|
, ViewOrigin(View.ViewMatrices.GetViewOrigin())
|
|
, OcclusionFrameCounter(ViewState.OcclusionFrameCounter)
|
|
, PrimitiveProbablyVisibleTime(GEngine->PrimitiveProbablyVisibleTime)
|
|
, CurrentRealTime(View.Family->Time.GetRealTimeSeconds())
|
|
, NeverOcclusionTestDistanceSquared(GNeverOcclusionTestDistance* GNeverOcclusionTestDistance)
|
|
, bUseOcclusionFeedback(View.FeatureLevel == ERHIFeatureLevel::ES3_1 && OcclusionFeedback.IsInitialized())
|
|
, bNewlyConsideredBBoxExpandActive(
|
|
GExpandNewlyOcclusionTestedBBoxesAmount > 0.0f && GExpandNewlyOcclusionTestedBBoxesScreenSpace > 0.0f &&
|
|
GFramesToExpandNewlyOcclusionTestedBBoxes > 0 && GFramesNotOcclusionTestedToExpandBBoxes > 0)
|
|
{}
|
|
|
|
template <bool bIsParallel, typename VisitorType>
|
|
bool FGPUOcclusionPacket::OcclusionCullPrimitive(VisitorType& Visitor, FOcclusionCullResult& Result, int32 Index)
|
|
{
|
|
const uint8 OcclusionFlags = Scene.PrimitiveOcclusionFlags[Index];
|
|
|
|
int32 NumSubQueries = 1;
|
|
bool bSubQueries = false;
|
|
const TArray<FBoxSphereBounds>* SubBounds = nullptr;
|
|
int32 SubIsOccludedStart = 0;
|
|
|
|
const auto SetAtomicBit = [] (FSceneBitArray& Array, int32 Index, bool Value)
|
|
{
|
|
if constexpr (bIsParallel)
|
|
{
|
|
Array[Index].AtomicSet(Value);
|
|
}
|
|
else
|
|
{
|
|
Array[Index] = Value;
|
|
}
|
|
};
|
|
|
|
if (OcclusionFlags & EOcclusionFlags::IsForceHidden)
|
|
{
|
|
// Primitive is not visible and does not need to be occlusion tested
|
|
return false;
|
|
}
|
|
|
|
if ((OcclusionFlags & EOcclusionFlags::HasSubprimitiveQueries) && OcclusionState.bAllowSubQueries)
|
|
{
|
|
FPrimitiveSceneProxy* Proxy = Scene.PrimitiveSceneProxies[Index];
|
|
SubBounds = Proxy->GetOcclusionQueries(&View);
|
|
NumSubQueries = SubBounds->Num();
|
|
bSubQueries = true;
|
|
if (!NumSubQueries)
|
|
{
|
|
SetAtomicBit(View.PrimitiveVisibilityMap, Index, false);
|
|
return false;
|
|
}
|
|
|
|
if (!SubIsOccluded || SubIsOccluded->Num() + NumSubQueries > SubIsOccluded->Max())
|
|
{
|
|
SubIsOccluded = View.Allocator.Create<TArray<bool>>();
|
|
SubIsOccluded->Reserve(FMath::Max<uint32>(NumSubQueries, SubIsOccludedPageSize));
|
|
}
|
|
|
|
SubIsOccludedStart = SubIsOccluded->Num();
|
|
}
|
|
|
|
bool bIsVisible = true;
|
|
bool bAllSubOcclusionStateIsDefinite = true;
|
|
bool bAllSubOccluded = true;
|
|
FPrimitiveComponentId PrimitiveId = Scene.PrimitiveComponentIds[Index];
|
|
|
|
// Presolve for screen space bbox expansion
|
|
FVector4 ExpansionWorldSpaceNewlyConsidered;
|
|
FVector4 ExpansionWorldSpaceNotNewlyConsidered;
|
|
FVector4 ViewProjectionHomogeneousVector;
|
|
if (GExpandAllTestedBBoxesScreenSpace > 0.0f || GExpandNewlyOcclusionTestedBBoxesScreenSpace > 0.0f)
|
|
{
|
|
const FMatrix& InvViewProjectionMatrix = View.ViewMatrices.GetInvViewProjectionMatrix();
|
|
|
|
float ExtentNewly = GExpandAllTestedBBoxesScreenSpace + GExpandNewlyOcclusionTestedBBoxesScreenSpace;
|
|
FVector4 ExpansionScreenSpaceNewlyConsidered = FVector4(ExtentNewly / View.ViewRect.Width(), ExtentNewly / View.ViewRect.Height(), 0.0f, 0.0f);
|
|
ExpansionWorldSpaceNewlyConsidered = InvViewProjectionMatrix.TransformFVector4(ExpansionScreenSpaceNewlyConsidered);
|
|
|
|
float ExtentNotNewly = GExpandAllTestedBBoxesScreenSpace;
|
|
FVector4 ExpansionScreenSpaceNotNewlyConsidered = FVector4(ExtentNotNewly / View.ViewRect.Width(), ExtentNotNewly / View.ViewRect.Height(), 0.0f, 0.0f);
|
|
ExpansionWorldSpaceNotNewlyConsidered = InvViewProjectionMatrix.TransformFVector4(ExpansionScreenSpaceNotNewlyConsidered);
|
|
|
|
const FMatrix& ViewProjectionMatrix = View.ViewMatrices.GetViewProjectionMatrix();
|
|
ViewProjectionHomogeneousVector = FVector4(ViewProjectionMatrix.M[0][3], ViewProjectionMatrix.M[1][3], ViewProjectionMatrix.M[2][3], ViewProjectionMatrix.M[3][3]);
|
|
}
|
|
|
|
for (int32 SubQuery = 0; SubQuery < NumSubQueries; SubQuery++)
|
|
{
|
|
FPrimitiveOcclusionHistory* PrimitiveOcclusionHistory = PrimitiveOcclusionHistorySet.Find(FPrimitiveOcclusionHistoryKey(PrimitiveId, SubQuery));
|
|
|
|
bool bIsOccluded = false;
|
|
bool bOcclusionStateIsDefinite = false;
|
|
|
|
if (!PrimitiveOcclusionHistory)
|
|
{
|
|
PrimitiveOcclusionHistory = Visitor.AddOcclusionHistory(FPrimitiveOcclusionHistory(PrimitiveId, SubQuery));
|
|
}
|
|
else
|
|
{
|
|
if (View.bIgnoreExistingQueries)
|
|
{
|
|
// If the view is ignoring occlusion queries, the primitive is definitely unoccluded.
|
|
bOcclusionStateIsDefinite = View.bDisableQuerySubmissions;
|
|
}
|
|
else
|
|
{
|
|
if (bUseOcclusionFeedback)
|
|
{
|
|
bIsOccluded = OcclusionFeedback.IsOccluded(FPrimitiveOcclusionHistoryKey(PrimitiveId, SubQuery));
|
|
bOcclusionStateIsDefinite = true;
|
|
}
|
|
else if (OcclusionState.bHZBOcclusion)
|
|
{
|
|
if (HZBOcclusionTests.IsValidFrame(PrimitiveOcclusionHistory->LastTestFrameNumber))
|
|
{
|
|
bIsOccluded = !HZBOcclusionTests.IsVisible(PrimitiveOcclusionHistory->HZBTestIndex);
|
|
bOcclusionStateIsDefinite = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Read the occlusion query results.
|
|
uint64 NumSamples = 0;
|
|
bool bGrouped = false;
|
|
FRHIRenderQuery* PastQuery = PrimitiveOcclusionHistory->GetQueryForReading(OcclusionFrameCounter, OcclusionState.NumBufferedFrames, OcclusionState.ReadBackLagTolerance, bGrouped);
|
|
if (PastQuery)
|
|
{
|
|
if (RHIGetRenderQueryResult(PastQuery, NumSamples, true))
|
|
{
|
|
// we render occlusion without MSAA
|
|
uint32 NumPixels = (uint32)NumSamples;
|
|
|
|
// The primitive is occluded if none of its bounding box's pixels were visible in the previous frame's occlusion query.
|
|
bIsOccluded = (NumPixels == 0);
|
|
|
|
if (!bIsOccluded)
|
|
{
|
|
checkSlow(View.OneOverNumPossiblePixels > 0.0f);
|
|
PrimitiveOcclusionHistory->LastPixelsPercentage = NumPixels * View.OneOverNumPossiblePixels;
|
|
}
|
|
else
|
|
{
|
|
PrimitiveOcclusionHistory->LastPixelsPercentage = 0.0f;
|
|
}
|
|
|
|
// Flag the primitive's occlusion state as definite if it wasn't grouped.
|
|
bOcclusionStateIsDefinite = !bGrouped;
|
|
}
|
|
else
|
|
{
|
|
// If the occlusion query failed, treat the primitive as visible.
|
|
// already set bIsOccluded = false;
|
|
}
|
|
|
|
Result.NumTestedQueries++;
|
|
}
|
|
else
|
|
{
|
|
if (OcclusionState.NumBufferedFrames > 1 || GRHIMaximumInFlightQueries < MAX_int32)
|
|
{
|
|
// If there's no occlusion query for the primitive, assume it is whatever it was last frame
|
|
bIsOccluded = PrimitiveOcclusionHistory->WasOccludedLastFrame;
|
|
bOcclusionStateIsDefinite = PrimitiveOcclusionHistory->OcclusionStateWasDefiniteLastFrame;
|
|
}
|
|
else
|
|
{
|
|
// If there's no occlusion query for the primitive, set it's visibility state to whether it has been unoccluded recently.
|
|
bIsOccluded = (PrimitiveOcclusionHistory->LastProvenVisibleTime + GEngine->PrimitiveProbablyVisibleTime < CurrentRealTime);
|
|
// the state was definite last frame, otherwise we would have ran a query
|
|
bOcclusionStateIsDefinite = true;
|
|
}
|
|
if (bIsOccluded)
|
|
{
|
|
PrimitiveOcclusionHistory->LastPixelsPercentage = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
PrimitiveOcclusionHistory->LastPixelsPercentage = GEngine->MaxOcclusionPixelsFraction;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GVisualizeOccludedPrimitives == 1 && bIsOccluded)
|
|
{
|
|
const FBoxSphereBounds& Bounds = bSubQueries ? (*SubBounds)[SubQuery] : Scene.PrimitiveOcclusionBounds[Index];
|
|
Visitor.AddVisualizeQuery(Bounds.GetBox(), FColor(50, 255, 50));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OcclusionState.bSubmitQueries)
|
|
{
|
|
bool bSkipNewlyConsidered = false;
|
|
|
|
if (bNewlyConsideredBBoxExpandActive)
|
|
{
|
|
if (!PrimitiveOcclusionHistory->BecameEligibleForQueryCooldown && OcclusionFrameCounter - PrimitiveOcclusionHistory->LastConsideredFrameNumber > uint32(GFramesNotOcclusionTestedToExpandBBoxes))
|
|
{
|
|
PrimitiveOcclusionHistory->BecameEligibleForQueryCooldown = GFramesToExpandNewlyOcclusionTestedBBoxes;
|
|
}
|
|
|
|
bSkipNewlyConsidered = !!PrimitiveOcclusionHistory->BecameEligibleForQueryCooldown;
|
|
|
|
if (bSkipNewlyConsidered)
|
|
{
|
|
PrimitiveOcclusionHistory->BecameEligibleForQueryCooldown--;
|
|
}
|
|
}
|
|
|
|
const FBoxSphereBounds PrimitiveOcclusionBounds = (bSubQueries ? (*SubBounds)[SubQuery] : Scene.PrimitiveOcclusionBounds[Index]);
|
|
|
|
// Print unexpanded bounding boxes in green if not already visualized by GVisualizeOccludedPrimitives
|
|
if (GVisualizePrimitiveBBoxes == 2 && !(GVisualizeOccludedPrimitives == 1 && bIsOccluded))
|
|
{
|
|
Visitor.AddVisualizeQuery(PrimitiveOcclusionBounds.GetBox(), FColor(0, 155, 0));
|
|
}
|
|
|
|
// scale occlusion bounds by GExpand*TestedBBoxesAmount in world space
|
|
FBoxSphereBounds WorldSpaceExpandedOcclusionBounds = PrimitiveOcclusionBounds;
|
|
if (GExpandAllTestedBBoxesAmount > 0.0f || GExpandNewlyOcclusionTestedBBoxesAmount > 0.0f)
|
|
{
|
|
WorldSpaceExpandedOcclusionBounds = WorldSpaceExpandedOcclusionBounds.ExpandBy(GExpandAllTestedBBoxesAmount + (bSkipNewlyConsidered ? GExpandNewlyOcclusionTestedBBoxesAmount : 0.0));
|
|
}
|
|
|
|
// scale occlusion bounds by GExpand*TestedBBoxesScreenSpace in screen space
|
|
FBoxSphereBounds FinalOcclusionBounds = WorldSpaceExpandedOcclusionBounds;
|
|
if (GExpandAllTestedBBoxesScreenSpace > 0.0f || GExpandNewlyOcclusionTestedBBoxesScreenSpace > 0.0f)
|
|
{
|
|
FVector ExpansionWorldSpace = (bSkipNewlyConsidered) ? ExpansionWorldSpaceNewlyConsidered : ExpansionWorldSpaceNotNewlyConsidered;
|
|
|
|
const float BoundsScreenSpace_W = FVector::DotProduct(FinalOcclusionBounds.Origin, ViewProjectionHomogeneousVector) + ViewProjectionHomogeneousVector.W;
|
|
|
|
ExpansionWorldSpace *= BoundsScreenSpace_W;
|
|
ExpansionWorldSpace = FVector(abs(ExpansionWorldSpace.X), abs(ExpansionWorldSpace.Y), abs(ExpansionWorldSpace.Z));
|
|
|
|
FinalOcclusionBounds.BoxExtent = FinalOcclusionBounds.BoxExtent + ExpansionWorldSpace;
|
|
FinalOcclusionBounds.SphereRadius = FinalOcclusionBounds.BoxExtent.Length();
|
|
}
|
|
|
|
const FBoxSphereBounds OcclusionBounds = FinalOcclusionBounds;
|
|
|
|
if (GVisualizeOccludedPrimitives == 2 && bIsOccluded)
|
|
{
|
|
Visitor.AddVisualizeQuery(OcclusionBounds.GetBox(), FColor(50, 255, 50));
|
|
}
|
|
else if (GVisualizePrimitiveBBoxes > 0)
|
|
{
|
|
Visitor.AddVisualizeQuery(OcclusionBounds.GetBox(), FColor(155, 0, 0));
|
|
}
|
|
|
|
bool bAllowBoundsTest;
|
|
if (FVector::DistSquared(ViewOrigin, OcclusionBounds.Origin) < NeverOcclusionTestDistanceSquared)
|
|
{
|
|
bAllowBoundsTest = false;
|
|
}
|
|
else if (View.bHasNearClippingPlane)
|
|
{
|
|
bAllowBoundsTest = View.NearClippingPlane.PlaneDot(OcclusionBounds.Origin) <
|
|
-(FVector::BoxPushOut(View.NearClippingPlane, OcclusionBounds.BoxExtent));
|
|
|
|
}
|
|
else if (!View.IsPerspectiveProjection())
|
|
{
|
|
// Transform parallel near plane
|
|
static_assert((int32)ERHIZBuffer::IsInverted != 0, "Check equation for culling!");
|
|
bAllowBoundsTest = View.WorldToScreen(OcclusionBounds.Origin).Z - View.ViewMatrices.GetProjectionMatrix().M[2][2] * OcclusionBounds.SphereRadius < 1;
|
|
}
|
|
else
|
|
{
|
|
bAllowBoundsTest = OcclusionBounds.SphereRadius < HALF_WORLD_MAX;
|
|
}
|
|
|
|
if (bAllowBoundsTest)
|
|
{
|
|
PrimitiveOcclusionHistory->LastTestFrameNumber = OcclusionFrameCounter;
|
|
|
|
if (bUseOcclusionFeedback)
|
|
{
|
|
const FVector BoundOrigin = OcclusionBounds.Origin + View.ViewMatrices.GetPreViewTranslation();
|
|
const FVector BoundExtent = OcclusionBounds.BoxExtent;
|
|
|
|
Visitor.AddOcclusionFeedback(FOcclusionFeedbackEntry(FPrimitiveOcclusionHistoryKey(PrimitiveId, SubQuery), BoundOrigin, BoundExtent));
|
|
}
|
|
else if (OcclusionState.bHZBOcclusion)
|
|
{
|
|
Visitor.AddHZBBounds(FHZBBound(PrimitiveOcclusionHistory, OcclusionBounds.Origin, OcclusionBounds.BoxExtent));
|
|
}
|
|
else
|
|
{
|
|
// decide if a query should be run this frame
|
|
bool bRunQuery, bGroupedQuery;
|
|
|
|
if (!bSubQueries && // sub queries are never grouped, we assume the custom code knows what it is doing and will group internally if it wants
|
|
(OcclusionFlags & EOcclusionFlags::AllowApproximateOcclusion))
|
|
{
|
|
if (bIsOccluded)
|
|
{
|
|
// Primitives that were occluded the previous frame use grouped queries.
|
|
bGroupedQuery = true;
|
|
bRunQuery = true;
|
|
}
|
|
else if (bOcclusionStateIsDefinite)
|
|
{
|
|
bGroupedQuery = false;
|
|
float Rnd = GOcclusionRandomStream.GetFraction();
|
|
if (GRHISupportsExactOcclusionQueries)
|
|
{
|
|
float FractionMultiplier = FMath::Max(PrimitiveOcclusionHistory->LastPixelsPercentage / GEngine->MaxOcclusionPixelsFraction, 1.0f);
|
|
bRunQuery = (FractionMultiplier * Rnd) < GEngine->MaxOcclusionPixelsFraction;
|
|
}
|
|
else
|
|
{
|
|
bRunQuery = CurrentRealTime - PrimitiveOcclusionHistory->LastProvenVisibleTime > PrimitiveProbablyVisibleTime * (0.5f * 0.25f * Rnd);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bGroupedQuery = false;
|
|
bRunQuery = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Primitives that need precise occlusion results use individual queries.
|
|
bGroupedQuery = false;
|
|
bRunQuery = true;
|
|
}
|
|
|
|
if (bRunQuery)
|
|
{
|
|
const FVector BoundOrigin = OcclusionBounds.Origin + View.ViewMatrices.GetPreViewTranslation();
|
|
const FVector BoundExtent = OcclusionBounds.BoxExtent;
|
|
|
|
if (GRHIMaximumInFlightQueries < MAX_int32 && !bGroupedQuery)
|
|
{
|
|
Visitor.AddThrottledOcclusionQuery(FThrottledOcclusionQuery(FPrimitiveOcclusionHistoryKey(PrimitiveId, SubQuery), BoundOrigin, BoundExtent, PrimitiveOcclusionHistory->LastQuerySubmitFrame()));
|
|
}
|
|
else
|
|
{
|
|
Visitor.AddOcclusionQuery(FOcclusionQuery(PrimitiveOcclusionHistory, BoundOrigin, BoundExtent, bGroupedQuery));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If the primitive's bounding box intersects the near clipping plane, treat it as definitely unoccluded.
|
|
bIsOccluded = false;
|
|
bOcclusionStateIsDefinite = true;
|
|
}
|
|
}
|
|
|
|
// Set the primitive's considered time to keep its occlusion history from being trimmed.
|
|
PrimitiveOcclusionHistory->LastConsideredTime = CurrentRealTime;
|
|
if (!bIsOccluded && bOcclusionStateIsDefinite)
|
|
{
|
|
PrimitiveOcclusionHistory->LastProvenVisibleTime = CurrentRealTime;
|
|
}
|
|
|
|
PrimitiveOcclusionHistory->LastConsideredFrameNumber = OcclusionFrameCounter;
|
|
PrimitiveOcclusionHistory->WasOccludedLastFrame = bIsOccluded;
|
|
PrimitiveOcclusionHistory->OcclusionStateWasDefiniteLastFrame = bOcclusionStateIsDefinite;
|
|
|
|
if (bSubQueries)
|
|
{
|
|
SubIsOccluded->Add(bIsOccluded);
|
|
if (!bIsOccluded)
|
|
{
|
|
bAllSubOccluded = false;
|
|
}
|
|
if (bIsOccluded || !bOcclusionStateIsDefinite)
|
|
{
|
|
bAllSubOcclusionStateIsDefinite = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bIsOccluded)
|
|
{
|
|
SetAtomicBit(View.PrimitiveVisibilityMap, Index, false);
|
|
bIsVisible = false;
|
|
Result.NumCulledPrimitives++;
|
|
}
|
|
else if (bOcclusionStateIsDefinite)
|
|
{
|
|
SetAtomicBit(View.PrimitiveDefinitelyUnoccludedMap, Index, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bSubQueries)
|
|
{
|
|
FPrimitiveSceneProxy* Proxy = Scene.PrimitiveSceneProxies[Index];
|
|
Proxy->AcceptOcclusionResults(&View, SubIsOccluded, SubIsOccludedStart, SubIsOccluded->Num() - SubIsOccludedStart);
|
|
|
|
if (bAllSubOccluded)
|
|
{
|
|
SetAtomicBit(View.PrimitiveVisibilityMap, Index, false);
|
|
bIsVisible = false;
|
|
Result.NumCulledPrimitives++;
|
|
}
|
|
else if (bAllSubOcclusionStateIsDefinite)
|
|
{
|
|
SetAtomicBit(View.PrimitiveDefinitelyUnoccludedMap, Index, true);
|
|
}
|
|
}
|
|
|
|
return bIsVisible;
|
|
}
|
|
|
|
void FGPUOcclusionPacket::FProcessVisitor::AddOcclusionQuery(const FOcclusionQuery& Query)
|
|
{
|
|
FRHIRenderQuery* RenderQuery = nullptr;
|
|
|
|
if (Query.bGroupedQuery)
|
|
{
|
|
RenderQuery = Packet.View.GroupedOcclusionQueries.BatchPrimitive(Query.Bounds.Origin, Query.Bounds.Extent, DynamicVertexBuffer);
|
|
}
|
|
else
|
|
{
|
|
RenderQuery = Packet.View.IndividualOcclusionQueries.BatchPrimitive(Query.Bounds.Origin, Query.Bounds.Extent, DynamicVertexBuffer);
|
|
}
|
|
|
|
const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryIssueIndex(Packet.ViewState.OcclusionFrameCounter, Packet.OcclusionState.NumBufferedFrames);
|
|
Packet.ViewState.Occlusion.LastOcclusionQueryArray[QueryIndex] = RenderQuery;
|
|
Packet.ViewState.Occlusion.NumRequestedQueries++;
|
|
|
|
Query.PrimitiveOcclusionHistory->SetCurrentQuery(
|
|
Packet.ViewState.OcclusionFrameCounter,
|
|
RenderQuery,
|
|
Packet.OcclusionState.NumBufferedFrames,
|
|
Query.bGroupedQuery,
|
|
Packet.OcclusionState.bUseRoundRobinOcclusion
|
|
);
|
|
}
|
|
|
|
void FGPUOcclusionPacket::FProcessVisitor::SubmitThrottledOcclusionQueries()
|
|
{
|
|
if (ThrottledOcclusionQueries.IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
TArray<FThrottledOcclusionQuery*, SceneRenderingAllocator> SortedQueries;
|
|
SortedQueries.Reserve(ThrottledOcclusionQueries.Num());
|
|
|
|
for (FThrottledOcclusionQuery& ThrottledOcclusionQuery : ThrottledOcclusionQueries)
|
|
{
|
|
SortedQueries.Emplace(&ThrottledOcclusionQuery);
|
|
}
|
|
|
|
const int32 NumRequestedThrottledQueries = SortedQueries.Num();
|
|
const int32 NumUsedQueries = Packet.View.GroupedOcclusionQueries.GetNumBatchOcclusionQueries();
|
|
const int32 ThrottleThreshold = GRHIMaximumInFlightQueries / FMath::Min(Packet.OcclusionState.NumBufferedFrames, 2); // extra RHIT frame does not count
|
|
|
|
int32 NumThrottledQueries = NumRequestedThrottledQueries;
|
|
|
|
if (NumUsedQueries + NumRequestedThrottledQueries > ThrottleThreshold)
|
|
{
|
|
// We need to make progress, even if it means stalling and waiting for the GPU. At a minimum, we will do 10%.
|
|
NumThrottledQueries = (NumRequestedThrottledQueries + 9) / 10;
|
|
|
|
if (NumUsedQueries + NumThrottledQueries < ThrottleThreshold)
|
|
{
|
|
// We can do more than the minimum.
|
|
NumThrottledQueries = ThrottleThreshold - NumUsedQueries;
|
|
}
|
|
}
|
|
|
|
if (NumThrottledQueries < NumRequestedThrottledQueries)
|
|
{
|
|
SortedQueries.Sort([](const FThrottledOcclusionQuery& A, const FThrottledOcclusionQuery& B)
|
|
{
|
|
return A.LastQuerySubmitFrame < B.LastQuerySubmitFrame;
|
|
});
|
|
}
|
|
|
|
for (int32 Index = 0; Index < NumThrottledQueries; ++Index)
|
|
{
|
|
FThrottledOcclusionQuery* Query = SortedQueries[Index];
|
|
FPrimitiveOcclusionHistory* PrimitiveOcclusionHistory = PrimitiveOcclusionHistorySet.Find(Query->PrimitiveOcclusionHistoryKey);
|
|
|
|
FRHIRenderQuery* RenderQuery = Packet.View.IndividualOcclusionQueries.BatchPrimitive(Query->Bounds.Origin, Query->Bounds.Extent, DynamicVertexBuffer);
|
|
|
|
const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryIssueIndex(Packet.ViewState.OcclusionFrameCounter, Packet.OcclusionState.NumBufferedFrames);
|
|
Packet.ViewState.Occlusion.LastOcclusionQueryArray[QueryIndex] = RenderQuery;
|
|
Packet.ViewState.Occlusion.NumRequestedQueries++;
|
|
|
|
PrimitiveOcclusionHistory->SetCurrentQuery(
|
|
Packet.ViewState.OcclusionFrameCounter,
|
|
RenderQuery,
|
|
Packet.OcclusionState.NumBufferedFrames,
|
|
false,
|
|
Packet.OcclusionState.bUseRoundRobinOcclusion
|
|
);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FGPUOcclusion::FGPUOcclusion(FVisibilityViewPacket& InViewPacket)
|
|
: ViewPacket(InViewPacket)
|
|
, Scene(ViewPacket.Scene)
|
|
, View(ViewPacket.View)
|
|
, ViewState(*ViewPacket.ViewState)
|
|
{
|
|
// In single pass stereo we only submit queries from the primary view.
|
|
State.bSubmitQueries = !View.bDisableQuerySubmissions && !(View.bIsSinglePassStereo && View.StereoPass == EStereoscopicPass::eSSP_SECONDARY);
|
|
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
State.bSubmitQueries &= !ViewState.bIsFrozen;
|
|
#endif
|
|
|
|
// Perform round-robin occlusion queries
|
|
const bool bUseRoundRobinOcclusion = ViewState.IsRoundRobinEnabled() &&
|
|
!View.bIsSinglePassStereo && // No round robin on single-pass stereo
|
|
!View.bIsSceneCapture && // We only round-robin on the main renderer (not scene captures)
|
|
IStereoRendering::IsStereoEyeView(View); // Only relevant to stereo views
|
|
if (bUseRoundRobinOcclusion && !View.bIgnoreExistingQueries) // We do not alternate occlusion queries when we want to refresh the occlusion history
|
|
{
|
|
// For even frames, prevent left eye from occlusion querying
|
|
// For odd frames, prevent right eye from occlusion querying
|
|
const bool FrameParity = ((ViewState.PrevFrameNumber & 0x01) == 1);
|
|
State.bSubmitQueries &= (FrameParity && IStereoRendering::IsAPrimaryView(View)) || (!FrameParity && IStereoRendering::IsASecondaryView(View));
|
|
}
|
|
|
|
// Disable HZB on OpenGL platforms to avoid rendering artifacts
|
|
// It can be forced on by setting HZBOcclusion to 2
|
|
State.bHZBOcclusion = !IsOpenGLPlatform(View.GetShaderPlatform());
|
|
State.bHZBOcclusion &= FDataDrivenShaderPlatformInfo::GetSupportsHZBOcclusion(View.GetShaderPlatform());
|
|
State.bHZBOcclusion &= GHZBOcclusion != 0;
|
|
State.bHZBOcclusion |= GHZBOcclusion == 2;
|
|
|
|
State.bUseRoundRobinOcclusion = bUseRoundRobinOcclusion;
|
|
|
|
State.NumBufferedFrames = FOcclusionQueryHelpers::GetNumBufferedFrames(Scene.GetFeatureLevel());
|
|
State.ReadBackLagTolerance = State.NumBufferedFrames;
|
|
|
|
State.bAllowSubQueries = GAllowSubPrimitiveQueries && !View.bDisableQuerySubmissions;
|
|
|
|
if (State.bUseRoundRobinOcclusion)
|
|
{
|
|
// Round-robin occlusion culling involves reading frames that could be twice as stale as without round-robin
|
|
State.ReadBackLagTolerance = State.NumBufferedFrames * 2;
|
|
}
|
|
}
|
|
|
|
void FGPUOcclusion::Map(FRHICommandListImmediate& RHICmdListImmediate)
|
|
{
|
|
SCOPED_NAMED_EVENT(MapOcclusionResults, FColor::Magenta);
|
|
|
|
if (View.FeatureLevel == ERHIFeatureLevel::ES3_1 &&
|
|
ViewState.OcclusionFeedback.IsInitialized())
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_OcclusionFeedback_ReadbackResults);
|
|
ViewState.OcclusionFeedback.ReadbackResults(RHICmdListImmediate);
|
|
ViewState.OcclusionFeedback.AdvanceFrame(ViewState.OcclusionFrameCounter);
|
|
}
|
|
else if (State.bHZBOcclusion)
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_MapHZBResults);
|
|
check(!ViewState.HZBOcclusionTests.IsValidFrame(ViewState.OcclusionFrameCounter));
|
|
ViewState.HZBOcclusionTests.MapResults(RHICmdListImmediate);
|
|
}
|
|
|
|
ViewState.PrimitiveOcclusionQueryPool.AdvanceFrame(
|
|
ViewState.OcclusionFrameCounter,
|
|
FOcclusionQueryHelpers::GetNumBufferedFrames(Scene.GetFeatureLevel()),
|
|
State.bUseRoundRobinOcclusion);
|
|
|
|
ViewState.Occlusion.NumRequestedQueries = 0;
|
|
}
|
|
|
|
void FGPUOcclusion::Unmap(FRHICommandListImmediate& RHICmdListImmediate)
|
|
{
|
|
if (State.bHZBOcclusion)
|
|
{
|
|
ViewState.HZBOcclusionTests.UnmapResults(RHICmdListImmediate);
|
|
}
|
|
|
|
if (View.FeatureLevel == ERHIFeatureLevel::ES3_1)
|
|
{
|
|
// Initialize/release OcclusionFeedback system on demand
|
|
if (GOcclusionFeedback_Enable == 0 && ViewState.OcclusionFeedback.IsInitialized())
|
|
{
|
|
ViewState.OcclusionFeedback.ReleaseResource();
|
|
}
|
|
else if (GOcclusionFeedback_Enable != 0 && !ViewState.OcclusionFeedback.IsInitialized())
|
|
{
|
|
ViewState.OcclusionFeedback.InitResource(RHICmdListImmediate);
|
|
}
|
|
}
|
|
|
|
if (State.bHZBOcclusion && State.bSubmitQueries)
|
|
{
|
|
ViewState.HZBOcclusionTests.SetValidFrameNumber(ViewState.OcclusionFrameCounter);
|
|
}
|
|
}
|
|
|
|
void FGPUOcclusion::WaitForLastOcclusionQuery()
|
|
{
|
|
const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryLookupIndex(ViewState.OcclusionFrameCounter, State.NumBufferedFrames);
|
|
if (ViewState.Occlusion.LastOcclusionQueryArray[QueryIndex])
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(GPUBound_WaitingForGPUForOcclusionQueries_SeeGPUTrack);
|
|
|
|
uint64 Result;
|
|
const bool bWait = true;
|
|
RHIGetRenderQueryResult(ViewState.Occlusion.LastOcclusionQueryArray[QueryIndex], Result, bWait);
|
|
ViewState.Occlusion.LastOcclusionQueryArray[QueryIndex] = nullptr;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool FGPUOcclusionParallelPacket::AddPrimitive(int32 PrimitiveIndex)
|
|
{
|
|
EOcclusionFlags::Type OcclusionFlags;
|
|
|
|
if (CanBeOccluded(PrimitiveIndex, OcclusionFlags))
|
|
{
|
|
Input.AddElement(PrimitiveIndex);
|
|
int32 NumSubQueries = 1;
|
|
|
|
if (EnumHasAnyFlags(OcclusionFlags, EOcclusionFlags::HasSubprimitiveQueries) && OcclusionState.bAllowSubQueries)
|
|
{
|
|
NumSubQueries = Scene.PrimitiveSceneProxies[PrimitiveIndex]->GetOcclusionQueries(&View)->Num();
|
|
}
|
|
|
|
NumInputSubQueries += NumSubQueries;
|
|
return true;
|
|
}
|
|
|
|
View.PrimitiveDefinitelyUnoccludedMap[PrimitiveIndex].AtomicSet(true);
|
|
return false;
|
|
}
|
|
|
|
void FGPUOcclusionParallelPacket::LaunchOcclusionCullTask()
|
|
{
|
|
check(!bTaskLaunched);
|
|
|
|
if (Input.IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
bTaskLaunched = true;
|
|
|
|
ViewPacket.Relevance.CommandPipe.AddNumCommands(1);
|
|
|
|
FVisibilityTaskConfig& TaskConfig = ViewPacket.TaskConfig;
|
|
|
|
Task = UE::Tasks::Launch(UE_SOURCE_LOCATION, [this, &TaskConfig]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
|
|
FPrimitiveIndexList PrimitiveIndexList;
|
|
const FOcclusionCullResult Result = OcclusionCullTask(PrimitiveIndexList);
|
|
|
|
if (PrimitiveIndexList.IsEmpty())
|
|
{
|
|
ViewPacket.Relevance.CommandPipe.ReleaseNumCommands(1);
|
|
}
|
|
else
|
|
{
|
|
ViewPacket.Relevance.CommandPipe.EnqueueCommand(MoveTemp(PrimitiveIndexList));
|
|
}
|
|
|
|
RecordOcclusionCullResult(Result);
|
|
|
|
}, TaskConfig.OcclusionCull.TaskPriority);
|
|
}
|
|
|
|
FOcclusionCullResult FGPUOcclusionParallelPacket::OcclusionCullTask(FPrimitiveIndexList& PrimitiveIndexList)
|
|
{
|
|
SCOPED_NAMED_EVENT(OcclusionCull, FColor::Magenta);
|
|
|
|
FOcclusionCullResult Result;
|
|
|
|
PrimitiveIndexList.Reserve(Input.Num());
|
|
|
|
for (int32 Index : Input)
|
|
{
|
|
if (OcclusionCullPrimitive<true>(RecordVisitor, Result, Index))
|
|
{
|
|
PrimitiveIndexList.Emplace(Index);
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FGPUOcclusionParallel::AddPrimitives(FPrimitiveRange PrimitiveRange)
|
|
{
|
|
WaitForLastOcclusionQuery();
|
|
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
FGPUOcclusionParallelPacket* Packet = Packets.Last();
|
|
|
|
if (Packet->AddPrimitive(BitIt.GetIndex()))
|
|
{
|
|
if (Packet->IsFull())
|
|
{
|
|
Packet->LaunchOcclusionCullTask();
|
|
CreateOcclusionPacket();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The primitive will not be occluded, so accumulate a packet of primitives to send directly to the relevance pipe to reduce latency.
|
|
NonOccludedPrimitives.Emplace(BitIt.GetIndex());
|
|
|
|
if (NonOccludedPrimitives.Num() == MaxNonOccludedPrimitives)
|
|
{
|
|
ViewPacket.Relevance.CommandPipe.AddNumCommands(1);
|
|
ViewPacket.Relevance.CommandPipe.EnqueueCommand(MoveTemp(NonOccludedPrimitives));
|
|
NonOccludedPrimitives.Reset();
|
|
NonOccludedPrimitives.Reserve(MaxNonOccludedPrimitives);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FGPUOcclusionParallel::Finish(UE::Tasks::FTaskEvent& OcclusionCullTasks)
|
|
{
|
|
check(!bFinished);
|
|
bFinished = true;
|
|
|
|
Packets.Last()->LaunchOcclusionCullTask();
|
|
|
|
if (!NonOccludedPrimitives.IsEmpty())
|
|
{
|
|
ViewPacket.Relevance.CommandPipe.AddNumCommands(1);
|
|
ViewPacket.Relevance.CommandPipe.EnqueueCommand(MoveTemp(NonOccludedPrimitives));
|
|
NonOccludedPrimitives.Reset();
|
|
}
|
|
|
|
for (FGPUOcclusionParallelPacket* Packet : Packets)
|
|
{
|
|
if (Packet->bTaskLaunched)
|
|
{
|
|
OcclusionCullTasks.AddPrerequisites(Packet->Task);
|
|
}
|
|
}
|
|
|
|
OcclusionCullTasks.Trigger();
|
|
}
|
|
|
|
void FGPUOcclusionParallel::Finalize()
|
|
{
|
|
check(bFinished);
|
|
bFinalized = true;
|
|
|
|
SCOPED_NAMED_EVENT(FinalizeOcclusionCull, FColor::Magenta);
|
|
|
|
for (FGPUOcclusionParallelPacket* Packet : Packets)
|
|
{
|
|
FGPUOcclusionPacket::FProcessVisitor ProcessVisitor(*Packet, *RHICmdList, DynamicVertexBuffer);
|
|
ProcessVisitor.Replay(Packet->RecordVisitor);
|
|
}
|
|
|
|
for (FGPUOcclusionParallelPacket* Packet : Packets)
|
|
{
|
|
// Wait to add occlusion histories until after replaying commands since it will invalidate pointers.
|
|
for (FPrimitiveOcclusionHistory& OcclusionHistory : Packet->RecordVisitor.OcclusionHistories)
|
|
{
|
|
ViewState.Occlusion.PrimitiveOcclusionHistorySet.Add(OcclusionHistory);
|
|
}
|
|
|
|
delete Packet;
|
|
}
|
|
|
|
Packets.Empty();
|
|
DynamicVertexBuffer.Commit();
|
|
RHICmdList->FinishRecording();
|
|
FinalizeTask.Trigger();
|
|
}
|
|
|
|
void FGPUOcclusionParallel::Map(FRHICommandListImmediate& RHICmdListImmediate)
|
|
{
|
|
FGPUOcclusion::Map(RHICmdListImmediate);
|
|
RHICmdList = new FRHICommandList(RHICmdListImmediate.GetGPUMask());
|
|
RHICmdList->SwitchPipeline(ERHIPipeline::Graphics);
|
|
DynamicVertexBuffer.Init(*RHICmdList);
|
|
}
|
|
|
|
void FGPUOcclusionParallel::Unmap(FRHICommandListImmediate& RHICmdListImmediate)
|
|
{
|
|
FinalizeTask.Wait();
|
|
check(bFinalized);
|
|
RHICmdListImmediate.QueueAsyncCommandListSubmit(RHICmdList);
|
|
FGPUOcclusion::Unmap(RHICmdListImmediate);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FGPUOcclusionSerial::AddPrimitives(FPrimitiveRange PrimitiveRange)
|
|
{
|
|
CSV_SCOPED_TIMING_STAT_EXCLUSIVE(FetchVisibilityForPrimitives);
|
|
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
EOcclusionFlags::Type OcclusionFlags;
|
|
if (Packet.CanBeOccluded(BitIt.GetIndex(), OcclusionFlags))
|
|
{
|
|
Packet.OcclusionCullPrimitive<false>(ProcessVisitor, OcclusionCullResult, BitIt.GetIndex());
|
|
}
|
|
else
|
|
{
|
|
View.PrimitiveDefinitelyUnoccludedMap.AccessCorrespondingBit(BitIt) = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void FGPUOcclusionSerial::Map(FRHICommandListImmediate& RHICmdListImmediate)
|
|
{
|
|
FGPUOcclusion::Map(RHICmdListImmediate);
|
|
DynamicVertexBuffer.Init(RHICmdListImmediate);
|
|
}
|
|
|
|
void FGPUOcclusionSerial::Unmap(FRHICommandListImmediate& RHICmdListImmediate)
|
|
{
|
|
DynamicVertexBuffer.Commit();
|
|
ProcessVisitor.SubmitThrottledOcclusionQueries();
|
|
Packet.RecordOcclusionCullResult(OcclusionCullResult);
|
|
FGPUOcclusion::Unmap(RHICmdListImmediate);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
static int32 PrecomputedOcclusionCull(FVisibilityViewPacket& ViewPacket, FPrimitiveRange PrimitiveRange)
|
|
{
|
|
int32 NumOccludedPrimitives = 0;
|
|
|
|
const FScene& Scene = ViewPacket.Scene;
|
|
FViewInfo& View = ViewPacket.View;
|
|
|
|
if (View.PrecomputedVisibilityData)
|
|
{
|
|
SCOPED_NAMED_EVENT(PrecomputedOcclusionCull, FColor::Magenta);
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_PrecomputedOcclusionCull);
|
|
|
|
uint8 PrecomputedVisibilityFlags = EOcclusionFlags::CanBeOccluded | EOcclusionFlags::HasPrecomputedVisibility;
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
if ((Scene.PrimitiveOcclusionFlags[BitIt.GetIndex()] & PrecomputedVisibilityFlags) == PrecomputedVisibilityFlags)
|
|
{
|
|
FPrimitiveVisibilityId VisibilityId = Scene.PrimitiveVisibilityIds[BitIt.GetIndex()];
|
|
if ((View.PrecomputedVisibilityData[VisibilityId.ByteIndex] & VisibilityId.BitMask) == 0)
|
|
{
|
|
if (GVisualizeOccludedPrimitives)
|
|
{
|
|
const FBoxSphereBounds& Bounds = Scene.PrimitiveOcclusionBounds[BitIt.GetIndex()];
|
|
DrawWireBox(&ViewPacket.ViewElementPDI, Bounds.GetBox(), FColor(100, 50, 50), SDPG_Foreground);
|
|
}
|
|
|
|
View.PrimitiveVisibilityMap.AccessCorrespondingBit(BitIt) = false;
|
|
INC_DWORD_STAT_BY(STAT_StaticallyOccludedPrimitives, 1);
|
|
NumOccludedPrimitives++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return NumOccludedPrimitives;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FVisibilityTaskConfig::FVisibilityTaskConfig(const FScene& Scene, TConstArrayView<FViewInfo*> Views)
|
|
{
|
|
Schedule = GVisibilityTaskSchedule != 0 ? EVisibilityTaskSchedule::Parallel : EVisibilityTaskSchedule::RenderThread;
|
|
|
|
if (Schedule == EVisibilityTaskSchedule::Parallel)
|
|
{
|
|
if (!FApp::ShouldUseThreadingForPerformance() || !GIsThreadedRendering || !GSupportsParallelOcclusionQueries || GVisualizeOccludedPrimitives > 0 || GVisualizePrimitiveBBoxes > 0 || IsMobilePlatform(Scene.GetShaderPlatform()))
|
|
{
|
|
Schedule = EVisibilityTaskSchedule::RenderThread;
|
|
}
|
|
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
for (FViewInfo* View : Views)
|
|
{
|
|
auto* ViewState = static_cast<FSceneViewState*>(View->State);
|
|
|
|
// Frozen matrices require modifying the view matrices which does not support the async path.
|
|
if (ViewState && ViewState->bIsFrozen)
|
|
{
|
|
Schedule = EVisibilityTaskSchedule::RenderThread;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
NumTestedPrimitives = uint32(Scene.Primitives.Num());
|
|
NumVisiblePrimitives = 0u;
|
|
|
|
if (Scene.PrimitivesAlwaysVisibleOffset != ~0u)
|
|
{
|
|
NumTestedPrimitives = Scene.PrimitivesAlwaysVisibleOffset;
|
|
NumVisiblePrimitives = uint32(Scene.Primitives.Num()) - NumTestedPrimitives;
|
|
|
|
// Ensure that the dword alignment code is correct and we never have partial dword offsets
|
|
check(uint32(NumTestedPrimitives % NumBitsPerDWORD) == 0u);
|
|
}
|
|
|
|
const uint32 NumWorkerThreads = FMath::Min(LowLevelTasks::FScheduler::Get().GetNumWorkers(), 16u);
|
|
|
|
// These values tune the task granularity based on number of primitives in the scene and the number of worker tasks available.
|
|
const uint32 NumAlwaysVisibleTasksPerThread = 2;
|
|
const uint32 NumFrustumCullTasksPerThread = 2;
|
|
const uint32 NumOcclusionCullTasksPerThread = 2;
|
|
const uint32 NumRelevanceTasksPerThread = 32;
|
|
|
|
const uint32 NumWordsPerTaskIfRenderThread = 128;
|
|
|
|
// Always Visible
|
|
if (NumVisiblePrimitives > 0u)
|
|
{
|
|
const uint32 NumPrimitiveWords = FMath::DivideAndRoundUp<uint32>(NumVisiblePrimitives, NumBitsPerDWORD);
|
|
|
|
if (Schedule == EVisibilityTaskSchedule::RenderThread)
|
|
{
|
|
AlwaysVisible.NumWordsPerTask = NumWordsPerTaskIfRenderThread;
|
|
}
|
|
else
|
|
{
|
|
AlwaysVisible.NumWordsPerTask = FMath::DivideAndRoundUp(NumPrimitiveWords, NumWorkerThreads * NumAlwaysVisibleTasksPerThread);
|
|
}
|
|
|
|
AlwaysVisible.NumWordsPerTask = FMath::Clamp(AlwaysVisible.NumWordsPerTask, AlwaysVisible.MinWordsPerTask, NumPrimitiveWords);
|
|
AlwaysVisible.NumPrimitivesPerTask = AlwaysVisible.NumWordsPerTask * NumBitsPerDWORD;
|
|
AlwaysVisible.NumTasks = FMath::DivideAndRoundUp(NumVisiblePrimitives, AlwaysVisible.NumPrimitivesPerTask);
|
|
}
|
|
else
|
|
{
|
|
AlwaysVisible.NumWordsPerTask = 0;
|
|
AlwaysVisible.NumPrimitivesPerTask = 0;
|
|
AlwaysVisible.NumTasks = 0;
|
|
}
|
|
|
|
// Frustum Cull
|
|
{
|
|
const uint32 NumPrimitiveWords = FMath::DivideAndRoundUp<uint32>(NumTestedPrimitives, NumBitsPerDWORD);
|
|
|
|
if (GFrustumCullNumPrimitivesPerTask > 0)
|
|
{
|
|
FrustumCull.NumWordsPerTask = FMath::DivideAndRoundUp<uint32>(GFrustumCullNumPrimitivesPerTask, NumBitsPerDWORD);
|
|
}
|
|
else if (Schedule == EVisibilityTaskSchedule::RenderThread)
|
|
{
|
|
FrustumCull.NumWordsPerTask = NumWordsPerTaskIfRenderThread;
|
|
}
|
|
else
|
|
{
|
|
FrustumCull.NumWordsPerTask = FMath::DivideAndRoundUp(NumPrimitiveWords, NumWorkerThreads * NumFrustumCullTasksPerThread);
|
|
}
|
|
|
|
FrustumCull.NumWordsPerTask = FMath::Clamp(FrustumCull.NumWordsPerTask, FrustumCull.MinWordsPerTask, NumPrimitiveWords);
|
|
FrustumCull.NumPrimitivesPerTask = FrustumCull.NumWordsPerTask * NumBitsPerDWORD;
|
|
FrustumCull.NumTasks = FMath::DivideAndRoundUp(NumTestedPrimitives, FrustumCull.NumPrimitivesPerTask);
|
|
}
|
|
|
|
// Occlusion Cull
|
|
{
|
|
OcclusionCull.Views.SetNum(Views.Num());
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
|
|
{
|
|
uint32& MaxQueriesPerTask = OcclusionCull.Views[ViewIndex].MaxQueriesPerTask;
|
|
|
|
if (GOcclusionCullMaxQueriesPerTask > 0)
|
|
{
|
|
MaxQueriesPerTask = GOcclusionCullMaxQueriesPerTask;
|
|
}
|
|
else if (FSceneViewState* ViewState = static_cast<FSceneViewState*>(Views[ViewIndex]->State))
|
|
{
|
|
MaxQueriesPerTask = FMath::DivideAndRoundUp(ViewState->Occlusion.NumRequestedQueries, FMath::Max(1u, NumWorkerThreads) * NumOcclusionCullTasksPerThread);
|
|
}
|
|
|
|
MaxQueriesPerTask = FMath::Max(MaxQueriesPerTask, OcclusionCull.MinQueriesPerTask);
|
|
}
|
|
}
|
|
|
|
// Relevance
|
|
{
|
|
const uint32 NumPrimitivesPerPacketIfRenderThread = 128;
|
|
|
|
if (GRelevanceNumPrimitivesPerPacket > 0)
|
|
{
|
|
Relevance.NumPrimitivesPerPacket = GRelevanceNumPrimitivesPerPacket;
|
|
}
|
|
else if (Schedule == EVisibilityTaskSchedule::RenderThread)
|
|
{
|
|
Relevance.NumPrimitivesPerPacket = NumPrimitivesPerPacketIfRenderThread;
|
|
}
|
|
else
|
|
{
|
|
Relevance.NumPrimitivesPerPacket = FMath::DivideAndRoundUp(NumTestedPrimitives, NumWorkerThreads * NumRelevanceTasksPerThread);
|
|
}
|
|
|
|
Relevance.NumPrimitivesPerPacket = FMath::Clamp(Relevance.NumPrimitivesPerPacket, Relevance.MinPrimitivesPerTask, Relevance.MaxPrimitivesPerTask);
|
|
Relevance.NumEstimatedPackets = FMath::DivideAndRoundUp(NumTestedPrimitives, Relevance.NumPrimitivesPerPacket);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FVisibilityViewPacket::FVisibilityViewPacket(FVisibilityTaskData& InTaskData, FScene& InScene, FViewInfo& InView, int32 InViewIndex)
|
|
: TaskData(InTaskData)
|
|
, TaskConfig(TaskData.TaskConfig)
|
|
, Scene(InScene)
|
|
, View(InView)
|
|
, ViewState(static_cast<FSceneViewState*>(View.ViewState))
|
|
, ViewIndex(InViewIndex)
|
|
, ViewElementPDI(&View, nullptr, nullptr)
|
|
{
|
|
if (ViewState && !View.Family->EngineShowFlags.Wireframe && DoOcclusionQueries(*View.Family))
|
|
{
|
|
if (TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel)
|
|
{
|
|
OcclusionCull.ContextIfParallel = TaskData.Allocator.Create<FGPUOcclusionParallel>(*this);
|
|
}
|
|
else
|
|
{
|
|
OcclusionCull.ContextIfSerial = TaskData.Allocator.Create<FGPUOcclusionSerial>(*this);
|
|
}
|
|
}
|
|
|
|
if (TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel)
|
|
{
|
|
// Chain the frustum cull task to the relevance task since we only wait on relevance.
|
|
Tasks.ComputeRelevance.AddPrerequisites(Tasks.FrustumCull);
|
|
|
|
// Callback for when an occlusion command is queued from frustum culling.
|
|
OcclusionCull.CommandPipe.SetCommandFunction([this](FPrimitiveRange PrimitiveRange)
|
|
{
|
|
UpdatePrimitiveFading(Scene, View, ViewState, PrimitiveRange);
|
|
|
|
const int32 NumCulledPrimitives = PrecomputedOcclusionCull(*this, PrimitiveRange);
|
|
|
|
if (OcclusionCull.ContextIfParallel)
|
|
{
|
|
OcclusionCull.ContextIfParallel->AddPrimitives(PrimitiveRange);
|
|
}
|
|
else
|
|
{
|
|
// When occlusion is disabled primitives are queued directly to the relevance context rather than as a command on the relevance pipe.
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
Relevance.Context->AddPrimitive(BitIt.GetIndex());
|
|
}
|
|
}
|
|
|
|
TaskConfig.OcclusionCull.NumCulledPrimitives.fetch_add(NumCulledPrimitives, std::memory_order_relaxed);
|
|
});
|
|
|
|
// Callback for when the occlusion pipe is done accepting commands.
|
|
OcclusionCull.CommandPipe.SetEmptyFunction([this]
|
|
{
|
|
if (OcclusionCull.ContextIfParallel)
|
|
{
|
|
OcclusionCull.ContextIfParallel->Finish(Tasks.OcclusionCull);
|
|
|
|
// Launch a follow-up task to finalize occlusion results after all occlusion packets have completed.
|
|
UE::Tasks::Launch(UE_SOURCE_LOCATION, [this]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
Relevance.CommandPipe.ReleaseNumCommands(1);
|
|
OcclusionCull.ContextIfParallel->Finalize();
|
|
|
|
}, Tasks.OcclusionCull, TaskConfig.OcclusionCull.FinalizeTaskPriority);
|
|
}
|
|
else
|
|
{
|
|
Relevance.CommandPipe.ReleaseNumCommands(1);
|
|
Tasks.OcclusionCull.Trigger();
|
|
}
|
|
});
|
|
|
|
// Take a reference on the occlusion command pipe that is released when all frustum cull commands are enqueued.
|
|
OcclusionCull.CommandPipe.AddNumCommands(1);
|
|
|
|
// Callback for when a relevance command is queued from occlusion.
|
|
Relevance.CommandPipe.SetCommandFunction([this](FPrimitiveIndexList&& PrimitiveIndexList)
|
|
{
|
|
Relevance.Context->AddPrimitives(MoveTemp(PrimitiveIndexList));
|
|
});
|
|
|
|
// Callback for when the relevance pipe is done accepting commands.
|
|
Relevance.CommandPipe.SetEmptyFunction([this]
|
|
{
|
|
Relevance.Context->Finish(Tasks.ComputeRelevance);
|
|
|
|
// Only used in the ViewPackets.Num() == 1 case
|
|
if (TaskData.DynamicMeshElements.CommandPipe)
|
|
{
|
|
TaskData.DynamicMeshElements.CommandPipe->ReleaseNumCommands(1);
|
|
}
|
|
});
|
|
|
|
// Take a reference on the relevance command pipe that is released by the occlusion pipe when all occlusion commands are complete.
|
|
Relevance.CommandPipe.AddNumCommands(1);
|
|
}
|
|
}
|
|
|
|
void FVisibilityViewPacket::BeginInitVisibility()
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE_TEXT(*FString::Printf(TEXT("BeginInitVisibility %d"), ViewIndex));
|
|
|
|
// Mark all primitives as visible when not visibility culling
|
|
bool bShouldVisibilityCull = GFrustumCullEnabled;
|
|
|
|
UE::Tasks::FTaskEvent RelevancePrereqs{ UE_SOURCE_LOCATION };
|
|
RelevancePrereqs.AddPrerequisites(Scene.GetCacheMeshDrawCommandsTask());
|
|
|
|
// Offload initialization of maps that are not touched by frustum culling / occlusion until the relevance phase. These can be quite expensive to zero out.
|
|
RelevancePrereqs.AddPrerequisites(UE::Tasks::Launch(UE_SOURCE_LOCATION, [this]
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(SceneVisibility_InitMaps);
|
|
View.DynamicMeshElementRanges.SetNumZeroed(Scene.Primitives.Num());
|
|
View.PrimitivesLODMask.Init(FLODMask(), Scene.Primitives.Num());
|
|
View.StaticMeshVisibilityMap.Init(false, Scene.StaticMeshes.GetMaxIndex());
|
|
View.StaticMeshFadeOutDitheredLODMap.Init(false, Scene.StaticMeshes.GetMaxIndex());
|
|
View.StaticMeshFadeInDitheredLODMap.Init(false, Scene.StaticMeshes.GetMaxIndex());
|
|
|
|
}, TaskConfig.TaskPriority));
|
|
|
|
// Allocate the view's visibility maps.
|
|
View.PrimitiveVisibilityMap.Init(!bShouldVisibilityCull, Scene.Primitives.Num());
|
|
View.PrimitiveRayTracingVisibilityMap.Init(false, Scene.Primitives.Num());
|
|
View.PrimitiveDefinitelyUnoccludedMap.Init(!DoOcclusionQueries(*View.Family), Scene.Primitives.Num());
|
|
View.PotentiallyFadingPrimitiveMap.Init(false, Scene.Primitives.Num());
|
|
View.PrimitiveFadeUniformBuffers.AddZeroed(Scene.Primitives.Num());
|
|
View.PrimitiveFadeUniformBufferMap.Init(false, Scene.Primitives.Num());
|
|
View.PrimitiveViewRelevanceMap.Reset(Scene.Primitives.Num());
|
|
View.PrimitiveViewRelevanceMap.AddZeroed(Scene.Primitives.Num());
|
|
|
|
RelevancePrereqs.Trigger();
|
|
|
|
if (View.ShowOnlyPrimitives.IsSet())
|
|
{
|
|
View.bHasNoVisiblePrimitive = View.ShowOnlyPrimitives->Num() == 0;
|
|
}
|
|
|
|
Relevance.Context = TaskData.Allocator.Create<FComputeAndMarkRelevance>(TaskData, Scene, View, ViewIndex, RelevancePrereqs);
|
|
|
|
ClearStalePrimitiveFadingStates(View, ViewState);
|
|
|
|
// Development builds sometimes override frustum culling, e.g. dependent views in the editor.
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
if (ViewState)
|
|
{
|
|
// For views with frozen visibility, check if the primitive is in the frozen visibility set.
|
|
if (ViewState->bIsFrozen)
|
|
{
|
|
bShouldVisibilityCull = false;
|
|
for (int32 Index = 0; Index < int32(TaskConfig.NumTestedPrimitives); ++Index)
|
|
{
|
|
if (ViewState->FrozenPrimitives.Contains(Scene.PrimitiveComponentIds[Index]))
|
|
{
|
|
View.PrimitiveVisibilityMap[Index] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
const float MaxDrawDistanceScale = GetCachedScalabilityCVars().ViewDistanceScale * GetCachedScalabilityCVars().CalculateFieldOfViewDistanceScale(View.DesiredFOV);
|
|
const FHLODVisibilityState* HLODState = nullptr;
|
|
|
|
// Most views use standard frustum culling.
|
|
if (bShouldVisibilityCull)
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(HLODInit);
|
|
|
|
// Update HLOD transition/visibility states to allow use during distance culling
|
|
FLODSceneTree& HLODTree = Scene.SceneLODHierarchy;
|
|
|
|
if (HLODTree.IsActive())
|
|
{
|
|
HLODTree.UpdateVisibilityStates(View, Tasks.LightVisibility);
|
|
|
|
if (ViewState)
|
|
{
|
|
HLODState = &ViewState->HLODVisibilityState;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HLODTree.ClearVisibilityState(View);
|
|
}
|
|
}
|
|
|
|
Tasks.LightVisibility.Trigger();
|
|
|
|
FFrustumCullingFlags Flags;
|
|
Flags.bShouldVisibilityCull = bShouldVisibilityCull;
|
|
Flags.bUseCustomCulling = View.CustomVisibilityQuery && View.CustomVisibilityQuery->Prepare();
|
|
Flags.bUseSphereTestFirst = GFrustumCullUseSphereTestFirst;
|
|
Flags.bUseFastIntersect = (View.GetCullingFrustum().PermutedPlanes.Num() == 8) && GFrustumCullUseFastIntersect;
|
|
Flags.bUseVisibilityOctree = GFrustumCullUseOctree;
|
|
Flags.bHasHiddenPrimitives = View.HiddenPrimitives.Num() > 0;
|
|
Flags.bHasShowOnlyPrimitives = View.ShowOnlyPrimitives.IsSet();
|
|
|
|
UE::Tasks::FTask PrerequisiteTask;
|
|
|
|
#if RHI_RAYTRACING
|
|
View.RayTracingCullingParameters.Init(View);
|
|
|
|
// Sync cached raytracing tasks ShouldCullForRayTracing.
|
|
PrerequisiteTask = Scene.GetCacheRayTracingPrimitivesTask();
|
|
#endif
|
|
|
|
FSceneBitArray* VisibleNodes = nullptr;
|
|
|
|
if (bShouldVisibilityCull && Flags.bUseVisibilityOctree)
|
|
{
|
|
VisibleNodes = TaskData.Allocator.Create<FSceneBitArray>();
|
|
const FConvexVolume& ViewCullingFrustum = View.GetCullingFrustum();
|
|
CullOctree(Scene, View, Flags, *VisibleNodes, ViewCullingFrustum);
|
|
}
|
|
|
|
const bool bCullingIsThreadsafe = (!Flags.bUseCustomCulling || View.CustomVisibilityQuery->IsThreadsafe());
|
|
|
|
if (TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel)
|
|
{
|
|
// Always Visible
|
|
const bool bHasAlwaysVisible = TaskConfig.NumVisiblePrimitives > 0;
|
|
if (bHasAlwaysVisible)
|
|
{
|
|
const float CurrentWorldTime = View.Family->Time.GetWorldTimeSeconds();
|
|
for (uint32 TaskIndex = 0; TaskIndex < TaskConfig.AlwaysVisible.NumTasks; ++TaskIndex)
|
|
{
|
|
Tasks.AlwaysVisible.AddPrerequisites(
|
|
UE::Tasks::Launch(UE_SOURCE_LOCATION, [this, Flags, TaskIndex, CurrentWorldTime]() mutable
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(SceneVisibility_AlwaysVisible);
|
|
SCOPE_CYCLE_COUNTER(STAT_UpdateAlwaysVisible);
|
|
|
|
FTaskTagScope TaskTagScope(ETaskTag::EParallelRenderingThread);
|
|
UpdateAlwaysVisible(Scene, View, Flags, TaskConfig, TaskIndex, CurrentWorldTime);
|
|
|
|
}, PrerequisiteTask, TaskConfig.TaskPriority, UE::Tasks::EExtendedTaskPriority::None));
|
|
}
|
|
}
|
|
|
|
// Frustum Cull
|
|
{
|
|
// Frustum culling tasks have to run serially if custom culling is not thread-safe.
|
|
const UE::Tasks::EExtendedTaskPriority ExtendedTaskPriority = GetExtendedTaskPriority(bCullingIsThreadsafe);
|
|
|
|
// Assign the number of expected commands first so the pipe can determine when the last task has completed.
|
|
OcclusionCull.CommandPipe.AddNumCommands(TaskConfig.FrustumCull.NumTasks);
|
|
|
|
for (uint32 TaskIndex = 0; TaskIndex < TaskConfig.FrustumCull.NumTasks; ++TaskIndex)
|
|
{
|
|
Tasks.FrustumCull.AddPrerequisites(
|
|
UE::Tasks::Launch(UE_SOURCE_LOCATION, [this, Flags, MaxDrawDistanceScale, HLODState, VisibleNodes, TaskIndex]() mutable
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(SceneVisibility_FrustumCull);
|
|
FTaskTagScope TaskTagScope(ETaskTag::EParallelRenderingThread);
|
|
int32 NumCulledPrimitives = FrustumCull(Scene, View, Flags, MaxDrawDistanceScale, HLODState, VisibleNodes, TaskConfig, TaskIndex);
|
|
|
|
FPrimitiveRange PrimitiveRange;
|
|
PrimitiveRange.StartIndex = TaskConfig.FrustumCull.NumPrimitivesPerTask * (TaskIndex);
|
|
PrimitiveRange.EndIndex = TaskConfig.FrustumCull.NumPrimitivesPerTask + PrimitiveRange.StartIndex;
|
|
PrimitiveRange.EndIndex = FMath::Min(PrimitiveRange.EndIndex, int32(TaskConfig.NumTestedPrimitives));
|
|
|
|
// Skip rendering of dynamic objects without static lighting for static reflection captures.
|
|
if (View.bStaticSceneOnly)
|
|
{
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
if (!Scene.PrimitiveSceneProxies[BitIt.GetIndex()]->HasStaticLighting())
|
|
{
|
|
View.PrimitiveVisibilityMap.AccessCorrespondingBit(BitIt) = false;
|
|
NumCulledPrimitives++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Skip rendering of small objects when in wireframe mode for performance since wireframe doesn't enable occlusion culling.
|
|
if (View.Family->EngineShowFlags.Wireframe)
|
|
{
|
|
const float ScreenSizeScale = FMath::Max(View.ViewMatrices.GetProjectionMatrix().M[0][0] * View.ViewRect.Width(), View.ViewMatrices.GetProjectionMatrix().M[1][1] * View.ViewRect.Height());
|
|
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
if (ScreenSizeScale * Scene.PrimitiveBounds[BitIt.GetIndex()].BoxSphereBounds.SphereRadius <= GWireframeCullThreshold)
|
|
{
|
|
View.PrimitiveVisibilityMap.AccessCorrespondingBit(BitIt) = false;
|
|
NumCulledPrimitives++;
|
|
}
|
|
}
|
|
}
|
|
|
|
const uint32 NumVisiblePrimitives = PrimitiveRange.EndIndex - PrimitiveRange.StartIndex - NumCulledPrimitives;
|
|
|
|
if (NumVisiblePrimitives == 0)
|
|
{
|
|
OcclusionCull.CommandPipe.ReleaseNumCommands(1);
|
|
}
|
|
else
|
|
{
|
|
OcclusionCull.CommandPipe.EnqueueCommand(PrimitiveRange);
|
|
}
|
|
|
|
TaskConfig.FrustumCull.NumCulledPrimitives.fetch_add(NumCulledPrimitives, std::memory_order_relaxed);
|
|
|
|
}, bHasAlwaysVisible ? Tasks.AlwaysVisible : PrerequisiteTask, TaskConfig.TaskPriority, ExtendedTaskPriority));
|
|
}
|
|
|
|
OcclusionCull.CommandPipe.ReleaseNumCommands(1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const bool bSingleThreaded = !FApp::ShouldUseThreadingForPerformance() || !bCullingIsThreadsafe;
|
|
|
|
PrerequisiteTask.Wait();
|
|
|
|
const float CurrentWorldTime = View.Family->Time.GetWorldTimeSeconds();
|
|
ParallelFor(TaskConfig.AlwaysVisible.NumTasks, [this, Flags, CurrentWorldTime](int32 TaskIndex)
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(SceneVisibility_AlwaysVisible);
|
|
FTaskTagScope TaskTagScope(ETaskTag::EParallelRenderingThread);
|
|
UpdateAlwaysVisible(Scene, View, Flags, TaskConfig, TaskIndex, CurrentWorldTime);
|
|
|
|
}, bSingleThreaded);
|
|
|
|
ParallelFor(TaskConfig.FrustumCull.NumTasks, [this, Flags, MaxDrawDistanceScale, HLODState, VisibleNodes](int32 TaskIndex)
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(SceneVisibility_FrustumCull);
|
|
FTaskTagScope TaskTagScope(ETaskTag::EParallelRenderingThread);
|
|
int32 NumCulledPrimitives = FrustumCull(Scene, View, Flags, MaxDrawDistanceScale, HLODState, VisibleNodes, TaskConfig, TaskIndex);
|
|
TaskConfig.FrustumCull.NumCulledPrimitives.fetch_add(NumCulledPrimitives, std::memory_order_relaxed);
|
|
|
|
}, bSingleThreaded);
|
|
}
|
|
|
|
Tasks.AlwaysVisible.Trigger();
|
|
Tasks.FrustumCull.Trigger();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FDynamicMeshElementContext::FDynamicMeshElementContext(FSceneRenderer& SceneRenderer)
|
|
: FirstViewFamily(SceneRenderer.ViewFamily)
|
|
, Views(SceneRenderer.AllViews)
|
|
, Primitives(SceneRenderer.Scene->Primitives)
|
|
// Defer committing GPU scene and Material updates until the mesh collectors are finished. Deferring materials allows VT updates to
|
|
// overlap with GDME (uniform expression updates can't happen at the same time as the async VT system update), and since we are going
|
|
// wide across a single view we would otherwise have to lock for GPU scene updates.
|
|
, MeshCollector(SceneRenderer.FeatureLevel, SceneRenderer.Allocator, FMeshElementCollector::ECommitFlags::DeferAll)
|
|
#if WITH_EDITOR
|
|
, EditorMeshCollector(SceneRenderer.FeatureLevel, SceneRenderer.Allocator, FMeshElementCollector::ECommitFlags::DeferAll)
|
|
#endif
|
|
, RHICmdList(new FRHICommandList(FRHIGPUMask::All()))
|
|
, DynamicVertexBuffer(*RHICmdList)
|
|
, DynamicIndexBuffer(*RHICmdList)
|
|
{
|
|
// With Custom Render Passes, it's possible to have Views that point to a different Family. Divide Views into groups with the same family.
|
|
uint8 ViewSubsetMask = 0;
|
|
int32 LastViewIndex = Views.Num() - 1;
|
|
for (int32 ViewIndex = 0; ViewIndex <= LastViewIndex; ViewIndex++)
|
|
{
|
|
ViewSubsetMask |= 1u << ViewIndex;
|
|
|
|
// Check if the next element has a different ViewFamily, or this is the last view. If so, emit the GetDynamicMeshElements call
|
|
// with visibility mask bits set for the subset of views with the same ViewFamily, and reset the mask for the next family.
|
|
if (ViewIndex == LastViewIndex || Views[ViewIndex]->Family != Views[ViewIndex + 1]->Family)
|
|
{
|
|
// Emit a batch with the given mask, and reset the mask
|
|
ViewFamilyGroups.Add({ Views[ViewIndex]->Family, ViewSubsetMask });
|
|
ViewSubsetMask = 0;
|
|
}
|
|
}
|
|
|
|
RHICmdList->SwitchPipeline(ERHIPipeline::Graphics);
|
|
|
|
ViewMeshArraysPerView.SetNum(Views.Num());
|
|
|
|
MeshCollector.Start(
|
|
*RHICmdList,
|
|
DynamicVertexBuffer,
|
|
DynamicIndexBuffer,
|
|
SceneRenderer.DynamicReadBufferForInitViews
|
|
);
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
FViewMeshArrays& ViewMeshArrays = ViewMeshArraysPerView[ViewIndex];
|
|
|
|
MeshCollector.AddViewMeshArrays(
|
|
&View,
|
|
&ViewMeshArrays.DynamicMeshElements,
|
|
&ViewMeshArrays.SimpleElementCollector,
|
|
&View.DynamicPrimitiveCollector
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
, &ViewMeshArrays.DebugSimpleElementCollector
|
|
#endif
|
|
);
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
if (GIsEditor)
|
|
{
|
|
EditorMeshCollector.Start(
|
|
*RHICmdList,
|
|
DynamicVertexBuffer,
|
|
DynamicIndexBuffer,
|
|
SceneRenderer.DynamicReadBufferForInitViews
|
|
);
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
FViewMeshArrays& ViewMeshArrays = ViewMeshArraysPerView[ViewIndex];
|
|
|
|
EditorMeshCollector.AddViewMeshArrays(
|
|
&View,
|
|
&ViewMeshArrays.DynamicEditorMeshElements,
|
|
&ViewMeshArrays.EditorSimpleElementCollector,
|
|
&View.DynamicPrimitiveCollector
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
, &ViewMeshArrays.DebugSimpleElementCollector
|
|
#endif
|
|
);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
FGraphEventRef FDynamicMeshElementContext::LaunchRenderThreadTask(FDynamicPrimitiveIndexList&& PrimitiveIndexList)
|
|
{
|
|
return FFunctionGraphTask::CreateAndDispatchWhenReady([this, PrimitiveIndexList = MoveTemp(PrimitiveIndexList)]
|
|
{
|
|
for (FDynamicPrimitiveIndex PrimitiveIndex : PrimitiveIndexList.Primitives)
|
|
{
|
|
GatherDynamicMeshElementsForPrimitive(Primitives[PrimitiveIndex.Index], PrimitiveIndex.ViewMask);
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
for (FDynamicPrimitiveIndex PrimitiveIndex : PrimitiveIndexList.EditorPrimitives)
|
|
{
|
|
GatherDynamicMeshElementsForEditorPrimitive(Primitives[PrimitiveIndex.Index], PrimitiveIndex.ViewMask);
|
|
}
|
|
#endif
|
|
}, TStatId{}, nullptr, ENamedThreads::GetRenderThread_Local());
|
|
}
|
|
|
|
UE::Tasks::FTask FDynamicMeshElementContext::LaunchAsyncTask(FDynamicPrimitiveIndexQueue* PrimitiveIndexQueue, UE::Tasks::ETaskPriority TaskPriority)
|
|
{
|
|
return Pipe.Launch(UE_SOURCE_LOCATION, [this, PrimitiveIndexQueue]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
FDynamicPrimitiveIndex PrimitiveIndex;
|
|
|
|
while (PrimitiveIndexQueue->Pop(PrimitiveIndex))
|
|
{
|
|
GatherDynamicMeshElementsForPrimitive(Primitives[PrimitiveIndex.Index], PrimitiveIndex.ViewMask);
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
while (PrimitiveIndexQueue->PopEditor(PrimitiveIndex))
|
|
{
|
|
GatherDynamicMeshElementsForEditorPrimitive(Primitives[PrimitiveIndex.Index], PrimitiveIndex.ViewMask);
|
|
}
|
|
#endif
|
|
}, TaskPriority);
|
|
}
|
|
|
|
void FDynamicMeshElementContext::GatherDynamicMeshElementsForPrimitive(FPrimitiveSceneInfo* Primitive, uint8 ViewMask)
|
|
{
|
|
SCOPED_NAMED_EVENT(DynamicPrimitive, FColor::Magenta);
|
|
|
|
TArray<int32, TInlineAllocator<4>> MeshBatchCountBefore;
|
|
MeshBatchCountBefore.SetNumUninitialized(Views.Num());
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
MeshBatchCountBefore[ViewIndex] = MeshCollector.GetMeshBatchCount(ViewIndex);
|
|
}
|
|
|
|
MeshCollector.SetPrimitive(Primitive->Proxy, Primitive->DefaultDynamicHitProxyId);
|
|
|
|
// If Custom Render Passes aren't in use, there will be only one group, which is the common case.
|
|
if (ViewFamilyGroups.Num() == 1 || Primitive->Proxy->SinglePassGDME())
|
|
{
|
|
Primitive->Proxy->GetDynamicMeshElements(FirstViewFamily.AllViews, FirstViewFamily, ViewMask, MeshCollector);
|
|
}
|
|
else
|
|
{
|
|
for (FViewFamilyGroup& Group : ViewFamilyGroups)
|
|
{
|
|
if (uint8 MaskedViewMask = ViewMask & Group.ViewSubsetMask)
|
|
{
|
|
Primitive->Proxy->GetDynamicMeshElements(FirstViewFamily.AllViews, *Group.Family, MaskedViewMask, MeshCollector);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
|
|
if (ViewMask & (1 << ViewIndex))
|
|
{
|
|
FDynamicPrimitive& DynamicPrimitive = DynamicPrimitives.Emplace_GetRef();
|
|
DynamicPrimitive.PrimitiveIndex = Primitive->GetIndex();
|
|
DynamicPrimitive.ViewIndex = ViewIndex;
|
|
DynamicPrimitive.StartElementIndex = MeshBatchCountBefore[ViewIndex];
|
|
DynamicPrimitive.EndElementIndex = MeshCollector.GetMeshBatchCount(ViewIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FDynamicMeshElementContext::GatherDynamicMeshElementsForEditorPrimitive(FPrimitiveSceneInfo* Primitive, uint8 ViewMask)
|
|
{
|
|
#if WITH_EDITOR
|
|
EditorMeshCollector.SetPrimitive(Primitive->Proxy, Primitive->DefaultDynamicHitProxyId);
|
|
|
|
// If Custom Render Passes aren't in use, there will be only one group, which is the common case.
|
|
if (ViewFamilyGroups.Num() == 1 || Primitive->Proxy->SinglePassGDME())
|
|
{
|
|
Primitive->Proxy->GetDynamicMeshElements(FirstViewFamily.AllViews, FirstViewFamily, ViewMask, EditorMeshCollector);
|
|
}
|
|
else
|
|
{
|
|
for (FViewFamilyGroup& Group : ViewFamilyGroups)
|
|
{
|
|
if (uint8 MaskedViewMask = ViewMask & Group.ViewSubsetMask)
|
|
{
|
|
Primitive->Proxy->GetDynamicMeshElements(FirstViewFamily.AllViews, *Group.Family, MaskedViewMask, EditorMeshCollector);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void FDynamicMeshElementContext::Finish()
|
|
{
|
|
MeshCollector.Finish();
|
|
|
|
#if WITH_EDITOR
|
|
if (GIsEditor)
|
|
{
|
|
EditorMeshCollector.Finish();
|
|
}
|
|
#endif
|
|
|
|
DynamicVertexBuffer.Commit();
|
|
DynamicIndexBuffer.Commit();
|
|
RHICmdList->FinishRecording();
|
|
|
|
// Even though task dependencies are setup so all work is done by this point, we still have to wait on the
|
|
// pipe to clear out its internal state. Otherwise it can assert that it still has work at shutdown.
|
|
Pipe.WaitUntilEmpty();
|
|
}
|
|
|
|
FDynamicMeshElementContextContainer::~FDynamicMeshElementContextContainer()
|
|
{
|
|
check(CommandLists.IsEmpty());
|
|
}
|
|
|
|
UE::Tasks::FTask FDynamicMeshElementContextContainer::LaunchAsyncTask(FDynamicPrimitiveIndexQueue* PrimitiveIndexQueue, int32 Index, UE::Tasks::ETaskPriority TaskPriority)
|
|
{
|
|
return Contexts[Index]->LaunchAsyncTask(PrimitiveIndexQueue, TaskPriority);
|
|
}
|
|
|
|
FGraphEventRef FDynamicMeshElementContextContainer::LaunchRenderThreadTask(FDynamicPrimitiveIndexList&& PrimitiveIndexList)
|
|
{
|
|
return Contexts.Last()->LaunchRenderThreadTask(MoveTemp(PrimitiveIndexList));
|
|
}
|
|
|
|
void FDynamicMeshElementContextContainer::Init(FSceneRenderer& SceneRenderer, int32 NumAsyncContexts)
|
|
{
|
|
const int32 NumRenderThreadContexts = 1;
|
|
const int32 NumContexts = NumAsyncContexts + NumRenderThreadContexts;
|
|
Views = SceneRenderer.AllViews;
|
|
Contexts.Reserve(NumContexts);
|
|
CommandLists.Reserve(Contexts.Num());
|
|
|
|
for (int32 Index = 0; Index < NumContexts; ++Index)
|
|
{
|
|
FDynamicMeshElementContext* Context = SceneRenderer.Allocator.Create<FDynamicMeshElementContext>(SceneRenderer);
|
|
Contexts.Emplace(Context);
|
|
CommandLists.Emplace(Context->RHICmdList);
|
|
}
|
|
}
|
|
|
|
void FDynamicMeshElementContextContainer::MergeContexts(TArray<FDynamicPrimitive, SceneRenderingAllocator>& OutDynamicPrimitives)
|
|
{
|
|
SCOPED_NAMED_EVENT(MergeGatherDynamicMeshElementContexts, FColor::Magenta);
|
|
|
|
check(!Views.IsEmpty());
|
|
|
|
// Fast path for one context; just move the memory instead of copying.
|
|
if (Contexts.Num() == 1)
|
|
{
|
|
FDynamicMeshElementContext* Context = Contexts[0];
|
|
OutDynamicPrimitives = MoveTemp(Context->DynamicPrimitives);
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
|
|
{
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
FDynamicMeshElementContext::FViewMeshArrays& ViewMeshArrays = Context->ViewMeshArraysPerView[ViewIndex];
|
|
|
|
View.SimpleElementCollector = MoveTemp(ViewMeshArrays.SimpleElementCollector);
|
|
View.DynamicMeshElements = MoveTemp(ViewMeshArrays.DynamicMeshElements);
|
|
|
|
#if WITH_EDITOR
|
|
View.EditorSimpleElementCollector = MoveTemp(ViewMeshArrays.EditorSimpleElementCollector);
|
|
View.DynamicEditorMeshElements = MoveTemp(ViewMeshArrays.DynamicEditorMeshElements);
|
|
#endif
|
|
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
View.DebugSimpleElementCollector = MoveTemp(ViewMeshArrays.DebugSimpleElementCollector);
|
|
#endif
|
|
}
|
|
}
|
|
// >1 context means we have to merge the containers.
|
|
else
|
|
{
|
|
struct FViewAllocationInfo
|
|
{
|
|
FSimpleElementCollector::FAllocationInfo SimpleElementCollector;
|
|
uint32 NumDynamicMeshElements = 0;
|
|
#if WITH_EDITOR
|
|
FSimpleElementCollector::FAllocationInfo EditorSimpleElementCollector;
|
|
uint32 NumDynamicEditorMeshElements = 0;
|
|
#endif
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
FSimpleElementCollector::FAllocationInfo DebugSimpleElementCollector;
|
|
#endif
|
|
};
|
|
|
|
TArray<FViewAllocationInfo, TInlineAllocator<2>> AllocationInfosPerView;
|
|
AllocationInfosPerView.AddDefaulted(Views.Num());
|
|
uint32 NumDynamicPrimitives = 0;
|
|
|
|
for (FDynamicMeshElementContext* Context : Contexts)
|
|
{
|
|
NumDynamicPrimitives += Context->DynamicPrimitives.Num();
|
|
check(AllocationInfosPerView.Num() == Context->ViewMeshArraysPerView.Num());
|
|
|
|
// Accumulate allocation info for each context in order to reserve container memory once.
|
|
for (int32 ViewIndex = 0; ViewIndex < AllocationInfosPerView.Num(); ++ViewIndex)
|
|
{
|
|
const FDynamicMeshElementContext::FViewMeshArrays& ViewMeshArrays = Context->ViewMeshArraysPerView[ViewIndex];
|
|
FViewAllocationInfo& AllocationInfo = AllocationInfosPerView[ViewIndex];
|
|
|
|
ViewMeshArrays.SimpleElementCollector.AddAllocationInfo(AllocationInfo.SimpleElementCollector);
|
|
AllocationInfo.NumDynamicMeshElements += ViewMeshArrays.DynamicMeshElements.Num();
|
|
#if WITH_EDITOR
|
|
ViewMeshArrays.EditorSimpleElementCollector.AddAllocationInfo(AllocationInfo.EditorSimpleElementCollector);
|
|
AllocationInfo.NumDynamicEditorMeshElements += ViewMeshArrays.DynamicEditorMeshElements.Num();
|
|
#endif
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
ViewMeshArrays.DebugSimpleElementCollector.AddAllocationInfo(AllocationInfo.DebugSimpleElementCollector);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
OutDynamicPrimitives.Reserve(NumDynamicPrimitives);
|
|
|
|
// Reserve memory for merged containers.
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
|
|
{
|
|
FViewAllocationInfo& AllocationInfo = AllocationInfosPerView[ViewIndex];
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
|
|
View.SimpleElementCollector.Reserve(AllocationInfo.SimpleElementCollector);
|
|
View.DynamicMeshElements.Reserve(AllocationInfo.NumDynamicMeshElements);
|
|
#if WITH_EDITOR
|
|
View.EditorSimpleElementCollector.Reserve(AllocationInfo.EditorSimpleElementCollector);
|
|
View.DynamicEditorMeshElements.Reserve(AllocationInfo.NumDynamicEditorMeshElements);
|
|
#endif
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
View.DebugSimpleElementCollector.Reserve(AllocationInfo.DebugSimpleElementCollector);
|
|
#endif
|
|
|
|
// Reset dynamic element count to use as offset for copying ranges in the next loop.
|
|
AllocationInfo.NumDynamicMeshElements = 0;
|
|
}
|
|
|
|
for (FDynamicMeshElementContext* Context : Contexts)
|
|
{
|
|
for (FDynamicPrimitive DynamicPrimitive : Context->DynamicPrimitives)
|
|
{
|
|
const uint32 NumDynamicMeshElements = AllocationInfosPerView[DynamicPrimitive.ViewIndex].NumDynamicMeshElements;
|
|
|
|
// Offset the dynamic element range by the current number of meshes in the final container.
|
|
DynamicPrimitive.StartElementIndex += NumDynamicMeshElements;
|
|
DynamicPrimitive.EndElementIndex += NumDynamicMeshElements;
|
|
|
|
OutDynamicPrimitives.Emplace(DynamicPrimitive);
|
|
|
|
Views[DynamicPrimitive.ViewIndex]->DynamicMeshElementRanges[DynamicPrimitive.PrimitiveIndex] = FInt32Vector2(DynamicPrimitive.StartElementIndex, DynamicPrimitive.EndElementIndex);
|
|
}
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
|
|
{
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
FDynamicMeshElementContext::FViewMeshArrays& ViewMeshArrays = Context->ViewMeshArraysPerView[ViewIndex];
|
|
|
|
AllocationInfosPerView[ViewIndex].NumDynamicMeshElements += ViewMeshArrays.DynamicMeshElements.Num();
|
|
|
|
View.SimpleElementCollector.Append(ViewMeshArrays.SimpleElementCollector);
|
|
View.DynamicMeshElements.Append(ViewMeshArrays.DynamicMeshElements);
|
|
#if WITH_EDITOR
|
|
View.EditorSimpleElementCollector.Append(ViewMeshArrays.EditorSimpleElementCollector);
|
|
View.DynamicEditorMeshElements.Append(ViewMeshArrays.DynamicEditorMeshElements);
|
|
#endif
|
|
#if UE_ENABLE_DEBUG_DRAWING
|
|
View.DebugSimpleElementCollector.Append(ViewMeshArrays.DebugSimpleElementCollector);
|
|
#endif
|
|
}
|
|
|
|
Context->DynamicPrimitives.Empty();
|
|
Context->ViewMeshArraysPerView.Empty();
|
|
}
|
|
}
|
|
}
|
|
|
|
void FDynamicMeshElementContextContainer::Submit(FRHICommandListImmediate& RHICmdList)
|
|
{
|
|
for (FDynamicMeshElementContext* Context : Contexts)
|
|
{
|
|
Context->Finish();
|
|
}
|
|
|
|
RHICmdList.QueueAsyncCommandListSubmit(CommandLists);
|
|
CommandLists.Empty();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FVisibilityTaskData::FVisibilityTaskData(FRHICommandListImmediate& InRHICmdList, FSceneRenderer& InSceneRenderer)
|
|
: RHICmdList(InRHICmdList)
|
|
, SceneRenderer(InSceneRenderer)
|
|
, Scene(*SceneRenderer.Scene)
|
|
, Views(SceneRenderer.AllViews)
|
|
, ViewFamily(SceneRenderer.ViewFamily)
|
|
, ShadingPath(GetFeatureLevelShadingPath(Scene.GetFeatureLevel()))
|
|
, TaskConfig(Scene, Views)
|
|
, bAddNaniteRelevance(InSceneRenderer.ShouldRenderNanite())
|
|
, bAddLightmapDensityCommands(ViewFamily.EngineShowFlags.LightMapDensity&& AllowDebugViewmodes())
|
|
{
|
|
Tasks.bWaitingAllowed = TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel;
|
|
}
|
|
|
|
void FVisibilityTaskData::LaunchVisibilityTasks(const UE::Tasks::FTask& BeginInitVisibilityPrerequisites)
|
|
{
|
|
SCOPED_NAMED_EVENT(LaunchVisibilityTasks, FColor::Magenta);
|
|
ViewPackets.Reserve(Views.Num());
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
|
|
{
|
|
if (Views[ViewIndex]->bIsSinglePassStereo && Views[ViewIndex]->StereoPass == EStereoscopicPass::eSSP_SECONDARY)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Each non-vestigial view gets its own visibility task packet which contains all the state to manage the task graph for a view.
|
|
FVisibilityViewPacket& ViewPacket = ViewPackets.Emplace_GetRef(*this, Scene, *Views[ViewIndex], ViewIndex);
|
|
|
|
// Each respective stage of visibility for each view is connected to its corresponding task event in order to track when all views complete each stage.
|
|
Tasks.LightVisibility.AddPrerequisites(ViewPacket.Tasks.LightVisibility);
|
|
Tasks.FrustumCull.AddPrerequisites(ViewPacket.Tasks.FrustumCull);
|
|
Tasks.OcclusionCull.AddPrerequisites(ViewPacket.Tasks.OcclusionCull);
|
|
Tasks.ComputeRelevance.AddPrerequisites(ViewPacket.Tasks.ComputeRelevance);
|
|
|
|
if (ViewPacket.ViewState)
|
|
{
|
|
SCOPE_CYCLE_COUNTER(STAT_DecompressPrecomputedOcclusion);
|
|
ViewPacket.View.PrecomputedVisibilityData = ViewPacket.ViewState->ResolvePrecomputedVisibilityData(ViewPacket.View, &Scene);
|
|
|
|
if (ViewPacket.View.PrecomputedVisibilityData)
|
|
{
|
|
SceneRenderer.bUsedPrecomputedVisibility = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Each relevance task should have this as a prerequisite, but in case there aren't any tasks we make it explicit.
|
|
Tasks.ComputeRelevance.AddPrerequisites(Scene.GetCacheMeshDrawCommandsTask());
|
|
|
|
// Wait on the GPU skin update task prior to GDME.
|
|
Tasks.DynamicMeshElementsPrerequisites.AddPrerequisites(Scene.GetGPUSkinUpdateTask());
|
|
|
|
bool bAllocatePrimitiveViewMasks = true;
|
|
|
|
if (TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel)
|
|
{
|
|
if (ViewPackets.Num() == 1)
|
|
{
|
|
// When using a single view, dynamic mesh elements are pushed into a pipe that is executed on the render thread which allows for some overlap with compute relevance work.
|
|
DynamicMeshElements.CommandPipe = Allocator.Create<TCommandPipe<FDynamicPrimitiveIndexList>>(TEXT("GatherDynamicMeshElements"));
|
|
|
|
DynamicMeshElements.CommandPipe->SetCommandFunction([this](FDynamicPrimitiveIndexList&& DynamicPrimitiveIndexList)
|
|
{
|
|
GatherDynamicMeshElements(MoveTemp(DynamicPrimitiveIndexList));
|
|
});
|
|
|
|
DynamicMeshElements.CommandPipe->SetPrerequisiteTask(Tasks.DynamicMeshElementsPrerequisites);
|
|
|
|
Tasks.DynamicMeshElementsPipe = FGraphEvent::CreateGraphEvent();
|
|
|
|
DynamicMeshElements.CommandPipe->SetEmptyFunction([this]
|
|
{
|
|
Tasks.DynamicMeshElementsPipe->DispatchSubsequents();
|
|
Tasks.DynamicMeshElements.Trigger();
|
|
});
|
|
|
|
// Take a reference that is released when the relevance pipe has completed. We only need to take one since there can only be one view.
|
|
DynamicMeshElements.CommandPipe->AddNumCommands(1);
|
|
|
|
// We don't need the primitive view masks when in parallel mode with a single view.
|
|
bAllocatePrimitiveViewMasks = false;
|
|
}
|
|
}
|
|
|
|
if (bAllocatePrimitiveViewMasks)
|
|
{
|
|
DynamicMeshElements.PrimitiveViewMasks = Allocator.Create<FDynamicPrimitiveViewMasks>();
|
|
DynamicMeshElements.PrimitiveViewMasks->Primitives.AddZeroed(Scene.Primitives.Num());
|
|
|
|
#if WITH_EDITOR
|
|
if (GIsEditor)
|
|
{
|
|
DynamicMeshElements.PrimitiveViewMasks->EditorPrimitives.AddZeroed(Scene.Primitives.Num());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
DynamicMeshElements.ContextContainer.Init(SceneRenderer, GetNumDynamicMeshElementTasks());
|
|
DynamicMeshElements.ViewCommandsPerView.SetNum(Views.Num());
|
|
|
|
Tasks.LightVisibility.AddPrerequisites(UE::Tasks::Launch(UE_SOURCE_LOCATION, [this]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
SceneRenderer.ComputeLightVisibility();
|
|
|
|
}, TaskConfig.TaskPriority));
|
|
|
|
if (TaskConfig.Schedule == EVisibilityTaskSchedule::Parallel)
|
|
{
|
|
SceneRenderer.WaitOcclusionTests(RHICmdList);
|
|
|
|
// Parallel occlusion culling is not supported on mobile
|
|
check(!Views.IsEmpty())
|
|
checkf(!Views[0]->bIsMobileMultiViewEnabled, TEXT("This culling path was not tested with MMV"));
|
|
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
if (ViewPacket.OcclusionCull.ContextIfParallel)
|
|
{
|
|
ViewPacket.OcclusionCull.ContextIfParallel->Map(RHICmdList);
|
|
}
|
|
|
|
Tasks.BeginInitVisibility.AddPrerequisites(UE::Tasks::Launch(UE_SOURCE_LOCATION, [&ViewPacket]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
ViewPacket.BeginInitVisibility();
|
|
|
|
}, BeginInitVisibilityPrerequisites, TaskConfig.TaskPriority));
|
|
}
|
|
|
|
// Static relevance is finalized for ALL views after each view completes static mesh filtering tasks.
|
|
Tasks.FinalizeRelevance = UE::Tasks::Launch(UE_SOURCE_LOCATION, [this]
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(FSceneRenderer_FinalizeStaticRelevance);
|
|
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
ViewPacket.Relevance.Context->Finalize();
|
|
}
|
|
|
|
}, Tasks.ComputeRelevance, TaskConfig.TaskPriority);
|
|
}
|
|
|
|
// All task events are connected to prerequisites now and can be safely triggered.
|
|
Tasks.BeginInitVisibility.Trigger();
|
|
Tasks.LightVisibility.Trigger();
|
|
Tasks.FrustumCull.Trigger();
|
|
Tasks.OcclusionCull.Trigger();
|
|
Tasks.ComputeRelevance.Trigger();
|
|
}
|
|
|
|
void FVisibilityTaskData::GatherDynamicMeshElements(FDynamicPrimitiveIndexList&& DynamicPrimitiveIndexList)
|
|
{
|
|
FDynamicPrimitiveIndexList RenderThreadDynamicPrimitiveIndexList;
|
|
|
|
const int32 NumAsyncContexts = DynamicMeshElements.ContextContainer.GetNumAsyncContexts();
|
|
|
|
if (NumAsyncContexts > 0)
|
|
{
|
|
const auto FilterDynamicPrimitives = [] (TArrayView<FPrimitiveSceneProxy*> PrimitiveSceneProxies, FDynamicPrimitiveIndexList::FList& Primitives, FDynamicPrimitiveIndexList::FList& RenderThreadPrimitives)
|
|
{
|
|
for (int32 Index = 0; Index < Primitives.Num(); )
|
|
{
|
|
const FDynamicPrimitiveIndex PrimitiveIndex = Primitives[Index];
|
|
|
|
if (!PrimitiveSceneProxies[PrimitiveIndex.Index]->SupportsParallelGDME())
|
|
{
|
|
RenderThreadPrimitives.Emplace(PrimitiveIndex);
|
|
Primitives.RemoveAtSwap(Index, EAllowShrinking::No);
|
|
}
|
|
else
|
|
{
|
|
Index++;
|
|
}
|
|
}
|
|
};
|
|
|
|
FilterDynamicPrimitives(Scene.PrimitiveSceneProxies, DynamicPrimitiveIndexList.Primitives, RenderThreadDynamicPrimitiveIndexList.Primitives);
|
|
#if WITH_EDITOR
|
|
FilterDynamicPrimitives(Scene.PrimitiveSceneProxies, DynamicPrimitiveIndexList.EditorPrimitives, RenderThreadDynamicPrimitiveIndexList.EditorPrimitives);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
RenderThreadDynamicPrimitiveIndexList = MoveTemp(DynamicPrimitiveIndexList);
|
|
DynamicPrimitiveIndexList = {};
|
|
}
|
|
|
|
if (!RenderThreadDynamicPrimitiveIndexList.IsEmpty())
|
|
{
|
|
Tasks.DynamicMeshElementsRenderThread = DynamicMeshElements.ContextContainer.LaunchRenderThreadTask(MoveTemp(RenderThreadDynamicPrimitiveIndexList));
|
|
}
|
|
|
|
if (!DynamicPrimitiveIndexList.IsEmpty())
|
|
{
|
|
FDynamicPrimitiveIndexQueue* Queue = Allocator.Create<FDynamicPrimitiveIndexQueue>(MoveTemp(DynamicPrimitiveIndexList));
|
|
|
|
for (int32 Index = 0; Index < DynamicMeshElements.ContextContainer.GetNumAsyncContexts(); ++Index)
|
|
{
|
|
Tasks.DynamicMeshElements.AddPrerequisites(DynamicMeshElements.ContextContainer.LaunchAsyncTask(Queue, Index, TaskConfig.TaskPriority));
|
|
}
|
|
}
|
|
}
|
|
|
|
void FVisibilityTaskData::GatherDynamicMeshElements(const FDynamicPrimitiveViewMasks& DynamicPrimitiveViewMasks)
|
|
{
|
|
SCOPED_NAMED_EVENT(GatherDynamicMeshElements, FColor::Magenta);
|
|
|
|
Tasks.DynamicMeshElementsPrerequisites.Wait();
|
|
|
|
const auto GetPrimaryViewMask = [this] (uint8 ViewMask) -> uint8
|
|
{
|
|
// If a mesh is visible in a secondary view, mark it as visible in the primary view
|
|
uint8 ViewMaskFinal = ViewMask;
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
const FViewInfo& View = *Views[ViewIndex];
|
|
|
|
if (ViewMask & (1 << ViewIndex) && IStereoRendering::IsASecondaryView(View))
|
|
{
|
|
ViewMaskFinal |= 1 << Views[ViewIndex]->PrimaryViewIndex;
|
|
}
|
|
}
|
|
|
|
return ViewMaskFinal;
|
|
};
|
|
|
|
FDynamicPrimitiveIndexList DynamicPrimitiveIndexList;
|
|
DynamicPrimitiveIndexList.Primitives.Reserve(128);
|
|
|
|
const int32 NumPrimitives = DynamicPrimitiveViewMasks.Primitives.Num();
|
|
|
|
for (int32 PrimitiveIndex = 0; PrimitiveIndex < NumPrimitives; ++PrimitiveIndex)
|
|
{
|
|
const uint8 ViewMask = DynamicPrimitiveViewMasks.Primitives[PrimitiveIndex];
|
|
|
|
if (ViewMask != 0)
|
|
{
|
|
DynamicPrimitiveIndexList.Primitives.Emplace(PrimitiveIndex, GetPrimaryViewMask(ViewMask));
|
|
}
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
if (GIsEditor)
|
|
{
|
|
DynamicPrimitiveIndexList.EditorPrimitives.Reserve(128);
|
|
|
|
for (int32 PrimitiveIndex = 0; PrimitiveIndex < NumPrimitives; ++PrimitiveIndex)
|
|
{
|
|
const uint8 ViewMask = DynamicPrimitiveViewMasks.EditorPrimitives[PrimitiveIndex];
|
|
|
|
if (ViewMask != 0)
|
|
{
|
|
DynamicPrimitiveIndexList.EditorPrimitives.Emplace(PrimitiveIndex, GetPrimaryViewMask(ViewMask));
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
GatherDynamicMeshElements(MoveTemp(DynamicPrimitiveIndexList));
|
|
Tasks.DynamicMeshElements.Trigger();
|
|
}
|
|
|
|
void FVisibilityTaskData::SetupMeshPasses(FExclusiveDepthStencil::Type BasePassDepthStencilAccess, FInstanceCullingManager& InstanceCullingManager)
|
|
{
|
|
DynamicMeshElements.ContextContainer.MergeContexts(DynamicMeshElements.DynamicPrimitives);
|
|
|
|
{
|
|
SCOPED_NAMED_EVENT(DynamicRelevance, FColor::Magenta);
|
|
|
|
for (FViewInfo* View : Views)
|
|
{
|
|
View->DynamicMeshElementsPassRelevance.SetNum(View->DynamicMeshElements.Num());
|
|
}
|
|
|
|
const bool bIsTLVUsingVoxelMarking = IsTranslucencyLightingVolumeUsingVoxelMarking();
|
|
|
|
for (FDynamicPrimitive DynamicPrimitive : DynamicMeshElements.DynamicPrimitives)
|
|
{
|
|
FPrimitiveSceneInfo* PrimitiveSceneInfo = Scene.Primitives[DynamicPrimitive.PrimitiveIndex];
|
|
const FPrimitiveBounds& Bounds = Scene.PrimitiveBounds[DynamicPrimitive.PrimitiveIndex];
|
|
FViewInfo& View = *Views[DynamicPrimitive.ViewIndex];
|
|
const FPrimitiveViewRelevance& ViewRelevance = View.PrimitiveViewRelevanceMap[DynamicPrimitive.PrimitiveIndex];
|
|
|
|
for (int32 ElementIndex = DynamicPrimitive.StartElementIndex; ElementIndex < DynamicPrimitive.EndElementIndex; ++ElementIndex)
|
|
{
|
|
const FMeshBatchAndRelevance& MeshBatch = View.DynamicMeshElements[ElementIndex];
|
|
FMeshPassMask& PassRelevance = View.DynamicMeshElementsPassRelevance[ElementIndex];
|
|
|
|
ComputeDynamicMeshRelevance(ShadingPath, bAddLightmapDensityCommands, bIsTLVUsingVoxelMarking, ViewRelevance, MeshBatch, View, PassRelevance, PrimitiveSceneInfo, Bounds);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = *Views[ViewIndex];
|
|
|
|
#if WITH_EDITOR
|
|
{
|
|
// Sort the selected Nanite hit proxy IDs
|
|
Algo::Sort(View.EditorSelectedNaniteHitProxyIds);
|
|
|
|
// Make sure it is power of 2 as it is searched in the shader with binary search that only works with power2 buffer sizes
|
|
int32 PreviousCount = View.EditorSelectedNaniteHitProxyIds.Num();
|
|
int32 NewCount = FMath::RoundUpToPowerOfTwo(PreviousCount);
|
|
|
|
if (PreviousCount > 0)
|
|
{
|
|
const uint32 LastValue = View.EditorSelectedNaniteHitProxyIds.Last();
|
|
View.EditorSelectedNaniteHitProxyIds.SetNumUninitialized(NewCount);
|
|
// Pad the end with the last value to ensure still sorted
|
|
for (int32 Index = PreviousCount; Index < NewCount; ++Index)
|
|
{
|
|
View.EditorSelectedNaniteHitProxyIds[Index] = LastValue;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
FSceneViewState* ViewState = static_cast<FSceneViewState*>(View.State);
|
|
|
|
// if we are freezing the scene, then remember the primitives that are rendered.
|
|
if (ViewState && ViewState->bIsFreezing)
|
|
{
|
|
for (FSceneSetBitIterator BitIt(View.PrimitiveVisibilityMap); BitIt; ++BitIt)
|
|
{
|
|
ViewState->FrozenPrimitives.Add(Scene.PrimitiveComponentIds[BitIt.GetIndex()]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!View.ShouldRenderView())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FViewCommands& ViewCommands = DynamicMeshElements.ViewCommandsPerView[ViewIndex];
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
FViewDebugInfo::Get().ProcessPrimitives(&Scene, View, ViewCommands);
|
|
#endif
|
|
|
|
SceneRenderer.SetupMeshPass(View, BasePassDepthStencilAccess, ViewCommands, InstanceCullingManager);
|
|
}
|
|
}
|
|
|
|
void FVisibilityTaskData::ProcessRenderThreadTasks()
|
|
{
|
|
SCOPE_CYCLE_COUNTER(STAT_ViewVisibilityTime);
|
|
SCOPED_NAMED_EVENT(ProcessVisibilityTasks, FColor::Magenta);
|
|
|
|
UE::Tasks::FTask VirtualTextureTask;
|
|
|
|
StartGatherDynamicMeshElements();
|
|
|
|
FPrimitiveRange PrimitiveRange;
|
|
PrimitiveRange.StartIndex = 0u;
|
|
PrimitiveRange.EndIndex = TaskConfig.NumTestedPrimitives;
|
|
|
|
if (TaskConfig.Schedule == EVisibilityTaskSchedule::RenderThread)
|
|
{
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
if (ViewPacket.ViewState)
|
|
{
|
|
ViewPacket.ViewState->ActivateFrozenViewMatrices(ViewPacket.View);
|
|
}
|
|
#endif
|
|
|
|
ViewPacket.BeginInitVisibility();
|
|
UpdatePrimitiveFading(Scene, ViewPacket.View, ViewPacket.ViewState, PrimitiveRange);
|
|
}
|
|
|
|
SceneRenderer.WaitOcclusionTests(RHICmdList);
|
|
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
SCOPED_NAMED_EVENT(OcclusionCull, FColor::Magenta);
|
|
const int32 NumCulledPrimitives = PrecomputedOcclusionCull(ViewPacket, PrimitiveRange);
|
|
|
|
if (ViewPacket.OcclusionCull.ContextIfSerial)
|
|
{
|
|
ViewPacket.OcclusionCull.ContextIfSerial->Map(RHICmdList);
|
|
ViewPacket.OcclusionCull.ContextIfSerial->AddPrimitives(PrimitiveRange);
|
|
ViewPacket.OcclusionCull.ContextIfSerial->Unmap(RHICmdList);
|
|
}
|
|
|
|
if (NumCulledPrimitives > 0)
|
|
{
|
|
TaskConfig.OcclusionCull.NumCulledPrimitives.fetch_add(NumCulledPrimitives, std::memory_order_relaxed);
|
|
}
|
|
|
|
ViewPacket.Tasks.OcclusionCull.Trigger();
|
|
}
|
|
|
|
// Relevance requires that cached mesh commands be available first.
|
|
Scene.WaitForCacheMeshDrawCommandsTask();
|
|
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
for (FSceneSetBitIterator BitIt(ViewPacket.View.PrimitiveVisibilityMap, PrimitiveRange.StartIndex); BitIt.GetIndex() < PrimitiveRange.EndIndex; ++BitIt)
|
|
{
|
|
ViewPacket.Relevance.Context->AddPrimitive(BitIt.GetIndex());
|
|
}
|
|
ViewPacket.Relevance.Context->Finalize();
|
|
ViewPacket.Tasks.ComputeRelevance.Trigger();
|
|
}
|
|
|
|
Tasks.bWaitingAllowed = true;
|
|
|
|
check(DynamicMeshElements.PrimitiveViewMasks);
|
|
GatherDynamicMeshElements(*DynamicMeshElements.PrimitiveViewMasks);
|
|
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
if (ViewPacket.ViewState)
|
|
{
|
|
ViewPacket.ViewState->RestoreUnfrozenViewMatrices(ViewPacket.View);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
if (DynamicMeshElements.CommandPipe)
|
|
{
|
|
SCOPED_NAMED_EVENT(WaitForVisibilityTasks, FColor::Magenta);
|
|
CSV_SCOPED_SET_WAIT_STAT(Visibility);
|
|
|
|
// Wait on the command pipe first as it will be continually updating the render thread event (and process tasks while we wait).
|
|
Tasks.DynamicMeshElementsPipe->Wait(ENamedThreads::GetRenderThread_Local());
|
|
}
|
|
else
|
|
{
|
|
Tasks.ComputeRelevance.Wait();
|
|
check(DynamicMeshElements.PrimitiveViewMasks);
|
|
GatherDynamicMeshElements(*DynamicMeshElements.PrimitiveViewMasks);
|
|
}
|
|
|
|
for (FVisibilityViewPacket& ViewPacket : ViewPackets)
|
|
{
|
|
if (ViewPacket.OcclusionCull.ContextIfParallel)
|
|
{
|
|
ViewPacket.OcclusionCull.ContextIfParallel->Unmap(RHICmdList);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now process all gather dynamic mesh element tasks that were queued up to run on the render thread.
|
|
if (Tasks.DynamicMeshElementsRenderThread)
|
|
{
|
|
Tasks.DynamicMeshElementsRenderThread->Wait(ENamedThreads::GetRenderThread_Local());
|
|
}
|
|
|
|
Tasks.LightVisibility.Wait();
|
|
Tasks.FinalizeRelevance.Wait();
|
|
|
|
INC_DWORD_STAT_BY(STAT_ProcessedPrimitives, PrimitiveRange.EndIndex * Views.Num());
|
|
INC_DWORD_STAT_BY(STAT_CulledPrimitives, TaskConfig.FrustumCull.NumCulledPrimitives);
|
|
INC_DWORD_STAT_BY(STAT_OccludedPrimitives, TaskConfig.OcclusionCull.NumCulledPrimitives);
|
|
|
|
TRACE_COUNTER_SET(Scene_Visibility_NumProcessedPrimitives, PrimitiveRange.EndIndex * Views.Num());
|
|
TRACE_COUNTER_SET(Scene_Visibility_FrustumCull_NumPrimitivesPerTask, TaskConfig.FrustumCull.NumPrimitivesPerTask);
|
|
TRACE_COUNTER_SET(Scene_Visibility_FrustumCull_NumCulledPrimitives, TaskConfig.FrustumCull.NumCulledPrimitives);
|
|
TRACE_COUNTER_SET(Scene_Visibility_OcclusionCull_NumCulledPrimitives, TaskConfig.OcclusionCull.NumCulledPrimitives);
|
|
TRACE_COUNTER_SET(Scene_Visibility_OcclusionCull_NumTestedQueries, TaskConfig.OcclusionCull.NumTestedQueries);
|
|
TRACE_COUNTER_SET(Scene_Visibility_Relevance_NumPrimitivesPerPacket, TaskConfig.Relevance.NumPrimitivesPerPacket);
|
|
}
|
|
|
|
void FVisibilityTaskData::FinishGatherDynamicMeshElements(FExclusiveDepthStencil::Type BasePassDepthStencilAccess, FInstanceCullingManager& InstanceCullingManager, FVirtualTextureUpdater* VirtualTextureUpdater)
|
|
{
|
|
check(IsInRenderingThread());
|
|
SCOPED_NAMED_EVENT(FinishDynamicMeshElements, FColor::Magenta);
|
|
|
|
FVirtualTextureSystem::Get().WaitForTasks(VirtualTextureUpdater);
|
|
Tasks.DynamicMeshElements.Wait();
|
|
DynamicMeshElements.ContextContainer.Submit(RHICmdList);
|
|
|
|
Tasks.MeshPassSetup = UE::Tasks::Launch(UE_SOURCE_LOCATION, [this, BasePassDepthStencilAccess, &InstanceCullingManager]
|
|
{
|
|
FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
|
|
SetupMeshPasses(BasePassDepthStencilAccess, InstanceCullingManager);
|
|
|
|
}, TaskConfig.TaskPriority);
|
|
|
|
FSceneRenderer::DynamicReadBufferForInitViews.Commit(RHICmdList);
|
|
}
|
|
|
|
void FVisibilityTaskData::Finish()
|
|
{
|
|
SCOPED_NAMED_EVENT(FinishVisibility, FColor::Magenta);
|
|
|
|
Tasks.ComputeRelevance.Wait();
|
|
Tasks.FinalizeRelevance.Wait();
|
|
Tasks.DynamicMeshElements.Wait();
|
|
Tasks.MeshPassSetup.Wait();
|
|
|
|
ViewPackets.Empty();
|
|
DynamicMeshElements.DynamicPrimitives.Empty();
|
|
Allocator.BulkDelete();
|
|
bFinished = true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Helper for InitViews to detect large camera movement, in both angle and position.
|
|
*/
|
|
static bool IsLargeCameraMovement(FSceneView& View, const FMatrix& PrevViewMatrix, const FVector& PrevViewOrigin, float CameraRotationThreshold, float CameraTranslationThreshold)
|
|
{
|
|
float RotationThreshold = FMath::Cos(FMath::DegreesToRadians(CameraRotationThreshold));
|
|
float ViewRightAngle = View.ViewMatrices.GetViewMatrix().GetColumn(0) | PrevViewMatrix.GetColumn(0);
|
|
float ViewUpAngle = View.ViewMatrices.GetViewMatrix().GetColumn(1) | PrevViewMatrix.GetColumn(1);
|
|
float ViewDirectionAngle = View.ViewMatrices.GetViewMatrix().GetColumn(2) | PrevViewMatrix.GetColumn(2);
|
|
|
|
FVector Distance = FVector(View.ViewMatrices.GetViewOrigin()) - PrevViewOrigin;
|
|
return
|
|
ViewRightAngle < RotationThreshold ||
|
|
ViewUpAngle < RotationThreshold ||
|
|
ViewDirectionAngle < RotationThreshold ||
|
|
Distance.SizeSquared() > CameraTranslationThreshold * CameraTranslationThreshold;
|
|
}
|
|
|
|
void FSceneRenderer::PreVisibilityFrameSetup(FRDGBuilder& GraphBuilder)
|
|
{
|
|
// Possible stencil dither optimization approach
|
|
for (FViewInfo& View : Views)
|
|
{
|
|
View.bAllowStencilDither = DepthPass.bDitheredLODTransitionsUseStencil;
|
|
}
|
|
|
|
// Initialize InstanceFactor. AllViews includes CustomRenderPass views, which might possibly also require InstanceFactor to be correctly assigned.
|
|
const int32 InstanceFactor = FMath::Max(1, GEngine->StereoRenderingDevice.IsValid() ? GEngine->StereoRenderingDevice->GetDesiredNumberOfViews(true) : 1);
|
|
if (InstanceFactor > 1)
|
|
{
|
|
for (FViewInfo* View : AllViews)
|
|
{
|
|
if (View->bIsInstancedStereoEnabled && IStereoRendering::IsStereoEyeView(*View))
|
|
{
|
|
View->InstanceFactor = InstanceFactor;
|
|
}
|
|
}
|
|
}
|
|
|
|
FRHICommandListImmediate& RHICmdList = GraphBuilder.RHICmdList;
|
|
|
|
if (GetRendererOutput() == ERendererOutput::FinalSceneColor)
|
|
{
|
|
FHairStrandsBookmarkParameters Parameters;
|
|
bool bHasHairStrandsBookmarks = false;
|
|
|
|
if (Views.Num() > 0 && !ViewFamily.EngineShowFlags.HitProxies)
|
|
{
|
|
CreateHairStrandsBookmarkParameters(Scene, Views, AllViews, Parameters, false /*bComputeVisibleInstances*/);
|
|
Parameters.TransientResources = AllocateHairTransientResources(GraphBuilder, Scene, Views);
|
|
if (Parameters.HasInstances())
|
|
{
|
|
if (Scene && IsHairStrandsEnabled(EHairStrandsShaderType::All, Scene->GetShaderPlatform()))
|
|
{
|
|
// Need GPUSkinCache results to be available in order to get correct skel. mesh data
|
|
Scene->GetGPUSkinCacheTask().Wait();
|
|
|
|
// 1.Update binding surfaces
|
|
// Prepare surface data (MeshLODData)
|
|
RunHairStrandsBookmark(GraphBuilder, EHairStrandsBookmark::ProcessBindingSurfaceUpdate, Parameters);
|
|
|
|
// 2. Prepare surface data for guides
|
|
if (Views[0].AllowGPUParticleUpdate())
|
|
{
|
|
RunHairStrandsBookmark(GraphBuilder, EHairStrandsBookmark::ProcessGuideInterpolation, Parameters);
|
|
bHasHairStrandsBookmarks = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Scene)
|
|
{
|
|
for (IComputeTaskWorker* ComputeTaskWorker : Scene->ComputeTaskWorkers)
|
|
{
|
|
if (ComputeTaskWorker->HasWork(ComputeTaskExecutionGroup::BeginInitViews))
|
|
{
|
|
FComputeContext Context
|
|
{
|
|
.GraphBuilder = GraphBuilder,
|
|
.ExecutionGroupName = ComputeTaskExecutionGroup::BeginInitViews,
|
|
.FeatureLevel = FeatureLevel,
|
|
.Scene = Scene,
|
|
};
|
|
|
|
ComputeTaskWorker->SubmitWork(Context);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Notify the FX system that the scene is about to perform visibility checks.
|
|
|
|
if (FXSystem && Views.IsValidIndex(0))
|
|
{
|
|
TArray<const FSceneViewFamily*, TInlineAllocator<2>> AllLinkedFamilies;
|
|
EnumerateLinkedViewFamilies([&] (const FSceneViewFamily& Family)
|
|
{
|
|
AllLinkedFamilies.Emplace(&Family);
|
|
return true;
|
|
});
|
|
FXSystem->PreInitViews(GraphBuilder, Views[0].AllowGPUParticleUpdate() && !ViewFamily.EngineShowFlags.HitProxies, AllLinkedFamilies, &ViewFamily);
|
|
}
|
|
|
|
if(bHasHairStrandsBookmarks)
|
|
{
|
|
RunHairStrandsBookmark(GraphBuilder, EHairStrandsBookmark::ProcessGuideDeformation, Parameters);
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
// Draw lines to lights affecting this mesh if its selected.
|
|
if (ViewFamily.EngineShowFlags.LightInfluences && Scene)
|
|
{
|
|
Scene->WaitForCreateLightPrimitiveInteractionsTask();
|
|
|
|
for (TConstSetBitIterator<> It(Scene->PrimitivesSelected); It; ++It)
|
|
{
|
|
const FPrimitiveSceneInfo* PrimitiveSceneInfo = Scene->Primitives[It.GetIndex()];
|
|
|
|
TArray<const FLightSceneProxy*> RelevantLights;
|
|
Scene->GetRelevantLights_RenderThread(PrimitiveSceneInfo->Proxy, RelevantLights);
|
|
|
|
for (const FLightSceneProxy* LightSceneProxy : RelevantLights)
|
|
{
|
|
bool bDynamic = true;
|
|
bool bRelevant = false;
|
|
bool bLightMapped = true;
|
|
bool bShadowMapped = false;
|
|
PrimitiveSceneInfo->Proxy->GetLightRelevance(LightSceneProxy, bDynamic, bRelevant, bLightMapped, bShadowMapped);
|
|
|
|
if (bRelevant)
|
|
{
|
|
// Draw blue for light-mapped lights and orange for dynamic lights
|
|
const FColor LineColor = bLightMapped ? FColor(0, 140, 255) : FColor(255, 140, 0);
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = Views[ViewIndex];
|
|
FViewElementPDI LightInfluencesPDI(&View, nullptr, &View.DynamicPrimitiveCollector);
|
|
LightInfluencesPDI.DrawLine(PrimitiveSceneInfo->Proxy->GetBounds().Origin, LightSceneProxy->GetLightToWorld().GetOrigin(), LineColor, SDPG_World);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if RHI_RAYTRACING
|
|
if (Scene)
|
|
{
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = Views[ViewIndex];
|
|
View.bRayTracingFeedbackEnabled = Scene->RayTracingScene.IsRayTracingFeedbackEnabled();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
for (const auto& ViewExtension : ViewFamily.ViewExtensions)
|
|
{
|
|
ViewExtension->PreInitViews_RenderThread(GraphBuilder);
|
|
}
|
|
}
|
|
|
|
void FSceneRenderer::PrepareViewStateForVisibility(const FSceneTexturesConfig& SceneTexturesConfig)
|
|
{
|
|
TRACE_CPUPROFILER_EVENT_SCOPE(PrepareViewStateForVisibility);
|
|
|
|
#if UE_BUILD_SHIPPING
|
|
const bool bFreezeTemporalHistories = false;
|
|
const bool bFreezeTemporalSequences = false;
|
|
#else
|
|
bool bFreezeTemporalHistories = CVarFreezeTemporalHistories.GetValueOnRenderThread() != 0;
|
|
|
|
static int32 CurrentFreezeTemporalHistoriesProgress = 0;
|
|
if (CurrentFreezeTemporalHistoriesProgress != CVarFreezeTemporalHistoriesProgress.GetValueOnRenderThread())
|
|
{
|
|
bFreezeTemporalHistories = false;
|
|
CurrentFreezeTemporalHistoriesProgress = CVarFreezeTemporalHistoriesProgress.GetValueOnRenderThread();
|
|
}
|
|
|
|
bool bFreezeTemporalSequences = bFreezeTemporalHistories || CVarFreezeTemporalSequences.GetValueOnRenderThread() != 0;
|
|
#endif
|
|
|
|
// Load this field once so it has a consistent value for all views (and to avoid the atomic load in the loop).
|
|
// While the value may not be perfectly in sync when we render other view families, this is ok as this
|
|
// invalidation mechanism is only used for interactive rendering where we expect to be constantly drawing the scene.
|
|
// Therefore it is acceptable for some view families to be a frame or so behind others.
|
|
uint32 CurrentPathTracingInvalidationCounter = Scene->PathTracingInvalidationCounter.Load();
|
|
|
|
// Setup motion blur parameters (also check for camera movement thresholds)
|
|
for(int32 ViewIndex = 0;ViewIndex < AllViews.Num();ViewIndex++)
|
|
{
|
|
FViewInfo& View = *AllViews[ViewIndex];
|
|
FSceneViewState* ViewState = View.ViewState;
|
|
|
|
#if DO_CHECK || USING_CODE_ANALYSIS
|
|
check(View.VerifyMembersChecks());
|
|
#endif
|
|
|
|
// Setup global dither fade in and fade out uniform buffers.
|
|
{
|
|
FDitherUniformShaderParameters DitherUniformShaderParameters;
|
|
DitherUniformShaderParameters.LODFactor = View.GetTemporalLODTransition();
|
|
View.DitherFadeOutUniformBuffer = FDitherUniformBufferRef::CreateUniformBufferImmediate(DitherUniformShaderParameters, UniformBuffer_SingleFrame);
|
|
|
|
DitherUniformShaderParameters.LODFactor = View.GetTemporalLODTransition() - 1.0f;
|
|
View.DitherFadeInUniformBuffer = FDitherUniformBufferRef::CreateUniformBufferImmediate(DitherUniformShaderParameters, UniformBuffer_SingleFrame);
|
|
}
|
|
|
|
// Once per render increment the occlusion frame counter.
|
|
if (ViewState)
|
|
{
|
|
ViewState->OcclusionFrameCounter++;
|
|
}
|
|
|
|
// HighResScreenshot should get best results so we don't do the occlusion optimization based on the former frame
|
|
extern bool GIsHighResScreenshot;
|
|
const bool bIsHitTesting = ViewFamily.EngineShowFlags.HitProxies;
|
|
// Don't test occlusion queries in collision viewmode as they can be bigger then the rendering bounds.
|
|
const bool bCollisionView = ViewFamily.EngineShowFlags.CollisionVisibility || ViewFamily.EngineShowFlags.CollisionPawn;
|
|
if (GIsHighResScreenshot || !DoOcclusionQueries() || bIsHitTesting || bCollisionView)
|
|
{
|
|
View.bDisableQuerySubmissions = true;
|
|
View.bIgnoreExistingQueries = true;
|
|
}
|
|
|
|
// set up the screen area for occlusion
|
|
{
|
|
float OcclusionPixelMultiplier = 1.0f;
|
|
if (UseDownsampledOcclusionQueries())
|
|
{
|
|
OcclusionPixelMultiplier = 1.0f / static_cast<float>(FMath::Square(SceneTexturesConfig.SmallDepthDownsampleFactor));
|
|
}
|
|
float NumPossiblePixels = static_cast<float>(View.ViewRect.Width() * View.ViewRect.Height()) * OcclusionPixelMultiplier;
|
|
View.OneOverNumPossiblePixels = NumPossiblePixels > 0.0 ? 1.0f / NumPossiblePixels : 0.0f;
|
|
}
|
|
|
|
// Still need no jitter to be set for temporal feedback on SSR (it is enabled even when temporal AA is off).
|
|
check(View.TemporalJitterPixels.X == 0.0f);
|
|
check(View.TemporalJitterPixels.Y == 0.0f);
|
|
|
|
// Cache the projection matrix b
|
|
// Cache the projection matrix before AA is applied
|
|
View.ViewMatrices.SaveProjectionNoAAMatrix();
|
|
|
|
if (ViewState)
|
|
{
|
|
check(View.bStatePrevViewInfoIsReadOnly);
|
|
View.bStatePrevViewInfoIsReadOnly = ViewFamily.bWorldIsPaused || ViewFamily.EngineShowFlags.HitProxies || bFreezeTemporalHistories;
|
|
|
|
ViewState->SetupDistanceFieldTemporalOffset(ViewFamily);
|
|
|
|
if (!View.bStatePrevViewInfoIsReadOnly && !bFreezeTemporalSequences)
|
|
{
|
|
ViewState->FrameIndex++;
|
|
}
|
|
|
|
if (View.OverrideFrameIndexValue.IsSet())
|
|
{
|
|
ViewState->FrameIndex = View.OverrideFrameIndexValue.GetValue();
|
|
}
|
|
|
|
if (View.OverrideOutputFrameIndexValue.IsSet())
|
|
{
|
|
ViewState->OutputFrameIndex = View.OverrideOutputFrameIndexValue.GetValue();
|
|
}
|
|
else
|
|
{
|
|
// If the output frame index isn't being overwritten then we keep it in sync with
|
|
// FrameIndex so that downstream systems are unchanged.
|
|
ViewState->OutputFrameIndex = ViewState->FrameIndex;
|
|
}
|
|
}
|
|
|
|
// Subpixel jitter for temporal AA
|
|
int32 CVarTemporalAASamplesValue = CVarTemporalAASamples.GetValueOnRenderThread();
|
|
const bool bShouldScaleTemporalAASampleCount = (CVarTemporalAAScaleSamples.GetValueOnRenderThread() != 0);
|
|
|
|
// Custom render passes support sharing temporal state with the main view
|
|
FViewInfo& TemporalSourceView = View.TemporalSourceView ? *View.TemporalSourceView : View;
|
|
FSceneViewState* TemporalViewState = TemporalSourceView.ViewState;
|
|
|
|
EMainTAAPassConfig TAAConfig = GetMainTAAPassConfig(TemporalSourceView);
|
|
|
|
bool bTemporalUpsampling = TemporalSourceView.PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::TemporalUpscale;
|
|
|
|
// Apply a sub pixel offset to the view.
|
|
if (IsTemporalAccumulationBasedMethod(TemporalSourceView.AntiAliasingMethod) && TemporalViewState && (CVarTemporalAASamplesValue > 0 || bTemporalUpsampling) && TemporalSourceView.bAllowTemporalJitter)
|
|
{
|
|
float EffectivePrimaryResolutionFraction = float(View.ViewRect.Width()) / float(TemporalSourceView.GetSecondaryViewRectSize().X);
|
|
|
|
// Compute number of TAA samples.
|
|
int32 TemporalAASamples;
|
|
{
|
|
if (TAAConfig == EMainTAAPassConfig::TSR)
|
|
{
|
|
// Force the number of AA sample to make sure the quality doesn't get
|
|
// compromised by previously set settings for Gen4 TAA
|
|
TemporalAASamples = 8;
|
|
}
|
|
else
|
|
{
|
|
TemporalAASamples = FMath::Clamp(CVarTemporalAASamplesValue, 1, 255);
|
|
}
|
|
|
|
if (bTemporalUpsampling && bShouldScaleTemporalAASampleCount)
|
|
{
|
|
// When doing TAA upsample with screen percentage < 100%, we need extra temporal samples to have a
|
|
// constant temporal sample density for final output pixels to avoid output pixel aligned converging issues.
|
|
TemporalAASamples = FMath::RoundToInt(float(TemporalAASamples) * FMath::Max(1.f, 1.f / (EffectivePrimaryResolutionFraction * EffectivePrimaryResolutionFraction)));
|
|
}
|
|
else if (CVarTemporalAASamplesValue == 5)
|
|
{
|
|
TemporalAASamples = 4;
|
|
}
|
|
|
|
// Use immediately higher prime number to break up coherence between the TAA jitter sequence and any
|
|
// other random signal that are power of two of View.StateFrameIndex
|
|
if (TAAConfig == EMainTAAPassConfig::TSR)
|
|
{
|
|
static const uint8 kFirstPrimeNumbers[] = {
|
|
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
|
|
101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
|
|
211, 223, 227, 229, 233, 239, 241, 251,
|
|
};
|
|
|
|
for (int32 PrimeNumberId = FMath::Max(4, (TemporalAASamples - 1) / 5); PrimeNumberId < UE_ARRAY_COUNT(kFirstPrimeNumbers); PrimeNumberId++)
|
|
{
|
|
if (int32(kFirstPrimeNumbers[PrimeNumberId]) >= TemporalAASamples)
|
|
{
|
|
TemporalAASamples = int32(kFirstPrimeNumbers[PrimeNumberId]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compute the new sample index in the temporal sequence.
|
|
int32 TemporalSampleIndex;
|
|
if (View.TemporalSourceView)
|
|
{
|
|
// Where a TemporalSourceView is specified, the temporal sample index is pulled directly from the source view's state, and not incremented,
|
|
// assuming the source view already will have updated that.
|
|
TemporalSampleIndex = TemporalViewState->TemporalAASampleIndex;
|
|
}
|
|
else
|
|
{
|
|
TemporalSampleIndex = TemporalViewState->TemporalAASampleIndex + 1;
|
|
if (TemporalSampleIndex >= TemporalAASamples || View.bCameraCut)
|
|
{
|
|
TemporalSampleIndex = 0;
|
|
}
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
if (CVarTAADebugOverrideTemporalIndex.GetValueOnRenderThread() >= 0)
|
|
{
|
|
TemporalSampleIndex = CVarTAADebugOverrideTemporalIndex.GetValueOnRenderThread();
|
|
}
|
|
#endif
|
|
|
|
// Updates view state.
|
|
if (!View.bStatePrevViewInfoIsReadOnly && !bFreezeTemporalSequences)
|
|
{
|
|
TemporalViewState->TemporalAASampleIndex = TemporalSampleIndex;
|
|
}
|
|
}
|
|
|
|
// Choose sub pixel sample coordinate in the temporal sequence.
|
|
float SampleX = 0.0f, SampleY = 0.0f;
|
|
if (TemporalSourceView.PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::TemporalUpscale)
|
|
{
|
|
// Uniformly distribute temporal jittering in [-.5; .5], because there is no longer any alignement of input and output pixels.
|
|
SampleX = Halton(TemporalSampleIndex + 1, 2) - 0.5f;
|
|
SampleY = Halton(TemporalSampleIndex + 1, 3) - 0.5f;
|
|
|
|
// Adjust Automatic View Mip Bias
|
|
float MipBias = -(FMath::Max(-FMath::Log2(EffectivePrimaryResolutionFraction), 0.0f)) + CVarAutomaticViewMipBiasOffset.GetValueOnRenderThread();
|
|
MipBias = FMath::Clamp(FMath::Max(MipBias, CVarAutomaticViewMipBiasMin.GetValueOnRenderThread()), -4.0f, 4.0f);
|
|
|
|
// Quantize to discrete values between -4.0f and 4.0f (range of 8.0f), since each value creates a unique sampler state
|
|
const int32 MipBiasQuantization = CVarAutomaticViewMipBiasQuantization.GetValueOnRenderThread();
|
|
|
|
if (MipBiasQuantization > 0)
|
|
{
|
|
// Divide the 8.0f range by the number of desired steps to get the step size
|
|
const float QuantizationStepSize = 8.0f / ((float)MipBiasQuantization);
|
|
MipBias = FMath::CeilToFloat(MipBias / QuantizationStepSize) * QuantizationStepSize;
|
|
}
|
|
|
|
View.MaterialTextureMipBias = MipBias;
|
|
}
|
|
else if( CVarTemporalAASamplesValue == 2 )
|
|
{
|
|
// 2xMSAA
|
|
// Pattern docs: http://msdn.microsoft.com/en-us/library/windows/desktop/ff476218(v=vs.85).aspx
|
|
// N.
|
|
// .S
|
|
float SamplesX[] = { -4.0f/16.0f, 4.0/16.0f };
|
|
float SamplesY[] = { -4.0f/16.0f, 4.0/16.0f };
|
|
check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
|
|
SampleX = SamplesX[ TemporalSampleIndex ];
|
|
SampleY = SamplesY[ TemporalSampleIndex ];
|
|
}
|
|
else if( CVarTemporalAASamplesValue == 3 )
|
|
{
|
|
// 3xMSAA
|
|
// A..
|
|
// ..B
|
|
// .C.
|
|
// Rolling circle pattern (A,B,C).
|
|
float SamplesX[] = { -2.0f/3.0f, 2.0/3.0f, 0.0/3.0f };
|
|
float SamplesY[] = { -2.0f/3.0f, 0.0/3.0f, 2.0/3.0f };
|
|
check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
|
|
SampleX = SamplesX[ TemporalSampleIndex ];
|
|
SampleY = SamplesY[ TemporalSampleIndex ];
|
|
}
|
|
else if( CVarTemporalAASamplesValue == 4 )
|
|
{
|
|
// 4xMSAA
|
|
// Pattern docs: http://msdn.microsoft.com/en-us/library/windows/desktop/ff476218(v=vs.85).aspx
|
|
// .N..
|
|
// ...E
|
|
// W...
|
|
// ..S.
|
|
// Rolling circle pattern (N,E,S,W).
|
|
float SamplesX[] = { -2.0f/16.0f, 6.0/16.0f, 2.0/16.0f, -6.0/16.0f };
|
|
float SamplesY[] = { -6.0f/16.0f, -2.0/16.0f, 6.0/16.0f, 2.0/16.0f };
|
|
check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
|
|
SampleX = SamplesX[ TemporalSampleIndex ];
|
|
SampleY = SamplesY[ TemporalSampleIndex ];
|
|
}
|
|
else if( CVarTemporalAASamplesValue == 5 )
|
|
{
|
|
// Compressed 4 sample pattern on same vertical and horizontal line (less temporal flicker).
|
|
// Compressed 1/2 works better than correct 2/3 (reduced temporal flicker).
|
|
// . N .
|
|
// W . E
|
|
// . S .
|
|
// Rolling circle pattern (N,E,S,W).
|
|
float SamplesX[] = { 0.0f/2.0f, 1.0/2.0f, 0.0/2.0f, -1.0/2.0f };
|
|
float SamplesY[] = { -1.0f/2.0f, 0.0/2.0f, 1.0/2.0f, 0.0/2.0f };
|
|
check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
|
|
SampleX = SamplesX[ TemporalSampleIndex ];
|
|
SampleY = SamplesY[ TemporalSampleIndex ];
|
|
}
|
|
else if(View.IsPerspectiveProjection())
|
|
{
|
|
float u1 = Halton( TemporalSampleIndex + 1, 2 );
|
|
float u2 = Halton( TemporalSampleIndex + 1, 3 );
|
|
|
|
// Generates samples in normal distribution
|
|
// exp( x^2 / Sigma^2 )
|
|
|
|
static auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAAFilterSize"));
|
|
float FilterSize = CVar->GetFloat();
|
|
|
|
// Scale distribution to set non-unit variance
|
|
// Variance = Sigma^2
|
|
float Sigma = 0.47f * FilterSize;
|
|
|
|
// Window to [-0.5, 0.5] output
|
|
// Without windowing we could generate samples far away on the infinite tails.
|
|
float OutWindow = 0.5f;
|
|
float InWindow = FMath::Exp( -0.5 * FMath::Square( OutWindow / Sigma ) );
|
|
|
|
// Box-Muller transform
|
|
float Theta = 2.0f * PI * u2;
|
|
float r = Sigma * FMath::Sqrt( -2.0f * FMath::Loge( (1.0f - u1) * InWindow + u1 ) );
|
|
|
|
SampleX = r * FMath::Cos( Theta );
|
|
SampleY = r * FMath::Sin( Theta );
|
|
}
|
|
|
|
if (CVarInvertTemporalJitterX.GetValueOnRenderThread() != 0)
|
|
{
|
|
SampleX = -SampleX;
|
|
}
|
|
|
|
if (CVarInvertTemporalJitterY.GetValueOnRenderThread() != 0)
|
|
{
|
|
SampleY = -SampleY;
|
|
}
|
|
|
|
View.TemporalJitterSequenceLength = TemporalAASamples;
|
|
View.TemporalJitterIndex = TemporalSampleIndex;
|
|
View.TemporalJitterPixels.X = SampleX;
|
|
View.TemporalJitterPixels.Y = SampleY;
|
|
|
|
View.ViewMatrices.HackAddTemporalAAProjectionJitter(FVector2D(SampleX * 2.0f / View.ViewRect.Width(), SampleY * -2.0f / View.ViewRect.Height()));
|
|
}
|
|
|
|
// Setup a new FPreviousViewInfo from current frame infos.
|
|
FPreviousViewInfo NewPrevViewInfo;
|
|
{
|
|
NewPrevViewInfo.ViewRect = View.ViewRect;
|
|
NewPrevViewInfo.ViewMatrices = View.ViewMatrices;
|
|
}
|
|
|
|
if ( ViewState )
|
|
{
|
|
// update previous frame matrices in case world origin was rebased on this frame
|
|
if (!View.OriginOffsetThisFrame.IsZero())
|
|
{
|
|
ViewState->PrevFrameViewInfo.ViewMatrices.ApplyWorldOffset(View.OriginOffsetThisFrame);
|
|
}
|
|
|
|
// determine if we are initializing or we should reset the persistent state
|
|
const float DeltaTime = View.Family->Time.GetRealTimeSeconds() - ViewState->LastRenderTime;
|
|
const bool bFirstFrameOrTimeWasReset = DeltaTime < -0.0001f || ViewState->LastRenderTime < 0.0001f;
|
|
const bool bIsLargeCameraMovement = IsLargeCameraMovement(
|
|
View,
|
|
ViewState->PrevFrameViewInfo.ViewMatrices.GetViewMatrix(),
|
|
ViewState->PrevFrameViewInfo.ViewMatrices.GetViewOrigin(),
|
|
75.0f, GCameraCutTranslationThreshold);
|
|
const bool bResetCamera = (bFirstFrameOrTimeWasReset || View.bCameraCut || bIsLargeCameraMovement || View.bForceCameraVisibilityReset);
|
|
|
|
#if RHI_RAYTRACING
|
|
static const auto CVarTemporalDenoiser = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PathTracing.TemporalDenoiser.mode"));
|
|
const int TemporalDenoiserMode = CVarTemporalDenoiser ? CVarTemporalDenoiser->GetValueOnAnyThread() : 0;
|
|
|
|
if (View.bIsOfflineRender)
|
|
{
|
|
// In the offline context, we want precise control over when to restart the path tracer's accumulation to allow for motion blur
|
|
// So we use the camera cut signal only. In particular - we should not use bForceCameraVisibilityReset since this has
|
|
// interactions with the motion blur post process effect in tiled rendering (see comment below).
|
|
if (View.bCameraCut || View.bForcePathTracerReset)
|
|
{
|
|
const bool bClearTemporalDenoisingHistory = (TemporalDenoiserMode == 1) ? View.bCameraCut : true;
|
|
ViewState->PathTracingInvalidate(bClearTemporalDenoisingHistory);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// for interactive usage - any movement or scene change should restart the path tracer
|
|
|
|
// Note: 0.18 deg is the minimum angle for avoiding numerical precision issue (which would cause constant invalidation)
|
|
const bool bIsCameraMove = IsLargeCameraMovement(
|
|
View,
|
|
ViewState->PrevFrameViewInfo.ViewMatrices.GetViewMatrix(),
|
|
ViewState->PrevFrameViewInfo.ViewMatrices.GetViewOrigin(),
|
|
0.18f /*degree*/, 0.1f /*cm*/);
|
|
const bool bIsProjMatrixDifferent = View.ViewMatrices.GetProjectionNoAAMatrix() != View.ViewState->PrevFrameViewInfo.ViewMatrices.GetProjectionNoAAMatrix();
|
|
|
|
// For each view, we remember what the invalidation counter was set to last time we were here so we can catch all changes
|
|
const bool bNeedsInvalidation = ViewState->PathTracingInvalidationCounter != CurrentPathTracingInvalidationCounter;
|
|
ViewState->PathTracingInvalidationCounter = CurrentPathTracingInvalidationCounter;
|
|
if (bNeedsInvalidation ||
|
|
bIsProjMatrixDifferent ||
|
|
bIsCameraMove ||
|
|
View.bCameraCut ||
|
|
View.bForceCameraVisibilityReset ||
|
|
View.bForcePathTracerReset)
|
|
{
|
|
const bool bClearTemporalDenoisingHistory = (TemporalDenoiserMode == 2) ? View.bCameraCut : true;
|
|
ViewState->PathTracingInvalidate(bClearTemporalDenoisingHistory);
|
|
}
|
|
}
|
|
|
|
#endif // RHI_RAYTRACING
|
|
|
|
if (bResetCamera)
|
|
{
|
|
View.PrevViewInfo = NewPrevViewInfo;
|
|
|
|
// PT: If the motion blur shader is the last shader in the post-processing chain then it is the one that is
|
|
// adjusting for the viewport offset. So it is always required and we can't just disable the work the
|
|
// shader does. The correct fix would be to disable the effect when we don't need it and to properly mark
|
|
// the uber-postprocessing effect as the last effect in the chain.
|
|
|
|
View.bPrevTransformsReset = true;
|
|
}
|
|
else
|
|
{
|
|
View.PrevViewInfo = ViewState->PrevFrameViewInfo;
|
|
}
|
|
|
|
// Replace previous view info of the view state with this frame, clearing out references over render target.
|
|
if (!View.bStatePrevViewInfoIsReadOnly)
|
|
{
|
|
ViewState->PrevFrameViewInfo = NewPrevViewInfo;
|
|
}
|
|
|
|
// If the view has a previous view transform, then overwrite the previous view info for the _current_ frame.
|
|
if (View.PreviousViewTransform.IsSet())
|
|
{
|
|
// Note that we must ensure this transform ends up in ViewState->PrevFrameViewInfo else it will be used to calculate the next frame's motion vectors as well
|
|
View.PrevViewInfo.ViewMatrices.UpdateViewMatrix(View.PreviousViewTransform->GetTranslation(), View.PreviousViewTransform->GetRotation().Rotator());
|
|
}
|
|
|
|
// detect conditions where we should reset occlusion queries
|
|
if (bFirstFrameOrTimeWasReset ||
|
|
ViewState->LastRenderTime + GEngine->PrimitiveProbablyVisibleTime < View.Family->Time.GetRealTimeSeconds() ||
|
|
View.bCameraCut ||
|
|
View.bForceCameraVisibilityReset ||
|
|
IsLargeCameraMovement(
|
|
View,
|
|
FMatrix(ViewState->PrevViewMatrixForOcclusionQuery),
|
|
ViewState->PrevViewOriginForOcclusionQuery,
|
|
GEngine->CameraRotationThreshold, GEngine->CameraTranslationThreshold))
|
|
{
|
|
View.bIgnoreExistingQueries = true;
|
|
View.bDisableDistanceBasedFadeTransitions = true;
|
|
}
|
|
|
|
// Turn on/off round-robin occlusion querying in the ViewState
|
|
static const auto CVarRROCC = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("vr.RoundRobinOcclusion"));
|
|
const bool bEnableRoundRobin = CVarRROCC ? (CVarRROCC->GetValueOnAnyThread() != false) : false;
|
|
if (bEnableRoundRobin != ViewState->IsRoundRobinEnabled())
|
|
{
|
|
ViewState->UpdateRoundRobin(bEnableRoundRobin);
|
|
View.bIgnoreExistingQueries = true;
|
|
}
|
|
|
|
ViewState->PrevViewMatrixForOcclusionQuery = FMatrix44f(View.ViewMatrices.GetViewMatrix()); // LWC_TODO: Precision loss
|
|
ViewState->PrevViewOriginForOcclusionQuery = View.ViewMatrices.GetViewOrigin();
|
|
|
|
// we don't use DeltaTime as it can be 0 (in editor) and is computed by subtracting floats (loses precision over time)
|
|
// Clamp DeltaWorldTime to reasonable values for the purposes of motion blur, things like TimeDilation can make it very small
|
|
// Offline renders always control the timestep for the view and always need the timescales calculated.
|
|
if (!ViewFamily.bWorldIsPaused || View.bIsOfflineRender)
|
|
{
|
|
ViewState->UpdateMotionBlurTimeScale(View);
|
|
}
|
|
|
|
|
|
ViewState->PrevFrameNumber = ViewState->PendingPrevFrameNumber;
|
|
ViewState->PendingPrevFrameNumber = View.Family->FrameNumber;
|
|
|
|
// This finishes the update of view state
|
|
ViewState->UpdateLastRenderTime(*View.Family);
|
|
|
|
ViewState->UpdateTemporalLODTransition(View);
|
|
}
|
|
else
|
|
{
|
|
// Without a viewstate, we just assume that camera has not moved.
|
|
View.PrevViewInfo = NewPrevViewInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
void FSceneViewState::UpdateMotionBlurTimeScale(const FViewInfo& View)
|
|
{
|
|
const int32 MotionBlurTargetFPS = View.FinalPostProcessSettings.MotionBlurTargetFPS;
|
|
|
|
// Ensure we can divide by the Delta Time later without a divide by zero.
|
|
float DeltaRealTime = FMath::Max(View.Family->Time.GetDeltaRealTimeSeconds(), SMALL_NUMBER);
|
|
|
|
// Track the current FPS by using an exponential moving average of the current delta time.
|
|
if (MotionBlurTargetFPS <= 0)
|
|
{
|
|
// Keep motion vector lengths stable for paused sequencer frames.
|
|
if (GetSequencerState() == ESS_Paused)
|
|
{
|
|
// Reset the moving average to the current delta time.
|
|
MotionBlurTargetDeltaTime = DeltaRealTime;
|
|
}
|
|
else
|
|
{
|
|
// Smooth the target delta time using a moving average.
|
|
MotionBlurTargetDeltaTime = FMath::Lerp(MotionBlurTargetDeltaTime, DeltaRealTime, 0.1f);
|
|
}
|
|
}
|
|
else // Track a fixed target FPS.
|
|
{
|
|
// Keep motion vector lengths stable for paused sequencer frames. Assumes a 60 FPS tick.
|
|
// Tuned for content compatibility with existing content when target is the default 30 FPS.
|
|
if (GetSequencerState() == ESS_Paused)
|
|
{
|
|
DeltaRealTime = 1.0f / 60.0f;
|
|
}
|
|
|
|
|
|
MotionBlurTargetDeltaTime = 1.0f / static_cast<float>(MotionBlurTargetFPS);
|
|
}
|
|
|
|
MotionBlurTimeScale = MotionBlurTargetDeltaTime / DeltaRealTime;
|
|
}
|
|
|
|
void FDeferredShadingSceneRenderer::ComputeLightVisibility()
|
|
{
|
|
FSceneRenderer::ComputeLightVisibility();
|
|
|
|
CreateIndirectCapsuleShadows();
|
|
|
|
SetupVolumetricFog();
|
|
}
|
|
|
|
void FSceneRenderer::ComputeLightVisibility()
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_PostVisibilityFrameSetup_Light_Visibility);
|
|
|
|
VisibleLightInfos.AddDefaulted(Scene->Lights.GetMaxIndex());
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = Views[ViewIndex];
|
|
View.VisibleLightInfos.Empty(Scene->Lights.GetMaxIndex());
|
|
|
|
for (int32 LightIndex = 0; LightIndex < Scene->Lights.GetMaxIndex(); LightIndex++)
|
|
{
|
|
new (View.VisibleLightInfos) FVisibleLightViewInfo();
|
|
}
|
|
}
|
|
|
|
const bool bSetupMobileLightShafts = FeatureLevel <= ERHIFeatureLevel::ES3_1 && ShouldRenderLightShafts(ViewFamily);
|
|
|
|
// determine visibility of each light
|
|
for(auto LightIt = Scene->Lights.CreateConstIterator();LightIt;++LightIt)
|
|
{
|
|
const FLightSceneInfoCompact& LightSceneInfoCompact = *LightIt;
|
|
const FLightSceneInfo* LightSceneInfo = LightSceneInfoCompact.LightSceneInfo;
|
|
|
|
// view frustum cull lights in each view
|
|
for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++)
|
|
{
|
|
const FLightSceneProxy* Proxy = LightSceneInfo->Proxy;
|
|
FViewInfo& View = Views[ViewIndex];
|
|
FVisibleLightViewInfo& VisibleLightViewInfo = View.VisibleLightInfos[LightIt.GetIndex()];
|
|
// dir lights are always visible, and point/spot only if in the frustum
|
|
if( Proxy->GetLightType() == LightType_Point ||
|
|
Proxy->GetLightType() == LightType_Spot ||
|
|
Proxy->GetLightType() == LightType_Rect )
|
|
{
|
|
const FSphere& BoundingSphere = Proxy->GetBoundingSphere();
|
|
const bool bInViewFrustum = View.GetCullingFrustum().IntersectSphere(BoundingSphere.Center, BoundingSphere.W);
|
|
|
|
if (View.IsPerspectiveProjection())
|
|
{
|
|
const float DistanceSquared = (BoundingSphere.Center - View.CullingOrigin).SizeSquared();
|
|
const float ProxyMaxDistance = Proxy->GetMaxDrawDistance();
|
|
const float ScaledMaxDistance = ProxyMaxDistance * GLightMaxDrawDistanceScale;
|
|
const bool bDrawLight = (FMath::Square(FMath::Min(0.0002f, GMinScreenRadiusForLights / BoundingSphere.W) * View.LODDistanceFactor) * DistanceSquared < 1.0f)
|
|
&& (ProxyMaxDistance <= 0.0 || DistanceSquared < FMath::Square(ScaledMaxDistance));
|
|
|
|
VisibleLightViewInfo.bInViewFrustum = bDrawLight && bInViewFrustum;
|
|
VisibleLightViewInfo.bInDrawRange = bDrawLight;
|
|
}
|
|
else
|
|
{
|
|
VisibleLightViewInfo.bInViewFrustum = bInViewFrustum;
|
|
VisibleLightViewInfo.bInDrawRange = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VisibleLightViewInfo.bInViewFrustum = true;
|
|
VisibleLightViewInfo.bInDrawRange = true;
|
|
// Setup single sun-shaft from direction lights for mobile.
|
|
if (bSetupMobileLightShafts && LightSceneInfo->bEnableLightShaftBloom && ShouldRenderLightShaftsForLight(View, *LightSceneInfo->Proxy))
|
|
{
|
|
View.MobileLightShaft = GetMobileLightShaftInfo(View, *LightSceneInfo);
|
|
}
|
|
}
|
|
|
|
// Draw shapes for reflection captures
|
|
if( View.bIsReflectionCapture
|
|
&& VisibleLightViewInfo.bInViewFrustum
|
|
&& Proxy->HasStaticLighting()
|
|
&& Proxy->GetLightType() != LightType_Directional )
|
|
{
|
|
FVector Origin = Proxy->GetOrigin();
|
|
FVector ToLight = Origin - View.ViewMatrices.GetViewOrigin();
|
|
float DistanceSqr = ToLight | ToLight;
|
|
float Radius = Proxy->GetRadius();
|
|
|
|
if( DistanceSqr < Radius * Radius )
|
|
{
|
|
View.VisibleReflectionCaptureLights.Emplace(Proxy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
InitFogConstants();
|
|
}
|
|
|
|
void FSceneRenderer::GatherReflectionCaptureLightMeshElements()
|
|
{
|
|
// view frustum cull lights in each view
|
|
for (FViewInfo& View : Views)
|
|
{
|
|
for (const FLightSceneProxy* Proxy : View.VisibleReflectionCaptureLights)
|
|
{
|
|
FVector Origin = Proxy->GetOrigin();
|
|
FVector ToLight = Origin - View.ViewMatrices.GetViewOrigin();
|
|
float DistanceSqr = ToLight | ToLight;
|
|
float Radius = Proxy->GetRadius();
|
|
|
|
FLightRenderParameters LightParameters;
|
|
Proxy->GetLightShaderParameters(LightParameters);
|
|
|
|
// Force to be at least 0.75 pixels
|
|
float CubemapSize = (float)IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.ReflectionCaptureResolution"))->GetValueOnAnyThread();
|
|
float Distance = FMath::Sqrt(DistanceSqr);
|
|
float MinRadius = Distance * 0.75f / CubemapSize;
|
|
LightParameters.SourceRadius = FMath::Max(MinRadius, LightParameters.SourceRadius);
|
|
|
|
// Snap to cubemap pixel center to reduce aliasing
|
|
FVector Scale = ToLight.GetAbs();
|
|
int32 MaxComponent = Scale.X > Scale.Y ? (Scale.X > Scale.Z ? 0 : 2) : (Scale.Y > Scale.Z ? 1 : 2);
|
|
for (int32 k = 1; k < 3; k++)
|
|
{
|
|
float Projected = ToLight[(MaxComponent + k) % 3] / Scale[MaxComponent];
|
|
float Quantized = (FMath::RoundToFloat(Projected * (0.5f * CubemapSize) - 0.5f) + 0.5f) / (0.5f * CubemapSize);
|
|
ToLight[(MaxComponent + k) % 3] = Quantized * Scale[MaxComponent];
|
|
}
|
|
Origin = ToLight + View.ViewMatrices.GetViewOrigin();
|
|
|
|
FLinearColor Color(LightParameters.Color.R, LightParameters.Color.G, LightParameters.Color.B, LightParameters.FalloffExponent);
|
|
const bool bIsRectLight = Proxy->IsRectLight();
|
|
if (!bIsRectLight)
|
|
{
|
|
const float SphereArea = (4.0f * PI) * FMath::Square(LightParameters.SourceRadius);
|
|
const float CylinderArea = (2.0f * PI) * LightParameters.SourceRadius * LightParameters.SourceLength;
|
|
const float SurfaceArea = SphereArea + CylinderArea;
|
|
Color *= 4.0f / SurfaceArea;
|
|
}
|
|
|
|
if (Proxy->IsInverseSquared())
|
|
{
|
|
float LightRadiusMask = FMath::Square(1.0f - FMath::Square(DistanceSqr * FMath::Square(LightParameters.InvRadius)));
|
|
Color.A = LightRadiusMask;
|
|
}
|
|
else
|
|
{
|
|
// Remove inverse square falloff
|
|
Color *= DistanceSqr + 1.0f;
|
|
|
|
// Apply falloff
|
|
Color.A = FMath::Pow(1.0f - DistanceSqr * FMath::Square(LightParameters.InvRadius), LightParameters.FalloffExponent);
|
|
}
|
|
|
|
// Spot falloff
|
|
FVector L = ToLight.GetSafeNormal();
|
|
Color.A *= FMath::Square(FMath::Clamp(((L | (FVector)LightParameters.Direction) - LightParameters.SpotAngles.X) * LightParameters.SpotAngles.Y, 0.0f, 1.0f));
|
|
|
|
Color.A *= LightParameters.SpecularScale;
|
|
|
|
// Rect is one sided
|
|
if (bIsRectLight && (L | (FVector)LightParameters.Direction) < 0.0f)
|
|
continue;
|
|
|
|
UTexture* SurfaceTexture = nullptr;
|
|
if (bIsRectLight)
|
|
{
|
|
const FRectLightSceneProxy* RectLightProxy = (const FRectLightSceneProxy*)Proxy;
|
|
SurfaceTexture = RectLightProxy->SourceTexture;
|
|
}
|
|
|
|
FMaterialRenderProxy* ColoredMeshInstance = nullptr;
|
|
if (SurfaceTexture)
|
|
{
|
|
ColoredMeshInstance = Allocator.Create<FColoredTexturedMaterialRenderProxy>(GEngine->EmissiveMeshMaterial->GetRenderProxy(), Color, NAME_Color, SurfaceTexture, NAME_LinearColor);
|
|
}
|
|
else
|
|
{
|
|
ColoredMeshInstance = Allocator.Create<FColoredMaterialRenderProxy>(GEngine->EmissiveMeshMaterial->GetRenderProxy(), Color, NAME_Color);
|
|
}
|
|
|
|
FMatrix LightToWorld = Proxy->GetLightToWorld();
|
|
LightToWorld.RemoveScaling();
|
|
|
|
FViewElementPDI LightPDI(&View, NULL, &View.DynamicPrimitiveCollector);
|
|
|
|
if (bIsRectLight)
|
|
{
|
|
DrawBox(&LightPDI, LightToWorld, FVector(0.0f, LightParameters.SourceRadius, LightParameters.SourceLength), ColoredMeshInstance, SDPG_World);
|
|
}
|
|
else if (LightParameters.SourceLength > 0.0f)
|
|
{
|
|
DrawSphere(&LightPDI, Origin + 0.5f * LightParameters.SourceLength * LightToWorld.GetUnitAxis(EAxis::Z), FRotator::ZeroRotator, LightParameters.SourceRadius * FVector::OneVector, 36, 24, ColoredMeshInstance, SDPG_World);
|
|
DrawSphere(&LightPDI, Origin - 0.5f * LightParameters.SourceLength * LightToWorld.GetUnitAxis(EAxis::Z), FRotator::ZeroRotator, LightParameters.SourceRadius * FVector::OneVector, 36, 24, ColoredMeshInstance, SDPG_World);
|
|
DrawCylinder(&LightPDI, Origin, LightToWorld.GetUnitAxis(EAxis::X), LightToWorld.GetUnitAxis(EAxis::Y), LightToWorld.GetUnitAxis(EAxis::Z), LightParameters.SourceRadius, 0.5f * LightParameters.SourceLength, 36, ColoredMeshInstance, SDPG_World);
|
|
}
|
|
else
|
|
{
|
|
DrawSphere(&LightPDI, Origin, FRotator::ZeroRotator, LightParameters.SourceRadius * FVector::OneVector, 36, 24, ColoredMeshInstance, SDPG_World);
|
|
}
|
|
}
|
|
|
|
View.VisibleReflectionCaptureLights.Empty();
|
|
}
|
|
}
|
|
|
|
void FSceneRenderer::PostVisibilityFrameSetup(FILCUpdatePrimTaskData*& OutILCTaskData)
|
|
{
|
|
if (GetRendererOutput() != ERendererOutput::FinalSceneColor)
|
|
{
|
|
return;
|
|
}
|
|
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_PostVisibilityFrameSetup);
|
|
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_PostVisibilityFrameSetup_Sort);
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
|
|
{
|
|
FViewInfo& View = Views[ViewIndex];
|
|
|
|
if (View.State)
|
|
{
|
|
((FSceneViewState*)View.State)->TrimHistoryRenderTargets(Scene);
|
|
}
|
|
}
|
|
}
|
|
|
|
GatherReflectionCaptureLightMeshElements();
|
|
|
|
if (ViewFamily.EngineShowFlags.HitProxies == 0 && Scene->PrecomputedLightVolumes.Num() > 0
|
|
&& GILCUpdatePrimTaskEnabled && FPlatformProcess::SupportsMultithreading())
|
|
{
|
|
OutILCTaskData = Allocator.Create<FILCUpdatePrimTaskData>();
|
|
Scene->IndirectLightingCache.StartUpdateCachePrimitivesTask(Scene, *this, true, *OutILCTaskData);
|
|
check(OutILCTaskData->TaskRef.IsValid());
|
|
}
|
|
}
|
|
|
|
uint32 GetShadowQuality();
|
|
void UpdateHairResources(FRDGBuilder& GraphBuilder, const FViewInfo& View);
|
|
|
|
/**
|
|
* Performs once per frame setup prior to visibility determination.
|
|
*/
|
|
void FDeferredShadingSceneRenderer::PreVisibilityFrameSetup(FRDGBuilder& GraphBuilder)
|
|
{
|
|
|
|
|
|
FSceneRenderer::PreVisibilityFrameSetup(GraphBuilder);
|
|
}
|
|
|
|
/**
|
|
* Initialize scene's views.
|
|
* Check visibility, build visible mesh commands, etc.
|
|
*/
|
|
void FDeferredShadingSceneRenderer::BeginInitViews(
|
|
FRDGBuilder& GraphBuilder,
|
|
const FSceneTexturesConfig& SceneTexturesConfig,
|
|
FInstanceCullingManager& InstanceCullingManager,
|
|
FRDGExternalAccessQueue& ExternalAccessQueue,
|
|
FInitViewTaskDatas& TaskDatas)
|
|
{
|
|
SCOPED_NAMED_EVENT(FDeferredShadingSceneRenderer_InitViews, FColor::Emerald);
|
|
SCOPE_CYCLE_COUNTER(STAT_InitViewsTime);
|
|
RDG_CSV_STAT_EXCLUSIVE_SCOPE(GraphBuilder, InitViews_Scene);
|
|
|
|
const bool bRendererOutputFinalSceneColor = (GetRendererOutput() == ERendererOutput::FinalSceneColor);
|
|
|
|
PreVisibilityFrameSetup(GraphBuilder);
|
|
|
|
{
|
|
// 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).
|
|
// Note: This MUST happen before we start to execute GDME tasks of any kind otherwise we will race with PostInitViews renderers!
|
|
if (FXSystem && FXSystem->RequiresEarlyViewUniformBuffer() && Views.IsValidIndex(0) && bRendererOutputFinalSceneColor)
|
|
{
|
|
// during ISR, instanced view RHI resources need to be initialized first.
|
|
if (FViewInfo* InstancedView = const_cast<FViewInfo*>(Views[0].GetInstancedView()))
|
|
{
|
|
InstancedView->InitRHIResources();
|
|
}
|
|
Views[0].InitRHIResources();
|
|
FXSystem->PostInitViews(GraphBuilder, GetSceneViews(), !ViewFamily.EngineShowFlags.HitProxies);
|
|
}
|
|
}
|
|
|
|
// Start processing dynamic mesh elements tasks early enough to overlap with shadows and GPU scene update.
|
|
TaskDatas.VisibilityTaskData->StartGatherDynamicMeshElements();
|
|
|
|
#if RHI_RAYTRACING
|
|
// Start processing dynamic ray tracing instances early enough to overlap with shadows and GPU scene update.
|
|
if (TaskDatas.RayTracingGatherInstances != nullptr)
|
|
{
|
|
RayTracing::BeginGatherDynamicRayTracingInstances(*TaskDatas.RayTracingGatherInstances);
|
|
}
|
|
#endif
|
|
|
|
if (!ViewFamily.EngineShowFlags.HitProxies)
|
|
{
|
|
TaskDatas.Decals = FDecalVisibilityTaskData::Launch(GraphBuilder, *Scene, Views);
|
|
}
|
|
|
|
// Attempt to launch dynamic shadow tasks early before finalizing visibility.
|
|
if (bRendererOutputFinalSceneColor)
|
|
{
|
|
BeginInitDynamicShadows(GraphBuilder, TaskDatas, InstanceCullingManager);
|
|
}
|
|
|
|
FRHICommandListImmediate& RHICmdList = GraphBuilder.RHICmdList;
|
|
|
|
if (InstanceCullingManager.IsEnabled()
|
|
&& Scene->InstanceCullingOcclusionQueryRenderer
|
|
&& Scene->InstanceCullingOcclusionQueryRenderer->InstanceOcclusionQueryBuffer)
|
|
{
|
|
InstanceCullingManager.InstanceOcclusionQueryBuffer = GraphBuilder.RegisterExternalBuffer(Scene->InstanceCullingOcclusionQueryRenderer->InstanceOcclusionQueryBuffer);
|
|
InstanceCullingManager.InstanceOcclusionQueryBufferFormat = Scene->InstanceCullingOcclusionQueryRenderer->InstanceOcclusionQueryBufferFormat;
|
|
}
|
|
|
|
LumenScenePDIVisualization();
|
|
|
|
// This must happen before we start initialising and using views.
|
|
UpdateSkyIrradianceGpuBuffer(GraphBuilder, ViewFamily.EngineShowFlags, Scene->SkyLight, Scene->SkyIrradianceEnvironmentMap);
|
|
|
|
// Initialise Sky/View resources before the view global uniform buffer is built.
|
|
if (ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags))
|
|
{
|
|
InitSkyAtmosphereForViews(RHICmdList, GraphBuilder);
|
|
}
|
|
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_InitRHIResources);
|
|
// initialize per-view uniform buffer. Do it from back to front because secondary stereo view follows its primary one, but primary needs to know the instanced's params
|
|
for (int32 ViewIndex = Views.Num() - 1; ViewIndex >= 0; --ViewIndex)
|
|
{
|
|
FViewInfo& View = Views[ViewIndex];
|
|
// Set the pre-exposure before initializing the constant buffers.
|
|
View.UpdatePreExposure();
|
|
|
|
// Initialize the view's RHI resources.
|
|
UpdateHairResources(GraphBuilder, View);
|
|
View.InitRHIResources();
|
|
}
|
|
|
|
for (FCustomRenderPassInfo& PassInfo : CustomRenderPassInfos)
|
|
{
|
|
for (FViewInfo& View : PassInfo.Views)
|
|
{
|
|
View.InitRHIResources();
|
|
}
|
|
}
|
|
}
|
|
|
|
TaskDatas.VisibilityTaskData->ProcessRenderThreadTasks();
|
|
|
|
// Make a second attempt to launch shadow tasks it wasn't able to the first time due to visibility being deferred.
|
|
if (bRendererOutputFinalSceneColor)
|
|
{
|
|
BeginInitDynamicShadows(GraphBuilder, TaskDatas, InstanceCullingManager);
|
|
}
|
|
|
|
PostVisibilityFrameSetup(TaskDatas.ILCUpdatePrim);
|
|
}
|
|
|
|
void FSceneRenderer::SetupSceneReflectionCaptureBuffer(FRHICommandListImmediate& RHICmdList)
|
|
{
|
|
const TArray<FReflectionCaptureSortData>& SortedCaptures = Scene->ReflectionSceneData.SortedCaptures;
|
|
|
|
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
|
|
{
|
|
FViewInfo& View = Views[ViewIndex];
|
|
|
|
if (IsMobilePlatform(ShaderPlatform))
|
|
{
|
|
View.MobileReflectionCaptureUniformBuffer = Scene->ReflectionSceneData.MobileReflectionCaptureUniformBuffer;
|
|
}
|
|
else
|
|
{
|
|
View.ReflectionCaptureUniformBuffer = Scene->ReflectionSceneData.ReflectionCaptureUniformBuffer;
|
|
}
|
|
|
|
View.NumBoxReflectionCaptures = 0;
|
|
View.NumSphereReflectionCaptures = 0;
|
|
View.FurthestReflectionCaptureDistance = 0.0f;
|
|
|
|
if (View.Family->EngineShowFlags.ReflectionEnvironment
|
|
// Avoid feedback
|
|
&& !View.bIsReflectionCapture)
|
|
{
|
|
View.NumBoxReflectionCaptures = Scene->ReflectionSceneData.NumBoxCaptures;
|
|
View.NumSphereReflectionCaptures = Scene->ReflectionSceneData.NumSphereCaptures;
|
|
|
|
for (int32 CaptureIndex = 0; CaptureIndex < SortedCaptures.Num(); CaptureIndex++)
|
|
{
|
|
const FSphere BoundingSphere(SortedCaptures[CaptureIndex].Position.GetVector3d(), SortedCaptures[CaptureIndex].Radius);
|
|
|
|
const float Distance = View.ViewMatrices.GetViewMatrix().TransformPosition(BoundingSphere.Center).Z + BoundingSphere.W;
|
|
|
|
View.FurthestReflectionCaptureDistance = FMath::Max(View.FurthestReflectionCaptureDistance, Distance);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FDeferredShadingSceneRenderer::EndInitViews(
|
|
FRDGBuilder& GraphBuilder,
|
|
FLumenSceneFrameTemporaries& FrameTemporaries,
|
|
FInstanceCullingManager& InstanceCullingManager,
|
|
FInitViewTaskDatas& TaskDatas)
|
|
{
|
|
SCOPED_NAMED_EVENT(FDeferredShadingSceneRenderer_InitViewsAfterPrepass, FColor::Emerald);
|
|
SCOPE_CYCLE_COUNTER(STAT_InitViewsPossiblyAfterPrepass);
|
|
|
|
TaskDatas.VisibilityTaskData->Finish();
|
|
|
|
// Trigger shadow GDME tasks after the main visibility tasks are synced. Projection stencil shadows reference the main view dynamic elements.
|
|
BeginShadowGatherDynamicMeshElements(TaskDatas.DynamicShadows);
|
|
|
|
FRHICommandListImmediate& RHICmdList = GraphBuilder.RHICmdList;
|
|
|
|
// 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(!TaskDatas.ILCUpdatePrim);
|
|
Scene->IndirectLightingCache.UpdateCache(Scene, *this, true);
|
|
}
|
|
|
|
// If we kicked off ILC update via task, wait and finalize.
|
|
if (TaskDatas.ILCUpdatePrim)
|
|
{
|
|
Scene->IndirectLightingCache.FinalizeCacheUpdates(Scene, *this, *TaskDatas.ILCUpdatePrim);
|
|
}
|
|
|
|
{
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_UpdatePrimitiveIndirectLightingCacheBuffers);
|
|
// Now that the indirect lighting cache is updated, we can update the primitive precomputed lighting buffers.
|
|
UpdatePrimitiveIndirectLightingCacheBuffers(GraphBuilder.RHICmdList);
|
|
}
|
|
|
|
SeparateTranslucencyDimensions = UpdateSeparateTranslucencyDimensions(*this);
|
|
|
|
SetupSceneReflectionCaptureBuffer(RHICmdList);
|
|
|
|
if (IsForwardShadingEnabled(ShaderPlatform))
|
|
{
|
|
// Dynamic shadows are synced earlier when forward shading is enabled.
|
|
FinishInitDynamicShadows(GraphBuilder, TaskDatas.DynamicShadows, InstanceCullingManager);
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------------------
|
|
FLODSceneTree Implementation
|
|
------------------------------------------------------------------------------*/
|
|
void FLODSceneTree::AddChildNode(const FPrimitiveComponentId ParentId, FPrimitiveSceneInfo* ChildSceneInfo)
|
|
{
|
|
if (ParentId.IsValid() && ChildSceneInfo)
|
|
{
|
|
FLODSceneNode* Parent = SceneNodes.Find(ParentId);
|
|
|
|
// If parent SceneNode hasn't been created yet (possible, depending on the order actors are added to the scene)
|
|
if (!Parent)
|
|
{
|
|
// Create parent SceneNode, assign correct SceneInfo
|
|
Parent = &SceneNodes.Add(ParentId, FLODSceneNode());
|
|
|
|
int32 ParentIndex = Scene->PrimitiveComponentIds.Find(ParentId);
|
|
if (ParentIndex != INDEX_NONE)
|
|
{
|
|
Parent->SceneInfo = Scene->Primitives[ParentIndex];
|
|
check(Parent->SceneInfo->PrimitiveComponentId == ParentId);
|
|
}
|
|
}
|
|
|
|
Parent->AddChild(ChildSceneInfo);
|
|
}
|
|
}
|
|
|
|
void FLODSceneTree::RemoveChildNode(const FPrimitiveComponentId ParentId, FPrimitiveSceneInfo* ChildSceneInfo)
|
|
{
|
|
if (ParentId.IsValid() && ChildSceneInfo)
|
|
{
|
|
if (FLODSceneNode* Parent = SceneNodes.Find(ParentId))
|
|
{
|
|
Parent->RemoveChild(ChildSceneInfo);
|
|
|
|
// Delete from scene if no children remain
|
|
if (Parent->ChildrenSceneInfos.Num() == 0)
|
|
{
|
|
SceneNodes.Remove(ParentId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FLODSceneTree::UpdateNodeSceneInfo(FPrimitiveComponentId NodeId, FPrimitiveSceneInfo* SceneInfo)
|
|
{
|
|
if (FLODSceneNode* Node = SceneNodes.Find(NodeId))
|
|
{
|
|
Node->SceneInfo = SceneInfo;
|
|
}
|
|
}
|
|
|
|
void FLODSceneTree::ClearVisibilityState(FViewInfo& View)
|
|
{
|
|
if (FSceneViewState* ViewState = (FSceneViewState*)View.State)
|
|
{
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
// Skip update logic when frozen
|
|
if (ViewState->bIsFrozen)
|
|
{
|
|
return;
|
|
}
|
|
#endif
|
|
FHLODVisibilityState& HLODState = ViewState->HLODVisibilityState;
|
|
|
|
if(HLODState.IsValidPrimitiveIndex(0))
|
|
{
|
|
HLODState.PrimitiveFadingLODMap.Empty(0);
|
|
HLODState.PrimitiveFadingOutLODMap.Empty(0);
|
|
HLODState.ForcedVisiblePrimitiveMap.Empty(0);
|
|
HLODState.ForcedHiddenPrimitiveMap.Empty(0);
|
|
}
|
|
|
|
TMap<FPrimitiveComponentId, FHLODSceneNodeVisibilityState>& VisibilityStates = ViewState->HLODSceneNodeVisibilityStates;
|
|
|
|
if(VisibilityStates.Num() > 0)
|
|
{
|
|
VisibilityStates.Empty(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FLODSceneTree::UpdateVisibilityStates(FViewInfo& View, UE::Tasks::FTaskEvent& FlushCachedShadowsTaskEvent)
|
|
{
|
|
if (FSceneViewState* ViewState = (FSceneViewState*)View.State)
|
|
{
|
|
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
|
|
// Skip update logic when frozen
|
|
if (ViewState->bIsFrozen)
|
|
{
|
|
return;
|
|
}
|
|
#endif
|
|
QUICK_SCOPE_CYCLE_COUNTER(STAT_ViewVisibilityTime_HLODUpdate);
|
|
|
|
// Per-frame initialization
|
|
FHLODVisibilityState& HLODState = ViewState->HLODVisibilityState;
|
|
TMap<FPrimitiveComponentId, FHLODSceneNodeVisibilityState>& VisibilityStates = ViewState->HLODSceneNodeVisibilityStates;
|
|
|
|
HLODState.PrimitiveFadingLODMap.Init(false, Scene->Primitives.Num());
|
|
HLODState.PrimitiveFadingOutLODMap.Init(false, Scene->Primitives.Num());
|
|
HLODState.ForcedVisiblePrimitiveMap.Init(false, Scene->Primitives.Num());
|
|
HLODState.ForcedHiddenPrimitiveMap.Init(false, Scene->Primitives.Num());
|
|
TArray<FPrimitiveViewRelevance, SceneRenderingAllocator>& RelevanceMap = View.PrimitiveViewRelevanceMap;
|
|
|
|
if (HLODState.PrimitiveFadingLODMap.Num() != Scene->Primitives.Num())
|
|
{
|
|
checkf(0, TEXT("HLOD update incorrectly allocated primitive maps"));
|
|
return;
|
|
}
|
|
|
|
TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator> FlushCachedShadowPrimitives;
|
|
|
|
int32 UpdateCount = ++HLODState.UpdateCount;
|
|
|
|
// Update persistent state on temporal dither sync frames
|
|
const FTemporalLODState& LODState = ViewState->GetTemporalLODState();
|
|
bool bSyncFrame = false;
|
|
|
|
if (HLODState.TemporalLODSyncTime != LODState.TemporalLODTime[0])
|
|
{
|
|
HLODState.TemporalLODSyncTime = LODState.TemporalLODTime[0];
|
|
bSyncFrame = true;
|
|
|
|
// Only update our scaling on sync frames else we might end up changing transition direction mid-fade
|
|
const FCachedSystemScalabilityCVars& ScalabilityCVars = GetCachedScalabilityCVars();
|
|
if (ScalabilityCVars.FieldOfViewAffectsHLOD)
|
|
{
|
|
HLODState.FOVDistanceScaleSq = ScalabilityCVars.CalculateFieldOfViewDistanceScale(View.DesiredFOV);
|
|
HLODState.FOVDistanceScaleSq *= HLODState.FOVDistanceScaleSq;
|
|
}
|
|
else
|
|
{
|
|
HLODState.FOVDistanceScaleSq = 1.f;
|
|
}
|
|
}
|
|
|
|
for (auto Iter = SceneNodes.CreateIterator(); Iter; ++Iter)
|
|
{
|
|
FLODSceneNode& Node = Iter.Value();
|
|
FPrimitiveSceneInfo* SceneInfo = Node.SceneInfo;
|
|
|
|
if (!SceneInfo || !SceneInfo->PrimitiveComponentId.IsValid() || !SceneInfo->IsIndexValid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FHLODSceneNodeVisibilityState& NodeVisibility = VisibilityStates.FindOrAdd(SceneInfo->PrimitiveComponentId);
|
|
const TArray<FStaticMeshBatchRelevance>& NodeMeshRelevances = SceneInfo->StaticMeshRelevances;
|
|
|
|
// Ignore already updated nodes, or those that we can't work with
|
|
if (NodeVisibility.UpdateCount == UpdateCount || !NodeMeshRelevances.IsValidIndex(0))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const int32 NodeIndex = SceneInfo->GetIndex();
|
|
|
|
if (!Scene->PrimitiveBounds.IsValidIndex(NodeIndex))
|
|
{
|
|
checkf(0, TEXT("A HLOD Node's PrimitiveSceneInfo PackedIndex was out of Scene.Primitive bounds!"));
|
|
continue;
|
|
}
|
|
|
|
FPrimitiveBounds& Bounds = Scene->PrimitiveBounds[NodeIndex];
|
|
const bool bForcedIntoView = FMath::IsNearlyZero(Bounds.MinDrawDistance);
|
|
|
|
// Update visibility states of this node and owned children
|
|
float ClosestDistSquared, FurthestDistSquared;
|
|
|
|
if (GDistanceCullToSphereEdge)
|
|
{
|
|
ComputeDistances(Bounds, View.ViewMatrices.GetViewOrigin(), ClosestDistSquared, FurthestDistSquared);
|
|
}
|
|
else
|
|
{
|
|
ClosestDistSquared = FurthestDistSquared = Bounds.BoxSphereBounds.ComputeSquaredDistanceFromBoxToPoint(View.ViewMatrices.GetViewOrigin());
|
|
}
|
|
|
|
const bool bNearCulled = FurthestDistSquared < FMath::Square(Bounds.MinDrawDistance) * HLODState.FOVDistanceScaleSq;
|
|
const bool bFarCulled = ClosestDistSquared > Bounds.MaxDrawDistance * Bounds.MaxDrawDistance * HLODState.FOVDistanceScaleSq;
|
|
|
|
const bool bIsInDrawRange = !bNearCulled && !bFarCulled;
|
|
|
|
const bool bWasFadingPreUpdate = !!NodeVisibility.bIsFading;
|
|
const bool bIsDitheredTransition = NodeMeshRelevances[0].bDitheredLODTransition;
|
|
|
|
if (bIsDitheredTransition && !bForcedIntoView)
|
|
{
|
|
// Update fading state with syncs
|
|
if (bSyncFrame)
|
|
{
|
|
// Fade when HLODs change threshold
|
|
const bool bChangedRange = bIsInDrawRange != !!NodeVisibility.bWasVisible;
|
|
|
|
if (NodeVisibility.bIsFading)
|
|
{
|
|
NodeVisibility.bIsFading = false;
|
|
}
|
|
else if (bChangedRange)
|
|
{
|
|
NodeVisibility.bIsFading = true;
|
|
}
|
|
|
|
NodeVisibility.bWasVisible = NodeVisibility.bIsVisible;
|
|
NodeVisibility.bIsVisible = bIsInDrawRange;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Instant transitions without dithering
|
|
NodeVisibility.bWasVisible = NodeVisibility.bIsVisible;
|
|
NodeVisibility.bIsVisible = bIsInDrawRange || bForcedIntoView;
|
|
NodeVisibility.bIsFading = false;
|
|
}
|
|
|
|
// Flush cached lighting data when changing visible contents
|
|
if (NodeVisibility.bIsVisible != NodeVisibility.bWasVisible || bWasFadingPreUpdate || NodeVisibility.bIsFading)
|
|
{
|
|
FlushCachedShadowPrimitives.Emplace(SceneInfo);
|
|
}
|
|
|
|
// Force fully disabled view relevance so shadows don't attempt to recompute
|
|
if (!NodeVisibility.bIsVisible)
|
|
{
|
|
if (RelevanceMap.IsValidIndex(NodeIndex))
|
|
{
|
|
FPrimitiveViewRelevance& ViewRelevance = RelevanceMap[NodeIndex];
|
|
FMemory::Memzero(&ViewRelevance, sizeof(FPrimitiveViewRelevance));
|
|
ViewRelevance.bInitializedThisFrame = true;
|
|
}
|
|
else
|
|
{
|
|
checkf(0, TEXT("A HLOD Node's PrimitiveSceneInfo PackedIndex was out of View.Relevancy bounds!"));
|
|
}
|
|
}
|
|
|
|
// NOTE: We update our children last as HideNodeChildren can add new visibility
|
|
// states, potentially invalidating our cached reference above, NodeVisibility
|
|
if (NodeVisibility.bIsFading)
|
|
{
|
|
// Fade until state back in sync
|
|
HLODState.PrimitiveFadingLODMap[NodeIndex] = true;
|
|
HLODState.PrimitiveFadingOutLODMap[NodeIndex] = !NodeVisibility.bIsVisible;
|
|
HLODState.ForcedVisiblePrimitiveMap[NodeIndex] = true;
|
|
ApplyNodeFadingToChildren(ViewState, Node, NodeVisibility, true, !!NodeVisibility.bIsVisible);
|
|
}
|
|
else if (NodeVisibility.bIsVisible)
|
|
{
|
|
// If stable and visible, override hierarchy visibility
|
|
HLODState.ForcedVisiblePrimitiveMap[NodeIndex] = true;
|
|
HideNodeChildren(ViewState, Node);
|
|
}
|
|
else
|
|
{
|
|
// Not visible and waiting for a transition to fade, keep HLOD hidden
|
|
HLODState.ForcedHiddenPrimitiveMap[NodeIndex] = true;
|
|
|
|
// Also hide children when performing far culling
|
|
if (bFarCulled)
|
|
{
|
|
HideNodeChildren(ViewState, Node);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!FlushCachedShadowPrimitives.IsEmpty())
|
|
{
|
|
// We don't want to block on the LPI creation task as it overlaps with this work. Spawn a new task that will be waited on further down the pipe.
|
|
FlushCachedShadowsTaskEvent.AddPrerequisites(UE::Tasks::Launch(UE_SOURCE_LOCATION, [this, Primitives = MoveTemp(FlushCachedShadowPrimitives)]
|
|
{
|
|
for (FPrimitiveSceneInfo* SceneInfo : Primitives)
|
|
{
|
|
FLightPrimitiveInteraction* NodeLightList = SceneInfo->LightList;
|
|
while (NodeLightList)
|
|
{
|
|
NodeLightList->FlushCachedShadowMapData();
|
|
NodeLightList = NodeLightList->GetNextLight();
|
|
}
|
|
}
|
|
}, Scene->GetCreateLightPrimitiveInteractionsTask()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void FLODSceneTree::ApplyNodeFadingToChildren(FSceneViewState* ViewState, FLODSceneNode& Node, FHLODSceneNodeVisibilityState& NodeVisibility, const bool bIsFading, const bool bIsFadingOut)
|
|
{
|
|
checkSlow(ViewState);
|
|
if (Node.SceneInfo)
|
|
{
|
|
FHLODVisibilityState& HLODState = ViewState->HLODVisibilityState;
|
|
NodeVisibility.UpdateCount = HLODState.UpdateCount;
|
|
|
|
// Force visibility during fades
|
|
for (const auto Child : Node.ChildrenSceneInfos)
|
|
{
|
|
if (!Child || !Child->PrimitiveComponentId.IsValid() || !Child->IsIndexValid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const int32 ChildIndex = Child->GetIndex();
|
|
|
|
if (!HLODState.PrimitiveFadingLODMap.IsValidIndex(ChildIndex))
|
|
{
|
|
checkf(0, TEXT("A HLOD Child's PrimitiveSceneInfo PackedIndex was out of FadingMap's bounds!"));
|
|
continue;
|
|
}
|
|
|
|
HLODState.PrimitiveFadingLODMap[ChildIndex] = bIsFading;
|
|
HLODState.PrimitiveFadingOutLODMap[ChildIndex] = bIsFadingOut;
|
|
HLODState.ForcedHiddenPrimitiveMap[ChildIndex] = false;
|
|
|
|
if (bIsFading)
|
|
{
|
|
HLODState.ForcedVisiblePrimitiveMap[ChildIndex] = true;
|
|
}
|
|
|
|
// Fading only occurs at the adjacent hierarchy level, below should be hidden
|
|
if (FLODSceneNode* ChildNode = SceneNodes.Find(Child->PrimitiveComponentId))
|
|
{
|
|
HideNodeChildren(ViewState, *ChildNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FLODSceneTree::HideNodeChildren(FSceneViewState* ViewState, FLODSceneNode& Node)
|
|
{
|
|
checkSlow(ViewState);
|
|
if (Node.SceneInfo)
|
|
{
|
|
FHLODVisibilityState& HLODState = ViewState->HLODVisibilityState;
|
|
TMap<FPrimitiveComponentId, FHLODSceneNodeVisibilityState>& VisibilityStates = ViewState->HLODSceneNodeVisibilityStates;
|
|
FHLODSceneNodeVisibilityState& NodeVisibility = VisibilityStates.FindOrAdd(Node.SceneInfo->PrimitiveComponentId);
|
|
|
|
if (NodeVisibility.UpdateCount != HLODState.UpdateCount)
|
|
{
|
|
NodeVisibility.UpdateCount = HLODState.UpdateCount;
|
|
|
|
for (const auto Child : Node.ChildrenSceneInfos)
|
|
{
|
|
if (!Child || !Child->PrimitiveComponentId.IsValid() || !Child->IsIndexValid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const int32 ChildIndex = Child->GetIndex();
|
|
|
|
if (!HLODState.ForcedHiddenPrimitiveMap.IsValidIndex(ChildIndex))
|
|
{
|
|
checkf(0, TEXT("A HLOD Child's PrimitiveSceneInfo PackedIndex was out of ForcedHidden's bounds!"));
|
|
continue;
|
|
}
|
|
|
|
HLODState.ForcedHiddenPrimitiveMap[ChildIndex] = true;
|
|
|
|
// Clear the force visible flag in case the child was processed before it's parent
|
|
HLODState.ForcedVisiblePrimitiveMap[ChildIndex] = false;
|
|
|
|
if (FLODSceneNode* ChildNode = SceneNodes.Find(Child->PrimitiveComponentId))
|
|
{
|
|
HideNodeChildren(ViewState, *ChildNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|