Vector3.h

#ifndef VECTOR3_H
#define VECTOR3_H

/*
** ---------------------------------------------------------------
** Includes:
*/
#include <iostream>
#include <vector>
#include "defs.h"
#include "Vector4.h"


/*
** ---------------------------------------------------------------
** Definitions:
*/

using namespace std;

class Vector4;
class Vector3;

typedef vector<Vector3 *> Vector3Array;


class Vector3 {

public:


        Vector3 (void);
        Vector3 (Real x, Real y, Real z);
        Vector3(const Vector4 &vector); 
        Vector3(const Vector3 &vector); 
        ~Vector3(void);
        
        Real &operator()(int comp);
        Real operator()(int comp) const;
        Vector3 &operator=(const Vector3 &u);           

        Vector3 unit(void);
        Real norm(void);
        Real sqrnorm(void);

private :

        Real x,y,z;
        friend class Vector4; // for row() and col()

};

inline Vector3 operator*(Real s, const Vector3 &u);
inline Vector3 operator+(const Vector3 &u, const Vector3 &v);
inline Vector3 operator-(const Vector3 &u, const Vector3 &v);
inline Real operator*(const Vector3 &u, const Vector3 &v);
inline Vector3 cross(const Vector3 &u, const Vector3 &v);
inline Vector3 mult(const Vector3 &u,const Vector3 &v);
inline Vector3 lerp(Real t, const Vector3 &u, const Vector3 &v);
inline Vector3 bilerp(Real t, Real lt, const Vector3 &l0, const Vector3 &l1,
                          Real rt, const Vector3 &r0, const Vector3 &r1);

inline istream &operator>>(istream &is, Vector3 &vector);
inline ostream &operator<<(ostream &os, const Vector3 &vector);

inline
Vector3::Vector3(void)
{
        x = y = z = 0.0;
}

inline
Vector3::Vector3(const Vector3 &vector)
        : x(vector(0)),
          y(vector(1)),
          z(vector(2))
{
}

inline
Vector3::Vector3(Real x_, Real y_, Real z_)
        : x(x_),
          y(y_),
          z(z_)
{
}

inline 
Vector3::Vector3(const Vector4 &v)
{
        Real w_ = v(3);
        if (REL_EQ(v(3), 0.)) 
                w_ = 1.;
        x = v(0)/w_;
        y = v(1)/w_;
        z = v(2)/w_;
}

inline Vector3 &
Vector3::operator=(const Vector3 &vector)
{
        x = vector(0);
        y = vector(1);
        z = vector(2);
        return *this;
}

inline Real &
Vector3::operator()(int comp)
{
        return (comp == 0) ? x : ( (comp == 1) ? y : z );
}

inline Real
Vector3::operator()(int comp) const
{
        return (comp == 0) ? x : ( (comp == 1) ? y : z );
}

inline Vector3
operator*(Real s, const Vector3 &u)
{
        return Vector3(s*u(0), s*u(1), s*u(2));
}

inline Vector3
operator+(const Vector3 &u, const Vector3 &v)
{
        return Vector3(u(0) + v(0), u(1) + v(1), u(2) + v(2));
}

inline Vector3
operator-(const Vector3 &u, const Vector3 &v)
{
        return Vector3(u(0) - v(0), u(1) - v(1), u(2) - v(2));
}

inline Real
operator*(const Vector3 &u, const Vector3 &v)
{
        return u(0)*v(0) + u(1)*v(1) + u(2)*v(2);
}

inline Vector3 
cross(const Vector3 &u, const Vector3 &v)
{
        Vector3 uxv;
        uxv(0) =    u(1) * v(2) - v(1) * u(2);
        uxv(1) =  - u(0) * v(2) + v(0) * u(2);
        uxv(2) =    u(0) * v(1) - u(1) * v(0);
        return uxv;
}

inline Vector3 
Vector3::unit(void)
{
        Real  length = z_norm(this);
        if(fabs(length) < EPS)
        throw "(g3_unit) zero norm\n";
        else
        return z_scale(1.0/length,this);
}

inline Real
Vector3::sqrnorm(void)
{
        return (x * x + y * y + z * z);
}

inline Real
Vector3::norm(void)
{
        return sqrt((Real)(x * x + y * y + z * z));
}

inline Vector3 
mult(const Vector3 &u,const Vector3 &v)
{
        Vector3 w;
        w(0) = u(0) * v(0);  w(1) = u(1) * v(1);  w(2) = u(2) * v(2);
        return w;
}

inline Vector3 
lerp(Real t, const Vector3 &u, const Vector3 &v)
{
        return ((1-t)*u) + ((t)*v);
}

inline Vector3 
bilerp(Real t, Real lt, const Vector3 &l0, const Vector3 &l1,
                          Real rt, const Vector3 &r0, const Vector3 &r1)
{
        return lerp(t, lerp(lt, l0, l1), lerp(rt, r0, r1));
}

inline istream &
operator>>(istream &is, Vector3 &vector)
{
        is >> vector(0) >> vector(1) >> vector(2);
        return is;
}

inline ostream &
operator<<(ostream &os, const Vector3 &vector)
{
        os << vector(0) << " " << vector(1) << " " << vector(2);
        return os;
}
#endif //VECTOR3_H

---