xrb_math.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_math.hpp by Victor Dods, created 2005/06/25
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_MATH_HPP_)
#define _XRB_MATH_HPP_

#include "xrb.hpp"

#if defined(WIN32)
    // this is for _finite()
    #include <float.h>
#endif // defined(WIN32)
#include <math.h>
#include <stdlib.h>

#include "xrb_vector.hpp"

namespace Xrb
{

namespace Math
{

    inline Float Radians (Float const angle)
    {
        static Float const conversion_factor = static_cast<Float>(M_PI) / 180.0f;
        return angle * conversion_factor;
    }
    inline Float Degrees (Float const radians)
    {
        static Float const conversion_factor = 180.0f / static_cast<Float>(M_PI);
        return radians * conversion_factor;
    }
    Float CanonicalAngle (Float angle);

    inline Float Sin (Float const angle)
    {
        return sinf(Radians(angle));
    }
    inline Float Asin (Float const value)
    {
        return Degrees(asinf(value));
    }
    inline Float Cos (Float const angle)
    {
        return cosf(Radians(angle));
    }
    inline Float Acos (Float const value)
    {
        return Degrees(acosf(value));
    }
    inline Float Tan (Float const angle)
    {
        return tanf(Radians(angle));
    }
    inline Float Atan (Float const value)
    {
        return Degrees(atanf(value));
    }
    inline Float Atan (FloatVector2 const &vector)
    {
        return Degrees(atan2f(vector[Dim::Y], vector[Dim::X]));
    }
    inline Float Atan2 (Float const y, Float const x)
    {
        return Degrees(atan2f(y, x));
    }
    inline FloatVector2 UnitVector (Float const angle)
    {
        Float angle_in_radians = Radians(angle);
        return FloatVector2(cosf(angle_in_radians), sinf(angle_in_radians));
    }
    inline Float Sqrt (Float const x)
    {
        return sqrtf(x);
    }
    inline Float Pow (Float const base, Float const exponent)
    {
        return powf(base, exponent);
    }
    Float PowInt (Float base, Uint32 exponent);
    Float RandomFloat (Float lower_bound, Float upper_bound);
    Uint16 RandomUint16 (Uint16 lower_bound = 0, Uint16 upper_bound = 65535);
    inline Float RandomAngle ()
    {
        return RandomFloat(static_cast<Float>(0), static_cast<Float>(360));
    }
    inline Float ExpBaseE (Float const exponent)
    {
        return expf(exponent);
    }
    inline Float ExpBase10 (Float const exponent)
    {
        return powf(static_cast<Float>(10), exponent);
    }
    inline Float LogBaseE (Float const x)
    {
        return logf(x);
    }
    inline Float LogBase10 (Float const x)
    {
        return log10f(x);
    }
    inline Float Nan ()
    {
        // hacky type way to get the IEEE single precision floating
        // point representation of not-a-number.
    #if defined(WORDS_BIGENDIAN)
        static Uint8 const s_nan_bytes[8] = { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
        static Float const s_nan = *reinterpret_cast<Float const *>(s_nan_bytes);
    #else // !defined(WORDS_BIGENDIAN)
        static Uint8 const s_nan_bytes[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F };
        static Float const s_nan = *reinterpret_cast<Float const *>(s_nan_bytes + 8 - sizeof(Float));
    #endif // !defined(WORDS_BIGENDIAN)

        return s_nan;
    }
    inline bool IsFinite (Float const x)
    {
    #if defined(WIN32)
        return _finite(static_cast<double>(x)) != 0;
    #else // !defined(WIN32)
        return isfinite(x);
    #endif
    }
    Uint32 HighestBitIndex (Uint32 x);
    template <Uint32 fractional_bits, typename IntType>
    inline IntType FixedPointRound (IntType x)
    {
        if (x < 0)
            x -= (1<<(fractional_bits-1));
        else
            x += (1<<(fractional_bits-1));
        return x;
    }

    Float FastSin (Float angle);
    Float FastAsin (Float value);
    Float FastCos (Float angle);
    Float FastAcos (Float value);
    Float FastTan (Float angle);
    Float FastAtan (Float value);
    Float FastAtan (FloatVector2 const &vector);
    Float FastAtan2 (Float y, Float x);
    FloatVector2 FastUnitVector (Float angle);
    Float FastSqrt (Float x);
    Float FastPow (Float base, Float exponent);

    inline Float Floor (Float const x)
    {
        return floorf(x);
    }
    inline Float Ceiling (Float const x)
    {
        return ceilf(x);
    }
    inline Float Round (Float const x)
    {
        return floorf(x + 0.5f);
    }
} // end of namespace Math

} // end of namespace Xrb

#endif // !defined(_XRB_MATH_HPP_)

---