optimized draw: time/2; multithread entities update

TheGame/openglrenderdevice.cpp

 void OpenGLRenderDevice::drawPolygon(const QList<ColorVector3D> &points)
 {
     glBegin(GL_POLYGON);
-    Vector3D p1 = points[0];
+//    Vector3D p1 = points[0];
 //    Vector3D p2 = points[1];
 //    Vector3D n = p1.crossProduct(p2);
 //    Vector3D n2 = p2.crossProduct(p1);
     glBindTexture(GL_TEXTURE_2D, data.id);
     glBegin(GL_POLYGON);
     for (int i = 0; i < points.size(); ++i) {
-        TextureVector3D p = points[i];
-        glTexCoord2d(p.getTextureCoord().getX(), p.getTextureCoord().getY());
+        const TextureVector3D& p = points[i];
+        const Vector2D& coord = p.getTextureCoord();
+        glTexCoord2d(coord.getX(), coord.getY());
         drawVertex(p);
     }
     glEnd();

TheGame/renderwidget.cpp

 
     _engine->addEntity(new UGEEntityAxes(_engine));
 
-    for (int i = 0; i < 100; ++i) {
+    for (int i = 0; i < 1000; ++i) {
         UGEEntityCube* cube = new UGEEntityCube(_engine);
         cube->setTextureId("test");
         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->setScale(Vector3D(1.0, 2.0, 1.0));
         _engine->addEntity(cube);
         _entities.append(cube);
     }
 
 void RenderWidget::animate()
 {
-//    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();
 }

UGameEngine/UGameEngine.pro

     utils/tools.cpp \
     cameras/abstractcamera.cpp \
     cameras/rotationcamera.cpp \
-    cameras/freeflycamera.cpp
+    cameras/freeflycamera.cpp \
+    engine/entitiesupdatethread.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
     cameras/rotationcamera.h \
     cameras/freeflycamera.h \
     utils/matrixdebug.h \
-    utils/matrixdebug.hxx
+    utils/matrixdebug.hxx \
+    engine/entitiesupdatethread.h
 
 
 # FLEX && BISON

UGameEngine/engine/entitiesupdatethread.cpp

+#include "entitiesupdatethread.h"
+#include "entities/ugeentity.h"
+
+EntitiesUpdateThread::EntitiesUpdateThread(UGameEngine *parent)
+    : QThread(parent)
+    , _engine(parent)
+{
+}
+
+void EntitiesUpdateThread::update(int begin, int end)
+{
+    _begin = begin;
+    _end = end;
+    start();
+}
+
+void EntitiesUpdateThread::run()
+{
+    for (int i = _begin; i < _end; ++i) {
+        UGEEntity* entity = _engine->getEntity(i);
+        if (entity->isVisible()) {
+            entity->update();
+        }
+    }
+}

UGameEngine/engine/entitiesupdatethread.h

+#ifndef ENTITIESUPDATETHREAD_H
+#define ENTITIESUPDATETHREAD_H
+
+#include <QThread>
+#include "ugameengine.h"
+
+class UGameEngine;
+
+class EntitiesUpdateThread : public QThread
+{
+    Q_OBJECT
+public:
+    explicit EntitiesUpdateThread(UGameEngine *parent = 0);
+
+    void update(int begin, int end);
+
+protected:
+    void run();
+
+signals:
+
+public slots:
+
+private:
+    UGameEngine* _engine;
+
+    int _begin;
+
+    int _end;
+
+};
+
+#endif // ENTITIESUPDATETHREAD_H

UGameEngine/engine/ugameengine.cpp

 #include "ugameengine.h"
-
+#include <QTime>
 
 UGameEngine::UGameEngine(AbstractRenderDevice* device)
     : _device(device)
 {
+    for (int i = 0; i < 8; ++i) {
+        _entitiesUpdateThreads.append(new EntitiesUpdateThread(this));
+    }
 }
 
 UGameEngine::~UGameEngine()
 {
 }
 
+void UGameEngine::update()
+{
+    int entitiesCount = _entitites.size();
+    if (entitiesCount > 1000) {
+        int threads = _entitiesUpdateThreads.size();
+        for (int t = 0; t < threads; ++t) {
+            EntitiesUpdateThread* thread = _entitiesUpdateThreads[t];
+            int begin = (entitiesCount / threads) * t;
+            int end = (entitiesCount / threads) * (t + 1);
+            if (t == threads - 1) {
+                end = entitiesCount;
+            }
+            thread->update(begin, end);
+        }
+        for (int t = 0; t < threads; ++t) {
+            EntitiesUpdateThread* thread = _entitiesUpdateThreads[t];
+            thread->wait();
+        }
+    }
+    else {
+        for(int i = 0; i < _entitites.size(); ++i) {
+            UGEEntity* entity = _entitites[i];
+            if (entity->isVisible()) {
+                entity->update();
+            }
+        }
+    }
+}
+
 void UGameEngine::draw()
 {
     _device->preDraw();
 
+    QTime time;
+    time.start();
+    update();
+    int update = time.elapsed();
+    time.restart();
+
     for(int i = 0; i < _entitites.size(); ++i) {
         UGEEntity* entity = _entitites[i];
         if (entity->isVisible()) {
             entity->draw(_device);
         }
     }
+    int draw = time.elapsed();
+    qDebug() << update << draw << (update + draw);
 
     _device->postDraw();
 }
 
+const QList<UGEEntity *> &UGameEngine::getEntities() const
+{
+    return _entitites;
+}
+
+UGEEntity *UGameEngine::getEntity(int i) const
+{
+    return _entitites[i];
+}
+
 void UGameEngine::addEntity(UGEEntity *entity)
 {
     _entitites.append(entity);

UGameEngine/engine/ugameengine.h

 
 #include "abstractrenderdevice.h"
 #include "entities/ugeentity.h"
+#include "entitiesupdatethread.h"
+
+class EntitiesUpdateThread;
 
 class UGameEngine : public QObject
 {
     UGameEngine(AbstractRenderDevice* device);
     virtual ~UGameEngine();
 
+    void update();
+
     void draw();
 
+    const QList<UGEEntity*>& getEntities() const;
+
+    UGEEntity *getEntity(int i) const;
+
 public slots:
     void addEntity(UGEEntity* entity);
 
     QList<UGEEntity*> _entitites;
 
     AbstractRenderDevice* _device;
+
+    QList<EntitiesUpdateThread*> _entitiesUpdateThreads;
 };
 
 #endif // UGAMEENGINE_H

UGameEngine/entities/ugeentity.cpp

     : QObject(parent)
     , _scale(1.0, 1.0, 1.0)
     , _visible(true)
+    , _needUpdate(true)
 {
+    connect(this, SIGNAL(positionChanged()), this, SLOT(needUpdate()));
+    connect(this, SIGNAL(rotationChanged()), this, SLOT(needUpdate()));
+    connect(this, SIGNAL(scaleChanged()), this, SLOT(needUpdate()));
+    connect(this, SIGNAL(colorChanged()), this, SLOT(needUpdate()));
 }
 
 UGEEntity::~UGEEntity()
     emit visibilityChanged(_visible);
 }
 
-QColor UGEEntity::getColor() const
+const QColor& UGEEntity::getColor() const
 {
     return _color;
 }
 
 Vector3D UGEEntity::getRealPoint(const Vector3D &pos)
 {
-    Matrix3x3 trans = getTransformationMatrix();
-    return (trans.multMatrix(pos) + _position);
+    return (_tranformation.multMatrix(pos) + _position);
 }
 
 ColorVector3D UGEEntity::getRealPoint(const ColorVector3D &pos)
     }
     device->drawPolygonTexture(points, textureId);
 }
