---

vector.h

//---------------------------------------------------------------------------

#ifndef vectorH
#define vectorH

#include <fastmath.h>
//---------------------------------------------------------------------------
template <class t>
class vector
{
        private:
                t _x, _y, _z;


                t _length() {
                        return _fm_sqrt(_x*_x + _y*_y + _z*_z);
                }


        public:
                vector()
                : _x(0.0),
                  _y(0.0),
                  _z(0.0)
                {}

                vector(t x, t y, t z)
                : _x(x),
                  _y(y),
                  _z(z)
                {}

                vector(const vector &v)
                : _x(v._x),
                  _y(v._y),
                  _z(v._z)
                {}

                const vector &operator=(const vector &v)
                {
                        if (&v != this) {
                                _x = v._x;
                                _y = v._y;
                                _z = v._z;
                        }
                        return *this;
                }

                const vector operator*(const t s) const
                {
                        return vector<t>(_x*s, _y*s, _z*s);
                }

                const vector operator*(const vector &v) const
                {
                        return vector<t>(_y*v._z-v._y*_z,
                                         _z*v._x-v._z*_x,
                                         _x*v._y-v._x*_y);  
                }

                const t operator^(const vector &v) const
                {
                        return (_x*v._x + _y*v._y + _z*v._z);
                }

                const vector operator+(const vector &v) const
                {
                        return vector<t>(_x+v._x, _y+v._y, _z+v._z);
                }

                const vector operator+() const
                {
                        return *this;
                }

                const vector &operator+=(const vector v)
                {
                        _x += v._x;
                        _y += v._y;
                        _z += v._z;
                        return *this;
                }

                const vector operator-(const vector &v) const
                {
                        return vector<t>(_x-v._x, _y-v._y, _z-v._z);
                }

                const vector operator-() const
                {
                        vector tmp(-_x, -_y, -_z);
                        return tmp;
                }

                const vector &operator-=(const vector v)
                {
                        _x -= v._x;
                        _y -= v._y;
                        _z -= v._z;
                        return *this;
                }


                void rotx(t val)
                {
                        t _yold = _y, _zold = _z;
                        _y =   _yold*_fm_cos(val) - _zold*_fm_sin(val);
                        _z =   _yold*_fm_sin(val) + _zold*_fm_cos(val);
                }

                void roty(t val)
                {
                        t _xold = _x, _zold = _z;
                        _x =   _xold*_fm_cos(val) + _zold*_fm_sin(val);
                        _z = - _xold*_fm_sin(val) + _zold*_fm_cos(val);
                }

                void rotz(t val)
                {
                        t _xold = _x, _yold = _y;
                        _x =   _xold*_fm_cos(val) - _yold*_fm_sin(val);
                        _y =   _xold*_fm_sin(val) + _yold*_fm_cos(val);
                }

                void normal(void)
                {
                        t l = _length();
                        _x = _x / l;
                        _y = _y / l;
                        _z = _z / l;
                }


                __property t X = { read=_x, write=_x };
                __property t Y = { read=_y, write=_y };
                __property t Z = { read=_z, write=_z };
                __property t L = { read=_length };
};

typedef vector<float> vectorf;
typedef vector<double> vectord;

#endif

---