CUBE VECTOR COLLISION

TheGame/assets/objs/enterprise/USSEnterprise.mtl

+# Blender MTL File: 'USSEnterprise.blend'
+# Material Count: 1
+
+newmtl Material
+Ns 96.078431
+Ka 0.000000 0.000000 0.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.800000 0.800000 0.800000
+Ni 1.000000
+d 1.000000
+illum 2
+map_Kd /home/robin/Downloads/UV Maps/UV Textur.png
+map_Bump /home/robin/Downloads/UV Maps/NormalMap.png
+map_Ks /home/robin/Downloads/UV Maps/UV Textur.png

TheGame/renderwidget.cpp

     setFocusPolicy(Qt::StrongFocus);
     setAutoFillBackground(false);
     setAutoBufferSwap(false);
+    #ifdef __APPLE__
+    _assetsPath = "../../../assets/";
+    #else
+    _assetsPath = "./assets/";
+    #endif
 
     _engine = new UGameEngine(new OpenGLRenderDevice(this));
     _camera = new FreeFlyCamera(_engine, this);
 
-    _engine->addEntity(new UGEEntityAxes(_engine));
+    //_engine->addEntity(new UGEEntityAxes(_engine));
 
-    for (int i = 0; i < 1000; ++i) {
+    for (int i = 0; i < 1; ++i) {
         UGEEntityCube* cube = new GameCube(_engine);
-        cube->setTextureId("test");
+        cube->setTextureId("rubiks");
 //        cube->rotate(Vector3D(0.0, 45.0, 45.0));
         cube->move(Vector3D(0, i, i));
 //        cube->setScale(Vector3D(1.0, 2.0, 1.0));
         _entities.append(cube);
     }
 
-    for(int i = 0,j = 0; i * j< 625;){
-        UGEEntityCube* cube = new GameCube(_engine);
-        cube->setTextureId("test");
-        cube->move(Vector3D(i, 0, j++));
-        _engine->addEntity(cube);
-        _entities.append(cube);
-        if(j == 26){
-            j = 0;
-            i++;
-        }
-    }
+//    for(int i = 0,j = 0; i * j< 626;){
+//        UGEEntityCube* cube = new GameCube(_engine);
+//        cube->setTextureId("rubiks");
+//        cube->move(Vector3D(i, 0, j++));
+//        _engine->addEntity(cube);
+//        _entities.append(cube);
+//        if(j == 26){
+//            j = 0;
+//            i++;
+//        }
+//    }
 
     WaveFrontObj* wavefrontObj = new WaveFrontObj(this);
-    wavefrontObj->openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
+    wavefrontObj->openFile(_assetsPath + "objs/enterprise/USSEnterprise.obj");
     UGEEntityWaveFrontObj* obj = new UGEEntityWaveFrontObj(wavefrontObj, this);
+    obj->hide();
     _engine->addEntity(obj);
     _entities.append(obj);
     animate();
     _engine->setClearColor(Qt::gray);
     _engine->initialize(70, width(), height());
 
-    _engine->loadTextureFromFile("test", "/home/robin/Downloads/test.png");
+    _engine->loadTextureFromFile("rubiks", _assetsPath + "textures/rubiks.png");
 }
 
 void RenderWidget::paintGL()
 {
     _camera->mousePressEvent(event);
     if (event->buttons() & Qt::LeftButton) {
-        Vector3D pos = _engine->get3DFrom2D(Vector2D(event->x(), height() - event->y()));
+//        Vector3D pos = _engine->get3DFrom2D(Vector2D(event->x(), height() - event->y()));
+        Vector3D pos = _camera->getDirection();
         qDebug() << pos.getX() << pos.getY() << pos.getZ();
+        Vector3D bestp;
+        bool ok;
+        for (int i = 0; i < _engine->getEntities().size(); i++) {
+            UGEEntity* entity = _engine->getEntities()[i];
+            bool provi;
+            Vector3D collision = entity->getVectorNearestIntesection(_camera->getDirection(), _camera->getPosition(), &provi);
+            if (provi) {
+                bestp = collision;
+                UGEEntityAxes* axe = new UGEEntityAxes(_engine);
+                axe->move(bestp);
+                _engine->addEntity(axe);
+                ok = true;
+            }
+        }
     }
 }
 

TheGame/renderwidget.h

     QList<UGEEntity*> _entities;
 
     AbstractCamera* _camera;
+
+    QString _assetsPath;
 };
 
 #endif // RENDERWIDGET_H

UGameEngine/cameras/abstractcamera.cpp

 {
     (void) event;
 }
+Vector3D AbstractCamera::getDirection() const
+{
+    return _direction;
+}
+
+void AbstractCamera::setDirection(const Vector3D &direction)
+{
+    _direction = direction;
+}
+Vector3D AbstractCamera::getPosition() const
+{
+    return _position;
+}
+
+void AbstractCamera::setPosition(const Vector3D &position)
+{
+    _position = position;
+}
+
+
 

UGameEngine/cameras/abstractcamera.h

 
     virtual void updateLookAt() = 0;
 
