vector3d.h

Go to the documentation of this file.

#ifndef Vector3_H
#define Vector3_H

#include "lwpp/math.h"

namespace lwpp
{

#ifndef PI
 #define PI     (3.14159265358979324)
#endif
#ifndef HALFPI
 #define HALFPI (PI*0.5)
#endif
#ifndef TWOPI
 #define TWOPI (PI*2.0)
#endif

  template <typename T> class Point3;

  template <typename T>
  class Vector3 {
    public:
      T x, y, z; 
    public:

      explicit Vector3 (T n = 0.0) 
        : x(n), y(n), z(n) {}

      Vector3 (T _x, T _y, T _z) 
        : x(_x), y(_y), z(_z) {};

      explicit Vector3 (const T n[3]) 
        : x(n[0]), y(n[1]), z(n[2]) {}
      explicit Vector3 (const Point3<T> &p);
      Vector3 (T theta, T phi)
        : x( -sin(theta) * cos(phi) ),
          y( -sin(theta) * sin(phi) ),
          z( cos(theta) )
      {}

      inline T *asLWVector() {return &x;}
      inline T Dot(Vector3 a) const;
      inline Vector3 Cross(Vector3 a) const;
      inline T Magnitude() const {return sqrt(Sqr(x) + Sqr(y) + Sqr(z));}
      inline Vector3 &Normalize();

      T &X() {return x;}
      T &Y() {return y;}
      T &Z() {return z;}

      inline void Translate (Vector3 dir, T distance) {
        x += dir.x * distance;
        y += dir.y * distance;
        z += dir.z * distance;
      }
      inline Vector3& operator+= (Vector3 b) {
        x += b.x;
        y += b.y;
        z += b.z;
        return *this;
      }
      inline Vector3 operator+ (Vector3 b)
      {
        return Vector3 (x + b.x, y + b.y, z + b.z);
      }
      inline Vector3& operator-= (Vector3 b) {
        x -= b.x;
        y -= b.y;
        z -= b.z;
        return *this;
      }
      inline Vector3 operator- (Vector3 b)
      {
        return Vector3 (x - b.x, y - b.y, z - b.z);
      }

      inline Vector3& operator*= (Vector3 b) {
        x *= b.x;
        y *= b.y;
        z *= b.z;
        return *this;
      }
      inline Vector3 operator* (Vector3 b) 
      {
        return Vector3 (x * b.x, y * b.y, z * b.z);
      }

      inline Vector3& operator*= (T b)
      {
        x *= b;
        y *= b;
        z *= b;
        return *this;
      }
      inline Vector3 operator* (double b)
      {
        return Vector3 (x * b, y * b, z * b);
      }

      inline Vector3& operator/= (Vector3 b)
      {
        x /= b.x;
        y /= b.y;
        z /= b.z;
        return *this;
      }
      inline Vector3 operator/ (Vector3 b)
      {
        return Vector3 (x / b.x, y / b.y, z / b.z);
      }
      inline Vector3& operator/= (T b) {
        T ib = 1.0 / b;
        x *= ib;
        y *= ib;
        z *= ib;
        return *this;
      }
      inline Vector3 operator/ (T b)
      {
        T ib = 1.0 / b;
        return Vector3 (x * ib, y * ib, z * ib);
      }

      inline T SphericalTheta()
      {
        return acos(-y);
      }
      inline T SphericalPhi()
      {
        float p = atan2(x, z);
        return (p < 0.0) ? p + TWOPI : p;
      }

      inline void Abs()
      {
        x = x > 0 ? x : -x;
        y = y > 0 ? y : -y;
        z = z > 0 ? z : -z;
      }
  };


  template <typename T>
  inline Vector3<T> Cross(Vector3<T> a, Vector3<T> b)
  {
    return Vector3<T>(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 <typename T>
  inline T Vector3<T>::Dot(Vector3<T> a) const
  {
    return (x*a.x + y*a.y + z*a.z);
  }

  template <typename T>
  inline Vector3<T> Vector3<T>::Cross(Vector3<T> a) const
  {
    return Vector3<T>( y*a.z - z*a.y, z*a.x - x*a.z, x*a.y - y*a.x );
  }

  template <typename T>
  inline Vector3<T> &Vector3<T>::Normalize()
  {
    *this /= Magnitude();
    return *this;
  }

  template <typename T>
  inline void CoordinateSystem(const Vector3<T> &v1, Vector3<T> *v2, Vector3<T> *v3)
  {
    if (abs(v1.x) > abs(v1.y))
    {
      T invLen = 1.0 / sqrt(v1.x * v1.x + v1.z * v1.z);
      *v2 = Vector3<T>(-v1.z * invLen, 0.0, v1.x * invLen);
    }
    else
    {
      T invLen = 1.0 / sqrt(v1.y * v1.y + v1.z * v1.z);
      *v2 = Vector3<T>(0.0, v1.z * invLen, -v1.y * invLen);
    }
    *v3 = Cross(v1, *v2);
  }
  template <typename T>
  inline void CoordinateSystem(const Vector3<T> &view, const Vector3<T> &normal, Vector3<T> *right, Vector3<T> *forward)
  {
    if (view.Dot(normal) < .1)
    {
      CoordinateSystem(normal, right, forward);
    }
    else
    {
      *right = Cross(view, normal);
      *forward = Cross(*right, normal);
    }
  }

  typedef Vector3<double> Vector3d;
  typedef Vector3<float> Vector3f;

} // end namespace lwpp
#endif // Vector3_H