UnrealMathUtility.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Concepts/FloatingPoint.h"
#include "Concepts/Integral.h"
#include "Misc/AssertionMacros.h"
#include "HAL/PlatformMath.h"
#include "Math/MathFwd.h"
#include "Templates/Requires.h"
 
// Assert on non finite numbers. Used to track NaNs.
#ifndef ENABLE_NAN_DIAGNOSTIC
    #if UE_BUILD_DEBUG
        #define ENABLE_NAN_DIAGNOSTIC 1
    #else
        #define ENABLE_NAN_DIAGNOSTIC 0
    #endif
#endif
 
/*-----------------------------------------------------------------------------
    Definitions.
-----------------------------------------------------------------------------*/
 
// Forward declarations.
struct  FTwoVectors;
struct FLinearColor;
template<typename ElementType>
class TRange;
 
/*-----------------------------------------------------------------------------
    Floating point constants.
-----------------------------------------------------------------------------*/
 
// These macros can have different values across modules inside a single codebase.
// Tell the IncludeTool static analyzer to ignore that divergence in state:
#define UE_INCLUDETOOL_IGNORE_INCONSISTENT_STATE
 
// Define this to 1 in a module's .Build.cs to make legacy names issue deprecation warnings.
#ifndef UE_DEPRECATE_LEGACY_MATH_CONSTANT_MACRO_NAMES
    #define UE_DEPRECATE_LEGACY_MATH_CONSTANT_MACRO_NAMES 0
#endif
 
// Define this to 0 in a module's .Build.cs to stop that module recognizing the old identifiers.
#ifndef UE_DEFINE_LEGACY_MATH_CONSTANT_MACRO_NAMES
    #define UE_DEFINE_LEGACY_MATH_CONSTANT_MACRO_NAMES 1
#endif
 
// Process for fixing up a module's use of legacy names:
//
// - Define UE_DEPRECATE_LEGACY_MATH_CONSTANT_MACRO_NAMES=1 to the module's .Build.cs.
// - Build and fix all warnings.
// - Remove UE_DEPRECATE_LEGACY_MATH_CONSTANT_MACRO_NAMES=1 from the module's .Build.cs.
// - Define UE_DEFINE_LEGACY_MATH_CONSTANT_MACRO_NAMES=0 from the module's .Build.cs to stop new usage of the legacy macros.
 
#if UE_DEFINE_LEGACY_MATH_CONSTANT_MACRO_NAMES
    #if UE_DEPRECATE_LEGACY_MATH_CONSTANT_MACRO_NAMES
        #define UE_PRIVATE_MATH_DEPRECATION(Before, After) UE_DEPRECATED_MACRO(5.1, "The " #Before " macro has been deprecated in favor of " #After ".")
    #else
        #define UE_PRIVATE_MATH_DEPRECATION(Before, After)
    #endif
 
    #undef  PI
    #define PI                                      UE_PRIVATE_MATH_DEPRECATION(PI                                      , UE_PI                                     ) UE_PI
    #define SMALL_NUMBER                            UE_PRIVATE_MATH_DEPRECATION(SMALL_NUMBER                            , UE_SMALL_NUMBER                           ) UE_SMALL_NUMBER
    #define KINDA_SMALL_NUMBER                      UE_PRIVATE_MATH_DEPRECATION(KINDA_SMALL_NUMBER                      , UE_KINDA_SMALL_NUMBER                     ) UE_KINDA_SMALL_NUMBER
    #define BIG_NUMBER                              UE_PRIVATE_MATH_DEPRECATION(BIG_NUMBER                              , UE_BIG_NUMBER                             ) UE_BIG_NUMBER
    #define EULERS_NUMBER                           UE_PRIVATE_MATH_DEPRECATION(EULERS_NUMBER                           , UE_EULERS_NUMBER                          ) UE_EULERS_NUMBER
    #define FLOAT_NON_FRACTIONAL                    UE_PRIVATE_MATH_DEPRECATION(FLOAT_NON_FRACTIONAL                    , UE_FLOAT_NON_FRACTIONAL                   ) UE_FLOAT_NON_FRACTIONAL
    #define DOUBLE_PI                               UE_PRIVATE_MATH_DEPRECATION(DOUBLE_PI                               , UE_DOUBLE_PI                              ) UE_DOUBLE_PI
    #define DOUBLE_SMALL_NUMBER                     UE_PRIVATE_MATH_DEPRECATION(DOUBLE_SMALL_NUMBER                     , UE_DOUBLE_SMALL_NUMBER                    ) UE_DOUBLE_SMALL_NUMBER
    #define DOUBLE_KINDA_SMALL_NUMBER               UE_PRIVATE_MATH_DEPRECATION(DOUBLE_KINDA_SMALL_NUMBER               , UE_DOUBLE_KINDA_SMALL_NUMBER              ) UE_DOUBLE_KINDA_SMALL_NUMBER
    #define DOUBLE_BIG_NUMBER                       UE_PRIVATE_MATH_DEPRECATION(DOUBLE_BIG_NUMBER                       , UE_DOUBLE_BIG_NUMBER                      ) UE_DOUBLE_BIG_NUMBER
    #define DOUBLE_EULERS_NUMBER                    UE_PRIVATE_MATH_DEPRECATION(DOUBLE_EULERS_NUMBER                    , UE_DOUBLE_EULERS_NUMBER                   ) UE_DOUBLE_EULERS_NUMBER
    #define DOUBLE_UE_GOLDEN_RATIO                  UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_GOLDEN_RATIO                  , UE_DOUBLE_GOLDEN_RATIO                    ) UE_DOUBLE_GOLDEN_RATIO
    #define DOUBLE_NON_FRACTIONAL                   UE_PRIVATE_MATH_DEPRECATION(DOUBLE_NON_FRACTIONAL                   , UE_DOUBLE_NON_FRACTIONAL                  ) UE_DOUBLE_NON_FRACTIONAL
    #define MAX_FLT                                 UE_PRIVATE_MATH_DEPRECATION(MAX_FLT                                 , UE_MAX_FLT                                ) UE_MAX_FLT
    #define INV_PI                                  UE_PRIVATE_MATH_DEPRECATION(INV_PI                                  , UE_INV_PI                                 ) UE_INV_PI
    #define HALF_PI                                 UE_PRIVATE_MATH_DEPRECATION(HALF_PI                                 , UE_HALF_PI                                ) UE_HALF_PI
    #define TWO_PI                                  UE_PRIVATE_MATH_DEPRECATION(TWO_PI                                  , UE_TWO_PI                                 ) UE_TWO_PI
    #define PI_SQUARED                              UE_PRIVATE_MATH_DEPRECATION(PI_SQUARED                              , UE_PI_SQUARED                             ) UE_PI_SQUARED
    #define DOUBLE_INV_PI                           UE_PRIVATE_MATH_DEPRECATION(DOUBLE_INV_PI                           , UE_DOUBLE_INV_PI                          ) UE_DOUBLE_INV_PI
    #define DOUBLE_HALF_PI                          UE_PRIVATE_MATH_DEPRECATION(DOUBLE_HALF_PI                          , UE_DOUBLE_HALF_PI                         ) UE_DOUBLE_HALF_PI
    #define DOUBLE_TWO_PI                           UE_PRIVATE_MATH_DEPRECATION(DOUBLE_TWO_PI                           , UE_DOUBLE_TWO_PI                          ) UE_DOUBLE_TWO_PI
    #define DOUBLE_PI_SQUARED                       UE_PRIVATE_MATH_DEPRECATION(DOUBLE_PI_SQUARED                       , UE_DOUBLE_PI_SQUARED                      ) UE_DOUBLE_PI_SQUARED
    #define DOUBLE_UE_SQRT_2                        UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_SQRT_2                        , UE_DOUBLE_SQRT_2                          ) UE_DOUBLE_SQRT_2
    #define DOUBLE_UE_SQRT_3                        UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_SQRT_3                        , UE_DOUBLE_SQRT_3                          ) UE_DOUBLE_SQRT_3
    #define DOUBLE_UE_INV_SQRT_2                    UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_INV_SQRT_2                    , UE_DOUBLE_INV_SQRT_2                      ) UE_DOUBLE_INV_SQRT_2
    #define DOUBLE_UE_INV_SQRT_3                    UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_INV_SQRT_3                    , UE_DOUBLE_INV_SQRT_3                      ) UE_DOUBLE_INV_SQRT_3
    #define DOUBLE_UE_HALF_SQRT_2                   UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_HALF_SQRT_2                   , UE_DOUBLE_HALF_SQRT_2                     ) UE_DOUBLE_HALF_SQRT_2
    #define DOUBLE_UE_HALF_SQRT_3                   UE_PRIVATE_MATH_DEPRECATION(DOUBLE_UE_HALF_SQRT_3                   , UE_DOUBLE_HALF_SQRT_3                     ) UE_DOUBLE_HALF_SQRT_3
    #define DELTA                                   UE_PRIVATE_MATH_DEPRECATION(DELTA                                   , UE_DELTA                                  ) UE_DELTA
    #define DOUBLE_DELTA                            UE_PRIVATE_MATH_DEPRECATION(DOUBLE_DELTA                            , UE_DOUBLE_DELTA                           ) UE_DOUBLE_DELTA
    #define FLOAT_NORMAL_THRESH                     UE_PRIVATE_MATH_DEPRECATION(FLOAT_NORMAL_THRESH                     , UE_FLOAT_NORMAL_THRESH                    ) UE_FLOAT_NORMAL_THRESH
    #define DOUBLE_NORMAL_THRESH                    UE_PRIVATE_MATH_DEPRECATION(DOUBLE_NORMAL_THRESH                    , UE_DOUBLE_NORMAL_THRESH                   ) UE_DOUBLE_NORMAL_THRESH
    #define THRESH_POINT_ON_PLANE                   UE_PRIVATE_MATH_DEPRECATION(THRESH_POINT_ON_PLANE                   , UE_THRESH_POINT_ON_PLANE                  ) UE_THRESH_POINT_ON_PLANE
    #define THRESH_POINT_ON_SIDE                    UE_PRIVATE_MATH_DEPRECATION(THRESH_POINT_ON_SIDE                    , UE_THRESH_POINT_ON_SIDE                   ) UE_THRESH_POINT_ON_SIDE
    #define THRESH_POINTS_ARE_SAME                  UE_PRIVATE_MATH_DEPRECATION(THRESH_POINTS_ARE_SAME                  , UE_THRESH_POINTS_ARE_SAME                 ) UE_THRESH_POINTS_ARE_SAME
    #define THRESH_POINTS_ARE_NEAR                  UE_PRIVATE_MATH_DEPRECATION(THRESH_POINTS_ARE_NEAR                  , UE_THRESH_POINTS_ARE_NEAR                 ) UE_THRESH_POINTS_ARE_NEAR
    #define THRESH_NORMALS_ARE_SAME                 UE_PRIVATE_MATH_DEPRECATION(THRESH_NORMALS_ARE_SAME                 , UE_THRESH_NORMALS_ARE_SAME                ) UE_THRESH_NORMALS_ARE_SAME
    #define THRESH_UVS_ARE_SAME                     UE_PRIVATE_MATH_DEPRECATION(THRESH_UVS_ARE_SAME                     , UE_THRESH_UVS_ARE_SAME                    ) UE_THRESH_UVS_ARE_SAME
    #define THRESH_VECTORS_ARE_NEAR                 UE_PRIVATE_MATH_DEPRECATION(THRESH_VECTORS_ARE_NEAR                 , UE_THRESH_VECTORS_ARE_NEAR                ) UE_THRESH_VECTORS_ARE_NEAR
    #define THRESH_SPLIT_POLY_WITH_PLANE            UE_PRIVATE_MATH_DEPRECATION(THRESH_SPLIT_POLY_WITH_PLANE            , UE_THRESH_SPLIT_POLY_WITH_PLANE           ) UE_THRESH_SPLIT_POLY_WITH_PLANE
    #define THRESH_SPLIT_POLY_PRECISELY             UE_PRIVATE_MATH_DEPRECATION(THRESH_SPLIT_POLY_PRECISELY             , UE_THRESH_SPLIT_POLY_PRECISELY            ) UE_THRESH_SPLIT_POLY_PRECISELY
    #define THRESH_ZERO_NORM_SQUARED                UE_PRIVATE_MATH_DEPRECATION(THRESH_ZERO_NORM_SQUARED                , UE_THRESH_ZERO_NORM_SQUARED               ) UE_THRESH_ZERO_NORM_SQUARED
    #define THRESH_NORMALS_ARE_PARALLEL             UE_PRIVATE_MATH_DEPRECATION(THRESH_NORMALS_ARE_PARALLEL             , UE_THRESH_NORMALS_ARE_PARALLEL            ) UE_THRESH_NORMALS_ARE_PARALLEL
    #define THRESH_NORMALS_ARE_ORTHOGONAL           UE_PRIVATE_MATH_DEPRECATION(THRESH_NORMALS_ARE_ORTHOGONAL           , UE_THRESH_NORMALS_ARE_ORTHOGONAL          ) UE_THRESH_NORMALS_ARE_ORTHOGONAL
    #define THRESH_VECTOR_NORMALIZED                UE_PRIVATE_MATH_DEPRECATION(THRESH_VECTOR_NORMALIZED                , UE_THRESH_VECTOR_NORMALIZED               ) UE_THRESH_VECTOR_NORMALIZED
    #define THRESH_QUAT_NORMALIZED                  UE_PRIVATE_MATH_DEPRECATION(THRESH_QUAT_NORMALIZED                  , UE_THRESH_QUAT_NORMALIZED                 ) UE_THRESH_QUAT_NORMALIZED
    #define DOUBLE_THRESH_POINT_ON_PLANE            UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_POINT_ON_PLANE            , UE_DOUBLE_THRESH_POINT_ON_PLANE           ) UE_DOUBLE_THRESH_POINT_ON_PLANE
    #define DOUBLE_THRESH_POINT_ON_SIDE             UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_POINT_ON_SIDE             , UE_DOUBLE_THRESH_POINT_ON_SIDE            ) UE_DOUBLE_THRESH_POINT_ON_SIDE
    #define DOUBLE_THRESH_POINTS_ARE_SAME           UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_POINTS_ARE_SAME           , UE_DOUBLE_THRESH_POINTS_ARE_SAME          ) UE_DOUBLE_THRESH_POINTS_ARE_SAME
    #define DOUBLE_THRESH_POINTS_ARE_NEAR           UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_POINTS_ARE_NEAR           , UE_DOUBLE_THRESH_POINTS_ARE_NEAR          ) UE_DOUBLE_THRESH_POINTS_ARE_NEAR
    #define DOUBLE_THRESH_NORMALS_ARE_SAME          UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_NORMALS_ARE_SAME          , UE_DOUBLE_THRESH_NORMALS_ARE_SAME         ) UE_DOUBLE_THRESH_NORMALS_ARE_SAME
    #define DOUBLE_THRESH_UVS_ARE_SAME              UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_UVS_ARE_SAME              , UE_DOUBLE_THRESH_UVS_ARE_SAME             ) UE_DOUBLE_THRESH_UVS_ARE_SAME
    #define DOUBLE_THRESH_VECTORS_ARE_NEAR          UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_VECTORS_ARE_NEAR          , UE_DOUBLE_THRESH_VECTORS_ARE_NEAR         ) UE_DOUBLE_THRESH_VECTORS_ARE_NEAR
    #define DOUBLE_THRESH_SPLIT_POLY_WITH_PLANE     UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_SPLIT_POLY_WITH_PLANE     , UE_DOUBLE_THRESH_SPLIT_POLY_WITH_PLANE    ) UE_DOUBLE_THRESH_SPLIT_POLY_WITH_PLANE
    #define DOUBLE_THRESH_SPLIT_POLY_PRECISELY      UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_SPLIT_POLY_PRECISELY      , UE_DOUBLE_THRESH_SPLIT_POLY_PRECISELY     ) UE_DOUBLE_THRESH_SPLIT_POLY_PRECISELY
    #define DOUBLE_THRESH_ZERO_NORM_SQUARED         UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_ZERO_NORM_SQUARED         , UE_DOUBLE_THRESH_ZERO_NORM_SQUARED        ) UE_DOUBLE_THRESH_ZERO_NORM_SQUARED
    #define DOUBLE_THRESH_NORMALS_ARE_PARALLEL      UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_NORMALS_ARE_PARALLEL      , UE_DOUBLE_THRESH_NORMALS_ARE_PARALLEL     ) UE_DOUBLE_THRESH_NORMALS_ARE_PARALLEL
    #define DOUBLE_THRESH_NORMALS_ARE_ORTHOGONAL    UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_NORMALS_ARE_ORTHOGONAL    , UE_DOUBLE_THRESH_NORMALS_ARE_ORTHOGONAL   ) UE_DOUBLE_THRESH_NORMALS_ARE_ORTHOGONAL
    #define DOUBLE_THRESH_VECTOR_NORMALIZED         UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_VECTOR_NORMALIZED         , UE_DOUBLE_THRESH_VECTOR_NORMALIZED        ) UE_DOUBLE_THRESH_VECTOR_NORMALIZED
    #define DOUBLE_THRESH_QUAT_NORMALIZED           UE_PRIVATE_MATH_DEPRECATION(DOUBLE_THRESH_QUAT_NORMALIZED           , UE_DOUBLE_THRESH_QUAT_NORMALIZED          ) UE_DOUBLE_THRESH_QUAT_NORMALIZED
