specialized vector2d and vector3d instead of inheritance

UGameEngine/utils/vector2d.cpp

 #include "vector2d.h"
 
+VectorXD<2>::VectorXD()
+{
+    _scalars[0] = 0.0;
+    _scalars[1] = 0.0;
+}
 
-Vector2D::Vector2D(double x, double y)
-    : VectorXD<2>()
+VectorXD<2>::VectorXD(const double scalars[2])
 {
-    _scalars[0] = x;
-    _scalars[1] = y;
+    _scalars[0] = scalars[0];
+    _scalars[1] = scalars[1];
 }
 
-Vector2D::Vector2D(const Vector2D &other)
-    : VectorXD<2>(other)
+Vector2D::VectorXD(double x, double y)
 {
+    _scalars[0] = x;
+    _scalars[1] = y;
 }
 
-Vector2D::Vector2D(const VectorXD<2> &other)
-    : VectorXD<2>(other)
+Vector2D::VectorXD(const VectorXD<2> &other)
 {
+    _scalars[0] = other._scalars[0];
+    _scalars[1] = other._scalars[1];
 }
 
-Vector2D::~Vector2D()
+Vector2D::~VectorXD()
 {
 }
 
 
 Vector2D &Vector2D::add(double x, double y)
 {
-    _scalars[0] += x;
-    _scalars[1] += y;
-    return *this;
+    return add(Vector2D(x, y));
 }
 
 Vector2D &Vector2D::sub(double x, double y)
 {
-    _scalars[0] -= x;
-    _scalars[1] -= y;
-    return *this;
+    return sub(Vector2D(x, y));
 }
 
 double Vector2D::dotProduct(double x, double y) const

UGameEngine/utils/vector2d.h

 
 #include "vectorxd.h"
 
-class Vector2D : public VectorXD<2>
+typedef VectorXD<2> Vector2D;
+
+template<> class VectorXD<2> : public GenericVector<2, VectorXD<2> >
 {
 public:
-    explicit Vector2D(double x = 0.0, double y = 0.0);
-    Vector2D(const Vector2D& other);
-    Vector2D(const VectorXD<2>& other);
-    virtual ~Vector2D();
+    VectorXD<2>();
+    VectorXD<2>(const double scalars[2]);
+    VectorXD<2>(double x, double y);
+    VectorXD<2>(const VectorXD<2>& other);
+    virtual ~VectorXD<2>();
 
     double getX() const;
     Vector2D& setX(double x);
     double getY() const;
     Vector2D& setY(double y);
 
-    using VectorXD<2>::add;
+    using GenericVector<2, VectorXD<2> >::add;
     Vector2D& add(double x, double y);
 
-    using VectorXD<2>::sub;
+    using GenericVector<2, VectorXD<2> >::sub;
     Vector2D& sub(double x, double y);
 
-    using VectorXD<2>::dotProduct;
+    using GenericVector<2, VectorXD<2> >::dotProduct;
     double dotProduct(double x, double y) const;
 };
 

UGameEngine/utils/vector3d.cpp

 #include "vector3d.h"
 #include <math.h>
 
-Vector3D::Vector3D(double x, double y, double z)
-    : VectorXD<3>()
+Vector3D::VectorXD()
 {
-    _scalars[0] = x;
-    _scalars[1] = y;
-    _scalars[2] = z;
+    _scalars[0] = 0.0;
+    _scalars[1] = 0.0;
+    _scalars[2] = 0.0;
 }
 
-Vector3D::Vector3D(const Vector3D &other)
-    : VectorXD<3>(other)
+Vector3D::VectorXD(const double scalars[3])
 {
+    _scalars[0] = scalars[0];
+    _scalars[1] = scalars[1];
+    _scalars[2] = scalars[2];
+}
+
+Vector3D::VectorXD(double x, double y, double z)
+{
+    _scalars[0] = x;
+    _scalars[1] = y;
+    _scalars[2] = z;
 }
 
-Vector3D::Vector3D(const VectorXD<3> &other)
-    : VectorXD<3>(other)
+Vector3D::VectorXD(const Vector3D &other)
 {
+    _scalars[0] = other._scalars[0];
+    _scalars[1] = other._scalars[1];
+    _scalars[2] = other._scalars[2];
 }
 
