KeosMath.cpp

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.
 *
 */

#include "KeosMath.h"

namespace Keos
{
  //=======================================================================
  // CMath implementation
  //=======================================================================

  const Real CMath::POS_INFINITY = std::numeric_limits<Real>::infinity();
  const Real CMath::NEG_INFINITY = -std::numeric_limits<Real>::infinity();
  const Real CMath::PI = Real( 4.0 * atan( 1.0 ) );
  const Real CMath::TWO_PI = Real( 2.0 * PI );
  const Real CMath::HALF_PI = Real( 0.5 * PI );
  const Real CMath::fDeg2Rad = PI / Real(180.0);
  const Real CMath::fRad2Deg = Real(180.0) / PI;


  //-----------------------------------------------------------------------
  CMath::CMath( )
  {}

  //-----------------------------------------------------------------------
  CMath::~CMath()
  {}

  //-----------------------------------------------------------------------
  uint CMath::NearestPowerOfTwo(uint nValue)
  {
    uint nTemp = nValue;
    uint nPowerOfTwo = 0;

    while (nTemp > 1)
    {
      nTemp >>= 1;
      ++nPowerOfTwo;
    }

    uint nRetval = 1 << nPowerOfTwo;

    return nRetval == nValue ? nRetval : nRetval << 1;
  }

  //-----------------------------------------------------------------------
  Real CMath::UnitRandom ()
  {
    return float(rand()) / float(RAND_MAX);
  }

  //-----------------------------------------------------------------------
  Real CMath::RangeRandom (Real fLow, Real fHigh)
  {
    return (fHigh -fLow)*UnitRandom() + fLow;
  }

  //-----------------------------------------------------------------------
  Real CMath::SymmetricRandom ()
  {
    return 2.0f * UnitRandom() - 1.0f;
  }

  //-----------------------------------------------------------------------
  bool CMath::RealEqual( Real a, Real b, Real tolerance )
  {
    if (fabs(b - a) <= tolerance)
      return true;
    else
      return false;
  }

  //-----------------------------------------------------------------------
  TVector4F CMath::calculateFaceNormal(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3)
  {
    TVector3F normal = calculateBasicFaceNormal(v1, v2, v3);
    // Now set up the w (distance of tri from origin
    return TVector4F(normal.x, normal.y, normal.z, -VectorDot(normal, v1));
  }

  //-----------------------------------------------------------------------
  TVector3F CMath::calculateBasicFaceNormal(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3)
  {
    TVector3F normal = VectorCross((v2 - v1), (v3 - v1));
    normal.Normalize();
    return normal;
  }

  //-----------------------------------------------------------------------
  TVector4F CMath::calculateFaceNormalWithoutNormalize(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3)
  {
    TVector3F normal = calculateBasicFaceNormalWithoutNormalize(v1, v2, v3);
    // Now set up the w (distance of tri from origin)
    return TVector4F(normal.x, normal.y, normal.z, -VectorDot(normal, v1));
  }

  //-----------------------------------------------------------------------
  TVector3F CMath::calculateBasicFaceNormalWithoutNormalize(const TVector3F& v1, const TVector3F& v2, const TVector3F& v3)
  {
    TVector3F normal = VectorCross((v2 - v1), (v3 - v1));
    return normal;
  }

} // namespace Keos

---