+
+void UGEEntity::draw(AbstractRenderDevice *device)
+{
+    onDraw(device);
+}
+
+void UGEEntity::update()
+{
+    if (_needUpdate) {
+        _tranformation = getTransformationMatrix();
+        onUpdate();
+        _needUpdate = false;
+    }
+}
+
+void UGEEntity::onUpdate()
+{
+
+}
+
+void UGEEntity::needUpdate()
+{
+    _needUpdate = true;
+}

UGameEngine/entities/ugeentity.h

     void show();
     void hide();
 
-    QColor getColor() const;
+    const QColor &getColor() const;
     void setColor(const QColor &color);
 
     Vector3D getRealPoint(const Vector3D& pos);
     Matrix3x3 getScaleMatrix() const;
     Matrix3x3 getRotationMatrix() const;
 
-    virtual void drawPoint(AbstractRenderDevice* device, const ColorVector3D& point);
+    void drawPoint(AbstractRenderDevice* device, const ColorVector3D& point);
 
-    virtual void drawLine(AbstractRenderDevice* device, const ColorVector3D& begin, const ColorVector3D& end, double width = 1.0);
+    void drawLine(AbstractRenderDevice* device, const ColorVector3D& begin, const ColorVector3D& end, double width = 1.0);
 
-    virtual void drawPolygon(AbstractRenderDevice* device, QList<ColorVector3D> points);
+    void drawPolygon(AbstractRenderDevice* device, QList<ColorVector3D> points);
 