+    Vector3D getDirection() const;
+    void setDirection(const Vector3D &getDirection);
+
+    Vector3D getPosition() const;
+    void setPosition(const Vector3D &getPosition);
+
 protected:
     UGameEngine* _engine;
 
     QWidget* _widget;
+
+    Vector3D _direction;
+
+    Vector3D _position;
 };
 
 #endif // ABSTRACTCAMERA_H

UGameEngine/cameras/freeflycamera.h

     void rotate(float phi, float theta);
 
 private:
-    Vector3D _direction;
-
-    Vector3D _position;
 
     Vector2D _speedVector;
 

UGameEngine/cameras/rotationcamera.cpp

 {
     float theta = fabs(_theta / 180.0 * M_PI);
     float phi = _phi / 180.0 * M_PI;
-    Vector3D center = Vector3D(
+    _position = Vector3D(
                 _radius * sin(theta) * sin(phi),
                 _radius * cos(theta),
                 _radius * sin(theta) * cos(phi)
                 );
-    _engine->lookAt(center, Vector3D(0.0f, 0.0f, 0.0f));
+    _direction = -_position;
+    _engine->lookAt(_position, Vector3D(0.0f, 0.0f, 0.0f));
 }
 
 void RotationCamera::rotate(float phi, float theta)

UGameEngine/engine/abstractrenderdevice.cpp

 #include "abstractrenderdevice.h"
 #include <QImage>
+#include <QDir>
 
 AbstractRenderDevice::AbstractRenderDevice(QObject *parent) :
     QObject(parent)
 void AbstractRenderDevice::loadTextureFromFile(const QVariant &id, const QString &filename)
 {
     QImage img;
+    qDebug() << QDir::currentPath() << filename;
     if (img.load(filename)) {
         loadTexture(id, img);
     }

UGameEngine/entities/ugeentity.cpp

     , _scale(1.0, 1.0, 1.0)
     , _visible(true)
     , _needUpdate(true)
+    , _zero(0.001)
 {
     connect(this, SIGNAL(positionChanged()), this, SLOT(needUpdate()));
     connect(this, SIGNAL(rotationChanged()), this, SLOT(needUpdate()));
 {
     _needUpdate = true;
 }
+
+
+Vector3D UGEEntity::getVectorNearestFaceIntersection(const Vector3D & p0, const Vector3D &p1, const Vector3D &p2, const Vector3D &vector, const Vector3D &pos, bool* ok){
+    Vector3D v1 = p1 - p0;
+    Vector3D v2 = p2 - p0;
+    Vector3D n = v1.crossProduct(v2);
+    double dotProduct = vector.dotProduct(n);
+    if(isZero(dotProduct)){
+        *ok = false;
+        return Vector3D();
+    }
+    double l2 = n.dotProduct(p0 - pos) / dotProduct;
+    if(-_zero > l2){
+        *ok = false;
+        return Vector3D();
+    }
+    *ok = true;
+    Vector3D unit = (vector / vector.norm()) * l2;
+    return pos + unit;
+}
+
+bool UGEEntity::isZero(double v){
+    return v < _zero && v > -_zero;
+}

UGameEngine/entities/ugeentity.h

 
     virtual Vector3D getVectorNearestIntesection(const Vector3D &vector, const Vector3D &pos, bool* ok) = 0;
 
+    Vector3D getVectorNearestFaceIntersection(const Vector3D & p0, const Vector3D &p1, const Vector3D &p2, const Vector3D &vector, const Vector3D &pos, bool* ok);
+
+    bool isZero(double v);
+
     void update();
 
     virtual void onUpdate();
 
     Matrix3x3 _tranformation;
 
+    double _zero;
+
 };
 
 #endif // UGEENTITY_H

UGameEngine/entities/ugeentitycube.cpp

 Vector3D UGEEntityCube::getVectorNearestIntesection(const Vector3D &vector, const Vector3D &origin, bool *ok)
 {
     *ok = false;
-    return Vector3D();
+    //    Vector3D p1 = points[1] - p;
+    //    Vector3D p2 = points[1];
+    //    Vector3D n = p1.crossProduct(p2);
+    Vector3D bestP;
+    for (int i = 0; i < _facesTexture.size(); ++i){
+        bool provi = false;
+        QList<TextureVector3D> face = _facesTexture[i];
+        Vector3D pinter = getVectorNearestFaceIntersection(face[0], face[1], face[2], vector, origin, &provi);
+        if (provi) {
+            bool isNearest = (origin - pinter).norm() < (origin - bestP).norm();
+            bool isInFace = (_position - face[0]).norm() >= (_position - pinter).norm();
+            if (isInFace && (!(*ok) || isNearest)) {
+                bestP = pinter;
+                *ok = true;
+            }
+            qDebug() << bestP.getX() << bestP.getY() << bestP.getZ();
+        }
+    }
+    return bestP;
+
+
 //    Vector3D inv(1.0 / vector.getX(), 1.0 / vector.getY(), 1.0 / vector.getZ());
 //    float tmin, tmax, tymin, tymax, tzmin, tzmax;