KeosMath.h

Go to the documentation of this file.

/*
 * This source file is part of KEOS (Free 3D Engine)
 * For the latest info, see http://www.keosengine.org/
 * E-mails : thierry.vouriot@keosengine.org, yeri@keosengine.org
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307, USA, or go to
 * http://www.gnu.org/copyleft/lesser.txt.
 *
 */

#ifndef KEOS_MATH_H
#define KEOS_MATH_H

#include "KeosPrerequisites.h"

namespace Keos
{
  class CDegree;

  //-----------------------------------------------------------------------
  class CRadian
  {
  protected:

    Real m_Rad;

  public:
    CRadian ( Real r = 0 ) : m_Rad(r)
    {}
    CRadian ( const CDegree& d );
    const CRadian& operator = ( const Real& f )
    {
      m_Rad = f;
      return *this;
    }
    const CRadian& operator = ( const CRadian& r )
    {
      m_Rad = r.m_Rad;
      return *this;
    }
    const CRadian& operator = ( const CDegree& d );

    Real valueDegrees() const;
    Real valueRadians() const
    {
      return m_Rad;
    }

    CRadian operator + ( const CRadian& r ) const
    {
      return CRadian ( m_Rad + r.m_Rad );
    }
    CRadian operator + ( const CDegree& d ) const;
    CRadian& operator += ( const CRadian& r )
    {
      m_Rad += r.m_Rad;
      return *this;
    }
    CRadian& operator += ( const CDegree& d );
    CRadian operator - ()
    {
      return CRadian(-m_Rad);
    }
    CRadian operator - ( const CRadian& r ) const
    {
      return CRadian ( m_Rad - r.m_Rad );
    }
    CRadian operator - ( const CDegree& d ) const;
    CRadian& operator -= ( const CRadian& r )
    {
      m_Rad -= r.m_Rad;
      return *this;
    }
    CRadian& operator -= ( const CDegree& d );
    CRadian operator * ( Real f ) const
    {
      return CRadian ( m_Rad * f );
    }
    CRadian operator * ( const CRadian& f ) const
    {
      return CRadian ( m_Rad * f.m_Rad );
    }
    CRadian& operator *= ( Real f )
    {
      m_Rad *= f;
      return *this;
    }
    CRadian operator / ( Real f ) const
    {
      return CRadian ( m_Rad / f );
    }
    CRadian& operator /= ( Real f )
    {
      m_Rad /= f;
      return *this;
    }

    bool operator <  ( const CRadian& r ) const
    {
      return m_Rad <  r.m_Rad;
    }
    bool operator <= ( const CRadian& r ) const
    {
      return m_Rad <= r.m_Rad;
    }
    bool operator == ( const CRadian& r ) const
    {
      return m_Rad == r.m_Rad;
    }
    bool operator != ( const CRadian& r ) const
    {
      return m_Rad != r.m_Rad;
    }
    bool operator >= ( const CRadian& r ) const
    {
      return m_Rad >= r.m_Rad;
    }
    bool operator >  ( const CRadian& r ) const
    {
      return m_Rad >  r.m_Rad;
    }
  };

  //-----------------------------------------------------------------------
  class CDegree
  {
  protected:
    Real m_Deg;

  public:
    explicit CDegree ( Real d = 0 ) : m_Deg(d)
    {}
    CDegree ( const CRadian& r ) : m_Deg(r.valueDegrees())
    {}
    const CDegree& operator = ( const Real& f )
    {
      m_Deg = f;
      return *this;
    }
    const CDegree& operator = ( const CDegree& d )
    {
      m_Deg = d.m_Deg;
      return *this;
    }
    const CDegree& operator = ( const CRadian& r )
    {
      m_Deg = r.valueDegrees();
      return *this;
    }

    Real valueDegrees() const
    {
      return m_Deg;
    }
    Real valueRadians() const;

    CDegree operator + ( const CDegree& d ) const
    {
      return CDegree ( m_Deg + d.m_Deg );
    }
    CDegree operator + ( const CRadian& r ) const
    {
      return CDegree ( m_Deg + r.valueDegrees() );
    }
    CDegree& operator += ( const CDegree& d )
    {
      m_Deg += d.m_Deg;
      return *this;
    }
    CDegree& operator += ( const CRadian& r )
    {
      m_Deg += r.valueDegrees();
      return *this;
    }
    CDegree operator - ()
    {
      return CDegree(-m_Deg);
    }
    CDegree operator - ( const CDegree& d ) const
    {
      return CDegree ( m_Deg - d.m_Deg );
    }
    CDegree operator - ( const CRadian& r ) const
    {
      return CDegree ( m_Deg - r.valueDegrees() );
    }
    CDegree& operator -= ( const CDegree& d )
    {
      m_Deg -= d.m_Deg;
      return *this;
    }
    CDegree& operator -= ( const CRadian& r )
    {
      m_Deg -= r.valueDegrees();
      return *this;
    }
    CDegree operator * ( Real f ) const
    {
      return CDegree ( m_Deg * f );
    }
    CDegree operator * ( const CDegree& f ) const
    {
      return CDegree ( m_Deg * f.m_Deg );
    }
    CDegree& operator *= ( Real f )
    {
      m_Deg *= f;
      return *this;
    }
    CDegree operator / ( Real f ) const
    {
      return CDegree ( m_Deg / f );
    }
    CDegree& operator /= ( Real f )
    {
      m_Deg /= f;
      return *this;
    }

