rad/dregree tools; added rotation and scaling

TheGame/renderwidget.cpp

 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
   , _radius(5.0)
-  , _phi(45)
-  , _theta(45)
+  , _phi(45.0)
+  , _theta(45.0)
+  , _angle(0.0)
 {
     _device = new OpenGLRenderDevice(this);
     _engine = new UGameEngine(_device);
 
     UGEEntityCube* cube = new UGEEntityCube(_engine);
     cube->setTextureId("test");
-//    cube->move(Vector3D(0, 1, 0));
+    cube->rotate(Vector3D(0.0, 45.0, 45.0));
+    cube->move(Vector3D(0, 1, 0));
+    cube->setScale(Vector3D(1.0, 2.0, 1.0));
 //    cube->hide();
     _engine->addEntity(cube);
     _engine->addEntity(new UGEEntityAxes(_engine));
     _engine->addEntity(obj);
     obj->hide();
 
+    _entity = cube;
+//    animate();
 }
 
 void RenderWidget::initializeGL()
         rotate(-diff.x(), -diff.y());
 
         _lastPoint = event->pos();
+        update();
     }
 
-    Vector3D dd = _device->get2DFrom3D(Vector3D(0.5, 0.5, 0.5));
-    dd.setY(height() - dd.getY());
+//    Vector3D dd = _device->get2DFrom3D(Vector3D(0.5, 0.5, 0.5));
+//    dd.setY(height() - dd.getY());
 //    qDebug() << event->pos() << dd;
-    pos = _device->get3DFrom2D(event->x(), height() - event->y());
+//    pos = _device->get3DFrom2D(event->x(), height() - event->y());
 
-    update();
 }
 
 void RenderWidget::wheelEvent(QWheelEvent *event)
     }
     update();
 }
+
+void RenderWidget::animate()
+{
+//    _angle += 0.1;
+    _entity->rotate(Vector3D(0.0, 2.0, 2.0));
+    QTimer::singleShot(20, this, SLOT(animate()));
+    update();
+}

TheGame/renderwidget.h

 signals:
 
 public slots:
+    void animate();
 
 private:
     AbstractRenderDevice* _device;
 
     QPoint _lastPoint;
 
-    float _radius;
+    double _radius;
 
-    float _phi;
+    double _phi;
 
-    float _theta;
+    double _theta;
 
     Vector3D pos;
+
+    double _angle;
+
+    UGEEntity* _entity;
 };
 
 #endif // RENDERWIDGET_H

UGameEngine/UGameEngine.pro

     utils/texturevector3d.cpp \
     utils/vector2d.cpp \
     utils/vector3d.cpp \
-    utils/matrix3x3.cpp
+    utils/matrix3x3.cpp \
+    utils/tools.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
     utils/vector2d.h \
     utils/matrixmxn.h \
     utils/matrixmxn.hxx \
-    utils/matrix3x3.h
+    utils/matrix3x3.h \
+    utils/tools.h \
+    utils/tools.hxx
 
 
 # FLEX && BISON

UGameEngine/entities/ugeentity.cpp

 #include "ugeentity.h"
+#include "utils/tools.h"
 
 UGEEntity::UGEEntity(QObject *parent)
     : QObject(parent)
+    , _scale(1.0, 1.0, 1.0)
     , _visible(true)
 {
 }
 
 void UGEEntity::setRotation(const Vector3D &rotation)
 {
-    _rotation = rotation;
+    _rotation = Tools::normalizeAngle(rotation);
     emit rotationChanged();
     emit rotationChanged(rotation);
 }
 
 void UGEEntity::rotate(const Vector3D &rotation)
 {
-    _rotation += rotation;
+    _rotation = Tools::normalizeAngle(rotation + _rotation);
     emit rotationChanged();
     emit rotationChanged(rotation);
 }
 
 Vector3D UGEEntity::getRealPoint(const Vector3D &pos)
 {
-    Vector3D p = pos + _position;
-    return p;
+    Matrix3x3 scale;
+    scale.setScalar(0, 0, _scale.getX());
+    scale.setScalar(1, 1, _scale.getY());
+    scale.setScalar(2, 2, _scale.getZ());
+    Vector3D p = scale.multMatrix(pos);
+    Matrix3x3 rot = getRotationMatrix(_rotation);
+    return (rot.multMatrix(p) + _position);
 }
 
 ColorVector3D UGEEntity::getRealPoint(const ColorVector3D &pos)
     return TextureVector3D(pos.getTextureCoord(), getRealPoint((ColorVector3D)pos));
 }
 
