First bbox cache test

include/BoundingBox.h

+/*!
+ * \file include/BoundingBox.h
+ * \brief 3D Axis Aligned Bounding Box
+ *
+ * \author xythobuz
+ */
+
+#ifndef _BOUNDING_BOX_H_
+#define _BOUNDING_BOX_H_
+
+#include <array>
+#include <vector>
+
+class BoundingBox {
+  public:
+    BoundingBox(glm::vec3 min, glm::vec3 max);
+
+    bool inBox(glm::vec3 p);
+    bool inBoxPlane(glm::vec3 p);
+
+    glm::vec3 getCorner(int i) { return corner.at(i); }
+
+    void display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot);
+
+    static void display();
+
+  private:
+    std::array<glm::vec3, 8> corner;
+
+    static std::vector<glm::vec3> vertices, colorsLine, colorsPoint;
+    static std::vector<unsigned short> indicesLine;
+};
+
+#endif
+

include/Room.h

 #include <memory>
 #include <vector>
 
+#include "BoundingBox.h"
 #include "Sprite.h"
 #include "RoomData.h"
 #include "RoomMesh.h"

include/RoomData.h

 #ifndef _ROOM_DATA_H_
 #define _ROOM_DATA_H_
 
-#include <memory>
-#include <vector>
-
-class BoundingBox {
-  public:
-    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 >= corner[0].y) && (p.y <= corner[7].y)
-                && inBoxPlane(p));
-    }
-
-    bool inBoxPlane(glm::vec3 p) {
-        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) {
-        orAssertGreaterThanEqual(i, 0);
-        orAssertLessThan(i, 8);
-        return corner[i];
-    }
-
-    void display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot);
-
-  private:
-    glm::vec3 corner[8];
-};
-
-// --------------------------------------
+#include "BoundingBox.h"
 
 class StaticModel {
   public:

include/config.h.in

 #cmakedefine HAVE_UNISTD_H
 #cmakedefine HAVE_GETCWD
 
+#cmakedefine HAVE_DIRECT_H
+#cmakedefine HAVE__GETCWD
+
 #cmakedefine HAVE_STDLIB_H
 #cmakedefine HAVE_GETENV
 

src/BoundingBox.cpp

+/*!
+ * \file src/BoundingBox.cpp
+ * \brief 3D Axis Aligned Bounding Box
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Camera.h"
+#include "World.h"
+#include "system/Shader.h"
+#include "RoomData.h"
+
+#include <glbinding/gl/gl.h>
+
+std::vector<glm::vec3> BoundingBox::vertices, BoundingBox::colorsLine, BoundingBox::colorsPoint;
+std::vector<unsigned short> BoundingBox::indicesLine;
+
+BoundingBox::BoundingBox(glm::vec3 min, glm::vec3 max) {
+    corner[0] = min;
+    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] = max;
+}
+
+bool BoundingBox::inBox(glm::vec3 p) {
+    return ((p.y >= corner[0].y) && (p.y <= corner[7].y) && inBoxPlane(p));
+}
+
+bool BoundingBox::inBoxPlane(glm::vec3 p) {
+    return ((p.x >= corner[0].x) && (p.x <= corner[7].x) && (p.z >= corner[0].z) && (p.z <= corner[7].z));
+}
+
+void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {
+    auto startSize = vertices.size();
+
+    for (auto& c : corner) {
+        vertices.emplace_back(VP * glm::vec4(c, 1.0f));
+        colorsLine.emplace_back(colorLine);
+        colorsPoint.emplace_back(colorDot);
+    }
+
+    indicesLine.emplace_back(startSize);
+    indicesLine.emplace_back(startSize + 2);
+    indicesLine.emplace_back(startSize + 2);
+    indicesLine.emplace_back(startSize + 4);
+    indicesLine.emplace_back(startSize + 4);
+    indicesLine.emplace_back(startSize + 1);
+    indicesLine.emplace_back(startSize + 1);
+    indicesLine.emplace_back(startSize + 6);
+    indicesLine.emplace_back(startSize + 6);
+    indicesLine.emplace_back(startSize + 7);
+    indicesLine.emplace_back(startSize + 7);
+    indicesLine.emplace_back(startSize + 5);
+    indicesLine.emplace_back(startSize + 5);
+    indicesLine.emplace_back(startSize + 3);
+    indicesLine.emplace_back(startSize + 3);
+    indicesLine.emplace_back(startSize);
+    indicesLine.emplace_back(startSize);
+    indicesLine.emplace_back(startSize + 1);
+    indicesLine.emplace_back(startSize + 1);
+    indicesLine.emplace_back(startSize + 4);
+    indicesLine.emplace_back(startSize + 4);
+    indicesLine.emplace_back(startSize + 7);
+    indicesLine.emplace_back(startSize + 7);
+    indicesLine.emplace_back(startSize + 6);
+    indicesLine.emplace_back(startSize + 6);
+    indicesLine.emplace_back(startSize + 3);
+    indicesLine.emplace_back(startSize + 3);
+    indicesLine.emplace_back(startSize + 5);
+    indicesLine.emplace_back(startSize + 5);
+    indicesLine.emplace_back(startSize + 2);
+}
+
+void BoundingBox::display() {
+    if (vertices.size() > 0) {
+        Shader::drawGL(vertices, colorsLine, indicesLine, glm::mat4(1.0f), gl::GL_LINES);
+        Shader::drawGL(vertices, colorsPoint, glm::mat4(1.0f), gl::GL_POINTS);
+
+        vertices.clear();
+        colorsLine.clear();
+        colorsPoint.clear();
+        indicesLine.clear();
+    }
+}
+

src/CMakeLists.txt

 #################################################################
 
 # Set Source files
+set (SRCS ${SRCS} "BoundingBox.cpp" "../include/BoundingBox.h")
 set (SRCS ${SRCS} "Camera.cpp" "../include/Camera.h")
 set (SRCS ${SRCS} "Console.cpp" "../include/Console.h")
 set (SRCS ${SRCS} "Entity.cpp" "../include/Entity.h")
 check_include_files (unistd.h HAVE_UNISTD_H)
 check_function_exists (getcwd HAVE_GETCWD)
 
+# _getcwd() for current working directory in windows
+check_include_files (direct.h HAVE_DIRECT_H)
+check_function_exists (_getcwd HAVE__GETCWD)
+
 # getenv() for reading environment variables
 check_include_files (stdlib.h HAVE_STDLIB_H)
 check_function_exists (getenv HAVE_GETENV)

src/Entity.cpp

         orAssertGreaterThan(cacheType, -1);
     }
 
-    glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
+    glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
     glm::mat4 rotate;
     if (cacheType == 0) {
         rotate = glm::rotate(glm::mat4(1.0f), Camera::getRotation().x, glm::vec3(0.0f, 1.0f, 0.0f));

src/RoomData.cpp

 #include <glbinding/gl/gl.h>
 #include <glm/gtc/matrix_transform.hpp>
 
-void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {
-    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(colorLine);
-    }
-
-    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);
-
-    Shader::drawGL(verts, cols, inds, VP, gl::GL_LINE_STRIP);
-
-    cols.clear();
-    inds.clear();
-
-    for (int i = 0; i < 8; i++) {
-        cols.push_back(colorDot);
-        inds.push_back(i);
-    }
-
-    Shader::drawGL(verts, cols, inds, VP, gl::GL_POINTS);
-}
-
-// ----------------------------------------------------------------------------
-
 StaticModel::StaticModel(glm::vec3 pos, float angle, int i) : id(i), cache(-1) {
     glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
     glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));

src/main.cpp

 #include <memory>
 
 #include "global.h"
+#include "BoundingBox.h"
 #include "Camera.h"
 #include "Log.h"
 #include "Menu.h"
 
 void renderFrame() {
     Render::display();
+    BoundingBox::display();
     UI::display();
     Window::swapBuffers();
     RunTime::updateFPS();

src/utils/filesystem.cpp

 #include <stdlib.h>
 #endif
 
+#if defined(HAVE_DIRECT_H) && defined(HAVE__GETCWD)
+#include <direct.h>
+#endif
+
 #ifdef _WIN32
 #include <windows.h>
 #include <shlobj.h>
     orAssertEqual(getcwd(path, 1024), path);
     return std::string(path);
 
+#elif defined(HAVE_DIRECT_H) && defined(HAVE__GETCWD)
+
+    char path[1024];
+    orAssertEqual(_getcwd(path, 1024), path);
+    return std::string(path);
+
 #else
 
     orAssert(false);
 }
 
 std::string getHomeDirectory() {
-#if defined(HAVE_STDLIB_H) && defined(HAVE_GETENV)
-
-    char* path = getenv("HOME");
-    orAssert(path != nullptr);
-    return path;
-
-#elif defined(_WIN32)
+#if defined(_WIN32)
 
     char path[MAX_PATH];
     orAssertEqual(SHGetFolderPath(nullptr, CSIDL_PROFILE, nullptr, 0, path), S_OK);
             path[i] = '/';
     return std::string(path);
 
+#elif defined(HAVE_STDLIB_H) && defined(HAVE_GETENV)
+
+    char* path = getenv("HOME");
+    orAssert(path != nullptr);
+    return path;
+
 #else
 
     orAssert(false);