From b80c2790d0c45a3757e3367ccbc9cdc67d597acb Mon Sep 17 00:00:00 2001
From: XProger <xproger@list.ru>
Date: Sat, 10 Sep 2016 23:01:45 +0300
Subject: [PATCH] #5 fix portals culling, add camera controller

---
 bin/OpenLara.exe | Bin 40448 -> 41472 bytes
 src/camera.h     | 333 ++++++++++++++++++++++++++++++-----------------
 src/controller.h |  31 +++--
 src/debug.h      |  97 +++++++++++++-
 src/format.h     |  61 ++++++++-
 src/level.h      | 230 +++++++++++++++-----------------
 src/mesh.h       |  19 ++-
 src/utils.h      |  12 ++
 8 files changed, 512 insertions(+), 271 deletions(-)

diff --git a/bin/OpenLara.exe b/bin/OpenLara.exe
index a6ffd44b4bc40b25657b7c67a2699baf9c17bb90..00167a67247e0e354fa1b83eaa06277f242c6f09 100644
GIT binary patch
delta 16222
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
b|6l#`)2BCtHKpzen6!<i#3uWmUeo^t%1!R@

delta 15344
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

diff --git a/src/camera.h b/src/camera.h
index 8cced19..63b6cc4 100644
--- a/src/camera.h
+++ b/src/camera.h
@@ -2,135 +2,194 @@
 #define H_CAMERA
 
 #include "core.h"
+#include "controller.h"
 
-#define MAX_CLIP_PLANES 16
+#define MAX_CLIP_PLANES 10
 