#endif
 
#undef UE_INCLUDETOOL_IGNORE_INCONSISTENT_STATE
 
#define UE_PI                   (3.1415926535897932f)   /* Extra digits if needed: 3.1415926535897932384626433832795f */
#define UE_SMALL_NUMBER         (1.e-8f)
#define UE_KINDA_SMALL_NUMBER   (1.e-4f)
#define UE_BIG_NUMBER           (3.4e+38f)
#define UE_EULERS_NUMBER        (2.71828182845904523536f)
#define UE_GOLDEN_RATIO         (1.6180339887498948482045868343656381f) /* Also known as divine proportion, golden mean, or golden section - related to the Fibonacci Sequence = (1 + sqrt(5)) / 2 */
#define UE_FLOAT_NON_FRACTIONAL (8388608.f) /* All single-precision floating point numbers greater than or equal to this have no fractional value. */
 
 
#define UE_DOUBLE_PI                    (3.141592653589793238462643383279502884197169399)
#define UE_DOUBLE_SMALL_NUMBER          (1.e-8)
#define UE_DOUBLE_KINDA_SMALL_NUMBER    (1.e-4)
#define UE_DOUBLE_BIG_NUMBER            (3.4e+38)
#define UE_DOUBLE_EULERS_NUMBER         (2.7182818284590452353602874713526624977572)
#define UE_DOUBLE_GOLDEN_RATIO          (1.6180339887498948482045868343656381)  /* Also known as divine proportion, golden mean, or golden section - related to the Fibonacci Sequence = (1 + sqrt(5)) / 2 */
#define UE_DOUBLE_NON_FRACTIONAL        (4503599627370496.0) /* All double-precision floating point numbers greater than or equal to this have no fractional value. 2^52 */
 
// Copied from float.h
#define UE_MAX_FLT 3.402823466e+38F
 
// Aux constants.
#define UE_INV_PI           (0.31830988618f)
#define UE_HALF_PI          (1.57079632679f)
#define UE_TWO_PI           (6.28318530717f)
#define UE_PI_SQUARED       (9.86960440108f)
 
#define UE_DOUBLE_INV_PI        (0.31830988618379067154)
#define UE_DOUBLE_HALF_PI       (1.57079632679489661923)
#define UE_DOUBLE_TWO_PI        (6.28318530717958647692)
#define UE_DOUBLE_PI_SQUARED    (9.86960440108935861883)
 
#define UE_LN2      (0.69314718056f)
 
// Common square roots
#define UE_SQRT_2       (1.4142135623730950488016887242097f)
#define UE_SQRT_3       (1.7320508075688772935274463415059f)
#define UE_INV_SQRT_2   (0.70710678118654752440084436210485f)
#define UE_INV_SQRT_3   (0.57735026918962576450914878050196f)
#define UE_HALF_SQRT_2  (0.70710678118654752440084436210485f)
#define UE_HALF_SQRT_3  (0.86602540378443864676372317075294f)
 
#define UE_DOUBLE_SQRT_2        (1.4142135623730950488016887242097)
#define UE_DOUBLE_SQRT_3        (1.7320508075688772935274463415059)
#define UE_DOUBLE_INV_SQRT_2    (0.70710678118654752440084436210485)
#define UE_DOUBLE_INV_SQRT_3    (0.57735026918962576450914878050196)
#define UE_DOUBLE_HALF_SQRT_2   (0.70710678118654752440084436210485)
#define UE_DOUBLE_HALF_SQRT_3   (0.86602540378443864676372317075294)
 
// Common metric unit conversion
#define UE_KM_TO_M   (1000.f)
#define UE_M_TO_KM   (0.001f)
#define UE_CM_TO_M   (0.01f)
#define UE_M_TO_CM   (100.f)
#define UE_CM2_TO_M2 (0.0001f)
#define UE_M2_TO_CM2 (10000.f)
 
// Magic numbers for numerical precision.
#define UE_DELTA        (0.00001f)
#define UE_DOUBLE_DELTA (0.00001 )
 
#define UE_FLOAT_NORMAL_THRESH          (0.0001f)
#define UE_DOUBLE_NORMAL_THRESH         (0.0001)
 
//
// Magic numbers for numerical precision.
//
#define UE_THRESH_POINT_ON_PLANE                (0.10f)     /* Thickness of plane for front/back/inside test */
#define UE_THRESH_POINT_ON_SIDE                 (0.20f)     /* Thickness of polygon side's side-plane for point-inside/outside/on side test */
#define UE_THRESH_POINTS_ARE_SAME               (0.00002f)  /* Two points are same if within this distance */
#define UE_THRESH_POINTS_ARE_NEAR               (0.015f)    /* Two points are near if within this distance and can be combined if imprecise math is ok */
#define UE_THRESH_NORMALS_ARE_SAME              (0.00002f)  /* Two normal points are same if within this distance */
#define UE_THRESH_UVS_ARE_SAME                  (0.0009765625f)/* Two UV are same if within this threshold (1.0f/1024f) */
                                                            /* Making this too large results in incorrect CSG classification and disaster */
#define UE_THRESH_VECTORS_ARE_NEAR              (0.0004f)   /* Two vectors are near if within this distance and can be combined if imprecise math is ok */
                                                            /* Making this too large results in lighting problems due to inaccurate texture coordinates */
#define UE_THRESH_SPLIT_POLY_WITH_PLANE         (0.25f)     /* A plane splits a polygon in half */
#define UE_THRESH_SPLIT_POLY_PRECISELY          (0.01f)     /* A plane exactly splits a polygon */
#define UE_THRESH_ZERO_NORM_SQUARED             (0.0001f)   /* Size of a unit normal that is considered "zero", squared */
#define UE_THRESH_NORMALS_ARE_PARALLEL          (0.999845f) /* Two unit vectors are parallel if abs(A dot B) is greater than or equal to this. This is roughly cosine(1.0 degrees). */
#define UE_THRESH_NORMALS_ARE_ORTHOGONAL        (0.017455f) /* Two unit vectors are orthogonal (perpendicular) if abs(A dot B) is less than or equal this. This is roughly cosine(89.0 degrees). */
 
