// RHI_RAYTRACING begin
SHOWFLAG_ALWAYS_ACCESSIBLE(PathTracing, SFG_Hidden, NSLOCTEXT("UnrealEd", "PathTracing", "Path tracing"))
SHOWFLAG_FIXED_IN_SHIPPING(0, RayTracingDebug, SFG_Hidden, NSLOCTEXT("UnrealEd", "RayTracingDebug", "Ray tracing debug"))
// RHI_RAYTRACING end

/** Enable the SkyAtmosphere visualization to be drawn on screen */
SHOWFLAG_FIXED_IN_SHIPPING(0, VisualizeSkyAtmosphere, SFG_Visualize, NSLOCTEXT("UnrealEd", "VisualizeSkyAtmosphereSF", "Sky Atmosphere"))
/** Enable the light function atlas debug visualization to be drawn on screen */

file
class        class UKismetRenderingLibrary : public UBlueprintFunctionLibrary

	/** Enables or disables the path tracer for the current Game Viewport.
	 * This command is equivalent to setting ShowFlag.PathTracing, but is accessible even from shipping builds.
	 */
	UFUNCTION(BlueprintCallable, Category = "Rendering", meta = (Keywords="EnablePathTracing"))
	static ENGINE_API void EnablePathTracing(bool bEnablePathTracer);

	/** Forces the path tracer to restart sample accumulation.
	 * This can be used to force the path tracer to compute a new frame in situations where it can not detect a change in the scene automatically.
	 */
	UFUNCTION(BlueprintCallable, Category = "Rendering", meta = (Keywords = "PathTracing"))

file
function     void UWaterSubsystem::ComputeUnderwaterPostProcess

	SceneView->UnderwaterDepth = CachedDepthUnderwater;

	if (!bUnderwaterForPostProcess || !IsUnderwaterPostProcessEnabled() || SceneView->Family->EngineShowFlags.PathTracing)
	{
		UnderwaterPostProcessVolume.PostProcessProperties.bIsEnabled = false;
		UnderwaterPostProcessVolume.PostProcessProperties.Settings = nullptr;
	}

#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)

file
namespace    UE::MovieGraph::Rendering
function     void FMovieGraphImagePassBase::ApplyMovieGraphOverridesToSceneView

	{
		bool bIsSupportedAAMethod = View->AntiAliasingMethod == EAntiAliasingMethod::AAM_FXAA;
		bool bIsPathTracer = InOutFamily->EngineShowFlags.PathTracing;
		bool bWarnJitters = InCameraInfo.ProjectionMatrixJitterAmount.SquaredLength() > SMALL_NUMBER;
		if ((!bIsPathTracer && !bIsSupportedAAMethod) || bWarnJitters)
		{
			UE_LOG(LogMovieRenderPipeline, Warning, TEXT("Orthographic Cameras are only supported with PathTracer or Deferred with FXAA Anti-Aliasing"));
		}
	}

file
namespace    UE::MovieGraph::Rendering
function     void FMovieGraphImagePassBase::ApplyMovieGraphOverridesToSceneView

		// inside FSceneRenderer::PreVisibilityFrameSetup. Path Tracing does its own anti-aliasing internally.
		bool bApplyProjectionJitter = !bIsOrthographicCamera
			&& !InOutFamily->EngineShowFlags.PathTracing
			&& !IsTemporalAccumulationBasedMethod(View->AntiAliasingMethod);
		if (bApplyProjectionJitter)
		{
			View->ViewMatrices.HackAddTemporalAAProjectionJitter(InCameraInfo.ProjectionMatrixJitterAmount);
		}
	}

file
function     TSharedPtr<FSceneViewFamilyContext> UMoviePipelineImagePassBase::CalculateViewFamily

	{
		bool bIsSupportedAAMethod = View->AntiAliasingMethod == EAntiAliasingMethod::AAM_FXAA;
		bool bIsPathTracer = OutViewFamily->EngineShowFlags.PathTracing;
		bool bWarnJitters = InOutSampleState.ProjectionMatrixJitterAmount.SquaredLength() > SMALL_NUMBER;
		if ((!bIsPathTracer && !bIsSupportedAAMethod) || bWarnJitters)
		{
			UE_LOG(LogMovieRenderPipeline, Warning, TEXT("Orthographic Cameras are only supported with PathTracer or Deferred with FXAA Anti-Aliasing"));
		}
	}