-struct Camera {
 
-    struct Frustum {
+struct Frustum {
 
-        struct Poly {
-            vec3    vertices[MAX_CLIP_PLANES];
-            int     count;
-        };
+    struct Poly {
+        vec3    vertices[MAX_CLIP_PLANES];
+        int     count;
+    };
 
-        vec3 pos;
-        vec4 planes[MAX_CLIP_PLANES];
-        int  count;
+    vec3 pos;
+    vec4 planes[MAX_CLIP_PLANES];
+    int  count;
+#ifdef _DEBUG
+    int dbg;
+    Poly debugPoly;
+#endif
+    void calcPlanes(const mat4 &m) {
+    #ifdef _DEBUG
+        dbg = 0;
+    #endif
+        count = 5;
+        planes[0] = vec4(m.e30 - m.e20, m.e31 - m.e21, m.e32 - m.e22, m.e33 - m.e23); // near
+        planes[1] = vec4(m.e30 - m.e10, m.e31 - m.e11, m.e32 - m.e12, m.e33 - m.e13); // top
+        planes[2] = vec4(m.e30 - m.e00, m.e31 - m.e01, m.e32 - m.e02, m.e33 - m.e03); // right
+        planes[3] = vec4(m.e30 + m.e10, m.e31 + m.e11, m.e32 + m.e12, m.e33 + m.e13); // bottom
+        planes[4] = vec4(m.e30 + m.e00, m.e31 + m.e01, m.e32 + m.e02, m.e33 + m.e03); // left
+        for (int i = 0; i < count; i++)
+            planes[i] *= 1.0f / planes[i].xyz.length();
+    }
 
-        void calcPlanes(const mat4 &m) {
-            count = 4;
-            planes[0] = vec4(m.e30 - m.e00, m.e31 - m.e01, m.e32 - m.e02, m.e33 - m.e03); // right
-            planes[1] = vec4(m.e30 + m.e00, m.e31 + m.e01, m.e32 + m.e02, m.e33 + m.e03); // left
-            planes[2] = vec4(m.e30 - m.e10, m.e31 - m.e11, m.e32 - m.e12, m.e33 - m.e13); // top
-            planes[3] = vec4(m.e30 + m.e10, m.e31 + m.e11, m.e32 + m.e12, m.e33 + m.e13); // bottom
-            for (int i = 0; i < count; i++)
-                planes[i] *= 1.0f / planes[i].xyz.length();
+    void calcPlanes(const Poly &poly) {
+        count = 1 + poly.count; // add one for near plane (not changing)
+        ASSERT(count < MAX_CLIP_PLANES);
+        if (count < 4) return;
+
+        vec3 e1 = poly.vertices[0] - pos;
+        for (int i = 1; i < count; i++) {
+            vec3 e2 = poly.vertices[i % poly.count] - pos;
+            planes[i].xyz =  e1.cross(e2).normal();
+            planes[i].w   = -(pos.dot(planes[i].xyz));
+            e1 = e2;
         }
+    #ifdef _DEBUG
+        dbg++;
+        debugPoly = poly;
+    #endif
+    }
 
-        void calcPlanes(const Poly &poly) {
-            count = poly.count;
-            ASSERT(count < MAX_CLIP_PLANES);
-            if (!count) return;
+#ifdef _DEBUG
+    void debug() {
+        if (debugPoly.count < 3) return;
 
-            vec3 e1 = poly.vertices[0] - pos;
-            for (int i = 0; i < count; i++) {
-                vec3 e2 = poly.vertices[(i + 1) % count] - pos;
-                planes[i].xyz = e1.cross(e2).normal();
-                planes[i].w   = -(pos.dot(planes[i].xyz));
-                e1 = e2;
+        glUseProgram(0);
+        Core::setBlending(bmAdd);
+        glDisable(GL_DEPTH_TEST);
+        glBegin(GL_TRIANGLES);
+        for (int i = 0; i < debugPoly.count; i++) {
+            glVertex3fv((GLfloat*)&pos);
+            glVertex3fv((GLfloat*)&debugPoly.vertices[i]);
+            glVertex3fv((GLfloat*)&debugPoly.vertices[(i + 1) % debugPoly.count]);
+        }
+        glEnd();
+
+        glColor3f(0, 1, 0);
+        glBegin(GL_LINE_STRIP);
+        for (int i = 0; i <= debugPoly.count; i++) {
+            glVertex3fv((GLfloat*)&debugPoly.vertices[i % debugPoly.count]);
+        }
+        glEnd();
+
+        glEnable(GL_DEPTH_TEST);
+        Core::setBlending(bmAlpha);
+    }
+#endif
+
+    void clipPlane(const Poly &src, Poly &dst, const vec4 &plane) {
+        dst.count = 0;
+        if (!src.count) return;
+
+        float t1 = src.vertices[0].dot(plane.xyz) + plane.w;
+
+        for (int i = 0; i < src.count; i++) {
+            const vec3 &v1 = src.vertices[i];
+            const vec3 &v2 = src.vertices[(i + 1) % src.count];
+
+            float t2 = v2.dot(plane.xyz) + plane.w;
+        
+        // hack for big float numbers
+            int s1 = sign((int)t1);
+            int s2 = sign((int)t2);
+
+            if (s1 >= 0) {
+                dst.vertices[dst.count++] = v1;
+                ASSERT(dst.count < MAX_CLIP_PLANES);
             }
-        }
-
-        void clipPlane(const Poly &src, Poly &dst, const vec4 &plane) {
-            dst.count = 0;
-            if (!src.count) return;
-
-            float t1 = src.vertices[0].dot(plane.xyz) + plane.w;
-
-            for (int i = 0; i < src.count; i++) {
-                const vec3 &v1 = src.vertices[i];
-                const vec3 &v2 = src.vertices[(i + 1) % src.count];
-
-                float t2 = v2.dot(plane.xyz) + plane.w;
-
-                if (t1 >= 0.0f) {
-                    dst.vertices[dst.count++] = v1;
-                    ASSERT(dst.count < MAX_CLIP_PLANES);
-                }
             
-                if (t1 * t2 < 0.0f) {
-                    float k1 = t2 / (t2 - t1);
-                    float k2 = t1 / (t2 - t1);
-                    dst.vertices[dst.count++] = v1 * k1 - v2 * k2;
-                    ASSERT(dst.count < MAX_CLIP_PLANES);
-                }
-
-                t1 = t2;
+            if (s1 * s2 < 0) {
+                float k1 = t2 / (t2 - t1);
+                float k2 = t1 / (t2 - t1);
+                dst.vertices[dst.count++] = v1 * (float)k1 - v2 * (float)k2;
+                ASSERT(dst.count < MAX_CLIP_PLANES);
             }
-        }
 
-        bool clipByPortal(const vec3 *vertices, const vec3 &normal) { // 4 vertices
-            if (normal.dot(pos - vertices[0]) < 0.0f) // check portal winding order
+            t1 = t2;
+        }
+    }
+
+    bool clipByPortal(const vec3 *vertices, int vCount, const vec3 &normal) {
+        if (normal.dot(pos - vertices[0]) < 0.0f) // check portal winding order
+            return false;
+
+        Poly poly[2];
+
+        poly[0].count = vCount;
+        memmove(poly[0].vertices, vertices, sizeof(vec3) * poly[0].count);
+#ifdef _DEBUG
+        debugPoly.count = 0;
+#endif
+        int j = 0;
+        for (int i = 1; i < count; i++, j ^= 1)
+            clipPlane(poly[j], poly[j ^ 1], planes[i]);
+
+        calcPlanes(poly[j]);
+        return count >= 4;
+    }
+
+    bool isVisible(const vec3 &min, const vec3 &max) const {
+        if (count < 4) return false;
+
+        for (int i = 0; i < count; i++) {
+            const vec3 &n =  planes[i].xyz;
+            const float d = -planes[i].w;
+
+            if (n.dot(max) < d && 
+                n.dot(min) < d &&
+                n.dot(vec3(min.x, max.y, max.z)) < d &&
+                n.dot(vec3(max.x, min.y, max.z)) < d &&
+                n.dot(vec3(min.x, min.y, max.z)) < d &&
+                n.dot(vec3(max.x, max.y, min.z)) < d &&
+                n.dot(vec3(min.x, max.y, min.z)) < d &&
+                n.dot(vec3(max.x, min.y, min.z)) < d)
                 return false;
+        }
+        return true;
+    }
 
-            Poly poly[2];
+    bool isVisible(const vec3 &center, float radius) {
+        if (count < 4) return false;
 
-            poly[0].count = 4;
-            memmove(poly[0].vertices, vertices, sizeof(vec3) * poly[0].count);
-
-            int j = 0;
-            for (int i = 0; i < count; i++, j ^= 1)
-                clipPlane(poly[j], poly[j ^ 1], planes[i]);
-
-            if (poly[j].count < 3)
+        for (int i = 0; i < count; i++)
+            if (planes[i].xyz.dot(center) + planes[i].w < -radius)
                 return false;
+        return true;
+    }
 
-            calcPlanes(poly[j]);
-            return true;
-        }
+};
 
-        bool isVisible(const vec3 &min, const vec3 &max) const {
-            if (count < 3) return false;
 
-            for (int i = 0; i < count; i++) {
-                const vec3 &n = planes[i].xyz;
-                const float d = -planes[i].w;
-
-                if (n.dot(max) < d &&
-                    n.dot(vec3(min.x, max.y, max.z)) < d &&
-                    n.dot(vec3(max.x, min.y, max.z)) < d &&
-                    n.dot(vec3(min.x, min.y, max.z)) < d &&
-                    n.dot(vec3(max.x, max.y, min.z)) < d &&
-                    n.dot(vec3(min.x, max.y, min.z)) < d &&
-                    n.dot(vec3(max.x, min.y, min.z)) < d &&
-                    n.dot(min) < d)
-                    return false;
-            }
-            return true;
-        }
-
-        bool isVisible(const vec3 &center, float radius) {
-            if (count < 3) return false;
-
-            for (int i = 0; i < count; i++)
-                if (planes[i].xyz.dot(center) + planes[i].w < -radius)
-                    return false;
-            return true;
-        }
-
-    } *frustum;
+struct Camera : Controller {
+    Controller  *owner;
+    Frustum     *frustum;
 
     float fov, znear, zfar;
-    vec3 pos, angle, offset, deltaPos, deltaAngle, targetDeltaPos, targetAngle;
+    vec3 pos, target;
 
-    Camera() : frustum(new Frustum()) {}
+    int         room;
+
+    Camera(TR::Level *level, Controller *owner) : Controller(level, owner->entity), owner(owner), frustum(new Frustum()) {
+        fov          = 75.0f;
+        znear        = 0.1f * 2048.0f;
+        zfar         = 1000.0f * 2048.0f;
+        angle.y += PI;
+        
+        room = owner->getEntity().room;
+    }
 
     ~Camera() {
         delete frustum;
     }
 
-    void update() {
+    virtual TR::Room& getRoom() {
+        return level->rooms[room];
+    }
+
+    virtual void update() {
     #ifdef FREE_CAMERA
         vec3 dir = vec3(sinf(angle.y - PI) * cosf(-angle.x), -sinf(-angle.x), cosf(angle.y - PI) * cosf(-angle.x));
         vec3 v = vec3(0);
@@ -141,35 +200,73 @@ struct Camera {
         if (Input::down[ikA]) v = v - dir.cross(vec3(0, 1, 0));
         pos = pos + v.normal() * (Core::deltaTime * 2048.0f);
     #endif
-        deltaPos = deltaPos.lerp(targetDeltaPos, Core::deltaTime * 10.0f);
-        angle    = angle.lerp(targetAngle, Core::deltaTime);
+    //    deltaPos = deltaPos.lerp(targetDeltaPos, Core::deltaTime * 10.0f);
+    //    angle    = angle.lerp(targetAngle, Core::deltaTime);
+
 
         if (Input::down[ikMouseL]) {
             vec2 delta = Input::mouse.pos - Input::mouse.start.L;
-            deltaAngle.x -= delta.y * 0.01f;
-            deltaAngle.y -= delta.x * 0.01f;
-            deltaAngle.x = min(max(deltaAngle.x + angle.x, -PI * 0.5f + EPS), PI * 0.5f - EPS) - angle.x;
+            angle.x += delta.y * 0.01f;
+        //    angle.y -= delta.x * 0.01f;
             Input::mouse.start.L = Input::mouse.pos;
         }
+ 
+ //       angle.x = owner->angle.x;
+        angle.y = PI - owner->angle.y;
+        angle.z = 0.0f;        
+
+        angle.x  = min(max(angle.x, -80 * DEG2RAD), 80 * DEG2RAD);
+
+        vec3 dir = vec3(sinf(PI - angle.y) * cosf(-angle.x), -sinf(-angle.x), cosf(PI - angle.y) * cosf(-angle.x));
+
+        float height = owner->inWater ? 256.0f : 768.0f;
+
+        target = vec3(owner->pos.x, owner->pos.y - height, owner->pos.z);
+        pos = target - dir * 1024.0;
+
+        FloorInfo info = getFloorInfo((int)pos.x, (int)pos.z);
+        
+        if (info.roomNext != 255) 
+            room = info.roomNext;
+        
+        if (pos.y < info.ceiling) {
+            if (info.roomAbove != 255)
+                room = info.roomAbove;
+            else
+                if (info.ceiling != 0xffff8100)
+                    pos.y = info.ceiling;
+        }
+
+        if (pos.y > info.floor) {
+            if (info.roomBelow != 255)
+                room = info.roomBelow;
+            else
+                if (info.floor != 0xffff8100)
+                    pos.y = info.floor;
+        }
     }
 
     void setup() {
-        Core::mView.identity();
-        Core::mView.translate(vec3(-offset.x, -offset.y, -offset.z));
-        Core::mView.rotateZ(-(angle.z + deltaAngle.z));
-        Core::mView.rotateX(-(angle.x + deltaAngle.x));
-        Core::mView.rotateY(-(angle.y + deltaAngle.y));
-        Core::mView.translate(deltaPos - pos);
-        Core::mView.scale(vec3(-1, -1, 1));
+        Core::mViewInv = mat4(pos, target, vec3(0, -1, 0));
+        Core::mView    = Core::mViewInv.inverse();
+        Core::mProj    = mat4(fov, (float)Core::width / (float)Core::height, znear, zfar);
 
-        Core::mProj = mat4(fov, (float)Core::width / (float)Core::height, znear, zfar);
-
-        Core::mViewProj = Core::mProj * Core::mView;
-        Core::mViewInv  = Core::mView.inverse();
-        Core::viewPos   = Core::mViewInv.getPos();
+        Core::mViewProj = Core::mProj * Core::mView;        
+        Core::viewPos   = Core::mViewInv.offset.xyz;
 
         frustum->pos = Core::viewPos;
         frustum->calcPlanes(Core::mViewProj);
+       
+    #ifdef _DEBUG
+        vec3 offset = vec3(0.0f) - (Input::down[ikR] ? (Core::mViewInv.dir.xyz * 2048 - vec3(0, 2048, 0)) : vec3(0.0f));
+        
+        Core::mViewInv = mat4(pos - offset, target - offset, vec3(0, -1, 0));
+        Core::mView    = Core::mViewInv.inverse();
+        Core::mProj    = mat4(fov, (float)Core::width / (float)Core::height, znear, zfar);
+
+        Core::mViewProj = Core::mProj * Core::mView;        
+        Core::viewPos   = Core::mViewInv.offset.xyz;
+    #endif
     }
 };
 
diff --git a/src/controller.h b/src/controller.h
index f0ff44d..95b2812 100644
--- a/src/controller.h
+++ b/src/controller.h
@@ -65,7 +65,7 @@ struct Controller {
         return level->models[0];
     }
 
-    TR::Room& getRoom() {
+    virtual TR::Room& getRoom() {
         int index = getEntity().room;
         ASSERT(index >= 0 && index < level->roomsCount);
         return level->rooms[index];
@@ -73,9 +73,13 @@ struct Controller {
 
     TR::Room::Sector& getSector(int x, int z, int &dx, int &dz) {
         TR::Room &room = getRoom();
-        
+
         int sx = x - room.info.x;
         int sz = z - room.info.z;
+
+        sx = clamp(sx, 0, (room.xSectors - 1) << 10);
+        sz = clamp(sz, 0, (room.zSectors - 1) << 10);
+
         dx = sx & 1023; // mod 1024
         dz = sz & 1023;
         sx >>= 10;      // div 1024
@@ -118,11 +122,6 @@ struct Controller {
         return exists;
     }
 
-    struct FloorInfo {
-        int floor, ceiling;
-        int roomNext, roomBelow, roomAbove;
-    };
-
     int getOverlap(int fromX, int fromY, int fromZ, int toX, int toZ, int &delta) { 
         int dx, dz;
         TR::Room::Sector &s = getSector(fromX, fromZ, dx, dz);
@@ -154,6 +153,11 @@ struct Controller {
         return floor;
     }
 
+    struct FloorInfo {
+        int floor, ceiling;
+        int roomNext, roomBelow, roomAbove;
+    };
+
     FloorInfo getFloorInfo(int x, int z) {
         int dx, dz;
         TR::Room::Sector &s = getSector(x, z, dx, dz);
@@ -259,8 +263,6 @@ struct Controller {
 #define GLIDE_SPEED         50.0f
 
 struct Lara : Controller {
-    int sc;
-    bool lState;
 
     Lara(TR::Level *level, int entity) : Controller(level, entity) {
     /*
@@ -268,6 +270,11 @@ struct Lara : Controller {
         angle = vec3(0.0f, -0.68f, 0.0f);
         getEntity().room = 15;        
     */
+    /*
+        pos = vec3(41015, 3584, 34494);
+        angle = vec3(0.0f, -PI, 0.0f);
+        getEntity().room = 51;
+    */
     }
 
     virtual void update() {
@@ -425,7 +432,7 @@ struct Lara : Controller {
 
 #ifdef _DEBUG
         // show state transitions for current animation
-
+        static bool lState = false;
         if (Input::down[ikEnter]) {
             if (!lState) {
                 lState = true;
@@ -600,11 +607,11 @@ struct Lara : Controller {
             fIndex = anim->nextFrame - nextAnim->frameStart;
             fTime = fIndex / 30.0f;
         }
-
-
         
         move(velocity * dt);
         collide();
+
+        updateEntity();
         
         lastFrame = fIndex;
     }
diff --git a/src/debug.h b/src/debug.h
index 8907e44..9dea695 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -17,6 +17,8 @@ namespace Debug {
         glPointSize(32);
 
         glUseProgram(0);
+        Core::active.shader = NULL;
+        Core::active.testures[0] = NULL;
     }
 
     void end() {
@@ -25,7 +27,8 @@ namespace Debug {
 
     namespace Draw {
 
-        void box(const vec3 &min, const vec3 &max) {
+        void box(const vec3 &min, const vec3 &max, const vec4 &color) {
+            glColor4fv((GLfloat*)&color);
             glBegin(GL_LINES);
                 glVertex3f(min.x, min.y, min.z);
                 glVertex3f(max.x, min.y, min.z);
@@ -350,6 +353,98 @@ namespace Debug {
             glEnd();
         }
 
+        void meshes(const TR::Level &level) {
+        // static objects
+            for (int i = 0; i < level.roomsCount; i++) {
+                TR::Room &r = level.rooms[i];
+ 
+                for (int j = 0; j < r.meshesCount; j++) {
+                    TR::Room::Mesh &m = r.meshes[j];
+                                        
+                    TR::StaticMesh *sm = level.getMeshByID(m.meshID);
+                    ASSERT(sm != NULL);
+
+                    vec3 min, max, offset = vec3(m.x, m.y, m.z);
+                    sm->getBox(false, m.rotation, min, max); // visible box
+
+                    Debug::Draw::box(offset + min, offset + max, vec4(1, 1, 0, 0.25));
+
+                    if (sm->flags == 2) { // collision box
+                        sm->getBox(true, m.rotation, min, max);
+                        Debug::Draw::box(offset + min - vec3(10.0f), offset + max + vec3(10.0f), vec4(1, 0, 0, 0.50));
+                    }
+
+                    TR::Mesh *mesh = (TR::Mesh*)&level.meshData[level.meshOffsets[sm->mesh] / 2];
+
+                    ASSERT(mesh->radius == 0 || mesh->radius == 0x10000);
+
+                    Debug::Draw::sphere(offset + (min + max) * 0.5f, 128, mesh->radius == 0 ? vec4(0, 0, 1, 1) : vec4(0, 1, 0, 1));
+                }
+            }
+        // dynamic objects            
+            for (int i = 0; i < level.entitiesCount; i++) {
+                TR::Entity &e = level.entities[i];
+                mat4 matrix;
+                matrix.identity();
+                matrix.translate(vec3(e.x, e.y, e.z));
+                matrix.rotateY(e.rotation / 16384.0f * PI * 0.5f);
+
+                for (int j = 0; j < level.modelsCount; j++) {
+                    TR::Model &m = level.models[j];
+                    TR::Node *node = m.node < level.nodesDataSize ? (TR::Node*)&level.nodesData[m.node] : NULL;
+
+                    if (!node) continue; // ???
+
+                    TR::Animation *anim  = m.animation < 0xFFFF ? &level.anims[m.animation] : NULL;
+                    TR::AnimFrame *frame = anim ? (TR::AnimFrame*)&level.frameData[anim->frameOffset >> 1] : NULL;
+
+                    //mat4 m;
+                    //m.identity();
+                   // m.translate(vec3(frame->x, frame->y, frame->z).lerp(vec3(frameB->x, frameB->y, frameB->z), k));
+
+                    int  sIndex = 0;
+                    mat4 stack[20];
+                    mat4 joint;
+
+                    joint.identity();
+                    if (frame) joint.translate(frame->pos);
+
+                    if (e.id == m.id) {
+                        for (int k = 0; k < m.mCount; k++) {
+
+                            if (k > 0 && node) {
+                                TR::Node &t = node[k - 1];
+
+                                if (t.flags & 0x01) joint = stack[--sIndex];
+                                if (t.flags & 0x02) stack[sIndex++] = joint;
+
+                                ASSERT(sIndex >= 0 && sIndex < 20);
+
+                                joint.translate(vec3(t.x, t.y, t.z));
+                            }
+
+                            vec3 a = frame ? frame->getAngle(k) : vec3(0.0f);
+
+                            mat4 rot;
+                            rot.identity();
+                            rot.rotateY(a.y);
+                            rot.rotateX(a.x);
+                            rot.rotateZ(a.z);
+
+                            joint = joint * rot;
+
+                            int offset = level.meshOffsets[m.mStart + k];
+                            TR::Mesh *mesh = (TR::Mesh*)&level.meshData[offset / 2];
+                            Debug::Draw::sphere(matrix * joint * mesh->center, mesh->radius & 0x3FF, mesh->radius > 0x3FF ? vec4(1, 0, 0, 0.5f) : vec4(0, 1, 1, 0.5f));
+                        }
+                        break;
+                    }
+                
+                }
+
+            }
+        }
+
     }
 }
 
diff --git a/src/format.h b/src/format.h
index ba148ac..0c78207 100644
--- a/src/format.h
+++ b/src/format.h
@@ -244,7 +244,7 @@ namespace TR {
             uint16  rotation;
             uint16  intensity;
             uint16  meshID;
-            uint16  align;          // ! not exists in file !
+            uint16  flags;          // ! not exists in file !
         } *meshes;
     };
 
@@ -342,11 +342,20 @@ namespace TR {
     };
 
     struct AnimFrame {
-        int16   minX, minY, minZ;   // Bounding box (low)
-        int16   maxX, maxY, maxZ;   // Bounding box (high)
-        int16   x, y, z;            // Starting offset for this model
+        TR::Vertex  min;   // Bounding box (low)
+        TR::Vertex  max;   // Bounding box (high)
+        TR::Vertex  pos;   // Starting offset for this model
         int16   aCount;
         uint16  angles[0];          // angle frames in YXZ order
+
+        vec3 getAngle(int index) {
+            #define ANGLE_SCALE (2.0f * PI / 1024.0f)
+
+            uint16 b = angles[index * 2 + 0];
+            uint16 a = angles[index * 2 + 1];
+
+            return vec3((a & 0x3FF0) >> 4, ( ((a & 0x000F) << 6) | ((b & 0xFC00) >> 10)), b & 0x03FF) * ANGLE_SCALE;
+        }
     };
 
     struct AnimTexture {
@@ -372,9 +381,40 @@ namespace TR {
     struct StaticMesh {
         uint32  id;             // Static Mesh Identifier
         uint16  mesh;           // Mesh (offset into MeshPointers[])
-        Vertex  vBox[2];
-        Vertex  cBox[2];
+        struct MinMax {
+            int16 minX, maxX, minY, maxY, minZ, maxZ;
+        } box[2];               // visible (minX, maxX, minY, maxY, minZ, maxZ) & collision
         uint16  flags;
+
+        void getBox(bool collision, int rotation, vec3 &min, vec3 &max) {
+            int k = rotation / 16384;
+
+            MinMax &m = box[collision];
+
+            ASSERT(m.minX <= m.maxX && m.minY <= m.maxY && m.minZ <= m.maxZ);
+
+            switch (k) {
+                case 0 : 
+                    min = vec3(m.minX, m.minY, m.minZ);
+                    max = vec3(m.maxX, m.maxY, m.maxZ);
+                    break;
+                case 1 : 
+                    min = vec3(m.minZ, m.minY, -m.maxX);
+                    max = vec3(m.maxZ, m.maxY, -m.minX);
+                    break;
+                case 2 : 
+                    min = vec3(-m.maxX, m.minY, -m.maxZ);
+                    max = vec3(-m.minX, m.maxY, -m.minZ);
+                    break;
+                case 3 : 
+                    min = vec3(-m.maxZ, m.minY, m.minX);
+                    max = vec3(-m.minZ, m.maxY, m.maxX);
+                    break;
+                default :
+                    ASSERT(false);
+            }
+            ASSERT(min.x <= max.x && min.y <= max.y && min.z <= max.z);
+        }
     };
 
     struct Tile {
@@ -589,7 +629,7 @@ namespace TR {
             // meshes
                 r.meshes = new Room::Mesh[stream.read(r.meshesCount)];
                 for (int i = 0; i < r.meshesCount; i++)
-                    stream.raw(&r.meshes[i], sizeof(r.meshes[i]) - sizeof(r.meshes[i].align));
+                    stream.raw(&r.meshes[i], sizeof(r.meshes[i]) - sizeof(r.meshes[i].flags));
             // misc flags
                 stream.read(r.alternateRoom);
                 stream.read(r.flags);
@@ -706,6 +746,13 @@ namespace TR {
             delete[] soundData;
             delete[] soundOffsets;
         }
+
+        TR::StaticMesh* getMeshByID(int id) const { // TODO: map this
+            for (int i = 0; i < staticMeshesCount; i++)
+                if (staticMeshes[i].id == id)
+                    return &staticMeshes[i];
+            return NULL;
+        }
     };
 }
 
diff --git a/src/level.h b/src/level.h
index 15fd2a6..4903fe6 100644
--- a/src/level.h
+++ b/src/level.h
@@ -7,6 +7,7 @@
 #include "controller.h"
 #include "camera.h"
 
+
 #ifdef _DEBUG
     #include "debug.h"
 #endif
@@ -24,9 +25,9 @@ struct Level {
     MeshBuilder *mesh;
 
     Controller  *lara;
+    Camera      *camera;
 
     float       time;
-    Camera      camera;
 
     Level(Stream &stream) : level{stream}, time(0.0f) {
         mesh = new MeshBuilder(level);
@@ -42,15 +43,8 @@ struct Level {
                 break;
             }
 
-        lara = new Lara(&level, entity);
-
-        camera.fov          = 75.0f;
-        camera.znear        = 0.1f * 2048.0f;
-        camera.zfar         = 1000.0f * 2048.0f;
-        camera.offset       = vec3(0, 0, 1024);
-        camera.deltaPos     = vec3(0.0f, 768.0f, 0.0f);
-        camera.deltaAngle   = vec3(0.0f, PI, 0.0f);
-        camera.angle        = vec3(0.0f);
+        lara    = new Lara(&level, entity);
+        camera  = new Camera(&level, lara);
     }
 
     ~Level() {
@@ -59,6 +53,7 @@ struct Level {
         delete atlas;
         delete mesh;
 
+        delete camera;
         delete lara;
     }
 
@@ -144,13 +139,6 @@ struct Level {
     */ 
     }
 
-    TR::StaticMesh* getMeshByID(int id) {
-        for (int i = 0; i < level.staticMeshesCount; i++)
-            if (level.staticMeshes[i].id == id)
-                return &level.staticMeshes[i];
-        return NULL;
-    }
-
     Shader *setRoomShader(const TR::Room &room, float intensity) {
         if (room.flags & TR::ROOM_FLAG_WATER) {
             Core::color = vec4(0.6f * intensity, 0.9f * intensity, 0.9f * intensity, 1.0f);
@@ -161,107 +149,120 @@ struct Level {
         }
     }
 
-    void renderRoom(int index) {
-        ASSERT(index >= 0 && index < level.roomsCount);
-
-        TR::Room &room = level.rooms[index];
-
-        if (room.flags & TR::ROOM_FLAG_VISIBLE) return; // already rendered
-        room.flags |= TR::ROOM_FLAG_VISIBLE;
+    void renderRoom(int roomIndex, int from = -1) {
+        ASSERT(roomIndex >= 0 && roomIndex < level.roomsCount);
 
+        TR::Room &room = level.rooms[roomIndex];
         vec3 offset = vec3(room.info.x, 0.0f, room.info.z);
 
-        mat4 m = Core::mModel;
-        Core::mModel.translate(offset);
-        Core::ambient       = vec3(1.0f);
-        Core::lightColor    = vec4(0.0f, 0.0f, 0.0f, 1.0f);
-
         Shader *sh = setRoomShader(room, 1.0f);
 
         sh->bind();
-        sh->setParam(uModel, Core::mModel);
         sh->setParam(uColor, Core::color);
-        sh->setParam(uAmbient, Core::ambient);
-        sh->setParam(uLightColor, Core::lightColor);
 
-    // render room geometry
-        mesh->renderRoomGeometry(index);
-
-    // render room sprites
-        if (mesh->hasRoomSprites(index)) {
-            sh = shaders[shSprite];
-            sh->bind();
-            sh->setParam(uModel, Core::mModel);
-            sh->setParam(uColor, Core::color);
-            mesh->renderRoomSprites(index);
-        }
-
-        Core::mModel = m;
-
-        // meshes
+    // room static meshes
         for (int i = 0; i < room.meshesCount; i++) {
             TR::Room::Mesh &rMesh = room.meshes[i];
-            TR::StaticMesh *sMesh = getMeshByID(rMesh.meshID);
+            if ((rMesh.flags & TR::ROOM_FLAG_VISIBLE)) continue;    // skip if already rendered
+
+            TR::StaticMesh *sMesh = level.getMeshByID(rMesh.meshID);
             ASSERT(sMesh != NULL);
 
-            mat4 m = Core::mModel;
-            Core::mModel.translate(vec3((float)rMesh.x, (float)rMesh.y, (float)rMesh.z));
+        // check visibility
+            vec3 min, max, offset = vec3(rMesh.x, rMesh.y, rMesh.z);
+            sMesh->getBox(false, rMesh.rotation, min, max);
+            if (!camera->frustum->isVisible(offset + min, offset + max))
+                continue;           
+            rMesh.flags |= TR::ROOM_FLAG_VISIBLE;
+
+        // set light parameters
+            getLight(offset, roomIndex);
+
+        // render static mesh
+            mat4 mTemp = Core::mModel;
+            Core::mModel.translate(offset);
             Core::mModel.rotateY(rMesh.rotation / 16384.0f * PI * 0.5f);
-
-            // TODO: check visibility for sMesh.vBox
-
-            getLight(vec3(rMesh.x, rMesh.y, rMesh.z), index);
-
             renderMesh(sMesh->mesh);
-
-            Core::mModel = m;
+            Core::mModel = mTemp;
         }
-        
-        Camera::Frustum *camFrustum = camera.frustum;   // push camera frustum
-        Camera::Frustum frustum = *camFrustum;
-        camera.frustum = &frustum;
+
+    // room geometry & sprites
+        if (!(room.flags & TR::ROOM_FLAG_VISIBLE)) {    // skip if already rendered
+            room.flags |= TR::ROOM_FLAG_VISIBLE;
+
+            Core::lightColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);
+            Core::ambient    = vec3(1.0f);
+            sh->setParam(uLightColor, Core::lightColor);
+            sh->setParam(uAmbient, Core::ambient);
+
+            mat4 mTemp = Core::mModel;
+            Core::mModel.translate(offset);
+
+        // render room geometry
+            sh->setParam(uModel, Core::mModel);
+            mesh->renderRoomGeometry(roomIndex);
+
+        // render room sprites
+            if (mesh->hasRoomSprites(roomIndex)) {
+                sh = shaders[shSprite];
+                sh->bind();
+                sh->setParam(uModel, Core::mModel);
+                sh->setParam(uColor, Core::color);
+                mesh->renderRoomSprites(roomIndex);
+            }
+
+            Core::mModel = mTemp;
+        }
+
+    // render rooms through portals recursively
+        Frustum *camFrustum = camera->frustum;   // push camera frustum
+        Frustum frustum;
+        camera->frustum = &frustum;
 
         for (int i = 0; i < room.portalsCount; i++) {
             TR::Room::Portal &p = room.portals[i];
 
-            vec3 v[4] = {
+            if (p.roomIndex == from) continue;
+
+            vec3 v[] = {
                 offset + p.vertices[0],
                 offset + p.vertices[1],
                 offset + p.vertices[2],
                 offset + p.vertices[3],
             };
 
-            if (frustum.clipByPortal(v, p.normal)) {
-                renderRoom(p.roomIndex);
-                frustum = *camFrustum;
-            }
+            frustum = *camFrustum;
+            if (frustum.clipByPortal(v, 4, p.normal))
+                renderRoom(p.roomIndex, roomIndex);
         }
-        camera.frustum = camFrustum;    // pop camera frustum
+        camera->frustum = camFrustum;    // pop camera frustum
+        
+    #ifdef _DEBUG
+        glColor3f(0, 0.05, 0);
+        camera->frustum->debug();
+    #endif
+    }
+
+    MeshBuilder::MeshInfo* getMeshInfoByOffset(uint32 meshOffset) {
+        if (!level.meshOffsets[meshOffset] && meshOffset)
+            return NULL;
+
+        for (int i = 0; i < mesh->mCount; i++)
+            if (mesh->meshInfo[i].offset == level.meshOffsets[meshOffset])
+                return &mesh->meshInfo[i];
+
+        return NULL;
     }
 
     void renderMesh(uint32 meshOffset) {
-        if (!level.meshOffsets[meshOffset] && meshOffset)
-            return;
+        MeshBuilder::MeshInfo *m = getMeshInfoByOffset(meshOffset);
+        ASSERT(m != NULL);
+        if (!m) return;
 
-        for (int i = 0; i < mesh->mCount; i++)
-            if (mesh->meshInfo[i].offset == level.meshOffsets[meshOffset]) {
-                MeshBuilder::MeshInfo &m = mesh->meshInfo[i];
-
-                if (camera.frustum->isVisible(Core::mModel * m.center, m.radius)) {
-                    Core::active.shader->setParam(uModel, Core::mModel);
-                    mesh->renderMesh(i);
-                }
-                break;
-            }
-    }
-
-    vec3 getAngle(TR::AnimFrame *frame, int index) {
-        #define ANGLE_SCALE (2.0f * PI / 1024.0f)
-
-        uint16 b = frame->angles[index * 2 + 0];
-        uint16 a = frame->angles[index * 2 + 1];
-
-        return vec3((a & 0x3FF0) >> 4, ( ((a & 0x000F) << 6) | ((b & 0xFC00) >> 10)), b & 0x03FF) * ANGLE_SCALE;
+        if ((m->radius & 0xFFFF) == 0 || camera->frustum->isVisible(Core::mModel * m->center, (m->radius & 0x3FF)) * 2) {
+            Core::active.shader->setParam(uModel, Core::mModel);
+            mesh->renderMesh(m);
+        }
     }
 
     float lerpAngle(float a, float b, float t) {
@@ -327,23 +328,7 @@ struct Level {
         } else
             nextAnim = anim;
 
-//      LOG("%d %f\n", fIndexA, fTime);
-
-
         TR::AnimFrame *frameB = (TR::AnimFrame*)&level.frameData[(nextAnim->frameOffset + fIndexB * fSize) >> 1];
-
-
-
-//      ASSERT(fpSize == fSize);
-//      fSize = fpSize;
-
-    //  LOG("%d\n", fIndex % fCount);
-        //if (fCount > 1) LOG("%d %d\n", model->id, fCount);
-    //  LOG("%d\n", fIndex % fCount);
-
-
-//      Debug::Draw::box(Box(vec3(frameA->minX, frameA->minY, frameA->minZ), vec3(frameA->maxX, frameA->maxY, frameA->maxZ)));
-
         TR::Node *node = (int)model.node < level.nodesDataSize ? (TR::Node*)&level.nodesData[model.node] : NULL;
 
         int sIndex = 0;
@@ -351,7 +336,7 @@ struct Level {
 
         mat4 m;
         m.identity();
-        m.translate(vec3(frameA->x, frameA->y, frameA->z).lerp(vec3(frameB->x, frameB->y, frameB->z), k));
+        m.translate(((vec3)frameA->pos).lerp(frameB->pos, k));
 
         for (int i = 0; i < model.mCount; i++) {
 
@@ -361,13 +346,12 @@ struct Level {
                 if (t.flags & 0x01) m = stack[--sIndex];
                 if (t.flags & 0x02) stack[sIndex++] = m;
 
-                ASSERT(sIndex >= 0);
-                ASSERT(sIndex < 20);
+                ASSERT(sIndex >= 0 && sIndex < 20);
 
                 m.translate(vec3(t.x, t.y, t.z));
             }
 
-            quat q = lerpAngle(getAngle(frameA, i), getAngle(frameB, i), k);
+            quat q = lerpAngle(frameA->getAngle(i), frameB->getAngle(i), k);
             m = m * mat4(q, vec3(0.0f));
 
 
@@ -403,6 +387,7 @@ struct Level {
     void getLight(const vec3 &pos, int roomIndex) {
         int room = roomIndex;
         int idx = getLightIndex(pos, room);
+
         if (idx > -1) {
             TR::Room::Light &light = level.rooms[room].lights[idx];
             float c = level.rooms[room].lights[idx].intensity / 8191.0f;
@@ -412,6 +397,7 @@ struct Level {
             Core::lightPos   = vec3(0);
             Core::lightColor = vec4(0, 0, 0, 1);
         }
+
         Core::ambient = vec3(1.0f - level.rooms[roomIndex].ambient / 8191.0f);
         Core::active.shader->setParam(uAmbient, Core::ambient);
         Core::active.shader->setParam(uLightPos, Core::lightPos);
@@ -470,13 +456,7 @@ struct Level {
     void update() {
         time += Core::deltaTime;
         lara->update();
-
-    #ifndef FREE_CAMERA
-        camera.pos = vec3(-lara->pos.x, -lara->pos.y, lara->pos.z);
-    #endif
-        camera.targetDeltaPos = lara->inWater ? vec3(0.0f, -256.0f, 0.0f) : vec3(0.0f, -768.0f, 0.0f);
-        camera.targetAngle = vec3(lara->angle.x, -lara->angle.y, 0.0f); //-lara->angle.z);
-        camera.update();
+        camera->update();
     }
 
     int getCameraRoomIndex() {
@@ -489,7 +469,7 @@ struct Level {
     void render() {
     //    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
-        camera.setup();;
+        camera->setup();;
 
         atlas->bind(0);
         mesh->bind();
@@ -510,12 +490,17 @@ struct Level {
 
         Core::mModel.identity();
 
-        for (int i = 0; i < level.roomsCount; i++)
-            level.rooms[i].flags &= ~TR::ROOM_FLAG_VISIBLE;    // clear visible flag
+    // clear visible flags for rooms & static meshes
+        for (int i = 0; i < level.roomsCount; i++) {
+            TR::Room &room = level.rooms[i];
+            room.flags &= ~TR::ROOM_FLAG_VISIBLE;           // clear visible flag for room geometry & sprites
+
+            for (int j = 0; j < room.meshesCount; j++)
+                room.meshes[j].flags &= ~TR::ROOM_FLAG_VISIBLE;       // clear visible flag for room static meshes
+        }
 
     // TODO: collision detection for camera
-        renderRoom(getCameraRoomIndex());
-        renderRoom(lara->getEntity().room);
+        renderRoom(camera->room);
 
         shaders[shStatic]->bind();
         for (int i = 0; i < level.entitiesCount; i++)
@@ -523,9 +508,10 @@ struct Level {
 
     #ifdef _DEBUG
         Debug::begin();
-        Debug::Level::rooms(level, lara->pos, lara->getEntity().room);
+    //    Debug::Level::rooms(level, lara->pos, lara->getEntity().room);
     //    Debug::Level::lights(level);
-        Debug::Level::portals(level);
+    //    Debug::Level::portals(level);
+        Debug::Level::meshes(level);
         Debug::end();
     #endif
     }
diff --git a/src/mesh.h b/src/mesh.h
index 6233afa..720be71 100644
--- a/src/mesh.h
+++ b/src/mesh.h
@@ -393,13 +393,7 @@ struct MeshBuilder {
     }
 
     void initAnimTextures(TR::Level &level) {
-        if (!level.animTexturesDataSize) {
-            animTexRangesCount = animTexOffsetsCount = 1;
-            animTexRanges      = new vec2[1];
-            animTexOffsets     = new vec2[1];
-            animTexRanges[0]   = vec2(0.0f, 1.0f);
-            animTexOffsets[0]  = vec2(0.0f);
-        }
+        ASSERT(level.animTexturesDataSize);
 
         uint16 *ptr = &level.animTexturesData[0];
         animTexRangesCount = *ptr++ + 1;
@@ -507,8 +501,9 @@ struct MeshBuilder {
 
         Vertex *quad = &vertices[vCount];
 
-        quad[0].coord = quad[1].coord = quad[2].coord = quad[3].coord = { x, y, z, 0 };
+        quad[0].coord  = quad[1].coord  = quad[2].coord  = quad[3].coord  = { x, y, z, 0 };
         quad[0].normal = quad[1].normal = quad[2].normal = quad[3].normal = { 0, 0, 0, 0 };
+        quad[0].color  = quad[1].color  = quad[2].color  = quad[3].color  = { intensity, intensity, intensity, 255 };
 
         int  tx = (sprite.tile % 4) * 256;
         int  ty = (sprite.tile / 4) * 256;
@@ -523,8 +518,6 @@ struct MeshBuilder {
         quad[2].texCoord = { u1, v1, sprite.l, sprite.b };
         quad[3].texCoord = { u0, v1, sprite.r, sprite.b };
 
-        quad[0].color = quad[1].color = quad[2].color = quad[3].color = { intensity, intensity, intensity, 255 };
-
         vCount += 4;
     }
 
@@ -544,8 +537,12 @@ struct MeshBuilder {
         return roomRanges[roomIndex].sprites.iCount > 0;
     }
 
+    void renderMesh(MeshInfo *meshInfo) {
+        mesh->render(*meshInfo);
+    }
+
     void renderMesh(int meshIndex) {
-        mesh->render(meshInfo[meshIndex]);
+        renderMesh(&meshInfo[meshIndex]);
     }
 
     void renderSprite(int spriteIndex) {
diff --git a/src/utils.h b/src/utils.h
index a7427cc..253d8dd 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -278,6 +278,18 @@ struct mat4 {
 		e23 = 2.0f * zfar * znear / (znear - zfar);
 	}
 
+    mat4(const vec3 &from, const vec3 &at, const vec3 &up) {
+	    vec3 r, u, d;
+	    d = (from - at).normal();
+	    r = up.cross(d).normal();
+	    u = d.cross(r);
+
+	    this->right		= vec4(r, 0.0f);
+	    this->up		= vec4(u, 0.0f);
+	    this->dir		= vec4(d, 0.0f);
+	    this->offset	= vec4(from, 1.0f);
+    }
+
 	void identity() {
 		e10 = e20 = e30 = e01 = e21 = e31 = e02 = e12 = e32 = e03 = e13 = e23 = 0.0f;
 		e00 = e11 = e22 = e33 = 1.0f;