Merge pull request #3927 from Ansariel/develop-math-improvements

Add a bunch of old and new math improvements

Author: marchcat

indra/llappearance/llpolymorph.cpp

@@ -550,12 +550,12 @@ void LLPolyMorphTarget::apply( ESex avatar_sex )
 
     mLastSex = avatar_sex;
 
-    // Check for NaN condition (NaN is detected if a variable doesn't equal itself.
-    if (mCurWeight != mCurWeight)
+    // Check for NaN condition
+    if (llisnan(mCurWeight))
     {
-        mCurWeight = 0.0;
+        mCurWeight = 0.f;
     }
-    if (mLastWeight != mLastWeight)
+    if (llisnan(mLastWeight))
     {
         mLastWeight = mCurWeight+.001f;
     }

indra/llcommon/indra_constants.h

@@ -171,34 +171,34 @@ constexpr U32   MAXADDRSTR      = 17;       // 123.567.901.345 = 15 chars + \0 +
 
 // recursion tail
 template <typename T>
-inline auto llmax(T data)
+constexpr auto llmax(T data)
 {
     return data;
 }
 
 template <typename T0, typename T1, typename... Ts>
-inline auto llmax(T0 d0, T1 d1, Ts... rest)
+constexpr auto llmax(T0 d0, T1 d1, Ts... rest)
 {
     auto maxrest = llmax(d1, rest...);
     return (d0 > maxrest)? d0 : maxrest;
 }
 
 // recursion tail
 template <typename T>
-inline auto llmin(T data)
+constexpr auto llmin(T data)
 {
     return data;
 }
 
 template <typename T0, typename T1, typename... Ts>
-inline auto llmin(T0 d0, T1 d1, Ts... rest)
+constexpr auto llmin(T0 d0, T1 d1, Ts... rest)
 {
     auto minrest = llmin(d1, rest...);
     return (d0 < minrest) ? d0 : minrest;
 }
 
 template <typename A, typename MIN, typename MAX>
-inline A llclamp(A a, MIN minval, MAX maxval)
+constexpr A llclamp(A a, MIN minval, MAX maxval)
 {
     A aminval{ static_cast<A>(minval) }, amaxval{ static_cast<A>(maxval) };
     if ( a < aminval )
@@ -213,13 +213,13 @@ inline A llclamp(A a, MIN minval, MAX maxval)
 }
 
 template <class LLDATATYPE>
-inline LLDATATYPE llclampf(LLDATATYPE a)
+constexpr LLDATATYPE llclampf(LLDATATYPE a)
 {
     return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(1));
 }
 
 template <class LLDATATYPE>
-inline LLDATATYPE llclampb(LLDATATYPE a)
+constexpr LLDATATYPE llclampb(LLDATATYPE a)
 {
     return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(255));
 }

indra/llcommon/lldefs.h

@@ -164,14 +164,14 @@ class narrow
     FROM mValue;
 
 public:
-    narrow(FROM value): mValue(value) {}
+    constexpr narrow(FROM value): mValue(value) {}
 
     /*---------------------- Narrowing unsigned to signed ----------------------*/
     template <typename TO,
               typename std::enable_if<std::is_unsigned<FROM>::value &&
                                       std::is_signed<TO>::value,
                                       bool>::type = true>
