2015-05-23 22:55:12 -06:00
|
|
|
// Copyright 2008 Dolphin Emulator Project
|
2015-05-17 17:08:10 -06:00
|
|
|
// Licensed under GPLv2+
|
2013-04-17 21:09:55 -06:00
|
|
|
// Refer to the license.txt file included.
|
2008-12-07 21:46:09 -07:00
|
|
|
|
2014-02-10 11:54:46 -07:00
|
|
|
#pragma once
|
2008-12-07 21:46:09 -07:00
|
|
|
|
2015-09-11 21:43:17 -06:00
|
|
|
#include <algorithm>
|
2017-04-11 10:01:29 -06:00
|
|
|
#include <array>
|
2014-02-19 20:11:52 -07:00
|
|
|
#include <cstdlib>
|
2009-07-12 15:58:32 -06:00
|
|
|
#include <vector>
|
2014-02-17 03:18:15 -07:00
|
|
|
|
2014-09-07 19:06:58 -06:00
|
|
|
#include "Common/CommonTypes.h"
|
2009-07-12 15:58:32 -06:00
|
|
|
|
2017-03-07 22:38:05 -07:00
|
|
|
#ifdef _MSC_VER
|
|
|
|
#include <intrin.h>
|
|
|
|
#endif
|
|
|
|
|
2009-06-14 04:59:06 -06:00
|
|
|
namespace MathUtil
|
|
|
|
{
|
2016-04-03 17:08:47 -06:00
|
|
|
template <typename T>
|
|
|
|
constexpr T SNANConstant()
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
return std::numeric_limits<T>::signaling_NaN();
|
2016-04-03 17:08:47 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
|
|
|
|
// MSVC needs a workaround, because its std::numeric_limits<double>::signaling_NaN()
|
|
|
|
// will use __builtin_nans, which is improperly handled by the compiler and generates
|
|
|
|
// a bad constant. Here we go back to the version MSVC used before the builtin.
|
|
|
|
// TODO: Remove this and use numeric_limits directly whenever this bug is fixed.
|
2017-02-15 21:37:04 -07:00
|
|
|
|
2016-04-03 17:08:47 -06:00
|
|
|
template <>
|
|
|
|
constexpr double SNANConstant()
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
return (_CSTD _Snan._Double);
|
2016-04-03 17:08:47 -06:00
|
|
|
}
|
|
|
|
template <>
|
|
|
|
constexpr float SNANConstant()
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
return (_CSTD _Snan._Float);
|
2016-04-03 17:08:47 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
template <class T>
|
2015-09-11 21:43:17 -06:00
|
|
|
constexpr T Clamp(const T val, const T& min, const T& max)
|
2014-02-04 18:43:07 -07:00
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
return std::max(min, std::min(max, val));
|
2014-07-14 06:42:33 -06:00
|
|
|
}
|
|
|
|
|
2018-03-23 07:50:09 -06:00
|
|
|
template <typename T>
|
|
|
|
constexpr bool IsPow2(T imm)
|
2015-09-11 22:22:48 -06:00
|
|
|
{
|
2018-03-23 07:50:09 -06:00
|
|
|
return imm > 0 && (imm & (imm - 1)) == 0;
|
2015-09-11 22:22:48 -06:00
|
|
|
}
|
|
|
|
|
2014-03-09 12:34:58 -06:00
|
|
|
// The most significant bit of the fraction is an is-quiet bit on all architectures we care about.
|
2009-06-14 04:59:06 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
static const u64 DOUBLE_SIGN = 0x8000000000000000ULL, DOUBLE_EXP = 0x7FF0000000000000ULL,
|
|
|
|
DOUBLE_FRAC = 0x000FFFFFFFFFFFFFULL, DOUBLE_ZERO = 0x0000000000000000ULL,
|
2014-03-09 12:34:58 -06:00
|
|
|
DOUBLE_QBIT = 0x0008000000000000ULL;
|
2009-06-14 04:59:06 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
static const u32 FLOAT_SIGN = 0x80000000, FLOAT_EXP = 0x7F800000, FLOAT_FRAC = 0x007FFFFF,
|
2014-03-09 12:34:58 -06:00
|
|
|
FLOAT_ZERO = 0x00000000;
|
2009-06-14 04:59:06 -06:00
|
|
|
|
2017-01-04 04:45:40 -07:00
|
|
|
union IntDouble
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
double d;
|
|
|
|
u64 i;
|
2014-03-23 03:24:06 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
explicit IntDouble(u64 _i) : i(_i) {}
|
|
|
|
explicit IntDouble(double _d) : d(_d) {}
|
2009-06-14 04:59:06 -06:00
|
|
|
};
|
2017-01-04 04:45:40 -07:00
|
|
|
union IntFloat
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
float f;
|
|
|
|
u32 i;
|
2014-03-23 03:24:06 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
explicit IntFloat(u32 _i) : i(_i) {}
|
|
|
|
explicit IntFloat(float _f) : f(_f) {}
|
2009-06-14 04:59:06 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
inline bool IsQNAN(double d)
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
IntDouble x(d);
|
|
|
|
return ((x.i & DOUBLE_EXP) == DOUBLE_EXP) && ((x.i & DOUBLE_QBIT) == DOUBLE_QBIT);
|
2009-06-14 04:59:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline bool IsSNAN(double d)
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
IntDouble x(d);
|
|
|
|
return ((x.i & DOUBLE_EXP) == DOUBLE_EXP) && ((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) &&
|
|
|
|
((x.i & DOUBLE_QBIT) == DOUBLE_ZERO);
|
2009-06-14 04:59:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline float FlushToZero(float f)
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
IntFloat x(f);
|
|
|
|
if ((x.i & FLOAT_EXP) == 0)
|
|
|
|
{
|
|
|
|
x.i &= FLOAT_SIGN; // turn into signed zero
|
|
|
|
}
|
|
|
|
return x.f;
|
2009-06-14 04:59:06 -06:00
|
|
|
}
|
|
|
|
|
2013-10-24 14:05:53 -06:00
|
|
|
inline double FlushToZero(double d)
|
2009-06-14 04:59:06 -06:00
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
IntDouble x(d);
|
|
|
|
if ((x.i & DOUBLE_EXP) == 0)
|
|
|
|
{
|
|
|
|
x.i &= DOUBLE_SIGN; // turn into signed zero
|
|
|
|
}
|
|
|
|
return x.d;
|
2009-06-14 04:59:06 -06:00
|
|
|
}
|
|
|
|
|
2009-06-14 05:30:33 -06:00
|
|
|
enum PPCFpClass
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
PPC_FPCLASS_QNAN = 0x11,
|
|
|
|
PPC_FPCLASS_NINF = 0x9,
|
|
|
|
PPC_FPCLASS_NN = 0x8,
|
|
|
|
PPC_FPCLASS_ND = 0x18,
|
|
|
|
PPC_FPCLASS_NZ = 0x12,
|
|
|
|
PPC_FPCLASS_PZ = 0x2,
|
|
|
|
PPC_FPCLASS_PD = 0x14,
|
|
|
|
PPC_FPCLASS_PN = 0x4,
|
|
|
|
PPC_FPCLASS_PINF = 0x5,
|
2009-06-14 05:30:33 -06:00
|
|
|
};
|
2009-06-14 04:59:06 -06:00
|
|
|
|
2009-06-14 05:30:33 -06:00
|
|
|
// Uses PowerPC conventions for the return value, so it can be easily
|
|
|
|
// used directly in CPU emulation.
|
2011-05-25 12:14:29 -06:00
|
|
|
u32 ClassifyDouble(double dvalue);
|
2009-06-15 15:10:11 -06:00
|
|
|
// More efficient float version.
|
2011-05-25 12:14:29 -06:00
|
|
|
u32 ClassifyFloat(float fvalue);
|
2009-06-14 05:30:33 -06:00
|
|
|
|
2017-04-11 10:01:29 -06:00
|
|
|
struct BaseAndDec
|
|
|
|
{
|
|
|
|
int m_base;
|
|
|
|
int m_dec;
|
|
|
|
};
|
|
|
|
extern const std::array<BaseAndDec, 32> frsqrte_expected;
|
|
|
|
extern const std::array<BaseAndDec, 32> fres_expected;
|
2014-09-02 21:50:03 -06:00
|
|
|
|
2014-09-03 13:11:02 -06:00
|
|
|
// PowerPC approximation algorithms
|
2014-09-02 21:50:03 -06:00
|
|
|
double ApproximateReciprocalSquareRoot(double val);
|
2014-09-03 13:11:02 -06:00
|
|
|
double ApproximateReciprocal(double val);
|
2014-09-02 21:50:03 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
template <class T>
|
2009-07-14 18:51:24 -06:00
|
|
|
struct Rectangle
|
|
|
|
{
|
2016-06-24 02:43:46 -06:00
|
|
|
T left{};
|
|
|
|
T top{};
|
|
|
|
T right{};
|
|
|
|
T bottom{};
|
|
|
|
|
|
|
|
constexpr Rectangle() = default;
|
|
|
|
|
|
|
|
constexpr Rectangle(T theLeft, T theTop, T theRight, T theBottom)
|
|
|
|
: left(theLeft), top(theTop), right(theRight), bottom(theBottom)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr bool operator==(const Rectangle& r) const
|
|
|
|
{
|
|
|
|
return left == r.left && top == r.top && right == r.right && bottom == r.bottom;
|
|
|
|
}
|
|
|
|
|
|
|
|
T GetWidth() const { return abs(right - left); }
|
|
|
|
T GetHeight() const { return abs(bottom - top); }
|
|
|
|
// If the rectangle is in a coordinate system with a lower-left origin, use
|
|
|
|
// this Clamp.
|
|
|
|
void ClampLL(T x1, T y1, T x2, T y2)
|
|
|
|
{
|
|
|
|
left = Clamp(left, x1, x2);
|
|
|
|
right = Clamp(right, x1, x2);
|
|
|
|
top = Clamp(top, y2, y1);
|
|
|
|
bottom = Clamp(bottom, y2, y1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the rectangle is in a coordinate system with an upper-left origin,
|
|
|
|
// use this Clamp.
|
|
|
|
void ClampUL(T x1, T y1, T x2, T y2)
|
|
|
|
{
|
|
|
|
left = Clamp(left, x1, x2);
|
|
|
|
right = Clamp(right, x1, x2);
|
|
|
|
top = Clamp(top, y1, y2);
|
|
|
|
bottom = Clamp(bottom, y1, y2);
|
|
|
|
}
|
2009-07-14 18:51:24 -06:00
|
|
|
};
|
|
|
|
|
2009-06-14 05:30:33 -06:00
|
|
|
} // namespace MathUtil
|
2009-06-14 04:59:06 -06:00
|
|
|
|
2009-07-28 01:40:18 -06:00
|
|
|
float MathFloatVectorSum(const std::vector<float>&);
|
2008-12-07 21:46:09 -07:00
|
|
|
|
2013-03-05 14:48:57 -07:00
|
|
|
// Rounds down. 0 -> undefined
|
2014-08-24 12:03:07 -06:00
|
|
|
inline int IntLog2(u64 val)
|
2013-03-05 02:12:17 -07:00
|
|
|
{
|
2013-03-05 14:48:57 -07:00
|
|
|
#if defined(__GNUC__)
|
2016-06-24 02:43:46 -06:00
|
|
|
return 63 - __builtin_clzll(val);
|
2013-03-19 19:51:12 -06:00
|
|
|
|
2014-09-03 11:04:48 -06:00
|
|
|
#elif defined(_MSC_VER)
|
2017-06-07 05:16:02 -06:00
|
|
|
unsigned long result = ULONG_MAX;
|
2016-06-24 02:43:46 -06:00
|
|
|
_BitScanReverse64(&result, val);
|
|
|
|
return result;
|
2013-03-19 19:51:12 -06:00
|
|
|
|
2013-03-05 02:12:17 -07:00
|
|
|
#else
|
2016-06-24 02:43:46 -06:00
|
|
|
int result = -1;
|
|
|
|
while (val != 0)
|
|
|
|
{
|
|
|
|
val >>= 1;
|
|
|
|
++result;
|
|
|
|
}
|
|
|
|
return result;
|
2013-03-05 02:12:17 -07:00
|
|
|
#endif
|
|
|
|
}
|
2009-06-14 05:30:33 -06:00
|
|
|
|
|
|
|
// Tiny matrix/vector library.
|
2011-02-13 19:18:03 -07:00
|
|
|
// Used for things like Free-Look in the gfx backend.
|
2009-06-14 05:30:33 -06:00
|
|
|
|
2009-04-19 04:10:45 -06:00
|
|
|
class Matrix33
|
|
|
|
{
|
|
|
|
public:
|
2016-06-24 02:43:46 -06:00
|
|
|
static void LoadIdentity(Matrix33& mtx);
|
2009-04-19 04:10:45 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
// set mtx to be a rotation matrix around the x axis
|
|
|
|
static void RotateX(Matrix33& mtx, float rad);
|
|
|
|
// set mtx to be a rotation matrix around the y axis
|
|
|
|
static void RotateY(Matrix33& mtx, float rad);
|
2009-04-19 04:10:45 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
// set result = a x b
|
|
|
|
static void Multiply(const Matrix33& a, const Matrix33& b, Matrix33& result);
|
|
|
|
static void Multiply(const Matrix33& a, const float vec[3], float result[3]);
|
2009-04-19 04:10:45 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
float data[9];
|
2009-04-19 04:10:45 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
class Matrix44
|
|
|
|
{
|
|
|
|
public:
|
2016-06-24 02:43:46 -06:00
|
|
|
static void LoadIdentity(Matrix44& mtx);
|
|
|
|
static void LoadMatrix33(Matrix44& mtx, const Matrix33& m33);
|
|
|
|
static void Set(Matrix44& mtx, const float mtxArray[16]);
|
2009-04-19 04:10:45 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
static void Translate(Matrix44& mtx, const float vec[3]);
|
|
|
|
static void Shear(Matrix44& mtx, const float a, const float b = 0);
|
2009-04-19 04:10:45 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
static void Multiply(const Matrix44& a, const Matrix44& b, Matrix44& result);
|
2009-04-19 04:10:45 -06:00
|
|
|
|
2016-06-24 02:43:46 -06:00
|
|
|
float data[16];
|
2009-04-19 04:10:45 -06:00
|
|
|
};
|