opengl draw functions; 3d drag camera

TheGame/openglrenderdevice.cpp

 
 void OpenGLRenderDevice::initialize(int fov, int width, int height)
 {
-    glClearColor((GLfloat)_clearColor.red() / 255.0, (GLfloat)_clearColor.green() / 255.0,
-                      (GLfloat)_clearColor.blue() / 255.0, (GLfloat) _clearColor.alpha() / 255.0);
+    glClearColor(_clearColor.redF(), _clearColor.greenF(),
+                 _clearColor.blue(), _clearColor.alpha());
 
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_CULL_FACE);
     glEnable(GL_MULTISAMPLE);
 
     glMatrixMode(GL_PROJECTION);
-    gluPerspective(fov, width/height, 0.1, 100.0);
+    gluPerspective(fov, width / height, 0.1, 100.0);
     glMatrixMode(GL_MODELVIEW);
 }
 
 {
 
 }
+
+void OpenGLRenderDevice::drawVertex(const ColorVector3D &point)
+{
+    glColor4f(point.getColor().redF(), point.getColor().greenF(),
+                  point.getColor().blue(), point.getColor().alpha());
+    glVertex3d(point.getX(), point.getY(), point.getZ());
+}
+
+void OpenGLRenderDevice::drawPoint(const ColorVector3D &point)
+{
+    glBegin(GL_POINTS);
+    drawVertex(point);
+    glEnd();
+}
+
+void OpenGLRenderDevice::drawLine(const ColorVector3D &begin, const ColorVector3D &end, double width)
+{
+    glLineWidth(width);
+    glBegin(GL_LINES);
+    drawVertex(begin);
+    drawVertex(end);
+    glEnd();
+}
+
+void OpenGLRenderDevice::drawPolygon(const QList<ColorVector3D> &points)
+{
+    glBegin(GL_POLYGON);
+    for (int i = 0; i < points.size(); ++i) {
+        drawVertex(points[i]);
+    }
+    glEnd();
+}

TheGame/openglrenderdevice.h

 public:
     explicit OpenGLRenderDevice(QObject *parent = 0);
 
+//    static float
+
 signals:
 
 public slots:
 
     virtual void postDraw();
 
+    virtual void drawVertex(const ColorVector3D& point);
+
+    virtual void drawPoint(const ColorVector3D& point);
+
+    virtual void drawLine(const ColorVector3D& begin, const ColorVector3D& end, double width = 1.0);
+
+    virtual void drawPolygon(const QList<ColorVector3D>& points);
+
 };
 
 #endif // OPENGLRENDERDEVICE_H

TheGame/renderwidget.cpp

 #include "renderwidget.h"
 #include <QTimer>
 #include <math.h>
+#include <QDebug>
 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
   , angle(0)
+  , _radius(5.0)
+  , _phi(45)
+  , _theta(45)
 {
     _device = new OpenGLRenderDevice(this);
     _engine = new UGameEngine(_device);
+    setMouseTracking(false);
 }
 
 void RenderWidget::initializeGL()
     _device->setClearColor(Qt::gray);
     _device->initialize(70, width(), height());
 
