RenderUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "RHIFwd.h"
#include "RHIShaderPlatform.h"
#include "RHIFeatureLevel.h"
#include "ReadOnlyCVARCache.h"
 
class ITargetPlatform;
class ITargetPlatformSettings;
struct IPooledRenderTarget;
enum class ERayTracingMode : uint8;
 
extern RENDERCORE_API void RenderUtilsInit();
 
#define NUM_DEBUG_UTIL_COLORS (32)
inline constexpr FColor DebugUtilColor[NUM_DEBUG_UTIL_COLORS] = 
{
    FColor(20,226,64),
    FColor(210,21,0),
    FColor(72,100,224),
    FColor(14,153,0),
    FColor(186,0,186),
    FColor(54,0,175),
    FColor(25,204,0),
    FColor(15,189,147),
    FColor(23,165,0),
    FColor(26,206,120),
    FColor(28,163,176),
    FColor(29,0,188),
    FColor(130,0,50),
    FColor(31,0,163),
    FColor(147,0,190),
    FColor(1,0,109),
    FColor(2,126,203),
    FColor(3,0,58),
    FColor(4,92,218),
    FColor(5,151,0),
    FColor(18,221,0),
    FColor(6,0,131),
    FColor(7,163,176),
    FColor(8,0,151),
    FColor(102,0,216),
    FColor(10,0,171),
    FColor(11,112,0),
    FColor(12,167,172),
    FColor(13,189,0),
    FColor(16,155,0),
    FColor(178,161,0),
    FColor(19,25,126)
};
 
#define NUM_CUBE_VERTICES 36
 
extern RENDERCORE_API const uint16 GCubeIndices[36];
 
inline uint16 GetCubeVertexIndex(uint32 X,uint32 Y,uint32 Z) { return (uint16)(X * 4 + Y * 2 + Z); }
 
struct FPackedPosition
{
    union
    {
        struct
        {
#if PLATFORM_LITTLE_ENDIAN
            int32   X : 11;
            int32   Y : 11;
            int32   Z : 10;
#else
            int32   Z : 10;
            int32   Y : 11;
            int32   X : 11;
#endif
        } Vector;
 
        uint32      Packed;
    };
 
    // Constructors.
    FPackedPosition() : Packed(0) {}
    FPackedPosition(const FVector3f& Other) : Packed(0) 
    {
        Set(Other);
    }
    FPackedPosition(const FVector3d& Other) : Packed(0) 
    {
        Set(Other);
    }
    
    // Conversion operators.
    FPackedPosition& operator=( FVector3f Other )
    {
        Set( Other );
        return *this;
    }
    FPackedPosition& operator=( FVector3d Other )
    {
        Set( Other );
        return *this;
    }
 
    operator FVector3f() const;
    VectorRegister GetVectorRegister() const;
 
    // Set functions.
    void Set(const FVector3f& InVector);
    void Set(const FVector3d& InVector);
 
    // Serializer.
    friend FArchive& operator<<(FArchive& Ar,FPackedPosition& N);
};
 
 
enum EConstructTextureFlags : uint32
{
    CTF_Compress =              0x01,
    CTF_DeferCompression =      0x02,
    CTF_SRGB =                  0x04,
    CTF_AllowMips =             0x08,
    CTF_ForceOneBitAlpha =      0x10,
    CTF_RemapAlphaAsMasked =    0x20,
    CTF_ForceOpaque =           0x40,
    CTF_SkipPostEdit =          0x80,
 
    CTF_Default = CTF_Compress | CTF_SRGB,
};
 
RENDERCORE_API SIZE_T CalcTextureMipMapSize3D( uint32 TextureSizeX, uint32 TextureSizeY, uint32 TextureSizeZ, EPixelFormat Format, uint32 MipIndex);
 
RENDERCORE_API void CalcMipMapExtent3D( uint32 TextureSizeX, uint32 TextureSizeY, uint32 TextureSizeZ, EPixelFormat Format, uint32 MipIndex, uint32& OutXExtent, uint32& OutYExtent, uint32& OutZExtent );
 
RENDERCORE_API FIntPoint CalcMipMapExtent( uint32 TextureSizeX, uint32 TextureSizeY, EPixelFormat Format, uint32 MipIndex );
 
RENDERCORE_API SIZE_T CalcTextureMipMapSize( uint32 TextureSizeX, uint32 TextureSizeY, EPixelFormat Format, uint32 MipIndex );
 
