getVectorNearestIntesection

TheGame/TheGame.pro

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

TheGame/gamecube.cpp

+#include "gamecube.h"
+
+GameCube::GameCube(QObject *parent)
+    : UGEEntityCube(parent)
+{
+    _size = 1;
+}

TheGame/gamecube.h

+#ifndef GAMECUBE_H
+#define GAMECUBE_H
+
+#include "entities/ugeentitycube.h"
+
+class GameCube : public UGEEntityCube
+{
+public:
+    GameCube(QObject *parent = 0);
+
+public slots:
+};
+
+#endif // GAMECUBE_H

TheGame/openglrenderdevice.cpp

      return Vector3D(gx, gy, gz);
 }
 
-Vector3D OpenGLRenderDevice::get3DFrom2D(int x, int y)
+Vector3D OpenGLRenderDevice::get3DFrom2D(const Vector2D &pos)
 {
     double gx, gy, gz;
     double modelMatrix[16];
     glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
     glGetIntegerv(GL_VIEWPORT, viewport);
 
-    gluUnProject(x, y, 1, modelMatrix, projMatrix, viewport, &gx, &gy, &gz);
+    gluUnProject(pos.getX(), pos.getY(), 1, modelMatrix, projMatrix, viewport, &gx, &gy, &gz);
     return Vector3D(gx, gy, gz);
 }
 
 //    glEnable(GL_LIGHT0);
 //    glEnable(GL_LIGHTING);
 
-    glEnable(GL_DEPTH_TEST);
 //    glDisable(GL_BLEND);
 //    glDisable(GL_POLYGON_SMOOTH);
 //    glEnable(GL_TEXTURE_2D);
 {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
+    glEnable(GL_DEPTH_TEST);
 
     gluLookAt(_lookEye.getX(), _lookEye.getY(), _lookEye.getZ(),
                _lookCenter.getX(), _lookCenter.getY(), _lookCenter.getZ(),
 
 void OpenGLRenderDevice::postDraw()
 {
-
+    glDisable(GL_DEPTH_TEST);
 }
 
 void OpenGLRenderDevice::drawVertex(const ColorVector3D &point)

TheGame/openglrenderdevice.h

 
     virtual Vector3D get2DFrom3D(const Vector3D& pos);
 
-    virtual Vector3D get3DFrom2D(int x, int y);
+    virtual Vector3D get3DFrom2D(const Vector2D& pos);
 
 signals:
 

TheGame/renderwidget.cpp

 #include "entities/ugeentitywavefrontobj.h"
 #include "cameras/rotationcamera.h"
 #include "cameras/freeflycamera.h"
+#include "gamecube.h"
 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
 {
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);
+    setAutoFillBackground(false);
+    setAutoBufferSwap(false);
 
     _engine = new UGameEngine(new OpenGLRenderDevice(this));
     _camera = new FreeFlyCamera(_engine, this);
     _engine->addEntity(new UGEEntityAxes(_engine));
 
     for (int i = 0; i < 1000; ++i) {
-        UGEEntityCube* cube = new UGEEntityCube(_engine);
+        UGEEntityCube* cube = new GameCube(_engine);
         cube->setTextureId("test");
-        cube->rotate(Vector3D(0.0, 45.0, 45.0));
+//        cube->rotate(Vector3D(0.0, 45.0, 45.0));
         cube->move(Vector3D(0, i, i));
 //        cube->setScale(Vector3D(1.0, 2.0, 1.0));
         _engine->addEntity(cube);
 {
     _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));
 }
 
 void RenderWidget::resizeGL(int width, int height)
 void RenderWidget::mousePressEvent(QMouseEvent *event)
 {
     _camera->mousePressEvent(event);
+    if (event->buttons() & Qt::LeftButton) {
+        Vector3D pos = _engine->get3DFrom2D(Vector2D(event->x(), height() - event->y()));
+        qDebug() << pos.getX() << pos.getY() << pos.getZ();
+    }
 }
 
 void RenderWidget::mouseReleaseEvent(QMouseEvent *event)
     _camera->keyReleaseEvent(event);
 }
 
+void RenderWidget::paintEvent(QPaintEvent *event)
+{
+    QGLWidget::paintEvent(event);
+    int r = 20;
+    QPainter p;
+    p.begin(this);
+    QPoint c(width() / 2, height() / 2);
+    p.drawLine(c.x() - r, c.y(), c.x() + r, c.y());
+    p.drawLine(c.x(), c.y() - r, c.x(), c.y() + r);
+    p.end();
+    swapBuffers();
+}
+
 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();
 }

TheGame/renderwidget.h

     void keyPressEvent(QKeyEvent* event);
     void keyReleaseEvent(QKeyEvent* event);
 
+    void paintEvent(QPaintEvent* event);
+
 signals:
 
 public slots:

UGameEngine/engine/abstractrenderdevice.h

 
     virtual Vector3D get2DFrom3D(const Vector3D& pos) = 0;
 
-    virtual Vector3D get3DFrom2D(int x, int y) = 0;
+    virtual Vector3D get3DFrom2D(const Vector2D& pos) = 0;
 
 public slots:
     virtual void setClearColor(const QColor &clearColor);

UGameEngine/engine/ugameengine.cpp

         }
     }
     int draw = time.elapsed();
-    qDebug() << update << draw << (update + draw);
+//    qDebug() << update << draw << (update + draw);
 
     _device->postDraw();
 }
     return _entitites[i];
 }
 
