textured cube

TheGame/openglrenderdevice.cpp

 #include "openglrenderdevice.h"
+#include <QRgb>
 #include "GL/gl.h"
 #include "GL/glu.h"
 
     return Vector3D(gx, gy, gz);
 }
 
+void OpenGLRenderDevice::loadTexture(const QVariant &id, const QImage &texture)
+{
+    OpenGLTextureData data;
+    data.id = 0;
+    data.image = texture;
+    data.rawData = new char[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;
+        }
+    }
+
+
+    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);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+    _textures.insert(id, data);
+}
+
 void OpenGLRenderDevice::initialize(int fov, int width, int height)
 {
     _fov = fov;
     glClearColor(_clearColor.redF(), _clearColor.greenF(),
                  _clearColor.blueF(), _clearColor.alphaF());
 
+//    glShadeModel(GL_SMOOTH);
+//    glBlendFunc (GL_SRC_ALPHA_SATURATE, GL_ONE);
+//    glColorMaterial(GL_FRONT,GL_SPECULAR);
+//    glCullFace(GL_BACK);
+
+//    glEnable(GL_LIGHTING);
+//    glEnable(GL_LIGHT0);
+//    glEnable(GL_COLOR_MATERIAL);
+//    glEnable(GL_CULL_FACE);
+    glEnable(GL_TEXTURE_2D);
+
+//    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+
 
 //    GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0};  /* Red diffuse light. */
 //    GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};  /* Infinite light location. */
 //    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, light_diffuse);
 //    glEnable(GL_LIGHT0);
 //    glEnable(GL_LIGHTING);
-    glDisable(GL_LIGHTING);
 
     glEnable(GL_DEPTH_TEST);
+//    glDisable(GL_BLEND);
+//    glDisable(GL_POLYGON_SMOOTH);
+//    glEnable(GL_TEXTURE_2D);
+//    glColorMaterial(GL_FRONT,GL_SPECULAR);
+//    glEnable(GL_COLOR_MATERIAL);
+//    glEnable(GL_CULL_FACE);
 
     glMatrixMode(GL_PROJECTION);
     gluPerspective(_fov, _width / _height, 0.1, 100.0);
     }
     glEnd();
 }
+
+void OpenGLRenderDevice::drawPolygonTexture(const QList<TextureVector3D> &points, const QVariant &textureId)
+{
+    const OpenGLTextureData& data = _textures[textureId];
+    glBindTexture(GL_TEXTURE_2D, data.id);
+    glBegin(GL_POLYGON);
+    for (int i = 0; i < points.size(); ++i) {
+        TextureVector3D p = points[i];
+        glTexCoord2d(p.getTextureCoord().getX(), p.getTextureCoord().getY());
+        drawVertex(p);
+    }
+    glEnd();
+}

TheGame/openglrenderdevice.h

 
 #include "engine/abstractrenderdevice.h"
 
+struct OpenGLTextureData
+{
+    unsigned id;
+    QImage image;
+    char* rawData;
+};
+
 class OpenGLRenderDevice : public AbstractRenderDevice
 {
     Q_OBJECT
 
 public slots:
 
+    virtual void loadTexture(const QVariant& id, const QImage& texture);
+
     virtual void initialize(int fov, int width, int height);
 
     virtual void resize(int width, int height);
 
     virtual void drawPolygon(const QList<ColorVector3D>& points);
 
+    virtual void drawPolygonTexture(const QList<TextureVector3D>& points, const QVariant& textureId);
+
 private:
     int _width;
 
 
     int _fov;
 
+    QMap<QVariant, OpenGLTextureData> _textures;
+
 };
 
 #endif // OPENGLRENDERDEVICE_H

TheGame/renderwidget.cpp

 {
     _device = new OpenGLRenderDevice(this);
     _engine = new UGameEngine(_device);
+
     UGEEntityCube* cube = new UGEEntityCube(_engine);
+    cube->setTextureId("test");
 //    cube->move(Vector3D(0, 1, 0));
-    cube->hide();
+//    cube->hide();
     _engine->addEntity(cube);
     _engine->addEntity(new UGEEntityAxes(_engine));
     setMouseTracking(true);
 
     UGEEntityWaveFrontObj* obj = new UGEEntityWaveFrontObj(wavefrontObj, this);
     _engine->addEntity(obj);
-//    obj->hide();
+    obj->hide();
 
 }
 
     _device->setClearColor(Qt::gray);
     _device->initialize(70, width(), height());
 
+    _device->loadTextureFromFile("test", "/home/robin/Downloads/test.png");
 }
 
 void RenderWidget::paintGL()
                 );
     _device->lookAt(center, Vector3D(0.0f, 0.0f, 0.0f));
     _engine->draw();
-    _device->drawLine(ColorVector3D(Qt::black, 0, 0, 0), ColorVector3D(Qt::black, pos));
-    _device->drawPoint(ColorVector3D(Qt::magenta, 0.5, 0.5, 0.5));
+//    _device->drawLine(ColorVector3D(Qt::black, 0, 0, 0), ColorVector3D(Qt::black, pos));
+//    _device->drawPoint(ColorVector3D(Qt::magenta, 0.5, 0.5, 0.5));
 }
 
 void RenderWidget::resizeGL(int width, int height)

UGameEngine/engine/abstractrenderdevice.cpp

     _lookUp = up;
 }
 
-//void AbstractRenderDevice::loadTextureFromFile(const QVariant &id, const QString &filename)
-//{
-//    QImage img;
-//    if (img.load(filename)) {
-//        loadTexture(id, img);
-//    }
-//}
+void AbstractRenderDevice::loadTextureFromFile(const QVariant &id, const QString &filename)
+{
+    QImage img;
+    if (img.load(filename)) {
+        loadTexture(id, img);
+    }
+}
 
 QColor AbstractRenderDevice::getClearColor() const
 {

UGameEngine/engine/abstractrenderdevice.h

 
 #include <QObject>
 #include <QColor>
+#include <QImage>
 #include "utils/colorvector3d.h"
+#include "utils/texturevector3d.h"
 
 class AbstractRenderDevice : public QObject
 {
 
     virtual void lookAt(const Vector3D& eye, const Vector3D& center, const Vector3D& up = Vector3D(0.0, 1.0, 0.0));
 
-//    void loadTextureFromFile(const QVariant& id, const QString& filename);
+    void loadTextureFromFile(const QVariant& id, const QString& filename);
 
-//    virtual void loadTexture(const QVariant& id, const QImage& texture) = 0;
+    virtual void loadTexture(const QVariant& id, const QImage& texture) = 0;
 
     virtual void initialize(int fov, int width, int height) = 0;
 
 
     virtual void drawPolygon(const QList<ColorVector3D>& points) = 0;
 
-//    virtual void drawPolygonTexture(const QList<ColorVector3D>& points) = 0;
+    virtual void drawPolygonTexture(const QList<TextureVector3D>& points, const QVariant& textureId) = 0;
 
 protected:
     QColor _clearColor;

UGameEngine/entities/ugeentity.cpp

     return ColorVector3D(pos.getColor(), getRealPoint((Vector3D)pos));
 }
 
+TextureVector3D UGEEntity::getRealPoint(const TextureVector3D &pos)
+{
+    return TextureVector3D(pos.getTextureCoord(), getRealPoint((ColorVector3D)pos));
+}
+
 void UGEEntity::drawPoint(AbstractRenderDevice *device, const ColorVector3D &point)
 {
     device->drawPoint(getRealPoint(point));
     }
     device->drawPolygon(points);
 }
+
+void UGEEntity::drawPolygonTexture(AbstractRenderDevice *device, QList<TextureVector3D> points, const QVariant &textureId)
+{
+    for (int i = 0; i < points.size(); ++i) {
+        points[i] = getRealPoint(points[i]);
+    }
+    device->drawPolygonTexture(points, textureId);
+}

UGameEngine/entities/ugeentity.h

 
     Vector3D getRealPoint(const Vector3D& pos);
     ColorVector3D getRealPoint(const ColorVector3D& pos);
+    TextureVector3D getRealPoint(const TextureVector3D& pos);
 
     virtual void drawPoint(AbstractRenderDevice* device, const ColorVector3D& point);
 
 
     virtual void drawPolygon(AbstractRenderDevice* device, QList<ColorVector3D> points);
 
+    virtual void drawPolygonTexture(AbstractRenderDevice *device, QList<TextureVector3D> points, const QVariant& textureId);
+
     virtual void draw(AbstractRenderDevice* device) = 0;
 
 private:

UGameEngine/entities/ugeentitycube.cpp

 
 void UGEEntityCube::draw(AbstractRenderDevice *device)
 {
-    QColor color = Qt::red;
     float r = _size / 2;
-    QList<ColorVector3D> points;
-    points << ColorVector3D(color, -r, -r, r) << ColorVector3D(color, -r, r, r) << ColorVector3D(color, r, r, r) << ColorVector3D(color, r, -r, r);
-    points << ColorVector3D(color, -r, -r, -r) << ColorVector3D(color, -r, r, -r) << ColorVector3D(color, r, r, -r) << ColorVector3D(color, r, -r, -r);
-    drawPolygon(device, QList<ColorVector3D>() << points[3] << points[2] << points[1] << points[0]);
-    drawPolygon(device, QList<ColorVector3D>() << points[2] << points[3] << points[7] << points[6]);
-    drawPolygon(device, QList<ColorVector3D>() << points[6] << points[7] << points[4] << points[5]);
-    drawPolygon(device, QList<ColorVector3D>() << points[5] << points[4] << points[0] << points[1]);
-    drawPolygon(device, QList<ColorVector3D>() << points[1] << points[2] << points[6] << points[5]);
-    drawPolygon(device, QList<ColorVector3D>() << points[4] << points[7] << points[3] << points[0]);
+    if (_textureId.isNull()) {
+        QColor color = Qt::red;
+        QList<ColorVector3D> points;
+        points << ColorVector3D(color, -r, -r, r)  << ColorVector3D(color, -r, r, r)
+               << ColorVector3D(color, r, r, r)    << ColorVector3D(color, r, -r, r)
+               << ColorVector3D(color, -r, -r, -r) << ColorVector3D(color, -r, r, -r)
+               << ColorVector3D(color, r, r, -r)   << ColorVector3D(color, r, -r, -r);
+        drawPolygon(device, QList<ColorVector3D>() << points[3] << points[2] << points[1] << points[0]);
+        drawPolygon(device, QList<ColorVector3D>() << points[2] << points[3] << points[7] << points[6]);
+        drawPolygon(device, QList<ColorVector3D>() << points[6] << points[7] << points[4] << points[5]);
+        drawPolygon(device, QList<ColorVector3D>() << points[5] << points[4] << points[0] << points[1]);
+        drawPolygon(device, QList<ColorVector3D>() << points[1] << points[2] << points[6] << points[5]);
+        drawPolygon(device, QList<ColorVector3D>() << points[4] << points[7] << points[3] << points[0]);
+    }
+    else {
+        QColor color = Qt::white;
+        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), color, r, -r, r)
+                           << TextureVector3D(Vector2D(0.25, 0.25), color, r, r, r)
+                           << TextureVector3D(Vector2D(0.00, 0.25), color, -r, r, r)
+                           << TextureVector3D(Vector2D(0.00, 0.50), color, -r, -r, r), _textureId);
+        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), color, r, r, r)
+                           << TextureVector3D(Vector2D(0.25, 0.25), color, r, -r, r)
+                           << TextureVector3D(Vector2D(0.50, 0.25), color, r, -r, -r)
+                           << TextureVector3D(Vector2D(0.50, 0.50), color, r, r, -r), _textureId);
+        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.50, 0.25), color, r, r, -r)
+                           << TextureVector3D(Vector2D(0.50, 0.50), color, r, -r, -r)
+                           << TextureVector3D(Vector2D(0.75, 0.50), color, -r, -r, -r)
+                           << TextureVector3D(Vector2D(0.75, 0.25), color, -r, r, -r), _textureId);
+        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.75, 0.25), color, -r, r, -r)
+                           << TextureVector3D(Vector2D(0.75, 0.50), color, -r, -r, -r)
+                           << TextureVector3D(Vector2D(1.00, 0.50), color, -r, -r, r)
+                           << TextureVector3D(Vector2D(1.00, 0.25), color, -r, r, r), _textureId);
+        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.00), color, -r, r, r)
+                           << TextureVector3D(Vector2D(0.25, 0.25), color, r, r, r)
+                           << TextureVector3D(Vector2D(0.50, 0.25), color, r, r, -r)
+                           << TextureVector3D(Vector2D(0.50, 0.00), color, -r, r, -r), _textureId);
+        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.50, 0.75), color, -r, -r, -r)
+                           << TextureVector3D(Vector2D(0.50, 0.50), color, r, -r, -r)
+                           << TextureVector3D(Vector2D(0.25, 0.5), color, r, -r, r)
+                           << TextureVector3D(Vector2D(0.25, 0.75), color, -r, -r, r), _textureId);
+    }
+}
+
+QVariant UGEEntityCube::getTextureId() const
+{
+    return _textureId;
 }
 
 void UGEEntityCube::setSize(float size)
     _size = size;
 }
 
+void UGEEntityCube::setTextureId(const QVariant &textureId)
+{
+    _textureId = textureId;
+}
+
+

UGameEngine/entities/ugeentitycube.h

 
     virtual void draw(AbstractRenderDevice* device);
 
+    QVariant getTextureId() const;
+
 signals:
 
 public slots:
     void setSize(float size);
+    void setTextureId(const QVariant &textureId);
 
 private:
     float _size;
+    QVariant _textureId;
 
 };
 

UGameEngine/utils/colorvector3d.cpp

 #include "colorvector3d.h"
 
-ColorVector3D::ColorVector3D(QColor color, double x, double y, double z)
+ColorVector3D::ColorVector3D()
+    : Vector3D(0.0, 0.0, 0.0)
+    , _color(Qt::black)
+{
+}
+
+ColorVector3D::ColorVector3D(const QColor &color)
+    : Vector3D(0.0, 0.0, 0.0)
+    , _color(color)
+{
+}
+
+ColorVector3D::ColorVector3D(const QColor &color, double x, double y, double z)
     : Vector3D(x, y, z)
     , _color(color)
 {
 }
 
-ColorVector3D::ColorVector3D(QColor color, const Vector3D &other)
+ColorVector3D::ColorVector3D(const QColor& color, const Vector3D &other)
     : Vector3D(other)
     , _color(color)
 {

UGameEngine/utils/colorvector3d.h

 class ColorVector3D : public Vector3D
 {
 public:
-    ColorVector3D(QColor color = Qt::black, double x = 0.0, double y = 0.0, double z = 0.0);
-    ColorVector3D(QColor color = Qt::black, const Vector3D& other = Vector3D());
+    ColorVector3D();
+    ColorVector3D(const QColor& color);
+    ColorVector3D(const QColor& color, double x, double y, double z);
+    ColorVector3D(const QColor& color, const Vector3D& other);
     ColorVector3D(const ColorVector3D& other);
     virtual ~ColorVector3D();
 

UGameEngine/utils/parser-wavefront-obj.y

 face: F face_vertex_list { $$ = $2; };
 
 face_vertex_list: { $$ = new QList<int>(); }
-            | face_vertex_list face_vertex { $1->append($2); };
+            | face_vertex_list face_vertex { $1->append($2); $$ = $1;};
 
 face_vertex: NUMBER { $$ = $1; }
             | NUMBER SLASH NUMBER { $$ = $1; }

UGameEngine/utils/texturevector3d.cpp

 #include "texturevector3d.h"
 
+TextureVector3D::TextureVector3D()
+    : ColorVector3D(Qt::white, 0.0, 0.0, 0.0)
+    , _textureCoord(0.0, 0.0)
+{
+}
+
+TextureVector3D::TextureVector3D(const Vector2D &textureCoord)
+    : ColorVector3D(Qt::white, 0.0, 0.0, 0.0)
+    , _textureCoord(textureCoord)
+{
+}
+
+TextureVector3D::TextureVector3D(const Vector2D &textureCoord, const QColor &color)
+    : ColorVector3D(color, 0.0, 0.0, 0.0)
+    , _textureCoord(textureCoord)
+{
+}
+
+TextureVector3D::TextureVector3D(const Vector2D &textureCoord, const QColor &color, double x, double y, double z)
+    : ColorVector3D(color, x, y, z)
+    , _textureCoord(textureCoord)
+{
+}
+
+TextureVector3D::TextureVector3D(const Vector2D &textureCoord, const QColor& color, const Vector3D &other)
+    : ColorVector3D(color, other)
+    , _textureCoord(textureCoord)
+{
+}
+
+TextureVector3D::TextureVector3D(const Vector2D &textureCoord, const ColorVector3D &other)
+    : ColorVector3D(other)
+    , _textureCoord(textureCoord)
+{
+}
+
+TextureVector3D::TextureVector3D(const TextureVector3D &other)
+    : ColorVector3D(other)
+    , _textureCoord(other._textureCoord)
+{
+}
+
 TextureVector3D::~TextureVector3D()
 {
 }
+
+Vector2D TextureVector3D::getTextureCoord() const
+{
+    return _textureCoord;
+}
+
+void TextureVector3D::setTextureCoord(const Vector2D &textureCoord)
+{
+    _textureCoord = textureCoord;
+}

UGameEngine/utils/texturevector3d.h

 #define TEXTUREVECTOR3D_H
 
 #include "colorvector3d.h"
+#include "vector2d.h"
 
 class TextureVector3D : public ColorVector3D
 {
 public:
-    TextureVector3D(QColor color = Qt::white, double x = 0.0, double y = 0.0, double z = 0.0);
-    TextureVector3D(QColor color = Qt::white, const Vector3D& other = Vector3D());
-    TextureVector3D(const ColorVector3D& other);
+    TextureVector3D();
+    TextureVector3D(const Vector2D& textureCoord);
+    TextureVector3D(const Vector2D& textureCoord, const QColor& color);
+    TextureVector3D(const Vector2D& textureCoord, const QColor& color, double x, double y, double z);
+    TextureVector3D(const Vector2D& textureCoord, const QColor& color, const Vector3D& other);
+    TextureVector3D(const Vector2D& textureCoord, const ColorVector3D& other);
+    TextureVector3D(const TextureVector3D& other);
     virtual ~TextureVector3D();
+
+    Vector2D getTextureCoord() const;
+    void setTextureCoord(const Vector2D &textureCoord);
+
+private:
+    Vector2D _textureCoord;
 };
 
 #endif // TEXTUREVECTOR3D_H