RaytracingOptions.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    RaytracingOptions.h declares ray tracing options for use in rendering
=============================================================================*/
 
#pragma once
 
#include "RHIDefinitions.h"
#include "RayTracingPayloadType.h"
 
class FSkyLightSceneProxy;
class FViewInfo;
class FLightSceneInfoCompact;
class FLightSceneInfo;
class FScene;
class FSceneView;
class FSceneViewFamily;
class FLightSceneProxy;
enum EShaderPlatform : uint16;
struct FEngineShowFlags;
 
// be sure to also update the definition in the `RayTracingPrimaryRays.usf`
enum class ERayTracingPrimaryRaysFlag: uint32 
{
    None                      =      0,
    UseGBufferForMaxDistance  = 1 << 0,
    PrimaryView               = 1 << 1,
    AllowSkipSkySample        = 1 << 2,
};
 
ENUM_CLASS_FLAGS(ERayTracingPrimaryRaysFlag);
 
struct FRayTracingPrimaryRaysOptions
{
    bool bEnabled;
    bool bForceOpaque;
    int32 SamplerPerPixel;
    int32 ApplyHeightFog;
    float PrimaryRayBias;
    float MaxRoughness;
    int32 MaxRefractionRays;
    int32 EnableEmmissiveAndIndirectLighting;
    int32 EnableDirectLighting;
    int32 EnableShadows;
    int32 ShadowsTranslucencyType;
    float MinRayDistance;
    float MaxRayDistance;
    int32 EnableRefraction;
};
 
enum class ERayTracingPipelineCompatibilityFlags
{
    // Rendering feature can use the full ray tracing pipeline, with raygen, hit and miss shaders.
    FullPipeline = 1 << 0,
 
    // Rendering feature can use inline ray tracing
    Inline  = 1 << 1,
};
ENUM_CLASS_FLAGS(ERayTracingPipelineCompatibilityFlags);
 
namespace RayTracing
{
    // Keep in sync with r.RayTracing.Culling
    enum class ECullingMode : uint8
    {
        Disabled,
        BehindCameraByDistanceAndSolidAngle,
        DistanceAndSolidAngle,
        DistanceOrSolidAngle,
 
        MAX
    };
}
 
#if RHI_RAYTRACING
 
// Whether a particular effect should be used, taking into account debug override
extern bool ShouldRenderRayTracingEffect(bool bEffectEnabled, ERayTracingPipelineCompatibilityFlags CompatibilityFlags, const FSceneView& View);
extern bool ShouldRenderRayTracingEffect(bool bEffectEnabled, ERayTracingPipelineCompatibilityFlags CompatibilityFlags, const FSceneViewFamily& ViewFamily);
extern bool ShouldRenderRayTracingSkyLightEffect();
 
extern bool AnyInlineRayTracingPassEnabled(const FScene* Scene, const FViewInfo& View);
extern FRayTracingPrimaryRaysOptions GetRayTracingTranslucencyOptions(const FViewInfo& View);
 
extern bool ShouldRenderRayTracingSkyLight(const FSkyLightSceneProxy* SkyLightSceneProxy, EShaderPlatform ShaderPlatform);
extern bool ShouldRenderRayTracingAmbientOcclusion(const FViewInfo& View);
extern bool ShouldRenderRayTracingTranslucency(const FViewInfo& View);
extern bool ShouldRenderRayTracingShadows(const FSceneViewFamily& ViewFamily);
extern bool ShouldRenderRayTracingShadowsForLight(const FSceneViewFamily& ViewFamily, const FLightSceneProxy& LightProxy);
extern bool ShouldRenderRayTracingShadowsForLight(const FSceneViewFamily& ViewFamily, const FLightSceneInfoCompact& LightInfo);
extern bool ShouldRenderPluginRayTracingGlobalIllumination(const FViewInfo& View);
extern bool HasRayTracedOverlay(const FSceneViewFamily& ViewFamily);
 
namespace RayTracing
{
    extern ECullingMode GetCullingMode(const FEngineShowFlags& ShowFlags);
}
 
extern bool EnableRayTracingShadowTwoSidedGeometry();
extern float GetRaytracingMaxNormalBias();
extern float GetRayTracingCullingRadius();
extern bool IsRayTracingInstanceDebugDataEnabled(const FViewInfo& View);
extern bool IsRayTracingInstanceOverlapEnabled(const FViewInfo& View);
extern bool RaytracingDebugViewModeNeedsTonemapping(const FSceneView& View);
extern bool IsRayTracingFeedbackEnabled(const FSceneViewFamily& ViewFamily);
 
extern bool CanUseRayTracingAMDHitToken();
 
#else // RHI_RAYTRACING
 
FORCEINLINE bool ShouldRenderRayTracingEffect(bool bEffectEnabled, ERayTracingPipelineCompatibilityFlags CompatibilityFlags, const FSceneView& View)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingEffect(bool bEffectEnabled, ERayTracingPipelineCompatibilityFlags CompatibilityFlags, const FSceneViewFamily& ViewFamily)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingSkyLightEffect()
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingSkyLight(const FSkyLightSceneProxy* SkyLightSceneProxy, EShaderPlatform ShaderPlatform)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingAmbientOcclusion(const FViewInfo& View)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingTranslucency(const FViewInfo& View)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingShadows(const FSceneViewFamily& ViewFamily)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingShadowsForLight(const FSceneViewFamily& ViewFamily, const FLightSceneProxy& LightProxy)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderRayTracingShadowsForLight(const FSceneViewFamily& ViewFamily, const FLightSceneInfoCompact& LightInfo)
{
    return false;
}
 
FORCEINLINE bool ShouldRenderPluginRayTracingGlobalIllumination(const FViewInfo& View)
{
    return false;
}
 
FORCEINLINE bool HasRayTracedOverlay(const FSceneViewFamily& ViewFamily)
{
    return false;
}
 
namespace RayTracing
{
    FORCEINLINE ECullingMode GetCullingMode(const FEngineShowFlags& ShowFlags)
    {
        return ECullingMode::Disabled;
    }
}
 
FORCEINLINE float GetRayTracingCullingRadius()
{
    return 0.0;
}
 
FORCEINLINE bool CanUseRayTracingAMDHitToken()
{
    return false;
}
 
FORCEINLINE bool IsRayTracingInstanceDebugDataEnabled(const FViewInfo& View)
{
    return false;
}
 
FORCEINLINE bool IsRayTracingInstanceOverlapEnabled(const FViewInfo& View)
{
    return false;
}
 
FORCEINLINE bool IsRayTracingFeedbackEnabled(const FSceneViewFamily& ViewFamily)
{
    return false;
}
 
FORCEINLINE bool RaytracingDebugViewModeNeedsTonemapping(const FViewInfo& View)
{
    return false;
}
 
#endif // RHI_RAYTRACING