Fixed new 2D portal visibility checks.

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150405 ]
+    * No longer flipping axis in shaders, now turning camera upside-down.
+    * Mostly fixed portal-to-portal 2D visibility checks.
+        * Currently also checking behind player.
+
     [ 20150404 ]
     * World is now static
     * Can display debug informations about Rooms and StaticMeshes

include/Camera.h

     static void handleMouseMotion(int x, int y);
     static void handleControllerAxis(float value, KeyboardButton axis);
 
-    //! \fixme The Y axis seems to be the source of all evil?
-    static void setPosition(glm::vec3 p) { pos = glm::vec3(p.x, -p.y, p.z); dirty = true; }
-    static glm::vec3 getPosition() { return glm::vec3(pos.x, -pos.y, pos.z); }
+    static void setPosition(glm::vec3 p) { pos = p; dirty = true; }
+    static glm::vec3 getPosition() { return pos; }
 
     static glm::vec2 getRotation() { return rot; }
     static glm::mat4 getProjectionMatrix() { return projection; }

include/Render.h

     static std::vector<Room*> roomList;
 
     static bool displayViewFrustum;
+    static bool displayVisibilityCheck;
 };
 
 #endif

src/Camera.cpp

 }
 
 void Camera::setSize(glm::i32vec2 s) {
-    //! \fixme TODO instead of mirroring the Y axis in the shader, scale with -1 here
     projection = glm::perspective(fov, float(s.x) / float(s.y), nearDist, farDist);
 }
 
     } else if (action == backwardAction) {
         posSpeed -= dirUnit * maxSpeed * factor;
     } else if (action == leftAction) {
-        posSpeed += rightUnit * maxSpeed * factor;
-    } else if (action == rightAction) {
         posSpeed -= rightUnit * maxSpeed * factor;
+    } else if (action == rightAction) {
+        posSpeed += rightUnit * maxSpeed * factor;
     } else if (action == jumpAction) {
         posSpeed += upUnit * maxSpeed * factor;
     } else if (action == crouchAction) {
         dirty = true;
 
     while (x > 0) {
-        rot.x += rotationDeltaX;
+        rot.x -= rotationDeltaX;
         x--;
     }
 
     while (x < 0) {
-        rot.x -= rotationDeltaX;
+        rot.x += rotationDeltaX;
         x++;
     }
 
         value = 0.0f;
 
     if (axis == leftXAxis) {
-        posSpeed.x = -maxSpeed * value;
+        posSpeed.x = maxSpeed * value;
     } else if (axis == leftYAxis) {
         posSpeed.z = maxSpeed * value;
     } else if (axis == rightXAxis) {
-        rotSpeed.x = controllerViewFactor * value;
+        rotSpeed.x = -controllerViewFactor * value;
     } else if (axis == rightYAxis) {
         rotSpeed.y = -controllerViewFactor * value;
     } else {
     else
         rotSpeed = glm::vec2(0.0f, 0.0f);
 
+    static glm::quat quatZ = glm::angleAxis(glm::pi<float>(), glm::vec3(0.0f, 0.0f, 1.0f));
     glm::quat quatY = glm::angleAxis(rot.x, glm::vec3(0.0f, 1.0f, 0.0f));
     glm::quat quatX = glm::angleAxis(rot.y, glm::vec3(1.0f, 0.0f, 0.0f));
-    glm::quat quaternion = quatY * quatX;
+    glm::quat quaternion = quatZ * quatY * quatX;
 
     glm::vec3 clampedSpeed;
     if (movingFaster) {
     for (int i = 0; i < 8; i++) {
         glm::vec4 t = inverse * glm::vec4(frustumVertices[i], 1.0f);
         frustumVertices[i] = glm::vec3(t) / t.w;
-        frustumVertices[i].y *= -1.0f;
     }
 
     // Set planes used for frustum culling
     for (int i = 0; i < 6; i++) {
         int out = 0, in = 0;
         for (int c = 0; (c < 8) && ((in == 0) || (out == 0)); c++) {
-            if (planes[i].distance(b.getCorner(c)) < 0)
+            if (planes[i].distance(b.getCorner(c)) > 0)
                 out++;
             else
                 in++;

src/Render.cpp

 RenderMode Render::mode = RenderMode::LoadScreen;
 std::vector<Room*> Render::roomList;
 bool Render::displayViewFrustum = false;
+bool Render::displayVisibilityCheck = false;
 
 void Render::display() {
     gl::glClear(gl::GL_COLOR_BUFFER_BIT | gl::GL_DEPTH_BUFFER_BIT);
     glm::mat4 view = Camera::getViewMatrix();
     glm::mat4 VP = projection * view;
 
-    //if (updated) {
+    if (updated || displayVisibilityCheck) {
         int r = Camera::getRoom();
         clearRoomList();
         if (r < 0) {
         } else {
             buildRoomList(VP, r);
         }
-    //}
+    }
 
     for (int r = roomList.size() - 1; r >= 0; r--) {
         roomList.at(r)->display(VP);
             }
         }
     } else {
-        // Check if this room is visible
-        if (Camera::boxInFrustum(World::getRoom(room).getBoundingBox())) {
-            roomList.push_back(&World::getRoom(room));
+        roomList.push_back(&World::getRoom(room));
 
+        if (displayVisibilityCheck) {
             // 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);
+
+            // Calculate the 2D window of this portal
+            glm::vec3 newMin, newMax;
+            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;
 
-            // 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);
-
-                // 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;
-                    }
+                if (displayVisibilityCheck) {
+                    ImGui::Text("Test %d: %.3f %.3f %.3f", c, vert.x, vert.y, vert.z);
                 }
 
-                // 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;
+                if (c == 0) {
+                    newMin = vert;
+                    newMax = vert;
                 } else {
-                    ImGui::Text("Visible!");
+                    if (vert.x < newMin.x)
+                        newMin.x = vert.x;
+                    if (vert.y < newMin.y)
+                        newMin.y = vert.y;
+                    if (vert.z < newMin.z)
+                        newMin.z = vert.z;
+                    if (vert.x > newMax.x)
+                        newMax.x = vert.x;
+                    if (vert.y > newMax.y)
+                        newMax.y = vert.y;
+                    if (vert.z > newMax.z)
+                        newMax.z = vert.z;
                 }
+            }
 
-                // 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())) {
-                        found = true;
-                        break;
-                    }
-                }
+            if (displayVisibilityCheck) {
+                ImGui::Text("NewMin: %.3f %.3f %.3f", newMin.x, newMin.y, newMin.z);
+                ImGui::Text("NewMax: %.3f %.3f %.3f", newMax.x, newMax.y, newMax.z);
+            }
 
-                // ...only render it if it is not
-                if (!found) {
-                    buildRoomList(VP, portal.getAdjoiningRoom(), newMin, newMax);
+            //! \fixme Currently also checking behind player, because Z is always 1.0f?!
+            //if ((newMin.z > 0.0f) || (newMin.z < -1.0f) || (newMax.z > 0.0f) || (newMax.z < -1.0f)) {
+            //    continue;
+            //}
+
+            // 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))) {
+                continue;
+            }
+
+            // 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())) {
+                    found = true;
+                    break;
                 }
             }
+
+            // ...only render it if it is not
+            if (!found) {
+                buildRoomList(VP, portal.getAdjoiningRoom(), glm::vec2(newMin), glm::vec2(newMax));
+            }
         }
     }
 }
         if (ImGui::Checkbox("Portals##bbox", &showBoundingBox3)) {
             Portal::setShowBoundingBox(showBoundingBox3);
         }
