AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

Vec3.cpp

Go to the documentation of this file.

#include "Vec3.h"

namespace animal {
namespace octree {

//************************************************************
// Implementation of Vec3
//************************************************************
template<class DataType>
inline
Vec3<DataType>::Vec3()
  : x(0.0f), y(0.0f), z(0.0f)
{
}
 template<class DataType>
inline Vec3<DataType>::Vec3(const DataType x,const DataType y,const DataType z)
  : x(x), y(y), z(z)
{
}
 template<class DataType>
inline Vec3<DataType>::Vec3(const Vec3& v)
  : x(v[0]),y(v[1]),z(v[2])
{
}
/*
inline Vec3<DataType>::Vec3( const animal::VectorVec<DataType>& v )
    : x(v[0]),y(v[1]),z(v[2])
{
}
*/


 template<class DataType>
inline void
Vec3<DataType>::set(const DataType ax,const DataType ay,const DataType az)
{
  x = ax;
  y = ay;
  z = az;
}
template<class DataType>
inline void Vec3<DataType>::set(const Vec3& v)
{
    this->set( v[0], v[1], v[2] );
}

 template<class DataType>
inline Vec3<DataType>::operator const DataType*() const
{
  return static_cast<const DataType*>(&x);
}



 template<class DataType>
inline bool
Vec3<DataType>::operator==(const Vec3& b) const
{
  return (x == b.x &&
      y == b.y &&
      z == b.z);
}
 template<class DataType>
inline bool
Vec3<DataType>::operator!=(const Vec3& b) const
{
  return (x != b.x ||
      y != b.y ||
      z != b.z);
}
 template<class DataType>
inline bool
Vec3<DataType>::operator<(const Vec3& b) const
{
  return ((x < b.x) ||
      ((x == b.x) && y < b.y) ||
      ((x == b.x  && y == b.y) && z < b.z));
}
 template<class DataType>
inline const DataType&
Vec3<DataType>::operator[](const int i) const
{
  return static_cast<const DataType*>(&x)[i] ;
}
 template<class DataType>
inline DataType&
Vec3<DataType>::operator[](const int i)
{
  return static_cast<DataType*>(&x)[i] ;
}





template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator*=(const DataType& k)
{
    this->x *= k;
    this->y *= k;
    this->z *= k;
    return *this;
}
template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator/=(const DataType& k)
{
    this->x /= k;
    this->y /= k;
    this->z /= k;
    return *this;
}

template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator+=(const Vec3& a)
{
    this->x += a.x;
    this->y += a.y;
    this->z += a.z;
    return *this;
}
template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator-=(const Vec3& a)
{
    this->x -= a.x;
    this->y -= a.y;
    this->z -= a.z;
    return *this;
}


template<class DataType>
Vec3<DataType> operator+(const Vec3<DataType>& a, const Vec3<DataType>& b)
{
    return Vec3<DataType>( a.x+b.x, a.y+b.y, a.z+b.z );
}

template<class DataType>
Vec3<DataType> operator-(const Vec3<DataType>& a, const Vec3<DataType>& b)
{
    return Vec3<DataType>( a.x-b.x, a.y-b.y, a.z-b.z );
}

template<class DataType>
Vec3<DataType> operator-(const Vec3<DataType>& a )
{
    return Vec3<DataType>( -a.x, -a.y, -a.z );
}




template<class DataType>
DataType operator*(const Vec3<DataType>& a, const Vec3<DataType>& b)
{
    return b.x*a.x + b.y*a.y + b.z*a.z;
}
template<class DataType>
Vec3<DataType> operator*(const DataType& k, const Vec3<DataType>& a)
{
    return Vec3<DataType>( a.x*k, a.y*k, a.z*k );
}
  
template<class DataType>
Vec3<DataType> operator/(const Vec3<DataType>& a, const DataType& k) 
{
    return Vec3<DataType>( a.x/k, a.y/k, a.z/k );
}  



template<class DataType>
Vec3<DataType> operator^(const Vec3<DataType>& a, const Vec3<DataType>& b)
{
  return Vec3<DataType>(a.y*b.z - a.z*b.y,
          a.z*b.x - a.x*b.z,
          a.x*b.y - a.y*b.x);
}



 template<class DataType>
inline DataType
Vec3<DataType>::norm2() const
{
  return x*x+y*y+z*z;
}
 template<class DataType>
inline DataType
Vec3<DataType>::norm() const
{
  return sqrtf(norm2()) ;
}
 template<class DataType>
inline void
Vec3<DataType>::normalize()
{
  const DataType f = norm();
  x /= f ;
  y /= f ;
  z /= f ;
}

 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::normalized() const
{
  return *this / norm() ;
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::normalized(DataType& l) const
{
  return *this / (l=norm()) ;
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::withX(const DataType theX) const
{
  return Vec3(theX,y,z);
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::withY(const DataType theY) const
{
  return Vec3(x,theY,z);
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::withZ(const DataType theZ) const
{
  return Vec3(x,y,theZ);
}

template<class DataType>
inline const Vec3<DataType>&
Vec3<DataType>::axis(const int i)
{
  static const Vec3 axis[3] =
    {
      Vec3(1.0f,0.0f,0.0f),
      Vec3(0.0f,1.0f,0.0f),
      Vec3(0.0f,0.0f,1.0f)
    };
  return axis[i];
};
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::nonColinearVec() const
{
  return ((*this)^Vec3<DataType>::axis(0)).norm2() > 0.0001f ?
    Vec3<DataType>::axis(0) :
    Vec3<DataType>::axis(1);
}         

}
}

---