#define UE_THRESH_VECTOR_NORMALIZED             (0.01f)     
#define UE_THRESH_QUAT_NORMALIZED               (0.01f)     
// Double precision values
#define UE_DOUBLE_THRESH_POINT_ON_PLANE         (0.10)      /* Thickness of plane for front/back/inside test */
#define UE_DOUBLE_THRESH_POINT_ON_SIDE          (0.20)      /* Thickness of polygon side's side-plane for point-inside/outside/on side test */
#define UE_DOUBLE_THRESH_POINTS_ARE_SAME        (0.00002)   /* Two points are same if within this distance */
#define UE_DOUBLE_THRESH_POINTS_ARE_NEAR        (0.015)     /* Two points are near if within this distance and can be combined if imprecise math is ok */
#define UE_DOUBLE_THRESH_NORMALS_ARE_SAME       (0.00002)   /* Two normal points are same if within this distance */
#define UE_DOUBLE_THRESH_UVS_ARE_SAME           (0.0009765625)/* Two UV are same if within this threshold (1.0/1024.0) */
                                                            /* Making this too large results in incorrect CSG classification and disaster */
#define UE_DOUBLE_THRESH_VECTORS_ARE_NEAR       (0.0004)    /* Two vectors are near if within this distance and can be combined if imprecise math is ok */
                                                            /* Making this too large results in lighting problems due to inaccurate texture coordinates */
#define UE_DOUBLE_THRESH_SPLIT_POLY_WITH_PLANE  (0.25)      /* A plane splits a polygon in half */
#define UE_DOUBLE_THRESH_SPLIT_POLY_PRECISELY   (0.01)      /* A plane exactly splits a polygon */
#define UE_DOUBLE_THRESH_ZERO_NORM_SQUARED      (0.0001)    /* Size of a unit normal that is considered "zero", squared */
#define UE_DOUBLE_THRESH_NORMALS_ARE_PARALLEL   (0.999845)  /* Two unit vectors are parallel if abs(A dot B) is greater than or equal to this. This is roughly cosine(1.0 degrees). */
#define UE_DOUBLE_THRESH_NORMALS_ARE_ORTHOGONAL (0.017455)  /* Two unit vectors are orthogonal (perpendicular) if abs(A dot B) is less than or equal this. This is roughly cosine(89.0 degrees). */
 
#define UE_DOUBLE_THRESH_VECTOR_NORMALIZED      (0.01)      
#define UE_DOUBLE_THRESH_QUAT_NORMALIZED        (0.01)      
/*-----------------------------------------------------------------------------
    Global functions.
-----------------------------------------------------------------------------*/
 
template <typename T>
struct TCustomLerp
{
    constexpr static bool Value = false;
};
 
struct FMath : public FPlatformMath
{
    // Random Number Functions
 
