UnitConversion.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Internationalization/Text.h"
#include "Misc/Optional.h"
#include "Templates/ValueOrError.h"
 
class FText;
template<typename NumericType> struct FNumericUnit;
 
enum class EUnit : uint8
{
    Micrometers, Millimeters, Centimeters, Meters, Kilometers,
    Inches, Feet, Yards, Miles,
    Lightyears,
 
    Degrees, Radians,
 
    CentimetersPerSecond, MetersPerSecond, KilometersPerHour, MilesPerHour,
 
    DegreesPerSecond, RadiansPerSecond,
 
    CentimetersPerSecondSquared, MetersPerSecondSquared,
 
    Celsius, Farenheit, Kelvin,
 
    Micrograms, Milligrams, Grams, Kilograms, MetricTons,
    Ounces, Pounds, Stones,
 
    GramsPerCubicCentimeter, GramsPerCubicMeter, KilogramsPerCubicCentimeter, KilogramsPerCubicMeter,
 
    Newtons, PoundsForce, KilogramsForce, KilogramCentimetersPerSecondSquared,
 
    NewtonMeters, KilogramCentimetersSquaredPerSecondSquared,
 
    NewtonSeconds, KilogramCentimeters, KilogramMeters,
 
    Hertz, Kilohertz, Megahertz, Gigahertz, RevolutionsPerMinute,
 
    Bytes, Kilobytes, Megabytes, Gigabytes, Terabytes,
 
    Lumens,
    
    Candela,
    
    Lux,
    
    CandelaPerMeter2, Nit,
    
    ExposureValue,
 
    Nanoseconds, Microseconds, Milliseconds, Seconds, Minutes, Hours, Days, Months, Years,
 
    PixelsPerInch,
 
    Percentage,
 
    Multiplier,
 
    Pascals, KiloPascals, MegaPascals, GigaPascals,
 
    Unspecified
};
 
enum class EUnitType
{
    Distance, Angle, Speed, AngularSpeed, Acceleration, Temperature, Mass, Density, Force, Torque, Impulse, PositionalImpulse, Frequency, DataSize, LuminousFlux, LuminousIntensity, Illuminance, Luminance, Time, PixelDensity, Multipliers, ExposureValue, Stress,
 
    // Symbolic entry - do not use directly
    NumberOf,
};
 
template<typename NumericType> struct FNumericUnit;
 
class FUnitSettings
{
public:
 
    [[nodiscard]] CORE_API FUnitSettings();
 
    CORE_API bool ShouldDisplayUnits() const;
    CORE_API void SetShouldDisplayUnits(bool bInGlobalUnitDisplay);
    
    CORE_API const TArray<EUnit>& GetDisplayUnits(EUnitType InType) const;
    CORE_API void SetDisplayUnits(EUnitType InType, const TArray<EUnit>& Units);
    CORE_API void SetDisplayUnits(EUnitType InType, EUnit Units);
 
    DECLARE_EVENT(FUnitSettings, FDisplaySettingChanged);
    FDisplaySettingChanged& OnDisplaySettingsChanged() { return SettingChangedEvent; }
 
private:
 
    bool bGlobalUnitDisplay;
 
    TArray<EUnit> DisplayUnits[(uint8)EUnitType::NumberOf + 1];
    
    FDisplaySettingChanged SettingChangedEvent;
};
 
struct FUnitConversion
{
    [[nodiscard]] static CORE_API FUnitSettings& Settings();
 
    [[nodiscard]] static CORE_API bool AreUnitsCompatible(EUnit From, EUnit To);
 
    [[nodiscard]] static CORE_API bool IsUnitOfType(EUnit Unit, EUnitType Type);
 
    [[nodiscard]] static CORE_API EUnitType GetUnitType(EUnit);
 
    [[nodiscard]] static CORE_API const TCHAR* GetUnitDisplayString(EUnit Unit);
 
    [[nodiscard]] static CORE_API TOptional<EUnit> UnitFromString(const TCHAR* UnitString);
 
    [[nodiscard]] static CORE_API TConstArrayView<const TCHAR*> GetSupportedUnits();
 
public:
 
    template<typename T>
    [[nodiscard]] static T Convert(T InValue, EUnit From, EUnit To);
 
    template<typename T>
    [[nodiscard]] static FNumericUnit<T> QuantizeUnitsToBestFit(T Value, EUnit Units);
 
    template<typename T>
    [[nodiscard]] static EUnit CalculateDisplayUnit(T Value, EUnit InUnits);
 
};
 
 
template<typename NumericType>
struct FNumericUnit
{
    NumericType Value;
    const EUnit Units;
 
    [[nodiscard]] FNumericUnit();
    [[nodiscard]] FNumericUnit(const NumericType& InValue, EUnit InUnits = EUnit::Unspecified);
 
    [[nodiscard]] FNumericUnit(const FNumericUnit& Other);
    FNumericUnit& operator=(const FNumericUnit& Other);
 
    template<typename OtherType>
    [[nodiscard]] FNumericUnit(const FNumericUnit<OtherType>& Other);
    template<typename OtherType>
    FNumericUnit& operator=(const FNumericUnit<OtherType>& Other);
 
    [[nodiscard]] TOptional<FNumericUnit<NumericType>> ConvertTo(EUnit ToUnits) const;
 
public:
 
    [[nodiscard]] FNumericUnit<NumericType> QuantizeUnitsToBestFit() const;
 
    static TValueOrError<FNumericUnit<NumericType>, FText> TryParseExpression(const TCHAR* InExpression, EUnit InDefaultUnit, const FNumericUnit<NumericType>& InExistingValue);
 
    static TOptional<FNumericUnit<NumericType>> TryParseString(const TCHAR* InSource);
 
private:
    operator const NumericType&() const = delete;
 
    template<typename OtherType>
    void CopyValueWithConversion(const FNumericUnit<OtherType>& Other);
 
    static bool ExtractNumberBoundary(const TCHAR* Start, const TCHAR*& End);
 
    template<typename OtherType>
    [[nodiscard]] friend inline bool operator==(const FNumericUnit<NumericType>& LHS, const FNumericUnit<OtherType>& RHS)
    {
        if (LHS.Units != EUnit::Unspecified && RHS.Units != EUnit::Unspecified)
        {
            if (LHS.Units == RHS.Units)
            {
                return LHS.Value == RHS.Value;
            }
            else if (FUnitConversion::AreUnitsCompatible(LHS.Units, RHS.Units))
            {
                return LHS.Value == FUnitConversion::Convert(RHS.Value, RHS.Units, LHS.Units);
            }
            else
            {
                // Invalid conversion
                return false;
            }
        }
        else
        {
            return LHS.Value == RHS.Value;
        }
    }
 
    template<typename OtherType>
    [[nodiscard]] friend inline bool operator!=(const FNumericUnit<NumericType>& LHS, const FNumericUnit<OtherType>& RHS)
    {
        return !(LHS == RHS);
    }
};
 
template <typename CharType, typename T>
TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const FNumericUnit<T>& NumericUnit);
 
template<typename T>
FString LexToString(const FNumericUnit<T>& NumericUnit);
 
template<typename T>
FString LexToSanitizedString(const FNumericUnit<T>& NumericUnit);
 
template<typename T>
void LexFromString(FNumericUnit<T>& OutValue, const TCHAR* String);
    
template<typename T>
bool LexTryParseString(FNumericUnit<T>& OutValue, const TCHAR* String);
 
// Include template definitions
#include "Math/UnitConversion.inl" // IWYU pragma: export