+        ImGui::SameLine();
+        ImGui::Checkbox("VisChecks##bbox", &displayVisibilityCheck);
 
         ImGui::Separator();
         ImGui::Text("Renderable Objects:");

src/RoomData.cpp

 // ----------------------------------------------------------------------------
 
 StaticModel::StaticModel(glm::vec3 pos, float angle, int i) : id(i), cache(-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 = glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));
     model = translate * rotate;
 }
 // ----------------------------------------------------------------------------
 
 void RoomSprite::display(glm::mat4 VP) {
-    glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
-    glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), Camera::getRotation().x, glm::vec3(0.0f, 1.0f,
-                                   0.0f));
-    glm::mat4 model = translate * rotate;
+    glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
 
-    World::getSprite(sprite).display(VP * model);
+    //! \fixme Calculate angle between camera and sprite
+    glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), Camera::getRotation().x,
+                                   glm::vec3(0.0f, 1.0f, 0.0f));
+
+    World::getSprite(sprite).display(VP * (translate * rotate));
 }
 
 // ----------------------------------------------------------------------------

src/SkeletalModel.cpp

     BoneFrame& boneframe = anim.get(bframe);
 
     glm::vec3 pos = boneframe.getPosition();
-    glm::mat4 frameTrans = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
+    glm::mat4 frameTrans = glm::translate(glm::mat4(1.0f), pos);
 
     MatrixStack stack(MVP * frameTrans);
 
 #endif
 
             glm::vec3 off = tag.getOffset();
-            translate = glm::translate(glm::mat4(1.0f), glm::vec3(off.x, -off.y, off.z));
+            translate = glm::translate(glm::mat4(1.0f), off);
         }
 
         glm::vec3 rot = tag.getRotation();

src/system/Shader.cpp

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