OK, // Ray tracing is supported and running
	DISABLED_BY_PROJECT_SETTINGS, // "Ray Tracing" or "Support Compute Skin Cache" is off in project settings
	DISABLED_BY_TARGET_PLATFORM, // FXXXTargetPlatform::UsesRayTracing() returns false (eg. WindowsTargetPlatform checks for bEnableRayTracing in its ini)
	INCOMPATIBLE_SHADER_PLATFORM, // An incompatible shader platform is chosen (eg. ES3.1)
	INCAPABLE_RHI, // The RHI is incapable of ray tracing in general (eg. DX11)
	INCOMPATIBLE_PLUGIN, // An incompatible plugin is enabled (specifically, RenderDoc)
	INCAPABLE_HARDWARE, // The video card isn't capable of hardware ray tracing (too old), or supports only software emulated ray tracing (GTX 10 series)
};

file
function     void UPatternTool::EmitResults
lambda-function

				NewMeshObjectParams.bEnableCollision = ModelingSettings->bEnableCollision;
				NewMeshObjectParams.CollisionMode = ModelingSettings->CollisionMode;
				NewMeshObjectParams.bEnableRaytracingSupport = ModelingSettings->bEnableRayTracing;

				FCreateMeshObjectResult Result = UE::Modeling::CreateMeshObject(GetToolManager(), MoveTemp(NewMeshObjectParams));
				return Result;
			};

file
function     void UModelingComponentsSettings::ApplyDefaultsToCreateMeshObjectParams

		Params.CollisionMode = Settings->CollisionMode;
		Params.bGenerateLightmapUVs = Settings->bGenerateLightmapUVs;
		Params.bEnableRaytracingSupport = Settings->bEnableRayTracing;
	}
}

#undef LOCTEXT_NAMESPACE

file
class        class UModelingComponentsSettings : public UDeveloperSettings

	/** Enable Raytracing Support for new Mesh Objects created by Modeling Tools, if support is optional (eg DynamicMeshActors) */
	UPROPERTY(config, EditAnywhere, Category = "Modeling Tools|New Mesh Objects")
	bool bEnableRayTracing = false;

	/** Enable auto-generated Lightmap UVs for new Mesh Objects created by Modeling Tools, where supported */
	UPROPERTY(config, EditAnywhere, Category = "Modeling Tools|New Mesh Objects")
	bool bGenerateLightmapUVs = false;

	/** Enable Collision Support for new Mesh Objects created by Modeling Tools */

file
class        class FAndroidTargetPlatformSettings : public TTargetPlatformSettingsBase<FAndroidPlatformProperties>
function     virtual bool UsesRayTracing

	virtual bool UsesRayTracing() const override
	{
		bool bEnableRayTracing = false;
		GConfig->GetBool(TEXT("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings"), TEXT("bEnableRayTracing"), bEnableRayTracing, GEngineIni);

		return bEnableRayTracing;
	}

#if WITH_ENGINE
	virtual void GetReflectionCaptureFormats(TArray<FName>& OutFormats) const override;
	virtual const UTextureLODSettings& GetTextureLODSettings() const override;
	virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override

file
class        class TGenericMacTargetPlatform : public TTargetPlatformBase<FMacPlatformProperties<HAS_EDITOR_DATA, IS_DEDICATED_SERVER, IS_CLIENT_ONLY> >
function     virtual bool UsesRayTracing

	virtual bool UsesRayTracing() const override
	{
		bool bEnableRayTracing = false;
		GConfig->GetBool(TEXT("/Script/MacTargetPlatform.MacTargetSettings"), TEXT("bEnableRayTracing"), bEnableRayTracing, GEngineIni);
	 
		return bEnableRayTracing;
	}
	//~ End ITargetPlatform Interface

private:

	// Holds the local device.

file
class        class TGenericWindowsTargetPlatform : public TTargetPlatformBase<TProperties>
function     virtual bool UsesRayTracing

	virtual bool UsesRayTracing() const override
	{
		bool bEnableRayTracing = false;
		GConfig->GetBool(TEXT("/Script/WindowsTargetPlatform.WindowsTargetSettings"), TEXT("bEnableRayTracing"), bEnableRayTracing, GEngineIni);

		return bEnableRayTracing && TSuper::UsesRayTracing();
	}

	//~ End ITargetPlatform Interface

private:

file
class        class URendererSettings : public UDeveloperSettings

		ToolTip = "Support Hardware Ray Tracing features.  Requires 'Support Compute Skincache' before project is allowed to set this.",
		ConfigRestartRequired = true))
		uint32 bEnableRayTracing : 1;

	UPROPERTY(config, EditAnywhere, Category = HardwareRayTracing, meta = (
		ConsoleVariable = "r.RayTracing.Shadows", DisplayName = "Ray Traced Shadows",
		ToolTip = "Controls whether Ray Traced Shadows are used by default. Lights can still override and force Ray Traced shadows on or off. Requires Hardware Ray Tracing to be enabled."))
		uint32 bEnableRayTracingShadows : 1;

file
function     URendererSettings::URendererSettings

	GPUSimulationTextureSizeX = 1024;
	GPUSimulationTextureSizeY = 1024;
	bEnableRayTracing = 0;
	bUseHardwareRayTracingForLumen = 0;
	bEnableRayTracingShadows = 0;
	bEnablePathTracing = 0;
	bEnableRayTracingTextureLOD = 0;
	DefaultBoneInfluenceLimit = 0;
	MaxSkinBones = FGPUBaseSkinVertexFactory::GHardwareMaxGPUSkinBones;