-Vector3D::~Vector3D()
+Vector3D::~VectorXD()
 {
 }
 

UGameEngine/utils/vector3d.h

 
 #include "vectorxd.h"
 
-class Vector3D: public VectorXD<3>
+typedef VectorXD<3> Vector3D;
+
+template<> class VectorXD<3>: public GenericVector<3, VectorXD<3> >
 {
 public:
-    explicit Vector3D(double x = 0.0, double y = 0.0, double z = 0.0);
-    Vector3D(const Vector3D& other);
-    Vector3D(const VectorXD<3>& other);
-    virtual ~Vector3D();
+    VectorXD<3>();
+    VectorXD<3>(const double scalars[3]);
+    VectorXD<3>(double x, double y, double z);
+    VectorXD<3>(const Vector3D& other);
+    virtual ~VectorXD<3>();
 
     double getX() const;
     Vector3D& setX(double x);
     double getZ() const;
     Vector3D& setZ(double z);
 
-    using VectorXD<3>::add;
+    using GenericVector<3, VectorXD<3> >::add;
     Vector3D& add(double x, double y, double z);
 
-    using VectorXD<3>::sub;
+    using GenericVector<3, VectorXD<3> >::sub;
     Vector3D& sub(double x, double y, double z);
 
-    using VectorXD<3>::dotProduct;
+    using GenericVector<3, VectorXD<3> >::dotProduct;
     double dotProduct(double x, double y, double z) const;
 };
 

UGameEngine/utils/vectorxd.h

 
 #include <QDebug>
 
-#define tmpl template<unsigned X>
+#define tmplx template<unsigned X>
+#define tmpl template<unsigned X, class T>
 
-tmpl class VectorXD
+tmpl class GenericVector
 {
 public:
-    VectorXD();
-    VectorXD(const double scalars[X]);
-    VectorXD(const VectorXD<X>& other);
 
-    VectorXD<X>& setScalar(unsigned i, double value);
+    T& setScalar(unsigned i, double value);
     double getScalar(unsigned i) const;
 
     bool isNull() const;
 
-    bool equal(const VectorXD<X>& other) const;
-
-    VectorXD<X>& add(double k);
-    VectorXD<X>& add(double scalars[X]);
-    VectorXD<X>& add(const VectorXD<X>& other);
+    bool equal(const T& other) const;
 
-    VectorXD<X>& sub(double k);
-    VectorXD<X>& sub(double scalars[X]);
-    VectorXD<X>& sub(const VectorXD<X>& other);
+    T& add(double k);
+    T& add(double scalars[X]);
+    T& add(const T& other);
 
-    VectorXD<X>& mult(double k);
-    VectorXD<X>& mult(double scalars[X]);
-    VectorXD<X>& mult(const VectorXD<X>& k);
+    T& sub(double k);
+    T& sub(double scalars[X]);
+    T& sub(const T& other);
 
-    VectorXD<X>& div(double k);
-    VectorXD<X>& div(double scalars[X]);
-    VectorXD<X>& div(const VectorXD<X>& k);
+    T& mult(double k);
+    T& mult(double scalars[X]);
+    T& mult(const T& k);
 
+    T& div(double k);
+    T& div(double scalars[X]);
+    T& div(const T& k);
 
-    double dotProduct(const VectorXD<X>& other) const;
+    double dotProduct(const T& other) const;
 
-    VectorXD<X>& crossProduct(const VectorXD<X>& other);
-    static VectorXD<X> crossProduct(const VectorXD<X> &v1, const VectorXD<X> &v2);
+    T& crossProduct(const T& other);
+    static T crossProduct(const T &v1, const T &v2);
 
     double norm() const;
 
-    VectorXD<X> operator+() const;
-    VectorXD<X> operator+(const double& k) const;
-    VectorXD<X>& operator+=(const double& k);
-    VectorXD<X> operator+(const VectorXD<X>& other) const;
-    VectorXD<X>& operator+=(const VectorXD<X>& other);
+    T operator+() const;
+    T operator+(const double& k) const;
+    T& operator+=(const double& k);
+    T operator+(const T& other) const;
+    T& operator+=(const T& other);
 
-    VectorXD<X> operator-() const;
-    VectorXD<X> operator-(const double& k) const;
-    VectorXD<X>& operator-=(const double& k);
-    VectorXD<X> operator-(const VectorXD<X>& other) const;
-    VectorXD<X>& operator-=(const VectorXD<X>& other);
+    T operator-() const;
+    T operator-(const double& k) const;
+    T& operator-=(const double& k);
+    T operator-(const T& other) const;
+    T& operator-=(const T& other);
 
-    VectorXD<X> operator*(const double& k) const;
-    VectorXD<X>& operator*=(const double& k);
-    VectorXD<X> operator*(const VectorXD<X>& other) const;
-    VectorXD<X>& operator*=(const VectorXD<X>& other);
+    T operator*(const double& k) const;
+    T& operator*=(const double& k);
+    T operator*(const T& other) const;
+    T& operator*=(const T& other);
 
-    VectorXD<X> operator/(const double& k) const;
-    VectorXD<X>& operator/=(const double& k);
+    T operator/(const double& k) const;
+    T& operator/=(const double& k);
 
-    bool operator==(const VectorXD<X>& other) const;
-    bool operator!=(const VectorXD<X>& other) const;
+    bool operator==(const T& other) const;
+    bool operator!=(const T& other) const;
 
     double operator[](unsigned i) const;
 
 
 protected:
     double _scalars[X];
+
+private:
+    T* getThis() const;
+};
+
+tmplx class VectorXD: public GenericVector<X, VectorXD<X> >
+{
+public:
+    VectorXD();
+    VectorXD(const double scalars[X]);
+    VectorXD(const VectorXD<X>& other);
+
+protected:
+    using GenericVector<X, VectorXD<X> >::_scalars;
 };
 
