rotation/freefly cameras

TheGame/renderwidget.cpp

@@ -6,18 +6,17 @@
 #include "entities/ugeentityaxes.h"
 #include "utils/wavefrontobj.h"
 #include "entities/ugeentitywavefrontobj.h"
+#include "cameras/rotationcamera.h"
+#include "cameras/freeflycamera.h"
 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
-  , _radius(5.0)
-  , _phi(45.0)
-  , _theta(45.0)
 {
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);
 
-    _device = new OpenGLRenderDevice(this);
-    _engine = new UGameEngine(_device);
+    _engine = new UGameEngine(new OpenGLRenderDevice(this));
+    _camera = new FreeFlyCamera(_engine, this);
 
     _engine->addEntity(new UGEEntityAxes(_engine));
 
@@ -27,7 +26,6 @@ RenderWidget::RenderWidget(QWidget *parent) :
         cube->rotate(Vector3D(0.0, 45.0, 45.0));
         cube->move(Vector3D(0, i, i));
         cube->setScale(Vector3D(1.0, 2.0, 1.0));
-    //    cube->hide();
         _engine->addEntity(cube);
         _entities.append(cube);
     }
@@ -37,30 +35,21 @@ RenderWidget::RenderWidget(QWidget *parent) :
     UGEEntityWaveFrontObj* obj = new UGEEntityWaveFrontObj(wavefrontObj, this);
     _engine->addEntity(obj);
     _entities.append(obj);