-    animate();
 }
 
 void RenderWidget::paintGL()
 {
-    float rad = (float)angle / 180.0 * M_PI;
-    float radius = 5.0f;
-    _device->lookAt(Vector3D(radius * cos(rad), 5.0f, radius * sin(rad)),
+    float theta = _theta / 180.0 * M_PI;
+    float phi = _phi / 180.0 * M_PI;
+    _device->lookAt(Vector3D(
+                        _radius * sin(theta) * sin(phi),
+                        _radius * cos(theta),
+                        _radius * sin(theta) * cos(phi)
+                        ),
                    Vector3D(0.0f, 0.0f, 0.0f));
     _engine->draw();
 
     _device->resize(width, height);
 }
 
-void RenderWidget::animate()
+void RenderWidget::mousePressEvent(QMouseEvent *event)
 {
-    angle = (angle + 3) % 360;
+    _lastPoint = event->pos();
+}
+
+void RenderWidget::mouseMoveEvent(QMouseEvent *event)
+{
+    QPoint diff = event->pos() - _lastPoint;
+
+    _phi -= diff.x();
+    _theta -= diff.y();
+
+    qDebug() << _phi << _theta;
+
+    _lastPoint = event->pos();
     update();
-    QTimer::singleShot(50, this, SLOT(animate()));
 }
 
-void RenderWidget::drawAxes()
+void RenderWidget::wheelEvent(QWheelEvent *event)
 {
-    glLineWidth(2.5);
+    _radius = qMax(2.0, _radius - event->delta() / 20.0);
+    update();
+}
 
-    glColor3f(1.0, 0.0, 0.0);
-    glBegin(GL_LINES);
-    glVertex3f(0.0, 0.0, 0.0);
-    glVertex3f(1.0, 0.0, 0.0);
-    glEnd();
+void RenderWidget::drawAxes()
+{
+    _device->drawLine(ColorVector3D(Qt::red, 0.0, 0.0, 0.0), ColorVector3D(Qt::red, 1.0, 0.0, 0.0), 2.5);
+    _device->drawLine(ColorVector3D(Qt::green, 0.0, 0.0, 0.0), ColorVector3D(Qt::green, 0.0, 1.0, 0.0), 2.5);
+    _device->drawLine(ColorVector3D(Qt::blue, 0.0, 0.0, 0.0), ColorVector3D(Qt::blue, 0.0, 0.0, 1.0), 2.5);
 
-    glColor3f(0.0, 1.0, 0.0);
-    glBegin(GL_LINES);
-    glVertex3f(0.0, 0.0, 0.0);
-    glVertex3f(0.0, 1.0, 0.0);
-    glEnd();
+    _device->drawPolygon(QList<ColorVector3D>() << ColorVector3D(Qt::red, 0, 0, 0) << ColorVector3D(Qt::green, 1, 0, 0) << ColorVector3D(Qt::transparent, 1, 1, 0) << ColorVector3D(Qt::blue, 0, 1, 0));
 
-    glColor3f(0.0, 0.0, 1.0);
-    glBegin(GL_LINES);
-    glVertex3f(0.0, 0.0, 0.0);
-    glVertex3f(0.0, 0.0, 1.0);
-    glEnd();
 }

TheGame/renderwidget.h

 #define RENDERWIDGET_H
 
 #include <QGLWidget>
+#include <QMouseEvent>
+#include <QWheelEvent>
 #include "ugameengine.h"
 #include "openglrenderdevice.h"
 
     void paintGL();
     void resizeGL(int width, int height);
 
+    void mousePressEvent(QMouseEvent* event);
+    void mouseMoveEvent(QMouseEvent* event);
+    void wheelEvent(QWheelEvent* event);
+
 signals:
 
 public slots:
-    void animate();
-
     void drawAxes();
 
 private:
 
     UGameEngine* _engine;
 
+    QPoint _lastPoint;
+
+    float _radius;
+
+    float _phi;
+
+    float _theta;
+
 };
 
 #endif // RENDERWIDGET_H

UGameEngine/UGameEngine.pro

 SOURCES += ugameengine.cpp \
     ugeentity.cpp \
     vector3d.cpp \
-    abstractrenderdevice.cpp
+    abstractrenderdevice.cpp \
+    colorvector3d.cpp
 
 HEADERS += ugameengine.h\
     ugeentity.h \
     vector3d.h \
-    abstractrenderdevice.h
+    abstractrenderdevice.h \
+    colorvector3d.h
 
 unix {
     target.path = /usr/lib

UGameEngine/abstractrenderdevice.h

 
 #include <QObject>
 #include <QColor>
-#include "vector3d.h"
+#include "colorvector3d.h"
 
 class AbstractRenderDevice : public QObject
 {
 
     virtual void postDraw() = 0;
 
+    virtual void drawPoint(const ColorVector3D& point) = 0;
+
+    virtual void drawLine(const ColorVector3D& begin, const ColorVector3D& end, double width = 1.0) = 0;
+
+    virtual void drawPolygon(const QList<ColorVector3D>& points) = 0;
+
 protected:
     QColor _clearColor;
 

UGameEngine/colorvector3d.cpp

+#include "colorvector3d.h"
+
+ColorVector3D::ColorVector3D(QColor color, double x, double y, double z)
+    : Vector3D(x, y, z)
+    , _color(color)
+{
+}
+
+ColorVector3D::ColorVector3D(QColor color, const Vector3D &other)
+    : Vector3D(other)
+    , _color(color)
+{
+}
+
+ColorVector3D::ColorVector3D(const ColorVector3D &other)
+    : Vector3D(other)
+    , _color(other._color)
+{
+}
+
+QColor ColorVector3D::getColor() const
+{
+    return _color;
+}
+
+void ColorVector3D::setColor(const QColor &color)
+{
+    _color = color;
+}
+

UGameEngine/colorvector3d.h

+#ifndef COLORVECTOR3D_H
+#define COLORVECTOR3D_H
+
+#include <QColor>
+#include "vector3d.h"
+
+class ColorVector3D : public Vector3D
+{
+public:
+    ColorVector3D(QColor color = Qt::black, double x = 0.0, double y = 0.0, double z = 0.0);
+    ColorVector3D(QColor color = Qt::black, const Vector3D& other = Vector3D());
+    ColorVector3D(const ColorVector3D& other);
+
+    QColor getColor() const;
+    void setColor(const QColor &color);
+
+private:
+    QColor _color;
+};
+
+#endif // COLORVECTOR3D_H

UGameEngine/vector3d.cpp

 {
 }
 
+Vector3D::~Vector3D()
+{
+}
+
 double Vector3D::getX() const
 {
     return _x;

UGameEngine/vector3d.h

 public:
     explicit Vector3D(double x = 0.0, double y = 0.0, double z = 0.0);
     Vector3D(const Vector3D& other);
+    virtual ~Vector3D();
 
     double getX() const;
     Vector3D& setX(double x);