-tmpl QDebug operator<<(QDebug dbg, const VectorXD<X>& v);
+tmplx QDebug operator<<(QDebug dbg, const VectorXD<X>& v);
 
 #include "vectorxd.hxx"
 

UGameEngine/utils/vectorxd.hxx

 #include <math.h>
 
-#define tmpl template<unsigned X>
+#define tmplx template<unsigned X>
+#define tmpl template<unsigned X, class T>
 
-tmpl VectorXD<X>::VectorXD()
+tmplx VectorXD<X>::VectorXD()
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] = 0;
     }
 }
 
-tmpl VectorXD<X>::VectorXD(const double scalars[X])
+tmplx VectorXD<X>::VectorXD(const double scalars[X])
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] = scalars[i];
     }
 }
 
-tmpl VectorXD<X>::VectorXD(const VectorXD<X>& other)
+tmplx VectorXD<X>::VectorXD(const VectorXD<X>& other)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] = other._scalars[i];
     }
 }
 
-tmpl VectorXD<X>& VectorXD<X>::setScalar(unsigned i, double value)
+tmpl T& GenericVector<X, T>::setScalar(unsigned i, double value)
 {
     _scalars[i] = value;
-    return *this;
+    return *getThis();
 }
 
-tmpl double VectorXD<X>::getScalar(unsigned i) const
+tmpl double GenericVector<X, T>::getScalar(unsigned i) const
 {
     return _scalars[i];
 }
 
-tmpl bool VectorXD<X>::isNull() const
+tmpl bool GenericVector<X, T>::isNull() const
 {
-    return equal(VectorXD<X>());
+    return equal(T());
 }
 
