DynamicRenderScaling.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/List.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "HAL/IConsoleManager.h"
#include "Misc/AssertionMacros.h"
#include "Stats/Stats.h"
 
namespace DynamicRenderScaling
{
 
template<typename Type>
class TMap;
 
/* Model how the GPU costs of a budget scales with a ResolutionFraction. */
enum class EHeuristicModel
{
    Unknown,
 
    // GPU cost scales linearly to the ResolutionFraction
    Linear,
 
    // GPU cost scales quadratically to the ResolutionFraction
    Quadratic,
};
 
/* Represent an independent budget to dynamically scale by its own. */
struct FHeuristicSettings final
{
    static constexpr float kDefaultMinResolutionFraction = 0.5f;
    static constexpr float kDefaultMaxResolutionFraction = 1.0f;
    static constexpr float kDefaultThrottlingMaxResolutionFraction = 0.0f;
    static constexpr float kBudgetMsDisabled = 0.0f;
    static constexpr float kDefaultChangeThreshold = 0.02f;
    static constexpr float kDefaultTargetedHeadRoom = 0.05f;
    static constexpr float kDefaultIncreaseAmortizationFactor = 0.9f;
    static constexpr int32 kDefaultFractionQuantization = 0;
    static constexpr int32 kDefaultUpperBoundQuantization = 0;
 
    EHeuristicModel Model = EHeuristicModel::Unknown;
    bool bModelScalesWithPrimaryScreenPercentage = false;
 
    float MinResolutionFraction      = kDefaultMinResolutionFraction;
    float MaxResolutionFraction      = kDefaultMaxResolutionFraction;
    float ThrottlingMaxResolutionFraction = kDefaultThrottlingMaxResolutionFraction;
    float BudgetMs                   = kBudgetMsDisabled;
    float ChangeThreshold            = kDefaultChangeThreshold;
    float TargetedHeadRoom           = kDefaultTargetedHeadRoom;
    float IncreaseAmortizationFactor = kDefaultIncreaseAmortizationFactor;
    int32 FractionQuantization       = kDefaultFractionQuantization;
    int32 UpperBoundQuantization     = kDefaultUpperBoundQuantization;
 
    RENDERCORE_API bool IsEnabled() const;
 
    RENDERCORE_API float GetTargetedMs(float BudgetMs) const;
 
    RENDERCORE_API float EstimateCostScale(float ResolutionFraction) const;
 
    RENDERCORE_API float EstimateResolutionFactor(float TargetMs, float TimingMs) const;
 
    RENDERCORE_API float EstimateTimeFactor(float CurrentResolutionFraction, float NewResolutionFraction) const;
 
    RENDERCORE_API float CorrectNewResolutionFraction(float CurrentResolutionFraction, float NewResolutionFraction, float ResolutionFractionScale) const;
 
    RENDERCORE_API bool DoesResolutionChangeEnough(float CurrentResolutionFraction, float NewResolutionFraction, bool bCanChangeResolution) const;
};
 
 
/* Represent an independent budget to dynamically scale by its own. */
class FBudget final
{
public:
    RENDERCORE_API FBudget(const TCHAR* Name, FHeuristicSettings (*HeuristicSettingsGetter)(void));
    RENDERCORE_API ~FBudget();
 
    /* Returns the global list of all dynamic resolution budgets. */
    static RENDERCORE_API TLinkedList<FBudget*>*& GetGlobalList();
    static RENDERCORE_API int32 GetGlobalListSize();
 
    inline const TCHAR* GetName() const
    {
        return Name;
    }
 
    inline const char* GetAnsiName() const
    {
        return AnsiName.GetData();
    }
 
    /* Returns the settings of the heuristic for this budget. */
    inline const FHeuristicSettings& GetSettings() const
    {
        return CachedSettings;
    }
 
    inline int32 GetBudgetId() const
    {
        return BudgetId;
    }
 
    inline bool operator == (const FBudget& Other) const
    {
        return BudgetId == Other.BudgetId;
    }
 
#if STATS
    inline const TStatId& GetStatId_TargetMs() const
    {
        return StatId_TargetMs;
    }
 