-//    obj->hide();
-//    _entity = cube;
     animate();
 }
 
 void RenderWidget::initializeGL()
 {
     makeCurrent();
-    _device->setClearColor(Qt::gray);
-    _device->initialize(70, width(), height());
+    _engine->setClearColor(Qt::gray);
+    _engine->initialize(70, width(), height());
 
-    _device->loadTextureFromFile("test", "/home/robin/Downloads/test.png");
+    _engine->loadTextureFromFile("test", "/home/robin/Downloads/test.png");
 }
 
 void RenderWidget::paintGL()
 {
-    float theta = fabs(_theta / 180.0 * M_PI);
-    float phi = _phi / 180.0 * M_PI;
-    Vector3D center = Vector3D(
-                _radius * sin(theta) * sin(phi),
-                _radius * cos(theta),
-                _radius * sin(theta) * cos(phi)
-                );
-    _device->lookAt(center, Vector3D(0.0f, 0.0f, 0.0f));
+    _camera->updateLookAt();
     _engine->draw();
 //    _device->drawLine(ColorVector3D(Qt::black, 0, 0, 0), ColorVector3D(Qt::black, pos));
 //    _device->drawPoint(ColorVector3D(Qt::magenta, 0.5, 0.5, 0.5));
@@ -68,35 +57,22 @@ void RenderWidget::paintGL()
 
 void RenderWidget::resizeGL(int width, int height)
 {
-    _device->resize(width, height);
+    _engine->resize(width, height);
 }
 
-float RenderWidget::normalizeAngle(float angle)
+void RenderWidget::mousePressEvent(QMouseEvent *event)
 {
-    while (angle >= 360.0) {
-        angle -= 360.0;
-    }
-    while (angle < 0.0) {
-        angle += 360.0;
-    }
-    return angle;
+    _camera->mousePressEvent(event);
 }
 
-void RenderWidget::mousePressEvent(QMouseEvent *event)
+void RenderWidget::mouseReleaseEvent(QMouseEvent *event)
 {
-    _lastPoint = event->pos();
+    _camera->mouseReleaseEvent(event);
 }
 
 void RenderWidget::mouseMoveEvent(QMouseEvent *event)
 {
-    if (event->buttons() & Qt::LeftButton) {
-        QPoint diff = event->pos() - _lastPoint;
-
-        rotate(-diff.x(), -diff.y());
-
-        _lastPoint = event->pos();
-        update();
-    }
+    _camera->mouseMoveEvent(event);
 
 //    Vector3D dd = _device->get2DFrom3D(Vector3D(0.5, 0.5, 0.5));
 //    dd.setY(height() - dd.getY());
@@ -105,49 +81,31 @@ void RenderWidget::mouseMoveEvent(QMouseEvent *event)
 
 }
 
+void RenderWidget::mouseDoubleClickEvent(QMouseEvent *event)
+{
+    _camera->mouseDoubleClickEvent(event);
+}
+
 void RenderWidget::wheelEvent(QWheelEvent *event)
 {
-    _radius = qMax(2.0, _radius - event->delta() / 30.0);
-    update();
+    _camera->wheelEvent(event);
 }
 
 void RenderWidget::keyPressEvent(QKeyEvent *event)
 {
-    if (event->key() == Qt::Key_Up) {
-        rotate(0.0, 1.0);
-    }
-    else if (event->key() == Qt::Key_Down) {
-        rotate(0.0, -1.0);
-    }
-    else if (event->key() == Qt::Key_Left) {
-        rotate(1.0, 0.0);
-    }
-    else if (event->key() == Qt::Key_Right) {
-        rotate(-1.0, 0.0);
-    }
+    _camera->keyPressEvent(event);
 }
 
-void RenderWidget::rotate(float phi, float theta)
+void RenderWidget::keyReleaseEvent(QKeyEvent *event)
 {
-    _phi = normalizeAngle(_phi + phi);
-    if (_theta + theta >= 180.0) {
-        theta = 179.0;
-    }
-    else if (_theta + theta < 1.0) {
-        theta = 1.0;
-    }
-    else {
-        _theta = normalizeAngle(_theta + theta);
-    }
-    update();
+    _camera->keyReleaseEvent(event);
 }
 
 void RenderWidget::animate()
 {
-//    _angle += 0.1;
-    for (int i = 0; i < _entities.size(); ++i) {
-        _entities[i]->rotate(Vector3D(0.0, 2.0, 2.0));
-    }
+//    for (int i = 0; i < _entities.size(); ++i) {
+//        _entities[i]->rotate(Vector3D(0.0, 2.0, 2.0));
+//    }
     QTimer::singleShot(20, this, SLOT(animate()));
     update();
 }

TheGame/renderwidget.h

@@ -7,6 +7,7 @@
 #include <QKeyEvent>
 #include "engine/ugameengine.h"
 #include "openglrenderdevice.h"
+#include "cameras/abstractcamera.h"
 
 class RenderWidget : public QGLWidget
 {
@@ -19,14 +20,13 @@ protected:
     void paintGL();
     void resizeGL(int width, int height);
 
-    float normalizeAngle(float angle);
-
     void mousePressEvent(QMouseEvent* event);
+    void mouseReleaseEvent(QMouseEvent *event);
     void mouseMoveEvent(QMouseEvent* event);
+    void mouseDoubleClickEvent(QMouseEvent* event);
     void wheelEvent(QWheelEvent* event);
     void keyPressEvent(QKeyEvent* event);
-
-    void rotate(float phi, float theta);
+    void keyReleaseEvent(QKeyEvent* event);
 
 signals:
 
@@ -34,21 +34,13 @@ public slots:
     void animate();
 
 private:
-    AbstractRenderDevice* _device;
-
     UGameEngine* _engine;
 
-    QPoint _lastPoint;
-
-    double _radius;
-
-    double _phi;
-
-    double _theta;
-
     Vector3D pos;
 
     QList<UGEEntity*> _entities;
+
+    AbstractCamera* _camera;
 };
 
 #endif // RENDERWIDGET_H

UGameEngine/UGameEngine.pro

@@ -25,7 +25,10 @@ SOURCES += engine/ugameengine.cpp \
     utils/vector2d.cpp \
     utils/vector3d.cpp \
     utils/matrix3x3.cpp \
-    utils/tools.cpp
+    utils/tools.cpp \
+    cameras/abstractcamera.cpp \
+    cameras/rotationcamera.cpp \
+    cameras/freeflycamera.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
@@ -44,7 +47,12 @@ HEADERS += engine/ugameengine.h\
     utils/matrixmxn.hxx \
     utils/matrix3x3.h \
     utils/tools.h \
-    utils/tools.hxx
+    utils/tools.hxx \
+    cameras/abstractcamera.h \
+    cameras/rotationcamera.h \
+    cameras/freeflycamera.h \
+    utils/matrixdebug.h \
+    utils/matrixdebug.hxx
 
 
 # FLEX && BISON

UGameEngine/cameras/abstractcamera.cpp

@@ -0,0 +1,43 @@
+#include "abstractcamera.h"
+
+AbstractCamera::AbstractCamera(UGameEngine* engine, QWidget* widget)
+    : _engine(engine)
+    , _widget(widget)
+{
+}
+
+void AbstractCamera::mousePressEvent(QMouseEvent* event)
+{
+    (void) event;
+}
+
+void AbstractCamera::mouseReleaseEvent(QMouseEvent *event)
+{
+    (void) event;
+}
+
+void AbstractCamera::mouseMoveEvent(QMouseEvent* event)
+{
+    (void) event;
+}
+
+void AbstractCamera::mouseDoubleClickEvent(QMouseEvent* event)
+{
+    (void) event;
+}
+
+void AbstractCamera::wheelEvent(QWheelEvent* event)
+{
+    (void) event;
+}
+
+void AbstractCamera::keyPressEvent(QKeyEvent* event)
+{
+    (void) event;
+}
+
+void AbstractCamera::keyReleaseEvent(QKeyEvent* event)
+{
+    (void) event;
+}
+

UGameEngine/cameras/abstractcamera.h

@@ -0,0 +1,34 @@
+#ifndef ABSTRACTCAMERA_H
+#define ABSTRACTCAMERA_H
+
+#include <QMouseEvent>
+#include <QWheelEvent>
+#include <QKeyEvent>
+#include <QtWidgets/QWidget>
+
+#include "engine/ugameengine.h"
+
+class AbstractCamera
+{
+public:
+    AbstractCamera(UGameEngine* engine, QWidget* widget);
+
+    virtual void mousePressEvent(QMouseEvent* event);
+    virtual void mouseReleaseEvent(QMouseEvent *event);
+    virtual void mouseMoveEvent(QMouseEvent* event);
+    virtual void mouseDoubleClickEvent(QMouseEvent* event);
+
+    virtual void wheelEvent(QWheelEvent* event);
+
+    virtual void keyPressEvent(QKeyEvent* event);
+    virtual void keyReleaseEvent(QKeyEvent* event);
+
+    virtual void updateLookAt() = 0;
+
+protected:
+    UGameEngine* _engine;
+
+    QWidget* _widget;
+};
+
+#endif // ABSTRACTCAMERA_H

UGameEngine/cameras/freeflycamera.cpp

@@ -0,0 +1,85 @@
+#include "freeflycamera.h"
+#include <QCursor>
+#include "utils/tools.h"
+
+FreeFlyCamera::FreeFlyCamera(UGameEngine *engine, QWidget* widget)
+    : AbstractCamera(engine, widget)
+    , _speed(0.2)
+    , _phi(45)
+    , _theta(45)
+{
+    _widget->setCursor(Qt::BlankCursor);
+    _lastPoint = QPoint(_widget->width()/2,_widget->height()/2);
+    rotate(0, 0);
+}
+
+void FreeFlyCamera::mouseMoveEvent(QMouseEvent *event)
+{
+    QPoint diff = (event->pos() - _lastPoint) / 2;
+
+    rotate(-diff.x(), diff.y());
+
+    QPoint glob = _widget->mapToGlobal(QPoint(_widget->width()/2,_widget->height()/2));
+    QCursor::setPos(glob);
+    _lastPoint = QPoint(_widget->width()/2,_widget->height()/2);
+}
+
+void FreeFlyCamera::keyPressEvent(QKeyEvent *event)
+{
+    if (event->isAutoRepeat()) {
+        return;
+    }
+    if (event->key() == Qt::Key_Z) {
+        _speedVector.setX(1);
+    }
+    else if (event->key() == Qt::Key_S) {
+        _speedVector.setX(-1);
+    }
+    else if (event->key() == Qt::Key_Q) {
+        _speedVector.setY(1);
+    }
+    else if (event->key() == Qt::Key_D) {
+        _speedVector.setY(-1);
+    }
+}
+
+void FreeFlyCamera::keyReleaseEvent(QKeyEvent *event)
+{
+    if (event->key() == Qt::Key_Z || event->key() == Qt::Key_S) {
+        _speedVector.setX(0);
+    }
+    else if (event->key() == Qt::Key_Q || event->key() == Qt::Key_D) {
+        _speedVector.setY(0);
+    }
+}
+
+void FreeFlyCamera::updateLookAt()
+{
+    Vector3D perp(_direction.getZ(), 0, -_direction.getX());
+    qDebug() << perp.getX() << perp.getY() << perp.getZ() << perp.norm() << _direction.getX() << _direction.getY() << _direction.getZ() << _direction.norm();
+    perp /= perp.norm();
+    _position += Vector3D(_direction * _speedVector.getX()).mult(_speed);
+    _position += Vector3D(perp * _speedVector.getY()).mult(_speed);
+    _engine->lookAt(_position, _direction + _position);
+}
+
+void FreeFlyCamera::rotate(float phi, float theta)
+{
+    _phi = Tools::normalizeAngle(_phi + phi);
+    if (_theta + theta >= 180.0) {
+        theta = 179.0;
+    }
+    else if (_theta + theta < 1.0) {
+        theta = 1.0;
+    }
+    else {
+        _theta = Tools::normalizeAngle(_theta + theta);
+    }
+    float thetaRad = fabs(_theta / 180.0 * M_PI);
+    float phiRad = _phi / 180.0 * M_PI;
+    _direction = Vector3D(
+                sin(thetaRad) * sin(phiRad),
+                cos(thetaRad),
+                sin(thetaRad) * cos(phiRad)
+                );
+}

UGameEngine/cameras/freeflycamera.h

@@ -0,0 +1,37 @@
+#ifndef FREEFLYCAMERA_H
+#define FREEFLYCAMERA_H
+
+#include "cameras/abstractcamera.h"
+#include "utils/vector3d.h"
+
+class FreeFlyCamera : public AbstractCamera
+{
+public:
+    FreeFlyCamera(UGameEngine* engine, QWidget *widget);
+
+    virtual void mouseMoveEvent(QMouseEvent* event);
+
+    virtual void keyPressEvent(QKeyEvent* event);
+    virtual void keyReleaseEvent(QKeyEvent* event);
+
+    virtual void updateLookAt();
+
+    void rotate(float phi, float theta);
+
+private:
+    Vector3D _direction;
+
+    Vector3D _position;
+
+    Vector2D _speedVector;
+
+    double _speed;
+
+    double _phi;
+
+    double _theta;
+
+    QPoint _lastPoint;
+};
+
+#endif // FREEFLYCAMERA_H

UGameEngine/cameras/rotationcamera.cpp

@@ -0,0 +1,73 @@
+#include "rotationcamera.h"
+#include "utils/tools.h"
+
+RotationCamera::RotationCamera(UGameEngine* engine, QWidget* widget, double radius, double phi, double theta)
+    : AbstractCamera(engine, widget)
+    , _radius(radius)
+    , _phi(phi)
+    , _theta(theta)
+{
+}
+
+void RotationCamera::mousePressEvent(QMouseEvent *event)
+{
+    _lastPoint = event->pos();
+}
+
+void RotationCamera::mouseMoveEvent(QMouseEvent *event)
+{
+    if (event->buttons() & Qt::LeftButton) {
+        QPoint diff = event->pos() - _lastPoint;
+
+        rotate(-diff.x(), -diff.y());
+
+        _lastPoint = event->pos();
+    }
+}
+
+void RotationCamera::wheelEvent(QWheelEvent *event)
+{
+    _radius = qMax(2.0, _radius - event->delta() / 30.0);
+}
+
+void RotationCamera::keyPressEvent(QKeyEvent *event)
+{
+    if (event->key() == Qt::Key_Up) {
+        rotate(0.0, 1.0);
+    }
+    else if (event->key() == Qt::Key_Down) {
+        rotate(0.0, -1.0);
+    }
+    else if (event->key() == Qt::Key_Left) {
+        rotate(1.0, 0.0);
+    }
+    else if (event->key() == Qt::Key_Right) {
+        rotate(-1.0, 0.0);
+    }
+}
+
+void RotationCamera::updateLookAt()
+{
+    float theta = fabs(_theta / 180.0 * M_PI);
+    float phi = _phi / 180.0 * M_PI;
+    Vector3D center = Vector3D(
+                _radius * sin(theta) * sin(phi),
+                _radius * cos(theta),
+                _radius * sin(theta) * cos(phi)
+                );
+    _engine->lookAt(center, Vector3D(0.0f, 0.0f, 0.0f));
+}
+
+void RotationCamera::rotate(float phi, float theta)
+{
+    _phi = Tools::normalizeAngle(_phi + phi);
+    if (_theta + theta >= 180.0) {
+        theta = 179.0;
+    }
+    else if (_theta + theta < 1.0) {
+        theta = 1.0;
+    }
+    else {
+        _theta = Tools::normalizeAngle(_theta + theta);
+    }
+}

UGameEngine/cameras/rotationcamera.h

@@ -0,0 +1,32 @@
+#ifndef ROTATIONCAMERA_H
+#define ROTATIONCAMERA_H
+
+#include "abstractcamera.h"
+
+class RotationCamera : public AbstractCamera
+{
+public:
+    RotationCamera(UGameEngine* engine, QWidget *widget, double radius, double phi, double theta);
+
+    virtual void mousePressEvent(QMouseEvent* event);
+    virtual void mouseMoveEvent(QMouseEvent* event);
+
+    virtual void wheelEvent(QWheelEvent* event);
+
+    virtual void keyPressEvent(QKeyEvent* event);
+
+    virtual void updateLookAt();
+
+    void rotate(float phi, float theta);
+
+private:
+    double _radius;
+
+    double _phi;
+
+    double _theta;
+
+    QPoint _lastPoint;
+};
+
+#endif // ROTATIONCAMERA_H

UGameEngine/engine/abstractrenderdevice.h

@@ -30,7 +30,7 @@ public:
     virtual Vector3D get3DFrom2D(int x, int y) = 0;
 
 public slots:
-    virtual void setClearColor(const QColor &getClearColor);
+    virtual void setClearColor(const QColor &clearColor);
 
     virtual void setCurrentColor(const QColor &color);
 

UGameEngine/engine/ugameengine.cpp

@@ -28,3 +28,28 @@ void UGameEngine::addEntity(UGEEntity *entity)
 {
     _entitites.append(entity);
 }
+
+void UGameEngine::lookAt(const Vector3D &eye, const Vector3D &center, const Vector3D &up)
+{
+    _device->lookAt(eye, center, up);
+}
+
+void UGameEngine::setClearColor(const QColor &clearColor)
+{
+    _device->setClearColor(clearColor);
+}
+
+void UGameEngine::initialize(int fov, int width, int height)
+{
+    _device->initialize(fov, width, height);
+}
+
+void UGameEngine::resize(int width, int height)
+{
+    _device->resize(width, height);
+}
+
+void UGameEngine::loadTextureFromFile(const QVariant &id, const QString &filename)
+{
+    _device->loadTextureFromFile(id, filename);
+}

UGameEngine/engine/ugameengine.h

@@ -16,6 +16,16 @@ public:
 public slots:
     void addEntity(UGEEntity* entity);
 
+    void lookAt(const Vector3D& eye, const Vector3D& center, const Vector3D& up = Vector3D(0.0, 1.0, 0.0));
+
+    void setClearColor(const QColor &clearColor);
+
+    void initialize(int fov, int width, int height);
+
+    void resize(int width, int height);
+
+    void loadTextureFromFile(const QVariant& id, const QString& filename);
+
 protected:
     QList<UGEEntity*> _entitites;
 

UGameEngine/utils/matrixdebug.h

@@ -0,0 +1,11 @@
+#ifndef MATRIXDEBUG_H
+#define MATRIXDEBUG_H
+
+#include <QDebug>
+#include "matrixmxn.h"
+
+uge_gm_tmpl_mn QDebug operator<<(QDebug dbg, const MatrixMxN<M, N>& v);
+
+#include "matrixdebug.hxx"
+
+#endif // MATRIXDEBUG_H

UGameEngine/utils/matrixdebug.hxx

@@ -0,0 +1,13 @@
+#include "matrixdebug.h"
+
+uge_gm_tmpl_mn QDebug operator<<(QDebug dbg, const MatrixMxN<M, N> &v)
+{
+    QDebug d = dbg.nospace();
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            d << v.getScalar(i, j) << (j == N - 1 ? "" : " ");
+        }
+        d << "\n";
+    }
+    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
+}

UGameEngine/utils/vectorxd.h

@@ -46,8 +46,6 @@ protected:
     using GenericMatrix<X, 1, VectorXD<X>>::_scalars;
 };
 
-//tmplx QDebug operator<<(QDebug dbg, const VectorXD<X>& v);
-
 #include "vectorxd.hxx"
 
 #endif // VECTORXD_H

UGameEngine/utils/vectorxd.hxx

@@ -78,8 +78,3 @@ uge_gv_tmpl_xt T* GenericVector<X, T>::getThis() const
 {
     return (T*)this;
 }
-
-//uge_gv_tmpl_xt QDebug operator<<(QDebug dbg, const T &v)
-//{
-//    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
-//}