Setup objects from TombRaider in their constructor

ChangeLog.md

@@ -2,6 +2,10 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140505 ]
+    * Moved setup of Room, Portal, Box, Sector, ... into their
+      Constructors.
+
     [ 20140504 ]
     * Forcing use of new Room and Sprite classes in World.
     * Rewrote Sprite loading code in Game

include/Game.h

@@ -38,6 +38,9 @@ public:
 
     void handleMouseMotion(int xrel, int yrel);
 
+    unsigned int getTextureStart();
+    unsigned int getTextureOffset();
+
     //! \fixme should be private
     entity_t *mLara;
 

include/Room.h

@@ -11,8 +11,10 @@
 #include <vector>
 #include <memory>
 #include "math/math.h"
+#include "math/Matrix.h"
 #include "Mesh.h"
 #include "Sprite.h"
+#include "TombRaider.h"
 
 class Light {
 public:
@@ -25,20 +27,27 @@ public:
         typeDirectional = 3  //!< Directional light
     } LightType;
 
-    Light(vec4_t pos, vec3_t dir, vec_t att, vec4_t color, vec_t cutoff, LightType type);
+    Light(TombRaider &tr, unsigned int room, unsigned int index);
 
-//private:
-    vec4_t mPos; //! Light position in 3 space
-    vec3_t mDir; //! Light direction
-    vec_t mAtt;
-    vec4_t mColor; //! Color of light
-    vec_t mCutoff; //! Fade out distance
-    LightType mType; //! Type of light
+    void getPos(vec4_t p);
+    void getDir(vec3_t d);
+    vec_t getAtt();
+    void getColor(vec4_t c);
+    vec_t getCutoff();
+    LightType getType();
+
+private:
+    vec4_t pos; //! Light position in 3 space
+    vec3_t dir; //! Light direction
+    vec_t att;
+    vec4_t color; //! Color of light
+    vec_t cutoff; //! Fade out distance
+    LightType type; //! Type of light
 };
 
 class StaticModel {
 public:
-    StaticModel(int _index, vec_t _yaw, vec3_t _pos);
+    StaticModel(TombRaider &tr, unsigned int room, unsigned int i);
     void display();
 
     // Compares distance to ViewVolume for depth sorting
@@ -55,7 +64,7 @@ private:
 
 class Portal {
 public:
-    Portal(vec3_t _vertices[4], vec3_t _normal, int _adjoiningRoom);
+    Portal(TombRaider &tr, unsigned int room, unsigned int index, Matrix &transform);
 
     void getVertices(vec3_t vert[4]);
     int getAdjoiningRoom();
@@ -68,7 +77,7 @@ private:
 
 class Box {
 public:
-    Box(vec3_t _a, vec3_t _b, vec3_t _c, vec3_t _d);
+    Box(TombRaider &tr, unsigned int room, unsigned int index);
 
 private:
     vec3_t a;
@@ -79,7 +88,7 @@ private:
 
 class Sector {
 public:
-    Sector(vec_t _floor, vec_t _ceiling, bool _wall);
+    Sector(TombRaider &tr, unsigned int room, unsigned int index);
     vec_t getFloor();
     vec_t getCeiling();
     bool isWall();
@@ -96,64 +105,53 @@ typedef enum {
 
 class Room {
 public:
-    Room(int _id);
+    Room(TombRaider &tr, unsigned int index);
     ~Room();
 
     void setFlags(unsigned int f);
     unsigned int getFlags();
 
-    void setNumXSectors(unsigned int n);
     unsigned int getNumXSectors();
 
-    void setNumZSectors(unsigned int n);
     unsigned int getNumZSectors();
 
-    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();
     Portal &getPortal(unsigned int index);
-    void addPortal(Portal &p);
 
     unsigned int sizeSectors();
     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 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:
-    int id;
     unsigned int flags;
     unsigned int numXSectors;
     unsigned int numZSectors;
     vec3_t pos;
     vec3_t bbox[2];
+    Mesh mesh;
 
     std::vector<int> adjacentRooms;
     std::vector<Sprite *> sprites;
@@ -161,11 +159,10 @@ private:
     std::vector<Portal *> portals;
     std::vector<Box *> boxes;
     std::vector<Sector *> sectors;
+    std::vector<Light *> lights;
 
-    // Was previously stored in RenderRoom
-    //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
+    // Was used for "depth sorting" render list, but never assigned...?!
+    //vec_t dist; // Distance to near plane, move to room?
 };
 
 #endif

include/Sprite.h

@@ -9,10 +9,12 @@
 #define _SPRITE_H_
 
 #include "math/math.h"
+#include "TombRaider.h"
 
 class Sprite {
 public:
-    Sprite(vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture);
+    Sprite(TombRaider &tr, unsigned int room, unsigned int index);
+    Sprite(TombRaider &tr, unsigned int item, unsigned int sequence, unsigned int index);
     void display();
 
 private:
@@ -25,6 +27,7 @@ private:
 
 class SpriteSequence {
 public:
+    SpriteSequence(TombRaider &tr, unsigned int item, unsigned int sequence);
     ~SpriteSequence();
 
     void add(Sprite &s);

include/ViewVolume.h

@@ -134,7 +134,7 @@ public:
      * \param max maximum point of a valid abstract bounding box
      * \returns distance to abstract box bounding volume
      */
-    vec_t getDistToBboxFromNear(vec3_t min, vec3_t max);
+    vec_t getDistToBboxFromNear(const vec3_t min, const vec3_t max);
 
     /*!
      * \brief Get a copy of the view volume

include/math/math.h

@@ -51,7 +51,7 @@ int intersectionLinePolygon(vec3_t intersect, vec3_t p1, vec3_t p2, vec3_t *poly
  * \param b Second point
  * \returns distance/length
  */
-vec_t distance(vec3_t a, vec3_t b);
+vec_t distance(const vec3_t a, const vec3_t b);
 
 /*!
  * \brief Calculates the midpoint between two points / of a line segment
@@ -59,7 +59,7 @@ vec_t distance(vec3_t a, vec3_t b);
  * \param b Second point
  * \param mid Midpoint will be stored here
  */
-void midpoint(vec3_t a, vec3_t b, vec3_t mid);
+void midpoint(const vec3_t a, const vec3_t b, vec3_t mid);
 
 /*!
  * \brief Calculates a pseudo-random number

src/Game.cpp

@@ -22,13 +22,6 @@
 
 #include "games/TombRaider1.h"
 
-// Old Code compatibility
-#define TexelScale 256.0f
-
-#ifndef EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
-#define TextureLimit 24
-#endif
-
 #ifdef EXPERIMENTAL
 std::vector<unsigned int> gColorTextureHACK;
 #endif
@@ -50,6 +43,14 @@ Game::~Game() {
     destroy();
 }
 
+unsigned int Game::getTextureStart() {
+    return mTextureStart;
+}
+
+unsigned int Game::getTextureOffset() {
+    return mTextureOffset;
+}
+
 int Game::initialize() {
     // Enable Renderer
     mTextureStart = getRender().initTextures(getOpenRaider().mDataDir);
@@ -170,600 +171,25 @@ void Game::handleMouseMotion(int xrel, int yrel) {
 }
 
 void Game::processSprites() {
-    float scale = 4.0f;
-    tr2_item_t *item = mTombRaider.Item();
-    tr2_sprite_texture_t *spriteTextures = mTombRaider.Sprite();
-    tr2_sprite_sequence_t *spriteSequence = mTombRaider.SpriteSequence();
-
     printf("Processing sprites: ");
-
     for (int i = 0; i < (mTombRaider.NumItems() - 1); i++) {
-        if ((mTombRaider.Engine() == TR_VERSION_1) && (item[i].intensity1 == -1))
+        if ((mTombRaider.Engine() == TR_VERSION_1) && (mTombRaider.Item()[i].intensity1 == -1))
             continue;
 
-        int id = item[i].object_id;
         for (int j = 0; j < mTombRaider.NumSpriteSequences(); j++) {
-            if (spriteSequence[j].object_id == id) {
-                SpriteSequence &sequence = *new SpriteSequence();
-                for (int k = 0; k < (-spriteSequence[j].negative_length); k++) {
-                    tr2_sprite_texture_t *sprite = &spriteTextures[spriteSequence[j].offset];
-
-                    int width = sprite->width >> 8;
-                    int height = sprite->height >> 8;
-                    int x = sprite->x;
-                    int y = sprite->y;
-                    int width2 = (int)(width * scale);
-                    int height2 = (int)(height * scale);
-
-                    vec3_t vertex[4];
-                    vec2_t texel[4];
-                    vec3_t pos;
-
-                    // For vising use
-                    pos[0] = item[i].x;
-                    pos[1] = item[i].y;
-                    pos[2] = item[i].z;
-
-                    vertex[0][0] = -width2 / 2.0f;
-                    vertex[1][0] = -width2 / 2.0f;
-                    vertex[2][0] = width2 / 2.0f;
-                    vertex[3][0] = width2 / 2.0f;
-
-                    vertex[0][1] = 0;
-                    vertex[1][1] = -height2;
-                    vertex[2][1] = -height2;
-                    vertex[3][1] = 0;
-
-                    vertex[0][2] = 0;
-                    vertex[1][2] = 0;
-                    vertex[2][2] = 0;
-                    vertex[3][2] = 0;
-
-                    texel[3][0] = (vec_t)(x+width)/TexelScale;
-                    texel[3][1] = (vec_t)(y+height)/TexelScale;
-
-                    texel[2][0] = (vec_t)(x+width)/TexelScale;
-                    texel[2][1] = (vec_t)(y)/TexelScale;
-
-                    texel[1][0] = (vec_t)(x) /TexelScale;
-                    texel[1][1] = (vec_t)(y) /TexelScale;
-
-                    texel[0][0] = (vec_t)(x) / TexelScale;
-                    texel[0][1] = (vec_t)(y+height)/TexelScale;
-
-                    sequence.add(*new Sprite(vertex, texel, pos, width2 / 2.0f, sprite->tile + mTextureStart));
-
-                    //printf(".");
-                    //fflush(stdout);
-                }
-                getWorld().addSprite(sequence);
-            }
+            if (mTombRaider.SpriteSequence()[j].object_id == mTombRaider.Item()[i].object_id)
+                getWorld().addSprite(*new SpriteSequence(mTombRaider, i, j));
         }
     }
-
     printf("Done! Found %d sprites.\n", mTombRaider.NumSpriteSequences());
 }
 
 void Game::processRooms() {
     printf("Processing rooms: ");
-
     for (int index = 0; index < mTombRaider.NumRooms(); index++) {
-        Matrix transform;
-        Room &room = *new Room(index);
-        getWorld().addRoom(room);
-
-        if (!mTombRaider.isRoomValid(index)) {
-            getConsole().print("WARNING: Handling invalid vertex array in room");
-            //printf("x");
-            //fflush(stdout);
-            //return; // ?
-            continue;
-        }
-
-        unsigned int flags;
-        vec3_t pos;
-        vec3_t bbox[2];
-        mTombRaider.getRoomInfo(index, &flags, pos, bbox[0], bbox[1]);
-        room.setFlags(flags);
-        room.setPos(pos);
-
-        // Adjust positioning for OR world coordinate translation
-        bbox[0][0] += pos[0];
-        bbox[1][0] += pos[0];
-        bbox[0][2] += pos[2];
-        bbox[1][2] += pos[2];
-
-        room.setBoundingBox(bbox);
-
-        // Mongoose 2002.04.03, Setup 3D transform
-        transform.setIdentity();
-        transform.translate(pos);
-
-        // Setup portals
-        float portalVertices[12];
-        unsigned int count = mTombRaider.getRoomPortalCount(index);
-
-        // Current room is always first
-        room.addAdjacentRoom(index);
-
-        for (unsigned int i = 0; i < count; i++) {
-            vec3_t vertices[4];
-            vec3_t normal;
-            int adjoiningRoom;
-            mTombRaider.getRoomPortal(index, i, &adjoiningRoom, normal, portalVertices);
-            for (unsigned int j = 0; j < 4; ++j) {
-                vertices[j][0] = portalVertices[j*3];
-                vertices[j][1] = portalVertices[j*3+1];
-                vertices[j][2] = portalVertices[j*3+2];
-
-                // Relative coors in vis portals
-                transform.multiply3v(vertices[j], vertices[j]);
-            }
-            Portal &portal = *new Portal(vertices, normal, adjoiningRoom);
-            room.addPortal(portal);
-            room.addAdjacentRoom(adjoiningRoom);
-        }
-
-        // Physics/gameplay use /////////////////////////////
-
-        //! \fixme Use more of sector structure, boxes, and floordata
-
-        // List of sectors in this room
-        unsigned int numXSectors, numZSectors;
-        count = mTombRaider.getRoomSectorCount(index, &numZSectors, &numXSectors);
-        room.setNumXSectors(numXSectors);
-        room.setNumZSectors(numZSectors);
-        for (unsigned int i = 0; i < count; i++) {
-            unsigned int sectorFlags;
-            int floorDataIndex, boxIndex, roomBelow, roomAbove;
-            vec_t floor, ceiling;
-            bool wall = false;
-
-            mTombRaider.getRoomSector(index, i, &sectorFlags,
-                    &ceiling, &floor, &floorDataIndex, &boxIndex,
-                    &roomBelow, &roomAbove);
-
-            if (sectorFlags & tombraiderSector_wall)
-                wall = true;
-
-            room.addSector(*new Sector(floor, ceiling, wall));
-        }
-
-        // Setup collision boxes
-        //! fixme Should use sectors, but this is a test
-        count = mTombRaider.getRoomBoxCount(index);
-
-        //! fixme Only to be done only on room[0]?  I don't think so...
-        for (unsigned int i = 0; !index && i < count; i++) {
-            vec3_t a, b, c, d;
-            mTombRaider.getRoomBox(index, i, a, b, c, d);
-            room.addBox(*new Box(a, b, c, d));
-        }
-
-        // Setup room lights /////////////////////////////////////
-        count = mTombRaider.getRoomLightCount(index);
-
-        for (unsigned int i = 0; i < count; i++) {
-            unsigned int lightFlags, lightType;
-            vec4_t position;
-            vec3_t dir;
-            vec_t att;
-            vec4_t color;
-            vec_t cutoff;
-            Light::LightType type;
-
-            mTombRaider.getRoomLight(index, i, position, color,
-                    dir, &att, &cutoff, &lightType, &lightFlags);
-
-            switch (lightType) {
-                case tombraiderLight_typeDirectional:
-                    type = Light::typeDirectional;
-                    break;
-                case tombraiderLight_typeSpot:
-                    type = Light::typeSpot;
-                    break;
-                case tombraiderLight_typePoint:
-                default:
-                    type = Light::typePoint;
-            }
-
-            room.addLight(*new Light(position, dir, att, color, cutoff, type));
-
-            //! \todo Light flags?
-        }
-
-        // Room geometery //////////////////////////////////
-
-//#define EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
-#ifdef EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
-        unsigned int vertexCount, normalCount, colorCount, triCount;
-        vec_t *vertexArray;
-        vec_t *normalArray;
-        vec_t *colorArray;
-        unsigned int *indices, *flags;
-        float *texCoords;
-        int *textures;
-
-        mTombRaider.getRoomVertexArrays(index,
-                &vertexCount, &vertexArray,
-                &normalCount, &normalArray,
-                &colorCount, &colorArray);
-
-        room.getMesh().bufferVertexArray(vertexCount, (vec_t *)vertexArray);
-        room.getMesh().bufferNormalArray(normalCount, (vec_t *)normalArray);
-        room.getMesh().bufferColorArray(vertexCount, (vec_t *)colorArray);
-
-        mTombRaider.getRoomTriangles(index, mTextureStart,
-                &triCount, &indices, &texCoords, &textures,
-                &flags);
-
-        room.getMesh().bufferTriangles(triCount, indices, texCoords, textures, flags);
-#else
-        float rgba[4];
-        float xyz[3];
-
-        count = mTombRaider.getRoomVertexCount(index);
-        room.getMesh().allocateVertices(count);
-        room.getMesh().allocateNormals(0); // count
-        room.getMesh().allocateColors(count);
-
-        for (unsigned int i = 0; i < count; ++i)
-        {
-            mTombRaider.getRoomVertex(index, i, xyz, rgba);
-
-            room.getMesh().setVertex(i, xyz[0], xyz[1], xyz[2]);
-            room.getMesh().setColor(i, rgba);
-        }
-
-        // Mongoose 2002.06.09, Setup allocation of meshes and polygons
-        // Counters ( Textured polygon lists are allocated per texture)
-        //          ( Textures are mapped to these meshes )
-        int triangle_counter[TextureLimit];
-        int triangle_counter_alpha[TextureLimit];
-        int rectangle_counter[TextureLimit];
-        int rectangle_counter_alpha[TextureLimit];
-        int tris_mesh_map[TextureLimit];
-        int rect_mesh_map[TextureLimit];
-
-        for (unsigned int i = 0; i < TextureLimit; ++i)
-        {
-            triangle_counter[i]        = 0;
-            triangle_counter_alpha[i]  = 0;
-            rectangle_counter[i]       = 0;
-            rectangle_counter_alpha[i] = 0;
-
-            tris_mesh_map[i] = -1;
-            rect_mesh_map[i] = -1;
-        }
-
-        unsigned int numTris = 0;
-        unsigned int numQuads = 0;
-
-        int texture;
-        unsigned int r, t, q, v;
-        unsigned int indices[4];
-        float texCoords[8];
-
-        count = mTombRaider.getRoomTriangleCount(index);
-
-        // Mongoose 2002.08.15, Presort by alpha and texture and setup mapping
-        for (t = 0; t < count; ++t)
-        {
-            mTombRaider.getRoomTriangle(index, t,
-                    indices, texCoords, &texture, &flags);
-
-            texture += mTextureStart;
-
-            if (texture > (int)TextureLimit)
-            {
-                getConsole().print("Handling bad room[%i].tris[%i].texture = %i",
-                        index, t, texture);
-                texture = TextureLimit - 1;
-            }
-
-            // Counters set up polygon allocation
-            if (flags & tombraiderFace_Alpha ||
-                    flags & tombraiderFace_PartialAlpha)
-            {
-                triangle_counter_alpha[texture] += 1;
-            }
-            else
-            {
-                triangle_counter[texture] += 1;
-            }
-
-            // Counter sets up texture id to mesh id mapping
-            if (tris_mesh_map[texture] == -1)
-            {
-                tris_mesh_map[texture] = ++numTris;
-            }
-        }
-
-        count = mTombRaider.getRoomRectangleCount(index);
-
-        for (r = 0; r < count; ++r)
-        {
-            mTombRaider.getRoomRectangle(index, r,
-                    indices, texCoords, &texture, &flags);
-
-            texture += mTextureStart;
-
-            if (texture > (int)TextureLimit)
-            {
-                getConsole().print("Handling bad room[%i].quad[%i].texture = %i",
-                        index, r, texture);
-                texture = TextureLimit - 1;
-            }
-
-            if (flags & tombraiderFace_Alpha ||
-                    flags & tombraiderFace_PartialAlpha)
-            {
-                rectangle_counter_alpha[texture] += 1;
-            }
-            else
-            {
-                rectangle_counter[texture] += 1;
-            }
-
-            if (rect_mesh_map[texture] == -1)
-            {
-                rect_mesh_map[texture] = ++numQuads;
-            }
-        }
-
-        // Allocate indexed polygon meshes
-        room.getMesh().allocateTriangles(numTris);
-        room.getMesh().allocateRectangles(numQuads);
-
-        for (unsigned int i = 0, j = 0; i < TextureLimit; ++i)
-        {
-            if (tris_mesh_map[i] > 0)
-            {
-                j = tris_mesh_map[i] - 1;
-
-                t = triangle_counter[i];
-
-                room.getMesh().mTris[j].texture = i;
-#ifdef MULTITEXTURE
-                room.getMesh().mTris[j].bumpmap = gMapTex2Bump[i];
-#endif
-                room.getMesh().mTris[j].cnum_triangles = 0;
-                room.getMesh().mTris[j].num_triangles = 0;
-                room.getMesh().mTris[j].cnum_alpha_triangles = 0;
-                room.getMesh().mTris[j].num_alpha_triangles = 0;
-                room.getMesh().mTris[j].triangles = 0x0;
-                room.getMesh().mTris[j].alpha_triangles = 0x0;
-                room.getMesh().mTris[j].texcoors = 0x0;
-                room.getMesh().mTris[j].texcoors2 = 0x0;
-
-                if (t > 0)
-                {
-                    room.getMesh().mTris[j].num_triangles = t;
-                    room.getMesh().mTris[j].triangles = new unsigned int[t*3];
-                    room.getMesh().mTris[j].num_texcoors = t * 3;
-                    room.getMesh().mTris[j].texcoors = new vec2_t[t * 3];
-                }
-
-                t = triangle_counter_alpha[i];
-
-                if (t > 0)
-                {
-                    room.getMesh().mTris[j].num_alpha_triangles = t;
-                    room.getMesh().mTris[j].alpha_triangles = new unsigned int[t*3];
-                    room.getMesh().mTris[j].num_texcoors2 = t * 3;
-                    room.getMesh().mTris[j].texcoors2 = new vec2_t[t * 3];
-                }
-            }
-
-            ///////////////////////////////////////////
-
-            if (rect_mesh_map[i] > 0)
-            {
-                j = rect_mesh_map[i] - 1;
-
-                r = rectangle_counter[i];
-
-                room.getMesh().mQuads[j].texture = i;
-#ifdef MULTITEXTURE
-                room.getMesh().mQuads[j].bumpmap = gMapTex2Bump[i];
-#endif
-                room.getMesh().mQuads[j].cnum_quads = 0;
-                room.getMesh().mQuads[j].num_quads = 0;
-                room.getMesh().mQuads[j].cnum_alpha_quads = 0;
-                room.getMesh().mQuads[j].num_alpha_quads = 0;
-                room.getMesh().mQuads[j].quads = 0x0;
-                room.getMesh().mQuads[j].alpha_quads = 0x0;
-                room.getMesh().mQuads[j].texcoors = 0x0;
-                room.getMesh().mQuads[j].texcoors2 = 0x0;
-
-                if (r > 0)
-                {
-                    room.getMesh().mQuads[j].num_quads = r;
-                    room.getMesh().mQuads[j].quads = new unsigned int[r*4];
-                    room.getMesh().mQuads[j].num_texcoors = r * 4;
-                    room.getMesh().mQuads[j].texcoors = new vec2_t[r * 4];
-                }
-
-                r = rectangle_counter_alpha[i];
-
-                if (r > 0)
-                {
-                    room.getMesh().mQuads[j].num_alpha_quads = r;
-                    room.getMesh().mQuads[j].alpha_quads = new unsigned int[r*4];
-                    room.getMesh().mQuads[j].num_texcoors2 = r * 4;
-                    room.getMesh().mQuads[j].texcoors2 = new vec2_t[r * 4];
-                }
-            }
-        }
-
-        // Generate textured triangles
-        count = mTombRaider.getRoomTriangleCount(index);
-
-        for (t = 0; t < count; ++t)
-        {
-            mTombRaider.getRoomTriangle(index, t,
-                    indices, texCoords, &texture, &flags);
-
-            // Adjust texture id using mTextureStart to map into
-            // correct textures
-            texture += mTextureStart;
-
-            unsigned int j = tris_mesh_map[texture] - 1;
-
-            // Setup per vertex
-            for (unsigned int i = 0; i < 3; ++i)
-            {
-                // Get vertex index {(0, a), (1, b), (2, c)}
-                v = indices[i];
-
-                if ((flags & tombraiderFace_Alpha ||
-                            flags & tombraiderFace_PartialAlpha) &&
-                        room.getMesh().mTris[j].num_alpha_triangles > 0)
-                {
-                    q = room.getMesh().mTris[j].cnum_alpha_triangles*3+i;
-
-                    room.getMesh().mTris[j].alpha_triangles[q] = v;
-
-                    room.getMesh().mTris[j].texcoors2[q][0] = texCoords[i*2];
-                    room.getMesh().mTris[j].texcoors2[q][1] = texCoords[i*2+1];
-                }
-                else if (room.getMesh().mTris[j].num_triangles > 0)
-                {
-                    q = room.getMesh().mTris[j].cnum_triangles*3+i;
-
-                    room.getMesh().mTris[j].triangles[q] = v;
-
-                    room.getMesh().mTris[j].texcoors[q][0] = texCoords[i*2];
-                    room.getMesh().mTris[j].texcoors[q][1] = texCoords[i*2+1];
-                }
-
-                // Partial alpha hack
-                if (flags & tombraiderFace_PartialAlpha)
-                {
-                    //room.getMesh().colors[v].rgba[3] = 0.45;
-                }
-            }
-
-            if (flags & tombraiderFace_Alpha ||
-                    flags & tombraiderFace_PartialAlpha)
-            {
-                room.getMesh().mTris[j].cnum_alpha_triangles++;
-            }
-            else
-            {
-                room.getMesh().mTris[j].cnum_triangles++;
-            }
-        }
-
-        // Generate textured quads
-        count = mTombRaider.getRoomRectangleCount(index);
-
-        for (r = 0; r < count; ++r)
-        {
-            mTombRaider.getRoomRectangle(index, r,
-                    indices, texCoords, &texture, &flags);
-
-            // Adjust texture id using mTextureStart to map into
-            // correct textures
-            texture += mTextureStart;
-
-            if (texture > (int)TextureLimit)
-            {
-                texture = TextureLimit - 1;
-            }
-
-            unsigned int j = rect_mesh_map[texture] - 1;
-
-            if (room.getMesh().mQuads[j].num_quads <= 0 &&
-                    room.getMesh().mQuads[j].num_alpha_quads <= 0)
-                continue;
-
-            // Setup per vertex
-            for (unsigned int i = 0; i < 4; ++i)
-            {
-                // Get vertex index {(0, a), (1, b), (2, c), (3, d)}
-                v = indices[i];
-
-                if ((flags & tombraiderFace_Alpha ||
-                            flags & tombraiderFace_PartialAlpha) &&
-                        room.getMesh().mQuads[j].num_alpha_quads > 0)
-                {
-                    q = room.getMesh().mQuads[j].cnum_alpha_quads*4+i;
-
-                    room.getMesh().mQuads[j].alpha_quads[q] = v;
-
-                    room.getMesh().mQuads[j].texcoors2[q][0] = texCoords[i*2];
-                    room.getMesh().mQuads[j].texcoors2[q][1] = texCoords[i*2+1];
-                }
-                else if (room.getMesh().mQuads[j].num_quads > 0)
-                {
-                    q = room.getMesh().mQuads[j].cnum_quads*4+i;
-
-                    room.getMesh().mQuads[j].quads[q] = v;
-
-                    room.getMesh().mQuads[j].texcoors[q][0] = texCoords[i*2];
-                    room.getMesh().mQuads[j].texcoors[q][1] = texCoords[i*2+1];
-                }
-
-                // Partial alpha hack
-                if (flags & tombraiderFace_PartialAlpha)
-                {
-                    //rRoom->mesh.colors[v].rgba[3] = 0.45;
-                }
-            }
-
-            if (flags & tombraiderFace_Alpha ||
-                    flags & tombraiderFace_PartialAlpha)
-            {
-                room.getMesh().mQuads[j].cnum_alpha_quads++;
-            }
-            else
-            {
-                room.getMesh().mQuads[j].cnum_quads++;
-            }
-        }
-#endif
-
-        // Room models
-        count = mTombRaider.getRoomModelCount(index);
-        for (unsigned int i = 0; i < count; i++) {
-            int ind;
-            vec_t yaw;
-            vec3_t position;
-            mTombRaider.getRoomModel(index, i, &ind, position, &yaw);
-            room.addModel(*new StaticModel(ind, yaw, position));
-        }
-
-        // Room sprites
-        count = mTombRaider.getRoomSpriteCount(index);
-        for (unsigned int i = 0; i < count; i++) {
-            float spriteVertices[12];
-            float spriteTexCoords[8];
-            vec3_t vertex[4];
-            vec2_t texel[4];
-            vec3_t position;
-            int tex;
-
-            mTombRaider.getRoomSprite(index, i,
-                    10.0f, &tex, position, spriteVertices, spriteTexCoords);
-
-            tex += mTextureStart; // OpenRaider preloads some textures
-
-            for (unsigned int j = 0; j < 12; j++)
-                vertex[j / 3][j % 3] = spriteVertices[j];
-
-            for (unsigned int j = 0; j < 8; j++)
-                texel[j / 2][j % 2] = spriteTexCoords[j];
-
-            room.addSprite(*new Sprite(vertex, texel, position, 0.0f, tex)); //! \fixme radius 0??
-        }
-
+        Room &room = *new Room(mTombRaider, index);
         getWorld().addRoom(room);
-
-        //printf(".");
-        //fflush(stdout);
     }
-
     printf("Done! Found %d rooms.\n", mTombRaider.NumRooms());
 }
 

src/Render.cpp

@@ -197,16 +197,21 @@ void lightRoom(Room &room)
     for (unsigned int i = 0; i < room.sizeLights(); ++i)
     {
         Light &light = room.getLight(i);
+        vec4_t pos, color;
+        vec3_t dir;
+        light.getPos(pos);
+        light.getColor(color);
+        light.getDir(dir);
 
         glEnable(GL_LIGHT0 + i);
 
-        switch (light.mType)
+        switch (light.getType())
         {
             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.getCutoff());
+                glLightfv(GL_LIGHT0 + i, GL_POSITION,       pos);
+                glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, dir);
+                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,        color);
                 break;
             case Light::typePoint:
             case Light::typeDirectional:
@@ -214,10 +219,10 @@ void lightRoom(Room &room)
 
                 // GL_QUADRATIC_ATTENUATION
                 // GL_LINEAR_ATTENUATION
-                glLightf(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, light.mAtt);
+                glLightf(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, light.getAtt());
 
-                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, light.mColor); // GL_DIFFUSE
-                glLightfv(GL_LIGHT0 + i, GL_POSITION, light.mPos);
+                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, color); // GL_DIFFUSE
+                glLightfv(GL_LIGHT0 + i, GL_POSITION, pos);
                 break;
         }
     }

src/Room.cpp

@@ -19,23 +19,65 @@
 #include "main.h"
 #include "Room.h"
 
-Light::Light(vec4_t pos, vec3_t dir, vec_t att, vec4_t color, vec_t cutoff, LightType type) {
-    for (unsigned int i = 0; i < 4; i++) {
-        mPos[i] = pos[i];
-        mColor[i] = color[i];
-        if (i < 3)
-            mDir[i] = dir[i];
+#ifndef EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
+#define TextureLimit 24
+#endif
+
+Light::Light(TombRaider &tr, unsigned int room, unsigned int index) {
+    unsigned int lightFlags, lightType;
+
+    tr.getRoomLight(room, index, pos, color,
+            dir, &att, &cutoff, &lightType, &lightFlags);
+
+    switch (lightType) {
+        case tombraiderLight_typeDirectional:
+            type = Light::typeDirectional;
+            break;
+        case tombraiderLight_typeSpot:
+            type = Light::typeSpot;
+            break;
+        case tombraiderLight_typePoint:
+        default:
+            type = Light::typePoint;
     }
-    mAtt = att;
-    mCutoff = cutoff;
-    mType = type;
+
+    //! \todo Light flags?
 }
 
-StaticModel::StaticModel(int _index, vec_t _yaw, vec3_t _pos) {
-    index = _index;
-    yaw = _yaw;
-    for (unsigned int i = 0; i < 3; i++)
-        pos[i] = _pos[i];
+void Light::getPos(vec4_t p) {
+    p[0] = pos[0];
+    p[1] = pos[1];
+    p[2] = pos[2];
+    p[3] = pos[3];
+}
+
+void Light::getDir(vec3_t d) {
+    d[0] = dir[0];
+    d[1] = dir[1];
+    d[2] = dir[2];
+}
+
+vec_t Light::getAtt() {
+    return att;
+}
+
+void Light::getColor(vec4_t c) {
+    c[0] = color[0];
+    c[1] = color[1];
+    c[2] = color[2];
+    c[3] = color[3];
+}
+
+vec_t Light::getCutoff() {
+    return cutoff;
+}
+
+Light::LightType Light::getType() {
+    return type;
+}
+
+StaticModel::StaticModel(TombRaider &tr, unsigned int room, unsigned int i) {
+    tr.getRoomModel(room, i, &index, pos, &yaw);
 }
 
 void StaticModel::display() {
@@ -64,15 +106,17 @@ bool StaticModel::operator<(const StaticModel &other) {
     return (distA < distB);
 }
 
-Portal::Portal(vec3_t _vertices[4], vec3_t _normal, int _adjoiningRoom) {
-    for (unsigned int i = 0; i < 3; i++) {
-        vertices[0][i] = _vertices[0][i];
-        vertices[1][i] = _vertices[1][i];
-        vertices[2][i] = _vertices[2][i];
-        vertices[3][i] = _vertices[3][i];
-        normal[i] = _normal[i];
+Portal::Portal(TombRaider &tr, unsigned int room, unsigned int index, Matrix &transform) {
+    float portalVertices[12];
+    tr.getRoomPortal(room, index, &adjoiningRoom, normal, portalVertices);
+    for (unsigned int j = 0; j < 4; ++j) {
+        vertices[j][0] = portalVertices[j*3];
+        vertices[j][1] = portalVertices[j*3+1];
+        vertices[j][2] = portalVertices[j*3+2];
+
+        // Relative coors in vis portals
+        transform.multiply3v(vertices[j], vertices[j]);
     }
-    adjoiningRoom = _adjoiningRoom;
 }
 
 void Portal::getVertices(vec3_t vert[4]) {
@@ -87,19 +131,19 @@ int Portal::getAdjoiningRoom() {
     return adjoiningRoom;
 }
 
-Box::Box(vec3_t _a, vec3_t _b, vec3_t _c, vec3_t _d) {
-    for (unsigned int i = 0; i < 3; i++) {
-        a[i] = _a[i];
-        b[i] = _b[i];
-        c[i] = _c[i];
-        d[i] = _d[i];
-    }
+Box::Box(TombRaider &tr, unsigned int room, unsigned int index) {
+    tr.getRoomBox(room, index, a, b, c, d);
 }
 
-Sector::Sector(vec_t _floor, vec_t _ceiling, bool _wall) {
-    floor = _floor;
-    ceiling = _ceiling;
-    wall = _wall;
+Sector::Sector(TombRaider &tr, unsigned int room, unsigned int index) {
+    unsigned int sectorFlags;
+    int floorDataIndex, boxIndex, roomBelow, roomAbove;
+
+    tr.getRoomSector(room, index, &sectorFlags,
+            &ceiling, &floor, &floorDataIndex, &boxIndex,
+            &roomBelow, &roomAbove);
+
+    wall = (sectorFlags & tombraiderSector_wall);
 }
 
 vec_t Sector::getFloor() {
@@ -114,68 +158,444 @@ bool Sector::isWall() {
     return wall;
 }
 
-Room::Room(int _id) {
-    id = _id;
-    flags = 0;
-    numXSectors = 0;
-    numZSectors = 0;
-    pos[0] = pos[1] = pos[2] = 0.0f;
-    bbox[0][0] = bbox[0][1] = bbox[0][2] = 0.0f;
-    bbox[1][0] = bbox[1][1] = bbox[1][2] = 0.0f;
-}
+Room::Room(TombRaider &tr, unsigned int index) {
+    Matrix transform;
 
-Room::~Room() {
-    unsigned long i;
+    if (!tr.isRoomValid(index)) {
+        getConsole().print("WARNING: Handling invalid vertex array in room");
+        //printf("x");
+        //fflush(stdout);
+        return;
+    }
 
-    for (i = 0; i < sprites.size(); i++)
-        delete sprites[i];
+    tr.getRoomInfo(index, &flags, pos, bbox[0], bbox[1]);
 
-    for (i = 0; i < models.size(); i++)
-        delete models[i];
+    // Adjust positioning for OR world coordinate translation
+    bbox[0][0] += pos[0];
+    bbox[1][0] += pos[0];
+    bbox[0][2] += pos[2];
+    bbox[1][2] += pos[2];
 
-    for (i = 0; i < portals.size(); i++)
-        delete portals[i];
+    // Mongoose 2002.04.03, Setup 3D transform
+    transform.setIdentity();
+    transform.translate(pos);
 
-    for (i = 0; i < boxes.size(); i++)
-        delete boxes[i];
+    // Current room is always first
+    adjacentRooms.push_back(index);
 
-    for (i = 0; i < sectors.size(); i++)
-        delete sectors[i];
+    // Setup portals
+    unsigned int count = tr.getRoomPortalCount(index);
+    for (unsigned int i = 0; i < count; i++) {
+        portals.push_back(new Portal(tr, index, i, transform));
+        adjacentRooms.push_back(portals.back()->getAdjoiningRoom());
+    }
 
-    for (i = 0; i < lights.size(); i++) {
-        delete lights[i];
+    //! \fixme Use more of sector structure, boxes, and floordata
+
+    // List of sectors in this room
+    count = tr.getRoomSectorCount(index, &numZSectors, &numXSectors);
+    for (unsigned int i = 0; i < count; i++)
+        sectors.push_back(new Sector(tr, index, i));
+
+    // Setup collision boxes
+    //! fixme Should use sectors, but this is a test
+    count = tr.getRoomBoxCount(index);
+    for (unsigned int i = 0; i < count; i++)
+        boxes.push_back(new Box(tr, index, i));
+
+    // Setup room lights
+    count = tr.getRoomLightCount(index);
+    for (unsigned int i = 0; i < count; i++)
+        lights.push_back(new Light(tr, index, i));
+
+    // Room models
+    count = tr.getRoomModelCount(index);
+    for (unsigned int i = 0; i < count; i++)
+        models.push_back(new StaticModel(tr, index, i));
+
+    // Room sprites
+    count = tr.getRoomSpriteCount(index);
+    for (unsigned int i = 0; i < count; i++)
+        sprites.push_back(new Sprite(tr, index, i));
+
+//#define EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
+#ifdef EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
+    unsigned int vertexCount, normalCount, colorCount, triCount;
+    vec_t *vertexArray;
+    vec_t *normalArray;
+    vec_t *colorArray;
+    unsigned int *indices, *flags;
+    float *texCoords;
+    int *textures;
+
+    tr.getRoomVertexArrays(index,
+            &vertexCount, &vertexArray,
+            &normalCount, &normalArray,
+            &colorCount, &colorArray);
+
+    mesh.bufferVertexArray(vertexCount, (vec_t *)vertexArray);
+    mesh.bufferNormalArray(normalCount, (vec_t *)normalArray);
+    mesh.bufferColorArray(vertexCount, (vec_t *)colorArray);
+
+    tr.getRoomTriangles(index, getGame().getTextureStart(),
+            &triCount, &indices, &texCoords, &textures,
+            &flags);
+
+    mesh.bufferTriangles(triCount, indices, texCoords, textures, flags);
+#else
+    float rgba[4];
+    float xyz[3];
+
+    count = tr.getRoomVertexCount(index);
+    mesh.allocateVertices(count);
+    mesh.allocateNormals(0); // count
+    mesh.allocateColors(count);
+
+    for (unsigned int i = 0; i < count; ++i)
+    {
+        tr.getRoomVertex(index, i, xyz, rgba);
+
+        mesh.setVertex(i, xyz[0], xyz[1], xyz[2]);
+        mesh.setColor(i, rgba);
     }
+
+    // Mongoose 2002.06.09, Setup allocation of meshes and polygons
+    // Counters ( Textured polygon lists are allocated per texture)
+    //          ( Textures are mapped to these meshes )
+    int triangle_counter[TextureLimit];
+    int triangle_counter_alpha[TextureLimit];
+    int rectangle_counter[TextureLimit];
+    int rectangle_counter_alpha[TextureLimit];
+    int tris_mesh_map[TextureLimit];
+    int rect_mesh_map[TextureLimit];
+
+    for (unsigned int i = 0; i < TextureLimit; ++i)
+    {
+        triangle_counter[i]        = 0;
+        triangle_counter_alpha[i]  = 0;
+        rectangle_counter[i]       = 0;
+        rectangle_counter_alpha[i] = 0;
+
+        tris_mesh_map[i] = -1;
+        rect_mesh_map[i] = -1;
+    }
+
+    unsigned int numTris = 0;
+    unsigned int numQuads = 0;
+
+    int texture;
+    unsigned int r, t, q, v;
+    unsigned int indices[4];
+    float texCoords[8];
+
+    count = tr.getRoomTriangleCount(index);
+
+    // Mongoose 2002.08.15, Presort by alpha and texture and setup mapping
+    for (t = 0; t < count; ++t)
+    {
+        tr.getRoomTriangle(index, t,
+                indices, texCoords, &texture, &flags);
+
+        texture += getGame().getTextureStart();
+
+        if (texture > (int)TextureLimit)
+        {
+            getConsole().print("Handling bad room[%i].tris[%i].texture = %i",
+                    index, t, texture);
+            texture = TextureLimit - 1;
+        }
+
+        // Counters set up polygon allocation
+        if (flags & tombraiderFace_Alpha ||
+                flags & tombraiderFace_PartialAlpha)
+        {
+            triangle_counter_alpha[texture] += 1;
+        }
+        else
+        {
+            triangle_counter[texture] += 1;
+        }
+
+        // Counter sets up texture id to mesh id mapping
+        if (tris_mesh_map[texture] == -1)
+        {
+            tris_mesh_map[texture] = ++numTris;
+        }
+    }
+
+    count = tr.getRoomRectangleCount(index);
+
+    for (r = 0; r < count; ++r)
+    {
+        tr.getRoomRectangle(index, r,
+                indices, texCoords, &texture, &flags);
+
+        texture += getGame().getTextureStart();
+
+        if (texture > (int)TextureLimit)
+        {
+            getConsole().print("Handling bad room[%i].quad[%i].texture = %i",
+                    index, r, texture);
+            texture = TextureLimit - 1;
+        }
+
+        if (flags & tombraiderFace_Alpha ||
+                flags & tombraiderFace_PartialAlpha)
+        {
+            rectangle_counter_alpha[texture] += 1;
+        }
+        else
+        {
+            rectangle_counter[texture] += 1;
+        }
+
+        if (rect_mesh_map[texture] == -1)
+        {
+            rect_mesh_map[texture] = ++numQuads;
+        }
+    }
+
+    // Allocate indexed polygon meshes
+    mesh.allocateTriangles(numTris);
+    mesh.allocateRectangles(numQuads);
+
+    for (unsigned int i = 0, j = 0; i < TextureLimit; ++i)
+    {
+        if (tris_mesh_map[i] > 0)
+        {
+            j = tris_mesh_map[i] - 1;
+
+            t = triangle_counter[i];
+
+            mesh.mTris[j].texture = i;
+#ifdef MULTITEXTURE
+            mesh.mTris[j].bumpmap = gMapTex2Bump[i];
+#endif
+            mesh.mTris[j].cnum_triangles = 0;
+            mesh.mTris[j].num_triangles = 0;
+            mesh.mTris[j].cnum_alpha_triangles = 0;
+            mesh.mTris[j].num_alpha_triangles = 0;
+            mesh.mTris[j].triangles = 0x0;
+            mesh.mTris[j].alpha_triangles = 0x0;
+            mesh.mTris[j].texcoors = 0x0;
+            mesh.mTris[j].texcoors2 = 0x0;
+
+            if (t > 0)
+            {
+                mesh.mTris[j].num_triangles = t;
+                mesh.mTris[j].triangles = new unsigned int[t*3];
+                mesh.mTris[j].num_texcoors = t * 3;
+                mesh.mTris[j].texcoors = new vec2_t[t * 3];
+            }
+
+            t = triangle_counter_alpha[i];
+
+            if (t > 0)
+            {
+                mesh.mTris[j].num_alpha_triangles = t;
+                mesh.mTris[j].alpha_triangles = new unsigned int[t*3];
+                mesh.mTris[j].num_texcoors2 = t * 3;
+                mesh.mTris[j].texcoors2 = new vec2_t[t * 3];
+            }
+        }
+
+        ///////////////////////////////////////////
+
+        if (rect_mesh_map[i] > 0)
+        {
+            j = rect_mesh_map[i] - 1;
+
+            r = rectangle_counter[i];
+
+            mesh.mQuads[j].texture = i;
+#ifdef MULTITEXTURE
+            mesh.mQuads[j].bumpmap = gMapTex2Bump[i];
+#endif
+            mesh.mQuads[j].cnum_quads = 0;
+            mesh.mQuads[j].num_quads = 0;
+            mesh.mQuads[j].cnum_alpha_quads = 0;
+            mesh.mQuads[j].num_alpha_quads = 0;
+            mesh.mQuads[j].quads = 0x0;
+            mesh.mQuads[j].alpha_quads = 0x0;
+            mesh.mQuads[j].texcoors = 0x0;
+            mesh.mQuads[j].texcoors2 = 0x0;
+
+            if (r > 0)
+            {
+                mesh.mQuads[j].num_quads = r;
+                mesh.mQuads[j].quads = new unsigned int[r*4];
+                mesh.mQuads[j].num_texcoors = r * 4;
+                mesh.mQuads[j].texcoors = new vec2_t[r * 4];
+            }
+
+            r = rectangle_counter_alpha[i];
+
+            if (r > 0)
+            {
+                mesh.mQuads[j].num_alpha_quads = r;
+                mesh.mQuads[j].alpha_quads = new unsigned int[r*4];
+                mesh.mQuads[j].num_texcoors2 = r * 4;
+                mesh.mQuads[j].texcoors2 = new vec2_t[r * 4];
+            }
+        }
+    }
+
+    // Generate textured triangles
+    count = tr.getRoomTriangleCount(index);
+
+    for (t = 0; t < count; ++t)
+    {
+        tr.getRoomTriangle(index, t,
+                indices, texCoords, &texture, &flags);
+
+        // Adjust texture id using getGame().getTextureStart() to map into
+        // correct textures
+        texture += getGame().getTextureStart();
+
+        unsigned int j = tris_mesh_map[texture] - 1;
+
+        // Setup per vertex
+        for (unsigned int i = 0; i < 3; ++i)
+        {
+            // Get vertex index {(0, a), (1, b), (2, c)}
+            v = indices[i];
+
+            if ((flags & tombraiderFace_Alpha ||
+                        flags & tombraiderFace_PartialAlpha) &&
+                    mesh.mTris[j].num_alpha_triangles > 0)
+            {
+                q = mesh.mTris[j].cnum_alpha_triangles*3+i;
+
+                mesh.mTris[j].alpha_triangles[q] = v;
+
+                mesh.mTris[j].texcoors2[q][0] = texCoords[i*2];
+                mesh.mTris[j].texcoors2[q][1] = texCoords[i*2+1];
+            }
+            else if (mesh.mTris[j].num_triangles > 0)
+            {
+                q = mesh.mTris[j].cnum_triangles*3+i;
+
+                mesh.mTris[j].triangles[q] = v;
+
+                mesh.mTris[j].texcoors[q][0] = texCoords[i*2];
+                mesh.mTris[j].texcoors[q][1] = texCoords[i*2+1];
+            }
+
+            // Partial alpha hack
+            if (flags & tombraiderFace_PartialAlpha)
+            {
+                //mesh.colors[v].rgba[3] = 0.45;
+            }
+        }
+
+        if (flags & tombraiderFace_Alpha ||
+                flags & tombraiderFace_PartialAlpha)
+        {
+            mesh.mTris[j].cnum_alpha_triangles++;
+        }
+        else
+        {
+            mesh.mTris[j].cnum_triangles++;
+        }
+    }
+
+    // Generate textured quads
+    count = tr.getRoomRectangleCount(index);
+
+    for (r = 0; r < count; ++r)
+    {
+        tr.getRoomRectangle(index, r,
+                indices, texCoords, &texture, &flags);
+
+        // Adjust texture id using getGame().getTextureStart() to map into
+        // correct textures
+        texture += getGame().getTextureStart();
+
+        if (texture > (int)TextureLimit)
+        {
+            texture = TextureLimit - 1;
+        }
+
+        unsigned int j = rect_mesh_map[texture] - 1;
+
+        if (mesh.mQuads[j].num_quads <= 0 &&
+                mesh.mQuads[j].num_alpha_quads <= 0)
+            continue;
+
+        // Setup per vertex
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            // Get vertex index {(0, a), (1, b), (2, c), (3, d)}
+            v = indices[i];
+
+            if ((flags & tombraiderFace_Alpha ||
+                        flags & tombraiderFace_PartialAlpha) &&
+                    mesh.mQuads[j].num_alpha_quads > 0)
+            {
+                q = mesh.mQuads[j].cnum_alpha_quads*4+i;
+
+                mesh.mQuads[j].alpha_quads[q] = v;
+
+                mesh.mQuads[j].texcoors2[q][0] = texCoords[i*2];
+                mesh.mQuads[j].texcoors2[q][1] = texCoords[i*2+1];
+            }
+            else if (mesh.mQuads[j].num_quads > 0)
+            {
+                q = mesh.mQuads[j].cnum_quads*4+i;
+
+                mesh.mQuads[j].quads[q] = v;
+
+                mesh.mQuads[j].texcoors[q][0] = texCoords[i*2];
+                mesh.mQuads[j].texcoors[q][1] = texCoords[i*2+1];
+            }
+
+            // Partial alpha hack
+            if (flags & tombraiderFace_PartialAlpha)
+            {
+                //rRoom->mesh.colors[v].rgba[3] = 0.45;
+            }
+        }
+
+        if (flags & tombraiderFace_Alpha ||
+                flags & tombraiderFace_PartialAlpha)
+        {
+            mesh.mQuads[j].cnum_alpha_quads++;
+        }
+        else
+        {
+            mesh.mQuads[j].cnum_quads++;
+        }
+    }
+#endif
 }
 
-void Room::setFlags(unsigned int f) {
-    flags = f;
+#define EMPTY_VECTOR(x)     \
+while (!x.empty()) {        \
+    delete x[x.size() - 1]; \
+    x.pop_back();           \
 }
 
-unsigned int Room::getFlags() {
-    return flags;
+Room::~Room() {
+    EMPTY_VECTOR(sprites);
+    EMPTY_VECTOR(models);
+    EMPTY_VECTOR(portals);
+    EMPTY_VECTOR(boxes);
+    EMPTY_VECTOR(sectors);
+    EMPTY_VECTOR(lights);
 }
 
-void Room::setNumXSectors(unsigned int n) {
-     numXSectors = n;
+unsigned int Room::getFlags() {
+    return flags;
 }
 
 unsigned int Room::getNumXSectors() {
     return numXSectors;
 }
 
-void Room::setNumZSectors(unsigned int n) {
-    numZSectors = n;
-}
-
 unsigned int Room::getNumZSectors() {
     return numZSectors;
 }
 
-void Room::setPos(vec3_t p) {
-    for (unsigned int i = 0; i < 3; i++)
-        pos[i] = p[i];
-}
-
 void Room::getPos(vec3_t p) {
     for (unsigned int i = 0; i < 3; i++)
         p[i] = pos[i];
@@ -187,12 +607,6 @@ void Room::getBoundingBox(vec3_t box[2]) {
             box[i][j] = bbox[i][j];
 }
 
-void Room::setBoundingBox(vec3_t box[2]) {
-    for (unsigned int i = 0; i < 2; i++)
-        for (unsigned int j = 0; j < 3; j++)
-            bbox[i][j] = box[i][j];
-}
-
 bool Room::inBox(vec_t x, vec_t y, vec_t z) {
     return ((y > bbox[0][1]) && (y < bbox[1][1]) && inBoxPlane(x, z));
 }
@@ -211,10 +625,6 @@ int Room::getAdjacentRoom(unsigned int index) {
     return adjacentRooms.at(index);
 }
 
-void Room::addAdjacentRoom(int r) {
-    adjacentRooms.push_back(r);
-}
-
 unsigned int Room::sizePortals() {
     return portals.size();
 }
@@ -224,10 +634,6 @@ Portal &Room::getPortal(unsigned int index) {
     return *portals.at(index);
 }
 
-void Room::addPortal(Portal &p) {
-    portals.push_back(&p);
-}
-
 unsigned int Room::sizeSectors() {
     return sectors.size();
 }
@@ -237,10 +643,6 @@ Sector &Room::getSector(unsigned int index) {
     return *sectors.at(index);
 }
 
-void Room::addSector(Sector &s) {
-    sectors.push_back(&s);
-}
-
 unsigned int Room::sizeBox() {
     return boxes.size();
 }
@@ -250,10 +652,6 @@ Box &Room::getBox(unsigned int index) {
     return *boxes.at(index);
 }
 
-void Room::addBox(Box &b) {
-    boxes.push_back(&b);
-}
-
 unsigned int Room::sizeModels() {
     return models.size();
 }
@@ -263,10 +661,6 @@ StaticModel &Room::getModel(unsigned int index) {
     return *models.at(index);
 }
 
-void Room::addModel(StaticModel &m) {
-    models.push_back(&m);
-}
-
 void Room::sortModels() {
     std::sort(models.begin(), models.end());
 }
@@ -280,10 +674,6 @@ Light &Room::getLight(unsigned int index) {
     return *lights.at(index);
 }
 
-void Room::addLight(Light &l) {
-    lights.push_back(&l);
-}
-
 unsigned int Room::sizeSprites() {
     return sprites.size();
 }
@@ -293,10 +683,6 @@ Sprite &Room::getSprite(unsigned int index) {
     return *sprites.at(index);
 }
 
-void Room::addSprite(Sprite &s) {
-    sprites.push_back(&s);
-}
-
 Mesh &Room::getMesh() {
     return mesh;
 }

src/Sprite.cpp

@@ -16,6 +16,11 @@
 #include "main.h"
 #include "Sprite.h"
 
+SpriteSequence::SpriteSequence(TombRaider &tr, unsigned int item, unsigned int sequence) {
+    for (int i = 0; i < (-tr.SpriteSequence()[sequence].negative_length); i++)
+        add(*new Sprite(tr, item, sequence, i));
+}
+
 SpriteSequence::~SpriteSequence() {
     for (unsigned int i = 0; i < sprites.size(); i++)
         delete &sprites.at(i);
@@ -33,27 +38,77 @@ Sprite &SpriteSequence::get(unsigned int index) {
     return *sprites.at(index);
 }
 
-Sprite::Sprite(vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture) {
-    radius = _radius;
-    texture = _texture;
-    for (unsigned int i = 0; i < 3; i++) {
-        vertex[0][i] = _vertex[0][i];
-        vertex[1][i] = _vertex[1][i];
-        vertex[2][i] = _vertex[2][i];
-        vertex[3][i] = _vertex[3][i];
-        pos[i] = _pos[i];
-        if (i < 2) {
-            texel[0][i] = _texel[0][i];
-            texel[1][i] = _texel[1][i];
-            texel[2][i] = _texel[2][i];
-            texel[3][i] = _texel[3][i];
-        }
-    }
+Sprite::Sprite(TombRaider &tr, unsigned int item, unsigned int sequence, unsigned int index) {
+    tr2_item_t *i = tr.Item();
+    tr2_sprite_texture_t *spriteTextures = tr.Sprite();
+    tr2_sprite_sequence_t *spriteSequence = tr.SpriteSequence();
+
+    //! \fixme index was unused?!
+    tr2_sprite_texture_t *sprite = &spriteTextures[spriteSequence[sequence].offset + index];
+
+    int width = sprite->width >> 8;
+    int height = sprite->height >> 8;
+    int x = sprite->x;
+    int y = sprite->y;
+    float scale = 4.0f;
+    float texelScale = 256.0f;
+    int width2 = (int)(width * scale);
+    int height2 = (int)(height * scale);
+
+    // For vising use
+    pos[0] = i[item].x;
+    pos[1] = i[item].y;
+    pos[2] = i[item].z;
+
+    vertex[0][0] = -width2 / 2.0f;
+    vertex[1][0] = -width2 / 2.0f;
+    vertex[2][0] = width2 / 2.0f;
+    vertex[3][0] = width2 / 2.0f;
+
+    vertex[0][1] = 0;
+    vertex[1][1] = -height2;
+    vertex[2][1] = -height2;
+    vertex[3][1] = 0;
+
+    vertex[0][2] = 0;
+    vertex[1][2] = 0;
+    vertex[2][2] = 0;
+    vertex[3][2] = 0;
+
+    texel[3][0] = (vec_t)(x+width)/texelScale;
+    texel[3][1] = (vec_t)(y+height)/texelScale;
+
+    texel[2][0] = (vec_t)(x+width)/texelScale;
+    texel[2][1] = (vec_t)(y)/texelScale;
+
+    texel[1][0] = (vec_t)(x) /texelScale;
+    texel[1][1] = (vec_t)(y) /texelScale;
+
+    texel[0][0] = (vec_t)(x) / texelScale;
+    texel[0][1] = (vec_t)(y+height)/texelScale;
+
+    texture = sprite->tile + getGame().getTextureStart();
+    radius = width2 / 2.0f;
+}
+
+Sprite::Sprite(TombRaider &tr, unsigned int room, unsigned int index) {
+    float spriteVertices[12];
+    float spriteTexCoords[8];
+
+    tr.getRoomSprite(room, index,
+            10.0f, &texture, pos, spriteVertices, spriteTexCoords);
+
+    texture += getGame().getTextureStart(); // OpenRaider preloads some textures
+
+    for (unsigned int j = 0; j < 12; j++)
+        vertex[j / 3][j % 3] = spriteVertices[j];
+
+    for (unsigned int j = 0; j < 8; j++)
+        texel[j / 2][j % 2] = spriteTexCoords[j];
 }
 
 void Sprite::display() {
-    if (!getRender().isVisible(pos[0], pos[1], pos[2],
-                radius))
+    if (!getRender().isVisible(pos[0], pos[1], pos[2], radius))
         return;
 
     glPushMatrix();

src/ViewVolume.cpp

@@ -113,7 +113,7 @@ vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, vec_t radiu
     return d + radius;
 }
 
-vec_t ViewVolume::getDistToBboxFromNear(vec3_t min, vec3_t max) {
+vec_t ViewVolume::getDistToBboxFromNear(const vec3_t min, const vec3_t max) {
     vec3_t center;
     vec_t d, radius;
 

src/math/math.cpp

@@ -75,13 +75,13 @@ int intersectionLinePolygon(vec3_t intersect,
     return 1;
 }
 
-vec_t distance(vec3_t a, vec3_t b) {
+vec_t distance(const vec3_t a, const vec3_t b) {
     return sqrtf(((b[0] - a[0]) * (b[0] - a[0])) +
                  ((b[1] - a[1]) * (b[1] - a[1])) +
                  ((b[2] - a[2]) * (b[2] - a[2])));
 }
 
-void midpoint(vec3_t a, vec3_t b, vec3_t mid) {
+void midpoint(const vec3_t a, const vec3_t b, vec3_t mid) {
     mid[0] = (a[0] + b[0]) / 2.0f;
     mid[1] = (a[1] + b[1]) / 2.0f;
     mid[2] = (a[2] + b[2]) / 2.0f;