Engine; opengl render

TheGame/TheGame.pro

 
 SOURCES += main.cpp\
         mainwindow.cpp \
-    renderwidget.cpp
+    renderwidget.cpp \
+    openglrenderdevice.cpp
 
 HEADERS  += mainwindow.h \
-    renderwidget.h
+    renderwidget.h \
+    openglrenderdevice.h
 
 FORMS    += mainwindow.ui
 

TheGame/openglrenderdevice.cpp

+#include "openglrenderdevice.h"
+#include "GL/gl.h"
+#include "GL/glu.h"
+
+OpenGLRenderDevice::OpenGLRenderDevice(QObject *parent) :
+    AbstractRenderDevice(parent)
+{
+}
+
+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);
+
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+    glShadeModel(GL_SMOOTH);
+    glEnable(GL_MULTISAMPLE);
+
+    glMatrixMode(GL_PROJECTION);
+    gluPerspective(fov, width/height, 0.1, 100.0);
+    glMatrixMode(GL_MODELVIEW);
+}
+
+void OpenGLRenderDevice::resize(int width, int height)
+{
+    int side = qMin(width, height);
+    glViewport((width - side) / 2, (height - side) / 2, side, side);
+}
+
+void OpenGLRenderDevice::preDraw()
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glLoadIdentity();
+
+    gluLookAt(_lookEye.getX(), _lookEye.getY(), _lookEye.getZ(),
+               _lookCenter.getX(), _lookCenter.getY(), _lookCenter.getZ(),
+               _lookUp.getX(), _lookUp.getY(), _lookUp.getZ());
+}
+
+void OpenGLRenderDevice::postDraw()
+{
+
+}

TheGame/openglrenderdevice.h

+#ifndef OPENGLRENDERDEVICE_H
+#define OPENGLRENDERDEVICE_H
+
+#include "abstractrenderdevice.h"
+
+class OpenGLRenderDevice : public AbstractRenderDevice
+{
+    Q_OBJECT
+public:
+    explicit OpenGLRenderDevice(QObject *parent = 0);
+
+signals:
+
+public slots:
+
+    virtual void initialize(int fov, int width, int height);
+
+    virtual void resize(int width, int height);
+
+    virtual void preDraw();
+
+    virtual void postDraw();
+
+};
+
+#endif // OPENGLRENDERDEVICE_H

TheGame/renderwidget.cpp

 #include "renderwidget.h"
-#include <GL/glu.h>
 #include <QTimer>
 #include <math.h>
 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
   , angle(0)
-  , _fov(70)
 {
+    _device = new OpenGLRenderDevice(this);
+    _engine = new UGameEngine(_device);
 }
 
 void RenderWidget::initializeGL()
 {
     makeCurrent();
-    qglClearColor(Qt::gray);
+    _device->setClearColor(Qt::gray);
+    _device->initialize(70, width(), height());
 
-    glEnable(GL_DEPTH_TEST);
-    glEnable(GL_CULL_FACE);
-    glShadeModel(GL_SMOOTH);
-    glEnable(GL_MULTISAMPLE);
-
-    glMatrixMode(GL_PROJECTION);
-    gluPerspective(_fov, width()/height(), 0.1, 100.0);
-    glMatrixMode(GL_MODELVIEW);
     animate();
 }
 
 void RenderWidget::paintGL()
 {
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glLoadIdentity();
-
     float rad = (float)angle / 180.0 * M_PI;
     float radius = 5.0f;
+    _device->lookAt(Vector3D(radius * cos(rad), 5.0f, radius * sin(rad)),
+                   Vector3D(0.0f, 0.0f, 0.0f));
+    _engine->draw();
+//    device->preDraw();
+
+
+
 
-    gluLookAt(radius * cos(rad), 5.0f, radius * sin(rad),
-               0.0f, 0.0f, 0.0f,
-               0.0f, 1.0f, 0.0f);
 
     drawAxes();
+
+//    device->postDraw();
 }
 
 void RenderWidget::resizeGL(int width, int height)
 {
-    int side = qMin(width, height);
-    glViewport((width - side) / 2, (height - side) / 2, side, side);
+    _device->resize(width, height);
 }
 
 void RenderWidget::animate()

TheGame/renderwidget.h

 
 #include <QGLWidget>
 #include "ugameengine.h"
+#include "openglrenderdevice.h"
 
 class RenderWidget : public QGLWidget
 {
     void drawAxes();
 
 private:
-    int angle;
+    OpenGLRenderDevice* _device;
 
-    float _fov;
+    int angle;
 
-    QSharedPointer<UGameEngine> _engine;
+    UGameEngine* _engine;
 
 };
 

UGameEngine/UGameEngine.pro

 #
 #-------------------------------------------------
 
-QT       -= gui
+QT       += gui core
 
 TARGET = UGameEngine
 TEMPLATE = lib
 
 SOURCES += ugameengine.cpp \
     ugeentity.cpp \
-    vector3d.cpp
+    vector3d.cpp \
+    abstractrenderdevice.cpp
 
 HEADERS += ugameengine.h\