    inline const TStatId& GetStatId_MeasuredMs() const
    {
        return StatId_MeasuredMs;
    }
 
    inline const TStatId& GetStatId_MinScaling() const
    {
        return StatId_MinScaling;
    }
 
    inline const TStatId& GetStatId_MaxScaling() const
    {
        return StatId_MaxScaling;
    }
 
    inline const TStatId& GetStatId_CurrentScaling() const
    {
        return StatId_CurrentScaling;
    }
#endif
 
private:
    const TCHAR* Name;
    TArray<char> AnsiName;
    FHeuristicSettings(*HeuristicSettingsGetter)(void);
    TLinkedList<FBudget*> GlobalListLink;
    FHeuristicSettings CachedSettings;
    int32 BudgetId = 0;
 
#if STATS
    TStatId StatId_TargetMs;
    TStatId StatId_MeasuredMs;
    TStatId StatId_MinScaling;
    TStatId StatId_MaxScaling;
    TStatId StatId_CurrentScaling;
#endif
 
    UE_NONCOPYABLE(FBudget);
 
    template<typename Type>
    friend class TMap;
    friend RENDERCORE_API void UpdateHeuristicsSettings();
};
 
 
/* Map of FBudget -> <Type>. */
template<typename Type>
class TMap final
{
public:
    static constexpr int32 kInlineAllocatedBudgets = 16;
 
    TMap()
    {
        Array.SetNum(FBudget::GetGlobalListSize());
#if !UE_BUILD_SHIPPING
        for (TLinkedList<FBudget*>::TIterator BudgetIt(FBudget::GetGlobalList()); BudgetIt; BudgetIt.Next())
        {
            Array[BudgetIt->BudgetId].Name = BudgetIt->GetName();
        }
#endif
    }
 
    TMap(const Type& Value)
        : TMap()
    {
        SetAll(Value);
    }
 
    TMap(const TMap<Type>& Map) = default;
    ~TMap() = default;
 
    inline void SetAll(const Type& Value)
    {
        Array.SetNum(FBudget::GetGlobalListSize());
        for (int32 i = 0; i < Array.Num(); i++)
        {
            Array[i].Value = Value;
        }
    }
 
    inline const Type& operator [](const FBudget& Budget) const
    {
        check(Array.Num() == FBudget::GetGlobalListSize());
        return Array[Budget.BudgetId].Value;
    }
 
    inline Type& operator [](const FBudget& Budget)
    {
        check(Array.Num() == FBudget::GetGlobalListSize());
        return Array[Budget.BudgetId].Value;
    }
 
    inline const Type& operator [](const int32 BudgetId) const
    {
        check(Array.Num() == FBudget::GetGlobalListSize());
        return Array[BudgetId].Value;
    }
 
    inline Type& operator [](const int32 BudgetId)
    {
        check(Array.Num() == FBudget::GetGlobalListSize());
        return Array[BudgetId].Value;
    }
 
private:
    struct FItem
    {
#if !UE_BUILD_SHIPPING
        const TCHAR* Name = nullptr;
#endif
        Type Value;
    };
    TArray<FItem, TInlineAllocator<kInlineAllocatedBudgets>> Array;
};
 
 
constexpr float FractionToPercentage(float Fraction)
{
    return Fraction * 100.0f;
}
 
constexpr float PercentageToFraction(float Percentage)
{
    return Percentage / 100.0f;
}
 
inline float GetPercentageCVarToFraction(const TAutoConsoleVariable<float>& Percentage)
{
    return PercentageToFraction(Percentage.GetValueOnAnyThread());
}
 
RENDERCORE_API bool IsSupported();
 
RENDERCORE_API void UpdateHeuristicsSettings();
 
RENDERCORE_API void BeginFrame(const TMap<bool>& bIsBudgetEnabled);
 
RENDERCORE_API void EndFrame();
 
RENDERCORE_API const TMap<uint64>& GetLatestTimings();
 
 
} // namespace DynamicRenderScaling