_Vector3.h

Go to the documentation of this file.

#ifndef __VECMATH_VECTOR3_HPP
#define __VECMATH_VECTOR3_HPP

#ifndef __VECMATH_TUPLE3_HPP
#include <vecmath/_Tuple3.h>
#endif

#ifndef __VECMATH_POINT3_HPP
#include <vecmath/_Point3.h>
#endif

//#define DEBUGVECTOR3(d) d
#define DEBUGVECTOR3(d)

template <class Type> class _Vector3 : public _Tuple3<Type> {
public:

    _Vector3<Type>() : _Tuple3<Type>() {}

    // prevent implicit constructors!!!
    explicit _Vector3<Type>(Type x, Type y = 0, Type z = 0) : _Tuple3<Type>(x, y, z) {
        DEBUGVECTOR3(cout << "_Vector3 constructor x,y,z " << *this << endl);
    }

    _Vector3<Type>(const _Tuple3<double>& v) : _Tuple3<Type>(v) {
        DEBUGVECTOR3(cout << "_Vector3 constructor &double " << *this << endl);
    }

    // extension
    _Vector3<Type>(const _Point3<double>& v, const _Point3<double>& v1) {
        _Tuple3<Type>::sub(v, v1);
        DEBUGVECTOR3(cout << "_Vector3 constructor &double " << *this << endl);
    }

    _Vector3<Type>(const _Tuple3<float>& v) : _Tuple3<Type>(v) {
        DEBUGVECTOR3(cout << "_Vector3 constructor &float " << *this << endl);
    }

    _Vector3<Type>(const _Point3<float>& v, const _Point3<float>& v1) {
        _Tuple3<Type>::sub(v, v1);
        DEBUGVECTOR3(cout << "_Vector3 constructor &float " << *this << endl);
    }

    _Vector3<Type>(const Type t[3]) : _Tuple3<Type>(t) {
        DEBUGVECTOR3(cout << "_Vector3 constructor t[3] " << *this << endl);
    }

    // copy constructor
//      _Vector3<Type>& operator =(const _Tuple3<Type>& v) {
//      set(v.x, v.y, v.z);
//      DEBUGVECTOR3(cout << "_Vector3 operator= " << v << endl);
//          return (*this);
//      }

    Type angle(const _Vector3<Type>& v) const {
        double d = dot(v) / (length() * v.lentgh());
        if (d < -1)
            d = -1;
        else if (d > 1)
            d = 1;
        return (Type) acos(d);
    }

    // safe for *this
    void cross(const _Vector3<Type>& v, const _Vector3<Type>& v1) {
        Type t1 = v.y * v1.z - v1.y * v.z;
        Type t2 = v.z * v1.x - v1.z * v.x;
        // this is the right order - do not change!
        _Tuple3<Type>::z = v.x * v1.y - v1.x * v.y;
        _Tuple3<Type>::x = t1;
        _Tuple3<Type>::y = t2;
    }

    Type dot(const _Vector3<Type>& v) const {
        return _Tuple3<Type>::x * v.x + _Tuple3<Type>::y * v.y + _Tuple3<Type>::z * v.z;
    }

    Type lengthSquared() const {
        return _Tuple3<Type>::normSquared();
    }

    Type length() const {
        return _Tuple3<Type>::norm();
    }

    void normalize() {
        normalize(*this);
    }

    void normalize(const _Vector3<Type> &v) {
        Type l = v.length();
        this->set(v.x / l, v.y / l, v.z / l);
    }
};

#endif

---