+Matrix3x3 UGEEntity::getRotationMatrix(const Vector3D &rotation)
+{
+    Vector3D r = Tools::degreeToRad(rotation);
+
+    Matrix3x3 mx;
+    mx.setToIdentity();
+    mx.setScalar(1, 1, cos(r.getX()));
+    mx.setScalar(1, 2, -sin(r.getX()));
+    mx.setScalar(2, 1, sin(r.getX()));
+    mx.setScalar(2, 2, cos(r.getX()));
+
+    Matrix3x3 my;
+    my.setToIdentity();
+    my.setScalar(0, 0, cos(r.getY()));
+    my.setScalar(0, 2, sin(r.getY()));
+    my.setScalar(2, 0, -sin(r.getY()));
+    my.setScalar(2, 2, cos(r.getY()));
+
+    Matrix3x3 mz;
+    mz.setToIdentity();
+    mz.setScalar(0, 0, cos(r.getZ()));
+    mz.setScalar(0, 1, -sin(r.getZ()));
+    mz.setScalar(1, 0, sin(r.getZ()));
+    mz.setScalar(1, 1, cos(r.getZ()));
+
+    return mx.multMatrix(my).multMatrix(mz);
+}
+
 void UGEEntity::drawPoint(AbstractRenderDevice *device, const ColorVector3D &point)
 {
     device->drawPoint(getRealPoint(point));

UGameEngine/entities/ugeentity.h

 #include <QPoint>
 #include <QSharedPointer>
 #include "utils/vector3d.h"
+#include "utils/matrix3x3.h"
 #include "engine/abstractrenderdevice.h"
 
 class UGEEntity : public QObject
     ColorVector3D getRealPoint(const ColorVector3D& pos);
     TextureVector3D getRealPoint(const TextureVector3D& pos);
 
+    Matrix3x3 getRotationMatrix(const Vector3D& rotation);
+
     virtual void drawPoint(AbstractRenderDevice* device, const ColorVector3D& point);
 
     virtual void drawLine(AbstractRenderDevice* device, const ColorVector3D& begin, const ColorVector3D& end, double width = 1.0);

UGameEngine/utils/matrixmxn.h

 public:
     virtual ~GenericMatrix();
 
+    static T getIdentityMatrix();
+
     T& setScalar(unsigned i, unsigned j, double value);
     double getScalar(unsigned i, unsigned j) const;
 
     T& fill(double k);
     T& fill(double scalars[M][N]);
 
+    T& setToIdentity();
+
     T& add(double k);
     T& add(double scalars[M][N]);
     T& add(const T& other);

UGameEngine/utils/matrixmxn.hxx

 {
 }
 
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::getIdentityMatrix()
+{
+    T m;
+    m.setToIdentity();
+    return m;
+}
+
 uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::setScalar(unsigned i, unsigned j, double value)
 {
     _scalars[i][j] = value;
     return *getThis();
 }
 
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::setToIdentity()
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] = (i == j);
+        }
+    }
+    return *getThis();
+}
+
 uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::add(double k)
 {
     return add(T(k));
         for (int j = 0; j < P; ++j) {
             double t = 0;
             for (int k = 0; k < N; ++k) {
-                t += _scalars[i][k] * other._scalars[k][j];
+                t += _scalars[i][k] * other.getScalar(k, j);
             }
-            m._scalars[i][j] = t;
+            m.setScalar(i, j, t);
         }
     }
     return m;

UGameEngine/utils/tools.cpp

+#include "tools.h"
+#include <math.h>
+
+double Tools::normalizeAngle(double angle)
+{
+    while (angle >= 360.0) {
+        angle -= 360.0;
+    }
+    while (angle < 0.0) {
+        angle += 360.0;
+    }
+    return angle;
+}
+
+double Tools::radToDegree(double angle)
+{
+    return angle * 180.0 / M_PI;
+}
+
+double Tools::degreeToRad(double angle)
+{
+    return angle * M_PI / 180.0;
+}

UGameEngine/utils/tools.h

+#ifndef TOOLS_H
+#define TOOLS_H
+
+#include "utils/matrixmxn.h"
+
+class Tools
+{
+public:
+    static double normalizeAngle(double angle);
+    uge_gm_tmpl_mn static MatrixMxN<M, N> normalizeAngle(const MatrixMxN<M, N>& rotation);
+
+    static double radToDegree(double angle);
+    uge_gm_tmpl_mn static MatrixMxN<M, N> radToDegree(const MatrixMxN<M, N>& rotation);
+
+    static double degreeToRad(double angle);
+    uge_gm_tmpl_mn static MatrixMxN<M, N> degreeToRad(const MatrixMxN<M, N>& rotation);
+};
+
+#include "utils/tools.hxx"
+
+#endif // TOOLS_H

UGameEngine/utils/tools.hxx

