Draw room bounding boxes in wireframe mode

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141228 ]
+    * Room Bounding Boxes are now visualized in Wireframe mode (again)
+
     [ 20141227 ]
     * Added rudimentary SDL2 Game Controller support.
     * Camera now using Quaternion for rotation.

include/Room.h

   public:
     Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f,
          int a, int x, int z)
-       : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f), alternateRoom(a),
-         numXSectors(x), numZSectors(z) { }
+        : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f), alternateRoom(a),
+          numXSectors(x), numZSectors(z) { }
 
     void prepare() { mesh->prepare(); }
     void display(glm::mat4 view, glm::mat4 projection);

include/RoomData.h

 
 class BoundingBox {
   public:
-    BoundingBox(glm::vec3 min, glm::vec3 max) : a(min), b(max) {
-        corner[0] = glm::vec3(a.x, a.y, a.z);
-        corner[1] = glm::vec3(b.x, a.y, a.z);
-        corner[2] = glm::vec3(a.x, b.y, a.z);
-        corner[3] = glm::vec3(a.x, a.y, b.z);
-        corner[4] = glm::vec3(b.x, b.y, a.z);
-        corner[5] = glm::vec3(a.x, b.y, b.z);
-        corner[6] = glm::vec3(b.x, a.y, b.z);
-        corner[7] = glm::vec3(b.x, b.y, b.z);
+    BoundingBox(glm::vec3 min, glm::vec3 max) {
+        corner[0] = glm::vec3(min.x, min.y, min.z);
+        corner[1] = glm::vec3(max.x, min.y, min.z);
+        corner[2] = glm::vec3(min.x, max.y, min.z);
+        corner[3] = glm::vec3(min.x, min.y, max.z);
+        corner[4] = glm::vec3(max.x, max.y, min.z);
+        corner[5] = glm::vec3(min.x, max.y, max.z);
+        corner[6] = glm::vec3(max.x, min.y, max.z);
+        corner[7] = glm::vec3(max.x, max.y, max.z);
     }
 
     bool inBox(glm::vec3 p) {
-        return ((p.y >= a.y) && (p.y <= b.y) && inBoxPlane(p));
+        return ((p.y >= corner[0].y) && (p.y <= corner[7].y)
+                && inBoxPlane(p));
     }
 
     bool inBoxPlane(glm::vec3 p) {
-        return ((p.x >= a.x) && (p.x <= b.x) && (p.z >= a.z) && (p.z <= b.z));
+        return ((p.x >= corner[0].x) && (p.x <= corner[7].x)
+                && (p.z >= corner[0].z) && (p.z <= corner[7].z));
     }
 
     glm::vec3 getCorner(int i) {
         return corner[i];
     }
 
+    void display(glm::mat4 VP, glm::vec3 color);
+
   private:
-    glm::vec3 a, b;
     glm::vec3 corner[8];
 };
 

include/system/Window.h

     static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
                        std::vector<unsigned short>& indices, glm::mat4 MVP);
 
+    static void drawLinesGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                            std::vector<unsigned short>& indices, glm::mat4 MVP);
+
   protected:
     bool mInit;
     bool mFullscreen;

src/Camera.cpp

  * \author xythobuz
  */
 
-#include <limits>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/quaternion.hpp>
 const static float farDist = 75000.0f;
 const static float maxSpeed = 2048.0f;
 const static float controllerViewFactor = 384.0f;
+const static float controllerDeadZone = 0.1f;
 
 const static glm::vec3 rightUnit(1.0f, 0.0f, 0.0f);
 const static glm::vec3 upUnit(0.0f, 1.0f, 0.0f);
 }
 
 void Camera::handleControllerAxis(float value, KeyboardButton axis) {
-    if (glm::epsilonEqual(value, 0.0f, 0.01f))
+    if (glm::epsilonEqual(value, 0.0f, controllerDeadZone))
         value = 0.0f;
 
     if (axis == leftXAxis) {
     float dT = getRunTime().getLastFrameTime();
     pos += quaternion * posSpeed * dT;
 
-    if (glm::epsilonNotEqual(rotSpeed.x, 0.0f, 0.01f))
+    if (glm::epsilonNotEqual(rotSpeed.x, 0.0f, controllerDeadZone))
         quaternion = glm::quat(upUnit * rotationDeltaX * rotSpeed.x * dT) * quaternion;
 
-    if (glm::epsilonNotEqual(rotSpeed.y, 0.0f, 0.01f))
+    if (glm::epsilonNotEqual(rotSpeed.y, 0.0f, controllerDeadZone))
         quaternion = glm::quat(quaternion * -rightUnit * rotationDeltaY * rotSpeed.y * dT) * quaternion;
 
     glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
 
     // Calculate frustum corners to display them
     glm::mat4 inverse = glm::inverse(combo);
-    frustumVertices[NTL] = glm::vec3( 1.0f,  1.0f, 0.0f);
+    frustumVertices[NTL] = glm::vec3(1.0f,  1.0f, 0.0f);
     frustumVertices[NTR] = glm::vec3(-1.0f,  1.0f, 0.0f);
-    frustumVertices[NBL] = glm::vec3( 1.0f, -1.0f, 0.0f);
+    frustumVertices[NBL] = glm::vec3(1.0f, -1.0f, 0.0f);
     frustumVertices[NBR] = glm::vec3(-1.0f, -1.0f, 0.0f);
-    frustumVertices[FTL] = glm::vec3( 1.0f,  1.0f, 1.0f);
+    frustumVertices[FTL] = glm::vec3(1.0f,  1.0f, 1.0f);
     frustumVertices[FTR] = glm::vec3(-1.0f,  1.0f, 1.0f);
-    frustumVertices[FBL] = glm::vec3( 1.0f, -1.0f, 1.0f);
+    frustumVertices[FBL] = glm::vec3(1.0f, -1.0f, 1.0f);
     frustumVertices[FBR] = glm::vec3(-1.0f, -1.0f, 1.0f);
     for (int i = 0; i < 8; i++) {
         glm::vec4 t = inverse * glm::vec4(frustumVertices[i], 1.0f);

src/Mesh.cpp

     assert((ind.size() % 3) == 0);
     assert(vert.size() == tex.size());
     assert(vert.size() == uvs.size());
-    indices = ind;
-    vertices = vert;
-    textures = tex;
+    indices = std::move(ind);
+    vertices = std::move(vert);
+    textures = std::move(tex);
 
     std::vector<unsigned short> indC;
     std::vector<glm::vec3> vertC;
     }
     assert((indC.size() % 3) == 0);
     assert(vertC.size() == col.size());
-    indicesColor = indC;
-    verticesColor = vertC;
-    colors = col;
+    indicesColor = std::move(indC);
+    verticesColor = std::move(vertC);
+    colors = std::move(col);
 }
 
 void Mesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {

src/Room.cpp

     for (auto& m : models) {
         m->display(view, projection);
     }
+
+    if (Render::getMode() == RenderMode::Wireframe)
+        bbox->display(projection * view, glm::vec3(0.0f, 1.0f, 0.0f));
 }
 
 bool Room::isWall(unsigned long sector) {

src/RoomData.cpp

 #include "global.h"
 #include "SkeletalModel.h"
 #include "World.h"
+#include "system/Window.h"
 #include "RoomData.h"
 
+void BoundingBox::display(glm::mat4 VP, glm::vec3 color) {
+    std::vector<glm::vec3> verts;
+    std::vector<glm::vec3> cols;
+    std::vector<unsigned short> inds;
+
+    for (int i = 0; i < 8; i++) {
+        verts.push_back(corner[i]);
+        cols.push_back(color);
+    }
+
+    inds.push_back(0);
+    inds.push_back(2);
+    inds.push_back(4);
+    inds.push_back(1);
+    inds.push_back(6);
+    inds.push_back(7);
+    inds.push_back(5);
+    inds.push_back(3);
+    inds.push_back(0);
+    inds.push_back(1);
+    inds.push_back(4);
+    inds.push_back(7);
+    inds.push_back(6);
+    inds.push_back(3);
+    inds.push_back(5);
+    inds.push_back(2);
+
+    Window::drawLinesGL(verts, cols, inds, VP);
+}
+
+// ----------------------------------------------------------------------------
+
 void StaticModel::display(glm::mat4 view, glm::mat4 projection) {
     if (cache < 0) {
         for (int i = 0; i < getWorld().sizeStaticMesh(); i++) {

src/RoomMesh.cpp

 
     assert((ind.size() % 3) == 0);
 
-    indices = ind;
-    vertices = vert;
-    textures = tex;
+    indices = std::move(ind);
+    vertices = std::move(vert);
+    textures = std::move(tex);
 }
 
 void RoomMesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {

src/system/Window.cpp

     glDisableVertexAttribArray(1);
 }
 
+void Window::drawLinesGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                         std::vector<unsigned short>& indices, glm::mat4 MVP) {
+    assert(vertices.size() == colors.size());
+
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
+    glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), &colors[0], GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(2));
+    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
+
+    colorShader.use();
+
+    glUniformMatrix4fv(colorShader.getUniform(0), 1, GL_FALSE, &MVP[0][0]);
+
+    glEnableVertexAttribArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    glEnableVertexAttribArray(1);
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, colorShader.getBuffer(2));
+
+    glDrawElements(GL_LINE_STRIP, indices.size(), GL_UNSIGNED_SHORT, nullptr);
+
+    glDisableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+}
+
 // ----------------------------------------------------------------------------
 
 Shader::~Shader() {

src/system/WindowSDL.cpp

         return 0;
     }
 
-    SDL_GameControllerAddMapping("341a0000000000000208000000000000,"
-                                 "USB GAMEPAD 8116,"
-                                 "a:b0,x:b2,start:b7,back:b6,leftstick:b8,rightstick:b9,"
-                                 "leftshoulder:b4,rightshoulder:b5,"
-                                 "dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,"
-                                 "leftx:a0,lefty:a1,rightx:a3,righty:a2,"
-                                 "lefttrigger:,b:b1,y:b3,lefttrigger:a4,righttrigger:a4");
+    //! \todo Provide a way for user-defined controller mappings
+    /*
+        SDL_GameControllerAddMapping("341a0000000000000208000000000000,"
+                                     "USB GAMEPAD 8116,"
+                                     "a:b0,x:b2,start:b7,back:b6,leftstick:b8,rightstick:b9,"
+                                     "leftshoulder:b4,rightshoulder:b5,"
+                                     "dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,"
+                                     "leftx:a0,lefty:a1,rightx:a3,righty:a2,"
+                                     "lefttrigger:,b:b1,y:b3,lefttrigger:a4,righttrigger:a4");
+        SDL_GameControllerAddMapping("4c050000000000006802000000000000,"
+                                     "PLAYSTATION(R)3 Controller,"
+                                     "a:b14,b:b13,y:b12,x:b15,start:b3,guide:b16,back:b0,"
+                                     "leftstick:b1,rightstick:b2,leftshoulder:b10,"
+                                     "rightshoulder:b11,dpup:b4,dpleft:b7,dpdown:b6,dpright:b5,"
+                                     "leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b8,righttrigger:b9");
+    */
 
     for (int i = 0; i < SDL_NumJoysticks(); i++) {
         if (SDL_IsGameController(i)) {