D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spMathCore.hpp

Go to the documentation of this file.

/*
 * Math core header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_MATH_CORE_H__
#define __SP_MATH_CORE_H__


#include "Base/spStandard.hpp"

#include <cmath>


namespace sp
{
namespace math
{


/*
 * Global static constants
 */

static const f64 ROUNDING_ERROR64   = 0.00000001;   // 1.0e-8
static const f32 ROUNDING_ERROR     = 0.000001f;    // 1.0e-6

static const f32 OMEGA              = 999999.f;

static const f64 PI64   = 3.1415926535897932384626433832795028841971693993751;
static const f32 PI     = 3.14159265359f;

const f32 DEG       = PI / 180.0f;
const f32 RAD       = 180.0f / PI;
const f64 DEG64     = PI64 / 180.0;
const f64 RAD64     = 180.0 / PI64;

const f64 SQRT2     = sqrt(2.0);
const f32 SQRT2F    = sqrtf(2.0f);

const f64 STDASPECT = 4.0 / 3.0;


template <typename T> inline T Abs(const T &Value)
{
    return Value < 0 ? -Value : Value;
}

template <typename T> inline T Max(const T &A, const T &B)
{
    return A > B ? A : B;
}
template <typename T> inline T Min(const T &A, const T &B)
{
    return A < B ? A : B;
}

template <typename T> inline T Max(const T &A, const T &B, const T &C)
{
    return ( A >= B && A >= C ? A : ( B >= A && B >= C ? B : C ) );
}
template <typename T> inline T Min(const T &A, const T &B, const T &C)
{
    return ( A <= B && A <= C ? A : ( B <= A && B <= C ? B : C ) );
}

template <typename T> inline void Increase(T &Value, const T &PotNewValue)
{
    if (PotNewValue > Value)
        Value = PotNewValue;
}
template <typename T> inline void Decrease(T &Value, const T &PotNewValue)
{
    if (PotNewValue < Value)
        Value = PotNewValue;
}

template <typename T> inline T MinMax(const T &Value, const T &Min, const T &Max)
{
    if (Value > Max)
        return Max;
    else if (Value < Min)
        return Min;
    return Value;
}
template <typename T> inline void Clamp(T &Value, const T &Min, const T &Max)
{
    if (Value > Max)
        Value = Max;
    else if (Value < Min)
        Value = Min;
}

template <typename T> inline void Swap(T &A, T &B)
{
    const T Temp(A);
    A = B;
    B = Temp;
}

template <typename T> inline T Sgn(const T &Value)
{
    return (Value > 0) ? T(1) : (Value < 0) ? T(-1) : T(0);
}

template <typename T> inline T Round(const T &Value, s32 Precision)
{
    s32 exp = static_cast<s32>(pow(10, Precision));
    return static_cast<T>(static_cast<s32>(Value*exp)) / exp;
}

template <typename T> inline T Pow2(const T &Value)
{
    return Value*Value;
}

template <typename T> inline T Sin(const T &Value)
{
    return static_cast<T>(sin(DEG64*Value));
}
template <typename T> inline T Cos(const T &Value)
{
    return static_cast<T>(cos(DEG64*Value));
}
template <typename T> inline T Tan(const T &Value)
{
    return static_cast<T>(tan(DEG64*Value));
}

template <typename T> inline T ASin(const T &Value)
{
    return static_cast<T>(asin(Value)*RAD64);
}
template <typename T> inline T ACos(const T &Value)
{
    return static_cast<T>(acos(Value)*RAD64);
}
template <typename T> inline T ATan(const T &Value)
{
    return static_cast<T>(atan(Value)*RAD64);
}

template <typename T> inline T Log(const T &Value, const T &Base = T(10))
{
    return log(Value) / log(Base);
}

template <typename T, typename I> inline void Lerp(T &Result, const T &From, const T &To, const I &Factor)
{
    Result = To;
    Result -= From;
    Result *= Factor;
    Result += From;
}

template <typename T, typename I> inline T Lerp(const T &From, const T &To, const I &Factor)
{
    T Result;
    Lerp<T, I>(Result, From, To, Factor);
    return Result;
}

template <typename T, typename I> inline T LerpParabolic(const T &From, const T &To, const I &Factor)
{
    return Lerp(From, To, Factor*Factor);
}

template <typename T, typename I> inline T LerpSin(const T &From, const T &To, const I &Factor)
{
    return Lerp(From, To, Sin(Factor*I(90)));
}