-        ugameengine_global.h \
     ugeentity.h \
-    vector3d.h
+    vector3d.h \
+    abstractrenderdevice.h
 
 unix {
     target.path = /usr/lib

UGameEngine/abstractrenderdevice.cpp

+#include "abstractrenderdevice.h"
+
+AbstractRenderDevice::AbstractRenderDevice(QObject *parent) :
+    QObject(parent)
+{
+}
+
+AbstractRenderDevice::~AbstractRenderDevice()
+{
+
+}
+
+QColor AbstractRenderDevice::getCurrentColor() const
+{
+    return _currentColor;
+}
+
+Vector3D AbstractRenderDevice::getLookEye() const
+{
+    return _lookEye;
+}
+
+Vector3D AbstractRenderDevice::getLookCenter() const
+{
+    return _lookCenter;
+}
+
+Vector3D AbstractRenderDevice::getLookUp() const
+{
+    return _lookUp;
+}
+
+void AbstractRenderDevice::setCurrentColor(const QColor &color)
+{
+    _currentColor = color;
+}
+
+void AbstractRenderDevice::lookAt(const Vector3D &eye, const Vector3D &center, const Vector3D &up)
+{
+    _lookEye = eye;
+    _lookCenter = center;
+    _lookUp = up;
+}
+
+QColor AbstractRenderDevice::getClearColor() const
+{
+    return _clearColor;
+}
+
+void AbstractRenderDevice::setClearColor(const QColor &clearColor)
+{
+    _clearColor = clearColor;
+}
+
+

UGameEngine/abstractrenderdevice.h

+#ifndef ABSTRACTRENDERDEVICE_H
+#define ABSTRACTRENDERDEVICE_H
+
+#include <QObject>
+#include <QColor>
+#include "vector3d.h"
+
+class AbstractRenderDevice : public QObject
+{
+    Q_OBJECT
+public:
+    explicit AbstractRenderDevice(QObject *parent = 0);
+
+    virtual ~AbstractRenderDevice();
+
+    QColor getCurrentColor() const;
+
+    Vector3D getLookEye() const;
+
+    Vector3D getLookCenter() const;
+
+    Vector3D getLookUp() const;
+
+    QColor getClearColor() const;
+
+public slots:
+    virtual void setClearColor(const QColor &getClearColor);
+
+    virtual void setCurrentColor(const QColor &color);
+
+    virtual void lookAt(const Vector3D& eye, const Vector3D& center, const Vector3D& up = Vector3D(0.0, 1.0, 0.0));
+
+    virtual void initialize(int fov, int width, int height) = 0;
+
+    virtual void resize(int width, int height) = 0;
+
+    virtual void preDraw() = 0;
+
+    virtual void postDraw() = 0;
+
+protected:
+    QColor _clearColor;
+
+    QColor _currentColor;
+
+    Vector3D _lookEye;
+
+    Vector3D _lookCenter;
+
+    Vector3D _lookUp;
+};
+
+#endif // ABSTRACTRENDERDEVICE_H

UGameEngine/ugameengine.cpp

 #include "ugameengine.h"
 
 
-UGameEngine::UGameEngine()
+UGameEngine::UGameEngine(AbstractRenderDevice* device)
+    : _device(device)
 {
 }
+
+void UGameEngine::draw()
+{
+    _device->preDraw();
+
+    for(int i = 0; i < _entitites.size(); ++i) {
+        UGEEntity* entity = _entitites[i];
+        entity->draw(_device);
+    }
+
+    _device->postDraw();
+}

UGameEngine/ugameengine.h

 #ifndef UGAMEENGINE_H
 #define UGAMEENGINE_H
 
-#include "ugameengine_global.h"
+#include "abstractrenderdevice.h"
+#include "ugeentity.h"
 
-class UGAMEENGINESHARED_EXPORT UGameEngine
+class UGameEngine : public QObject
 {
-
+    Q_OBJECT
 public:
-    UGameEngine();
+    UGameEngine(AbstractRenderDevice* device);
+
+    void draw();
+
+protected:
+    QList<UGEEntity*> _entitites;
+
+    AbstractRenderDevice* _device;
 };
 
 #endif // UGAMEENGINE_H

UGameEngine/ugameengine_global.h

-#ifndef UGAMEENGINE_GLOBAL_H
-#define UGAMEENGINE_GLOBAL_H
-
-#include <QtCore/qglobal.h>
-
-#if defined(UGAMEENGINE_LIBRARY)
-#  define UGAMEENGINESHARED_EXPORT Q_DECL_EXPORT
-#else
-#  define UGAMEENGINESHARED_EXPORT Q_DECL_IMPORT
-#endif
-
-#endif // UGAMEENGINE_GLOBAL_H

UGameEngine/ugeentity.cpp

     QObject(parent)
 {
 }
+
+Vector3D UGEEntity::getPosition() const
+{
+    return _position;
+}
+
+void UGEEntity::setPosition(const Vector3D &position)
+{
+    _position = position;
+}
+
+void UGEEntity::move(const Vector3D &move)
+{
+    _position += move;
+}
+
+Vector3D UGEEntity::getSpeed() const
+{
+    return _speed;
+}
+
+void UGEEntity::setSpeed(const Vector3D &speed)
+{
+    _speed = speed;
+}
+
+void UGEEntity::accelerate(const Vector3D &speed)
+{
+    _speed += speed;
+}
+
+Vector3D UGEEntity::getRotation() const
+{
+    return _rotation;
+}
+
+void UGEEntity::setRotation(const Vector3D &rotation)
+{
+    _rotation = rotation;
+}
+
+void UGEEntity::rotate(const Vector3D &rotation)
+{
+    _rotation += rotation;
+}
+
+Vector3D UGEEntity::getScale() const
+{
+    return _scale;
+}
+
+void UGEEntity::setScale(const Vector3D &scale)
+{
+    _scale = scale;
+}
+
+void UGEEntity::scale(const Vector3D &scale)
+{
+    _scale += scale;
+}

UGameEngine/ugeentity.h

 
 #include <QObject>
 #include <QPoint>
+#include <QSharedPointer>
 #include "vector3d.h"
+#include "abstractrenderdevice.h"
 
 class UGEEntity : public QObject
 {
 public:
     explicit UGEEntity(QObject *parent = 0);
 
-signals:
+    Vector3D getPosition() const;
+    void setPosition(const Vector3D& position);
+    void move(const Vector3D& move);
 
-public slots:
+    Vector3D getSpeed() const;
+    void setSpeed(const Vector3D& speed);
+    void accelerate(const Vector3D& speed);
+
+    Vector3D getRotation() const;
+    void setRotation(const Vector3D& rotation);
+    void rotate(const Vector3D& rotation);
+
+    Vector3D getScale() const;
+    void setScale(const Vector3D& scale);
+    void scale(const Vector3D& scale);
+
+    virtual void draw(AbstractRenderDevice* device) = 0;
 
 private:
     Vector3D _position;
 
+    Vector3D _speed;
+
+    Vector3D _rotation;
+
+    Vector3D _scale;
+
 };
 
 #endif // UGEENTITY_H

UGameEngine/vector3d.cpp

     return Vector3D(*this).add(k);
 }
 