RENDERCORE_API SIZE_T CalcTextureSize( uint32 SizeX, uint32 SizeY, EPixelFormat Format, uint32 MipCount );
 
RENDERCORE_API SIZE_T CalcTextureSize3D( uint32 SizeX, uint32 SizeY, uint32 SizeZ, EPixelFormat Format, uint32 MipCount );
 
RENDERCORE_API void CopyTextureData2D(const void* Source,void* Dest,uint32 SizeY,EPixelFormat Format,uint32 SourceStride,uint32 DestStride);
 
RENDERCORE_API EPixelFormatChannelFlags GetPixelFormatValidChannels(EPixelFormat InPixelFormat);
 
 
RENDERCORE_API const TCHAR* GetCubeFaceName(ECubeFace Face);
 
RENDERCORE_API ECubeFace GetCubeFaceFromName(const FString& Name);
 
RENDERCORE_API FVertexDeclarationRHIRef& GetVertexDeclarationFVector4();
 
RENDERCORE_API FVertexDeclarationRHIRef& GetVertexDeclarationFVector3();
 
RENDERCORE_API FVertexDeclarationRHIRef& GetVertexDeclarationFVector2();
 
inline bool IsMobileHDR()
{
    return FReadOnlyCVARCache::MobileHDR();
}
 
inline bool MobileSupportsGPUScene()
{
    return FReadOnlyCVARCache::MobileSupportsGPUScene();
}
 
inline bool IsMobileDeferredShadingEnabled(const FStaticShaderPlatform Platform)
{
    return FReadOnlyCVARCache::MobileDeferredShading(Platform) && IsMobileHDR();
}
 
inline bool MobileForwardEnableLocalLights(const FStaticShaderPlatform Platform)
{
    return FReadOnlyCVARCache::MobileForwardLocalLights(Platform) > 0;
}
 
inline bool MobileForwardEnableParticleLights(const FStaticShaderPlatform Platform)
{
    return MobileForwardEnableLocalLights(Platform) && FReadOnlyCVARCache::MobileForwardParticleLights(Platform);
}
 
