Starting refactoring

TODO.md

@@ -1,3 +1,5 @@
+# To-Do List
+
 ## General
 
 There are these DebugModel, DebugMap flags...?

include/Sprite.h

@@ -24,5 +24,17 @@ private:
     int texture;
 };
 
+class SpriteSequence {
+public:
+    ~SpriteSequence();
+
+    void add(Sprite &s);
+    unsigned int size();
+    Sprite &get(unsigned int index);
+
+private:
+    std::vector<Sprite *> sprites;
+};
+
 #endif
 

include/World.h

@@ -12,14 +12,15 @@
 #include <list>
 #include <vector>
 
-#define BAD_BLOOD  //!< \todo For temp rendering use
+#define BAD_BLOOD //!< \todo For temp rendering use
 
 #ifdef BAD_BLOOD
 #include "SkeletalModel.h"
-#endif
-
+#else
 #include "Room.h"
 #include "Sprite.h"
+#endif
+
 #include "WorldData.h"
 
 /*!
@@ -29,14 +30,66 @@ class World {
 public:
 
     /*!
-     * \brief Constructs an object of World
+     * \brief Deconstructs an object of World
      */
-    World();
+    ~World();
+
+#ifdef BAD_BLOOD
+
+    //! \todo Temp methods for rendering use until more refactoring is done
 
     /*!
-     * \brief Deconstructs an object of World
+     * \brief Adds room to world
+     * \param room room to add
      */
-    ~World();
+    void addRoom(room_mesh_t *room);
+
+    /*!
+     * \brief Adds mesh to world
+     * \param model mesh to add
+     */
+    void addMesh(model_mesh_t *model);
+
+    /*!
+     * \brief Adds entity to world
+     * \param e entity to add
+     */
+    void addEntity(entity_t *e);
+
+    /*!
+     * \brief Adds model to world.
+     * \param model model to add
+     * \returns next model ID or -1 on error
+     */
+    int addModel(skeletal_model_t *model);
+
+    /*!
+     * \brief Adds sprite to world
+     * \param sprite sprite to add
+     */
+    void addSprite(sprite_seq_t *sprite);
+
+    /*!
+     * \brief Move entity in given direction unless collision occurs
+     * \param e entity to move
+     * \param movement direction of movement ('f', 'b', 'l' or 'r')
+     */
+    void moveEntity(entity_t *e, char movement);
+
+    model_mesh_t *getMesh(int index);
+    skeletal_model_t *getModel(int index);
+    room_mesh_t *getRoom(int index);
+    std::vector<entity_t *> *getEntities();
+    std::vector<sprite_seq_t *> *getSprites();
+    std::vector<room_mesh_t *> *getRooms();
+
+#else
+
+    void addRoom(Room &room);
+
+    void addSprite(SpriteSequence &sprite);
+
+#endif
 
     /*!
      * \brief Find room a location is in.
@@ -107,62 +160,16 @@ public:
      */
     bool getHeightAtPosition(int index, float x, float *y, float z);
 
-#ifdef BAD_BLOOD
-    //! \todo Temp methods for rendering use until more refactoring is done
-    model_mesh_t *getMesh(int index);
-    skeletal_model_t *getModel(int index);
-    room_mesh_t *getRoom(int index);
-    std::vector<entity_t *> *getEntities();
-    std::vector<sprite_seq_t *> *getSprites();
-    std::vector<room_mesh_t *> *getRooms();
-#endif
-
     /*!
      * \brief Clears all data in world
      * \todo in future will check if data is in use before clearing
      */
     void destroy();
 
-    /*!
-     * \brief Adds room to world
-     * \param room room to add
-     */
-    void addRoom(room_mesh_t *room);
-
-    /*!
-     * \brief Adds mesh to world
-     * \param model mesh to add
-     */
-    void addMesh(model_mesh_t *model);
-
-    /*!
-     * \brief Adds entity to world
-     * \param e entity to add
-     */
-    void addEntity(entity_t *e);
-
-    /*!
-     * \brief Adds model to world.
-     * \param model model to add
-     * \returns next model ID or -1 on error
-     */
-    int addModel(skeletal_model_t *model);
-
-    /*!
-     * \brief Adds sprite to world
-     * \param sprite sprite to add
-     */
-    void addSprite(sprite_seq_t *sprite);
-
-    /*!
-     * \brief Move entity in given direction unless collision occurs
-     * \param e entity to move
-     * \param movement direction of movement ('f', 'b', 'l' or 'r')
-     */
-    void moveEntity(entity_t *e, char movement);
-
 private:
 
