First try at scissoring room portals

include/Render.h

     Texture
 };
 
+struct RoomRenderList {
+    RoomRenderList(Room* r, glm::vec2 pos, glm::vec2 size)
+        : room(r), portalPos(pos), portalSize(size) { }
+
+    Room* room;
+    glm::vec2 portalPos, portalSize;
+};
+
 class Render {
   public:
 
                               glm::vec2 max = glm::vec2(1.0f, 1.0f));
 
     static RenderMode mode;
-    static std::vector<Room*> roomList;
+    static std::vector<RoomRenderList> roomList;
 
     static bool displayViewFrustum;
     static bool displayVisibilityCheck;

src/BoundingBox.cpp

     auto startSize = vertices.size();
 
     for (auto& c : corner) {
-        vertices.emplace_back(VP * glm::vec4(c, 1.0f));
+        glm::vec4 t = VP * glm::vec4(c, 1.0f);
+        vertices.emplace_back(glm::vec3(t) / t.w);
         colorsLine.emplace_back(colorLine);
         colorsPoint.emplace_back(colorDot);
     }
     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);
 }
     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();
     }
+
+    vertices.clear();
+    colorsLine.clear();
+    colorsPoint.clear();
+    indicesLine.clear();
 }
 

src/Render.cpp

 #include <sstream>
 
 #include "global.h"
+#include "BoundingBox.h"
 #include "Camera.h"
 #include "Log.h"
 #include "Menu.h"
 #include "stb/stb_image_write.h"
 
 RenderMode Render::mode = RenderMode::LoadScreen;
-std::vector<Room*> Render::roomList;
+std::vector<RoomRenderList> Render::roomList;
 bool Render::displayViewFrustum = false;
 bool Render::displayVisibilityCheck = false;
 
     }
 
     for (int r = roomList.size() - 1; r >= 0; r--) {
-        roomList.at(r)->display(VP);
+        auto& rl = roomList.at(r);
+
+        //! \fixme TODO scissor to portal in screenspace to fix 4D rendering
+
+        //gl::glEnable(gl::GL_SCISSOR_TEST);
+        //gl::glScissor(rl.portalPos.x, rl.portalPos.y, rl.portalSize.x, rl.portalSize.y);
+
+        //ImGui::Text("%.2f %.2f", rl.portalPos.x, rl.portalPos.y);
+        //ImGui::Text("%.2f %.2f", rl.portalSize.x, rl.portalSize.y);
+        //ImGui::Text("--");
+
+        rl.room->display(VP);
 
         for (int i = 0; i < World::sizeEntity(); i++) {
             auto& e = World::getEntity(i);
-            if (roomList.at(r)->getIndex() == e.getRoom()) {
+            if (rl.room->getIndex() == e.getRoom()) {
                 e.display(VP);
             }
         }
+
+        //gl::glDisable(gl::GL_SCISSOR_TEST);
     }
 
     if (displayViewFrustum)
         Camera::displayFrustum(VP);
 
+    BoundingBox::display();
+
     if (mode == RenderMode::Wireframe) {
         gl::glPolygonMode(gl::GL_FRONT_AND_BACK, gl::GL_FILL);
     }
 }
 
 void Render::buildRoomList(glm::mat4 VP, int room, glm::vec2 min, glm::vec2 max) {
+    glm::vec2 halfSize = glm::vec2(Window::getSize()) / 2.0f;
+    glm::vec2 pos = (min * halfSize) + halfSize;
+    glm::vec2 size = (max * halfSize) + halfSize - pos;
+
     if (room < -1) {
         // Check if the camera currently is in a room...
         for (int i = 0; i < World::sizeRoom(); i++) {
         // Check visibility for all rooms!
         for (int i = 0; i < World::sizeRoom(); i++) {
             if (Camera::boxInFrustum(World::getRoom(i).getBoundingBox())) {
-                roomList.push_back(&World::getRoom(i));
+                roomList.emplace_back(&World::getRoom(i), pos, size);
             }
         }
     } else {
-        roomList.push_back(&World::getRoom(room));
+        roomList.emplace_back(&World::getRoom(room), pos, size);
 
         if (displayVisibilityCheck) {
             // Display the visibility test for the portal to this room
             // Check if this room is already in the list...
             bool found = false;
             for (int n = 0; n < roomList.size(); n++) {
-                if (roomList.at(n) == &room) {
+                if (roomList.at(n).room == &room) {
                     found = true;
                     break;
                 }

src/RoomData.cpp

 
 #include "imgui/imgui.h"
 
-#include <glbinding/gl/gl.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 StaticModel::StaticModel(glm::vec3 pos, float angle, int i) : id(i), cache(-1) {

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/system/Shader.cpp

 uniform mat4 MVP;
 
 void main() {
-    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
-                          vertexPosition_modelspace.y,
-                          vertexPosition_modelspace.z,
-                          1);
+    vec4 pos = MVP * vec4(vertexPosition_modelspace, 1);
     gl_Position = pos;
     UV = vertexUV;
 }
 uniform mat4 MVP;
 
 void main() {
-    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
-                          vertexPosition_modelspace.y,
-                          vertexPosition_modelspace.z,
-                          1);
+    vec4 pos = MVP * vec4(vertexPosition_modelspace, 1);
     gl_Position = pos;
     color = vertexColor;
 }