-    virtual void drawPolygonTexture(AbstractRenderDevice *device, QList<TextureVector3D> points, const QVariant& textureId);
+    void drawPolygonTexture(AbstractRenderDevice *device, QList<TextureVector3D> points, const QVariant& textureId);
 
-    virtual void draw(AbstractRenderDevice* device) = 0;
+    void draw(AbstractRenderDevice* device);
+
+    virtual void onDraw(AbstractRenderDevice* device) = 0;
+
+    void update();
+
+    virtual void onUpdate();
+
+public slots:
+
+    void needUpdate();
 
 signals:
     void positionChanged();
 
     QColor _color;
 
+    bool _needUpdate;
+
+    Matrix3x3 _tranformation;
+
 };
 
 #endif // UGEENTITY_H

UGameEngine/entities/ugeentityaxes.cpp

 {
 }
 
-void UGEEntityAxes::draw(AbstractRenderDevice *device)
+void UGEEntityAxes::onDraw(AbstractRenderDevice *device)
 {
     drawLine(device, ColorVector3D(Qt::red, 0.0, 0.0, 0.0), ColorVector3D(Qt::red, 1.0, 0.0, 0.0), 2.5);
     drawLine(device, ColorVector3D(Qt::green, 0.0, 0.0, 0.0), ColorVector3D(Qt::green, 0.0, 1.0, 0.0), 2.5);

UGameEngine/entities/ugeentityaxes.h

 public:
     explicit UGEEntityAxes(QObject *parent = 0);
 
-    virtual void draw(AbstractRenderDevice* device);
+    virtual void onDraw(AbstractRenderDevice* device);
 
 signals:
 

UGameEngine/entities/ugeentitycube.cpp

     : UGEEntity(parent)
     , _size(1.0)
 {
-    updateFaces();
-    connect(this, SIGNAL(colorChanged()), this, SLOT(updateFaces()));
-    connect(this, SIGNAL(sizeChanged()), this, SLOT(updateFaces()));
-    connect(this, SIGNAL(textureChanged()), this, SLOT(updateFaces()));
+    connect(this, SIGNAL(sizeChanged()), this, SLOT(needUpdate()));
+    connect(this, SIGNAL(textureChanged()), this, SLOT(needUpdate()));
 }
 
 double UGEEntityCube::getSize() const
     return _size;
 }
 
-void UGEEntityCube::draw(AbstractRenderDevice *device)
+void UGEEntityCube::onDraw(AbstractRenderDevice *device)
 {
     if (!_facesColor.empty()) {
         for (int i = 0; i < _facesColor.size(); ++i) {
-            drawPolygon(device, _facesColor[i]);
+//            drawPolygon(device, _facesColor[i]);
+            device->drawPolygon(_facesColor[i]);
         }
     }
     else {
         for (int i = 0; i < _facesTexture.size(); ++i) {
-            drawPolygonTexture(device, _facesTexture[i], _textureId);
+//            drawPolygonTexture(device, _facesTexture[i], _textureId);
+            device->drawPolygonTexture(_facesTexture[i], _textureId);
         }
     }
 }
     emit textureChanged(_textureId);
 }
 
