Common: Remove unused cruft from math_util, and remove a duplicated Rect class in common_types.

4 files changed, 3 insertions, 409 deletions

diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 11659c3c5..f8fc6450f 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -9,7 +9,6 @@ set(SRCS
             logging/filter.cpp
             logging/text_formatter.cpp
             logging/backend.cpp
-            math_util.cpp
             memory_util.cpp
             misc.cpp
             profiler.cpp
diff --git a/src/common/common_types.h b/src/common/common_types.h
index 644709ba6..f6de0adfc 100644
--- a/src/common/common_types.h
+++ b/src/common/common_types.h
@@ -87,29 +87,3 @@ protected:
     NonCopyable(NonCopyable&) = delete;
     NonCopyable& operator=(NonCopyable&) = delete;
 };
-
-namespace Common {
-/// Rectangle data structure
-class Rect {
-public:
-    Rect(int x0=0, int y0=0, int x1=0, int y1=0) {
-        x0_ = x0;
-        y0_ = y0;
-        x1_ = x1;
-        y1_ = y1;
-    }
-    ~Rect() { }
-
-    int x0_;    ///< Rect top left X-coordinate
-    int y0_;    ///< Rect top left Y-coordinate
-    int x1_;    ///< Rect bottom left X-coordinate
-    int y1_;    ///< Rect bottom right Y-coordinate
-
-    inline u32 width() const { return std::abs(x1_ - x0_); }
-    inline u32 height() const { return std::abs(y1_ - y0_); }
-
-    inline bool operator == (const Rect& val) const {
-        return (x0_ == val.x0_ && y0_ == val.y0_ && x1_ == val.x1_ && y1_ == val.y1_);
-    }
-};
-}
diff --git a/src/common/math_util.cpp b/src/common/math_util.cpp
deleted file mode 100644
index bcb70cae5..000000000
--- a/src/common/math_util.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <numeric> // Necessary on OS X, but not Linux
-
-#include "common/common_types.h"
-#include "common/math_util.h"
-
-namespace MathUtil
-{
-
-u32 ClassifyDouble(double dvalue)
-{
-    // TODO: Optimize the below to be as fast as possible.
-    IntDouble value;
-    value.d = dvalue;
-    u64 sign = value.i & DOUBLE_SIGN;
-    u64 exp  = value.i & DOUBLE_EXP;
-    if (exp > DOUBLE_ZERO && exp < DOUBLE_EXP)
-    {
-        // Nice normalized number.
-        return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;
-    }
-    else
-    {
-        u64 mantissa = value.i & DOUBLE_FRAC;
-        if (mantissa)
-        {
-            if (exp)
-            {
-                return PPC_FPCLASS_QNAN;
-            }
-            else
-            {
-                // Denormalized number.
-                return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD;
-            }
-        }
-        else if (exp)
-        {
-            //Infinite
-            return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF;
-        }
-        else
-        {
-            //Zero
-            return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ;
-        }
-    }
-}
-
-u32 ClassifyFloat(float fvalue)
-{
-    // TODO: Optimize the below to be as fast as possible.
-    IntFloat value;
-    value.f = fvalue;
-    u32 sign = value.i & FLOAT_SIGN;
-    u32 exp  = value.i & FLOAT_EXP;
-    if (exp > FLOAT_ZERO && exp < FLOAT_EXP)
-    {
-        // Nice normalized number.
-        return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;
-    }
-    else
-    {
-        u32 mantissa = value.i & FLOAT_FRAC;
-        if (mantissa)
-        {
-            if (exp)
-            {
-                return PPC_FPCLASS_QNAN; // Quiet NAN
-            }
-            else
-            {
-                // Denormalized number.
-                return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD;
-            }
-        }
-        else if (exp)
-        {
-            // Infinite
-            return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF;
-        }
-        else
-        {
-            //Zero
-            return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ;
-        }
-    }
-}
-
-
-}  // namespace
-
-inline void MatrixMul(int n, const float *a, const float *b, float *result)
-{
-    for (int i = 0; i < n; ++i)
-    {
-        for (int j = 0; j < n; ++j)
-        {
-            float temp = 0;
-            for (int k = 0; k < n; ++k)
-            {
-                temp += a[i * n + k] * b[k * n + j];
-            }
-            result[i * n + j] = temp;
-        }
-    }
-}
-
-// Calculate sum of a float list
-float MathFloatVectorSum(const std::vector<float>& Vec)
-{
-    return std::accumulate(Vec.begin(), Vec.end(), 0.0f);
-}
-
-void Matrix33::LoadIdentity(Matrix33 &mtx)
-{
-    memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = 1.0f;
-    mtx.data[4] = 1.0f;
-    mtx.data[8] = 1.0f;
-}
-
-void Matrix33::RotateX(Matrix33 &mtx, float rad)
-{
-    float s = sin(rad);
-    float c = cos(rad);
-    memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = 1;
-    mtx.data[4] = c;
-    mtx.data[5] = -s;
-    mtx.data[7] = s;
-    mtx.data[8] = c;
-}
-void Matrix33::RotateY(Matrix33 &mtx, float rad)
-{
-    float s = sin(rad);
-    float c = cos(rad);
-    memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = c;
-    mtx.data[2] = s;
-    mtx.data[4] = 1;
-    mtx.data[6] = -s;
-    mtx.data[8] = c;
-}
-
-void Matrix33::Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result)
-{
-    MatrixMul(3, a.data, b.data, result.data);
-}
-
-void Matrix33::Multiply(const Matrix33 &a, const float vec[3], float result[3])
-{
-    for (int i = 0; i < 3; ++i) {
-        result[i] = 0;
-        for (int k = 0; k < 3; ++k) {
-            result[i] += a.data[i * 3 + k] * vec[k];
-        }
-    }
-}
-
-void Matrix44::LoadIdentity(Matrix44 &mtx)
-{
-    memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = 1.0f;
-    mtx.data[5] = 1.0f;
-    mtx.data[10] = 1.0f;
-    mtx.data[15] = 1.0f;
-}
-
-void Matrix44::LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33)
-{
-    for (int i = 0; i < 3; ++i)
-    {
-        for (int j = 0; j < 3; ++j)
-        {
-            mtx.data[i * 4 + j] = m33.data[i * 3 + j];
-        }
-    }
-
-    for (int i = 0; i < 3; ++i)
-    {
-        mtx.data[i * 4 + 3] = 0;
-        mtx.data[i + 12] = 0;
-    }
-    mtx.data[15] = 1.0f;
-}
-
-void Matrix44::Set(Matrix44 &mtx, const float mtxArray[16])
-{
-    for(int i = 0; i < 16; ++i) {
-        mtx.data[i] = mtxArray[i];
-    }
-}
-
-void Matrix44::Translate(Matrix44 &mtx, const float vec[3])
-{
-    LoadIdentity(mtx);
-    mtx.data[3] = vec[0];
-    mtx.data[7] = vec[1];
-    mtx.data[11] = vec[2];
-}
-
-void Matrix44::Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result)
-{
-    MatrixMul(4, a.data, b.data, result.data);
-}
-
diff --git a/src/common/math_util.h b/src/common/math_util.h
index 52f579cf7..0b1400b41 100644
--- a/src/common/math_util.h
+++ b/src/common/math_util.h
@@ -4,11 +4,9 @@
 
 #pragma once
 