inline s32 Round(f32 Value)
{
    return static_cast<s32>(Value + 0.5f);
}

inline s32 RoundPow2(s32 Value)
{
    s32 i;
    
    for (i = 1; i < Value; i <<= 1);
    
    if (i - Value <= Value - i/2)
        return i;
    
    return i/2;
}

inline bool Equal(f32 A, f32 B, f32 Tolerance = ROUNDING_ERROR)
{
    return (A + Tolerance >= B) && (A - Tolerance <= B);
}
inline bool Equal(s32 A, s32 B, s32 Tolerance = 0)
{
    return A == B;
}

inline bool getBitR2L(u32 Integer, s32 Pos)
{
    return ((Integer >> Pos) & 0x00000001) != 0;
}
inline void setBitR2L(u32 &Integer, s32 Pos, bool Enable)
{
    if (Enable)
        Integer |= (0x00000001 << Pos);
    else
        Integer &= ((0xFFFFFFFE << Pos) + (0x7FFFFFFF << (Pos - 31)));
}

inline bool getBitL2R(u32 Integer, s32 Pos)
{
    return ((Integer << Pos) & 0x80000000) != 0;
}
inline void setBitL2R(u32 &Integer, s32 Pos, bool Enable)
{
    if (Enable)
        Integer |= (0x80000000 >> Pos);
    else
        Integer &= ((0x7FFFFFFF >> Pos) + (0xFFFFFFFE >> (Pos - 31)));
}

inline bool getBitR2L(u8 Integer, s32 Pos)
{
    return ((Integer >> Pos) & 0x01) != 0;
}
inline void setBitR2L(u8 &Integer, s32 Pos, bool Enable)
{
    if (Enable)
        Integer |= (0x01 << Pos);
    else
        Integer &= ((0xFE << Pos) + (0x7F << (Pos - 31)));
}

inline bool getBitL2R(u8 Integer, s32 Pos)
{
    return ((Integer << Pos) & 0x80) != 0;
}
inline void setBitL2R(u8 &Integer, s32 Pos, bool Enable)
{
    if (Enable)
        Integer |= (0x80 >> Pos);
    else
        Integer &= ((0x7F >> Pos) + (0xFE >> (Pos - 31)));
}

template <typename T> inline T getTriangleArea2D(
    const T &x1, const T &y1, const T &x2, const T &y2, const T &x3, const T &y3)
{
    return (x1 - x2)*(y2 - y3) - (x2 - x3)*(y1 - y2);
}

template <typename T> T getBezierValue(const f32 t, const T &Pos1, const T &Pos2, const T &Radial1, const T &Radial2)
{
    const f32 invt    = 1.0f - t;
    const f32 invt2   = invt*invt;
    const f32 invt3   = invt2*invt;
    const f32 t2      = t*t;
    const f32 t3      = t*t*t;
    
    return Pos1*invt3 + Radial1*3*t*invt2 + Radial2*3*t2*invt + Pos2*t3;
}

template <typename T> T getBernsteinValue(const f32 t, const T Points[4])
{
    const f32 invt = 1.0f - t;
    
    return
        Points[0] * pow(t, 3) +
        Points[1] * (T(3) * pow(t, 2) * invt) +
        Points[2] * (T(3) * pow(invt, 2) * t) +
        Points[3] * pow(invt, 3);
}

template <typename T> T getGaussianValue(const T &X, const T &Mean, const T &StdDeviation)
{
    return (
        ( T(1) / sqrt( T(2) * static_cast<T>(math::PI) * StdDeviation * StdDeviation ) )
        * exp( ( -( ( X - Mean ) * ( X - Mean ) ) ) / ( T(2) * StdDeviation * StdDeviation ) )
    );
}

template <typename T> T getHaltonSequence(s32 Index, s32 Base)
{
    T Result = T(0);
    
    T f = T(1) / Base;
    
    while (Index > 0)
    {
        Result += f * (Index % Base);
        Index /= Base;
        f /= Base;
    }
    
    return Result;
}

template <typename T> T ModularPow(T Base, T Exp, const T &Modulus)
{
    T Result = T(1);
    
    while (Exp > T(0))
    {
        if (Exp % 2 == 1)
        {
            Result *= Base;
            Result %= Modulus;
        }
        Exp >>= 1;
        Base *= Base;
        Base %= Modulus;
    }
    
    return Result;
}


} // /namespace math

} // /namespace sp


#endif



// ================================================================================