    [[nodiscard]] static UE_FORCEINLINE_HINT int32 RandHelper(int32 A)
    {
        // Note that on some platforms RAND_MAX is a large number so we cannot do ((rand()/(RAND_MAX+1)) * A)
        // or else we may include the upper bound results, which should be excluded.
        return A > 0 ? Min(TruncToInt(FRand() * (float)A), A - 1) : 0;
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT int64 RandHelper64(int64 A)
    {
        // Note that on some platforms RAND_MAX is a large number so we cannot do ((rand()/(RAND_MAX+1)) * A)
        // or else we may include the upper bound results, which should be excluded.
        return A > 0 ? Min<int64>(TruncToInt(FRand() * (float)A), A - 1) : 0;
    }
 
    [[nodiscard]] static inline int32 RandRange(int32 Min, int32 Max)
    {
        const int32 Range = (Max - Min) + 1;
        return Min + RandHelper(Range);
    }
 
    [[nodiscard]] static inline int64 RandRange(int64 Min, int64 Max)
    {
        const int64 Range = (Max - Min) + 1;
        return Min + RandHelper64(Range);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float RandRange(float InMin, float InMax)
    {
        return FRandRange(InMin, InMax);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double RandRange(double InMin, double InMax)
    {
        return FRandRange(InMin, InMax);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float FRandRange(float InMin, float InMax)
    {
        return InMin + (InMax - InMin) * FRand();
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double FRandRange(double InMin, double InMax)
    {
        return InMin + (InMax - InMin) * FRand();   // LWC_TODO: Implement FRandDbl() for increased precision
    }
 
    RESOLVE_FLOAT_AMBIGUITY_2_ARGS(FRandRange);
 
    [[nodiscard]] static UE_FORCEINLINE_HINT bool RandBool()
    {
        return (RandRange(0,1) == 1) ? true : false;
    }
 
    [[nodiscard]] static FVector VRand();
    
    [[nodiscard]] static CORE_API FVector VRandCone(FVector const& Dir, float ConeHalfAngleRad);
 
    [[nodiscard]] static CORE_API FVector VRandCone(FVector const& Dir, float HorizontalConeHalfAngleRad, float VerticalConeHalfAngleRad);
 
    [[nodiscard]] static CORE_API FVector2D RandPointInCircle(float CircleRadius);
 
    [[nodiscard]] static CORE_API FVector RandPointInBox(const FBox& Box);
 
    [[nodiscard]] static CORE_API FVector GetReflectionVector(const FVector& Direction, const FVector& SurfaceNormal);
    
    // Predicates
 
    template< class T, class U> 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT bool IsWithin(const T& TestValue, const U& MinValue, const U& MaxValue)
    {
        return ((TestValue >= MinValue) && (TestValue < MaxValue));
    }
 
 
    template< class T, class U> 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT bool IsWithinInclusive(const T& TestValue, const U& MinValue, const U& MaxValue)
    {
        return ((TestValue>=MinValue) && (TestValue <= MaxValue));
    }
    
    [[nodiscard]] static UE_FORCEINLINE_HINT bool IsNearlyEqual(float A, float B, float ErrorTolerance = UE_SMALL_NUMBER)
    {
        return Abs<float>( A - B ) <= ErrorTolerance;
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT bool IsNearlyEqual(double A, double B, double ErrorTolerance = UE_DOUBLE_SMALL_NUMBER)
    {
        return Abs<double>(A - B) <= ErrorTolerance;
    }
 
    RESOLVE_FLOAT_PREDICATE_AMBIGUITY_2_ARGS(IsNearlyEqual);
    RESOLVE_FLOAT_PREDICATE_AMBIGUITY_3_ARGS(IsNearlyEqual);
 
    [[nodiscard]] static UE_FORCEINLINE_HINT bool IsNearlyZero(float Value, float ErrorTolerance = UE_SMALL_NUMBER)
    {
        return Abs<float>( Value ) <= ErrorTolerance;
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT bool IsNearlyZero(double Value, double ErrorTolerance = UE_DOUBLE_SMALL_NUMBER)
    {
        return Abs<double>( Value ) <= ErrorTolerance;
    }
 
    RESOLVE_FLOAT_PREDICATE_AMBIGUITY_2_ARGS(IsNearlyZero);
 
private:
    template<typename FloatType, typename IntegralType, IntegralType SignedBit>
    static inline bool TIsNearlyEqualByULP(FloatType A, FloatType B, int32 MaxUlps)
    {
        // Any comparison with NaN always fails.
        if (FMath::IsNaN(A) || FMath::IsNaN(B))
        {
            return false;
        }
 
        // If either number is infinite, then ignore ULP and do a simple equality test. 
        // The rationale being that two infinities, of the same sign, should compare the same 
        // no matter the ULP, but FLT_MAX and Inf should not, even if they're neighbors in
        // their bit representation.
        if (!FMath::IsFinite(A) || !FMath::IsFinite(B))
        {
            return A == B;
        }
 
        // Convert the integer representation of the float from sign + magnitude to
        // a signed number representation where 0 is 1 << 31. This allows us to compare
        // ULP differences around zero values.
        auto FloatToSignedNumber = [](IntegralType V) {
            if (V & SignedBit)
            {
                return ~V + 1;
            }
            else
            {
                return SignedBit | V;
            }
        };
 
        IntegralType SNA = FloatToSignedNumber(FMath::AsUInt(A));
        IntegralType SNB = FloatToSignedNumber(FMath::AsUInt(B));
        IntegralType Distance = (SNA >= SNB) ? (SNA - SNB) : (SNB - SNA);
        return Distance <= IntegralType(MaxUlps);
    }
 
public:
 
    [[nodiscard]] static UE_FORCEINLINE_HINT bool IsNearlyEqualByULP(float A, float B, int32 MaxUlps = 4)
    {
        return TIsNearlyEqualByULP<float, uint32, uint32(1U << 31)>(A, B, MaxUlps);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT bool IsNearlyEqualByULP(double A, double B, int32 MaxUlps = 4)
    {
        return TIsNearlyEqualByULP<double, uint64, uint64(1ULL << 63)>(A, B, MaxUlps);
    }
 
    template <typename T>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT bool IsPowerOfTwo( T Value )
    {
        return ((Value & (Value - 1)) == (T)0);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float Floor(float F)
    {
        return FloorToFloat(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double Floor(double F)
    {
        return FloorToDouble(F);
    }
 
    template <UE::CIntegral IntegralType>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT IntegralType Floor(IntegralType I)
    {
        return I;
    }
 
 
    // Math Operations
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Max3( const T A, const T B, const T C )
    {
        return Max ( Max( A, B ), C );
    }
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Min3( const T A, const T B, const T C )
    {
        return Min ( Min( A, B ), C );
    }
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT int32 Max3Index( const T A, const T B, const T C )
    {
        return ( A > B ) ? ( ( A > C ) ? 0 : 2 ) : ( ( B > C ) ? 1 : 2 );
    }
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT int32 Min3Index( const T A, const T B, const T C )
    {
        return ( A < B ) ? ( ( A < C ) ? 0 : 2 ) : ( ( B < C ) ? 1 : 2 );
    }
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Square( const T A )
    {
        return A*A;
    }
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Cube( const T A )
    {
        return A*A*A;
    }
 
    template< class T >
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Clamp(const T X, const T MinValue, const T MaxValue)
    {
        return Max(Min(X, MaxValue), MinValue);
    }
    MIX_FLOATS_3_ARGS(Clamp);
    
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT float Clamp(const float X, const float Min, const float Max) { return Clamp<float>(X, Min, Max); }
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT double Clamp(const double X, const double Min, const double Max) { return Clamp<double>(X, Min, Max); }
 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT int64 Clamp(const int64 X, const int32 Min, const int32 Max) { return Clamp<int64>(X, Min, Max); }
 
public:
    template <UE::CFloatingPoint T>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Wrap(const T X, const T Min, const T Max)
    {
        // Our asserts are not constexpr-friendly yet
        // checkSlow(Min <= Max);
 
        T Size = Max - Min;
        if (Size == 0)
        {
            // Guard against zero-sized ranges causing division by zero.
            return Max;
        }
 
        T EndVal = X;
        if (EndVal < Min)
        {
            T Mod = FMath::Modulo(Min - EndVal, Size);
            EndVal = (Mod != (T)0) ? Max - Mod : Min;
        }
        else if (EndVal > Max)
        {
            T Mod = FMath::Modulo(EndVal - Max, Size);
            EndVal = (Mod != (T)0) ? Min + Mod : Max;
        }
        return EndVal;
    }
 
    template <UE::CIntegral T>
    [[nodiscard]] static constexpr inline T WrapExclusive(const T X, const T Min, const T Max)
    {
        // Use unsigned type allow for large ranges which don't overflow on subtraction.
        using SizeType = std::make_unsigned_t<T>;
 
        // Our asserts are not constexpr-friendly yet
        // checkSlow(Min <= Max);
 
        SizeType Size = (SizeType)((SizeType)Max - (SizeType)Min);
        if (Size == 0)
        {
            // Guard against zero-sized ranges causing division by zero.
            return Max;
        }
 
        SizeType Mod;
        if (X < Min)
        {
            Mod = (SizeType)FMath::Modulo((SizeType)((SizeType)Min - (SizeType)X), Size);
            if (Mod > 0)
            {
                Mod = (SizeType)(Size - Mod);
            }
        }
        else
        {
            Mod = (SizeType)FMath::Modulo((SizeType)((SizeType)X - (SizeType)Min), Size);
        }
 
        return (T)(Min + Mod);
    }
 
    template <typename ValueType, typename BaseType>
    [[nodiscard]] static constexpr inline auto Modulo(ValueType Value, BaseType Base)
    {
        if constexpr (std::is_floating_point_v<ValueType>)
        {
            return FMath::Fmod(Value, Base);
        }
        else
        {
            return Value % Base;
        }
    }
 
    template< class T >
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T GridSnap(T Location, T Grid)
    {
        return (Grid == T{}) ? Location : (Floor((Location + (Grid/(T)2)) / Grid) * Grid);
    }
    MIX_FLOATS_2_ARGS(GridSnap);
 
    template <class T>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T DivideAndRoundUp(T Dividend, T Divisor)
    {
        return (Dividend + Divisor - 1) / Divisor;
    }
 
    template <class T>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T DivideAndRoundDown(T Dividend, T Divisor)
    {
        return Dividend / Divisor;
    }
 
    template <class T>
    [[nodiscard]] static constexpr inline T DivideAndRoundNearest(T Dividend, T Divisor)
    {
        return (Dividend >= 0)
            ? (Dividend + Divisor / 2) / Divisor
            : (Dividend - Divisor / 2 + 1) / Divisor;
    }
 
    [[nodiscard]] static inline float Log2(float Value)
    {
        // Cached value for fast conversions
        constexpr float LogToLog2 = 1.44269502f; // 1.f / Loge(2.f)
        // Do the platform specific log and convert using the cached value
        return Loge(Value) * LogToLog2;
    }
 
    [[nodiscard]] static inline double Log2(double Value)
    {
        // Cached value for fast conversions
        constexpr double LogToLog2 = 1.4426950408889634; // 1.0 / Loge(2.0);
        // Do the platform specific log and convert using the cached value
        return Loge(Value) * LogToLog2;
    }
 
    template <UE::CFloatingPoint T>
    static constexpr inline void SinCos(std::decay_t<T>* ScalarSin, std::decay_t<T>* ScalarCos, T  Value )
    {
        // Map Value to y in [-pi,pi], x = 2*pi*quotient + remainder.
        T quotient = (UE_INV_PI*0.5f)*Value;
        if (Value >= 0.0f)
        {
            quotient = (T)((int64)(quotient + 0.5f));
        }
        else
        {
            quotient = (T)((int64)(quotient - 0.5f));
        }
        T y = Value - UE_TWO_PI * quotient;
 
        // Map y to [-pi/2,pi/2] with sin(y) = sin(Value).
        T sign;
        if (y > UE_HALF_PI)
        {
            y = UE_PI - y;
            sign = -1.0f;
        }
        else if (y < -UE_HALF_PI)
        {
            y = -UE_PI - y;
            sign = -1.0f;
        }
        else
        {
            sign = +1.0f;
        }
 
        T y2 = y * y;
 
        // 11-degree minimax approximation
        *ScalarSin = ( ( ( ( (-2.3889859e-08f * y2 + 2.7525562e-06f) * y2 - 0.00019840874f ) * y2 + 0.0083333310f ) * y2 - 0.16666667f ) * y2 + 1.0f ) * y;
 
        // 10-degree minimax approximation
        T p = ( ( ( ( -2.6051615e-07f * y2 + 2.4760495e-05f ) * y2 - 0.0013888378f ) * y2 + 0.041666638f ) * y2 - 0.5f ) * y2 + 1.0f;
        *ScalarCos = sign*p;
    }
 
    static inline void SinCos(double* ScalarSin, double* ScalarCos, double Value)
    {
        // No approximations for doubles
        *ScalarSin = FMath::Sin(Value);
        *ScalarCos = FMath::Cos(Value);
    }
 
    template <
        typename T,
        typename U
        UE_REQUIRES(!std::is_same_v<T, U>)
    >
    static UE_FORCEINLINE_HINT void SinCos(T* ScalarSin, T* ScalarCos, U Value)
    {
        SinCos(ScalarSin, ScalarCos, T(Value));
    }
 
 
    // Note:  We use FASTASIN_HALF_PI instead of HALF_PI inside of FastASin(), since it was the value that accompanied the minimax coefficients below.
    // It is important to use exactly the same value in all places inside this function to ensure that FastASin(0.0f) == 0.0f.
    // For comparison:
    //      HALF_PI             == 1.57079632679f == 0x3fC90FDB
    //      FASTASIN_HALF_PI    == 1.5707963050f  == 0x3fC90FDA
#define FASTASIN_HALF_PI (1.5707963050f)
    [[nodiscard]] static inline float FastAsin(float Value)
    {
        // Clamp input to [-1,1].
        const bool nonnegative = (Value >= 0.0f);
        const float x = FMath::Abs(Value);
        float omx = 1.0f - x;
        if (omx < 0.0f)
        {
            omx = 0.0f;
        }
        const float root = FMath::Sqrt(omx);
        // 7-degree minimax approximation
        float result = ((((((-0.0012624911f * x + 0.0066700901f) * x - 0.0170881256f) * x + 0.0308918810f) * x - 0.0501743046f) * x + 0.0889789874f) * x - 0.2145988016f) * x + FASTASIN_HALF_PI;
        result *= root;  // acos(|x|)
        // acos(x) = pi - acos(-x) when x < 0, asin(x) = pi/2 - acos(x)
        return (nonnegative ? FASTASIN_HALF_PI - result : result - FASTASIN_HALF_PI);
    }
#undef FASTASIN_HALF_PI
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double FastAsin(double Value)
    {
        // TODO: add fast approximation
        return FMath::Asin(Value);
    }
 
    // Conversion Functions
 
    template<class T>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT auto RadiansToDegrees(T const& RadVal) -> decltype(RadVal * (180.f / UE_PI))
    {
        return RadVal * (180.f / UE_PI);
    }
 
    static constexpr UE_FORCEINLINE_HINT float RadiansToDegrees(float const& RadVal) { return RadVal * (180.f / UE_PI); }
    static constexpr UE_FORCEINLINE_HINT double RadiansToDegrees(double const& RadVal) { return RadVal * (180.0 / UE_DOUBLE_PI); }
 
    template<class T>
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT auto DegreesToRadians(T const& DegVal) -> decltype(DegVal * (UE_PI / 180.f))
    {
        return DegVal * (UE_PI / 180.f);
    }
 
    static constexpr UE_FORCEINLINE_HINT float DegreesToRadians(float const& DegVal) { return DegVal * (UE_PI / 180.f); }
    static constexpr UE_FORCEINLINE_HINT double DegreesToRadians(double const& DegVal) { return DegVal * (UE_DOUBLE_PI / 180.0); }
 
    template<typename T>
    [[nodiscard]] static T ClampAngle(T AngleDegrees, T MinAngleDegrees, T MaxAngleDegrees);
 
    RESOLVE_FLOAT_AMBIGUITY_3_ARGS(ClampAngle);
 
    template <
        typename T,
        typename T2
        UE_REQUIRES(std::is_floating_point_v<T> || std::is_floating_point_v<T2>)
    >
    [[nodiscard]] static constexpr auto FindDeltaAngleDegrees(T A1, T2 A2) -> decltype(A1 - A2)
    {
        // Find the difference
        auto Delta = A2 - A1;
 
        using DeltaType = decltype(Delta);
 
        // Return delta in [-180,180] range
        return Wrap(Delta, (DeltaType)-180, (DeltaType)180);
    }
 
    template <
        typename T,
        typename T2
        UE_REQUIRES(std::is_floating_point_v<T> || std::is_floating_point_v<T2>)
    >
    [[nodiscard]] static constexpr auto FindDeltaAngleRadians(T A1, T2 A2) -> decltype(A1 - A2)
    {
        // Find the difference
        auto Delta = A2 - A1;
 
        using DeltaType = decltype(Delta);
 
        // Return delta in [-PI,PI] range
        return Wrap(Delta, (DeltaType)-UE_PI, (DeltaType)UE_PI);
    }
 
    template <UE::CFloatingPoint T>
    [[nodiscard]] static constexpr T UnwindRadians(T A)
    {
        while(A > UE_PI)
        {
            A -= UE_TWO_PI;
        }
 
        while(A < -UE_PI)
        {
            A += UE_TWO_PI;
        }
 
        return A;
    }
 
    template <UE::CFloatingPoint T>
    [[nodiscard]] static constexpr T UnwindDegrees(T A)
    {
        while(A > 180.f)
        {
            A -= 360.f;
        }
 
        while(A < -180.f)
        {
            A += 360.f;
        }
 
        return A;
    }
 
    static CORE_API void WindRelativeAnglesDegrees(float InAngle0, float& InOutAngle1);
    static CORE_API void WindRelativeAnglesDegrees(double InAngle0, double& InOutAngle1);
 
    [[nodiscard]] static CORE_API float FixedTurn(float InCurrent, float InDesired, float InDeltaRate);
 
    template<typename T>
    static inline void CartesianToPolar(const T X, const T Y, T& OutRad, T& OutAng)
    {
        OutRad = Sqrt(Square(X) + Square(Y));
        OutAng = Atan2(Y, X);
    }
    template<typename T>
    static UE_FORCEINLINE_HINT void CartesianToPolar(const UE::Math::TVector2<T> InCart, UE::Math::TVector2<T>& OutPolar)
    {
        CartesianToPolar(InCart.X, InCart.Y, OutPolar.X, OutPolar.Y);
    }
 
    template<typename T>
    static inline void PolarToCartesian(const T Rad, const T Ang, T& OutX, T& OutY)
    {
        OutX = Rad * Cos(Ang);
        OutY = Rad * Sin(Ang);
    }
    template<typename T>
    static UE_FORCEINLINE_HINT void PolarToCartesian(const UE::Math::TVector2<T> InPolar, UE::Math::TVector2<T>& OutCart)
    {
        PolarToCartesian(InPolar.X, InPolar.Y, OutCart.X, OutCart.Y);
    }
 
    static CORE_API bool GetDotDistance(FVector2D &OutDotDist, const FVector &Direction, const FVector &AxisX, const FVector &AxisY, const FVector &AxisZ);
 
    [[nodiscard]] static CORE_API FVector2D GetAzimuthAndElevation(const FVector &Direction, const FVector &AxisX, const FVector &AxisY, const FVector &AxisZ);
 
    // Interpolation Functions
 
    template <UE::CFloatingPoint T, typename T2>
    [[nodiscard]] static constexpr inline auto GetRangePct(T MinValue, T MaxValue, T2 Value)
    {
        // Avoid Divide by Zero.
        // But also if our range is a point, output whether Value is before or after.
        const T Divisor = MaxValue - MinValue;
        if (FMath::IsNearlyZero(Divisor))
        {
            using RetType = decltype(T() / T2());
            return (Value >= MaxValue) ? (RetType)1 : (RetType)0;
        }
 
        return (Value - MinValue) / Divisor;
    }
 
    template <UE::CFloatingPoint T, typename T2>
    [[nodiscard]] static auto GetRangePct(UE::Math::TVector2<T> const& Range, T2 Value)
    {
        return GetRangePct(Range.X, Range.Y, Value);
    }
    
    template <UE::CFloatingPoint T, typename T2>
    [[nodiscard]] static auto GetRangeValue(UE::Math::TVector2<T> const& Range, T2 Pct)
    {
        return Lerp(Range.X, Range.Y, Pct);
    }
 
    template<typename T, typename T2>
    [[nodiscard]] static inline auto GetMappedRangeValueClamped(const UE::Math::TVector2<T>& InputRange, const UE::Math::TVector2<T>& OutputRange, const T2 Value)
    {
        using RangePctType = decltype(T() * T2());
        const RangePctType ClampedPct = Clamp<RangePctType>(GetRangePct(InputRange, Value), 0.f, 1.f);
        return GetRangeValue(OutputRange, ClampedPct);
    }
 
    template<typename T, typename T2>
    [[nodiscard]] static UE_FORCEINLINE_HINT auto GetMappedRangeValueUnclamped(const UE::Math::TVector2<T>& InputRange, const UE::Math::TVector2<T>& OutputRange, const T2 Value)
    {
        return GetRangeValue(OutputRange, GetRangePct(InputRange, Value));
    }
 
    template<class T>
    [[nodiscard]] static UE_FORCEINLINE_HINT double GetRangePct(TRange<T> const& Range, T Value)
    {
        return GetRangePct(Range.GetLowerBoundValue(), Range.GetUpperBoundValue(), Value);
    }
 
    template<class T>
    [[nodiscard]] static UE_FORCEINLINE_HINT T GetRangeValue(TRange<T> const& Range, T Pct)
    {
        return FMath::Lerp<T>(Range.GetLowerBoundValue(), Range.GetUpperBoundValue(), Pct);
    }
 
    template<class T>
    [[nodiscard]] static inline T GetMappedRangeValueClamped(const TRange<T>& InputRange, const TRange<T>& OutputRange, const T Value)
    {
        const T ClampedPct = FMath::Clamp<T>(GetRangePct(InputRange, Value), 0, 1);
        return GetRangeValue(OutputRange, ClampedPct);
    }
 
    template <
        typename T,
        typename U
        UE_REQUIRES(!TCustomLerp<T>::Value && (std::is_floating_point_v<U> || std::is_same_v<T, U>) && !std::is_same_v<T, bool>)
    >
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T Lerp( const T& A, const T& B, const U& Alpha )
    {
        return (T)(A + Alpha * (B-A));
    }
 
    template <
        typename T,
        typename U
        UE_REQUIRES(TCustomLerp<T>::Value)
    >
    [[nodiscard]] static UE_FORCEINLINE_HINT T Lerp(const T& A, const T& B, const U& Alpha)
    {
        return TCustomLerp<T>::Lerp(A, B, Alpha);
    }
 
    // Allow passing of differing A/B types.
    template <
        typename T1,
        typename T2,
        typename T3
        UE_REQUIRES(!std::is_same_v<T1, T2> && !TCustomLerp<T1>::Value && !TCustomLerp<T2>::Value)
    >
    [[nodiscard]] static auto Lerp( const T1& A, const T2& B, const T3& Alpha ) -> decltype(A * B)
    {
        using ABType = decltype(A * B);
        return Lerp(ABType(A), ABType(B), Alpha);
    }
 
    template< class T > 
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T LerpStable( const T& A, const T& B, double Alpha )
    {
        return (T)((A * (1.0 - Alpha)) + (B * Alpha));
    }
 
    template< class T >
    [[nodiscard]] static constexpr UE_FORCEINLINE_HINT T LerpStable(const T& A, const T& B, float Alpha)
    {
        return (T)((A * (1.0f - Alpha)) + (B * Alpha));
    }
 
    // Allow passing of differing A/B types.
    template <
        typename T1,
        typename T2,
        typename T3
        UE_REQUIRES(!std::is_same_v<T1, T2>)
    >
    [[nodiscard]] static auto LerpStable( const T1& A, const T2& B, const T3& Alpha ) -> decltype(A * B)
    {
        using ABType = decltype(A * B);
        return LerpStable(ABType(A), ABType(B), Alpha);
    }
    
    template <
        typename T,
        typename U
        UE_REQUIRES(!TCustomLerp<T>::Value && (std::is_floating_point_v<U> || std::is_same_v<T, U>))
    >
    [[nodiscard]] static constexpr inline T BiLerp(const T& P00,const T& P10,const T& P01,const T& P11, const U& FracX, const U& FracY)
    {
        return Lerp(
            Lerp(P00,P10,FracX),
            Lerp(P01,P11,FracX),
            FracY
            );
    }
 
    template <
        typename T,
        typename U
        UE_REQUIRES(TCustomLerp<T>::Value)
    >
    [[nodiscard]] static UE_FORCEINLINE_HINT T BiLerp(const T& P00, const T& P10, const T& P01, const T& P11, const U& FracX, const U& FracY)
    {
        return TCustomLerp<T>::BiLerp(P00, P10, P01, P11, FracX, FracY);
    }
 
    template <
        typename T,
        typename U
        UE_REQUIRES(!TCustomLerp<T>::Value && (std::is_floating_point_v<U> || std::is_same_v<T, U>))
    >
    [[nodiscard]] static constexpr inline T CubicInterp( const T& P0, const T& T0, const T& P1, const T& T1, const U& A )
    {
        const U A2 = A * A;
        const U A3 = A2 * A;
 
        return T((((2*A3)-(3*A2)+1) * P0) + ((A3-(2*A2)+A) * T0) + ((A3-A2) * T1) + (((-2*A3)+(3*A2)) * P1));
    }
 
    template <
        typename T,
        typename U
        UE_REQUIRES(TCustomLerp<T>::Value)
    >
    [[nodiscard]] static UE_FORCEINLINE_HINT T CubicInterp(const T& P0, const T& T0, const T& P1, const T& T1, const U& A)
    {
        return TCustomLerp<T>::CubicInterp(P0, T0, P1, T1, A);
    }
 
    template <typename T, UE::CFloatingPoint U>
    [[nodiscard]] static constexpr inline T CubicInterpDerivative( const T& P0, const T& T0, const T& P1, const T& T1, const U& A )
    {
        T a = 6.f*P0 + 3.f*T0 + 3.f*T1 - 6.f*P1;
        T b = -6.f*P0 - 4.f*T0 - 2.f*T1 + 6.f*P1;
        T c = T0;
 
        const U A2 = A * A;
 
        return T((a * A2) + (b * A) + c);
    }
 
    template <typename T, UE::CFloatingPoint U>
    [[nodiscard]] static constexpr inline T CubicInterpSecondDerivative( const T& P0, const T& T0, const T& P1, const T& T1, const U& A )
    {
        T a = 12.f*P0 + 6.f*T0 + 6.f*T1 - 12.f*P1;
        T b = -6.f*P0 - 4.f*T0 - 2.f*T1 + 6.f*P1;
 
        return (a * A) + b;
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpEaseIn(const T& A, const T& B, float Alpha, float Exp)
    {
        float const ModifiedAlpha = Pow(Alpha, Exp);
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpEaseOut(const T& A, const T& B, float Alpha, float Exp)
    {
        float const ModifiedAlpha = 1.f - Pow(1.f - Alpha, Exp);
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T > 
    [[nodiscard]] static inline T InterpEaseInOut( const T& A, const T& B, float Alpha, float Exp )
    {
        return Lerp<T>(A, B, (Alpha < 0.5f) ?
            InterpEaseIn(0.f, 1.f, Alpha * 2.f, Exp) * 0.5f :
            InterpEaseOut(0.f, 1.f, Alpha * 2.f - 1.f, Exp) * 0.5f + 0.5f);
    }
 
    template< class T >
    [[nodiscard]] static constexpr inline T InterpStep(const T& A, const T& B, float Alpha, int32 Steps)
    {
        if (Steps <= 1 || Alpha <= 0)
        {
            return A;
        }
        else if (Alpha >= 1)
        {
            return B;
        }
 
        const float StepsAsFloat = static_cast<float>(Steps);
        const float NumIntervals = StepsAsFloat - 1.f;
        float const ModifiedAlpha = FloorToFloat(Alpha * StepsAsFloat) / NumIntervals;
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpSinIn(const T& A, const T& B, float Alpha)
    {
        float const ModifiedAlpha = -1.f * Cos(Alpha * UE_HALF_PI) + 1.f;
        return Lerp<T>(A, B, ModifiedAlpha);
    }
    
    template< class T >
    [[nodiscard]] static inline T InterpSinOut(const T& A, const T& B, float Alpha)
    {
        float const ModifiedAlpha = Sin(Alpha * UE_HALF_PI);
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpSinInOut(const T& A, const T& B, float Alpha)
    {
        return Lerp<T>(A, B, (Alpha < 0.5f) ?
            InterpSinIn(0.f, 1.f, Alpha * 2.f) * 0.5f :
            InterpSinOut(0.f, 1.f, Alpha * 2.f - 1.f) * 0.5f + 0.5f);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpExpoIn(const T& A, const T& B, float Alpha)
    {
        float const ModifiedAlpha = (Alpha == 0.f) ? 0.f : Pow(2.f, 10.f * (Alpha - 1.f));
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpExpoOut(const T& A, const T& B, float Alpha)
    {
        float const ModifiedAlpha = (Alpha == 1.f) ? 1.f : -Pow(2.f, -10.f * Alpha) + 1.f;
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpExpoInOut(const T& A, const T& B, float Alpha)
    {
        return Lerp<T>(A, B, (Alpha < 0.5f) ?
            InterpExpoIn(0.f, 1.f, Alpha * 2.f) * 0.5f :
            InterpExpoOut(0.f, 1.f, Alpha * 2.f - 1.f) * 0.5f + 0.5f);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpCircularIn(const T& A, const T& B, float Alpha)
    {
        float const ModifiedAlpha = -1.f * (Sqrt(1.f - Alpha * Alpha) - 1.f);
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpCircularOut(const T& A, const T& B, float Alpha)
    {
        Alpha -= 1.f;
        float const ModifiedAlpha = Sqrt(1.f - Alpha  * Alpha);
        return Lerp<T>(A, B, ModifiedAlpha);
    }
 
    template< class T >
    [[nodiscard]] static inline T InterpCircularInOut(const T& A, const T& B, float Alpha)
    {
        return Lerp<T>(A, B, (Alpha < 0.5f) ?
            InterpCircularIn(0.f, 1.f, Alpha * 2.f) * 0.5f :
            InterpCircularOut(0.f, 1.f, Alpha * 2.f - 1.f) * 0.5f + 0.5f);
    }
 
    // Rotator specific interpolation
    // Similar to Lerp, but does not take the shortest path. Allows interpolation over more than 180 degrees.
    template< typename T, typename U >
    [[nodiscard]] static UE::Math::TRotator<T> LerpRange(const UE::Math::TRotator<T>& A, const UE::Math::TRotator<T>& B, U Alpha);
 
    /*
     *  Cubic Catmull-Rom Spline interpolation. Based on http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf 
     *  Curves are guaranteed to pass through the control points and are easily chained together.
     *  Equation supports abitrary parameterization. eg. Uniform=0,1,2,3 ; chordal= |Pn - Pn-1| ; centripetal = |Pn - Pn-1|^0.5
     *  P0 - The control point preceding the interpolation range.
     *  P1 - The control point starting the interpolation range.
     *  P2 - The control point ending the interpolation range.
     *  P3 - The control point following the interpolation range.
     *  T0-3 - The interpolation parameters for the corresponding control points.       
     *  T - The interpolation factor in the range 0 to 1. 0 returns P1. 1 returns P2.
     */
    template< class U > 
    [[nodiscard]] static constexpr inline U CubicCRSplineInterp(const U& P0, const U& P1, const U& P2, const U& P3, const float T0, const float T1, const float T2, const float T3, const float T)
    {
        //Based on http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf 
        float InvT1MinusT0 = 1.0f / (T1 - T0);
        U L01 = ( P0 * ((T1 - T) * InvT1MinusT0) ) + ( P1 * ((T - T0) * InvT1MinusT0) );
        float InvT2MinusT1 = 1.0f / (T2 - T1);
        U L12 = ( P1 * ((T2 - T) * InvT2MinusT1) ) + ( P2 * ((T - T1) * InvT2MinusT1) );
        float InvT3MinusT2 = 1.0f / (T3 - T2);
        U L23 = ( P2 * ((T3 - T) * InvT3MinusT2) ) + ( P3 * ((T - T2) * InvT3MinusT2) );
 
        float InvT2MinusT0 = 1.0f / (T2 - T0);
        U L012 = ( L01 * ((T2 - T) * InvT2MinusT0) ) + ( L12 * ((T - T0) * InvT2MinusT0) );
        float InvT3MinusT1 = 1.0f / (T3 - T1);
        U L123 = ( L12 * ((T3 - T) * InvT3MinusT1) ) + ( L23 * ((T - T1) * InvT3MinusT1) );
 
        return  ( ( L012 * ((T2 - T) * InvT2MinusT1) ) + ( L123 * ((T - T1) * InvT2MinusT1) ) );
    }
 
    /* Same as CubicCRSplineInterp but with additional saftey checks. If the checks fail P1 is returned. **/
    template< class U >
    [[nodiscard]] static constexpr inline U CubicCRSplineInterpSafe(const U& P0, const U& P1, const U& P2, const U& P3, const float T0, const float T1, const float T2, const float T3, const float T)
    {
        //Based on http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf 
        float T1MinusT0 = (T1 - T0);
        float T2MinusT1 = (T2 - T1);
        float T3MinusT2 = (T3 - T2);
        float T2MinusT0 = (T2 - T0);
        float T3MinusT1 = (T3 - T1);
        if (FMath::IsNearlyZero(T1MinusT0) || FMath::IsNearlyZero(T2MinusT1) || FMath::IsNearlyZero(T3MinusT2) || FMath::IsNearlyZero(T2MinusT0) || FMath::IsNearlyZero(T3MinusT1))
        {
            //There's going to be a divide by zero here so just bail out and return P1
            return P1;
        }
 
        float InvT1MinusT0 = 1.0f / T1MinusT0;
        U L01 = (P0 * ((T1 - T) * InvT1MinusT0)) + (P1 * ((T - T0) * InvT1MinusT0));
        float InvT2MinusT1 = 1.0f / T2MinusT1;
        U L12 = (P1 * ((T2 - T) * InvT2MinusT1)) + (P2 * ((T - T1) * InvT2MinusT1));
        float InvT3MinusT2 = 1.0f / T3MinusT2;
        U L23 = (P2 * ((T3 - T) * InvT3MinusT2)) + (P3 * ((T - T2) * InvT3MinusT2));
 
        float InvT2MinusT0 = 1.0f / T2MinusT0;
        U L012 = (L01 * ((T2 - T) * InvT2MinusT0)) + (L12 * ((T - T0) * InvT2MinusT0));
        float InvT3MinusT1 = 1.0f / T3MinusT1;
        U L123 = (L12 * ((T3 - T) * InvT3MinusT1)) + (L23 * ((T - T1) * InvT3MinusT1));
 
        return  ((L012 * ((T2 - T) * InvT2MinusT1)) + (L123 * ((T - T1) * InvT2MinusT1)));
    }
 
 
    // Special-case interpolation
 
    [[nodiscard]] static CORE_API FVector VInterpNormalRotationTo(const FVector& Current, const FVector& Target, float DeltaTime, float RotationSpeedDegrees);
 
    [[nodiscard]] static CORE_API FVector VInterpConstantTo(const FVector& Current, const FVector& Target, float DeltaTime, float InterpSpeed);
 
    [[nodiscard]] static CORE_API FVector VInterpTo( const FVector& Current, const FVector& Target, float DeltaTime, float InterpSpeed );
    
    [[nodiscard]] static CORE_API FVector2D Vector2DInterpConstantTo( const FVector2D& Current, const FVector2D& Target, float DeltaTime, float InterpSpeed );
 
    template <typename T>
    [[nodiscard]] static CORE_API UE::Math::TVector2<T> Vector2DInterpTo( const UE::Math::TVector2<T>& Current, const UE::Math::TVector2<T>& Target, float DeltaTime, float InterpSpeed );
 
    [[nodiscard]] static CORE_API FRotator RInterpConstantTo( const FRotator& Current, const FRotator& Target, float DeltaTime, float InterpSpeed);
 
    [[nodiscard]] static CORE_API FRotator RInterpTo( const FRotator& Current, const FRotator& Target, float DeltaTime, float InterpSpeed);
 
    template<typename T1, typename T2 = T1, typename T3 = T2, typename T4 = T3>
    [[nodiscard]] static auto FInterpConstantTo( T1 Current, T2 Target, T3 DeltaTime, T4 InterpSpeed )
    {
        static_assert(!std::is_same_v<T1, bool> && !std::is_same_v<T2, bool>, "Boolean types may not be interpolated");
        using RetType = decltype(T1() * T2() * T3() * T4());
    
        const RetType Dist = Target - Current;
 
        // If distance is too small, just set the desired location
        if( FMath::Square(Dist) < UE_SMALL_NUMBER )
        {
            return static_cast<RetType>(Target);
        }
 
        const RetType Step = InterpSpeed * DeltaTime;
        return Current + FMath::Clamp(Dist, -Step, Step);
    }
 
    template<typename T1, typename T2 = T1, typename T3 = T2, typename T4 = T3>
    [[nodiscard]] static auto FInterpTo( T1  Current, T2 Target, T3 DeltaTime, T4 InterpSpeed )
    {
        static_assert(!std::is_same_v<T1, bool> && !std::is_same_v<T2, bool>, "Boolean types may not be interpolated");
        using RetType = decltype(T1() * T2() * T3() * T4());
    
        // If no interp speed, jump to target value
        if( InterpSpeed <= 0.f )
        {
            return static_cast<RetType>(Target);
        }
 
        // Distance to reach
        const RetType Dist = Target - Current;
 
        // If distance is too small, just set the desired location
        if( FMath::Square(Dist) < UE_SMALL_NUMBER )
        {
            return static_cast<RetType>(Target);
        }
 
        // Delta Move, Clamp so we do not over shoot.
        const RetType DeltaMove = Dist * FMath::Clamp<RetType>(DeltaTime * InterpSpeed, 0.f, 1.f);
 
        return Current + DeltaMove;             
    }
 
    [[nodiscard]] static CORE_API FLinearColor CInterpTo(const FLinearColor& Current, const FLinearColor& Target, float DeltaTime, float InterpSpeed);
 
    template< class T >
    [[nodiscard]] static CORE_API UE::Math::TQuat<T> QInterpConstantTo(const UE::Math::TQuat<T>& Current, const UE::Math::TQuat<T>& Target, float DeltaTime, float InterpSpeed);
 
    template< class T >
    [[nodiscard]] static CORE_API UE::Math::TQuat<T> QInterpTo(const UE::Math::TQuat<T>& Current, const UE::Math::TQuat<T>& Target, float DeltaTime, float InterpSpeed);
 
    template<class T>
    [[nodiscard]] static constexpr T InvExpApprox(T X)
    {
        constexpr T A(1.00746054f); // 1 / 1! in Taylor series
        constexpr T B(0.45053901f); // 1 / 2! in Taylor series
        constexpr T C(0.25724632f); // 1 / 3! in Taylor series
        return 1 / (1 + A * X + B * X * X + C * X * X * X);     
    }
    
    template< class T >
    static constexpr void ExponentialSmoothingApprox(
        T&          InOutValue,
        const T&    InTargetValue,
        const float InDeltaTime,
        const float InSmoothingTime)
    {
        if (InSmoothingTime > UE_KINDA_SMALL_NUMBER)
        {
            const float A = InDeltaTime / InSmoothingTime;
            float Exp = InvExpApprox(A);
            InOutValue = InTargetValue + (InOutValue - InTargetValue) * Exp;
        }
        else
        {
            InOutValue = InTargetValue;
        }
    }
 
    template< class T >
    static constexpr void CriticallyDampedSmoothing(
        T&          InOutValue,
        T&          InOutValueRate,
        const T&    InTargetValue,
        const T&    InTargetValueRate,
        const float InDeltaTime,
        const float InSmoothingTime)
    {
        if (InSmoothingTime > UE_KINDA_SMALL_NUMBER)
        {
            // The closed form solution for critically damped motion towards zero is:
            //
            // x = ( x0 + t (v0 + w x0) ) exp(-w t)
            //
            // where w is the natural frequency, x0, v0 are x and dx/dt at time 0 (e.g. Brian Stone - Chatter and Machine Tools pdf)
            //
            // Differentiate to get velocity (remember d(v0)/dt = 0):
            //
            // v = ( v0 - w t (v0 + w x0) ) exp(-w t)
            //
            // We're damping towards a target, so convert - i.e. x = value - target
            //
            // Target velocity turns into an offset to the position
            T AdjustedTarget = InTargetValue + InTargetValueRate * InSmoothingTime;
 
            const float W = 2.0f / InSmoothingTime;
            const float A = W * InDeltaTime;
            // Approximation requires A < 1, so DeltaTime < SmoothingTime / 2
            const float Exp = InvExpApprox(A);
            T X0 = InOutValue - AdjustedTarget;
            // Target velocity turns into an offset to the position
            X0 -= InTargetValueRate * InSmoothingTime;      
            const T B = (InOutValueRate + X0 * W) * InDeltaTime;
            InOutValue = AdjustedTarget + (X0 + B) * Exp;
            InOutValueRate = (InOutValueRate - B * W) * Exp;
        }
        else if (InDeltaTime > 0.0f)
        {
            InOutValueRate = (InTargetValue - InOutValue) / InDeltaTime;
            InOutValue = InTargetValue;
        }
        else
        {
            InOutValue = InTargetValue;
            InOutValueRate = T(0);
        }
    }
 
    template< class T >
    static void SpringDamper(
        T&          InOutValue,
        T&          InOutValueRate,
        const T&    InTargetValue,
        const T&    InTargetValueRate,
        const float InDeltaTime,
        const float InUndampedFrequency,
        const float InDampingRatio)
    {
        if (InDeltaTime <= 0.0f)
        {
            return;
        }
 
        float W = InUndampedFrequency * UE_TWO_PI;
        // Handle special cases
        if (W < UE_SMALL_NUMBER) // no strength which means no damping either
        {
            InOutValue += InOutValueRate * InDeltaTime;
            return;
        }
        else if (InDampingRatio < UE_SMALL_NUMBER) // No damping at all
        {
            T Err = InOutValue - InTargetValue;
            const T B = InOutValueRate / W;
            float S, C;
            FMath::SinCos(&S, &C, W * InDeltaTime);
            InOutValue = InTargetValue + Err * C + B * S;
            InOutValueRate = InOutValueRate * C - Err * (W * S);
            return;
        }
 
        // Target velocity turns into an offset to the position
        float SmoothingTime = 2.0f / W;
        T AdjustedTarget = InTargetValue + InTargetValueRate * (InDampingRatio * SmoothingTime);
        T Err = InOutValue - AdjustedTarget;
 
        // Handle the cases separately
        if (InDampingRatio > 1.0f) // Overdamped
        {
            const float WD = W * FMath::Sqrt(FMath::Square(InDampingRatio) - 1.0f);
            const T C2 = -(InOutValueRate + (W * InDampingRatio - WD) * Err) / (2.0f * WD);
            const T C1 = Err - C2;
            const float A1 = (WD - InDampingRatio * W);
            const float A2 = -(WD + InDampingRatio * W);
            // Note that A1 and A2 will always be negative. We will use an approximation for 1/Exp(-A * DeltaTime).
            const float A1_DT = -A1 * InDeltaTime;
            const float A2_DT = -A2 * InDeltaTime;
            // This approximation in practice will be good for all DampingRatios
            const float E1 = InvExpApprox(A1_DT);
            // As DampingRatio gets big, this approximation gets worse, but mere inaccuracy for overdamped motion is
            // not likely to be important, since we end up with 1 / BigNumber
            const float E2 = InvExpApprox(A2_DT);
            InOutValue = AdjustedTarget + E1 * C1 + E2 * C2;
            InOutValueRate = E1 * C1 * A1 + E2 * C2 * A2;
        }
        else if (InDampingRatio < 1.0f) // Underdamped
        {
            const float WD = W * FMath::Sqrt(1.0f - FMath::Square(InDampingRatio));
            const T A = Err;
            const T B = (InOutValueRate + Err * (InDampingRatio * W)) / WD;
            float S, C;
            FMath::SinCos(&S, &C, WD * InDeltaTime);
            const float E0 = InDampingRatio * W * InDeltaTime;
            // Needs E0 < 1 so DeltaTime < SmoothingTime / (2 * DampingRatio * Sqrt(1 - DampingRatio^2))
            const float E = InvExpApprox(E0);
            InOutValue = E * (A * C + B * S);
            InOutValueRate = -InOutValue * InDampingRatio * W;
            InOutValueRate += E * (B * (WD * C) - A * (WD * S));
            InOutValue += AdjustedTarget;
        }
        else // Critical damping
        {
            const T& C1 = Err;
            T C2 = InOutValueRate + Err * W;
            const float E0 = W * InDeltaTime;
            // Needs E0 < 1 so InDeltaTime < SmoothingTime / 2 
            float E = InvExpApprox(E0);
            InOutValue = AdjustedTarget + (C1 + C2 * InDeltaTime) * E;
            InOutValueRate = (C2 - C1 * W - C2 * (W * InDeltaTime)) * E;
        }
    }
 
    template< class T >
    static void SpringDamperSmoothing(
        T&          InOutValue,
        T&          InOutValueRate,
        const T&    InTargetValue,
        const T&    InTargetValueRate,
        const float InDeltaTime,
        const float InSmoothingTime,
        const float InDampingRatio)
    {
        if (InSmoothingTime < UE_SMALL_NUMBER)
        {
            if (InDeltaTime <= 0.0f)
            {
                return;
            }
            InOutValueRate = (InTargetValue - InOutValue) / InDeltaTime;
            InOutValue = InTargetValue;
            return;
        }
 
        // Undamped frequency
        float UndampedFrequency = 1.0f / (UE_PI * InSmoothingTime);
        SpringDamper(InOutValue, InOutValueRate, InTargetValue, InTargetValueRate, InDeltaTime, UndampedFrequency, InDampingRatio);
    }
 
    [[nodiscard]] static float MakePulsatingValue( const double InCurrentTime, const float InPulsesPerSecond, const float InPhase = 0.0f )
    {
        return 0.5f + 0.5f * FMath::Sin( ( ( 0.25f + InPhase ) * UE_TWO_PI ) + ( (float)InCurrentTime * UE_TWO_PI ) * InPulsesPerSecond );
    }
 
    // Geometry intersection 
 
    template<typename FReal>
    [[nodiscard]] static UE::Math::TVector<FReal> RayPlaneIntersection(const UE::Math::TVector<FReal>& RayOrigin, const UE::Math::TVector<FReal>& RayDirection, const UE::Math::TPlane<FReal>& Plane);
 
    template<typename FReal>
    [[nodiscard]] static FReal RayPlaneIntersectionParam(const UE::Math::TVector<FReal>& RayOrigin, const UE::Math::TVector<FReal>& RayDirection, const UE::Math::TPlane<FReal>& Plane);
 
    template<typename FReal>
    [[nodiscard]] static UE::Math::TVector<FReal> LinePlaneIntersection(const UE::Math::TVector<FReal>& Point1, const UE::Math::TVector<FReal>& Point2, const UE::Math::TVector<FReal>& PlaneOrigin, const UE::Math::TVector<FReal>& PlaneNormal);
 
    template<typename FReal>
    [[nodiscard]] static UE::Math::TVector<FReal> LinePlaneIntersection(const UE::Math::TVector<FReal>& Point1, const UE::Math::TVector<FReal>& Point2, const UE::Math::TPlane<FReal>& Plane);
 
 
    // @parma InOutScissorRect should be set to View.ViewRect before the call
    // @return 0: light is not visible, 1:use scissor rect, 2: no scissor rect needed
    [[nodiscard]] static CORE_API uint32 ComputeProjectedSphereScissorRect(FIntRect& InOutScissorRect, FVector SphereOrigin, float Radius, FVector ViewOrigin, const FMatrix& ViewMatrix, const FMatrix& ProjMatrix);
 
    // @param ConeOrigin Cone origin
    // @param ConeDirection Cone direction
    // @param ConeRadius Cone Radius
    // @param CosConeAngle Cos of the cone angle
    // @param SinConeAngle Sin of the cone angle
    // @return Minimal bounding sphere encompassing given cone
    template<typename FReal>
    [[nodiscard]] static UE::Math::TSphere<FReal> ComputeBoundingSphereForCone(UE::Math::TVector<FReal> const& ConeOrigin, UE::Math::TVector<FReal> const& ConeDirection, FReal ConeRadius, FReal CosConeAngle, FReal SinConeAngle);
 
    [[nodiscard]] static CORE_API bool PlaneAABBIntersection(const FPlane& P, const FBox& AABB);
 
    [[nodiscard]] static CORE_API int32 PlaneAABBRelativePosition(const FPlane& P, const FBox& AABB);
 
    template<typename FReal>
    [[nodiscard]] static bool SphereAABBIntersection(const UE::Math::TVector<FReal>& SphereCenter,const FReal RadiusSquared,const UE::Math::TBox<FReal>& AABB);
 
    template<typename FReal>
    [[nodiscard]] static bool SphereAABBIntersection(const UE::Math::TSphere<FReal>& Sphere, const UE::Math::TBox<FReal>& AABB);
 
    template<typename FReal>
    [[nodiscard]] static bool PointBoxIntersection( const UE::Math::TVector<FReal>& Point, const UE::Math::TBox<FReal>& Box );
 
    template<typename FReal>
    [[nodiscard]] static bool LineBoxIntersection( const UE::Math::TBox<FReal>& Box, const UE::Math::TVector<FReal>& Start, const UE::Math::TVector<FReal>& End, const UE::Math::TVector<FReal>& Direction );
 
    template<typename FReal>
    [[nodiscard]] static bool LineBoxIntersection( const UE::Math::TBox<FReal>& Box, const UE::Math::TVector<FReal>& Start, const UE::Math::TVector<FReal>& End, const UE::Math::TVector<FReal>& Direction, const UE::Math::TVector<FReal>& OneOverDirection );
 
    template<typename FReal>
    [[nodiscard]] static bool LineBoxIntersection2D( const UE::Math::TBox2<FReal>& Box, const UE::Math::TVector2<FReal>& Start, const UE::Math::TVector2<FReal>& End );
 
    /* Swept-Box vs Box test */
    static CORE_API bool LineExtentBoxIntersection(const FBox& inBox, const FVector& Start, const FVector& End, const FVector& Extent, FVector& HitLocation, FVector& HitNormal, float& HitTime);
 
    template<typename FReal>
    [[nodiscard]] static bool LineSphereIntersection(const UE::Math::TVector<FReal>& Start,const UE::Math::TVector<FReal>& Dir, FReal Length,const UE::Math::TVector<FReal>& Origin, FReal Radius);
 
    [[nodiscard]] static CORE_API bool SphereConeIntersection(const FVector& SphereCenter, float SphereRadius, const FVector& ConeAxis, float ConeAngleSin, float ConeAngleCos);
 
    template<typename T>
    [[nodiscard]] static CORE_API UE::Math::TVector<T> ClosestPointOnLine(const UE::Math::TVector<T>& LineStart, const UE::Math::TVector<T>& LineEnd, const UE::Math::TVector<T>& Point);
 
    [[nodiscard]] static CORE_API FVector ClosestPointOnInfiniteLine(const FVector& LineStart, const FVector& LineEnd, const FVector& Point);
 
    template<typename FReal>
    [[nodiscard]] static bool IntersectPlanes3(UE::Math::TVector<FReal>& I, const UE::Math::TPlane<FReal>& P1, const UE::Math::TPlane<FReal>& P2, const UE::Math::TPlane<FReal>& P3 );
 
    template<typename FReal>
    [[nodiscard]] static bool IntersectPlanes2(UE::Math::TVector<FReal>& I, UE::Math::TVector<FReal>& D, const UE::Math::TPlane<FReal>& P1, const UE::Math::TPlane<FReal>& P2);
 
    static CORE_API float PointDistToLine(const FVector &Point, const FVector &Direction, const FVector &Origin, FVector &OutClosestPoint);
    [[nodiscard]] static CORE_API float PointDistToLine(const FVector &Point, const FVector &Direction, const FVector &Origin);
 
    template <typename T>
    [[nodiscard]] static CORE_API UE::Math::TVector<T> ClosestPointOnSegment(const UE::Math::TVector<T>&Point, const UE::Math::TVector<T>&StartPoint, const UE::Math::TVector<T>&EndPoint);
 
    template <typename T>
    [[nodiscard]] static CORE_API UE::Math::TVector2<T> ClosestPointOnSegment2D(const UE::Math::TVector2<T>& Point, const UE::Math::TVector2<T>& StartPoint, const UE::Math::TVector2<T>& EndPoint);
 
    [[nodiscard]] static CORE_API float PointDistToSegment(const FVector &Point, const FVector &StartPoint, const FVector &EndPoint);
 
    [[nodiscard]] static CORE_API float PointDistToSegmentSquared(const FVector &Point, const FVector &StartPoint, const FVector &EndPoint);
 
    static CORE_API void SegmentDistToSegment(FVector A1, FVector B1, FVector A2, FVector B2, FVector& OutP1, FVector& OutP2);
 
    template<typename T>
    static CORE_API void SegmentDistToSegmentSafe(UE::Math::TVector<T> A1, UE::Math::TVector<T> B1, UE::Math::TVector<T> A2, UE::Math::TVector<T> B2, UE::Math::TVector<T>& OutP1, UE::Math::TVector<T>& OutP2);
 
    [[nodiscard]] static CORE_API float GetTForSegmentPlaneIntersect(const FVector& StartPoint, const FVector& EndPoint, const FPlane& Plane);
 
    static CORE_API bool SegmentPlaneIntersection(const FVector& StartPoint, const FVector& EndPoint, const FPlane& Plane, FVector& out_IntersectionPoint);
 
 
    static CORE_API bool SegmentTriangleIntersection(const FVector& StartPoint, const FVector& EndPoint, const FVector& A, const FVector& B, const FVector& C, FVector& OutIntersectPoint, FVector& OutTriangleNormal);
 
    static CORE_API bool SegmentIntersection2D(const FVector& SegmentStartA, const FVector& SegmentEndA, const FVector& SegmentStartB, const FVector& SegmentEndB, FVector& out_IntersectionPoint);
 
 
    [[nodiscard]] static CORE_API FVector ClosestPointOnTriangleToPoint(const FVector& Point, const FVector& A, const FVector& B, const FVector& C);
 
    [[nodiscard]] static CORE_API FVector ClosestPointOnTetrahedronToPoint(const FVector& Point, const FVector& A, const FVector& B, const FVector& C, const FVector& D);
 
    static CORE_API void SphereDistToLine(FVector SphereOrigin, float SphereRadius, FVector LineOrigin, FVector LineDir, FVector& OutClosestPoint);
 
    [[nodiscard]] static CORE_API bool GetDistanceWithinConeSegment(FVector Point, FVector ConeStartPoint, FVector ConeLine, float RadiusAtStart, float RadiusAtEnd, float &PercentageOut);
 
    [[nodiscard]] static CORE_API bool PointsAreCoplanar(const TArray<FVector>& Points, const float Tolerance = 0.1f);
 
    [[nodiscard]] static CORE_API float TruncateToHalfIfClose(float F, float Tolerance = UE_SMALL_NUMBER);
    [[nodiscard]] static CORE_API double TruncateToHalfIfClose(double F, double Tolerance = UE_SMALL_NUMBER);
 
    [[nodiscard]] static CORE_API float RoundHalfToEven(float F);
    [[nodiscard]] static CORE_API double RoundHalfToEven(double F);
 
    [[nodiscard]] static CORE_API float RoundHalfFromZero(float F);
    [[nodiscard]] static CORE_API double RoundHalfFromZero(double F);
 
    [[nodiscard]] static CORE_API float RoundHalfToZero(float F);
    [[nodiscard]] static CORE_API double RoundHalfToZero(double F);
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float RoundFromZero(float F)
    {
        return (F < 0.0f) ? FloorToFloat(F) : CeilToFloat(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double RoundFromZero(double F)
    {
        return (F < 0.0) ? FloorToDouble(F) : CeilToDouble(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float RoundToZero(float F)
    {
        return (F < 0.0f) ? CeilToFloat(F) : FloorToFloat(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double RoundToZero(double F)
    {
        return (F < 0.0) ? CeilToDouble(F) : FloorToDouble(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float RoundToNegativeInfinity(float F)
    {
        return FloorToFloat(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double RoundToNegativeInfinity(double F)
    {
        return FloorToDouble(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT float RoundToPositiveInfinity(float F)
    {
        return CeilToFloat(F);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT double RoundToPositiveInfinity(double F)
    {
        return CeilToDouble(F);
    }
 
 
    // Formatting functions
 
    [[nodiscard]] static CORE_API FString FormatIntToHumanReadable(int32 Val);
 
 
    // Utilities
 
    [[nodiscard]] static CORE_API bool MemoryTest( void* BaseAddress, uint32 NumBytes );
 
    static CORE_API bool Eval( FString Str, float& OutValue );
 
    [[nodiscard]] static CORE_API FVector GetBaryCentric2D(const FVector& Point, const FVector& A, const FVector& B, const FVector& C);
 
    [[nodiscard]] static CORE_API FVector GetBaryCentric2D(const FVector2D& Point, const FVector2D& A, const FVector2D& B, const FVector2D& C);
 
    [[nodiscard]] static CORE_API FVector ComputeBaryCentric2D(const FVector& Point, const FVector& A, const FVector& B, const FVector& C);
 
    [[nodiscard]] static CORE_API bool ComputeBarycentricTri(const FVector& Point, const FVector& A, const FVector& B, const FVector& C, FVector& OutBarycentric, double Tolerance = UE_DOUBLE_SMALL_NUMBER);
 
    [[nodiscard]] static CORE_API FVector4 ComputeBaryCentric3D(const FVector& Point, const FVector& A, const FVector& B, const FVector& C, const FVector& D);
 
    static CORE_API const uint32 BitFlag[32];
 
    template<typename T>
    [[nodiscard]] static constexpr T SmoothStep(T A, T B, T X)
    {
        if (X < A)
        {
            return 0;
        }
        else if (X >= B)
        {
            return 1;
        }
        const T InterpFraction = (X - A) / (B - A);
        return InterpFraction * InterpFraction * (3.0f - 2.0f * InterpFraction);
    }
 
    [[nodiscard]] static constexpr bool ExtractBoolFromBitfield(const uint8* Ptr, uint32 Index)
    {
        const uint8* BytePtr = Ptr + Index / 8;
        uint8 Mask = (uint8)(1 << (Index & 0x7));
 
        return (*BytePtr & Mask) != 0;
    }
 
    static constexpr void SetBoolInBitField(uint8* Ptr, uint32 Index, bool bSet)
    {
        uint8* BytePtr = Ptr + Index / 8;
        uint8 Mask = (uint8)(1 << (Index & 0x7));
 
        if(bSet)
        {
            *BytePtr |= Mask;
        }
        else
        {
            *BytePtr &= ~Mask;
        }
    }
 
    static CORE_API void ApplyScaleToFloat(float& Dst, const FVector& DeltaScale, float Magnitude = 1.0f);
 
    // @param x assumed to be in this range: 0..1
    // @return 0..255
    [[nodiscard]] static uint8 Quantize8UnsignedByte(float x)
    {
        // 0..1 -> 0..255
        int32 Ret = (int32)(x * 255.f + 0.5f);
 
        check(Ret >= 0);
        check(Ret <= 255);
 
        return (uint8)Ret;
    }
    
    // @param x assumed to be in this range: -1..1
    // @return 0..255
    [[nodiscard]] static uint8 Quantize8SignedByte(float x)
    {
        // -1..1 -> 0..1
        float y = x * 0.5f + 0.5f;
 
        return Quantize8UnsignedByte(y);
    }
 
    // Use the Euclidean method to find the GCD
    [[nodiscard]] static constexpr int32 GreatestCommonDivisor(int32 a, int32 b)
    {
        while (b != 0)
        {
            int32 t = b;
            b = a % b;
            a = t;
        }
        return a;
    }
 
    // LCM = a/gcd * b
    // a and b are the number we want to find the lcm
    [[nodiscard]] static constexpr int32 LeastCommonMultiplier(int32 a, int32 b)
    {
        int32 CurrentGcd = GreatestCommonDivisor(a, b);
        return CurrentGcd == 0 ? 0 : (a / CurrentGcd) * b;
    }
 
    [[nodiscard]] static CORE_API float PerlinNoise1D(float Value);
 
    [[nodiscard]] static CORE_API float PerlinNoise2D(const FVector2D& Location);
     
 
    [[nodiscard]] static CORE_API float PerlinNoise3D(const FVector& Location);
 
    template<typename T>
    [[nodiscard]] static inline T WeightedMovingAverage(T CurrentSample, T PreviousSample, T Weight)
    {
        Weight = Clamp<T>(Weight, 0.f, 1.f);
        T WAvg = (CurrentSample * Weight) + (PreviousSample * (1.f - Weight));
        return WAvg;
    }
 
    template<typename T>
    [[nodiscard]] static inline T DynamicWeightedMovingAverage(T CurrentSample, T PreviousSample, T MaxDistance, T MinWeight, T MaxWeight)
    {
        // We need the distance between samples to determine how much of each weight to use
        const T Distance = Abs<T>(CurrentSample - PreviousSample);
        T Weight = MinWeight;
        if (MaxDistance > 0)
        {
            // Figure out the lerp value to use between the min/max weights
            const T LerpAlpha = Clamp<T>(Distance / MaxDistance, 0.f, 1.f);
            Weight = Lerp<T>(MinWeight, MaxWeight, LerpAlpha);
        }
        return WeightedMovingAverage(CurrentSample, PreviousSample, Weight);
    }
    
    [[nodiscard]] static CORE_API bool MatrixInverse(FMatrix44f* DstMatrix, const FMatrix44f* SrcMatrix);
    [[nodiscard]] static CORE_API bool MatrixInverse(FMatrix44d* DstMatrix, const FMatrix44d* SrcMatrix);
 
};
 
// LWC Conversion helpers
namespace UE
{
namespace LWC
{
 
    // Convert array to a new type
    template<typename TDest, typename TSrc, typename InAllocatorType>
    TArray<TDest, InAllocatorType> ConvertArrayType(const TArray<TSrc, InAllocatorType>& From)
    {
        //static_assert(!std::is_same_v<TDest, TSrc>, "Redundant call to ConvertArrayType");    // Unavoidable if supporting LWC toggle, but a useful check once LWC is locked to enabled.
        if constexpr (std::is_same_v<TDest, TSrc>)
        {
            return From;
        }
        else
        {
            TArray<TDest, InAllocatorType> Converted;
            Converted.Reserve(From.Num());
            for (const TSrc& Item : From)
            {
                Converted.Add(static_cast<TDest>(Item));
            }
            return Converted;
        }
    }
 
    // Convert array to a new type and clamps values to the Max of TDest type
    template<typename TDest, typename TSrc, typename InAllocatorType>
    TArray<TDest, InAllocatorType> ConvertArrayTypeClampMax(const TArray<TSrc, InAllocatorType>& From)
    {
        //static_assert(!std::is_same_v<TDest, TSrc>, "Redundant call to ConvertArrayType");    // Unavoidable if supporting LWC toggle, but a useful check once LWC is locked to enabled.
        if constexpr (std::is_same_v<TDest, TSrc>)
        {
            return From;
        }
        else
        {
            TArray<TDest, InAllocatorType> Converted;
            Converted.Reserve(From.Num());
            for (const TSrc& Item : From)
            {
                Converted.Add(FMath::Min(TNumericLimits<TDest>::Max(), static_cast<TDest>(Item)));
            }
            return Converted;
        }
    }
 
    /*
     * Floating point to integer conversions
     */
 
    // Generic float type to int type, to enable specializations below.
    template <UE::CIntegral OutIntType, UE::CFloatingPoint InFloatType>
    inline OutIntType FloatToIntCastChecked(InFloatType FloatValue)
    {
        return (OutIntType)(FloatValue);
    }
 
    // float->int32
    template<>
    inline int32 FloatToIntCastChecked(float FloatValue)
    {
        // floats over 2^31 - 1 - 64 overflow int32 after conversion.
        checkf(FloatValue >= float(TNumericLimits<int32>::Lowest()) && FloatValue <= float(TNumericLimits<int32>::Max() - 64), TEXT("Input value %f will exceed int32 limits"), FloatValue);
        return FMath::TruncToInt32(FloatValue);
    }
 
    // float->int64
    template<>
    inline int64 FloatToIntCastChecked(float FloatValue)
    {
        // floats over 2^63 - 1 - 2^39 overflow int64 after conversion.
        checkf(FloatValue >= float(TNumericLimits<int64>::Lowest()) && FloatValue <= float(TNumericLimits<int64>::Max() - (int64)549755813888), TEXT("Input value %f will exceed int64 limits"), FloatValue);
        return FMath::TruncToInt64(FloatValue);
    }
 
    // double->int32
    template<>
    inline int32 FloatToIntCastChecked(double FloatValue)
    {
        checkf(FloatValue >= double(TNumericLimits<int32>::Lowest()) && FloatValue <= double(TNumericLimits<int32>::Max()), TEXT("Input value %f will exceed int32 limits"), FloatValue);
        return FMath::TruncToInt32(FloatValue);
    }
 
    // double->int64
    template<>
    inline int64 FloatToIntCastChecked(double FloatValue)
    {
        // doubles over 2^63 - 1 - 512 overflow int64 after conversion.
        checkf(FloatValue >= double(TNumericLimits<int64>::Lowest()) && FloatValue <= double(TNumericLimits<int64>::Max() - 512), TEXT("Input value %f will exceed int64 limits"), FloatValue);
        return FMath::TruncToInt64(FloatValue);
    }
 
} // namespace LWC
} // namespace UE
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "Templates/Identity.h"
#endif