RENDERCORE_API bool PlatformGPUSceneUsesUniformBufferView(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileRequiresSceneDepthAux(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileAllowFramebufferFetch(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool SupportsTextureCubeArray(ERHIFeatureLevel::Type FeatureLevel);
 
RENDERCORE_API bool MaskedInEarlyPass(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool AllowPixelDepthOffset(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool AllowPerPixelShadingModels(const FStaticShaderPlatform Platform);
 
RENDERCORE_API uint32 GetPlatformShadingModelsMask(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsMobileAmbientOcclusionEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool AreMobileScreenSpaceReflectionsEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsMobileDistanceFieldEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsMobileMovableSpotlightShadowsEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsMobileCapsuleShadowsEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsMobileCapsuleDirectShadowsEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileForwardEnableClusteredReflections(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileUsesShadowMaskTexture(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileUsesExtenedGBuffer(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileUsesGBufferCustomData(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileBasePassAlwaysUsesCSM(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileUsesFullDepthPrepass(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool MobileSupportsSM5MaterialNodes(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool ShouldForceFullDepthPass(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool SupportsGen4TAA(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool SupportsTSR(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool PlatformSupportsVelocityRendering(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsUsingDBuffers(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsForwardShadingEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool ForwardShadingForcesSkyLightCubemapBlending(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsUsingGBuffers(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsUsingBasePassVelocity(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsUsingSelectiveBasePassOutputs(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsUsingDistanceFields(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsWaterDistanceFieldShadowEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsWaterSeparateMainDirLightEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsMobileDistanceFieldAOEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool IsStencilForLODDitherEnabled(const FStaticShaderPlatform Platform);
 
RENDERCORE_API int32 GetMaterialShadingPathNodeOverride(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool UseGPUScene(const FStaticShaderPlatform Platform, const FStaticFeatureLevel FeatureLevel);
 
RENDERCORE_API bool UseGPUScene(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool ForceSimpleSkyDiffuse(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool VelocityEncodeDepth(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool VelocityEncodeHasPixelAnimation(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool VelocitySupportsTemporalResponsiveness(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool VelocitySupportsPixelShaderMotionVectorWorldOffset(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool PlatformSupportsOpenXRMotionVectors(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool VelocityIncludeStationaryPrimitives(const FStaticShaderPlatform Platform);
 
RENDERCORE_API FBufferRHIRef& GetUnitCubeVertexBuffer();
 
RENDERCORE_API FBufferRHIRef& GetUnitCubeIndexBuffer();
 
RENDERCORE_API FBufferRHIRef& GetUnitCubeAABBVertexBuffer();
 
RENDERCORE_API void QuantizeSceneBufferSize(const FIntPoint& InBufferSize, FIntPoint& OutBufferSize, const uint32 SuggestedDivisor = 0);
 
RENDERCORE_API bool UseVirtualTexturing(const FStaticShaderPlatform InShaderPlatform);
RENDERCORE_API bool UseVirtualTexturing(const ITargetPlatformSettings* InTargetPlatform);
RENDERCORE_API bool UseVirtualTexturing(const FStaticShaderPlatform InShaderPlatform, const ITargetPlatformSettings* InTargetPlatform);
 
RENDERCORE_API bool NaniteAtomicsSupported();
RENDERCORE_API bool NaniteWorkGraphMaterialsSupported();
RENDERCORE_API bool NaniteSplineMeshesSupported();
RENDERCORE_API bool NaniteSkinnedMeshesSupported();
RENDERCORE_API bool NaniteAssembliesSupported();
RENDERCORE_API bool NaniteVoxelsSupported();
 
RENDERCORE_API bool UseNaniteFastTileClear();
RENDERCORE_API bool UseNaniteTessellation();
 
RENDERCORE_API bool DoesPlatformSupportNanite(EShaderPlatform Platform, bool bCheckForProjectSetting = true);
RENDERCORE_API bool DoesRuntimeSupportNanite(EShaderPlatform ShaderPlatform, bool bCheckForAtomicSupport, bool bCheckForProjectSetting);
RENDERCORE_API bool DoesTargetPlatformSupportNanite(const ITargetPlatform* TargetPlatform);
 
RENDERCORE_API bool UseNanite(EShaderPlatform ShaderPlatform, bool bCheckForAtomicSupport = true, bool bCheckForProjectSetting = true);
 
RENDERCORE_API bool AreNaniteFallbackMeshesEnabledForPlatform(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool UseVirtualShadowMaps(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool UseVirtualShadowMaps(EShaderPlatform ShaderPlatform, const FStaticFeatureLevel FeatureLevel);
 
RENDERCORE_API bool DoesPlatformSupportVirtualShadowMaps(EShaderPlatform Platform);
 
RENDERCORE_API bool DoesPlatformSupportNonNaniteVirtualShadowMaps(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool UseNonNaniteVirtualShadowMaps(EShaderPlatform ShaderPlatform, FStaticFeatureLevel FeatureLevel);
 
RENDERCORE_API bool IsWaterVirtualShadowMapFilteringEnabled(const FStaticShaderPlatform Platform);
 
/*
 * Detect (at runtime) if the runtime supports heterogeneous volumes.
 */
RENDERCORE_API bool DoesRuntimeSupportHeterogeneousVolumes(EShaderPlatform Platform);
 
RENDERCORE_API bool DoesPlatformSupportHeterogeneousVolumes(EShaderPlatform Platform);
 
RENDERCORE_API bool DoesPlatformSupportSparseVolumeTextures(EShaderPlatform Platform);
 
RENDERCORE_API bool UseSparseVolumeTextures(EShaderPlatform Platform);
 
RENDERCORE_API bool IsSingleLayerWaterDepthPrepassEnabled(const FStaticShaderPlatform Platform, FStaticFeatureLevel FeatureLevel);
 
RENDERCORE_API bool UseVirtualTextureLightmap(const FStaticShaderPlatform Platform, const ITargetPlatformSettings* TargetPlatform = nullptr);
 
RENDERCORE_API bool UseNaniteLandscapeMesh(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool ExcludeNonPipelinedShaderTypes(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool UseShaderPipelines(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool UseRemoveUnsedInterpolators(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool AreSkinCacheShadersEnabled(EShaderPlatform Platform);
 
RENDERCORE_API bool IsGPUSkinCacheAllowed(EShaderPlatform Platform);
 
RENDERCORE_API bool IsGPUSkinCacheAvailable(EShaderPlatform Platform);
 
RENDERCORE_API bool IsGPUSkinPassThroughSupported(EShaderPlatform Platform);
 
RENDERCORE_API bool AreBufferSRVsAlwaysCreatedByDefault(EShaderPlatform ShaderPlatform);
 
/*
 * Detect (at runtime) if the runtime supports rendering one-pass point light shadows (i.e., cube maps)
 */
RENDERCORE_API bool DoesRuntimeSupportOnePassPointLightShadows(EShaderPlatform Platform);
 
RENDERCORE_API bool AllowTranslucencyPerObjectShadows(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool Allow128BitBasePassPSCompilation(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool PlatformRequires128bitRT(EPixelFormat PixelFormat);
 
RENDERCORE_API bool IsRayTracingEnabledForProject(EShaderPlatform ShaderPlatform);
RENDERCORE_API bool ShouldCompileRayTracingShadersForProject(EShaderPlatform ShaderPlatform);
RENDERCORE_API bool ShouldCompileRayTracingCallableShadersForProject(EShaderPlatform ShaderPlatform);
 
// Returns `true` when running on RT-capable machine, RT support is enabled for the project and by game graphics options and RT is enabled with r.Raytracing.Enable
// This function may only be called at runtime, never during cooking.
extern RENDERCORE_API bool IsRayTracingEnabled();
 
// Returns 'true' when running on RT-capable machine, RT support is enabled for the project and by game graphics options and ShaderPlatform supports RT and RT is enabled with r.Raytracing.Enable
// This function may only be called at runtime, never during cooking.
RENDERCORE_API bool IsRayTracingEnabled(EShaderPlatform ShaderPlatform);
 
// Returns 'true' when running on RT-capable machine, RT support is enabled for the project and by game graphics options
// This function may only be called at runtime, never during cooking.
extern RENDERCORE_API bool IsRayTracingAllowed();
 
// Returns the ray tracing mode if ray tracing is allowed.
// This function may only be called at runtime, never during cooking.
extern RENDERCORE_API ERayTracingMode GetRayTracingMode();
 
// Returns 'true' when using TLAS references to determine ray tracing geometry residency
// In which case the runtime should track which ray tracing geometries are referenced in the TLAS
RENDERCORE_API bool IsRayTracingUsingReferenceBasedResidency();
 
// Returns 'true' when ray tracing can be toggled on/off at runtime.
RENDERCORE_API bool IsRayTracingEnableOnDemandSupported();
 
RENDERCORE_API bool ShouldGenerateRayTracingProxiesByDefault();
 
// Returns 'true' when static lighting is enabled for the project
inline bool IsStaticLightingAllowed()
{
    return FReadOnlyCVARCache::AllowStaticLighting();
}
 
// Returns 'true' when first person primitives are tagged in the GBuffer.
RENDERCORE_API bool HasFirstPersonGBufferBit(EShaderPlatform ShaderPlatform);
 
RENDERCORE_API bool DoesProjectSupportLumenGI(EShaderPlatform Platform);
 
extern RENDERCORE_API bool DoesPlatformSupportLumenGI(EShaderPlatform Platform, bool bSkipProjectCheck = false);
extern RENDERCORE_API bool DoesProjectSupportLumenRayTracedTranslucentRefraction();
 
RENDERCORE_API bool DoesProjectSupportExpFogMatchesVolumetricFog();
 
RENDERCORE_API bool UseSplineMeshSceneResources(const FStaticShaderPlatform Platform);
 
RENDERCORE_API bool RenderRectLightsAsSpotLights(const FStaticFeatureLevel FeatureLevel);
 
namespace Substrate
{
    RENDERCORE_API bool IsSubstrateEnabled();
    RENDERCORE_API bool IsSubstrateBlendableGBufferEnabled(EShaderPlatform InPlatform);
    RENDERCORE_API bool IsStochasticLightingEnabled(EShaderPlatform InPlatform);
    RENDERCORE_API bool IsRoughDiffuseEnabled();
    RENDERCORE_API bool IsRoughDiffuseEnabled(EShaderPlatform InPlatform);
    UE_DEPRECATED(5.7, "Plase use IsGlintEnabled(EShaderPlatform InPlatform)")
    RENDERCORE_API bool IsGlintEnabled();
    RENDERCORE_API bool IsGlintEnabled(EShaderPlatform InPlatform);
    RENDERCORE_API uint32 GlintLUTIndex();
    RENDERCORE_API float GlintLevelBias();
    RENDERCORE_API float GlintLevelMin();
    RENDERCORE_API bool IsSpecularProfileEnabled();
    RENDERCORE_API bool IsSpecularProfileEnabled(EShaderPlatform InPlatform);
    RENDERCORE_API bool IsDBufferPassEnabled(EShaderPlatform InPlatform);
    RENDERCORE_API bool IsOpaqueRoughRefractionEnabled(EShaderPlatform InPlatform);
    UE_DEPRECATED(5.7, "Plase use IsAdvancedVisualizationEnabled(EShaderPlatform InPlatform)")
    RENDERCORE_API bool IsAdvancedVisualizationEnabled();
    RENDERCORE_API bool IsAdvancedVisualizationEnabled(EShaderPlatform InPlatform);
    RENDERCORE_API bool IsMaterialLayeringSupportEnabled();
 
    RENDERCORE_API bool IsHiddenMaterialAssetConversionEnabled();
 
    RENDERCORE_API bool AreLightingPassesTiled();
 
    RENDERCORE_API uint32 GetRayTracingMaterialPayloadSizeInBytes(bool bFullySimplifiedMaterial);
 
    RENDERCORE_API uint32 GetBytePerPixel(EShaderPlatform InPlatform);
    RENDERCORE_API uint32 GetClosurePerPixel(EShaderPlatform InPlatform);
 
    RENDERCORE_API uint32 GetNormalQuality();
 
    RENDERCORE_API uint32 GetSheenQuality();
    RENDERCORE_API uint32 GetSheenQuality(EShaderPlatform InPlatform);
 
    RENDERCORE_API uint32 GetShadingQuality();
    RENDERCORE_API uint32 GetShadingQuality(EShaderPlatform InPlatform);
}
 
// Light function atlas settings
RENDERCORE_API int32 GetLightFunctionAtlasFormat();
// Light function atlas project settings triggering shader compilation
RENDERCORE_API bool GetSingleLayerWaterUsesLightFunctionAtlas();
RENDERCORE_API bool GetTranslucentUsesLightFunctionAtlas();
RENDERCORE_API bool GetTranslucentUsesLightRectLights();
RENDERCORE_API bool GetTranslucentUsesLightIESProfiles();
RENDERCORE_API bool GetTranslucentUsesShadowedLocalLights();
 
RENDERCORE_API bool GetHairStrandsUsesTriangleStrips();
RENDERCORE_API uint32 GetHairStrandsLODMode();
 
// Helper function to calculate Z params for froxel grids
// Used in shaders with ComputeDepthFromZSlice(...)
inline FVector CalculateGridZParams(float NearPlane, float FarPlane, float DepthDistributionScale, int32 GridSizeZ)
{
    // S = distribution scale
    // B, O are solved for given the z distances of the first+last slice, and the # of slices.
    //
    // slice = log2(z*B + O) * S
 
    // Don't spend lots of resolution right in front of the near plane
    double NearOffset = .095 * 100;
    // Space out the slices so they aren't all clustered at the near plane
    double S = DepthDistributionScale;
 
    double N = NearPlane + NearOffset;
    double F = FarPlane;
 
    double O = (F - N * FMath::Exp2(GridSizeZ / S)) / (F - N);
    double B = (1 - O) / N;
 
    return FVector(B, O, S);
}
 
// LuminanceMax is the amount of light that will cause the sensor to saturate at EV100.
//  See also https://en.wikipedia.org/wiki/Film_speed and https://en.wikipedia.org/wiki/Exposure_value for more info.
inline float EV100ToLuminance(float LuminanceMax, float EV100)
{
    return LuminanceMax * FMath::Pow(2.0f, EV100);
}
 
inline float EV100ToLuminance(float EV100)
{
    // LuminanceMax set to 1 for lighting to be unitless (1.0cd/m^2 becomes 1.0 at EV100)
    return EV100ToLuminance(1.0f, EV100);
}
 
inline float EV100ToLog2(float LuminanceMax, float EV100)
{
    return EV100 + FMath::Log2(LuminanceMax);
}
 
inline float LuminanceToEV100(float LuminanceMax, float Luminance)
{
    return FMath::Log2(Luminance / LuminanceMax);
}
 
inline float LuminanceToEV100(float Luminance)
{
    // LuminanceMax set to 1 for lighting to be unitless (1.0cd/m^2 becomes 1.0 at EV100)
    return FMath::Log2(Luminance);
}
 
inline float Log2ToEV100(float LuminanceMax, float Log2)
{
    return Log2 - FMath::Log2(LuminanceMax);
}
 
// Whether or not VRS is supported via r.VRS.Support and the current platform's DDPI
RENDERCORE_API bool HardwareVariableRateShadingSupportedByPlatform(EShaderPlatform ShaderPlatform);