+#ifdef BAD_BLOOD
+
     // Old World
     std::vector<entity_t *> mEntities;       //!< World entities
     std::vector<room_mesh_t *> mRooms;       //!< Map data and meshes
@@ -170,9 +177,14 @@ private:
     std::vector<sprite_seq_t *> mSprites;    //!< Sprites
     std::vector<skeletal_model_t *> mModels; //!< Skeletal animation models
 
+#else
+
     // New World
-    //std::vector<Room *> mRooms;
-    //std::vector<std::vector<Sprite *>> mSprites; // Sprite sequence
+    std::vector<Room *> mRooms;
+    std::vector<SpriteSequence *> mSprites;
+
+#endif
+
 };
 
 #endif

src/Sprite.cpp

@@ -16,6 +16,23 @@
 #include "main.h"
 #include "Sprite.h"
 
+SpriteSequence::~SpriteSequence() {
+    for (unsigned int i = 0; i < sprites.size(); i++)
+        delete &sprites.at(i);
+}
+
+void SpriteSequence::add(Sprite &s) {
+    sprites.push_back(&s);
+}
+
+unsigned int SpriteSequence::size() {
+    return sprites.size();
+}
+
+Sprite &SpriteSequence::get(unsigned int index) {
+    return *sprites.at(index);
+}
+
 Sprite::Sprite(int _numVerts, vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture) {
     numVerts = _numVerts;
     radius = _radius;

src/World.cpp

@@ -11,25 +11,278 @@
 
 #include "World.h"
 
+World::~World()
+{
+    destroy();
+}
 
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
 
-World::World()
+// Temp methods for rendering use until more refactoring is done
+#ifdef BAD_BLOOD
+model_mesh_t *World::getMesh(int index)
 {
+    return mMeshes[index];
 }
 
+skeletal_model_t *World::getModel(int index)
+{
+    return mModels[index];
+}
 
-World::~World()
+room_mesh_t *World::getRoom(int index)
 {
-    destroy();
+    return mRooms[index];
+}
+
+std::vector<entity_t *> *World::getEntities()
+{
+    return &mEntities;
+}
+
+std::vector<sprite_seq_t *> *World::getSprites()
+{
+    return &mSprites;
+}
+
+std::vector<room_mesh_t *> *World::getRooms()
+{
+    return &mRooms;
+}
+
+void World::addRoom(room_mesh_t *room)
+{
+    mRooms.push_back(room);
+}
+
+
+void World::addMesh(model_mesh_t *mesh)
+{
+    if (mesh)
+        mMeshes.push_back(mesh);
+}
+
+
+void World::addEntity(entity_t *e)
+{
+    if (e)
+    {
+        e->master = 0x0;
+        e->moveType = worldMoveType_walk; // Walk
+        e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
+        mEntities.push_back(e);
+    }
+}
+
+
+int World::addModel(skeletal_model_t *model)
+{
+    if (model)
+    {
+        mModels.push_back(model);
+        return mModels.size() - 1;
+    }
+
+    return -1;
+}
+
+
+void World::addSprite(sprite_seq_t *sprite)
+{
+    if (sprite)
+        mSprites.push_back(sprite);
+}
+
+
+void World::moveEntity(entity_t *e, char movement)
+{
+    const float moved = 180.0f;
+    const float testd = 220.0f;
+    const float camHeight = 8.0f;
+    float x, y, z, pitch, h, floor, ceiling;
+    int room, sector;
+    bool wall;
+    unsigned int roomFlags;
+
+
+    if (!e)
+    {
+        return;
+    }
+
+    switch (e->moveType)
+    {
+        case worldMoveType_walkNoSwim:
+        case worldMoveType_walk:
+            pitch = 0.0f;  // in the future pitch could control jump up blocks here
+            break;
+
+        case worldMoveType_noClipping:
+        case worldMoveType_fly:
+        case worldMoveType_swim:
+            pitch = e->angles[2];
+            break;
+    }
+
+    switch (movement)
+    {
+        case 'f':
+            x = e->pos[0] + (testd * sinf(e->angles[1]));
+            y = e->pos[1] + (testd * sinf(pitch));
+            z = e->pos[2] + (testd * cosf(e->angles[1]));
+            break;
+        case 'b':
+            x = e->pos[0] - (testd * sinf(e->angles[1]));
+            y = e->pos[1] - (testd * sinf(pitch));
+            z = e->pos[2] - (testd * cosf(e->angles[1]));
+            break;
+        case 'l':
+            x = e->pos[0] - (testd * sinf(e->angles[1] + 90.0f));
+            y = e->pos[1];
+            z = e->pos[2] - (testd * cosf(e->angles[1] + 90.0f));
+            break;
+        case 'r':
+            x = e->pos[0] + (testd * sinf(e->angles[1] + 90.0f));
+            y = e->pos[1];
+            z = e->pos[2] + (testd * cosf(e->angles[1] + 90.0f));
+            break;
+        default:
+            return;
+    }
+
+    //room = getRoomByLocation(x, y, z);
+    room = getRoomByLocation(e->room, x, y, z);
+
+    if (room == -1) // Will we hit a portal?
+    {
+        room = getAdjoiningRoom(e->room,
+                e->pos[0],  e->pos[1], e->pos[2],
+                x, y, z);
+
+        if (room > -1)
+        {
+            printf("Crossing from room %i to %i\n", e->room, room);
+        } else {
+            //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
+            return;
+        }
+    }
+
+    roomFlags = getRoomInfo(room);
+    sector = getSector(room, x, z, &floor, &ceiling);
+    wall = isWall(room, sector);
+
+    // If you're underwater you may want to swim  =)
+    // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
+    if (roomFlags & roomFlag_underWater && e->moveType == worldMoveType_walk)
+    {
+        e->moveType = worldMoveType_swim;
+    }
+
+    // Don't swim on land
+    if (!(roomFlags & roomFlag_underWater) && e->moveType == worldMoveType_swim)
+    {
+        e->moveType = worldMoveType_walk;
+    }
+
+    // Mongoose 2002.09.02, Add check for room -> room transition
+    //   ( Only allow by movement between rooms by using portals )
+    if (((e->moveType == worldMoveType_noClipping) ||
+                (e->moveType == worldMoveType_fly) ||
+                (e->moveType == worldMoveType_swim)) ||
+            ((room > -1) && (!wall)))
+    {
+        e->room = room;
+
+        switch (movement)
+        {
+            case 'f':
+                x = e->pos[0] + (moved * sinf(e->angles[1]));
+                y = e->pos[1] + (moved * sinf(pitch));
+                z = e->pos[2] + (moved * cosf(e->angles[1]));
+                break;
+            case 'b':
+                x = e->pos[0] - (moved * sinf(e->angles[1]));
+                y = e->pos[1] - (moved * sinf(pitch));
+                z = e->pos[2] - (moved * cosf(e->angles[1]));
+                break;
+            case 'l':
+                x = e->pos[0] - (moved * sinf(e->angles[1] + 90.0f));
+                z = e->pos[2] - (moved * cosf(e->angles[1] + 90.0f));
+                break;
+            case 'r':
+                x = e->pos[0] + (moved * sinf(e->angles[1] + 90.0f));
+                z = e->pos[2] + (moved * cosf(e->angles[1] + 90.0f));
+                break;
+        }
+
+        /*! \fixme Test for vector (move vector) / plane (portal) collision here
+         * to see if we need to switch rooms... man...
+         */
+
+        h = y;
+        getHeightAtPosition(room, x, &h, z);
+
+        switch (e->moveType)
+        {
+            case worldMoveType_fly:
+            case worldMoveType_swim:
+                // Don't fall out of world, avoid a movement that does
+                if (h > y - camHeight)
+                {
+                    e->pos[0] = x;
+                    e->pos[1] = y;
+                    e->pos[2] = z;
+                }
+                break;
+            case worldMoveType_walk:
+            case worldMoveType_walkNoSwim:
+                y = e->pos[1];  // Override vector movement walking ( er, not pretty )
+
+                // Now fake gravity
+                // Mongoose 2002.08.14, Remember TR is upside down ( you fall 'up' )
+
+                //ddist = h - e->pos[1];
+
+                // This is to force false gravity, by making camera stay on ground
+                e->pos[1] = h; //roomFloor->bbox_min[1];
+
+                // Check for camera below terrian and correct
+                if (e->pos[1] < h - camHeight)
+                {
+                    e->pos[1] = h - camHeight;
+                }
+
+                e->pos[0] = x;
+                e->pos[2] = z;
+                break;
+            case worldMoveType_noClipping:
+                e->pos[0] = x;
+                e->pos[1] = y;
+                e->pos[2] = z;
+        }
+    }
+    else
+    {
+        e->moving = false;
+        return;
+    }
+
+    e->room = room;
+    e->moving = true;
 }
 
+#else
+
+void World::addRoom(Room &room) {
+    mRooms.push_back(&room);
+}
+
+void World::addSprite(SpriteSequence &sprite) {
+    mSprites.push_back(&sprite);
+}
+
+#endif
 
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
 
 int World::getRoomByLocation(int index, float x, float y, float z)
 {
@@ -204,65 +457,31 @@ bool World::isWall(int room, int sector) {
 }
 
 
-bool World::getHeightAtPosition(int index, float x, float *y, float z)
-{
-    room_mesh_t *room = mRooms[index];
-    int sector;
-    sector_t *sect;
-
-    if (!room)
-    {
-        return false;
-    }
-
-    // Mongoose 2002.08.14, Remember sector_z is width of sector array
-    sector = getSector(index, x, z);
-
-    sect = room->sectors[sector];
-
-    if (!sect)
-    {
-        return true;
-    }
-
-    *y = sect->floor;
-
-    return true;
-}
-
-
-// Temp methods for rendering use until more refactoring is done
-#ifdef BAD_BLOOD
-model_mesh_t *World::getMesh(int index)
-{
-    return mMeshes[index];
-}
-
-skeletal_model_t *World::getModel(int index)
-{
-    return mModels[index];
-}
-
-room_mesh_t *World::getRoom(int index)
-{
-    return mRooms[index];
-}
-
-std::vector<entity_t *> *World::getEntities()
-{
-    return &mEntities;
-}
-
-std::vector<sprite_seq_t *> *World::getSprites()
+bool World::getHeightAtPosition(int index, float x, float *y, float z)
 {
-    return &mSprites;
-}
+    room_mesh_t *room = mRooms[index];
+    int sector;
+    sector_t *sect;
 
-std::vector<room_mesh_t *> *World::getRooms()
-{
-    return &mRooms;
+    if (!room)
+    {
+        return false;
+    }
+
+    // Mongoose 2002.08.14, Remember sector_z is width of sector array
+    sector = getSector(index, x, z);
+
+    sect = room->sectors[sector];
+
+    if (!sect)
+    {
+        return true;
+    }
+
+    *y = sect->floor;
+
+    return true;
 }
-#endif
 
 
 void World::destroy()
@@ -417,226 +636,3 @@ void World::destroy()
     mModels.clear();
 }
 
-
-void World::addRoom(room_mesh_t *room)
-{
-    mRooms.push_back(room);
-}
-
-
-void World::addMesh(model_mesh_t *mesh)
-{
-    if (mesh)
-        mMeshes.push_back(mesh);
-}
-
-
-void World::addEntity(entity_t *e)
-{
-    if (e)
-    {
-        e->master = 0x0;
-        e->moveType = worldMoveType_walk; // Walk
-        e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
-        mEntities.push_back(e);
-    }
-}
-
-
-int World::addModel(skeletal_model_t *model)
-{
-    if (model)
-    {
-        mModels.push_back(model);
-        return mModels.size() - 1;
-    }
-
-    return -1;
-}
-
-
-void World::addSprite(sprite_seq_t *sprite)
-{
-    if (sprite)
-        mSprites.push_back(sprite);
-}
-
-
-void World::moveEntity(entity_t *e, char movement)
-{
-    const float moved = 180.0f;
-    const float testd = 220.0f;
-    const float camHeight = 8.0f;
-    float x, y, z, pitch, h, floor, ceiling;
-    int room, sector;
-    bool wall;
-    unsigned int roomFlags;
-
-
-    if (!e)
-    {
-        return;
-    }
-
-    switch (e->moveType)
-    {
-        case worldMoveType_walkNoSwim:
-        case worldMoveType_walk:
-            pitch = 0.0f;  // in the future pitch could control jump up blocks here
-            break;
-
-        case worldMoveType_noClipping:
-        case worldMoveType_fly:
-        case worldMoveType_swim:
-            pitch = e->angles[2];
-            break;
-    }
-
-    switch (movement)
-    {
-        case 'f':
-            x = e->pos[0] + (testd * sinf(e->angles[1]));
-            y = e->pos[1] + (testd * sinf(pitch));
-            z = e->pos[2] + (testd * cosf(e->angles[1]));
-            break;
-        case 'b':
-            x = e->pos[0] - (testd * sinf(e->angles[1]));
-            y = e->pos[1] - (testd * sinf(pitch));
-            z = e->pos[2] - (testd * cosf(e->angles[1]));
-            break;
-        case 'l':
-            x = e->pos[0] - (testd * sinf(e->angles[1] + 90.0f));
-            y = e->pos[1];
-            z = e->pos[2] - (testd * cosf(e->angles[1] + 90.0f));
-            break;
-        case 'r':
-            x = e->pos[0] + (testd * sinf(e->angles[1] + 90.0f));
-            y = e->pos[1];
-            z = e->pos[2] + (testd * cosf(e->angles[1] + 90.0f));
-            break;
-        default:
-            return;
-    }
-
-    //room = getRoomByLocation(x, y, z);
-    room = getRoomByLocation(e->room, x, y, z);
-
-    if (room == -1) // Will we hit a portal?
-    {
-        room = getAdjoiningRoom(e->room,
-                e->pos[0],  e->pos[1], e->pos[2],
-                x, y, z);
-
-        if (room > -1)
-        {
-            printf("Crossing from room %i to %i\n", e->room, room);
-        } else {
-            //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
-            return;
-        }
-    }
-
-    roomFlags = getRoomInfo(room);
-    sector = getSector(room, x, z, &floor, &ceiling);
-    wall = isWall(room, sector);
-
-    // If you're underwater you may want to swim  =)
-    // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
-    if (roomFlags & roomFlag_underWater && e->moveType == worldMoveType_walk)
-    {
-        e->moveType = worldMoveType_swim;
-    }
-
-    // Don't swim on land
-    if (!(roomFlags & roomFlag_underWater) && e->moveType == worldMoveType_swim)
-    {
-        e->moveType = worldMoveType_walk;
-    }
-
-    // Mongoose 2002.09.02, Add check for room -> room transition
-    //   ( Only allow by movement between rooms by using portals )
-    if (((e->moveType == worldMoveType_noClipping) ||
-                (e->moveType == worldMoveType_fly) ||
-                (e->moveType == worldMoveType_swim)) ||
-            ((room > -1) && (!wall)))
-    {
-        e->room = room;
-
-        switch (movement)
-        {
-            case 'f':
-                x = e->pos[0] + (moved * sinf(e->angles[1]));
-                y = e->pos[1] + (moved * sinf(pitch));
-                z = e->pos[2] + (moved * cosf(e->angles[1]));
-                break;
-            case 'b':
-                x = e->pos[0] - (moved * sinf(e->angles[1]));
-                y = e->pos[1] - (moved * sinf(pitch));
-                z = e->pos[2] - (moved * cosf(e->angles[1]));
-                break;
-            case 'l':
-                x = e->pos[0] - (moved * sinf(e->angles[1] + 90.0f));
-                z = e->pos[2] - (moved * cosf(e->angles[1] + 90.0f));
-                break;
-            case 'r':
-                x = e->pos[0] + (moved * sinf(e->angles[1] + 90.0f));
-                z = e->pos[2] + (moved * cosf(e->angles[1] + 90.0f));
-                break;
-        }
-
-        /*! \fixme Test for vector (move vector) / plane (portal) collision here
-         * to see if we need to switch rooms... man...
-         */
-
-        h = y;
-        getHeightAtPosition(room, x, &h, z);
-
-        switch (e->moveType)
-        {
-            case worldMoveType_fly:
-            case worldMoveType_swim:
-                // Don't fall out of world, avoid a movement that does
-                if (h > y - camHeight)
-                {
-                    e->pos[0] = x;
-                    e->pos[1] = y;
-                    e->pos[2] = z;
-                }
-                break;
-            case worldMoveType_walk:
-            case worldMoveType_walkNoSwim:
-                y = e->pos[1];  // Override vector movement walking ( er, not pretty )
-
-                // Now fake gravity
-                // Mongoose 2002.08.14, Remember TR is upside down ( you fall 'up' )
-
-                //ddist = h - e->pos[1];
-
-                // This is to force false gravity, by making camera stay on ground
-                e->pos[1] = h; //roomFloor->bbox_min[1];
-
-                // Check for camera below terrian and correct
-                if (e->pos[1] < h - camHeight)
-                {
-                    e->pos[1] = h - camHeight;
-                }
-
-                e->pos[0] = x;
-                e->pos[2] = z;
-                break;
-            case worldMoveType_noClipping:
-                e->pos[0] = x;
-                e->pos[1] = y;
-                e->pos[2] = z;
-        }
-    }
-    else
-    {
-        e->moving = false;
-        return;
-    }
-
-    e->room = room;
-    e->moving = true;
-}
-