-    inline
+    constexpr
     operator TO() const
     {
         // The reason we skip the
@@ -189,7 +189,7 @@ class narrow
               typename std::enable_if<! (std::is_unsigned<FROM>::value &&
                                          std::is_signed<TO>::value),
                                       bool>::type = true>
-    inline
+    constexpr
     operator TO() const
     {
         // two different assert()s so we can tell which condition failed

indra/llcommon/stdtypes.h

@@ -33,23 +33,23 @@
 #include "llplane.h"
 #include "llvector4a.h"
 
-const F32 DEFAULT_FIELD_OF_VIEW     = 60.f * DEG_TO_RAD;
-const F32 DEFAULT_ASPECT_RATIO      = 640.f / 480.f;
-const F32 DEFAULT_NEAR_PLANE        = 0.25f;
-const F32 DEFAULT_FAR_PLANE         = 64.f; // far reaches across two horizontal, not diagonal, regions
+constexpr F32 DEFAULT_FIELD_OF_VIEW = 60.f * DEG_TO_RAD;
+constexpr F32 DEFAULT_ASPECT_RATIO  = 640.f / 480.f;
+constexpr F32 DEFAULT_NEAR_PLANE    = 0.25f;
+constexpr F32 DEFAULT_FAR_PLANE     = 64.f; // far reaches across two horizontal, not diagonal, regions
 
-const F32 MAX_ASPECT_RATIO  = 50.0f;
-const F32 MAX_NEAR_PLANE    = 1023.9f; // Clamp the near plane just before the skybox ends
-const F32 MAX_FAR_PLANE     = 100000.0f; //1000000.0f; // Max allowed. Not good Z precision though.
-const F32 MAX_FAR_CLIP      = 512.0f;
+constexpr F32 MAX_ASPECT_RATIO  = 50.0f;
+constexpr F32 MAX_NEAR_PLANE    = 1023.9f;   // Clamp the near plane just before the skybox ends
+constexpr F32 MAX_FAR_PLANE     = 100000.0f; //1000000.0f; // Max allowed. Not good Z precision though.
+constexpr F32 MAX_FAR_CLIP      = 512.0f;
 
-const F32 MIN_ASPECT_RATIO  = 0.02f;
-const F32 MIN_NEAR_PLANE    = 0.1f;
-const F32 MIN_FAR_PLANE     = 0.2f;
+constexpr F32 MIN_ASPECT_RATIO  = 0.02f;
+constexpr F32 MIN_NEAR_PLANE    = 0.1f;
+constexpr F32 MIN_FAR_PLANE     = 0.2f;
 
 // Min/Max FOV values for square views. Call getMin/MaxView to get extremes based on current aspect ratio.
-static const F32 MIN_FIELD_OF_VIEW = 5.0f * DEG_TO_RAD;
-static const F32 MAX_FIELD_OF_VIEW = 175.f * DEG_TO_RAD;
+constexpr F32 MIN_FIELD_OF_VIEW = 5.0f * DEG_TO_RAD;
+constexpr F32 MAX_FIELD_OF_VIEW = 175.f * DEG_TO_RAD;
 
 // An LLCamera is an LLCoorFrame with a view frustum.
 // This means that it has several methods for moving it around

indra/llmath/llcamera.h

@@ -26,7 +26,6 @@
 
 #include "linden_common.h"
 
-//#include "vmath.h"
 #include "v3math.h"
 #include "m3math.h"
 #include "v4math.h"

indra/llmath/llcoordframe.cpp

@@ -61,7 +61,7 @@ class LLCoordFrame
     //LLCoordFrame(const F32 *origin, const F32 *rotation); // Assumes "origin" is 1x3 and "rotation" is 1x9 array
     //LLCoordFrame(const F32 *origin_and_rotation);         // Assumes "origin_and_rotation" is 1x12 array
 
-    bool isFinite() { return mOrigin.isFinite() && mXAxis.isFinite() && mYAxis.isFinite() && mZAxis.isFinite(); }
+    bool isFinite() const { return mOrigin.isFinite() && mXAxis.isFinite() && mYAxis.isFinite() && mZAxis.isFinite(); }
 
     void reset();
     void resetAxes();

indra/llmath/llcoordframe.h

@@ -33,7 +33,7 @@
 #include "stdtypes.h"
 #include "v3math.h"
 
-const F32 DEFAULT_INTERSECTION_ERROR = 0.000001f;
+constexpr F32 DEFAULT_INTERSECTION_ERROR = 0.000001f;
 
 class LLLine
 {

indra/llmath/llline.h

@@ -39,18 +39,8 @@
 // llcommon depend on llmath.
 #include "is_approx_equal_fraction.h"
 
-// work around for Windows & older gcc non-standard function names.
-#if LL_WINDOWS
-#include <float.h>
-#define llisnan(val)    _isnan(val)
-#define llfinite(val)   _finite(val)
-#elif (LL_LINUX && __GNUC__ <= 2)
-#define llisnan(val)    isnan(val)
-#define llfinite(val)   isfinite(val)
-#else
-#define llisnan(val)    std::isnan(val)
-#define llfinite(val)   std::isfinite(val)
-#endif
+#define llisnan(val)  std::isnan(val)
+#define llfinite(val) std::isfinite(val)
 
 // Single Precision Floating Point Routines
 // (There used to be more defined here, but they appeared to be redundant and
@@ -89,7 +79,7 @@ constexpr F32   GIMBAL_THRESHOLD = 0.000436f; // sets the gimballock threshold 0
 constexpr F32 FP_MAG_THRESHOLD = 0.0000001f;
 
 // TODO: Replace with logic like is_approx_equal
-inline bool is_approx_zero( F32 f ) { return (-F_APPROXIMATELY_ZERO < f) && (f < F_APPROXIMATELY_ZERO); }
+constexpr bool is_approx_zero(F32 f) { return (-F_APPROXIMATELY_ZERO < f) && (f < F_APPROXIMATELY_ZERO); }
 
 // These functions work by interpreting sign+exp+mantissa as an unsigned
 // integer.
@@ -148,33 +138,17 @@ inline F64 llabs(const F64 a)
     return F64(std::fabs(a));
 }
 
-inline S32 lltrunc( F32 f )
+constexpr S32 lltrunc(F32 f)
 {
-#if LL_WINDOWS && !defined( __INTEL_COMPILER ) && (ADDRESS_SIZE == 32)
-        // Avoids changing the floating point control word.
-        // Add or subtract 0.5 - epsilon and then round
-        const static U32 zpfp[] = { 0xBEFFFFFF, 0x3EFFFFFF };
-        S32 result;
-        __asm {
-            fld     f
-            mov     eax,    f
-            shr     eax,    29
-            and     eax,    4
-            fadd    dword ptr [zpfp + eax]
-            fistp   result
-        }
-        return result;
-#else
-        return (S32)f;
-#endif
+    return narrow(f);
 }
 
-inline S32 lltrunc( F64 f )
+constexpr S32 lltrunc(F64 f)
 {
-    return (S32)f;
+    return narrow(f);
 }
 
-inline S32 llfloor( F32 f )
+inline S32 llfloor(F32 f)
 {
 #if LL_WINDOWS && !defined( __INTEL_COMPILER ) && (ADDRESS_SIZE == 32)
         // Avoids changing the floating point control word.
@@ -284,7 +258,7 @@ constexpr F32 FAST_MAG_BETA = 0.397824734759f;
 //constexpr F32 FAST_MAG_ALPHA = 0.948059448969f;
 //constexpr F32 FAST_MAG_BETA = 0.392699081699f;
 
-inline F32 fastMagnitude(F32 a, F32 b)
+constexpr F32 fastMagnitude(F32 a, F32 b)
 {
     a = (a > 0) ? a : -a;
     b = (b > 0) ? b : -b;
@@ -342,7 +316,7 @@ inline F32 llfastpow(const F32 x, const F32 y)
 }
 
 
-inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
+constexpr F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
 {
     // compute the power of ten
     F32 bar = 1.f;
@@ -358,30 +332,27 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
     return new_foo;
 }
 
-inline F32 lerp(F32 a, F32 b, F32 u)
-{
-    return a + ((b - a) * u);
-}
+using std::lerp;
 
-inline F32 lerp2d(F32 x00, F32 x01, F32 x10, F32 x11, F32 u, F32 v)
+constexpr F32 lerp2d(F32 x00, F32 x01, F32 x10, F32 x11, F32 u, F32 v)
 {
     F32 a = x00 + (x01-x00)*u;
     F32 b = x10 + (x11-x10)*u;
     F32 r = a + (b-a)*v;
     return r;
 }
 
-inline F32 ramp(F32 x, F32 a, F32 b)
+constexpr F32 ramp(F32 x, F32 a, F32 b)
 {
     return (a == b) ? 0.0f : ((a - x) / (a - b));
 }
 
-inline F32 rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
+constexpr F32 rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
 {
     return lerp(y1, y2, ramp(x, x1, x2));
 }
 
-inline F32 clamp_rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
+constexpr F32 clamp_rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
 {
     if (y1 < y2)
     {
@@ -394,7 +365,7 @@ inline F32 clamp_rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
 }
 
 
-inline F32 cubic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
+constexpr F32 cubic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
 {
     if (x <= x0)
         return s0;
@@ -407,14 +378,14 @@ inline F32 cubic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
     return  s0 + (s1 - s0) * (f * f) * (3.0f - 2.0f * f);
 }
 
-inline F32 cubic_step( F32 x )
+constexpr F32 cubic_step( F32 x )
 {
     x = llclampf(x);
 
     return  (x * x) * (3.0f - 2.0f * x);
 }
 
-inline F32 quadratic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
+constexpr F32 quadratic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
 {
     if (x <= x0)
         return s0;
@@ -428,7 +399,7 @@ inline F32 quadratic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
     return  (s0 * (1.f - f_squared)) + ((s1 - s0) * f_squared);
 }
 
-inline F32 llsimple_angle(F32 angle)
+constexpr F32 llsimple_angle(F32 angle)
 {
     while(angle <= -F_PI)
         angle += F_TWO_PI;
@@ -438,7 +409,7 @@ inline F32 llsimple_angle(F32 angle)
 }
 
 //SDK - Renamed this to get_lower_power_two, since this is what this actually does.
-inline U32 get_lower_power_two(U32 val, U32 max_power_two)
+constexpr U32 get_lower_power_two(U32 val, U32 max_power_two)
 {
     if(!max_power_two)
     {
@@ -460,7 +431,7 @@ inline U32 get_lower_power_two(U32 val, U32 max_power_two)
 // number of digits, then add one.  We subtract 1 initially to handle
 // the case where the number passed in is actually a power of two.
 // WARNING: this only works with 32 bit ints.
-inline U32 get_next_power_two(U32 val, U32 max_power_two)
+constexpr U32 get_next_power_two(U32 val, U32 max_power_two)
 {
     if(!max_power_two)
     {
@@ -486,7 +457,7 @@ inline U32 get_next_power_two(U32 val, U32 max_power_two)
 //get the gaussian value given the linear distance from axis x and guassian value o
 inline F32 llgaussian(F32 x, F32 o)
 {
-    return 1.f/(F_SQRT_TWO_PI*o)*powf(F_E, -(x*x)/(2*o*o));
+    return 1.f/(F_SQRT_TWO_PI*o)*powf(F_E, -(x*x)/(2.f*o*o));
 }
 
 //helper function for removing outliers
@@ -539,7 +510,8 @@ inline void ll_remove_outliers(std::vector<VEC_TYPE>& data, F32 k)
 // Note: in our code, values labeled as sRGB are ALWAYS gamma corrected linear values, NOT linear values with monitor gamma applied
 // Note: stored color values should always be gamma corrected linear (i.e. the values returned from an on-screen color swatch)
 // Note: DO NOT cache the conversion.  This leads to error prone synchronization and is actually slower in the typical case due to cache misses
-inline float linearTosRGB(const float val) {
+inline float linearTosRGB(const float val)
+{
     if (val < 0.0031308f) {
         return val * 12.92f;
     }
@@ -554,7 +526,8 @@ inline float linearTosRGB(const float val) {
 // Note: Stored color values should generally be gamma corrected sRGB.
 //       If you're serializing the return value of this function, you're probably doing it wrong.
 // Note: DO NOT cache the conversion.  This leads to error prone synchronization and is actually slower in the typical case due to cache misses.
-inline float sRGBtoLinear(const float val) {
+inline float sRGBtoLinear(const float val)
+{
     if (val < 0.04045f) {
         return val / 12.92f;
     }

indra/llmath/llmath.h

@@ -30,7 +30,6 @@
 
 #include "llquaternion.h"
 
-//#include "vmath.h"
 #include "v3math.h"
 #include "v3dmath.h"
 #include "v4math.h"