New vis check (work in progress)

CMakeLists.txt

         WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
         COMMENT "Auto-Formatting code..." VERBATIM
     )
+
+    #################################################################
+
+    # Count source code lines
+    add_custom_target (count
+        COMMAND cloc --exclude-dir=deps,cmake,data,build ${PROJECT_SOURCE_DIR}
+        COMMENT "Counting lines of source code..." VERBATIM
+    )
+
+    add_custom_target (countFull
+        COMMAND cloc --exclude-dir=build ${PROJECT_SOURCE_DIR}
+        COMMENT "Counting lines of source code..." VERBATIM
+    )
 endif (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
 

include/Render.h

     static bool getDisplayViewFrustum() { return displayViewFrustum; }
 
   private:
-    static void buildRoomList(int room = -2, int budget = 10);
+    static void buildRoomList(glm::mat4 VP, int room = -2,
+                              glm::vec2 min = glm::vec2(-1.0f, -1.0f),
+                              glm::vec2 max = glm::vec2(1.0f, 1.0f));
 
     static RenderMode mode;
     static std::vector<Room*> roomList;

include/RoomData.h

 
 class Portal {
   public:
-    Portal(int adj, glm::vec3 n, glm::vec3 v1, glm::vec3 v2, glm::vec3 v3,
-           glm::vec3 v4) : adjoiningRoom(adj), normal(n), bbox(v1, v3) {
-        vert[0] = v1; vert[1] = v2;
-        vert[2] = v3; vert[3] = v4;
-    }
+    Portal(int adj, glm::vec3 n,
+           glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, glm::vec3 v4);
 
     int getAdjoiningRoom() { return adjoiningRoom; }
     glm::vec3 getNormal() { return normal; }
     int adjoiningRoom;
     glm::vec3 normal;
     glm::vec3 vert[4];
-    BoundingBox bbox;
+    BoundingBox bbox, bboxNormal;
 
     static bool showBoundingBox;
 };

src/Camera.cpp

 static std::vector<glm::vec3> colorPointBuffer;
 
 void Camera::calculateFrustumPlanes() {
+    vertexBuffer.clear();
+    vertexPointBuffer.clear();
+    colorPointBuffer.clear();
+
     glm::mat4 combo = projection * view;
 
     // Calculate frustum corners to display them

src/Render.cpp

         gl::glPolygonMode(gl::GL_FRONT_AND_BACK, gl::GL_FILL);
     }
 
-    if (Camera::update()) {
+    bool updated = Camera::update();
+    glm::mat4 projection = Camera::getProjectionMatrix();
+    glm::mat4 view = Camera::getViewMatrix();
+    glm::mat4 VP = projection * view;
+
+    //if (updated) {
         int r = Camera::getRoom();
         clearRoomList();
         if (r < 0) {
-            buildRoomList();
+            buildRoomList(VP);
         } else {
-            buildRoomList(r);
+            buildRoomList(VP, r);
         }
-    }
-
-    glm::mat4 projection = Camera::getProjectionMatrix();
-    glm::mat4 view = Camera::getViewMatrix();
-    glm::mat4 VP = projection * view;
+    //}
 
     for (int r = roomList.size() - 1; r >= 0; r--) {
         roomList.at(r)->display(VP);
     }
 }
 