file
function     TSharedPtr<FSceneViewFamilyContext> UMoviePipelineImagePassBase::CalculateViewFamily

		// inside FSceneRenderer::PreVisibilityFrameSetup. Path Tracing does its own anti-aliasing internally.
		bool bApplyProjectionJitter = !bIsOrthographicCamera
									&& !OutViewFamily->EngineShowFlags.PathTracing 
									&& !IsTemporalAccumulationBasedMethod(View->AntiAliasingMethod);
		if (bApplyProjectionJitter)
		{
			View->ViewMatrices.HackAddTemporalAAProjectionJitter(InOutSampleState.ProjectionMatrixJitterAmount);
		}
	}

	// Path Tracer Sampling
	if (OutViewFamily->EngineShowFlags.PathTracing)
	{
		// override whatever settings came from PostProcessVolume or Camera

		// If motion blur is enabled:
		//    blend all spatial samples together while leaving the handling of temporal samples up to MRQ
		//    each temporal sample will include denoising and post-process effects

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicRayTracingInstances

		const bool bWireframe = AllowDebugViewmodes() && Context.ReferenceViewFamily.EngineShowFlags.Wireframe;
		const EHairViewRayTracingMask ViewRayTracingMask = Context.ReferenceViewFamily.EngineShowFlags.PathTracing ? EHairViewRayTracingMask::PathTracing : EHairViewRayTracingMask::RayTracing;
		if (bWireframe)
			return;

		for (uint32 GroupIt = 0, GroupCount = HairGroupInstances.Num(); GroupIt < GroupCount; ++GroupIt)
		{
			FHairGroupInstance* Instance = HairGroupInstances[GroupIt];

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicRayTracingInstances

			FHairStrandsRaytracingResource* RTGeometry = nullptr;
			bool bIsHairStrands = false;
			EHairViewRayTracingMask InstanceViewRayTracingMask = EHairViewRayTracingMask::PathTracing | EHairViewRayTracingMask::RayTracing;
			switch (GeometryType)
			{
				case EHairGeometryType::Strands:
				{
					RTGeometry = Instance->Strands.RenRaytracingResource;
					InstanceViewRayTracingMask = Instance->Strands.ViewRayTracingMask;

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicRayTracingInstances

					check(Segment.VertexBuffer.IsValid());
				}
				// ViewFamily.EngineShowFlags.PathTracing
				if (FMeshBatch* MeshBatch = CreateMeshBatch(Context.ReferenceView, Context.ReferenceViewFamily, Context.RayTracingMeshResourceCollector, EHairMeshBatchType::Raytracing, Instance, GroupIt, nullptr))
				{
					FRayTracingInstance RayTracingInstance;
					RayTracingInstance.Geometry = &RTGeometry->RayTracingGeometry;
					RayTracingInstance.Materials.Add(*MeshBatch);
					RayTracingInstance.InstanceTransforms.Add(OverrideLocalToWorld);

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual FPrimitiveViewRelevance GetViewRelevance

		// When path tracing is enabled force DrawRelevance if not visible in main view ('hidden in game'), 
		// but visible in shadow 'hidden shadow') so that raytracing geometry is created/updated correctly
		const bool bPathtracing = View->Family->EngineShowFlags.PathTracing;
		const bool bForceDrawRelevance = bPathtracing && (!IsShown(View) && IsShadowCast(View));

		bool bUseCardsOrMesh = false;
		for (const TRefCountPtr<FHairGroupInstance>& Instance : HairGroupInstances)
		{
			check(Instance->GetRefCount());

file
function     void UGroomComponent::InitResources

			if (IsHairRayTracingEnabled() && HairGroupInstance->Strands.Modifier.bUseHairRaytracingGeometry && bVisibleInRayTracing)
			{
				HairGroupInstance->Strands.ViewRayTracingMask = EHairViewRayTracingMask::RayTracing | EHairViewRayTracingMask::PathTracing;
				if (bNeedDynamicResources)
				{
					// Allocate dynamic raytracing resources (owned by the groom component/instance)
					HairGroupInstance->Strands.RenRaytracingResource = new FHairStrandsRaytracingResource(GroupData.Strands.BulkData, ResourceName, OwnerName);
					HairGroupInstance->Strands.RenRaytracingResourceOwned = true;
				}

file
function     static void RunHairStrandsInterpolation_Strands

	// Gather all strands instances
	const EHairViewRayTracingMask ViewRayTracingMask = RHI_RAYTRACING ? (View->Family->EngineShowFlags.PathTracing ? EHairViewRayTracingMask::PathTracing : EHairViewRayTracingMask::RayTracing) : EHairViewRayTracingMask::None;
	bool bHasAnySimCacheInstances = false;
	bool bHasAnyRenCacheInstances = false;
	bool bHasAnyRaytracingInstances = false;
	TArray<FInstanceData> InstanceDatas;
	InstanceDatas.Reserve(Instances.Num());
	for (FHairStrandsInstance* AbstractInstance : Instances)

file
function     static void AllocateRaytracingResources

		Instance->Strands.RenRaytracingResourceOwned = true;
	}
	Instance->Strands.ViewRayTracingMask |= EHairViewRayTracingMask::PathTracing;
}
#endif

void AddHairStreamingRequest(FHairGroupInstance* Instance, int32 InLODIndex)
{
	if (Instance && InLODIndex >= 0)

file
function     static void RunHairLODSelection

	for (const FSceneView* View : Views)
	{
		if (View->Family->EngineShowFlags.PathTracing)
		{
			bHasPathTracingView = true;
			break;
		}
	}
#endif

file
function     FHairGroupPublicData::FVertexFactoryInput InternalComputeHairStrandsVertexInputData

	bool bRaytracingGeometry = false;
#if RHI_RAYTRACING
	// Flag bUseRaytracingGeometry only if RT geometry has been allocated for RayTracing view (not for PathTracing view). 
	// This flag is used later for selecting if voxelization needs to flags voxel has shadow caster or if shadow casting is handled 
	// by the RT geometry.
	bRaytracingGeometry = Instance->Strands.RenRaytracingResource != nullptr && EnumHasAnyFlags(Instance->Strands.ViewRayTracingMask, EHairViewRayTracingMask::RayTracing);
#endif

	OutVFInput.Strands.Common.RegisteredIndex = Instance->RegisteredIndex;

	None		= 0x0,
	RayTracing  = 0x1, // Visible for raytracing effects (RT shadow, RT refleciton, Lumen, ...)
	PathTracing = 0x2, // Visible for pathtracing rendering
};
ENUM_CLASS_FLAGS(EHairViewRayTracingMask);

// Represent/Describe data & resources of a hair group belonging to a groom
struct HAIRSTRANDSCORE_API FHairGroupInstance : public FHairStrandsInstance
{

file
function     void UDisplayClusterViewportClient::Draw

	// Force path tracing view mode, and extern code set path tracer show flags
	const bool bForcePathTracing = InViewport->GetClient()->GetEngineShowFlags()->PathTracing;
	if (bForcePathTracing)
	{
		EngineShowFlags.SetPathTracing(true);
		ViewModeIndex = VMI_PathTracing;
	}

file
function     void FInEditorCapture::OnPIEViewportStarted

				if (CachedEngineShowFlags && Settings.bUsePathTracer)
				{
					CachedPathTracingMode = CachedEngineShowFlags->PathTracing;
					CachedEngineShowFlags->SetPathTracing(true);
				}
				CaptureObject->Initialize(SlatePlayInEditorSession->SlatePlayInEditorWindowViewport, Context.PIEInstance);
				OnCaptureStarted();
			}
			return;

file
function     EViewStatusForScreenPercentage FEditorViewportClient::GetViewStatusForScreenPercentage

EViewStatusForScreenPercentage FEditorViewportClient::GetViewStatusForScreenPercentage() const
{
	if (EngineShowFlags.PathTracing)
	{
		return EViewStatusForScreenPercentage::PathTracer;
	}
	else if (EngineShowFlags.StereoRendering || EngineShowFlags.VREditing)
	{
		return EViewStatusForScreenPercentage::VR;

file
function     EViewStatusForScreenPercentage UGameViewportClient::GetViewStatusForScreenPercentage

EViewStatusForScreenPercentage UGameViewportClient::GetViewStatusForScreenPercentage() const
{
	if (EngineShowFlags.PathTracing)
	{
		return EViewStatusForScreenPercentage::PathTracer;
	}
	else if (EngineShowFlags.StereoRendering)
	{
		return EViewStatusForScreenPercentage::VR;

file
function     void FSceneView::SetupCommonViewUniformBufferParameters

	ViewUniformShaderParameters.DebugViewModeMask = Family->UseDebugViewPS() ? 1 : 0;
	ViewUniformShaderParameters.UnlitViewmodeMask = !Family->EngineShowFlags.Lighting || Family->EngineShowFlags.PathTracing ? 1 : 0;
	ViewUniformShaderParameters.OutOfBoundsMask = Family->EngineShowFlags.VisualizeOutOfBoundsPixels ? 1 : 0;

#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
	float OverrideTimeMaterialExpression = CVarOverrideTimeMaterialExpressions.GetValueOnRenderThread();
	if (OverrideTimeMaterialExpression >= 0.0f)
	{

		return VMI_HLODColoration;
	}
	else if (EngineShowFlags.PathTracing)
	{
		return VMI_PathTracing;
	}
	else if (EngineShowFlags.RayTracingDebug)
	{
		return VMI_RayTracingDebug;

file
function     float DrawMapWarnings

	if (Viewport && Viewport->GetClient() && Viewport->GetClient()->GetEngineShowFlags())
	{
		bIsPathTracing = Viewport->GetClient()->GetEngineShowFlags()->PathTracing != 0;
	}

	// Put the messages over fairly far to stay in the safe zone on consoles
	if (World->NumLightingUnbuiltObjects > 0 && !bIsPathTracing)
	{
		SmallTextItem.SetColor(FLinearColor::White);

// RHI_RAYTRACING begin
SHOWFLAG_ALWAYS_ACCESSIBLE(PathTracing, SFG_Hidden, NSLOCTEXT("UnrealEd", "PathTracing", "Path tracing"))
SHOWFLAG_FIXED_IN_SHIPPING(0, RayTracingDebug, SFG_Hidden, NSLOCTEXT("UnrealEd", "RayTracingDebug", "Ray tracing debug"))
// RHI_RAYTRACING end

/** Enable the SkyAtmosphere visualization to be drawn on screen */
SHOWFLAG_FIXED_IN_SHIPPING(0, VisualizeSkyAtmosphere, SFG_Visualize, NSLOCTEXT("UnrealEd", "VisualizeSkyAtmosphereSF", "Sky Atmosphere"))
/** Enable the light function atlas debug visualization to be drawn on screen */

	}

	return ViewFamily.EngineShowFlags.PathTracing && PathTracing::UsesDecals(ViewFamily);
}

struct FRayTracingRelevantPrimitiveTaskData
{
	RayTracing::FRelevantPrimitiveList* List;
	FGraphEventRef Task;

	}

	const bool bIsPathTracing = ViewFamily.EngineShowFlags.PathTracing;

	if (GRHISupportsRayTracingShaders)
	{
		// #dxr_todo: UE-72565: refactor ray tracing effects to not be member functions of DeferredShadingRenderer. 
		// Should register each effect at startup and just loop over them automatically to gather all required shaders.

	}

	const bool bPathTracingEnabled = ViewFamily.EngineShowFlags.PathTracing && FDataDrivenShaderPlatformInfo::GetSupportsPathTracing(Scene->GetShaderPlatform());

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

		bool bBuildLightGrid = false;

file
function     void FDeferredShadingSceneRenderer::WaitForRayTracingScene

	}

	const bool bIsPathTracing = ViewFamily.EngineShowFlags.PathTracing;

	FBuildAccelerationStructurePassParams* PassParams = GraphBuilder.AllocParameters<FBuildAccelerationStructurePassParams>();
	PassParams->Scene = GetSceneUniformBufferRef(GraphBuilder);
	PassParams->RayTracingSceneScratchBuffer = nullptr;
	PassParams->DynamicGeometryScratchBuffer = nullptr;
	PassParams->LightGridPacked = bIsPathTracing ? nullptr : ReferenceView.RayTracingLightGridUniformBuffer; // accessed by FRayTracingLightingMS // Is this needed for anything?

file
function     void FDeferredShadingSceneRenderer::Render

			// This needs to be done prior to start Lumen scene lighting to ensure directional light color is correct, as the sun color needs atmosphere transmittance
			{
				const bool bPathTracedAtmosphere = ViewFamily.EngineShowFlags.PathTracing && Views.Num() > 0 && Views[0].FinalPostProcessSettings.PathTracingEnableReferenceAtmosphere;
				if (ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags) && !bPathTracedAtmosphere)
				{
					for (int32 LightIndex = 0; LightIndex < NUM_ATMOSPHERE_LIGHTS; ++LightIndex)
					{
						if (Scene->AtmosphereLights[LightIndex])
						{

file
function     void FDeferredShadingSceneRenderer::Render

	// By default, limit our GPU usage to only GPUs specified in the view masks.
	RDG_GPU_MASK_SCOPE(GraphBuilder, ViewFamily.EngineShowFlags.PathTracing ? FRHIGPUMask::All() : AllViewsGPUMask);
	RDG_EVENT_SCOPE(GraphBuilder, "Scene");
	RDG_GPU_STAT_SCOPE_VERBOSE(GraphBuilder, Unaccounted, *ViewFamily.ProfileDescription);
	
	if (RendererOutput == ERendererOutput::FinalSceneColor)
	{
		SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_Render_Init);

file
function     void FDeferredShadingSceneRenderer::Render

			Nanite::GRayTracingManager.Update();

			if (!ViewFamily.EngineShowFlags.PathTracing)
			{
				// get the default lighting miss shader (to implicitly fill in the MissShader library before the RT pipeline is created)
				GetRayTracingLightingMissShader(ReferenceView.ShaderMap);
				RayTracingScene.NumMissShaderSlots++;
			}

file
function     void FDeferredShadingSceneRenderer::Render

				// gather all the light functions that may be used (and also count how many miss shaders we will need)
				FRayTracingLightFunctionMap RayTracingLightFunctionMap;
				if (ViewFamily.EngineShowFlags.PathTracing)
				{
					RayTracingLightFunctionMap = GatherLightFunctionLightsPathTracing(Scene, ViewFamily.EngineShowFlags, ReferenceView.GetFeatureLevel());
				}
				else
				{
					RayTracingLightFunctionMap = GatherLightFunctionLights(Scene, ViewFamily.EngineShowFlags, ReferenceView.GetFeatureLevel());

file
function     void FDeferredShadingSceneRenderer::Render

				ShouldVisualizeLightGrid() ||
				ShouldRenderLocalFogVolume(Scene, ViewFamily)); // Needed when accessing forward light data for the directional light
			bComputeLightGrid &= !ViewFamily.EngineShowFlags.PathTracing;
		}
	}

	// force using occ queries for wireframe if rendering is parented or frozen in the first view
	check(Views.Num());
	#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)

file
function     void FDeferredShadingSceneRenderer::Render

			// Most of the ray tracing debug visualizations also require the full pipeline, but some support inline mode.
			
			if (ViewFamily.EngineShowFlags.PathTracing 
				&& FDataDrivenShaderPlatformInfo::GetSupportsPathTracing(Scene->GetShaderPlatform()))
			{
				for (const FViewInfo& View : Views)
				{
					RenderPathTracing(GraphBuilder, View, SceneTextures.UniformBuffer, SceneTextures.Color.Target, SceneTextures.Depth.Target,PathTracingResources);
				}

file
function     bool HasRayTracedOverlay

	// This can be used to skip certain calculations
	return
		ViewFamily.EngineShowFlags.PathTracing ||
		ViewFamily.EngineShowFlags.RayTracingDebug;
}

void FDeferredShadingSceneRenderer::InitializeRayTracingFlags_RenderThread()
{
	// The result of this call is used by AnyRayTracingPassEnabled to decide if we have any RT shadows enabled

file
function     bool FSceneRenderer::ShouldPrepareDistanceFieldScene

	const bool bShouldPrepareForDFInsetIndirectShadow = ShouldPrepareForDFInsetIndirectShadow();

	if (ViewFamily.EngineShowFlags.PathTracing)
	{
		return bShouldPrepareGlobalDistanceField;
	}

	// Prepare the distance field scene (object buffers and distance field atlas) if any feature needs it
	return bShouldPrepareGlobalDistanceField 

file
function     bool FSceneRenderer::ShouldPrepareGlobalDistanceField

		|| ((FXSystem != nullptr) && FXSystem->UsesGlobalDistanceField());

	if (ViewFamily.EngineShowFlags.PathTracing)
	{
		return bShouldPrepareForMaterialsOrNiagara;
	}

	const bool bShouldPrepareForAO = SupportsDistanceFieldAO(Scene->GetFeatureLevel(), Scene->GetShaderPlatform())
		&& (ShouldPrepareForDistanceFieldAO() || bShouldPrepareForMaterialsOrNiagara);

file
function     bool FSceneRenderer::ShouldRenderDistanceFieldAO

		&& !ViewFamily.EngineShowFlags.VisualizeMeshDistanceFields
		&& !ViewFamily.EngineShowFlags.VisualizeGlobalDistanceField
		&& !ViewFamily.EngineShowFlags.PathTracing;
}

file
function     bool FSceneRenderer::ShouldPrepareHeightFieldScene

	return Scene
		&& ViewFamily.EngineShowFlags.DynamicShadows
		&& !ViewFamily.EngineShowFlags.PathTracing
		&& SupportsHeightFieldShadows(Scene->GetFeatureLevel(), Scene->GetShaderPlatform());
}

void RayTraceShadows(
	FRDGBuilder& GraphBuilder,
	bool bAsyncCompute,

enum class EVoxelGridBuildMode
{
	PathTracing,
	Shadows,
};

struct FVoxelGridBuildOptions
{
	EVoxelGridBuildMode VoxelGridBuildMode = EVoxelGridBuildMode::PathTracing;
	float MinimumVoxelSizeOutsideFrustum = HeterogeneousVolumes::GetMinimumVoxelSizeOutsideFrustum();
	float MinimumVoxelSizeInFrustum = HeterogeneousVolumes::GetMinimumVoxelSizeInFrustum();

	bool bBuildOrthoGrid = true;
	bool bBuildFrustumGrid = true;
	bool bJitter = HeterogeneousVolumes::ShouldJitter();

file
function     bool ShouldAddToVoxelGrid

	{
		default:
		case EVoxelGridBuildMode::PathTracing:
			return Proxy->IsShown(&View);
		case EVoxelGridBuildMode::Shadows:
			return Proxy->IsShadowCast(&View);
	}
}

file
function     void FDeferredShadingSceneRenderer::RenderDeferredReflectionsAndSkyLighting

	if (ViewFamily.EngineShowFlags.VisualizeLightCulling 
		|| ViewFamily.EngineShowFlags.RayTracingDebug
		|| ViewFamily.EngineShowFlags.PathTracing
		|| !ViewFamily.EngineShowFlags.Lighting
		|| GLumenVisualizeIndirectDiffuse != 0)
	{
		return;
	}

file
function     bool ShouldRenderLumenDiffuseGI

		&& View.Family->EngineShowFlags.GlobalIllumination 
		&& View.Family->EngineShowFlags.LumenGlobalIllumination
		&& !View.Family->EngineShowFlags.PathTracing
		&& (bSkipTracingDataCheck || Lumen::UseHardwareRayTracedScreenProbeGather(*View.Family) || Lumen::IsSoftwareRayTracingSupported());
}

bool ShouldRenderLumenDirectLighting(const FScene* Scene, const FSceneView& View)
{
	return ShouldRenderLumenDiffuseGI(Scene, View)

file
function     bool FRayTracingMeshProcessor::ProcessPathTracing

		RayTracingShader,
		ShaderElementData,
		ERayTracingViewMaskMode::PathTracing);

	return true;
}

RENDERER_API void PrepareSkyTexture_Internal(
	FRDGBuilder& GraphBuilder,

file
function     void FDeferredShadingSceneRenderer::PreparePathTracing

void FDeferredShadingSceneRenderer::PreparePathTracing(const FSceneViewFamily& ViewFamily, const FScene& Scene, TArray<FRHIRayTracingShader*>& OutRayGenShaders)
{
	if (ViewFamily.EngineShowFlags.PathTracing
		&& ShouldCompilePathTracingShadersForProject(ViewFamily.GetShaderPlatform()))
	{
		// Declare all RayGen shaders that require material closest hit shaders to be bound
		FPathTracingRG::FPermutationDomain PermutationVector = GetPathTracingRGPermutation(Scene);
		{
			auto RayGenShader = GetGlobalShaderMap(ViewFamily.GetShaderPlatform())->GetShader<FPathTracingRG>(PermutationVector);

				RDG_EVENT_SCOPE_CONDITIONAL(GraphBuilder, NumGPUs > 1, "Path Tracing GPU%d", GPUIndex);
#if WITH_MGPU
				RDG_GPU_STAT_SCOPE(GraphBuilder, PathTracing);
#endif
				for (int32 TileY = 0; TileY < DispatchResY; TileY += DispatchSize)
				{
					for (int32 TileX = 0; TileX < DispatchResX; TileX += DispatchSize)
					{
						const int32 DispatchSizeX = FMath::Min(DispatchSize, DispatchResX - TileX);

file
function     static bool ShouldCompilePathTracingDenoiserShadersForProject

{
	static const auto CVarLocalVariablePathTracing = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PathTracing"));
	const int PathTracing = CVarLocalVariablePathTracing ? CVarLocalVariablePathTracing->GetValueOnAnyThread() : 0;

	return ShouldCompileRayTracingShadersForProject(ShaderPlatform) &&
		FDataDrivenShaderPlatformInfo::GetSupportsPathTracing(ShaderPlatform) &&
		PathTracing != 0;
}

static bool ShouldGenerateVarianceMap()
{
	int32 PathTracingTemporalDenoiserSource = CVarPathTracingTemporalDenoiserSource.GetValueOnRenderThread();
	return PathTracingTemporalDenoiserSource < 0 || PathTracingTemporalDenoiserSource > 3;

file
function     DiaphragmDOF::IsEnabled

		View.Family->EngineShowFlags.DepthOfField &&
		bDepthOfFieldRequestedByCVar &&
		!(View.Family->EngineShowFlags.PathTracing && View.FinalPostProcessSettings.PathTracingEnableReferenceDOF) &&
		((View.FinalPostProcessSettings.DepthOfFieldFstop > 0.f && View.FinalPostProcessSettings.DepthOfFieldFocalDistance > 0.f) || View.FinalPostProcessSettings.DepthOfFieldDepthBlurRadius > 0.f);
}

bool DiaphragmDOF::AddPasses(
	FRDGBuilder& GraphBuilder,
	const FSceneTextureParameters& SceneTextures,

file
function     bool IsAutoExposureUsingIlluminanceEnabled

bool IsAutoExposureUsingIlluminanceEnabled(const FViewInfo& View)
{
	// NOTE: This method cannot be supported with PathTracing because it requires a GBuffer which is not available in the path tracing case
	return CVarAutoExposureIgnoreMaterials.GetValueOnRenderThread() && GetAutoExposureMethod(View) == AEM_Histogram && !View.Family->EngineShowFlags.PathTracing;
}

int32 GetAutoExposureIlluminanceDownscaleFactor()
{
	int32 DownscaleFactor = CVarAutoExposureIgnoreMaterialsDownscaleFactor.GetValueOnRenderThread();

file
function     FScreenPassTexture AddVisualizeGBufferOverviewPass

		PostProcessMaterialInputs.SetInput(GraphBuilder, EPostProcessMaterialInput::Velocity, Inputs.Velocity);

		if (View.Family->EngineShowFlags.PathTracing && Inputs.PathTracingResources->bPostProcessEnabled)
		{
			const FPathTracingResources& PathTracingResources = *Inputs.PathTracingResources;
			
			FIntRect ViewRect = Inputs.SceneColor.ViewRect;
			PostProcessMaterialInputs.SetPathTracingInput(
				EPathTracingPostProcessMaterialInput::DenoisedRadiance, FScreenPassTexture(PathTracingResources.DenoisedRadiance, ViewRect));

file
function     bool IsIlluminanceMeterSupportedByView

bool IsIlluminanceMeterSupportedByView(const FViewInfo& View)
{
	return !IsForwardShadingEnabled(View.GetShaderPlatform()) && !View.Family->EngineShowFlags.PathTracing;
}

FScreenPassTexture AddVisualizeHDRPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FVisualizeHDRInputs& Inputs)
{
	check(Inputs.SceneColor.IsValid());
	check(Inputs.SceneColorBeforeTonemap.IsValid());

file
namespace    RayTracing
function     void OnRenderBegin

	void OnRenderBegin(FScene& Scene, TArray<FViewInfo>& Views, const FViewFamilyInfo& ViewFamily)
	{
		const ERayTracingMeshCommandsMode CurrentMode = ViewFamily.EngineShowFlags.PathTracing ? ERayTracingMeshCommandsMode::PATH_TRACING : ERayTracingMeshCommandsMode::RAY_TRACING;
		bool bNaniteCoarseMeshStreamingModeChanged = false;
#if WITH_EDITOR
		bNaniteCoarseMeshStreamingModeChanged = Nanite::FCoarseMeshStreamingManager::CheckStreamingMode();
#endif // WITH_EDITOR
		const bool bNaniteRayTracingModeChanged = Nanite::GRayTracingManager.CheckModeChanged();

file
namespace    RayTracing
function     bool GatherWorldInstancesForView

			RelevantPrimitiveList.GatherContexts,
			View.RayTracingCullingParameters,
			bool(View.Family->EngineShowFlags.PathTracing),
			RelevantPrimitiveList.NumCachedStaticSceneInstances,
			RelevantPrimitiveList.NumCachedStaticVisibleMeshCommands,
			// outputs
			RayTracingScene,
			View.VisibleRayTracingMeshCommands
		);

file
function     RayTracing::ECullingMode RayTracing::GetCullingMode

{
	// Disable culling if path tracer is used, so that path tracer matches raster view
	if (ShowFlags.PathTracing)
	{
		return ECullingMode::Disabled;
	}
	
	return (ECullingMode) FMath::Clamp(CVarRayTracingCulling.GetValueOnRenderThread(), 0, int32(ECullingMode::MAX) - 1);
}

file
function     uint8 ComputeRayTracingInstanceMask

		}
	}
	else if (MaskMode == ERayTracingViewMaskMode::PathTracing ||
		MaskMode == ERayTracingViewMaskMode::LightMapTracing)
	{
		switch (MaskType)
		{
		case ERayTracingInstanceMaskType::Opaque:
			Mask = PATHTRACER_MASK_CAMERA | PATHTRACER_MASK_INDIRECT;

file
function     FSceneProxyRayTracingMaskInfo GetSceneProxyRayTracingMaskInfo

	if (SceneViewFamily)
	{
		if (SceneViewFamily->EngineShowFlags.PathTracing)
		{
			MaskMode = ERayTracingViewMaskMode::PathTracing;
		}
	}
	else
	{
		FScene* RenderScene = PrimitiveSceneProxy.GetScene().GetRenderScene();

file
function     void SetupRayTracingMeshCommandMaskAndStatus

	// TODO: This should be done once all mesh commands for a mesh are combined (similar to BuildRayTracingInstanceMaskAndFlags(...) above)
	if (MaskMode == ERayTracingViewMaskMode::PathTracing || MaskMode == ERayTracingViewMaskMode::LightMapTracing)
	{
		if (!MaskInfo.bAffectsDynamicIndirectLighting)
		{
			// If the object does not affect indirect lighting, remove all indirect bits.
			MeshCommand.InstanceMask &= ~ComputeRayTracingInstanceMask(ERayTracingInstanceMaskType::VisibleInIndirectRay, MaskMode);
		}

{
	RayTracing,
	PathTracing,
	LightMapTracing,
};

uint8 ComputeRayTracingInstanceMask(ERayTracingInstanceMaskType MaskType, ERayTracingViewMaskMode MaskMode);

/** Compute the mask based on blend mode for different ray tracing mode*/

file
function     FRayTracingPipelineState* FDeferredShadingSceneRenderer::CreateRayTracingMaterialPipeline

	FRHICommandList& RHICmdList = GraphBuilder.RHICmdList;

	const bool bIsPathTracing = ViewFamily.EngineShowFlags.PathTracing;
	const bool bSupportMeshDecals = bIsPathTracing;

	ERayTracingPayloadType PayloadType = bIsPathTracing
		? (ERayTracingPayloadType::PathTracingMaterial | ERayTracingPayloadType::Decals)
		: ERayTracingPayloadType::RayTracingMaterial;

file
function     void FSceneRenderer::PrepareViewRectsForRendering

#if RHI_RAYTRACING
				// path tracer does its own anti-aliasing
				&& (!ViewFamily.EngineShowFlags.PathTracing)
#endif
			;

			if (!bWillApplyTemporalAA)
			{
				// Disable anti-aliasing if we are not going to be able to apply final post process effects

file
function     namespace ShadingEnergyConservation { bool IsEnable
function     void Init

	// the correct tables built & bound. Even if we are not using energy conservation, we want to 
	// have access to directional albedo information for env. lighting for instance)
	const bool bBindEnergyData = (View.ViewState != nullptr) && (bMaterialEnergyConservationEnabled || Substrate::IsSubstrateEnabled() || (View.Family->EngineShowFlags.PathTracing && RHI_RAYTRACING)) && (bIsEnergyPreservationEnabled || bIsEnergyConservationEnabled);
	if (bBindEnergyData)
	{
		// Change this to true in order to regenerate the energy tables, and manually copy the coefficients into ShadingEnergyConservationData.h
		const bool bRuntimeGeneration = false;

		const int Size = SHADING_ENERGY_CONSERVATION_TABLE_RESOLUTION;

file
function     void FSceneRenderer::InitVolumetricCloudsForViews

		{
			FMaterialRenderProxy* CloudVolumeMaterialProxy = CloudProxy.GetCloudVolumeMaterial()->GetRenderProxy();
			if (CloudVolumeMaterialProxy->GetIncompleteMaterialWithFallback(ViewFamily.GetFeatureLevel()).GetMaterialDomain() == MD_Volume && !ViewFamily.EngineShowFlags.PathTracing)
			{
				RDG_EVENT_SCOPE(GraphBuilder, "VolumetricCloudShadow");
				RDG_GPU_STAT_SCOPE(GraphBuilder, VolumetricCloudShadow);

				TRefCountPtr<IPooledRenderTarget> BlackDummy = GSystemTextures.BlackDummy;
				FRDGTextureRef BlackDummyRDG = GraphBuilder.RegisterExternalTexture(BlackDummy);

file
function     static TRDGUniformBufferRef<FRenderVolumetricCloudGlobalParameters> CreateCloudPassUniformBuffer

	}

	const bool bIsPathTracing = MainView.Family && MainView.Family->EngineShowFlags.PathTracing;
	if (CloudRC.bIsReflectionRendering 
		&& !(bIsPathTracing && CloudRC.bIsSkyRealTimeReflectionRendering))	// When using path tracing and real time sky capture, the captured sky cubemap is used to render the sky in the main view. As such, we always use the view settings.
	{
		VolumetricCloudParams.VolumetricCloud.SampleCountMax = FMath::Max(2.0f, FMath::Min(
			UVolumetricCloudComponent::BaseViewRaySampleCount * CloudInfo.GetVolumetricCloudSceneProxy().ReflectionViewSampleCountScale,
			CVarVolumetricCloudReflectionRaySampleMaxCount.GetValueOnAnyThread()));