fixed memory leaks; begin mtl parser; begin obj material support

TheGame/openglrenderdevice.cpp

     OpenGLTextureData data;
     data.id = 0;
     data.image = texture;
-    data.rawData = new char[texture.width() * texture.height() * 4];
+    char rawData[texture.width() * texture.height() * 4];
 
     for (int y = 0; y < texture.height(); ++y) {
         for(int x = 0; x < texture.width(); ++x) {
             int p = (y * texture.height() * 4) + x * 4;
             QColor px = QColor(texture.pixel(x, y));
-            data.rawData[p] = px.red();
-            data.rawData[p + 1] = px.green();
-            data.rawData[p + 2] = px.blue();
-            data.rawData[p + 3] = 255;
+            rawData[p] = px.red();
+            rawData[p + 1] = px.green();
+            rawData[p + 2] = px.blue();
+            rawData[p + 3] = 255;
         }
     }
 
     glGenTextures(1, &data.id);
     glBindTexture(GL_TEXTURE_2D, data.id);
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture.width(), texture.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, data.rawData);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture.width(), texture.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, rawData);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

TheGame/openglrenderdevice.h

 {
     unsigned id;
     QImage image;
-    char* rawData;
 };
 
 class OpenGLRenderDevice : public AbstractRenderDevice

TheGame/renderwidget.cpp

   , _radius(5.0)
   , _phi(45.0)
   , _theta(45.0)
-  , _angle(0.0)
 {
+    setMouseTracking(true);
+    setFocusPolicy(Qt::StrongFocus);
+
     _device = new OpenGLRenderDevice(this);
     _engine = new UGameEngine(_device);
 
+    _engine->addEntity(new UGEEntityAxes(_engine));
+
     UGEEntityCube* cube = new UGEEntityCube(_engine);
     cube->setTextureId("test");
     cube->rotate(Vector3D(0.0, 45.0, 45.0));
     cube->move(Vector3D(0, 1, 0));
     cube->setScale(Vector3D(1.0, 2.0, 1.0));
-//    cube->hide();
+    cube->hide();
     _engine->addEntity(cube);
-    _engine->addEntity(new UGEEntityAxes(_engine));
-    setMouseTracking(true);
-    setFocusPolicy(Qt::StrongFocus);
 
     WaveFrontObj* wavefrontObj = new WaveFrontObj(this);
     wavefrontObj->openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
-
     UGEEntityWaveFrontObj* obj = new UGEEntityWaveFrontObj(wavefrontObj, this);
     _engine->addEntity(obj);
-    obj->hide();
-
+//    obj->hide();
     _entity = cube;
 //    animate();
 }

TheGame/renderwidget.h

 
     Vector3D pos;
 
-    double _angle;
-
     UGEEntity* _entity;
 };
 

UGameEngine/UGameEngine.pro

 
 LIBS += -lfl -ly
 
-FLEXSOURCES = utils/lexer-wavefront-obj.l
-BISONSOURCES = utils/parser-wavefront-obj.y
+FLEXSOURCES = utils/lexer-wavefront-obj.l \
+    utils/lexer-wavefront-mtl.l
+BISONSOURCES = utils/parser-wavefront-obj.y \
+    utils/parser-wavefront-mtl.y
 
 OTHER_FILES +=  \
     $$FLEXSOURCES \