-Vector3D Vector3D::operator+(const Vector3D &v2)
+Vector3D &Vector3D::operator+=(const double &k)
 {
-    return Vector3D(*this).add(v2);
+    return add(k);
+}
+
+Vector3D Vector3D::operator+(const Vector3D &other)
+{
+    return Vector3D(*this).add(other);
+}
+
+Vector3D &Vector3D::operator+=(const Vector3D &other)
+{
+    return add(other);
 }
 
 Vector3D Vector3D::operator-()
     return Vector3D(*this).sub(k);
 }
 
-Vector3D Vector3D::operator-(const Vector3D &v2)
+Vector3D &Vector3D::operator-=(const double &k)
+{
+    return sub(k);
+}
+
+Vector3D Vector3D::operator-(const Vector3D &other)
+{
+    return Vector3D(*this).sub(other);
+}
+
+Vector3D &Vector3D::operator-=(const Vector3D &other)
 {
-    return Vector3D(*this).sub(v2);
+    return sub(other);
 }
 
 Vector3D Vector3D::operator*(const double &k)
     return Vector3D(*this).mult(k);
 }
 
-double Vector3D::operator*(const Vector3D &v2)
+Vector3D &Vector3D::operator*=(const double &k)
+{
+    return mult(k);
+}
+
+double Vector3D::operator*(const Vector3D &other)
 {
-    return Vector3D(*this).dotProduct(v2);
+    return Vector3D(*this).dotProduct(other);
+}
+
+Vector3D &Vector3D::operator*=(const Vector3D &other)
+{
+    dotProduct(other);
+    return *this;
 }
 
 Vector3D Vector3D::operator/(const double &k)
     return Vector3D(*this).div(k);
 }
 
+Vector3D &Vector3D::operator/=(const double &k)
+{
+    return div(k);
+}
+
 bool Vector3D::operator==(const Vector3D &other)
 {
     return equal(other);

UGameEngine/vector3d.h

 
     Vector3D operator+();
     Vector3D operator+(const double& k);
-    Vector3D operator+(const Vector3D& v2);
+    Vector3D& operator+=(const double& k);
+    Vector3D operator+(const Vector3D& other);
+    Vector3D& operator+=(const Vector3D& other);
 
     Vector3D operator-();
     Vector3D operator-(const double& k);
-    Vector3D operator-(const Vector3D& v2);
+    Vector3D& operator-=(const double& k);
+    Vector3D operator-(const Vector3D& other);
+    Vector3D& operator-=(const Vector3D& other);
 
     Vector3D operator*(const double& k);
-    double operator*(const Vector3D& v2);
+    Vector3D& operator*=(const double& k);
+    double operator*(const Vector3D& other);
+    Vector3D& operator*=(const Vector3D& other);
 
     Vector3D operator/(const double& k);
+    Vector3D& operator/=(const double& k);
 
     bool operator==(const Vector3D& other);
     bool operator!=(const Vector3D& other);