loading and drawing obj

TheGame/renderwidget.cpp

 #include "entities/ugeentitycube.h"
 #include "entities/ugeentityaxes.h"
 #include "utils/wavefrontobj.h"
+#include "entities/ugeentitywavefrontobj.h"
 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);
 
+    WaveFrontObj* wavefrontObj = new WaveFrontObj(this);
+    qDebug() << wavefrontObj->openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
+
+    UGEEntityWaveFrontObj* obj = new UGEEntityWaveFrontObj(wavefrontObj, this);
+    _engine->addEntity(obj);
 
-    WaveFrontObj obj;
-    qDebug() << obj.openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
 }
 
 void RenderWidget::initializeGL()

UGameEngine/UGameEngine.pro

     utils/colorvector3d.cpp \
     entities/ugeentitycube.cpp \
     entities/ugeentityaxes.cpp \
-    utils/wavefrontobj.cpp
+    utils/wavefrontobj.cpp \
+    entities/ugeentitywavefrontobj.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
     utils/colorvector3d.h \
     entities/ugeentitycube.h \
     entities/ugeentityaxes.h \
-    utils/wavefrontobj.h
+    utils/wavefrontobj.h \
+    entities/ugeentitywavefrontobj.h
 
 
 # FLEX && BISON

UGameEngine/entities/ugeentitywavefrontobj.cpp

+#include "ugeentitywavefrontobj.h"
+
+UGEEntityWaveFrontObj::UGEEntityWaveFrontObj(WaveFrontObj *obj, QObject *parent)
+    : UGEEntity(parent)
+    , _obj(obj)
+{
+}
+
+void UGEEntityWaveFrontObj::draw(AbstractRenderDevice *device)
+{
+    QList<QList<int> > faces = _obj->getFaces();
+    QList<Vector3D> vertexes = _obj->getVertexes();
+    for (int i = 0; i < faces.size(); ++i) {
+        QList<int> face = faces[i];
+        QList<ColorVector3D> poly;
+        for (int j = 0; j < face.size(); ++j) {
+            poly.append(ColorVector3D(Qt::gray, vertexes[face[j] - 1]));
+        }
+        drawPolygon(device, poly);
+    }
+}

UGameEngine/entities/ugeentitywavefrontobj.h

+#ifndef UGEENTITYWAVEFRONTOBJ_H
+#define UGEENTITYWAVEFRONTOBJ_H
+
+#include "ugeentity.h"
+#include "utils/wavefrontobj.h"
+
+class UGEEntityWaveFrontObj : public UGEEntity
+{
+    Q_OBJECT
+public:
+    explicit UGEEntityWaveFrontObj(WaveFrontObj* obj, QObject *parent = 0);
+
+    virtual void draw(AbstractRenderDevice* device);
+
+signals:
+
+public slots:
+
+private:
+    WaveFrontObj* _obj;
+
+};
+
+#endif // UGEENTITYWAVEFRONTOBJ_H

UGameEngine/utils/parser-wavefront-obj.y

 
 // Bison uses the yyerror function for informing us when a parsing error has
 // occurred.
-void wavefront_objerror(WaveFrontObjData* data, const char *s);
+void wavefront_objerror(WaveFrontObj* data, const char *s);
 %}
 
 %define api.prefix {wavefront_obj}
 %define api.token.prefix {TOK_}
 
-%parse-param {struct WaveFrontObjData* wavefrontData}
+%parse-param {struct WaveFrontObj* wavefrontData}
 
 // Here we define our custom variable types.
 // Custom types must be of fixed size.
 stmt: mtllib {}
             | usemtl {}
             | named_object {}
-            | vertex { wavefrontData->_vertexes.append(*$1); delete $1; }
+            | vertex { wavefrontData->addVertex(*$1); delete $1; }
             | texture_coordinate {}
             | vertex_normal {}
             | vertex_space {}
-            | face { wavefrontData->_faces.append(*$1); delete $1; }
+            | face { wavefrontData->addFace(*$1); delete $1; }
             | smooth {};
 
 mtllib: MTLLIB STRING {};
 
 %%
 
-void wavefront_objerror(WaveFrontObjData* data, const char *s)
+void wavefront_objerror(WaveFrontObj* data, const char *s)
 {
-    data->_error = QString(s) + " at line " + QString::number(wavefront_objlineno) + " at " + QString(wavefront_objtext);
+    data->setError("Parse error: " + QString(s) + " at line " + QString::number(wavefront_objlineno) + " at " + QString(wavefront_objtext));
 }

UGameEngine/utils/wavefrontobj.cpp

 {
 }
 
+QList<QList<int> > WaveFrontObj::getFaces() const
+{
+    return _faces;
+}
+
+QList<Vector3D> WaveFrontObj::getVertexes() const
+{
+    return _vertexes;
+}
+
 bool WaveFrontObj::openFile(const QString &filename)
 {
     QFile f(filename);
     QString file = device.readAll();
 
     YY_BUFFER_STATE bufferState = wavefront_obj_scan_string(file.toUtf8().constData());
-    WaveFrontObjData data;
-    int res = wavefront_objparse(&data);
+
+    int res = wavefront_objparse(this);
     wavefront_obj_delete_buffer(bufferState);
     if (res) {
-        _error = "Parse error: " + data._error;
         qDebug() << _error;
     }
     else {
-        qDebug() << "faces:" << data._faces.size() << "vertexes" << data._vertexes.size();
+        qDebug() << "faces:" << _faces.size() << "vertexes" << _vertexes.size();
     }
 
     return res == 0;
 }
+
+void WaveFrontObj::addFace(QList<int> face)
+{
+    _faces.append(face);
+}
+
+void WaveFrontObj::addVertex(const Vector3D &vertex)
+{
+    _vertexes.append(vertex);
+}
+
+void WaveFrontObj::setError(const QString &error)
+{
+    _error = error;
+}

UGameEngine/utils/wavefrontobj.h

 public:
     explicit WaveFrontObj(QObject *parent = 0);
 
+    QList<QList<int> > getFaces() const;
+    QList<Vector3D> getVertexes() const;
+
 signals:
 
 public slots:
     bool openFile(const QString& filename);
     bool load(QIODevice& device);
+    void addFace(QList<int> face);
+    void addVertex(const Vector3D& vertex);
+    void setError(const QString& error);
 
 private:
     QString _error;
-
-};
-
-struct WaveFrontObjData
-{
     QList<Vector3D> _vertexes;
     QList<QList<int> > _faces;
-    QString _error;
+
 };
 
 #endif // WAVEFRONTOBJ_H