UGameEngine/entities/ugeentitywavefrontobj.cpp

 
 void UGEEntityWaveFrontObj::draw(AbstractRenderDevice *device)
 {
-    QList<QList<int> > faces = _obj->getFaces();
+    QList<QList<WaveFrontObjFaceVertex> > faces = _obj->getFaces();
     QList<Vector3D> vertexes = _obj->getVertexes();
     for (int i = 0; i < faces.size(); ++i) {
-        QList<int> face = faces[i];
+        QList<WaveFrontObjFaceVertex> face = faces[i];
         QList<ColorVector3D> poly;
         for (int j = 0; j < face.size(); ++j) {
-            poly.append(ColorVector3D(Qt::black, vertexes[face[j] - 1]));
+            poly.append(ColorVector3D(Qt::black, vertexes[face[j].vertexPosition - 1]));
         }
         drawPolygon(device, poly);
     }

UGameEngine/utils/lexer-wavefront-mtl.l

+%{
+// In this section we can add all needed headers, from Qt or another libraries.
+//#include <QtScript>
+#include <QVariant>
+#include <QDebug>
+
+// Also, we must add the parser's header where are defined the tokens.
+#include "utils/vector3d.h"
+#include "utils/wavefrontobj.h"
+#include "parser-wavefront-mtl.h"
+
+#define TOKEN(type) \
+  TOK_WFMTL_##type
+
+%}
+
+%option noyywrap
+%option nounput
+%option prefix="wavefront_mtl"
+
+%%
+
+ /* Whitespace */
+[ \t]+       {                           }
+
+ /* Newline */
+\n|\n\r      { ++wavefront_mtllineno;    }
+
+ /* Comment */
+"#"[^\n\r]*  {                        }
+
+ /* Material library */
+"mtllib"     { return TOKEN(MTLLIB);  }
+
+ /* Use material */
+"usemtl"     { return TOKEN(USEMTL);  }
+
+ /* Named object */
+"o"     { return TOKEN(O);  }
+
+ /* Vertex */
+"v"     { return TOKEN(V);  }
+
+ /* Texture coordinate */
+"vt"     { return TOKEN(VT);  }
+
+ /* Vertex normal */
+"vn"     { return TOKEN(VN);  }
+
+ /* Parameter space vertices */
+"vp"     { return TOKEN(VP);  }
+
+ /* Face */
+"f"     { return TOKEN(F);  }
+
+ /* Smooth */
+"s"     { return TOKEN(S);  }
+
+ /* Slash */
+"/"     { return TOKEN(SLASH);  }
+
+ /* Number */
+-?[0-9]+(.[0-9]+)?     { wavefront_mtllval.number=atof(yytext); return TOKEN(NUMBER); }
+
+ /* String */
+[^\n\r\t ]+  { wavefront_mtllval.string = strcpy((char*)malloc(strlen(yytext) + 1), yytext); return TOKEN(STRING);  }
+
+
+%%

UGameEngine/utils/lexer-wavefront-obj.l

 
 // Also, we must add the parser's header where are defined the tokens.
 #include "utils/vector3d.h"
+#include "utils/wavefrontobj.h"
 #include "parser-wavefront-obj.h"
 
 #define TOKEN(type) \
-  TOK_##type
+  TOK_WFOBJ_##type
 
 %}
 
 %option noyywrap
+%option nounput
 %option prefix="wavefront_obj"
 
 %%
 -?[0-9]+(.[0-9]+)?     { wavefront_objlval.number=atof(yytext); return TOKEN(NUMBER); }
 
  /* String */
-[^\n\r\t ]+  { wavefront_objlval.string = strcpy((char*)malloc(strlen(yytext)), yytext); return TOKEN(STRING);  }
+[^\n\r\t ]+  { wavefront_objlval.string = strcpy((char*)malloc(strlen(yytext) + 1), yytext); return TOKEN(STRING);  }
 
 
 %%

UGameEngine/utils/parser-wavefront-mtl.y

