+Unity Runtime codeHEADmaster

1 files changed, 696 insertions, 0 deletions

diff --git a/Runtime/Math/FloatConversion.h b/Runtime/Math/FloatConversion.h
new file mode 100644
index 0000000..eb6b49c
--- /dev/null
+++ b/Runtime/Math/FloatConversion.h
@@ -0,0 +1,696 @@
+#ifndef FLOATCONVERSION_H
+#define FLOATCONVERSION_H
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <math.h>
+
+#if !UNITY_EXTERNAL_TOOL
+#include "Runtime/Utilities/LogAssert.h"
+#endif
+
+#if defined(SN_TARGET_PS3)
+#	include <ppu_intrinsics.h>
+#elif defined(__GNUC__) && defined(__ppc__)
+#	include <ppc_intrinsics.h>
+#endif
+
+#ifndef kPI
+	#define kPI 3.14159265358979323846264338327950288419716939937510F
+#endif
+
+const float kBiggestFloatSmallerThanOne = 0.99999994f;
+const double kBiggestDoubleSmallerThanOne = 0.99999999999999989;
+
+#if defined(_XBOX)
+#define __FSELF __fself
+#elif defined(SN_TARGET_PS3)
+#define __FSELF __fsels
+#endif
+
+inline float FloatMin(float a, float b)
+{
+#if defined(_XBOX) || defined(SN_TARGET_PS3)
+	return __FSELF((a)-(b), b, a);
+#else
+	return std::min(a, b);
+#endif
+}
+
+inline float FloatMax(float a, float b)
+{
+#if defined(_XBOX) || defined(SN_TARGET_PS3)
+	return __FSELF((a)-(b), a, b);
+#else
+	return std::max(a, b);
+#endif
+}
+
+inline float Abs (float v)
+{
+#if defined(__ppc__) && (defined(__MWERKS__) || defined(SN_TARGET_PS3))
+	return __fabsf(v);
+#elif defined(_XBOX)
+	return __fabs(v);
+#else
+	return v < 0.0F ? -v : v;
+#endif
+}
+
+inline double Abs (double v)
+{
+	return v < 0.0 ? -v : v;	
+}
+
+inline int Abs (int v)
+{
+	return v < 0 ? -v : v;
+}
+
+// Floor, ceil and round functions.
+//
+// When changing or implementing these functions, make sure the tests in MathTest.cpp
+// still pass.
+//
+// Floor: rounds to the largest integer smaller than or equal to the input parameter.
+// Ceil: rounds to the smallest integer larger than or equal to the input parameter.
+// Round: rounds to the nearest integer. Ties (0.5) are rounded up to the smallest integer
+// larger than or equal to the input parameter.
+// Chop/truncate: use a normal integer cast.
+//
+// Windows:
+// Casts are as fast as a straight fistp on an SSE equipped CPU. This is by far the most common
+// scenario and will result in the best code for most users. fistp will use the rounding mode set
+// in the control register (round to nearest by default), and needs fiddling to work properly.
+// This actually makes code that attempt to use fistp slower than a cast.
+// Unless we want round to nearest, in which case fistp should be the best choice, right? But
+// it is not. The default rounding mode is round to nearest, but in case of a tie (0.5), round to 
+// nearest even is used. Thus 0.5 is rounded down to 0, 1.5 is rounded up to 2.
+// Conclusion - fistp is useless without stupid fiddling around that actually makes is slower than
+// an SSE cast.
+//
+// OS X Intel:
+// Needs investigating
+//
+// OS X PowerPC:
+// Needs investigating
+//
+// Xbox 360:
+// Needs investigating
+//
+// PS3:
+// Needs investigating
+//
+// iPhone:
+// Needs investigating
+//
+// Android:
+// Needs investigating
+
+
+inline int FloorfToInt (float f)
+{
+	DebugAssertIf (f < INT_MIN || f > INT_MAX);
+	return f >= 0 ? (int)f : (int)(f - kBiggestFloatSmallerThanOne);
+}
+
+inline UInt32 FloorfToIntPos (float f)
+{
+	DebugAssertIf (f < 0 || f > UINT_MAX);
+	return (UInt32)f;
+}
+
+inline float Floorf (float f)
+{
+	// Use std::floor().
+	// We are interested in reliable functions that do not lose precision.
+	// Casting to int and back to float would not be helpful.
+	return floor (f);
+}
+
+inline double Floord (double f)
+{
+	// Use std::floor().
+	// We are interested in reliable functions that do not lose precision.
+	// Casting to int and back to float would not be helpful.
+	return floor (f);
+}
+
+
+inline int CeilfToInt (float f)
+{
+	DebugAssertIf (f < INT_MIN || f > INT_MAX);
+	return f >= 0 ? (int)(f + kBiggestFloatSmallerThanOne) : (int)(f);
+}
+
+inline UInt32 CeilfToIntPos (float f)
+{
+	DebugAssertIf (f < 0 || f > UINT_MAX);
+	return (UInt32)(f + kBiggestFloatSmallerThanOne);
+}
+
+inline float Ceilf (float f)
+{
+	// Use std::ceil().
+	// We are interested in reliable functions that do not lose precision.
+	// Casting to int and back to float would not be helpful.
+	return ceil (f);
+}
+
+inline double Ceild (double f)
+{
+	// Use std::ceil().
+	// We are interested in reliable functions that do not lose precision.
+	// Casting to int and back to float would not be helpful.
+	return ceil (f);
+}
+
+
+inline int RoundfToInt (float f)
+{
+	return FloorfToInt (f + 0.5F);
+}
+
+inline UInt32 RoundfToIntPos (float f)
+{
+	return FloorfToIntPos (f + 0.5F);
+}
+
+inline float Roundf (float f)
+{
+	return Floorf (f + 0.5F);
+}
+
+inline double Roundf (double f)
+{
+	return Floord (f + 0.5);
+}
+
+
+///  Fast conversion of float [0...1] to 0 ... 65535
+inline int NormalizedToWord (float f)
+{
+	f = FloatMax (f, 0.0F);
+	f = FloatMin (f, 1.0F);
+	return RoundfToIntPos (f * 65535.0f);
+}
+
+///  Fast conversion of float [0...1] to 0 ... 65535
+inline float WordToNormalized (int p)
+{
+	AssertIf(p < 0 || p > 65535);
+	return (float)p / 65535.0F;
+}
+
+///  Fast conversion of float [0...1] to 0 ... 255
+inline int NormalizedToByte (float f)
+{
+	f = FloatMax (f, 0.0F);
+	f = FloatMin (f, 1.0F);
+	return RoundfToIntPos (f * 255.0f);
+}
+
+///  Fast conversion of float [0...1] to 0 ... 255
+inline float ByteToNormalized (int p)
+{
+	AssertIf(p < 0 || p > 255);
+	return (float)p / 255.0F;
+}
+
+
+// Returns float remainder for t / length
+inline float Repeat (float t, float length)
+{
+	return t - Floorf (t / length) * length;
+}
+
+// Returns double remainder for t / length
+inline double RepeatD (double t, double length)
+{
+	return t - floor (t / length) * length;
+}
+
+// Returns relative angle on the interval (-pi, pi]
+inline float DeltaAngleRad (float current, float target)
+{
+	float delta = Repeat ((target - current), 2 * kPI);
+	if (delta > kPI)
+		delta -= 2 * kPI;
+	return delta;
+}
+
+// Returns true if the distance between f0 and f1 is smaller than epsilon
+inline bool CompareApproximately (float f0, float f1, float epsilon = 0.000001F)
+{
+	float dist = (f0 - f1);
+	dist = Abs (dist);
+	return dist < epsilon;
+}
+
+/// CopySignf () returns x with its sign changed to y's.
+inline float CopySignf (float x, float y)
+{
+	union
+	{
+		float f;
+		UInt32 i;
+	} u, u0, u1;
+	u0.f = x; u1.f = y;
+	UInt32 a    = u0.i;
+	UInt32 b    = u1.i;
+	SInt32 mask = 1 << 31;
+	UInt32 sign = b & mask;
+	a &= ~mask;
+	a |= sign;
+
+	u.i = a;
+	return u.f;
+}
+
+inline int CompareFloatRobustSignUtility (float A)
+{
+    // The sign bit of a number is the high bit.
+	union
+	{
+		float f;
+		int i;
+	} u;
+	u.f = A;
+    return (u.i) & 0x80000000;
+}
+
+inline bool CompareFloatRobust (float f0, float f1, int maxUlps = 10)
+{
+    // After adjusting floats so their representations are lexicographically
+    // ordered as twos-complement integers a very small positive number
+    // will compare as 'close' to a very small negative number. If this is
+    // not desireable, and if you are on a platform that supports
+    // subnormals (which is the only place the problem can show up) then
+    // you need this check.
+    // The check for A == B is because zero and negative zero have different
+    // signs but are equal to each other.
+    if (CompareFloatRobustSignUtility(f0) != CompareFloatRobustSignUtility(f1))
+        return f0 == f1;
+
+	union
+	{
+		float f;
+		int i;
+	} u0, u1;
+	u0.f = f0;
+	u1.f = f1;
+    int aInt = u0.i;
+    // Make aInt lexicographically ordered as a twos-complement int
+    if (aInt < 0)
+        aInt = 0x80000000 - aInt;
+    // Make bInt lexicographically ordered as a twos-complement int
+    int bInt = u1.i;
+    if (bInt < 0)
+        bInt = 0x80000000 - bInt;
+
+    // Now we can compare aInt and bInt to find out how far apart A and B
+    // are.
+    int intDiff = Abs (aInt - bInt);
+    if (intDiff <= maxUlps)
+        return true;
+    return false;
+}
+
+// Returns the t^2
+template<class T>
+T Sqr (const T& t)
+{
+	return t * t;
+}
+
+#define kDeg2Rad (2.0F * kPI / 360.0F)
+#define kRad2Deg (1.F / kDeg2Rad)
+
+inline float Deg2Rad (float deg)
+{
+	// TODO : should be deg * kDeg2Rad, but can't be changed, 
+	// because it changes the order of operations and that affects a replay in some RegressionTests
+	return deg / 360.0F * 2.0F * kPI;
+}
+
+inline float Rad2Deg (float rad)
+{
+	// TODO : should be rad * kRad2Deg, but can't be changed, 
+	// because it changes the order of operations and that affects a replay in some RegressionTests
+	return rad / 2.0F / kPI * 360.0F;
+}
+
+inline float Lerp (float from, float to, float t)
+{
+	return to * t + from * (1.0F - t);
+}
+
+inline bool IsNAN (float value)
+{
+	#if defined __APPLE_CC__
+		return value != value;
+	#elif _MSC_VER
+		return _isnan(value) != 0;
+	#else
+		return isnan (value);
+	#endif
+}
+
+inline bool IsNAN (double value)
+{
+	#if defined __APPLE_CC__
+		return value != value;
+	#elif _MSC_VER
+		return _isnan(value) != 0;
+	#else
+		return isnan (value);
+	#endif
+}
+
+inline bool IsPlusInf(float value)		{ return value == std::numeric_limits<float>::infinity (); }
+inline bool IsMinusInf(float value)		{ return value == -std::numeric_limits<float>::infinity ();	}
+
+inline bool IsFinite(const float& value)
+{
+	// Returns false if value is NaN or +/- infinity
+	UInt32 intval = *reinterpret_cast<const UInt32*>(&value);
+	return (intval & 0x7f800000) != 0x7f800000;
+}
+
+inline bool IsFinite(const double& value)
+{
+	// Returns false if value is NaN or +/- infinity
+	UInt64 intval = *reinterpret_cast<const UInt64*>(&value);
+	return (intval & 0x7ff0000000000000LL) != 0x7ff0000000000000LL;
+}
+
+inline float InvSqrt (float p) { return 1.0F / sqrt (p); }
+inline float Sqrt (float p) { return sqrt (p); }
+
+/// - Almost highest precision sqrt
+/// - Returns 0 if value is 0 or -1
+/// inline float FastSqrt (float value)
+
+/// - Almost highest precision inv sqrt
+/// - if value == 0 or -0 it returns 0.
+/// inline float FastInvSqrt (float value)
+
+/// - Low precision inv sqrt approximately
+/// - if value == 0 or -0 it returns nan or undefined
+/// inline float FastestInvSqrt (float value)
+
+#if defined(__ppc__) || defined(SN_TARGET_PS3)
+
+#if UNITY_WII
+// Copied from <CodeWarrior>\PowerPC_EABI_Support\MSL\MSL_C\PPC_EABI\Include\math_ppc_inlines.h
+// Requires hardware floating to be enabled
+// P.S I've also profiled with function below which uses fabs(x) == 0.0F, it's two times slower than this one
+inline float FastSqrt (float x)
+{
+	static const double _half=.5f;
+	static const double _three=3.0f;
+
+	if(x > 0.0f)
+	{
+		double xd = (double)x;
+		double guess = __frsqrte(xd);		  		 	/* returns an approximation to	*/
+		guess = _half*guess*(_three - guess*guess*xd);	/* now have 12 sig bits 		*/
+		guess = _half*guess*(_three - guess*guess*xd);	/* now have 24 sig bits			*/
+		return (float)(xd * guess);
+	}
+	else if (x < 0.0)
+		return NAN;
+	else
+		return x;
+}
+#else
+/// - Accurate to 1 bit precision
+/// - returns zero if x is zero
+inline float FastSqrt (float x)
+{
+    const float half = 0.5;
+    const float one = 1.0;
+    float B, y0, y1;
+
+	// This'll NaN if it hits frsqrte. Handle both +0.0 and -0.0
+    if (fabs(x) == 0.0F)
+      return x;
+
+    B = x;
+    
+#if defined(__GNUC__) && !defined(SN_TARGET_PS3)
+    y0 = __frsqrtes(B);
+#else
+    y0 = __frsqrte(B);
+#endif
+    // First refinement step
+    
+    y1 = y0 + half*y0*(one - B*y0*y0);
+    
+    // Second refinement step -- copy the output of the last step to the input of this step
+    
+    y0 = y1;
+    y1 = y0 + half*y0*(one - B*y0*y0);
+    
+    // Get sqrt(x) from x * 1/sqrt(x)
+    return x * y1;
+}
+#endif
+
+/// - Accurate to 1 bit precision
+/// - returns zero if f is zero
+inline float FastInvSqrt( float f ) 
+{
+	float result;
+	float estimate, estimate2;
+	float oneHalf = 0.5f;
+	float one = oneHalf + oneHalf;
+	//Calculate a 5 bit starting estimate for the reciprocal sqrt
+#if defined(__GNUC__) && !defined(SN_TARGET_PS3)
+    estimate = estimate2 = __frsqrtes ( f );
+#else
+    estimate = estimate2 = __frsqrte ( f );
+#endif
+
+	//if you require less precision, you may reduce the number of loop iterations
+	estimate = estimate + oneHalf * estimate * ( one - f * estimate * estimate );
+	estimate = estimate + oneHalf * estimate * ( one - f * estimate * estimate );
+	
+#if defined(__GNUC__) && !defined(SN_TARGET_PS3)
+	result = __fsels( -f, estimate2, estimate );
+#else
+	result = __fsel( -f, estimate2, estimate );
+#endif
+	return result;
+}
+
+/// Fast inverse sqrt function
+inline float FastestInvSqrt (float value)
+{
+	#if defined (__ppc__) && (defined (__MWERKS__) || defined(SN_TARGET_PS3))
+	return (float)__frsqrte (value);
+	#elif defined (__ppc__)
+		return (float)__frsqrtes(value);
+	#else
+		return 1.0F / sqrtf (value);
+	#endif
+}
+
+#else
+
+inline float FastSqrt (float value)
+{
+	return sqrtf (value);
+}
+
+inline float FastInvSqrt( float f ) 
+{
+	// The Newton iteration trick used in FastestInvSqrt is a bit faster on
+	// Pentium4 / Windows, but lower precision. Doing two iterations is precise enough,
+	// but actually a bit slower.
+	if (fabs(f) == 0.0F)
+		return f;
+	return 1.0F / sqrtf (f);
+}
+
+inline float FastestInvSqrt( float f )
+{
+	union
+	{
+		float f;
+		int i;
+	} u;
+	float fhalf = 0.5f*f;
+	u.f = f;
+	int i = u.i;
+	i = 0x5f3759df - (i>>1);
+	u.i = i;
+	f = u.f;
+	f = f*(1.5f - fhalf*f*f);
+	// f = f*(1.5f - fhalf*f*f); // uncommenting this would be two iterations
+	return f;
+}
+
+#endif
+
+inline float SqrtImpl (float f)
+{
+	#if UNITY_WII || UNITY_FLASH
+		return FastSqrt (f); 
+	#else
+		return sqrt (f); 
+	#endif
+}
+inline float Sin (float f)
+{
+	return sinf (f);
+}
+
+inline float Pow (float f, float f2)
+{
+	return powf (f, f2);
+}
+
+inline float Cos (float f)
+{
+	return cosf (f);
+}
+
+inline float Sign (float f)
+{
+#if defined(_XBOX)
+	return __fsel(f, 1.0f, -1.0f);
+#else
+	if (f < 0.0F)
+		return -1.0F;
+	else
+		return 1.0;
+#endif
+}
+
+#if UNITY_EDITOR
+
+class FloatToHalfConverter
+{
+public:
+	FloatToHalfConverter();
+
+	void Convert(const float& src, UInt16& dest)
+	{
+		UInt32 bits = *reinterpret_cast<const UInt32*>(&src);
+		UInt8 index = UInt8(bits >> 23);
+		UInt32 sign = bits & 0x80000000;
+		UInt32 mantissa = bits & 0x007fffff;
+		dest = (sign >> 16) | m_ExponentTable[index] | (mantissa >> m_MantissaShift[index]);
+	}
+
+private:
+	UInt16 m_ExponentTable[256];
+	UInt8 m_MantissaShift[256];
+};
+
+extern FloatToHalfConverter g_FloatToHalf;
+
+#endif // UNITY_EDITOR
+
+#if UNITY_SUPPORTS_SSE
+#include "Runtime/Math/Simd/SimdMath.h"
+
+#define SSE_CONST4(name, val) static const ALIGN16 UInt32 name[4] = { (val), (val), (val), (val) }
+#define CONST_M128I(name) *(const __m128i *)&name
+
+static ALIGN16 UInt16 source[] = {0,0,0,0,0,0,0,0};
+static ALIGN16 float destination[] = {0.0,0.0,0.0,0.0};
+
+static void HalfToFloat(UInt16 src, float& dest)
+{
+	SSE_CONST4(mask_nosign, 0x7fff);
+	SSE_CONST4(smallest_normal, 0x0400);
+	SSE_CONST4(infinity, 0x7c00);
+	SSE_CONST4(expadjust_normal, (127 - 15) << 23);
+	SSE_CONST4(magic_denorm, 113 << 23);
+	
+	source[0] = src;
+	__m128i in = _mm_loadu_si128(reinterpret_cast<const __m128i*>(source));
+	__m128i mnosign = CONST_M128I(mask_nosign);
+	__m128i eadjust = CONST_M128I(expadjust_normal);
+	__m128i smallest = CONST_M128I(smallest_normal);
+	__m128i infty = CONST_M128I(infinity);
+	__m128i expmant = _mm_and_si128(mnosign, in);
+	__m128i justsign = _mm_xor_si128(in, expmant);
+	__m128i b_notinfnan = _mm_cmpgt_epi32(infty, expmant);
+	__m128i b_isdenorm = _mm_cmpgt_epi32(smallest, expmant);
+	__m128i shifted = _mm_slli_epi32(expmant, 13);
+	__m128i adj_infnan = _mm_andnot_si128(b_notinfnan, eadjust);
+	__m128i adjusted = _mm_add_epi32(eadjust, shifted);
+	__m128i den1 = _mm_add_epi32(shifted, CONST_M128I(magic_denorm));
+	__m128i adjusted2 = _mm_add_epi32(adjusted, adj_infnan);
+	__m128 den2 = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm);
+	__m128 adjusted3 = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm));
+	__m128 adjusted4 = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2));
+	__m128 adjusted5 = _mm_or_ps(adjusted3, adjusted4);
+	__m128i sign = _mm_slli_epi32(justsign, 16);
+	__m128 out = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign));
+	_mm_storeu_ps(destination, out);
+	dest = destination[0];
+#undef SSE_CONST4
+#undef CONST_M128I
+}
+
+#else
+
+static void HalfToFloat(UInt16 src, float& dest)
+{
+	// Integer alias
+	UInt32& bits = *reinterpret_cast<UInt32*>(&dest);
+
+	// Based on Fabian Giesen's public domain half_to_float_fast3
+	static const UInt32 magic = { 113 << 23 };
+	const float& magicFloat = *reinterpret_cast<const float*>(&magic);
+	static const UInt32 shiftedExp = 0x7c00 << 13; // exponent mask after shift
+
+	// Mask out sign bit
+	bits = src & 0x7fff;
+	if (bits)
+	{
+		// Move exponent + mantissa to correct bits
+		bits <<= 13;
+		UInt32 exponent = bits & shiftedExp;
+		if (exponent == 0)
+		{
+			// Handle denormal
+			bits += magic;
+			dest -= magicFloat;
+		}
+		else if (exponent == shiftedExp) // Inf/NaN
+			bits += (255 - 31) << 23;
+		else
+			bits += (127 - 15) << 23;
+	}
+
+	// Copy sign bit
+	bits |= (src & 0x8000) << 16;
+}
+
+#endif
+
+using std::cos;
+using std::pow;
+using std::atan2;
+using std::acos;
+using std::sin;
+using std::sqrt;
+using std::log;
+using std::exp;
+
+// On non-C99 platforms log2 is not available, so approximate it.
+#if UNITY_WIN || UNITY_XENON || UNITY_ANDROID || UNITY_FLASH || UNITY_WEBGL
+#define kNaturalLogarithm2 0.693147180559945309417
+#define Log2(x) (logf(x) / kNaturalLogarithm2)
+#else
+#define Log2(x) log2f(x)
+#endif
+
+
+#endif