Render using new interface

include/Render.h

      */
     bool isVisible(float x, float y, float z, float radius);
 
+    /*!
+     * \brief Renders a mesh.
+     *
+     * Texture must be initialized.
+     * \param r_mesh Mesh to render.
+     * \param type Must be object containing mesh
+     */
+    void drawModelMesh(model_mesh_t *r_mesh, RenderMeshType type);
+
     //! \fixme should be private
 
     ViewVolume mViewVolume; //!< View Volume for frustum culling
      * only considers its linked rooms and their linked rooms.
      * \param room First room in list
      */
-    void buildRoomRenderList(Room *room);
+    void buildRoomRenderList(Room &room);
 
     /*!
      * \brief Renders visible world object.
      * \param rRoom room to render
      * \param draw_alpha once false, once true
      */
-    void drawRoom(Room *rRoom, bool draw_alpha);
-
-    /*!
-     * \brief Renders static room model.
-     *
-     * Texture must be initialized.
-     * \param mesh Static model to render
-     */
-    void drawRoomModel(StaticModel &mesh);
-
-    /*!
-     * \brief Renders a mesh.
-     *
-     * Texture must be initialized.
-     * \param r_mesh Mesh to render.
-     * \param type Must be object containing mesh
-     */
-    void drawModelMesh(model_mesh_t *r_mesh, RenderMeshType type);
-
-    /*!
-     * \brief Renders a sprite.
-     *
-     * Texture must be initialized.
-     * \param sprite sprite to render
-     */
-    void drawSprite(Sprite &sprite);
+    void drawRoom(Room &rRoom, bool draw_alpha);
 
     /*!
      * \brief Updates View Volume. Call once per render frame.

include/Room.h

 class StaticModel {
 public:
     StaticModel(int _index, vec_t _yaw, vec3_t _pos);
+    void display();
 
     // Compares distance to ViewVolume for depth sorting
     bool operator<(const StaticModel &other);
 public:
     Portal(vec3_t _vertices[4], vec3_t _normal, int _adjoiningRoom);
 
-    vec3_t *getVertices();
+    void getVertices(vec3_t vert[4]);
     int getAdjoiningRoom();
 
 private:
     void setPos(vec3_t p);
     void getPos(vec3_t p);
 
+    void getBoundingBox(vec3_t box[2]);
     void setBoundingBox(vec3_t box[2]);
     bool inBox(vec_t x, vec_t y, vec_t z);
     bool inBoxPlane(vec_t x, vec_t z);
 
+    unsigned int sizeAdjacentRooms();
+    int getAdjacentRoom(unsigned int index);
     void addAdjacentRoom(int r);
 
     unsigned int sizePortals();
     Sector &getSector(unsigned int index);
     void addSector(Sector &s);
 
+    unsigned int sizeBox();
+    Box &getBox(unsigned int index);
     void addBox(Box &b);
+
+    unsigned int sizeModels();
+    StaticModel &getModel(unsigned int index);
     void addModel(StaticModel &m);
-    void addSprite(Sprite &s);
+    void sortModels();
+
+    unsigned int sizeLights();
+    Light &getLight(unsigned int index);
     void addLight(Light &l);
 
+    unsigned int sizeSprites();
+    Sprite &getSprite(unsigned int index);
+    void addSprite(Sprite &s);
+
     Mesh &getMesh();
 
 private:
     std::vector<Sector *> sectors;
 
     // Was previously stored in RenderRoom
-    vec_t dist;                  //!< Distance to near plane, move to room?
+    //vec_t dist;                  //!< Distance to near plane, move to room?
     std::vector<Light *> lights; //!< List of lights in this room
     Mesh mesh;                   //!< OpenGL mesh that represents this room
 };

src/Render.cpp

     return (distA < distB);
 }
 
-bool compareRoomDist(const void *voidA, const void *voidB)
-{
-    const RenderRoom *a = static_cast<const RenderRoom *>(voidA);
-    const RenderRoom *b = static_cast<const RenderRoom *>(voidB);
-
-
-    if (!a || !b || !a->room || !b->room)
-        return false; // error really
-
-    return (a->dist < b->dist);
-}
-
-
 ////////////////////////////////////////////////////////////
 // Constructors
 ////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////
 
 
-void Render::addRoom(RenderRoom *room)
-{
-    mRooms.push_back(room);
-}
-
-
 void Render::loadTexture(unsigned char *image,
         unsigned int width, unsigned int height,
         unsigned int id)
 }
 
 
-void Render::ClearWorld()
-{
+void Render::ClearWorld() {
     mRoomRenderList.clear();
 
-    for (unsigned int i = 0; i < mRooms.size(); i++) {
-        if (mRooms[i])
-            delete mRooms[i];
-    }
-    mRooms.clear();
-
     for (unsigned int i = 0; i < mModels.size(); i++) {
         if (mModels[i])
             delete mModels[i];
 }
 
 
-void lightRoom(RenderRoom *room)
+void lightRoom(Room &room)
 {
-    unsigned int i;
-    Light *light;
-
-
-    for (i = 0; i < room->lights.size(); ++i)
+    for (unsigned int i = 0; i < room.sizeLights(); ++i)
     {
-        light = room->lights[i];
-
-        if (!light)
-            continue;
+        Light &light = room.getLight(i);
 
         glEnable(GL_LIGHT0 + i);
 
-        switch (light->mType)
+        switch (light.mType)
         {
             case Light::typeSpot:
-                glLightf(GL_LIGHT0 + i,  GL_SPOT_CUTOFF,    light->mCutoff);
-                glLightfv(GL_LIGHT0 + i, GL_POSITION,       light->mPos);
-                glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, light->mDir);
-                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,        light->mColor);
+                glLightf(GL_LIGHT0 + i,  GL_SPOT_CUTOFF,    light.mCutoff);
+                glLightfv(GL_LIGHT0 + i, GL_POSITION,       light.mPos);
+                glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, light.mDir);
+                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,        light.mColor);
                 break;
             case Light::typePoint:
             case Light::typeDirectional:
 
                 // GL_QUADRATIC_ATTENUATION
                 // GL_LINEAR_ATTENUATION
-                glLightf(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, light->mAtt);
+                glLightf(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, light.mAtt);
 
-                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, light->mColor); // GL_DIFFUSE
-                glLightfv(GL_LIGHT0 + i, GL_POSITION, light->mPos);
+                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, light.mColor); // GL_DIFFUSE
+                glLightfv(GL_LIGHT0 + i, GL_POSITION, light.mPos);
                 break;
         }
     }
     vec3_t curPos;
     vec3_t camPos;
     vec3_t atPos;
-    RenderRoom *room;
     int index;
 
     switch (mMode)
     // Room solid pass, need to do depth sorting to avoid 2 pass render
     for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
     {
-        room = mRoomRenderList[i];
+        Room &room = *mRoomRenderList[i];
 
-        if (room)
+        if (mFlags & Render::fGL_Lights)
         {
-            if (mFlags & Render::fGL_Lights)
-            {
-                lightRoom(room);
-            }
-
-            drawRoom(room, false);
+            lightRoom(room);
         }
+
+        drawRoom(room, false);
     }
 
     // Draw all visible enities
     {
         for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
         {
-            room = mRoomRenderList[i];
-
-            if (room)
-            {
-                drawRoom(room, true);
-            }
+            drawRoom(*mRoomRenderList[i], true);
         }
     }
 
 void Render::newRoomRenderList(int index)
 {
     static int currentRoomId = -1;
-    RenderRoom *room;
-
 
     if (mFlags & Render::fUsePortals)
     {
         if (index == -1) // -1 is error, so draw room 0, for the hell of it
         {
-            room = mRooms[0];
-
             mRoomRenderList.clear();
-
-            if (room)
-            {
-                mRoomRenderList.push_back(room);
-            }
+            mRoomRenderList.push_back(&getWorld().getRoom(0));
         }
         else
         {
             if (mFlags & Render::fUpdateRoomListPerFrame ||
                     currentRoomId != index)
             {
-                mRoomRenderList.clear();
-                room = mRooms[index];
-                buildRoomRenderList(room);
+                buildRoomRenderList(getWorld().getRoom(index));
             }
         }
     }
             printf("*** Room render list -> %i\n", index);
             mRoomRenderList.clear();
 
-            for (unsigned int i = 0; i < mRooms.size(); i++)
+            for (unsigned int i = 0; i < getWorld().sizeRoom(); i++)
             {
-                room = mRooms[i];
-
-                if (!room || !room->room)
-                    continue;
-
-                if (!isVisible(room->room->bbox_min, room->room->bbox_max))
+                vec3_t bbox[2];
+                getWorld().getRoom(i).getBoundingBox(bbox);
+                if (!isVisible(bbox[0], bbox[1]))
                     continue;
 
-                //room->dist =
-                //mViewVolume.getDistToBboxFromNear(room->room->bbox_min,
-                //                                           room->room->bbox_max);
-
-                mRoomRenderList.push_back(room);
+                mRoomRenderList.push_back(&getWorld().getRoom(i));
             }
         }
     }
 
-    // Depth Sort roomRenderList ( no use in that, work on portals first )
-    std::sort(mRoomRenderList.begin(), mRoomRenderList.end(), compareRoomDist);
-
     currentRoomId = index;
 }
 
 
-void Render::buildRoomRenderList(RenderRoom *rRoom)
+void Render::buildRoomRenderList(Room &room)
 {
-    RenderRoom *rRoom2;
-
-
-    // Must exist
-    if (!rRoom || !rRoom->room)
-        return;
 
     // Must be visible
     //! \fixme Add depth sorting here - remove multipass
-    if (!isVisible(rRoom->room->bbox_min, rRoom->room->bbox_max))
+    vec3_t bbox[2];
+    room.getBoundingBox(bbox);
+    if (!isVisible(bbox[0], bbox[1]))
         return;
 
     // Must not already be cached
     for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
     {
-        rRoom2 = mRoomRenderList[i];
+        Room &room2 = *mRoomRenderList[i];
 
-        if (rRoom2 == rRoom)
+        if (&room2 == &room)
             return;
     }
 
-    //rRoom->dist =
-    //mViewVolume.getDistToBboxFromNear(rRoom->room->bbox_min,
-    //                                           rRoom->room->bbox_max);
-
     /* Add current room to list */