+%{
+#include <QVariant>
+#include <QDebug>
+#include "utils/vector3d.h"
+#include "utils/wavefrontobj.h"
+#include "lexer-wavefront-mtl.h"
+
+
+
+// yylex is a function generated by Flex and we must tell to Bison that it is
+// defined in other place.
+extern int wavefront_mtllex(void);
+
+// Bison uses the yyerror function for informing us when a parsing error has
+// occurred.
+void wavefront_mtlerror(WaveFrontObj* data, const char *s);
+%}
+
+%define api.prefix {wavefront_mtl}
+%define api.token.prefix {TOK_WFMTL_}
+
+%parse-param {struct WaveFrontObj* wavefrontData}
+
+// Here we define our custom variable types.
+// Custom types must be of fixed size.
+%union {
+    double number;
+    int integer;
+    char* string;
+    Vector3D* vector3d;
+    QList<int>* integers;
+    WaveFrontObjFaceVertex faceVertex;
+    QList<WaveFrontObjFaceVertex>* face;
+}
+
+// Define the terminal expression types.
+%token <number> NUMBER
+%token <string> STRING
+%token SLASH
+%token MTLLIB
+%token USEMTL
+%token O
+%token V
+%token VT
+%token VN
+%token VP
+%token F
+%token S
+
+%destructor { free($$); } <string>
+%destructor { delete $$; } <vector3d>
+%destructor { delete $$; } <integers>
+%destructor { delete $$; } <face>
+
+// Define the non-terminal expression types.
+%type <vector3d> vertex
+%type <faceVertex>   face_vertex
+%type <face>  face_vertex_list
+%type <face>  face
+
+
+%%
+
+wavefront_mtl: stmt_list {};
+
+
+stmt_list: {}
+            | stmt_list stmt {};
+
+stmt: mtllib {}
+            | usemtl {}
+            | named_object {}
+            | vertex { wavefrontData->addVertex(*$1); delete $1; }
+            | texture_coordinate {}
+            | vertex_normal {}
+            | vertex_space {}
+            | face { wavefrontData->addFace(*$1); delete $1; }
+            | smooth {};
+
+mtllib: MTLLIB STRING { free($2); };
+
+usemtl: USEMTL STRING { free($2); };
+
+named_object: O STRING { free($2); };
+
+vertex: V NUMBER NUMBER NUMBER { $$ = new Vector3D($2, $3, $4); }
+            | V NUMBER NUMBER NUMBER NUMBER { $$ = new Vector3D($2, $3, $4); };
+
+texture_coordinate: VT NUMBER NUMBER {}
+            | VT NUMBER NUMBER NUMBER {};
+
+vertex_normal: VN NUMBER NUMBER NUMBER {};
+
+vertex_space: VP NUMBER NUMBER NUMBER {};
+
+face: F face_vertex_list { $$ = $2; };
+
+face_vertex_list: { $$ = new QList<WaveFrontObjFaceVertex>(); }
+            | face_vertex_list face_vertex { $1->append($2); $$ = $1;};
+
+face_vertex: NUMBER { $$.vertexPosition = $1; }
+            | NUMBER SLASH NUMBER { $$.vertexPosition = $1; $$.textureCoordPosition = $3; }
+            | NUMBER SLASH NUMBER SLASH NUMBER { $$.vertexPosition = $1; $$.textureCoordPosition = $3; }
+            | NUMBER SLASH SLASH NUMBER { $$.vertexPosition = $1; };
+
+smooth: S NUMBER {}
+            | S STRING { free($2); };
+
+%%
+
+void wavefront_mtlerror(WaveFrontObj* data, const char *s)
+{
+    data->setError("Parse error: " + QString(s) + " at line " + QString::number(wavefront_mtllineno) + " at " + QString(wavefront_mtltext));
+}

UGameEngine/utils/parser-wavefront-obj.y

 %{
-/*#include <QtGui>*/
 #include <QVariant>
 #include <QDebug>
 #include "utils/vector3d.h"
 %}
 
 %define api.prefix {wavefront_obj}
-%define api.token.prefix {TOK_}
+%define api.token.prefix {TOK_WFOBJ_}
 
 %parse-param {struct WaveFrontObj* wavefrontData}
 
     char* string;
     Vector3D* vector3d;
     QList<int>* integers;
+    WaveFrontObjFaceVertex faceVertex;
+    QList<WaveFrontObjFaceVertex>* face;
 }
 
 // Define the terminal expression types.
 %destructor { free($$); } <string>
 %destructor { delete $$; } <vector3d>
 %destructor { delete $$; } <integers>
+%destructor { delete $$; } <face>
 
 // Define the non-terminal expression types.
 %type <vector3d> vertex
-%type <integer>   face_vertex
-%type <integers>  face_vertex_list
-%type <integers>  face
+%type <faceVertex>   face_vertex
+%type <face>  face_vertex_list
+%type <face>  face
 
 
 %%
             | face { wavefrontData->addFace(*$1); delete $1; }
             | smooth {};
 
-mtllib: MTLLIB STRING {};
+mtllib: MTLLIB STRING { free($2); };
 
-usemtl: USEMTL STRING {};
+usemtl: USEMTL STRING { free($2); };
 
-named_object: O STRING {};
+named_object: O STRING { free($2); };
 
 vertex: V NUMBER NUMBER NUMBER { $$ = new Vector3D($2, $3, $4); }
             | V NUMBER NUMBER NUMBER NUMBER { $$ = new Vector3D($2, $3, $4); };
 
 face: F face_vertex_list { $$ = $2; };
 
-face_vertex_list: { $$ = new QList<int>(); }
+face_vertex_list: { $$ = new QList<WaveFrontObjFaceVertex>(); }
             | face_vertex_list face_vertex { $1->append($2); $$ = $1;};
 