file
function     void URendererSettings::PostEditChangeProperty

		}

		if (PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(URendererSettings, bEnableRayTracing) 
			&& bEnableRayTracing 
			&& !bSupportSkinCacheShaders)
		{
			FString FullPath = FPaths::ConvertRelativePathToFull(GetDefaultConfigFilename());
			FPlatformFileManager::Get().GetPlatformFile().SetReadOnly(*FullPath, false);

			if (FMessageDialog::Open(EAppMsgType::YesNo, LOCTEXT("Skin Cache Disabled", "Ray Tracing requires enabling skin cache. Do you want to automatically enable skin cache now?")) == EAppReturnType::Yes)

file
function     void URendererSettings::PostEditChangeProperty

			else
			{
				bEnableRayTracing = 0;
				UpdateDependentPropertyInConfigFile(this, GET_MEMBER_NAME_CHECKED(URendererSettings, bEnableRayTracing));
			}
		}

		if (PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(URendererSettings, bSupportSkinCacheShaders)
			&& !bSupportSkinCacheShaders
			&& bSkipCompilingGPUSkinVF)

file
function     bool URendererSettings::CanEditChange

	{
		//only allow DISABLE of skincache shaders if raytracing is also disabled as skincache is a dependency of raytracing.
		return !bSupportSkinCacheShaders || !bEnableRayTracing;
	}

	// the bSkipCompilingGPUSkinVF setting can only be edited if the skin cache is on.
	if ((InProperty->GetFName() == GET_MEMBER_NAME_CHECKED(URendererSettings, bSkipCompilingGPUSkinVF)))
	{
		return bSupportSkinCacheShaders;

file
function     bool URendererSettings::CanEditChange

		(InProperty->GetFName() == GET_MEMBER_NAME_CHECKED(URendererSettings, bEnableRayTracingTextureLOD)))
	{
		return bEnableRayTracing;
	}

	if ((InProperty->GetFName() == GET_MEMBER_NAME_CHECKED(URendererSettings, bSupportSkyAtmosphereAffectsHeightFog)))
	{
		return bSupportSkyAtmosphere;
	}

file
function     void URendererSettings::CheckForMissingShaderModels

#if PLATFORM_WINDOWS || PLATFORM_LINUX
	static IConsoleVariable* RayTracingRequireSM6CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.RayTracing.RequireSM6"));
	const bool bRayTracingRequireSM6 = bEnableRayTracing && RayTracingRequireSM6CVar && RayTracingRequireSM6CVar->GetBool();

	if (GIsEditor && (ShadowMapMethod == EShadowMapMethod::VirtualShadowMaps || bRayTracingRequireSM6))
	{
		auto CopySM6Format = [](const TCHAR* ShaderFormatName, const TArray<FString>& SrcArray, TArray<FString>& DstArray)
		{
			if (SrcArray.Contains(ShaderFormatName))

file
function     void FDeferredShadingSceneRenderer::RenderLights

	const bool bUseHairLighting = HairStrands::HasViewHairStrandsData(Views);
#if RHI_RAYTRACING
	const bool bEnableRayTracing = true;
#else
	const bool bEnableRayTracing = false;
#endif // RHI_RAYTRACING
	const bool bUseLightFunctionAtlas = LightFunctionAtlas::IsEnabled(*Scene, ELightFunctionAtlasSystem::DeferredLighting);

	RDG_EVENT_SCOPE(GraphBuilder, "Lights");
	RDG_GPU_STAT_SCOPE(GraphBuilder, Lights);

file
function     void FDeferredShadingSceneRenderer::RenderLights

			// function was converted to render graph, and want least intrusive change as possible. So right now it trades render target memory pressure
			// for denoising perf.
			if (bEnableRayTracing && bDoShadowBatching)
			{
				const uint32 ViewIndex = 0;
				FViewInfo& View = Views[ViewIndex];

				const int32 NumShadowedLights = ManyLightsLightStart - UnbatchedLightStart;
				// Allocate PreprocessedShadowMaskTextures once so QueueTextureExtraction can deferred write.

		/// </summary>
		[ConfigFile(ConfigHierarchyType.Engine, "/Script/AndroidTargetPlatform.AndroidTargetSettings")]
		public bool bEnableRayTracing = false;

		/// <summary>
		/// Enables ASIS plugin and STANDALONE support.
		/// </summary>
		[ConfigFile(ConfigHierarchyType.Engine, "/Script/AndroidSingleInstanceServiceEditor.AndroidSingleInstanceServiceRuntimeSettings")]
		public bool bEnableASISPlugin = false;

		/// </summary>
		[ConfigFile(ConfigHierarchyType.Engine, "/Script/LinuxTargetPlatform.LinuxTargetSettings")]
		public bool bEnableRayTracing = false;
	}

	/// <summary>
	/// Read-only wrapper for Linux-specific target settings
	/// </summary>
	public class ReadOnlyLinuxTargetRules

		/// Enables runtime ray tracing support.
		/// </summary>
		[ConfigFile(ConfigHierarchyType.Engine, "/Script/MacTargetPlatform.MacTargetSettings", "bEnableRayTracing")]
		public bool bEnableRayTracing = false;
	}

	/// <summary>
	/// Read-only wrapper for Mac-specific target settings
	/// </summary>

		/// Enables runtime ray tracing support.
		/// </summary>
		[ConfigFile(ConfigHierarchyType.Engine, "/Script/WindowsTargetPlatform.WindowsTargetSettings", "bEnableRayTracing")]
		public bool bEnableRayTracing = false;

		/// <summary>
		/// The name of the company (author, provider) that created the project.
		/// </summary>
		[ConfigFile(ConfigHierarchyType.Game, "/Script/EngineSettings.GeneralProjectSettings", "CompanyName")]