Added basic view frustum culling

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141222 ]
+    * Added basic (not yet working) view frustum culling
+
     [ 20141220 ]
     * Fixed Room StaticModel rotation
 

include/Camera.h

 #ifndef _CAMERA_H_
 #define _CAMERA_H_
 
+#include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 #include <glm/mat4x4.hpp>
 
+#include "RoomData.h"
+
 class Camera {
   public:
 
 
     static void handleAction(ActionEvents action, bool isFinished);
     static void handleMouseMotion(int x, int y);
-    static glm::mat4 getViewMatrix();
-
-    static float getRadianPitch() { return thetaX; }
-    static float getRadianYaw() { return thetaY; }
-    static void setRadianPitch(float x) { thetaX = x; }
+    static bool update();
 
     static void setPosition(glm::vec3 p) { pos = p; }
     static glm::vec3 getPosition() { return pos; }
 
+    static glm::vec2 getRotation() { return rot; }
+    static glm::mat4 getProjectionMatrix() { return projection; }
+    static glm::mat4 getViewMatrix() { return view; }
+
     static void setSensitivityX(float sens) { rotationDeltaX = sens; }
     static float getSensitivityX() { return rotationDeltaX; }
 
     static void setSensitivityY(float sens) { rotationDeltaY = sens; }
     static float getSensitivityY() { return rotationDeltaY; }
 
+    static void setUpdateViewFrustum(bool u) { updateViewFrustum = u; }
+    static bool getUpdateViewFrustum() { return updateViewFrustum; }
+
+    static bool boxInFrustum(BoundingBox b);
+    static void displayFrustum(glm::mat4 MVP);
+
   private:
     static glm::vec3 pos;
-    static float thetaX, thetaY;
+    static glm::vec2 rot;
+    static glm::vec3 lastPos;
+    static glm::vec2 lastRot;
+    static glm::vec2 lastSize;
+    static glm::mat4 projection;
+    static glm::mat4 view;
     static float rotationDeltaX, rotationDeltaY;
+    static bool updateViewFrustum;
 };
 
 #endif

include/Render.h

 #ifndef _RENDER_H_
 #define _RENDER_H_
 
+#include <vector>
 #include <glm/vec4.hpp>
 
+#include "Room.h"
 #include "TextureManager.h"
 
 enum class RenderMode {
 
     static void display();
 
+    static void clearRoomList();
+
     static void screenShot(const char* filenameBase);
 
     static void drawTexture(float x, float y, float w, float h, glm::vec4 color,
                             unsigned int texture, TextureManager::TextureStorage s);
 
+    static void setDisplayViewFrustum(bool d) { displayViewFrustum = d; }
+    static bool getDisplayViewFrustum() { return displayViewFrustum; }
+
   private:
+    static void buildRoomList(int room);
+
     static RenderMode mode;
+    static std::vector<Room*> roomList;
+
+    static bool displayViewFrustum;
 };
 
 #endif