-face_vertex: NUMBER { $$ = $1; }
-            | NUMBER SLASH NUMBER { $$ = $1; }
-            | NUMBER SLASH NUMBER SLASH NUMBER { $$ = $1; }
-            | NUMBER SLASH SLASH NUMBER { $$ = $1; };
+face_vertex: NUMBER { $$.vertexPosition = $1; }
+            | NUMBER SLASH NUMBER { $$.vertexPosition = $1; $$.textureCoordPosition = $3; }
+            | NUMBER SLASH NUMBER SLASH NUMBER { $$.vertexPosition = $1; $$.textureCoordPosition = $3; }
+            | NUMBER SLASH SLASH NUMBER { $$.vertexPosition = $1; };
 
 smooth: S NUMBER {}
-            | S STRING {};
+            | S STRING { free($2); };
 
 %%
 

UGameEngine/utils/wavefrontobj.cpp

 #include <QDebug>
 #include "lexer-wavefront-obj.h"
 #include "parser-wavefront-obj.h"
+#include "lexer-wavefront-mtl.h"
+#include "parser-wavefront-mtl.h"
 
 WaveFrontObj::WaveFrontObj(QObject *parent) :
     QObject(parent)
 {
 }
 
-QList<QList<int> > WaveFrontObj::getFaces() const
+QList<QList<WaveFrontObjFaceVertex> > WaveFrontObj::getFaces() const
 {
     return _faces;
 }
     wavefront_obj_delete_buffer(bufferState);
     if (res) {
         qDebug() << _error;
+        return false;
     }
     else {
-        qDebug() << "faces:" << _faces.size() << "vertexes" << _vertexes.size();
+        return true;
     }
-
-    return res == 0;
 }
 
-void WaveFrontObj::addFace(QList<int> face)
+void WaveFrontObj::addFace(QList<WaveFrontObjFaceVertex> face)
 {
     _faces.append(face);
 }

UGameEngine/utils/wavefrontobj.h

 #include <QIODevice>
 #include "utils/vector3d.h"
 
+struct WaveFrontObjFaceVertex
+{
+    int vertexPosition;
+    int textureCoordPosition;
+};
+
 class WaveFrontObj : public QObject
 {
     Q_OBJECT
 public:
     explicit WaveFrontObj(QObject *parent = 0);
 
-    QList<QList<int> > getFaces() const;
+    QList<QList<WaveFrontObjFaceVertex> > getFaces() const;
     QList<Vector3D> getVertexes() const;
 
 signals:
 public slots:
     bool openFile(const QString& filename);
     bool load(QIODevice& device);
-    void addFace(QList<int> face);
+    void addFace(QList<WaveFrontObjFaceVertex> face);
     void addVertex(const Vector3D& vertex);
     void setError(const QString& error);
 
 private:
     QString _error;
     QList<Vector3D> _vertexes;
-    QList<QList<int> > _faces;
+    QList<QList<WaveFrontObjFaceVertex> > _faces;
 
 };
 

UGameEngine/utils/wavefrontobjfacevertex.cpp

+#include "wavefrontobjfacevertex.h"
+
+WaveFrontObjFaceVertex::WaveFrontObjFaceVertex()
+{
+}
+int WaveFrontObjFaceVertex::textureCoordPosition() const
+{
+    return _textureCoordPosition;
+}
+
+void WaveFrontObjFaceVertex::setTextureCoordPosition(int textureCoordPosition)
+{
+    _textureCoordPosition = textureCoordPosition;
+}
+int WaveFrontObjFaceVertex::vertexPosition() const
+{
+    return _vertexPosition;
+}
+
+void WaveFrontObjFaceVertex::setVertexPosition(int vertexPosition)
+{
+    _vertexPosition = vertexPosition;
+}
+
+

UGameEngine/utils/wavefrontobjfacevertex.h

+#ifndef WAVEFRONTOBJVERTEX_H
+#define WAVEFRONTOBJVERTEX_H
+
+class WaveFrontObjFaceVertex
+{
+public:
+    WaveFrontObjFaceVertex();
+
+    int vertexPosition() const;
+    void setVertexPosition(int vertexPosition);
+
+    int textureCoordPosition() const;
+    void setTextureCoordPosition(int textureCoordPosition);
+
+private:
+    int _vertexPosition;
+
+    int _textureCoordPosition;
+
+};
+
+#endif // WAVEFRONTOBJVERTEX_H