-void UGEEntityCube::updateFaces()
+void UGEEntityCube::onUpdate()
 {
-    _facesColor.clear();
-    _facesTexture.clear();
     double r = _size / 2;
     if (_textureId.isNull()) {
+        _facesColor.clear();
         QList<ColorVector3D> points;
         points << ColorVector3D(getColor(), -r, -r, r)  << ColorVector3D(getColor(), -r, r, r)
                << ColorVector3D(getColor(), r, r, r)    << ColorVector3D(getColor(), r, -r, r)
                << ColorVector3D(getColor(), -r, -r, -r) << ColorVector3D(getColor(), -r, r, -r)
                << ColorVector3D(getColor(), r, r, -r)   << ColorVector3D(getColor(), r, -r, -r);
+        for (int i = 0; i < points.size(); ++i) {
+            points[i] = getRealPoint(points[i]);
+        }
         _facesColor.append(QList<ColorVector3D>() << points[3] << points[2] << points[1] << points[0]);
         _facesColor.append(QList<ColorVector3D>() << points[2] << points[3] << points[7] << points[6]);
         _facesColor.append(QList<ColorVector3D>() << points[6] << points[7] << points[4] << points[5]);
         _facesColor.append(QList<ColorVector3D>() << points[4] << points[7] << points[3] << points[0]);
     }
     else {
+        _facesTexture.clear();
         _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), getColor(), r, -r, r)
                              << TextureVector3D(Vector2D(0.25, 0.25), getColor(), r, r, r)
                              << TextureVector3D(Vector2D(0.00, 0.25), getColor(), -r, r, r)
                              << TextureVector3D(Vector2D(0.50, 0.50), getColor(), r, -r, -r)
                              << TextureVector3D(Vector2D(0.25, 0.5), getColor(), r, -r, r)
                              << TextureVector3D(Vector2D(0.25, 0.75), getColor(), -r, -r, r));
+        for (int i = 0; i < _facesTexture.size(); ++i) {
+            QList<TextureVector3D>& face = _facesTexture[i];
+            for (int j = 0; j < face.size(); ++j) {
+                face[j] = getRealPoint(face[j]);
+            }
+        }
     }
 }

UGameEngine/entities/ugeentitycube.h

 
     QVariant getTextureId() const;
 
-    virtual void draw(AbstractRenderDevice* device);
+    virtual void onDraw(AbstractRenderDevice* device);
+    void onUpdate();
 
 signals:
     void sizeChanged();
 
     void setTextureId(const QVariant &textureId);
 
-private slots:
-    void updateFaces();
-
 private:
     double _size;
 

UGameEngine/entities/ugeentitywavefrontobj.cpp

 {
 }
 
-void UGEEntityWaveFrontObj::draw(AbstractRenderDevice *device)
+void UGEEntityWaveFrontObj::onDraw(AbstractRenderDevice *device)
 {
     QList<QList<WaveFrontObjFaceVertex> > faces = _obj->getFaces();
     QList<Vector3D> vertexes = _obj->getVertexes();

UGameEngine/entities/ugeentitywavefrontobj.h

 public:
     explicit UGEEntityWaveFrontObj(WaveFrontObj* obj, QObject *parent = 0);
 
-    virtual void draw(AbstractRenderDevice* device);
+    virtual void onDraw(AbstractRenderDevice* device);
 
 signals:
 

UGameEngine/utils/texturevector3d.cpp

 {
 }
 
-Vector2D TextureVector3D::getTextureCoord() const
+const Vector2D &TextureVector3D::getTextureCoord() const
 {
     return _textureCoord;
 }

UGameEngine/utils/texturevector3d.h

     TextureVector3D(const TextureVector3D& other);
     virtual ~TextureVector3D();
 
-    Vector2D getTextureCoord() const;
+    const Vector2D& getTextureCoord() const;
     void setTextureCoord(const Vector2D &textureCoord);
 
 private: