begin obj lexer/parser

.gitignore

@@ -12,3 +12,8 @@ Makefile
 *.so.*
 TheGame/TheGame
 tests/tests
+
+lexer-*.cpp
+lexer-*.h
+parser-*.cpp
+parser-*.h

TheGame/openglrenderdevice.cpp

@@ -44,7 +44,7 @@ void OpenGLRenderDevice::initialize(int fov, int width, int height)
     _width = width;
     _height = height;
     glClearColor(_clearColor.redF(), _clearColor.greenF(),
-                 _clearColor.blue(), _clearColor.alpha());
+                 _clearColor.blueF(), _clearColor.alphaF());
 
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_CULL_FACE);

TheGame/renderwidget.cpp

@@ -5,6 +5,7 @@
 #include <QDebug>
 #include "entities/ugeentitycube.h"
 #include "entities/ugeentityaxes.h"
+#include "utils/wavefrontobj.h"
 
 RenderWidget::RenderWidget(QWidget *parent) :
     QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
@@ -20,6 +21,10 @@ RenderWidget::RenderWidget(QWidget *parent) :
     _engine->addEntity(new UGEEntityAxes(_engine));
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);
+
+
+    WaveFrontObj obj;
+    qDebug() << obj.openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
 }
 
 void RenderWidget::initializeGL()
@@ -78,7 +83,7 @@ void RenderWidget::mouseMoveEvent(QMouseEvent *event)
 
     Vector3D dd = _device->get2DFrom3D(Vector3D(0.5, 0.5, 0.5));
     dd.setY(height() - dd.getY());
-    qDebug() << event->pos() << dd;
+//    qDebug() << event->pos() << dd;
     pos = _device->get3DFrom2D(event->x(), height() - event->y());
 
     update();

UGameEngine/UGameEngine.pro

@@ -17,7 +17,8 @@ SOURCES += engine/ugameengine.cpp \
     utils/vector3d.cpp \
     utils/colorvector3d.cpp \
     entities/ugeentitycube.cpp \
-    entities/ugeentityaxes.cpp
+    entities/ugeentityaxes.cpp \
+    utils/wavefrontobj.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
@@ -25,7 +26,61 @@ HEADERS += engine/ugameengine.h\
     utils/vector3d.h \
     utils/colorvector3d.h \
     entities/ugeentitycube.h \