-tmpl bool VectorXD<X>::equal(const VectorXD<X> &other) const
+tmpl bool GenericVector<X, T>::equal(const T &other) const
 {
     for (unsigned i = 0; i < X; ++i) {
         if (_scalars[i] != other._scalars[i]) {
     return true;
 }
 
-tmpl VectorXD<X> &VectorXD<X>::add(double k)
+tmpl T &GenericVector<X, T>::add(double k)
 {
     double scalars[X];
     for (unsigned i = 0; i < X; ++i) {
         scalars[i] = k;
     }
-    return add(VectorXD<X>(scalars));
+    return add(T(scalars));
 }
 
-tmpl VectorXD<X> &VectorXD<X>::add(double scalars[X])
+tmpl T &GenericVector<X, T>::add(double scalars[X])
 {
-    return add(VectorXD<X>(scalars));
+    return add(T(scalars));
 }
 
-tmpl VectorXD<X>& VectorXD<X>::add(const  VectorXD<X> &other)
+tmpl T& GenericVector<X, T>::add(const  T &other)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] += other._scalars[i];
     }
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> &VectorXD<X>::sub(double k)
+tmpl T &GenericVector<X, T>::sub(double k)
 {
     double scalars[X];
     for (unsigned i = 0; i < X; ++i) {
         scalars[i] = k;
     }
-    return sub(VectorXD<X>(scalars));
+    return sub(T(scalars));
 }
 
-tmpl VectorXD<X> &VectorXD<X>::sub(double scalars[X])
+tmpl T &GenericVector<X, T>::sub(double scalars[X])
 {
-    return sub(VectorXD<X>(scalars));
+    return sub(T(scalars));
 }
 
-tmpl VectorXD<X>& VectorXD<X>::sub(const VectorXD<X> &other)
+tmpl T& GenericVector<X, T>::sub(const T &other)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] -= other._scalars[i];
     }
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> &VectorXD<X>::mult(double k)
+tmpl T &GenericVector<X, T>::mult(double k)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] *= k;
     }
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> &VectorXD<X>::mult(double scalars[X])
+tmpl T &GenericVector<X, T>::mult(double scalars[X])
 {
-    return mult(VectorXD<X>(scalars));
+    return mult(T(scalars));
 }
 
-tmpl VectorXD<X> &VectorXD<X>::mult(const VectorXD<X> &other)
+tmpl T &GenericVector<X, T>::mult(const T &other)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] *= other._scalars[i];
     }
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> &VectorXD<X>::div(double k)
+tmpl T &GenericVector<X, T>::div(double k)
 {
     double scalars[X];
     for (unsigned i = 0; i < X; ++i) {
         scalars[i] = k;
     }
-    return div(VectorXD<X>(scalars));
+    return div(T(scalars));
 }
 
-tmpl VectorXD<X> &VectorXD<X>::div(double scalars[X])
+tmpl T &GenericVector<X, T>::div(double scalars[X])
 {
-    return div(VectorXD<X>(scalars));
+    return div(T(scalars));
 }
 
-tmpl VectorXD<X> &VectorXD<X>::div(const VectorXD<X> &other)
+tmpl T &GenericVector<X, T>::div(const T &other)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] /= other._scalars[i];
     }
-    return *this;
+    return *getThis();
 }
 