include/RoomData.h

 class BoundingBox {
   public:
     BoundingBox(glm::vec3 min, glm::vec3 max) : a(min), b(max) { }
-    bool inBox(float x, float y, float z) { return ((y > a.y) && (y < b.y) && inBoxPlane(x, z)); }
-    bool inBoxPlane(float x, float z) { return ((x > a.x) && (x < b.x) && (z > a.z) && (z < b.z)); }
+
+    bool inBox(glm::vec3 p) {
+        return ((p.y >= a.y) && (p.y <= b.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));
+    }
+
+    glm::vec3 getVertexP(glm::vec3 normal) {
+        glm::vec3 p = a;
+        if (normal.x >= 0.0f)
+            p.x = b.x;
+        if (normal.y >= 0.0f)
+            p.y = b.y;
+        if (normal.z >= 0.0f)
+            p.z = b.z;
+        return p;
+    }
 
   private:
     glm::vec3 a, b;
 
 // --------------------------------------
 
+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) {
+        vert[0] = v1; vert[1] = v2;
+        vert[2] = v3; vert[3] = v4;
+    }
+    int getAdjoiningRoom() { return adjoiningRoom; }
+    glm::vec3 getNormal() { return normal; }
+    glm::vec3 getVertex(int i) { assert((i >= 0) && (i < 4)); return vert[i]; }
+
+  private:
+    int adjoiningRoom;
+    glm::vec3 normal;
+    glm::vec3 vert[4];
+};
+
+// --------------------------------------
+
 class Light {
   public:
     /*!
 
 // --------------------------------------
 
-class Portal {
-  public:
-    Portal(glm::vec3 vert[4], float norm[3], int adj);
-
-    void getVertices(float vert[4][3]);
-    int getAdjoiningRoom();
-
-  private:
-    float vertices[4][3];
-    float normal[3];
-    int adjoiningRoom;
-};
-
-// --------------------------------------
-
 class Sector {
   public:
     Sector(float f, float c, bool w) : floor(f), ceiling(c), wall(w) { }

include/World.h

     unsigned long sizeMesh();
     Mesh& getMesh(unsigned long index);
 
-    /*!
-     * \brief Find room a location is in.
-     *
-     * If it fails to be in a room it gives closest overlapping room.
-     * \param index Guessed room index
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     * \returns correct room index or -1 for unknown
-     */
-    long getRoomByLocation(long index, float x, float y, float z);
-
-    /*!
-     * \brief Find room a location is in.
-     *
-     * If it fails to be in a room it gives closest overlapping room.
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     * \returns correct room index or -1 for unknown
-     */
-    long getRoomByLocation(float x, float y, float z);
-
   private:
     std::vector<std::unique_ptr<Room>> mRooms;
     std::vector<std::unique_ptr<SpriteSequence>> mSprites;

src/Camera.cpp

 #include <glm/gtc/matrix_transform.hpp>
 
 #include "global.h"
+#include "system/Window.h"
 #include "Camera.h"
 
+#define NEAR 0
+#define FAR 1
+#define TOP 2
+#define BOTTOM 3
+#define LEFT 4
+#define RIGHT 5
+
+#define NTL 0
+#define NBL 1
+#define NBR 2
+#define NTR 3
+#define FTL 4
+#define FBL 5
+#define FBR 6
+#define FTR 7
+
+struct Plane {
+    glm::vec3 normal, pos;
+    float d;
+
+    Plane(glm::vec3 n = glm::vec3(0.0f, 0.0f, 0.0f),
+          glm::vec3 p = glm::vec3(0.0f, 0.0f, 0.0f)) {
+        set(n, p);
+    }
+
+    void set(glm::vec3 a, glm::vec3 b, glm::vec3 c) {
+        glm::vec3 aux1 = a - b;
+        glm::vec3 aux2 = c - b;
+        normal = glm::normalize(glm::cross(aux2, aux1));
+        pos = b;
+        d = -glm::dot(normal, pos);
+    }
+
+    void set(glm::vec3 n, glm::vec3 p) {
+        normal = n;
+        pos = p;
+        d = -glm::dot(normal, pos);
+    }
+
+    float distance(glm::vec3 p) {
+        return d + glm::dot(normal, p);
+    }
+};
+
+// ----------------------------------------------------------------------------
+
+const static float fov = 45.0f;
+const static float nearDist = 0.1f;
+const static float farDist = 75000.0f;
+const static float freeCameraStep = 256.0f;
+
 glm::vec3 Camera::pos(0.0f, 0.0f, 0.0f);
-float Camera::thetaX = 0.0f;
-float Camera::thetaY = 0.0f;
+glm::vec2 Camera::rot(0.0f, 0.0f);
+glm::vec3 Camera::lastPos(1.0f, 0.0f, 0.0f);
+glm::vec2 Camera::lastRot(1.0f, 0.0f);
+glm::vec2 Camera::lastSize(0.0f, 0.0f);
+glm::mat4 Camera::projection(1.0f);
+glm::mat4 Camera::view(1.0f);
 float Camera::rotationDeltaX = 0.75f;
 float Camera::rotationDeltaY = 0.75f;
+bool Camera::updateViewFrustum = true;
+static Plane planes[6];
+
+static glm::vec3 frustumColors[6] = {
+    glm::vec3(1.0f, 0.0f, 0.0f),
+    glm::vec3(0.0f, 1.0f, 0.0f),
+    glm::vec3(0.0f, 0.0f, 1.0f),
+    glm::vec3(1.0f, 1.0f, 0.0f),
+    glm::vec3(0.0f, 1.0f, 1.0f),
+    glm::vec3(1.0f, 0.0f, 1.0f)
+};
+static glm::vec3 frustumVertices[8];
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
-    thetaX = 0.0f;
-    thetaY = 0.0f;
+    rot = glm::vec2(0.0f, 0.0f);
+    lastPos = glm::vec3(1.0f, 0.0f, 0.0f);
+    lastRot = glm::vec2(1.0f, 0.0f);
+    lastSize = glm::vec2(0.0f, 0.0f);
+    projection = glm::mat4(1.0f);
+    view = glm::mat4(1.0f);
 }
 
 void Camera::handleAction(ActionEvents action, bool isFinished) {
     if (isFinished)
         return;
 
-    const static float step = 256.0f;
-
     glm::vec3 dir(
-        glm::cos(thetaY) * glm::sin(thetaX),
-        glm::sin(thetaY),
-        glm::cos(thetaY) * glm::cos(thetaX)
+        glm::cos(rot.y) * glm::sin(rot.x),
+        glm::sin(rot.y),
+        glm::cos(rot.y) * glm::cos(rot.x)
     );
     glm::vec3 right(
-        glm::sin(thetaX - glm::pi<float>() / 2.0f),
+        glm::sin(rot.x - glm::pi<float>() / 2.0f),
         0.0f,
-        glm::cos(thetaX - glm::pi<float>() / 2.0f)
+        glm::cos(rot.x - glm::pi<float>() / 2.0f)
     );
-    glm::vec3 up = glm::cross(right, dir);
+    glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
 
     if (action == forwardAction) {
-        pos += dir * step;
+        pos += dir * freeCameraStep;
     } else if (action == backwardAction) {
-        pos -= dir * step;
+        pos -= dir * freeCameraStep;
     } else if (action == leftAction) {
-        pos += right * step;
+        pos += right * freeCameraStep;
     } else if (action == rightAction) {
-        pos -= right * step;
+        pos -= right * freeCameraStep;
     } else if (action == jumpAction) {
-        pos += up * step;
+        pos += up * freeCameraStep;
     } else if (action == crouchAction) {
-        pos -= up * step;
+        pos -= up * freeCameraStep;
     } else if (action == useAction) {
     } else if (action == holsterAction) {
     } else if (action == walkAction) {
 
 void Camera::handleMouseMotion(int x, int y) {
     while (x > 0) {
-        thetaX += rotationDeltaX;
+        rot.x += rotationDeltaX;
         x--;
     }
     while (x < 0) {
-        thetaX -= rotationDeltaX;
+        rot.x -= rotationDeltaX;
         x++;
     }
     while (y > 0) {
-        if (thetaY > -(glm::pi<float>() / 2.0f)) {
-            thetaY -= rotationDeltaY;
+        if (rot.y > -(glm::pi<float>() / 2.0f)) {
+            rot.y -= rotationDeltaY;
         }
         y--;
     }
     while (y < 0) {
-        if (thetaY < (glm::pi<float>() / 2.0f)) {
-            thetaY += rotationDeltaY;
+        if (rot.y < (glm::pi<float>() / 2.0f)) {
+            rot.y += rotationDeltaY;
         }
         y++;
     }
 
-    while (thetaX > (glm::pi<float>() * 2.0f))
-        thetaX -= glm::pi<float>() * 2.0f;
+    while (rot.x > (glm::pi<float>() * 2.0f))
+        rot.x -= glm::pi<float>() * 2.0f;
 
-    while (thetaX < -(glm::pi<float>() * 2.0f))
-        thetaX += glm::pi<float>() * 2.0f;
+    while (rot.x < -(glm::pi<float>() * 2.0f))
+        rot.x += glm::pi<float>() * 2.0f;
 }
 
-glm::mat4 Camera::getViewMatrix() {
+bool Camera::update() {
+    glm::vec2 size(getWindow().getWidth(), getWindow().getHeight());
+
+    if ((lastPos == pos) && (lastRot == rot) && (lastSize == size))
+        return false;
+
+    if (lastSize != size) {
+        projection = glm::perspective(fov, size.x / size.y, nearDist, farDist);
+        lastSize = size;
+    }
+
     glm::vec3 dir(
-        glm::cos(thetaY) * glm::sin(thetaX),
-        glm::sin(thetaY),
-        glm::cos(thetaY) * glm::cos(thetaX)
+        glm::cos(rot.y) * glm::sin(rot.x),
+        glm::sin(rot.y),
+        glm::cos(rot.y) * glm::cos(rot.x)
     );
+
     glm::vec3 right(
-        glm::sin(thetaX - glm::pi<float>() / 2.0f),
+        glm::sin(rot.x - glm::pi<float>() / 2.0f),
         0.0f,
-        glm::cos(thetaX - glm::pi<float>() / 2.0f)
+        glm::cos(rot.x - glm::pi<float>() / 2.0f)
     );
+
     glm::vec3 up = glm::cross(right, dir);
-    return glm::lookAt(pos, pos + dir, up);
+    view = glm::lookAt(pos, pos + dir, up);
+
+    if (!updateViewFrustum)
+        return false;
+
+    dir = glm::normalize(dir);
+    right = glm::normalize(right);
+    up = glm::normalize(up);
+
+    static float tang = glm::tan(glm::radians(fov * 0.5f));
+    static float nh = nearDist * tang;
+    float nw = nh * (size.x / size.y);
+    static float fh = farDist * tang;
+    float fw = fh * (size.x / size.y);
+
+    glm::vec3 nearCenter = pos + dir * nearDist;
+    glm::vec3 farCenter = pos + dir * farDist;
+
+    frustumVertices[NTL] = nearCenter + up * nh - right * nw;
+    frustumVertices[NTR] = nearCenter + up * nh + right * nw;
+    frustumVertices[NBL] = nearCenter - up * nh - right * nw;
+    frustumVertices[NBR] = nearCenter - up * nh + right * nw;
+    frustumVertices[FTL] = farCenter + up * fh - right * fw;
+    frustumVertices[FTR] = farCenter + up * fh + right * fw;
+    frustumVertices[FBL] = farCenter - up * fh - right * fw;
+    frustumVertices[FBR] = farCenter - up * fh + right * fw;
+
+#if 1
+    planes[TOP].set(frustumVertices[NTR], frustumVertices[NTL], frustumVertices[FTL]);
+    planes[BOTTOM].set(frustumVertices[NBL], frustumVertices[NBR], frustumVertices[FBR]);
+    planes[LEFT].set(frustumVertices[NTL], frustumVertices[NBL], frustumVertices[FBL]);
+    planes[RIGHT].set(frustumVertices[NBR], frustumVertices[NTR], frustumVertices[FBR]);
+    planes[NEAR].set(frustumVertices[NTL], frustumVertices[NTR], frustumVertices[NBR]);
+    planes[FAR].set(frustumVertices[FTR], frustumVertices[FTL], frustumVertices[FBL]);
+#else
+    planes[NEAR].set(-dir, nearCenter);
+    planes[FAR].set(dir, farCenter);
+
+    glm::vec3 aux = glm::normalize((nearCenter + up * nh) - pos);
+    glm::vec3 normal = glm::cross(aux, right);
+    planes[TOP].set(normal, nearCenter + up * nh);
+
+    aux = glm::normalize((nearCenter - up * nh) - pos);
+    normal = glm::cross(right, aux);
+    planes[BOTTOM].set(normal, nearCenter - up * nh);
+
+    aux = glm::normalize((nearCenter - right * nw) - pos);
+    normal = glm::cross(aux, up);
+    planes[LEFT].set(normal, nearCenter - right * nw);
+
+    aux = glm::normalize((nearCenter + right * nw) - pos);
+    normal = glm::cross(up, aux);
+    planes[RIGHT].set(normal, nearCenter + right * nw);
+#endif
+
+    lastPos = pos;
+    lastRot = rot;
+    return true;
+}
+
+bool Camera::boxInFrustum(BoundingBox b) {
+    for (int i = 0; i < 6; i++) {
+        if (planes[i].distance(b.getVertexP(planes[i].normal)) < 0)
+            return false;
+    }
+    return true;
+}
+
+void Camera::displayFrustum(glm::mat4 MVP) {
+    std::vector<glm::vec3> verts;
+    std::vector<glm::vec3> cols;
+    std::vector<unsigned short> inds;
+
+    verts.push_back(frustumVertices[NTL]);
+    verts.push_back(frustumVertices[NTR]);
+    verts.push_back(frustumVertices[NBR]);
+    verts.push_back(frustumVertices[NBL]);
+
+    verts.push_back(frustumVertices[FTR]);
+    verts.push_back(frustumVertices[FTL]);
+    verts.push_back(frustumVertices[FBL]);
+    verts.push_back(frustumVertices[FBR]);
+
+    verts.push_back(frustumVertices[NBL]);
+    verts.push_back(frustumVertices[NBR]);
+    verts.push_back(frustumVertices[FBR]);
+    verts.push_back(frustumVertices[FBL]);
+
+    verts.push_back(frustumVertices[NTR]);
+    verts.push_back(frustumVertices[NTL]);
+    verts.push_back(frustumVertices[FTL]);
+    verts.push_back(frustumVertices[FTR]);
+
+    verts.push_back(frustumVertices[NTL]);
+    verts.push_back(frustumVertices[NBL]);
+    verts.push_back(frustumVertices[FBL]);
+    verts.push_back(frustumVertices[FTL]);
+
+    verts.push_back(frustumVertices[NBR]);
+    verts.push_back(frustumVertices[NTR]);
+    verts.push_back(frustumVertices[FTR]);
+    verts.push_back(frustumVertices[FBR]);
+
+    for (int i = 0; i < 6; i++) {
+        cols.push_back(frustumColors[i]);
+        cols.push_back(frustumColors[i]);
+        cols.push_back(frustumColors[i]);
+        cols.push_back(frustumColors[i]);
+
+        inds.push_back(4 * i);
+        inds.push_back((4 * i) + 1);
+        inds.push_back((4 * i) + 2);
+        inds.push_back((4 * i) + 3);
+        inds.push_back((4 * i) + 2);
+        inds.push_back(4 * i);
+    }
+
+    Window::drawGL(verts, cols, inds, MVP);
 }
 

src/Entity.cpp

 }
 
 void Entity::move(char movement) {
-    const float moved = 180.0f;
-    const float testd = 220.0f;
-    const float camHeight = 8.0f;
-    float x, y, z, pitch, h, floor, ceiling;
-    long roomNew, sector;
-    bool wall;
-    unsigned int roomFlags;
 
-    switch (moveType) {
-        case MoveTypeWalkNoSwim:
-        case MoveTypeWalk:
-            pitch = 0.0f; // in the future pitch could control jump up blocks here
-            break;
-
-        case MoveTypeNoClipping:
-        case MoveTypeFly:
-        case MoveTypeSwim:
-            pitch = angles[2];
-            break;
-    }
-
-    switch (movement) {
-        case 'f':
-            x = pos[0] + (testd * sinf(angles[1]));
-            y = pos[1] + (testd * sinf(pitch));
-            z = pos[2] + (testd * cosf(angles[1]));
-            break;
-        case 'b':
-            x = pos[0] - (testd * sinf(angles[1]));
-            y = pos[1] - (testd * sinf(pitch));
-            z = pos[2] - (testd * cosf(angles[1]));
-            break;
-        case 'l':
-            x = pos[0] - (testd * sinf(angles[1] + 90.0f));
-            y = pos[1];
-            z = pos[2] - (testd * cosf(angles[1] + 90.0f));
-            break;
-        case 'r':
-            x = pos[0] + (testd * sinf(angles[1] + 90.0f));
-            y = pos[1];
-            z = pos[2] + (testd * cosf(angles[1] + 90.0f));
-            break;
-        default:
-            return;
-    }
-
-    roomNew = getWorld().getRoomByLocation(room, x, y, z);
-
-    if (roomNew == -1) { // Will we hit a portal?
-        roomNew = getWorld().getRoom(room).getAdjoiningRoom(pos[0], pos[1], pos[2],
-                  x, y, z);
-
-        if (roomNew > -1)
-            getLog() << "Crossing from room " << room << " to " << roomNew << Log::endl;
-        else
-            //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
-            return;
-    }
-
-    roomFlags = getWorld().getRoom(roomNew).getFlags();
-    sector = getWorld().getRoom(roomNew).getSector(x, z, &floor, &ceiling);
-    wall = getWorld().getRoom(roomNew).isWall(sector);
-
-    // If you're underwater you may want to swim  =)
-    // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
-    if ((roomFlags & RoomFlagUnderWater) && (moveType == MoveTypeWalk))
-        moveType = MoveTypeSwim;
-
-    // Don't swim on land
-    if (!(roomFlags & RoomFlagUnderWater) && (moveType == MoveTypeSwim))
-        moveType = MoveTypeWalk;
-
-    // Mongoose 2002.09.02, Add check for room -> room transition
-    // (Only allow by movement between rooms by using portals)
-    if (((moveType == MoveTypeNoClipping) ||
-         (moveType == MoveTypeFly) ||
-         (moveType == MoveTypeSwim)) ||
-        ((roomNew > -1) && (!wall))) {
-        room = roomNew;
-
-        switch (movement) {
-            case 'f':
-                x = pos[0] + (moved * sinf(angles[1]));
-                y = pos[1] + (moved * sinf(pitch));
-                z = pos[2] + (moved * cosf(angles[1]));
-                break;
-            case 'b':
-                x = pos[0] - (moved * sinf(angles[1]));
-                y = pos[1] - (moved * sinf(pitch));
-                z = pos[2] - (moved * cosf(angles[1]));
-                break;
-            case 'l':
-                x = pos[0] - (moved * sinf(angles[1] + 90.0f));
-                z = pos[2] - (moved * cosf(angles[1] + 90.0f));
-                break;
-            case 'r':
-                x = pos[0] + (moved * sinf(angles[1] + 90.0f));
-                z = pos[2] + (moved * cosf(angles[1] + 90.0f));
-                break;
-        }
-
-        /*! \fixme Test for vector (move vector) / plane (portal) collision here
-         * to see if we need to switch rooms... man...
-         */
-
-        h = y;
-        getWorld().getRoom(room).getHeightAtPosition(x, &h, z);
-
-        switch (moveType) {
-            case MoveTypeFly:
-            case MoveTypeSwim:
-                // Don't fall out of world, avoid a movement that does
-                if (h > y - camHeight) {
-                    pos[0] = x;
-                    pos[1] = y;
-                    pos[2] = z;
-                }
-                break;
-
-            case MoveTypeWalk:
-            case MoveTypeWalkNoSwim:
-                y = pos[1];  // Override vector movement walking ( er, not pretty )
-
-                // Now fake gravity
-                // Mongoose 2002.08.14, Remember TR is upside down ( you fall 'up' )
-
-                //ddist = h - pos[1];
-
-                // This is to force false gravity, by making camera stay on ground
-                pos[1] = h; //roomFloor->bbox_min[1];
-
-                // Check for camera below terrian and correct
-                if (pos[1] < h - camHeight)
-                    pos[1] = h - camHeight;
-
-                pos[0] = x;
-                pos[2] = z;
-                break;
-
-            case MoveTypeNoClipping:
-                pos[0] = x;
-                pos[1] = y;
-                pos[2] = z;
-                break;
-        }
-    }
 }
 
 void Entity::print() {

src/Game.cpp

         Font::drawText(10, getWindow().getHeight() - 25, 0.6f, BLUE, s.str());
 
         s.str("");
-        s << "X: " << Camera::getPosition().x << " (" << Camera::getRadianPitch() << ")";
+        s << "X: " << Camera::getPosition().x << " (" << Camera::getRotation().x << ")";
         Font::drawText(10, getWindow().getHeight() - 70, 0.6f, BLUE, s.str());
 
         s.str("");
-        s << "Y: " << Camera::getPosition().y << " (" << Camera::getRadianYaw() << ")";
+        s << "Y: " << Camera::getPosition().y << " (" << Camera::getRotation().y << ")";
         Font::drawText(10, getWindow().getHeight() - 55, 0.6f, BLUE, s.str());
 
         s.str("");
     Render::setMode(RenderMode::LoadScreen);
 
     Camera::reset();
+    Render::clearRoomList();
     SoundManager::clear();
     getTextureManager().clear();
     getWorld().destroy();
         return;
 
     Camera::handleMouseMotion(xrel, yrel);
-
-    /* TODO
-    float angles[3] = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
-    getLara().setAngles(angles);
-    */
 }
 
 Entity& Game::getLara() {

src/Render.cpp

 #include "global.h"
 #include "Camera.h"
 #include "Game.h"
-#include "Render.h"
 #include "utils/strings.h"
 #include "utils/tga.h"
 #include "World.h"
 #include "system/Window.h"
+#include "Render.h"
 
 RenderMode Render::mode = RenderMode::Disabled;
+std::vector<Room*> Render::roomList;
+bool Render::displayViewFrustum = false;
 
 RenderMode Render::getMode() {
     return mode;
         case RenderMode::Wireframe:
             //glClearColor(PURPLE[0] / 256.0f, PURPLE[1] / 256.0f,
             //             PURPLE[2] / 256.0f, PURPLE[3] / 256.0f);
-            //glDisable(GL_TEXTURE_2D);
             break;
         default:
             //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f,
             //             BLACK[2] / 256.0f, BLACK[3] / 256.0f);
-            //glEnable(GL_TEXTURE_2D);
             break;
     }
 }
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     }
 
+    if (Camera::update()) {
+        clearRoomList();
+        buildRoomList(-2); // TODO cache room
+        std::cout << "Rendering " << roomList.size() << "/"
+                  << getWorld().sizeRoom() << " rooms..." << std::endl;
+    }
+
+    glm::mat4 projection = Camera::getProjectionMatrix();
     glm::mat4 view = Camera::getViewMatrix();
 
-    static unsigned int w = getWindow().getWidth();
-    static unsigned int h = getWindow().getHeight();
-    static glm::mat4 projection = glm::perspective(45.0f, // Field of View
-                                  (float)getWindow().getWidth()
-                                  / (float)getWindow().getHeight(),
-                                  0.1f, // Min Distance
-                                  100000.0f); // Max Distance
-
-    if ((w != getWindow().getWidth()) || (h != getWindow().getHeight())) {
-        w = getWindow().getWidth();
-        h = getWindow().getHeight();
-        glm::mat4 projection = glm::perspective(45.0f, // Field of View
-                                                (float)getWindow().getWidth() / (float)getWindow().getHeight(),
-                                                0.1f, // Min Distance
-                                                100000.0f); // Max Distance
+    for (auto r : roomList) {
+        r->display(view, projection);
     }
 
-    // Just draw all rooms, as a test
-    for (int i = 0; i < getWorld().sizeRoom(); i++)
-        getWorld().getRoom(i).display(view, projection);
+    if (displayViewFrustum)
+        Camera::displayFrustum(projection * view);
 
     if (mode == RenderMode::Wireframe) {
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     }
 }
 
+void Render::clearRoomList() {
+    roomList.clear();
+}
+
+void Render::buildRoomList(int room) {
+    if (room < -1) {
+        // Check if the camera currently is in a room...
+        for (int i = 0; i < getWorld().sizeRoom(); i++) {
+            if (getWorld().getRoom(i).getBoundingBox().inBox(Camera::getPosition())) {
+                buildRoomList(i);
+                return;
+            }
+        }
+        std::cout << "Camera not found!" << std::endl;
+        buildRoomList(-1);
+    } else if (room == -1) {
+        // Check visibility for all rooms!
+        for (int i = 0; i < getWorld().sizeRoom(); i++) {
+            if (Camera::boxInFrustum(getWorld().getRoom(i).getBoundingBox())) {
+                roomList.push_back(&getWorld().getRoom(i));
+            }
+        }
+    } else {
+        // Check visibility of room and connected rooms, recursively?
+        if (Camera::boxInFrustum(getWorld().getRoom(room).getBoundingBox())) {
+            roomList.push_back(&getWorld().getRoom(room));
+            for (int i = 0; i < getWorld().getRoom(room).sizePortals(); i++) {
+                int r = getWorld().getRoom(room).getPortal(i).getAdjoiningRoom();
+                bool found = false;
+                for (int n = 0; n < roomList.size(); n++) {
+                    if (roomList.at(n) == &getWorld().getRoom(r)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    buildRoomList(r);
+            }
+        }
+    }
+}
+
 void Render::screenShot(const char* filenameBase) {
     /*
     int sz = getWindow().getWidth() * getWindow().getHeight();

src/Room.cpp

 
 int Room::getAdjoiningRoom(float x, float y, float z,
                            float x2, float y2, float z2) {
-    float vertices[4][3];
     glm::vec3 orig(x, y, z);
     glm::vec3 dir(x2 - x, y2 - y, z2 - z);
     glm::vec3 intersect;
-    glm::vec3 verts[4];
 
     for (unsigned long i = 0; i < portals.size(); i++) {
-        portals.at(i)->getVertices(vertices);
-        verts[0] = glm::vec3(vertices[0][0], vertices[0][1], vertices[0][2]);
-        verts[1] = glm::vec3(vertices[1][0], vertices[1][1], vertices[1][2]);
-        verts[2] = glm::vec3(vertices[2][0], vertices[2][1], vertices[2][2]);
-        verts[3] = glm::vec3(vertices[3][0], vertices[3][1], vertices[3][2]);
-
-        if ((glm::intersectLineTriangle(orig, dir, verts[0], verts[1], verts[2], intersect))
-            || (glm::intersectLineTriangle(orig, dir, verts[0], verts[3], verts[1], intersect)))
+        if ((glm::intersectLineTriangle(orig, dir, portals.at(i)->getVertex(0),
+                                        portals.at(i)->getVertex(1),
+                                        portals.at(i)->getVertex(2), intersect))
+            || (glm::intersectLineTriangle(orig, dir, portals.at(i)->getVertex(0),
+                                           portals.at(i)->getVertex(3),
+                                           portals.at(i)->getVertex(1), intersect)))
             return portals.at(i)->getAdjoiningRoom();
     }
 

src/RoomData.cpp

 
 // ----------------------------------------------------------------------------
 
-Portal::Portal(glm::vec3 vert[4], float norm[3], int adj) {
-    for (unsigned int i = 0; i < 4; i++) {
-        for (unsigned int j = 0; j < 3; j++) {
-            vertices[i][j] = vert[i][j];
-        }
-
-        if (i < 3) {
-            normal[i] = norm[i];
-        }
-    }
-
-    adjoiningRoom = adj;
-}
-
-void Portal::getVertices(float vert[4][3]) {
-    for (unsigned int i = 0; i < 4; i++) {
-        for (unsigned int j = 0; j < 3; j++) {
-            vert[i][j] = vertices[i][j];
-        }
-    }
-}
-
-int Portal::getAdjoiningRoom() {
-    return adjoiningRoom;
-}
-
-// ----------------------------------------------------------------------------
-
 float Sector::getFloor() {
     return floor;
 }

src/UI.cpp

 #include <cstring>
 
 #include "global.h"
+#include "Camera.h"
 #include "Console.h"
 #include "Game.h"
 #include "Log.h"
                 getWindow().setFullscreen(fullscreen);
             }
 
+            bool updateViewFrustum = Camera::getUpdateViewFrustum();
+            if (ImGui::Checkbox("Update Frustum##runtime", &updateViewFrustum)) {
+                Camera::setUpdateViewFrustum(updateViewFrustum);
+            }
+            ImGui::SameLine();
+            bool displayViewFrustum = Render::getDisplayViewFrustum();
+            if (ImGui::Checkbox("Show Frustum##runtime", &displayViewFrustum)) {
+                Render::setDisplayViewFrustum(displayViewFrustum);
+            }
+
             float vol = Sound::getVolume();
             if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3,
                                   ImGuiInputTextFlags_EnterReturnsTrue)) {

src/World.cpp

     destroy();
 }
 
+void World::destroy() {
+    mRooms.clear();
+    mSprites.clear();
+    mEntities.clear();
+    mModels.clear();
+    mStaticMeshes.clear();
+    mMeshes.clear();
+}
+
 void World::addRoom(Room* room) {
     mRooms.emplace_back(std::unique_ptr<Room>(room));
 }
     return *mMeshes.at(index);
 }
 
-
-long World::getRoomByLocation(long index, float x, float y, float z) {
-    assert(index >= 0);
-    assert(index < (long)mRooms.size());
-    Room& room = *mRooms.at(index);
-
-    if (room.getBoundingBox().inBox(x, y, z))
-        return index;
-    else
-        return getRoomByLocation(x, y, z);
-}
-
-
-long World::getRoomByLocation(float x, float y, float z) {
-    long hop = -1;
-
-    for (unsigned long i = 0; i < mRooms.size(); i++) {
-        if (mRooms.at(i)->getBoundingBox().inBoxPlane(x, z)) {
-            if (mRooms.at(i)->getBoundingBox().inBox(x, y, z))
-                return i;
-            else
-                hop = i; // This room is above or below current position
-        }
-    }
-
-    return hop;
-}
-
-
-void World::destroy() {
-    mRooms.clear();
-    mSprites.clear();
-    mEntities.clear();
-    mModels.clear();
-    mStaticMeshes.clear();
-    mMeshes.clear();
-}
-

src/loader/LoaderTR2.cpp

         }
 
         uint16_t numPortals = file.readU16();
+        std::vector<Portal*> portals;
         for (unsigned int p = 0; p < numPortals; p++) {
             // Which room this portal leads to
             uint16_t adjoiningRoom = file.readU16();
             int16_t yCorner4 = file.read16();
             int16_t zCorner4 = file.read16();
 
-            // TODO store portals
+            //! \fixme TODO translate vertices by room offset!
+
+            portals.push_back(new Portal(adjoiningRoom,
+                                         glm::vec3(xNormal, yNormal, zNormal),
+                                         glm::vec3(xCorner1, yCorner1, zCorner1),
+                                         glm::vec3(xCorner2, yCorner2, zCorner2),
+                                         glm::vec3(xCorner3, yCorner3, zCorner3),
+                                         glm::vec3(xCorner4, yCorner4, zCorner4)));
         }
 
         uint16_t numZSectors = file.readU16();
         Room* room = new Room(pos, boundingbox, mesh, roomFlags, alternateRoom,
                               numXSectors, numZSectors);
 
+        for (auto p : portals)
+            room->addPortal(p);
+
         for (auto m : staticModels)
             room->addModel(m);