added gluunproject/gluproject in render device

TheGame/openglrenderdevice.cpp

 #include "GL/gl.h"
 #include "GL/glu.h"
 
-OpenGLRenderDevice::OpenGLRenderDevice(QObject *parent) :
-    AbstractRenderDevice(parent)
+OpenGLRenderDevice::OpenGLRenderDevice(QObject *parent)
+    : AbstractRenderDevice(parent)
+    , _width(0)
+    , _height(0)
+    , _fov(0)
 {
 }
 
+Vector3D OpenGLRenderDevice::get2DFrom3D(const Vector3D &pos)
+{
+    double gx, gy, gz;
+    double modelMatrix[16];
+    double projMatrix[16];
+    GLint viewport[4];
+    glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
+    glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
+    glGetIntegerv(GL_VIEWPORT, viewport);
+
+     gluProject(pos.getX(), pos.getY(), pos.getZ(), modelMatrix, projMatrix, viewport, &gx, &gy, &gz);
+     return Vector3D(gx, gy, gz);
+}
+
+Vector3D OpenGLRenderDevice::get3DFrom2D(int x, int y)
+{
+    double gx, gy, gz;
+    double modelMatrix[16];
+    double projMatrix[16];
+    GLint viewport[4];
+    glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
+    glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
+    glGetIntegerv(GL_VIEWPORT, viewport);
+
+    gluUnProject(x, y, 1, modelMatrix, projMatrix, viewport, &gx, &gy, &gz);
+    return Vector3D(gx, gy, gz);
+}
+
 void OpenGLRenderDevice::initialize(int fov, int width, int height)
 {
+    _fov = fov;
+    _width = width;
+    _height = height;
     glClearColor(_clearColor.redF(), _clearColor.greenF(),
                  _clearColor.blue(), _clearColor.alpha());
 
     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::resize(int width, int height)
 {
-    int side = qMin(width, height);
-    glViewport((width - side) / 2, (height - side) / 2, side, side);
+    _width = width;
+    _height = height;
+    int side = qMin(_width, _height);
+    glViewport((_width - side) / 2, (_height - side) / 2, side, side);
 }
 
 void OpenGLRenderDevice::preDraw()

TheGame/openglrenderdevice.h

 public:
     explicit OpenGLRenderDevice(QObject *parent = 0);
 
+    virtual Vector3D get2DFrom3D(const Vector3D& pos);
+
+    virtual Vector3D get3DFrom2D(int x, int y);
+
 signals:
 
 public slots:
 
     virtual void drawPolygon(const QList<ColorVector3D>& points);
 
+private:
+    int _width;
+
+    int _height;
+
+    int _fov;
+
 };
 
 #endif // OPENGLRENDERDEVICE_H

TheGame/renderwidget.cpp

 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
-  , angle(0)
   , _radius(5.0)
   , _phi(45)
   , _theta(45)
-  , _reverse(false)
 {
     _device = new OpenGLRenderDevice(this);
     _engine = new UGameEngine(_device);
                 );
     _device->lookAt(center, Vector3D(0.0f, 0.0f, 0.0f));
     _engine->draw();
-//    _device->drawLine(ColorVector3D(Qt::black, 0, 0, 0), ColorVector3D(Qt::black, wx, wy, wz));
+    _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)
 
         _lastPoint = event->pos();
     }
-//    double modelMatrix[16];
-//    double projMatrix[16];
-//    GLint viewport[4];
-//    glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
-//    glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
-//    glGetIntegerv(GL_VIEWPORT, viewport);
 
-//    gluUnProject(event->x(), height() - event->y(), 0, modelMatrix, projMatrix, viewport, &wx, &wy, &wz);
-//    qDebug() << event->pos() << wx << wy << wz;
-//    update();
+    Vector3D dd = _device->get2DFrom3D(Vector3D(0.5, 0.5, 0.5));
+    dd.setY(height() - dd.getY());
+    qDebug() << event->pos() << dd;
+    pos = _device->get3DFrom2D(event->x(), height() - event->y());
+
+    update();
 }
 
 void RenderWidget::wheelEvent(QWheelEvent *event)
 {
-    _radius = qMax(2.0, _radius - event->delta() / 20.0);
+    _radius = qMax(2.0, _radius - event->delta() / 30.0);
     update();
 }
 

TheGame/renderwidget.h

 public slots:
 
 private:
-    OpenGLRenderDevice* _device;
-
-    int angle;
+    AbstractRenderDevice* _device;
 
     UGameEngine* _engine;
 
 
     float _theta;
 
-    bool _reverse;
-
-//    double wx,wy,wz;
+    Vector3D pos;
 };
 
 #endif // RENDERWIDGET_H

UGameEngine/engine/abstractrenderdevice.h

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