-tmpl double VectorXD<X>::dotProduct(const VectorXD<X> &other) const
+tmpl double GenericVector<X, T>::dotProduct(const T &other) const
 {
     double total = 0;
     for (unsigned i = 0; i < X; ++i) {
     return total;
 }
 
-tmpl VectorXD<X>& VectorXD<X>::crossProduct(const VectorXD<X>& other)
+tmpl T& GenericVector<X, T>::crossProduct(const T& other)
 {
-    VectorXD<X> t = *this;
+    T t = *getThis();
     for (unsigned i = 0; i < X; ++i) {
         unsigned j = (i + 1) % X;
         unsigned k = (i + 2) % X;
         _scalars[i] = (t._scalars[j] * other._scalars[k]) - (t._scalars[k] * other._scalars[j]);
     }
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> VectorXD<X>::crossProduct(const VectorXD<X> &v1, const VectorXD<X> &v2)
+tmpl T GenericVector<X, T>::crossProduct(const T &v1, const T &v2)
 {
-    return VectorXD<X>(v1).crossProduct(v2);
+    return T(v1).crossProduct(v2);
 }
 
-tmpl double VectorXD<X>::norm() const
+tmpl double GenericVector<X, T>::norm() const
 {
     double total = 0;
     for (unsigned i = 0; i < X; ++i) {
     return sqrt(total);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator+() const
+tmpl T GenericVector<X, T>::operator+() const
 {
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator+(const double &k) const
+tmpl T GenericVector<X, T>::operator+(const double &k) const
 {
-    return VectorXD(*this).add(k);
+    return T(*getThis()).add(k);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator+=(const double &k)
+tmpl T &GenericVector<X, T>::operator+=(const double &k)
 {
     return add(k);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator+(const VectorXD<X> &other) const
+tmpl T GenericVector<X, T>::operator+(const T &other) const
 {
-    return VectorXD<X>(*this).add(other);
+    T v = *getThis();
+    return v.add(other);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator+=(const VectorXD<X> &other)
+tmpl T &GenericVector<X, T>::operator+=(const T &other)
 {
     return add(other);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator-() const
+tmpl T GenericVector<X, T>::operator-() const
 {
     double scalars[X];
     for (unsigned i = 0; i < X; ++i) {
         scalars[i] = -_scalars[i];
     }
-    return VectorXD<X>(scalars);
+    return T(scalars);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator-(const double &k) const
+tmpl T GenericVector<X, T>::operator-(const double &k) const
 {
-    return VectorXD(*this).sub(k);
+    return T(*getThis()).sub(k);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator-=(const double &k)
+tmpl T &GenericVector<X, T>::operator-=(const double &k)
 {
     return sub(k);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator-(const VectorXD<X> &other) const
+tmpl T GenericVector<X, T>::operator-(const T &other) const
 {
-    return VectorXD(*this).sub(other);
+    return T(*getThis()).sub(other);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator-=(const VectorXD<X> &other)
+tmpl T &GenericVector<X, T>::operator-=(const T &other)
 {
     return sub(other);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator*(const double &k) const
+tmpl T GenericVector<X, T>::operator*(const double &k) const
 {
-    return VectorXD<X>(*this).mult(k);
+    return T(*getThis()).mult(k);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator*=(const double &k)
+tmpl T &GenericVector<X, T>::operator*=(const double &k)
 {
     return mult(k);
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator*(const VectorXD<X> &other) const
+tmpl T GenericVector<X, T>::operator*(const T &other) const
 {
-    return VectorXD<X>(*this).mult(other);
+    return T(*getThis()).mult(other);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator*=(const VectorXD<X> &other)
+tmpl T &GenericVector<X, T>::operator*=(const T &other)
 {
     dotProduct(other);
-    return *this;
+    return *getThis();
 }
 
-tmpl VectorXD<X> VectorXD<X>::operator/(const double &k) const
+tmpl T GenericVector<X, T>::operator/(const double &k) const
 {
-    return VectorXD<X>(*this).div(k);
+    return T(*getThis()).div(k);
 }
 
-tmpl VectorXD<X> &VectorXD<X>::operator/=(const double &k)
+tmpl T &GenericVector<X, T>::operator/=(const double &k)
 {
     return div(k);
 }
 
-tmpl bool VectorXD<X>::operator==(const VectorXD<X> &other) const
+tmpl bool GenericVector<X, T>::operator==(const T &other) const
 {
     return equal(other);
 }
 
-tmpl bool VectorXD<X>::operator!=(const VectorXD<X> &other) const
+tmpl bool GenericVector<X, T>::operator!=(const T &other) const
 {
     return !equal(other);
 }
 
-tmpl double VectorXD<X>::operator[](unsigned i) const
+tmpl double GenericVector<X, T>::operator[](unsigned i) const
 {
     return getScalar(i);
 }
 
-tmpl bool VectorXD<X>::operator!() const
+tmpl bool GenericVector<X, T>::operator!() const
 {
     return isNull();
 }
 
-tmpl VectorXD<X>::operator bool() const
+tmpl GenericVector<X, T>::operator bool() const
 {
     return !isNull();
 }
 
-tmpl QDebug operator<<(QDebug dbg, const VectorXD<X> &v)
+tmpl T* GenericVector<X, T>::getThis() const
+{
+    return (T*)this;
+}
+
+tmpl QDebug operator<<(QDebug dbg, const T &v)
 {
     return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
 }