-#include "common/common_types.h"
-
 #include <algorithm>
+#include <cstdlib>
 #include <type_traits>
-#include <vector>
 
 namespace MathUtil
 {
@@ -19,83 +17,6 @@ inline T Clamp(const T val, const T& min, const T& max)
     return std::max(min, std::min(max, val));
 }
 
-static const u64 DOUBLE_SIGN = 0x8000000000000000ULL,
-    DOUBLE_EXP  = 0x7FF0000000000000ULL,
-    DOUBLE_FRAC = 0x000FFFFFFFFFFFFFULL,
-    DOUBLE_ZERO = 0x0000000000000000ULL;
-
-static const u32 FLOAT_SIGN = 0x80000000,
-    FLOAT_EXP  = 0x7F800000,
-    FLOAT_FRAC = 0x007FFFFF,
-    FLOAT_ZERO = 0x00000000;
-
-union IntDouble {
-    double d;
-    u64 i;
-};
-union IntFloat {
-    float f;
-    u32 i;
-};
-
-inline bool IsNAN(double d)
-{
-    IntDouble x; x.d = d;
-    return ( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
-             ((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) );
-}
-
-inline bool IsQNAN(double d)
-{
-    IntDouble x; x.d = d;
-    return ( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
-             ((x.i & 0x0007fffffffffffULL) == 0x000000000000000ULL) &&
-             ((x.i & 0x000800000000000ULL) == 0x000800000000000ULL) );
-}
-
-inline bool IsSNAN(double d)
-{
-    IntDouble x; x.d = d;
-    return( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
-            ((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) &&
-            ((x.i & 0x0008000000000000ULL) == DOUBLE_ZERO) );
-}
-
-inline float FlushToZero(float f)
-{
-    IntFloat x; x.f = f;
-    if ((x.i & FLOAT_EXP) == 0)
-        x.i &= FLOAT_SIGN;  // turn into signed zero
-    return x.f;
-}
-
-inline double FlushToZeroAsFloat(double d)
-{
-    IntDouble x; x.d = d;
-    if ((x.i & DOUBLE_EXP) < 0x3800000000000000ULL)
-        x.i &= DOUBLE_SIGN;  // turn into signed zero
-    return x.d;
-}
-
-enum PPCFpClass
-{
-    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,
-};
-
-// Uses PowerPC conventions for the return value, so it can be easily
-// used directly in CPU emulation.
-u32 ClassifyDouble(double dvalue);
-// More efficient float version.
-u32 ClassifyFloat(float fvalue);
-
 template<class T>
 struct Rectangle
 {
@@ -104,101 +25,12 @@ struct Rectangle
     T right;
     T bottom;
 
-    Rectangle()
-    { }
+    Rectangle() {}
 
-    Rectangle(T theLeft, T theTop, T theRight, T theBottom)
-        : left(theLeft), top(theTop), right(theRight), bottom(theBottom)
-    { }
-
-    bool operator==(const Rectangle& r) { return left==r.left && top==r.top && right==r.right && bottom==r.bottom; }
+    Rectangle(T left, T top, T right, T bottom) : left(left), top(top), right(right), bottom(bottom) {}
 
     T GetWidth() const { return std::abs(static_cast<typename std::make_signed<T>::type>(right - left)); }
     T GetHeight() const { return std::abs(static_cast<typename std::make_signed<T>::type>(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)
-    {
-        if (left < x1) left = x1;
-        if (right > x2) right = x2;
-        if (top > y1) top = y1;
-        if (bottom < y2) bottom = y2;
-    }
-
-    // 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)
-    {
-        if (left < x1) left = x1;
-        if (right > x2) right = x2;
-        if (top < y1) top = y1;
-        if (bottom > y2) bottom = y2;
-    }
 };
 
 }  // namespace MathUtil
-
-inline float pow2f(float x) {return x * x;}
-inline double pow2(double x) {return x * x;}
-
-float MathFloatVectorSum(const std::vector<float>&);
-
-#define ROUND_UP(x, a)        (((x) + (a) - 1) & ~((a) - 1))
-#define ROUND_DOWN(x, a)    ((x) & ~((a) - 1))
-
-// Rounds down. 0 -> undefined
-inline u64 Log2(u64 val)
-{
-#if defined(__GNUC__)
-    return 63 - __builtin_clzll(val);
-
-#elif defined(_MSC_VER) && defined(_M_X64)
-    unsigned long result = -1;
-    _BitScanReverse64(&result, val);
-    return result;
-
-#else
-    u64 result = -1;
-    while (val != 0)
-    {
-        val >>= 1;
-        ++result;
-    }
-    return result;
-#endif
-}
-
-// Tiny matrix/vector library.
-// Used for things like Free-Look in the gfx backend.
-
-class Matrix33
-{
-public:
-    static void LoadIdentity(Matrix33 &mtx);
-
-    // 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);
-
-    // 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]);
-
-    float data[9];
-};
-
-class Matrix44
-{
-public:
-    static void LoadIdentity(Matrix44 &mtx);
-    static void LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33);
-    static void Set(Matrix44 &mtx, const float mtxArray[16]);
-
-    static void Translate(Matrix44 &mtx, const float vec[3]);
-
-    static void Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result);
-
-    float data[16];
-};