-void Render::buildRoomList(int room, int budget) {
+void Render::buildRoomList(glm::mat4 VP, int room, glm::vec2 min, glm::vec2 max) {
     if (room < -1) {
         // Check if the camera currently is in a room...
         for (int i = 0; i < World::sizeRoom(); i++) {
             if (World::getRoom(i).getBoundingBox().inBox(Camera::getPosition())) {
-                buildRoomList(i, budget);
+                buildRoomList(VP, i);
                 return;
             }
         }
-        buildRoomList(-1, budget);
+        buildRoomList(VP, -1);
     } else if (room == -1) {
         // Check visibility for all rooms!
         for (int i = 0; i < World::sizeRoom(); i++) {
             }
         }
     } else {
-        // Check visibility of room and connected rooms, recursively
+        // Check if this room is visible
         if (Camera::boxInFrustum(World::getRoom(room).getBoundingBox())) {
             roomList.push_back(&World::getRoom(room));
+
+            // Display the visibility test for the portal to this room
+            BoundingBox debugBox(glm::vec3(min, 0.0f), glm::vec3(max, 0.0f));
+            debugBox.display(glm::mat4(1.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+
+            ImGui::Text("   Min: %.3f %.3f", min.x, min.y);
+            ImGui::Text("   Max: %.3f %.3f", max.x, max.y);
+
+            // Check all portals leading from this room to somewhere else
             for (int i = 0; i < World::getRoom(room).sizePortals(); i++) {
                 auto& portal = World::getRoom(room).getPortal(i);
 
-                // Check if portal is visible / can be seen through
-                bool visible = Camera::boxInFrustum(portal.getBoundingBox());
-                if (!visible) {
+                // Calculate the 2D window of this portal
+                glm::vec2 newMin, newMax;
+                bool inited = false;
+                for (int c = 0; c < 4; c++) {
+                    glm::vec3 vert = portal.getVertex(c);
+                    glm::vec4 result = VP * glm::vec4(vert, 1.0f);
+                    vert = glm::vec3(result) / result.w;
+
+                    ImGui::Text("Test %d: %.3f %.3f", c, vert.x, vert.y);
+
+                    if (!inited) {
+                        newMin = glm::vec2(vert);
+                        newMax = glm::vec2(vert);
+                        inited = true;
+                    } else {
+                        if (vert.x < newMin.x)
+                            newMin.x = vert.x;
+                        if (vert.y < newMin.y)
+                            newMin.y = vert.y;
+                        if (vert.x > newMax.x)
+                            newMax.x = vert.x;
+                        if (vert.y > newMax.y)
+                            newMax.y = vert.y;
+                    }
+                }
+
+                // Check if the portal intersects the portal leading into this room
+                if (!((min.x < newMax.x) && (max.x > newMin.x)
+                    && (min.y < newMax.y) && (max.y > newMin.y))) {
+                    ImGui::Text("Invisible!");
                     continue;
+                } else {
+                    ImGui::Text("Visible!");
                 }
 
-                // Check if already in list...
+                // Check if this room is already in the list...
                 bool found = false;
                 for (int n = 0; n < roomList.size(); n++) {
                     if (roomList.at(n) == &World::getRoom(portal.getAdjoiningRoom())) {
                     }
                 }
 
-                // ...only render if not
+                // ...only render it if it is not
                 if (!found) {
-                    if (budget > 0) {
-                        buildRoomList(portal.getAdjoiningRoom(), --budget);
-                    }
+                    buildRoomList(VP, portal.getAdjoiningRoom(), newMin, newMax);
                 }
             }
         }

src/RoomData.cpp

 
 bool Portal::showBoundingBox = false;
 
+Portal::Portal(int adj, glm::vec3 n, glm::vec3 v1, glm::vec3 v2, glm::vec3 v3,
+               glm::vec3 v4) : adjoiningRoom(adj), normal(n), bbox(v1, v3),
+                               bboxNormal(v1 + ((v3 - v1) / 2.0f),
+                                          v1 + ((v3 - v1) / 2.0f)
+                                             + (normal * 1024.0f)) {
+    vert[0] = v1; vert[1] = v2;
+    vert[2] = v3; vert[3] = v4;
+}
+
 void Portal::display(glm::mat4 VP) {
     if (showBoundingBox) {
         bbox.display(VP, glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+        bboxNormal.display(VP, glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(1.0f, 0.0f, 0.0f));
     }
 }
 

src/loader/LoaderTR2.cpp

             int16_t yCorner4 = file.read16();
             int16_t zCorner4 = file.read16();
 
-            // TODO translate vertices by room offset!
-
             portals.push_back(new Portal(adjoiningRoom,
-                                         glm::vec3(xNormal, yNormal, zNormal) + pos,
+                                         glm::vec3(xNormal, yNormal, zNormal),
                                          glm::vec3(xCorner1, yCorner1, zCorner1) + pos,
                                          glm::vec3(xCorner2, yCorner2, zCorner2) + pos,
                                          glm::vec3(xCorner3, yCorner3, zCorner3) + pos,

src/system/Shader.cpp

 
 void Shader::use() {
     orAssert(programID >= 0);
-    gl::glUseProgram(programID);
+    static int lastID = -1;
+    if (programID != lastID) {
+        gl::glUseProgram(programID);
+        lastID = programID;
+    }
 }
 
 int Shader::compile(const char* vertex, const char* fragment) {
 void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
                     glm::mat4 MVP, unsigned int texture, TextureStorage store,
                     gl::GLenum mode, ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.size() == uvs.size());
-    if (mode == gl::GL_TRIANGLES)
-        orAssert((vertices.size() % 3) == 0);
     bindProperBuffer(target);
 
     shader.use();
 }
 
 void Shader::drawGLBuffer(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs, Shader& shader) {
-    orAssert(vertices.size() == uvs.size());
-
     shader.vertexBuffer.bufferData(vertices);
     shader.otherBuffer.bufferData(uvs);
 }
 void Shader::drawGLOnly(std::vector<unsigned short>& indices, glm::mat4 MVP,
                         unsigned int texture, TextureStorage store,
                         gl::GLenum mode, ShaderTexture* target, Shader& shader) {
-    if (mode == gl::GL_TRIANGLES)
-        orAssert((indices.size() % 3) == 0);
     bindProperBuffer(target);
 
     shader.use();
 
 void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
                     glm::mat4 MVP, gl::GLenum mode, ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.size() == colors.size());
-    if (mode == gl::GL_TRIANGLES)
-        orAssert((vertices.size() % 3) == 0);
     bindProperBuffer(target);
 
     shader.use();
 void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
                     std::vector<unsigned short>& indices, glm::mat4 MVP,
                     gl::GLenum mode, ShaderTexture* target, Shader& shader) {
-    orAssert(vertices.size() == colors.size());
-    if (mode == gl::GL_TRIANGLES)
-        orAssert((indices.size() % 3) == 0);
     bindProperBuffer(target);
 
     shader.use();