+Vector3D UGameEngine::get2DFrom3D(const Vector3D &pos)
+{
+    return _device->get2DFrom3D(pos);
+}
+
+Vector3D UGameEngine::get3DFrom2D(const Vector2D &pos)
+{
+    return _device->get3DFrom2D(pos);
+}
+
+UGEEntity *UGameEngine::getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos)
+{
+    Vector3D nearestPoint;
+    UGEEntity* entity = 0;
+}
+
 void UGameEngine::addEntity(UGEEntity *entity)
 {
     _entitites.append(entity);

UGameEngine/engine/ugameengine.h

     UGameEngine(AbstractRenderDevice* device);
     virtual ~UGameEngine();
 
-    void update();
-
     void draw();
 
     const QList<UGEEntity*>& getEntities() const;
 
     UGEEntity *getEntity(int i) const;
 
+    Vector3D get2DFrom3D(const Vector3D& pos);
+
+    Vector3D get3DFrom2D(const Vector2D &pos);
+
+    UGEEntity* getVectorNearestIntesection(const Vector3D& vector, const Vector3D &pos);
+
 public slots:
     void addEntity(UGEEntity* entity);
 
     void loadTextureFromFile(const QVariant& id, const QString& filename);
 
 protected:
+    void update();
+
     QList<UGEEntity*> _entitites;
 
     AbstractRenderDevice* _device;

UGameEngine/entities/ugeentity.h

 
     virtual void onDraw(AbstractRenderDevice* device) = 0;
 
+    virtual Vector3D getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos, bool* ok) = 0;
+
     void update();
 
     virtual void onUpdate();
     void colorChanged();
     void colorChanged(QColor color);
 
-private:
+protected:
     Vector3D _position;
 
 //    Vector3D _speed;

UGameEngine/entities/ugeentityaxes.cpp

     drawLine(device, ColorVector3D(Qt::green, 0.0, 0.0, 0.0), ColorVector3D(Qt::green, 0.0, 1.0, 0.0), 2.5);
     drawLine(device, ColorVector3D(Qt::blue, 0.0, 0.0, 0.0), ColorVector3D(Qt::blue, 0.0, 0.0, 1.0), 2.5);
 }
+
+Vector3D UGEEntityAxes::getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos, bool *ok)
+{
+    *ok = false;
+    return Vector3D();
+}

UGameEngine/entities/ugeentityaxes.h

 
     virtual void onDraw(AbstractRenderDevice* device);
 
+    virtual Vector3D getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos, bool* ok);
+
 signals:
 
 public slots:

UGameEngine/entities/ugeentitycube.cpp

         }
     }
 }
+
+Vector3D UGEEntityCube::getVectorNearestIntesection(const Vector3D &vector, const Vector3D &origin, bool *ok)
+{
+    *ok = false;
+    return Vector3D();
+//    Vector3D inv(1.0 / vector.getX(), 1.0 / vector.getY(), 1.0 / vector.getZ());
+//    float tmin, tmax, tymin, tymax, tzmin, tzmax;
+
+//    tmin = (parameters[r.sign[0]].x() - origin.getX()) * inv.getX();
+//    tmax = (parameters[1-r.sign[0]].x() - origin.getX()) * inv.getX();
+//    tymin = (parameters[r.sign[1]].y() - origin.getY()) * inv.getY();
+//    tymax = (parameters[1-r.sign[1]].y() - origin.getY()) * inv.getY();
+//    if ( (tmin > tymax) || (tymin > tmax) ) {
+//        *ok = false;
+//        return Vector3D();
+//    }
+//    if (tymin > tmin)
+//    tmin = tymin;
+//    if (tymax < tmax)
+//    tmax = tymax;
+//    tzmin = (parameters[r.sign[2]].z() - r.origin.z()) * r.inv_direction.z();
+//    tzmax = (parameters[1-r.sign[2]].z() - r.origin.z()) * r.inv_direction.z();
+//    if ( (tmin > tzmax) || (tzmin > tmax) ) {
+//        *ok = false;
+//        return Vector3D();
+//    }
+//    *ok = true;
+//    return _position;
+
+//    if (tzmin > tmin)
+//    tmin = tzmin;
+//    if (tzmax < tmax)
+//    tmax = tzmax;
+//    if ((tmin < t1) && (tmax > t0)) {
+//        *ok = true;
+//        return _position;
+//    }
+//    *ok = false;
+//    return Vector3D();
+}

UGameEngine/entities/ugeentitycube.h

     virtual void onDraw(AbstractRenderDevice* device);
     void onUpdate();
 
+    virtual Vector3D getVectorNearestIntesection(const Vector3D &vector, const Vector3D &origin, bool* ok);
+
 signals:
     void sizeChanged();
     void sizeChanged(double);
 
     void setTextureId(const QVariant &textureId);
 
-private:
+protected:
     double _size;
 
     QVariant _textureId;

UGameEngine/entities/ugeentitywavefrontobj.cpp

         drawPolygon(device, poly);
     }
 }
+
+Vector3D UGEEntityWaveFrontObj::getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos, bool *ok)
+{
+    *ok = false;
+    return Vector3D();
+}

UGameEngine/entities/ugeentitywavefrontobj.h

 
     virtual void onDraw(AbstractRenderDevice* device);
 
+    virtual Vector3D getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos, bool *ok);
+
 signals:
 
 public slots: