Room Mesh displayed more or less correctly

ChangeLog.md

 
     [ 20141216 ]
     * Allow navigation with a free-floating Camera
-    * Started drawing the Room Mesh structures
+    * Room Meshes are displayed more or less correctly
 
     [ 20141215 ]
     * Rewrote GL code for the Font implementations, ImGUI and the Main Menu

include/Camera.h

 
     static float getRadianPitch() { return thetaX; }
     static float getRadianYaw() { return thetaY; }
+    static void setRadianPitch(float x) { thetaX = x; }
 
     static void setPosition(glm::vec3 p) { pos = p; }
     static glm::vec3 getPosition() { return pos; }

include/TextureManager.h

 class TextureTile {
   public:
     TextureTile(unsigned int a, unsigned int t) : attribute(a), texture(t) { }
+    void add(TextureTileVertex t) { vertices.push_back(t); }
 
     unsigned int getTexture() { return texture; }
-    glm::vec2 getUV(unsigned int i) { return glm::vec2(vertices.at(i).xPixel, vertices.at(i).yPixel); }
-    void add(TextureTileVertex t) { vertices.push_back(t); }
+    glm::vec2 getUV(unsigned int i) { return glm::vec2(vertices.at(i).xPixel / 255.0f,
+                                                       vertices.at(i).yPixel / 255.0f); }
 
   private:
     unsigned int attribute;

src/Camera.cpp

 #include "Camera.h"
 
 glm::vec3 Camera::pos(0.0f, 0.0f, 0.0f);
-float Camera::thetaX = glm::pi<float>();
+float Camera::thetaX = 0.0f;
 float Camera::thetaY = 0.0f;
 float Camera::rotationDeltaX = 0.75f;
 float Camera::rotationDeltaY = 0.75f;
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
-    thetaX = glm::pi<float>();
+    thetaX = 0.0f;
     thetaY = 0.0f;
 }
 
     } else if (action == backwardAction) {
         pos -= dir * step;
     } else if (action == leftAction) {
-        pos -= right * step;
-    } else if (action == rightAction) {
         pos += right * step;
+    } else if (action == rightAction) {
+        pos -= right * step;
     } else if (action == jumpAction) {
         pos += up * step;
     } else if (action == crouchAction) {
 
 void Camera::handleMouseMotion(int x, int y) {
     while (x > 0) {
-        if (thetaX < (glm::pi<float>() / 2.0f)) {
-            thetaX += rotationDeltaX;
-        }
+        thetaX += rotationDeltaX;
         x--;
     }
     while (x < 0) {
-        if (thetaX > -(glm::pi<float>() / 2.0f)) {
-            thetaX -= rotationDeltaX;
-        }
+        thetaX -= rotationDeltaX;
         x++;
     }
     while (y > 0) {
-        if (thetaY < (glm::pi<float>() / 2.0f)) {
-            thetaY += rotationDeltaY;
+        if (thetaY > -(glm::pi<float>() / 2.0f)) {
+            thetaY -= rotationDeltaY;
         }
         y--;
     }
     while (y < 0) {
-        if (thetaY > -(glm::pi<float>() / 2.0f)) {
-            thetaY -= rotationDeltaY;
+        if (thetaY < (glm::pi<float>() / 2.0f)) {
+            thetaY += rotationDeltaY;
         }
         y++;
     }
+
+    while (thetaX > (glm::pi<float>() * 2.0f))
+        thetaX -= glm::pi<float>() * 2.0f;
+
+    while (thetaX < -(glm::pi<float>() * 2.0f))
+        thetaX += glm::pi<float>() * 2.0f;
 }
 
 glm::mat4 Camera::getViewMatrix() {

src/Game.cpp

         } else {
             mLoaded = true;
             Render::setMode(RenderMode::Texture);
+
+            Camera::setPosition(glm::vec3(getLara().getPos(0),
+                                          getLara().getPos(1) + 1024.0f,
+                                          getLara().getPos(2)));
         }
     } else {
         getLog() << "No suitable loader for this level!" << Log::endl;

src/Mesh.cpp

         }
 
         if (indices.at(i) == 0) {
-            ind.push_back(ind.at(ind.size() - 1));
-            ind.push_back(ind.at(ind.size() - 3));
+            ind.push_back(ind.at(ind.size() - 2));
+            ind.push_back(ind.at(ind.size() - 5));
         }
 
         vertIndex += (indices.at(i) == 0) ? 4 : 3;
     indices = ind;
     vertices = vert;
     textures = tex;
+
+    assert((indices.size() % 3) == 0);
 }
 
 void Mesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
     glm::mat4 MVP = projection * view * model;
 
-    // TODO handle different textures!
+    unsigned int indexStart = 0;
+    unsigned int indexPos = 1;
+    unsigned int texture = textures.at(indices.at(0));
+
+    while ((indexStart != indexPos) && (indexPos < indices.size())) {
+        while ((indexPos < indices.size()) && (textures.at(indices.at(indexPos)) == texture))
+            indexPos++;
+
+        std::vector<unsigned short> ind(indices.begin() + indexStart, indices.begin() + indexPos);
+        Window::drawGL(vertices, uvs, ind, MVP, texture);
 
-    Window::drawGL(vertices, uvs, indices, MVP, textures.at(0));
+        if (indexPos < indices.size()) {
+            indexStart = indexPos;
+            indexPos += 1;
+            texture = textures.at(indices.at(indexStart));
+        }
+    }
 }
 

src/Render.cpp

             break;
         case RenderMode::Solid:
         case RenderMode::Wireframe:
-            glClearColor(PURPLE[0] / 256.0f, PURPLE[1] / 256.0f,
-                         PURPLE[2] / 256.0f, PURPLE[3] / 256.0f);
+            //glClearColor(PURPLE[0] / 256.0f, PURPLE[1] / 256.0f,
+            //             PURPLE[2] / 256.0f, PURPLE[3] / 256.0f);
             //glDisable(GL_TEXTURE_2D);
             break;
         default:
-            glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f,
-                         BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+            //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f,
+            //             BLACK[2] / 256.0f, BLACK[3] / 256.0f);
             //glEnable(GL_TEXTURE_2D);
+            break;
     }
 }
 
     }
 
     glm::mat4 view = Camera::getViewMatrix();
-    glm::mat4 projection = glm::perspective(45.0f, // Field of View
-                                            (float)getWindow().getWidth() / (float)getWindow().getHeight(),
-                                            0.1f, // Min Distance
-                                            100000.0f); // Max Distance
+
+    static unsigned int w = getWindow().getWidth();
+    static unsigned int h = getWindow().getHeight();
+    static glm::mat4 projection = glm::perspective(45.0f, // Field of View
+                                                   (float)getWindow().getWidth()
+                                                 / (float)getWindow().getHeight(),
+                                                   0.1f, // Min Distance
+                                                   100000.0f); // Max Distance
+
+    if ((w != getWindow().getWidth()) || (h != getWindow().getHeight())) {
+        w = getWindow().getWidth();
+        h = getWindow().getHeight();
+        glm::mat4 projection = glm::perspective(45.0f, // Field of View
+                                                (float)getWindow().getWidth() / (float)getWindow().getHeight(),
+                                                0.1f, // Min Distance
+                                                100000.0f); // Max Distance
+    }
 
     // Just draw all rooms, as a test
     for (int i = 0; i < getWorld().sizeRoom(); i++)

src/system/Window.cpp

 	glBindVertexArray(vertexArrayID);
 
     // Set background to black
-    glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+    //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+    glClearColor(0.0f, 0.0f, 0.4f, 1.0f);
 
     // Set up Z buffer
     glEnable(GL_DEPTH_TEST);
 uniform mat4 MVP;
 
 void main() {
-    gl_Position = MVP * vec4(vertexPosition_modelspace, 1);
+    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
+                          -vertexPosition_modelspace.y,
+                          vertexPosition_modelspace.z,
+                          1);
+    gl_Position = vec4(-pos.x, pos.yzw);
     UV = vertexUV;
 }
 )!?!";