+#ifndef TOOLS_HXX
+#define TOOLS_HXX
+
+#include <math.h>
+#define uge_gm_tmpl_mn template<unsigned M, unsigned N>
+
+uge_gm_tmpl_mn MatrixMxN<M, N> Tools::normalizeAngle(const MatrixMxN<M, N> &rotation)
+{
+    MatrixMxN<M, N> other;
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            other.setScalar(i, j, normalizeAngle(rotation.getScalar(i)));
+        }
+    }
+    return other;
+}
+
+uge_gm_tmpl_mn MatrixMxN<M, N> Tools::radToDegree(const MatrixMxN<M, N> &rotation)
+{
+    return rotation * MatrixMxN<M, N>(180.0 / M_PI);
+}
+
+uge_gm_tmpl_mn MatrixMxN<M, N> Tools::degreeToRad(const MatrixMxN<M, N> &rotation)
+{
+    return rotation * MatrixMxN<M, N>(M_PI / 180.0);
+}
+
+#endif // TOOLS_HXX

UGameEngine/utils/vectorxd.h

 #include <QDebug>
 #include "matrixmxn.h"
 
-#define tmplx template<unsigned X>
-#define tmpl template<unsigned X, class T>
+#define uge_gv_tmpl_x template<unsigned X>
+#define uge_gv_tmpl_xt template<unsigned X, class T>
 
-tmpl class GenericVector: public GenericMatrix<X, 1, T >
+uge_gv_tmpl_xt class GenericVector: public GenericMatrix<X, 1, T >
 {
 public:
 
     T* getThis() const;
 };
 
-tmplx using VectorXD = MatrixMxN<X, 1>;
+uge_gv_tmpl_x using VectorXD = MatrixMxN<X, 1>;
 
-tmplx class MatrixMxN<X, 1>: public GenericVector<X, VectorXD<X>>
+uge_gv_tmpl_x class MatrixMxN<X, 1>: public GenericVector<X, VectorXD<X>>
 {
 public:
     MatrixMxN();

UGameEngine/utils/vectorxd.hxx

 #include <math.h>
 
-#define tmplx template<unsigned X>
-#define tmpl template<unsigned X, class T>
+#define uge_gv_tmpl_x template<unsigned X>
+#define uge_gv_tmpl_xt template<unsigned X, class T>
 
-tmplx VectorXD<X>::MatrixMxN()
+uge_gv_tmpl_x VectorXD<X>::MatrixMxN()
 {
     this->fill(0);
 }
 
-tmplx VectorXD<X>::MatrixMxN(double k)
+uge_gv_tmpl_x VectorXD<X>::MatrixMxN(double k)
 {
     this->fill(k);
 }
 
-tmplx VectorXD<X>::MatrixMxN(const double scalars[X])
+uge_gv_tmpl_x VectorXD<X>::MatrixMxN(const double scalars[X])
 {
     this->fill(scalars);
 }
 
-tmplx VectorXD<X>::MatrixMxN(const VectorXD<X>& other)
+uge_gv_tmpl_x VectorXD<X>::MatrixMxN(const VectorXD<X>& other)
 {
     for (unsigned i = 0; i < X; ++i) {
         _scalars[i] = other._scalars[i];
     }
 }
 
-tmpl T& GenericVector<X, T>::setScalar(unsigned i, double value)
+uge_gv_tmpl_xt T& GenericVector<X, T>::setScalar(unsigned i, double value)
 {
     return setScalar(i, 0,value);
 }
 
-tmpl double GenericVector<X, T>::getScalar(unsigned i) const
+uge_gv_tmpl_xt double GenericVector<X, T>::getScalar(unsigned i) const
 {
     return getScalar(i, 0);
 }
 
-tmpl double GenericVector<X, T>::operator[](unsigned i) const
+uge_gv_tmpl_xt double GenericVector<X, T>::operator[](unsigned i) const
 {
     return getScalar(i);
 }
 
-tmpl double GenericVector<X, T>::dotProduct(const T &other) const
+uge_gv_tmpl_xt double GenericVector<X, T>::dotProduct(const T &other) const
 {
     double total = 0;
     for (unsigned i = 0; i < X; ++i) {
     return total;
 }
 
-tmpl T& GenericVector<X, T>::crossProduct(const T& other)
+uge_gv_tmpl_xt T& GenericVector<X, T>::crossProduct(const T& other)
 {
     T t = *getThis();
     for (unsigned i = 0; i < X; ++i) {
     return *getThis();
 }
 
-tmpl T GenericVector<X, T>::crossProduct(const T &v1, const T &v2)
+uge_gv_tmpl_xt T GenericVector<X, T>::crossProduct(const T &v1, const T &v2)
 {
     return T(v1).crossProduct(v2);
 }
 
-tmpl double GenericVector<X, T>::norm() const
+uge_gv_tmpl_xt double GenericVector<X, T>::norm() const
 {
     double total = 0;
     for (unsigned i = 0; i < X; ++i) {
     return sqrt(total);
 }
 
-tmpl T* GenericVector<X, T>::getThis() const
+uge_gv_tmpl_xt T* GenericVector<X, T>::getThis() const
 {
     return (T*)this;
 }
 
-//tmpl QDebug operator<<(QDebug dbg, const T &v)
+//uge_gv_tmpl_xt QDebug operator<<(QDebug dbg, const T &v)
 //{
 //    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
 //}