    bool operator <  ( const CDegree& d ) const
    {
      return m_Deg <  d.m_Deg;
    }
    bool operator <= ( const CDegree& d ) const
    {
      return m_Deg <= d.m_Deg;
    }
    bool operator == ( const CDegree& d ) const
    {
      return m_Deg == d.m_Deg;
    }
    bool operator != ( const CDegree& d ) const
    {
      return m_Deg != d.m_Deg;
    }
    bool operator >= ( const CDegree& d ) const
    {
      return m_Deg >= d.m_Deg;
    }
    bool operator >  ( const CDegree& d ) const
    {
      return m_Deg >  d.m_Deg;
    }
  };


  //-----------------------------------------------------------------------
  class KEOS_EXPORT CMath
  {
  public:

    CMath();

    ~CMath();

    static uint NearestPowerOfTwo(uint nValue);

    static Real UnitRandom ();

    static Real RangeRandom (Real fLow, Real fHigh);

    static Real SymmetricRandom ();

    static inline Real DegreesToRadians(Real degrees)
    {
      return degrees * fDeg2Rad;
    }

    static inline Real RadiansToDegrees(Real radians)
    {
      return radians * fRad2Deg;
    }

    static bool RealEqual(Real a, Real b,
                          Real tolerance = std::numeric_limits<Real>::epsilon());

    static TVector4F calculateFaceNormal(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3);

    static TVector3F calculateBasicFaceNormal(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3);

    static TVector4F calculateFaceNormalWithoutNormalize(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3);

    static TVector3F calculateBasicFaceNormalWithoutNormalize(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3);

    static const Real POS_INFINITY;
    static const Real NEG_INFINITY;
    static const Real PI;
    static const Real TWO_PI;
    static const Real HALF_PI;
    static const Real fDeg2Rad;
    static const Real fRad2Deg;
  };


  //=======================================================================
  // Inline functions
  //=======================================================================

  //-----------------------------------------------------------------------
  inline CRadian::CRadian ( const CDegree& d ) : m_Rad(d.valueRadians())
  {}

  //-----------------------------------------------------------------------
  inline const CRadian& CRadian::operator = ( const CDegree& d )
  {
    m_Rad = d.valueRadians();
    return *this;
  }

  //-----------------------------------------------------------------------
  inline CRadian CRadian::operator + ( const CDegree& d ) const
  {
    return CRadian ( m_Rad + d.valueRadians() );
  }

  //-----------------------------------------------------------------------
  inline CRadian& CRadian::operator += ( const CDegree& d )
  {
    m_Rad += d.valueRadians();
    return *this;
  }

  //-----------------------------------------------------------------------
  inline CRadian CRadian::operator - ( const CDegree& d ) const
  {
    return CRadian ( m_Rad - d.valueRadians() );
  }

  //-----------------------------------------------------------------------
  inline CRadian& CRadian::operator -= ( const CDegree& d )
  {
    m_Rad -= d.valueRadians();
    return *this;
  }

  //-----------------------------------------------------------------------
  inline Real CRadian::valueDegrees() const
  {
    return CMath::RadiansToDegrees ( m_Rad );
  }

  //-----------------------------------------------------------------------
  inline Real CDegree::valueRadians() const
  {
    return CMath::DegreesToRadians ( m_Deg );
  }

  //-----------------------------------------------------------------------
  inline CRadian operator * ( Real a, const CRadian& b )
  {
    return CRadian ( a * b.valueRadians() );
  }

  //-----------------------------------------------------------------------
  inline CRadian operator / ( Real a, const CRadian& b )
  {
    return CRadian ( a / b.valueRadians() );
  }

  //-----------------------------------------------------------------------
  inline CDegree operator * ( Real a, const CDegree& b )
  {
    return CDegree ( a * b.valueDegrees() );
  }

  //-----------------------------------------------------------------------
  inline CDegree operator / ( Real a, const CDegree& b )
  {
    return CDegree ( a / b.valueDegrees() );
  }

} // namespace Keos

#endif // KEOS_MATH_H

---