-    entities/ugeentityaxes.h
+    entities/ugeentityaxes.h \
+    utils/wavefrontobj.h
+
+
+# FLEX && BISON
+
+LIBS += -lfl -ly
+
+FLEXSOURCES = utils/lexer-wavefront-obj.l
+BISONSOURCES = utils/parser-wavefront-obj.y
+
+OTHER_FILES +=  \
+    $$FLEXSOURCES \
+    $$BISONSOURCES
+
+flexsource.input = FLEXSOURCES
+flexsource.output = ${QMAKE_FILE_BASE}.cpp
+flexsource.commands = flex --header-file=${QMAKE_FILE_BASE}.h -o ${QMAKE_FILE_BASE}.cpp ${QMAKE_FILE_IN}
+flexsource.variable_out = SOURCES
+flexsource.name = Flex Sources ${QMAKE_FILE_IN}
+flexsource.CONFIG += target_predeps
+
+QMAKE_EXTRA_COMPILERS += flexsource
+
+flexheader.input = FLEXSOURCES
+flexheader.output = ${QMAKE_FILE_BASE}.h
+flexheader.commands = @true
+flexheader.variable_out = HEADERS
+flexheader.name = Flex Headers ${QMAKE_FILE_IN}
+flexheader.CONFIG += target_predeps no_link
+
+QMAKE_EXTRA_COMPILERS += flexheader
+
+bisonsource.input = BISONSOURCES
+bisonsource.output = ${QMAKE_FILE_BASE}.cpp
+bisonsource.commands = bison -d --defines=${QMAKE_FILE_BASE}.h -o ${QMAKE_FILE_BASE}.cpp ${QMAKE_FILE_IN}
+bisonsource.variable_out = SOURCES
+bisonsource.name = Bison Sources ${QMAKE_FILE_IN}
+bisonsource.CONFIG += target_predeps
+
+QMAKE_EXTRA_COMPILERS += bisonsource
+
+bisonheader.input = BISONSOURCES
+bisonheader.output = ${QMAKE_FILE_BASE}.h
+bisonheader.commands = @true
+bisonheader.variable_out = HEADERS
+bisonheader.name = Bison Headers ${QMAKE_FILE_IN}
+bisonheader.CONFIG += target_predeps no_link
+
+QMAKE_EXTRA_COMPILERS += bisonheader
+
+
+
+
+
 
 unix {
     target.path = /usr/lib

UGameEngine/utils/lexer-wavefront-obj.l

@@ -0,0 +1,66 @@
+%{
+// 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 "parser-wavefront-obj.h"
+
+#define TOKEN(type) \
+  TOK_##type
+
+%}
+
+%option noyywrap
+%option prefix="wavefront_obj"
+
+%%
+
+ /* Whitespace */
+[ \t]+       {                           }
+
+ /* Newline */
+\n|\n\r      { ++wavefront_objlineno;    }
+
+ /* 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]+)?     { return TOKEN(NUMBER); }
+
+ /* String */
+[^\n\r\t ]+  { return TOKEN(STRING);  }
+
+
+%%

UGameEngine/utils/parser-wavefront-obj.y

@@ -0,0 +1,105 @@
+%{
+/*#include <QtGui>*/
+#include <QVariant>
+#include <QDebug>
+#include "utils/wavefrontobj.h"
+#include "lexer-wavefront-obj.h"
+
+
+
+// yylex is a function generated by Flex and we must tell to Bison that it is
+// defined in other place.
+extern int wavefront_objlex(void);
+
+// Bison uses the yyerror function for informing us when a parsing error has
+// occurred.
+void wavefront_objerror(const char *s);
+%}
+
+%define api.prefix {wavefront_obj}
+%define api.token.prefix {TOK_}
+
+// Here we define our custom variable types.
+// Custom types must be of fixed size.
+%union {
+    float number;
+    char* string;
+    void* wavefront;
+}
+
+// Define the terminal expression types.
+%token <float_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
+
+// Define the non-terminal expression types.
+%type <wavefront> wavefront_obj
+
+%%
+
+start: wavefront_obj {
+/*    qDebug() << $1;*/
+};
+
+wavefront_obj: stmt_list {
+                  }
+                ;
+
+
+stmt_list: {}
+            | stmt_list stmt {};
+
+stmt: mtllib {}
+            | usemtl {}
+            | named_object {}
+            | vertex {}
+            | texture_coordinate {}
+            | vertex_normal {}
+            | vertex_space {}
+            | face {}
+            | smooth {};
+
+mtllib: MTLLIB STRING {};
+
+usemtl: USEMTL STRING {};
+
+named_object: O STRING {};
+
+vertex: V NUMBER NUMBER NUMBER {}
+            | V NUMBER NUMBER NUMBER NUMBER {};
+
+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 {};
+
+face_vertex_list: {}
+            | face_vertex_list face_vertex {};
+
+face_vertex: NUMBER {}
+            | NUMBER SLASH NUMBER {}
+            | NUMBER SLASH NUMBER SLASH NUMBER {}
+            | NUMBER SLASH SLASH NUMBER {};
+
+smooth: S NUMBER {}
+            | S STRING {};
+
+%%
+
+void wavefront_objerror(const char *s)
+{
+    qDebug() << "parse error:" << s << "at line" << wavefront_objlineno << "at" << wavefront_objtext;
+}

UGameEngine/utils/wavefrontobj.cpp

@@ -0,0 +1,33 @@
+#include "wavefrontobj.h"
+#include <QFile>
+#include <QDebug>
+#include "lexer-wavefront-obj.h"
+#include "parser-wavefront-obj.h"
+
+WaveFrontObj::WaveFrontObj(QObject *parent) :
+    QObject(parent)
+{
+}
+
+bool WaveFrontObj::openFile(const QString &filename)
+{
+    QFile f(filename);
+    if (f.open(QIODevice::ReadOnly)) {
+        bool res = load(f);
+        f.close();
+        return res;
+    }
+    _error = "Failed to open file: " + f.errorString();
+    return false;
+}
+
+bool WaveFrontObj::load(QIODevice &device)
+{
+    QString file = device.readAll();
+
+    YY_BUFFER_STATE bufferState = wavefront_obj_scan_string(file.toUtf8().constData());
+    int res = wavefront_objparse();
+    wavefront_obj_delete_buffer(bufferState);
+
+    return res == 0;
+}

UGameEngine/utils/wavefrontobj.h

@@ -0,0 +1,28 @@
+#ifndef WAVEFRONTOBJ_H
+#define WAVEFRONTOBJ_H
+
+#include <QObject>
+#include <QIODevice>
+
+class WaveFrontObj : public QObject
+{
+    Q_OBJECT
+public:
+    explicit WaveFrontObj(QObject *parent = 0);
+
+signals:
+
+public slots:
+    bool openFile(const QString& filename);
+    bool load(QIODevice& device);
+
+private:
+    QString _error;
+
+};
+
+struct WaveFrontObjData
+{
+};
+
+#endif // WAVEFRONTOBJ_H