[SOLVED] QOpenGLWidget draw object

I already asked a question about QOpenglWidget here. In my last problem I just called the shaderid the wrong way. Now I am trying to load my vertices from a object. I've written a loader which loads the vertices, texture coordinates, normals and indices. I have already written this code in native openGL and checked the output. the vertices etc are matching with the ones in my Qt code.

The only problem is that I am unable to make the method paintGL() draw my object, which should be a simple cube.

--Main.cpp

    #include <QApplication>
#include <QLabel>
#include <QSurfaceFormat>

#ifndef QT_NO_OPENGL
#include "mainwidget.h"
#endif

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QSurfaceFormat format;
    format.setDepthBufferSize(24);
    QSurfaceFormat::setDefaultFormat(format);

    app.setApplicationName("MainWidget");

#ifndef QT_NO_OPENGL
    MainWidget widget;
    widget.resize(800, 600);
    widget.show();
#else
    QLabel note("OpenGL Support required");
    note.show();
#endif
    return app.exec();
}

--MainWidget.h

#ifndef MAINWIDGET_H
#define MAINWIDGET_H

#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QVector2D>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QVector3D>
#include <QOpenGLVertexArrayObject>
#include <QVector>
#include "geometryengine.h"


class GeometryEngine;
class MainWidget : public QOpenGLWidget, protected QOpenGLFunctions
{
    Q_OBJECT
public:
    MainWidget(QWidget *parent = 0);
    ~MainWidget();
protected:
    void initializeGL()Q_DECL_OVERRIDE;
    void resizeGL(int w, int h)Q_DECL_OVERRIDE;
    void paintGL()Q_DECL_OVERRIDE;

    void initShaders();
private:
    QOpenGLShaderProgram program;
    GeometryEngine *geometries;

};

#endif // MAINWIDGET_H

--MainWidget.cpp

#include "mainwidget.h"
#include <iostream>


extern QVector<QVector3D> m_vertices;
extern QVector<QVector2D> m_uvs;
extern QVector<QVector3D> m_normals;

extern QVector<QVector3D> m_indexed_vertices;
extern QVector<QVector2D> m_indexed_uvs;
extern QVector<QVector3D> m_indexed_normals;
extern QVector<unsigned short> m_indices;

MainWidget::MainWidget(QWidget *parent):QOpenGLWidget(parent), geometries(0){

}

MainWidget::~MainWidget(){
    makeCurrent();
    delete geometries;
    doneCurrent();
}

void MainWidget::initializeGL(){
    initializeOpenGLFunctions();
    glClearColor(0, 0, 0.4f, 0);
    glEnable(GL_DEPTH_TEST);
    initShaders();

    geometries = new GeometryEngine;
    for(auto i : m_indexed_vertices){
            std::cout<<i.x()<<" "<<i.y()<<" "<<i.z()<<std::endl;
            //std::cout << i << " " << std::endl;
        }
}

void MainWidget::resizeGL(int w, int h){

}

void MainWidget::paintGL(){
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    /*for(auto i : m_indices){
            //std::cout<<i.x()<<" "<<i.y()<<" "<<i.z()<<std::endl;
            std::cout << i << " " << std::endl;
        }*/
    geometries->drawGeometry(&program, m_indices);
}


void MainWidget::initShaders(){
    // Compile vertex shader
    if (!program.addShaderFromSourceFile(QOpenGLShader::Vertex, "vertex.vert"))
        close();

    // Compile fragment shader
    if (!program.addShaderFromSourceFile(QOpenGLShader::Fragment, "fragment.frag"))
        close();

    // Link shader pipeline
    if (!program.link())
        close();

    // Bind shader pipeline for use
    if (!program.bind())
        close();
}

--GeometryEngine.h

#ifndef GEOMETRYENGINE_H
#define GEOMETRYENGINE_H
#include <QOpenGLFunctions>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>
#include "mainwidget.h"


class GeometryEngine : protected QOpenGLFunctions
{
public:
    GeometryEngine();
    virtual ~GeometryEngine();

    void drawGeometry(QOpenGLShaderProgram *program, QVector<unsigned short> indices);


private:
    void initGeometry(const char *path, QVector<QVector3D> &vert, QVector<QVector2D> &uv, QVector<QVector3D> &norm,QVector<unsigned short> &indices, QVector<QVector3D> &indexed_vertices,
    QVector<QVector2D> &indexed_uvs,
    QVector<QVector3D> &indexed_normals);

    QOpenGLBuffer arrayBuf;
    QOpenGLBuffer indexBuf;
    QOpenGLVertexArrayObject vertexArrayID;

};

#endif // GEOMETRYENGINE_H

--GeometryEngine.cpp

#include "geometryengine.h"
#include "mainwidget.h"
#include "loadobj.h"
#include <QVector>
#include <QVector2D>
#include <QVector3D>
#include <string>
#include <iostream>


QVector<QVector3D> m_vertices;
QVector<QVector2D> m_uvs;
QVector<QVector3D> m_normals;

QVector<QVector3D> m_indexed_vertices;
QVector<QVector2D> m_indexed_uvs;
QVector<QVector3D> m_indexed_normals;
QVector<unsigned short> m_indices;

GeometryEngine::GeometryEngine() : indexBuf(QOpenGLBuffer::IndexBuffer)
{


    initializeOpenGLFunctions();
    vertexArrayID.create();
    vertexArrayID.bind();
    //generate vbos
    arrayBuf.create();
    indexBuf.create();


    initGeometry("cube.obj", m_vertices, m_uvs, m_normals, m_indices, m_indexed_vertices, m_indexed_uvs, m_indexed_normals);

}

GeometryEngine::~GeometryEngine(){
    arrayBuf.destroy();
    indexBuf.destroy();
    vertexArrayID.destroy();
}
void GeometryEngine::initGeometry(const char *path,QVector<QVector3D> &vertices, QVector<QVector2D> &uvs, QVector<QVector3D> &normals, QVector<unsigned short> &indices,  QVector<QVector3D> &indexed_vertices, QVector<QVector2D> &indexed_uvs, QVector<QVector3D> &indexed_normals ){
    bool res = loadObj(path, vertices, uvs, normals);
    vboIndexer(vertices, uvs, normals, indices, indexed_vertices, indexed_uvs, indexed_normals );
    /*for(auto i : indices){
            //std::cout<<i.x()<<" "<<i.y()<<" "<<i.z()<<std::endl;
            std::cout << i << " " << std::endl;
        }*/
    arrayBuf.bind();
    arrayBuf.allocate(&indexed_vertices, indexed_vertices.size() * sizeof(QVector3D));

    indexBuf.bind();
    indexBuf.allocate(&indices, indices.size() * sizeof(unsigned short));

}

void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program, QVector<unsigned short> indices){
    arrayBuf.bind();
    indexBuf.bind();

    int vertexLocation = program->attributeLocation("vertex");
    program->enableAttributeArray(vertexLocation);
    program->setAttributeBuffer(vertexLocation, GL_FLOAT, 0, 3, sizeof(GLfloat));

    //glDrawElements(GL_TRIANGLE_STRIP, indices.size(), GL_UNSIGNED_SHORT, 0);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glDisableVertexAttribArray(0);
}

--vertex.vert

#version 330

layout(location = 0) in vec3 vertex;

void main(){
    gl_Position = vec4(vertex, 1.0);
}

--fragment.frag

#version 330

out vec3 color;
void main(){
    color = vec3(1,0,0);
}

I don't know whether I messed up some of the QOpenGL code or if it's because of the fact that I have stored my vertices in a QVector and not in an array. As a lead I used the cube example from Qt as you can see in the code similarity.