-    mRoomRenderList.push_back(rRoom);
+    mRoomRenderList.push_back(&room);
 
     if (mFlags & Render::fOneRoom)
     {
     }
     else if (mFlags & Render::fAllRooms) /* Are you serious? */
     {
-        for (unsigned int i = 0; i < mRooms.size(); i++)
+        for (unsigned int i = 0; i < getWorld().sizeRoom(); i++)
         {
-            rRoom2 = mRooms[i];
+            Room &room2 = getWorld().getRoom(i);
 
-            if (rRoom2 && rRoom2 != rRoom)
+            if (&room2 != &room)
             {
-                buildRoomRenderList(rRoom2);
+                buildRoomRenderList(room2);
             }
         }
 
     }
 
     // Try to add adj rooms and their adj rooms, skip this room
-    for (unsigned int i = 1; i < rRoom->room->adjacentRooms.size(); i++)
+    for (unsigned int i = 1; i < room.sizeAdjacentRooms(); i++)
     {
-        if (rRoom->room->adjacentRooms[i] < 0)
+        if (room.getAdjacentRoom(i) < 0)
             continue;
 
-        rRoom2 = mRooms[rRoom->room->adjacentRooms[i]];
+        Room &room2 = getWorld().getRoom(room.getAdjacentRoom(i));
 
         // Mongoose 2002.03.22, Add portal visibility check here
 
-        if (rRoom2 && rRoom2 != rRoom)
+        if (&room2 != &room)
         {
-            buildRoomRenderList(rRoom2);
+            buildRoomRenderList(room2);
         }
     }
 }
 
 void Render::drawObjects()
 {
-#ifdef USING_FPS_CAMERA
-    vec3_t curPos;
-#endif
-    sprite_seq_t *sprite;
-    int frame;
-
-
     // Draw lara or other player model ( move to entity rendering method )
     if (mFlags & Render::fViewModel && getGame().mLara && getGame().mLara->tmpHook)
     {
 
         if (mdl)
         {
+            int frame;
 
             // Mongoose 2002.03.22, Test 'idle' aniamtions
             if (!getGame().mLara->moving)
 
         glPushMatrix();
 
-#ifdef USING_FPS_CAMERA
-        getCamera().getPosition(curPos);
-        glTranslated(curPos[0], curPos[1], curPos[2]);
-        glRotated(OR_RAD_TO_DEG(getCamera().getRadianYaw()), 0, 1, 0);
-        glTranslated(0, 500, 1200);
-#else
         glTranslated(getGame().mLara->pos[0], getGame().mLara->pos[1], getGame().mLara->pos[2]);
         glRotated(OR_RAD_TO_DEG(getCamera().getRadianYaw()), 0, 1, 0);
-#endif
 
         drawModel(getGame().mLara->tmpHook);
         glPopMatrix();
     }
 
     // Mongoose 2002.03.22, Draw sprites after player to handle alpha
-    if (mFlags & Render::fSprites)
-    {
-        std::vector<sprite_seq_t *> *sprites;
-
-        sprites = getWorld().getSprites();
-
-        for (unsigned int i = 0; i < sprites->size(); i++)
-        {
-            sprite = sprites->at(i);
-
-            if (!sprite)
-                continue;
-
-            if (sprite->sprite && sprite->num_sprites)
-            {
-                for (int j = 0; j < sprite->num_sprites; j++)
-                {
-                    drawSprite((sprite_t *)(sprite->sprite+j));
-                }
-            }
+    if (mFlags & Render::fSprites) {
+        for (unsigned int i = 0; i < getWorld().sizeSprite(); i++) {
+            SpriteSequence &sprite = getWorld().getSprite(i);
+            for (unsigned int j = 0; j < sprite.size(); j++)
+                sprite.get(j).display();
         }
     }
 }
 }
 
 
-void Render::drawRoom(RenderRoom *rRoom, bool draw_alpha)
+void Render::drawRoom(Room &room, bool draw_alpha)
 {
-    room_mesh_t *room;
-
-
-    if (!rRoom || !rRoom->room)
-        return;
-
-    room = rRoom->room;
-
     if (!(mFlags & Render::fRoomAlpha) && draw_alpha)
         return;
 
     mTexture.bindTextureId(0); // WHITE texture
 
     if (!draw_alpha &&
-            (mFlags & Render::fPortals || mMode == Render::modeWireframe))
-    {
-        portal_t *portal;
-
+            (mFlags & Render::fPortals || mMode == Render::modeWireframe)) {
         glLineWidth(2.0);
         glColor3fv(RED);
 
-        for (unsigned int i = 0; i < room->portals.size(); i++)
-        {
-            portal = room->portals[i];
-
-            if (!portal)
-                continue;
+        for (unsigned int i = 0; i < room.sizePortals(); i++) {
+            Portal &portal = room.getPortal(i);
+            vec3_t vertices[4];
+            portal.getVertices(vertices);
 
             glBegin(GL_LINE_LOOP);
-            glVertex3fv(portal->vertices[0]);
-            glVertex3fv(portal->vertices[1]);
-            glVertex3fv(portal->vertices[2]);
-            glVertex3fv(portal->vertices[3]);
+            glVertex3fv(vertices[0]);
+            glVertex3fv(vertices[1]);
+            glVertex3fv(vertices[2]);
+            glVertex3fv(vertices[3]);
             glEnd();
         }
 
         glLineWidth(1.0);
-
-#ifdef OBSOLETE
-        glColor3fv(RED);
-
-        for (i = 0; i < (int)room->num_boxes; ++i)
-        {
-            // Mongoose 2002.08.14, This is a simple test -
-            //   these like portals are really planes
-            glBegin(GL_QUADS);
-            glVertex3fv(room->boxes[i].a.pos);
-            glVertex3fv(room->boxes[i].b.pos);
-            glVertex3fv(room->boxes[i].c.pos);
-            glVertex3fv(room->boxes[i].d.pos);
-            glEnd();
-        }
-#endif
     }
 
-    if (mMode == Render::modeWireframe && !draw_alpha)
-    {
-        draw_bbox(room->bbox_min, room->bbox_max, true);
+    if (mMode == Render::modeWireframe && !draw_alpha) {
+        vec3_t bbox[2];
+        room.getBoundingBox(bbox);
+        draw_bbox(bbox[0], bbox[1], true);
     }
 
-    glTranslated(room->pos[0], room->pos[1], room->pos[2]);
+    vec3_t pos;
+    room.getPos(pos);
+    glTranslated(pos[0], pos[1], pos[2]);
 
     // Reset since GL_MODULATE used, reset to WHITE
     glColor3fv(WHITE);
     switch (mMode)
     {
         case modeWireframe:
-            rRoom->mesh.mMode = Mesh::MeshModeWireframe;
+            room.getMesh().mMode = Mesh::MeshModeWireframe;
             break;
         case modeSolid:
-            rRoom->mesh.mMode = Mesh::MeshModeSolid;
+            room.getMesh().mMode = Mesh::MeshModeSolid;
             break;
         default:
-            rRoom->mesh.mMode = Mesh::MeshModeTexture;
+            room.getMesh().mMode = Mesh::MeshModeTexture;
             break;
     }
 
     if (draw_alpha)
-    {
-        rRoom->mesh.drawAlpha();
-    }
+        room.getMesh().drawAlpha();
     else
-    {
-        rRoom->mesh.drawSolid();
-    }
+        room.getMesh().drawSolid();
 
     glPopMatrix();
 
     //mTexture.bindTextureId(0);
 
     // Draw other room meshes and sprites
-    if (draw_alpha || mMode == modeWireframe || mMode == modeSolid)
-    {
-        if (mFlags & Render::fRoomModels)
-        {
-            static_model_t *mdl;
-
-            for (unsigned int i = 0; i < room->models.size(); i++)
-            {
-                mdl = room->models[i];
-
-                if (!mdl)
-                    continue;
-
-                mdl->pos[0] += room->pos[0];
-                mdl->pos[1] += room->pos[1];
-                mdl->pos[2] += room->pos[2];
-
-                // Depth sort room model render list with qsort
-                std::sort(room->models.begin(), room->models.end(), compareStaticModels);
-
-                mdl->pos[0] -= room->pos[0];
-                mdl->pos[1] -= room->pos[1];
-                mdl->pos[2] -= room->pos[2];
-            }
-
-            for (unsigned int i = 0; i < room->models.size(); i++)
-            {
-                drawRoomModel(room->models[i]);
+    if (draw_alpha || mMode == modeWireframe || mMode == modeSolid) {
+        if (mFlags & Render::fRoomModels) {
+            room.sortModels();
+            for (unsigned int i = 0; i < room.sizeModels(); i++) {
+                room.getModel(i).display();
             }
         }
 
         // Draw other room alpha polygon objects
-        if (mFlags & Render::fSprites)
-        {
-            for (unsigned int i = 0; i < room->sprites.size(); i++)
-            {
-                drawSprite(room->sprites[i]);
+        if (mFlags & Render::fSprites) {
+            for (unsigned int i = 0; i < room.sizeSprites(); i++) {
+                room.getSprite(i).display();
             }
         }
     }
 }
 
 
-void Render::drawSprite(sprite_t *sprite)
-{
-    if (!sprite)
-        return;
-
-    if (!isVisible(sprite->pos[0], sprite->pos[1], sprite->pos[2],
-                sprite->radius))
-        return;
-
-    glPushMatrix();
-    glTranslated(sprite->pos[0], sprite->pos[1], sprite->pos[2]);
-
-    // Sprites must always face camera, because they have no depth  =)
-    glRotated(OR_RAD_TO_DEG(getCamera().getRadianYaw()), 0, 1, 0);
-
-    switch (mMode)
-    {
-        // No vertex lighting on sprites, as far as I see in specs
-        // So just draw normal texture, no case 2
-        case Render::modeSolid:
-            glBegin(GL_TRIANGLE_STRIP);
-            glColor3f(sprite->texel[0].st[0], sprite->texel[0].st[1], 0.5);
-            glVertex3fv(sprite->vertex[0].pos);
-
-            glColor3f(sprite->texel[1].st[0], sprite->texel[1].st[1], 0.5);
-            glVertex3fv(sprite->vertex[1].pos);
-
-            glColor3f(sprite->texel[3].st[0], sprite->texel[3].st[1], 0.5);
-            glVertex3fv(sprite->vertex[3].pos);
-
-            glColor3f(sprite->texel[2].st[0], sprite->texel[2].st[1], 0.5);
-            glVertex3fv(sprite->vertex[2].pos);
-            glEnd();
-            break;
-        case Render::modeWireframe:
-            glColor3fv(CYAN);
-            glBegin(GL_LINE_LOOP);
-            glVertex3fv(sprite->vertex[0].pos);
-            glVertex3fv(sprite->vertex[1].pos);
-            glVertex3fv(sprite->vertex[2].pos);
-            glVertex3fv(sprite->vertex[3].pos);
-            glEnd();
-            glColor3fv(WHITE);
-            break;
-        default:
-            glBindTexture(GL_TEXTURE_2D, sprite->texture+1);
-
-            glBegin(GL_TRIANGLE_STRIP);
-            glTexCoord2fv(sprite->texel[0].st);
-            glVertex3fv(sprite->vertex[0].pos);
-            glTexCoord2fv(sprite->texel[1].st);
-            glVertex3fv(sprite->vertex[1].pos);
-            glTexCoord2fv(sprite->texel[3].st);
-            glVertex3fv(sprite->vertex[3].pos);
-            glTexCoord2fv(sprite->texel[2].st);
-            glVertex3fv(sprite->vertex[2].pos);
-            glEnd();
-    }
-
-    glPopMatrix();
-}
-
-
-void Render::drawRoomModel(static_model_t *mesh)
-{
-    model_mesh_t *r_mesh;
-
-
-    if (!mesh)
-        return;
-
-    r_mesh = getWorld().getMesh(mesh->index);
-
-    if (!r_mesh)
-        return;
-
-    if (!isVisible(mesh->pos[0], mesh->pos[1], mesh->pos[2], r_mesh->radius))
-        return;
-
-    glPushMatrix();
-    glTranslated(mesh->pos[0], mesh->pos[1], mesh->pos[2]);
-    glRotated(mesh->yaw, 0, 1, 0);
-
-    drawModelMesh(r_mesh, roomMesh);
-    glPopMatrix();
-}
-
-
 void Render::tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri)
 {
     glBegin(GL_TRIANGLES);

src/Room.cpp

  * \author xythobuz
  */
 
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
+
+#include <algorithm>
+
 #include "main.h"
 #include "Room.h"
 
         pos[i] = _pos[i];
 }
 
+void StaticModel::display() {
+    model_mesh_t *mesh = getWorld().getMesh(index);
+
+    if (!mesh)
+        return;
+
+    if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh->radius))
+        return;
+
+    glPushMatrix();
+    glTranslated(pos[0], pos[1], pos[2]);
+    glRotated(yaw, 0, 1, 0);
+
+    getRender().drawModelMesh(mesh, Render::roomMesh);
+    glPopMatrix();
+}
+
 bool StaticModel::operator<(const StaticModel &other) {
     vec_t distA, distB;
     distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0],
     }
 }
 
+void Room::sortModels() {
+    std::sort(models.begin(), models.end());
+}
+

src/World.cpp

 int World::getRoomByLocation(int index, float x, float y, float z)
 {
     assert(index >= 0);
-    assert(index < mRooms.size());
+    assert(index < (int)mRooms.size());
     Room &room = *mRooms.at(index);
 
     if (room.inBox(x, y, z))
         float x, float y, float z,
         float x2, float y2, float z2) {
     assert(index >= 0);
-    assert(index < mRooms.size());
+    assert(index < (int)mRooms.size());
     Room &room = *mRooms.at(index);
     vec3_t intersect, p1, p2;
+    vec3_t vertices[4];
 
     p1[0] = x;  p1[1] = y;  p1[2] = z;
     p2[0] = x2; p2[1] = y2; p2[2] = z2;
 
     for (unsigned int i = 0; i < room.sizePortals(); i++) {
+        room.getPortal(i).getVertices(vertices);
         if (intersectionLinePolygon(intersect, p1, p2, //4,
-                    room.getPortal(i).getVertices()))
+                    vertices))
             return room.getPortal(i).getAdjoiningRoom();
     }
 
 
 int World::getSector(int room, float x, float z, float *floor, float *ceiling) {
     assert(room >= 0);
-    assert(room < mRooms.size());
+    assert(room < (int)mRooms.size());
     assert(floor != NULL);
     assert(ceiling != NULL);
 
     int sector = getSector(room, x, z);
 
-    if ((sector >= 0) && (sector < mRooms.at(room)->sizeSectors())) {
+    if ((sector >= 0) && (sector < (int)mRooms.at(room)->sizeSectors())) {
         *floor = mRooms.at(room)->getSector(sector).getFloor();
         *ceiling = mRooms.at(room)->getSector(sector).getCeiling();
     }
 
 int World::getSector(int room, float x, float z) {
     assert(room >= 0);
-    assert(room < mRooms.size());
+    assert(room < (int)mRooms.size());
 
     vec3_t pos;
     mRooms.at(room)->getPos(pos);
 
 unsigned int World::getRoomInfo(int room) {
     assert(room >= 0);
-    assert(room < mRooms.size());
+    assert(room < (int)mRooms.size());
 
     return mRooms.at(room)->getFlags();
 }
 
 bool World::isWall(int room, int sector) {
     assert(room >= 0);
-    assert(room < mRooms.size());
+    assert(room < (int)mRooms.size());
     assert(sector >= 0);
-    assert(sector < mRooms.at(room)->sizeSectors());
+    assert(sector < (int)mRooms.at(room)->sizeSectors());
 
     //! \fixme is (sector > 0) correct??
     return ((sector > 0) && mRooms.at(room)->getSector(sector).isWall());
 
 void World::getHeightAtPosition(int index, float x, float *y, float z) {
     assert(index >= 0);
-    assert(index < mRooms.size());
+    assert(index < (int)mRooms.size());
 
     int sector = getSector(index, x, z);
-    if ((sector >= 0) && (sector < mRooms.at(index)->sizeSectors()))
+    if ((sector >= 0) && (sector < (int)mRooms.at(index)->sizeSectors()))
         *y = mRooms.at(index)->getSector(sector).getFloor();
 }