Rewrote Sprite loading in Game

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140504 ]
+    * Forcing use of new Room and Sprite classes in World.
+    * Rewrote Sprite loading code in Game
+
     [ 20140503 ]
     * Started big World-Data refactoring.
       - Created Sprite class with drawing code from Render

include/Room.h

 public:
     Portal(vec3_t _vertices[4], vec3_t _normal, int _adjoiningRoom);
 
+    vec3_t *getVertices();
+    int getAdjoiningRoom();
+
 private:
     vec3_t vertices[4];
     vec3_t normal;
 class Sector {
 public:
     Sector(vec_t _floor, vec_t _ceiling, bool _wall);
+    vec_t getFloor();
+    vec_t getCeiling();
+    bool isWall();
 
 private:
     vec_t floor;
     Room(int _id);
     ~Room();
 
+    unsigned int getFlags();
+    unsigned int getNumXSectors();
+    unsigned int getNumZSectors();
+    void getPos(vec_t *target);
+
+    bool inBox(vec_t x, vec_t y, vec_t z);
+    bool inBoxPlane(vec_t x, vec_t z);
+
+    unsigned int sizePortals();
+    Portal &getPortal(unsigned int index);
+
+    unsigned int sizeSectors();
+    Sector &getSector(unsigned int index);
+
 private:
     int id;
     unsigned int flags;

include/Sprite.h

 
 class Sprite {
 public:
-    Sprite(int _numVerts, vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture);
+    Sprite(vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture);
     void display();
 
 private:
-    int numVerts;     //!< 4 == Quad, 3 == Triangle, rendered as triangles
     vec3_t vertex[4];
     vec2_t texel[4];
     vec3_t pos;

include/World.h

 #include <list>
 #include <vector>
 
-#define BAD_BLOOD //!< \todo For temp rendering use
-
-#ifdef BAD_BLOOD
-#include "SkeletalModel.h"
-#else
 #include "Room.h"
 #include "Sprite.h"
-#endif
 
 #include "WorldData.h"
 
      */
     ~World();
 
-#ifdef BAD_BLOOD
-
-    //! \todo Temp methods for rendering use until more refactoring is done
-
-    /*!
-     * \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
     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')
 
     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);
 
+    unsigned int sizeRoom();
+
+    Room &getRoom(unsigned int index);
+
     void addSprite(SpriteSequence &sprite);
 
-#endif
+    unsigned int sizeSprite();
+
+    SpriteSequence &getSprite(unsigned int index);
 
     /*!
      * \brief Find room a location is in.
      * \param x X coordinate
      * \param y will be set to world height in that room
      * \param z Z coordinate
-     * \returns true if position is in a room
      */
-    bool getHeightAtPosition(int index, float x, float *y, float z);
+    void getHeightAtPosition(int index, float x, float *y, float z);
 
     /*!
      * \brief Clears all data in world
 
 private:
 
-#ifdef BAD_BLOOD
-
     // Old World
     std::vector<entity_t *> mEntities;       //!< World entities
-    std::vector<room_mesh_t *> mRooms;       //!< Map data and meshes
     std::vector<model_mesh_t *> mMeshes;     //!< Unanimated meshes
-    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<SpriteSequence *> mSprites;
 
-#endif
-
 };
 
 #endif

src/Sprite.cpp

     return *sprites.at(index);
 }
 
-Sprite::Sprite(int _numVerts, vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture) {
+Sprite::Sprite(vec3_t _vertex[4], vec2_t _texel[4], vec3_t _pos, vec_t _radius, int _texture) {
-    numVerts = _numVerts;
     radius = _radius;
     texture = _texture;
     for (unsigned int i = 0; i < 3; i++) {

src/World.cpp

 
 
 // Temp methods for rendering use until more refactoring is done
-#ifdef BAD_BLOOD
 model_mesh_t *World::getMesh(int index)
 {
     return mMeshes[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()
-{
-    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)
 }
 
 
-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;
     e->moving = true;
 }
 
-#else
 
 void World::addRoom(Room &room) {
     mRooms.push_back(&room);
 }
 
+unsigned int World::sizeRoom() {
+    return mRooms.size();
+}
+
+Room &World::getRoom(unsigned int index) {
+    assert(index < mRooms.size());
+    return *mRooms.at(index);
+}
+
 void World::addSprite(SpriteSequence &sprite) {
     mSprites.push_back(&sprite);
 }
 
-#endif
+unsigned int World::sizeSprite() {
+    return mSprites.size();
+}
+
+SpriteSequence &World::getSprite(unsigned int index) {
+    assert(index < mSprites.size());
+    return *mSprites.at(index);
+}
 
 
 int World::getRoomByLocation(int index, float x, float y, float z)
 {
-    room_mesh_t *room = mRooms[index];
+    assert(index >= 0);
-
+    assert(index < mRooms.size());
-    if (room)
+    Room &room = *mRooms.at(index);
-    {
-        if (x > room->bbox_min[0] && x < room->bbox_max[0] &&
-                z > room->bbox_min[2] && z < room->bbox_max[2])
-        {
-            if (y > room->bbox_min[1] && y < room->bbox_max[1])
-                return index;
-        }
-    }
 
-    return getRoomByLocation(x, y, z);
+    if (room.inBox(x, y, z))
+        return index;
+    else
+        return getRoomByLocation(x, y, z);
 }
 
 
-int World::getRoomByLocation(float x, float y, float z)
+int World::getRoomByLocation(float x, float y, float z) {
-{
-    room_mesh_t *room;
     int hop = -1;
 
-
+    for (unsigned int i = 0; i < mRooms.size(); i++) {
-    for(std::vector<int>::size_type i = 0; i < mRooms.size(); i++)
+        if (mRooms.at(i)->inBoxPlane(x, z)) {
-    {
+            if (mRooms.at(i)->inBox(x, y, z))
-        room = mRooms[i];
-
-        if (!room)
-            continue;
-
-        if ((x > room->bbox_min[0]) && (x < room->bbox_max[0]) &&
-                (z > room->bbox_min[2]) && (z < room->bbox_max[2]))
-        {
-            // This room contains current position
-            if ((y > room->bbox_min[1]) && (y < room->bbox_max[1]))
                 return i;
-
+            else
-            // This room is above or below current position
+                hop = i; // This room is above or below current position
-            hop = i;
         }
     }
 
-    // Room is -1?  Must be in void, try to hop to room with same X,Z
     return hop;
-    //return -1;
 }
 
 
 int World::getAdjoiningRoom(int index,
         float x, float y, float z,
-        float x2, float y2, float z2)
+        float x2, float y2, float z2) {
-{
+    assert(index >= 0);
-    room_mesh_t *room = mRooms[index];
+    assert(index < mRooms.size());
-    portal_t * portal;
+    Room &room = *mRooms.at(index);
     vec3_t intersect, p1, p2;
 
-
     p1[0] = x;  p1[1] = y;  p1[2] = z;
     p2[0] = x2; p2[1] = y2; p2[2] = z2;
 
-    if (room)
+    for (unsigned int i = 0; i < room.sizePortals(); i++) {
-    {
+        if (intersectionLinePolygon(intersect, p1, p2, //4,
-        for(std::vector<int>::size_type i = 0; i != room->portals.size(); i++)
+                    room.getPortal(i).getVertices()))
-        {
+            return room.getPortal(i).getAdjoiningRoom();
-            portal = room->portals[i];
-
-            if (!portal)
-                continue;
-
-            if (intersectionLinePolygon(intersect, p1, p2, // 4,
-                        portal->vertices))
-            {
-                return portal->adjoining_room;
-            }
-        }
     }
 
     return -1;
 }
 
 
-int World::getSector(int room, float x, float z, float *floor, float *ceiling)
+int World::getSector(int room, float x, float z, float *floor, float *ceiling) {
-{
-    room_mesh_t *r;
-    sector_t * s;
-    int sector;
-
     assert(room >= 0);
+    assert(room < mRooms.size());
     assert(floor != NULL);
     assert(ceiling != NULL);
 
-    r = mRooms[room];
+    int sector = getSector(room, x, z);
-
-    if (!r)
-        return -1;
-
-    sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
-            (((int)z - (int)r->pos[2]) / 1024));
-
-    if (sector > -1)
-    {
-        s = r->sectors[sector];
 
-        if (!s)
+    if ((sector >= 0) && (sector < mRooms.at(room)->sizeSectors())) {
-            return -1;
+        *floor = mRooms.at(room)->getSector(sector).getFloor();
-
+        *ceiling = mRooms.at(room)->getSector(sector).getCeiling();
-        *floor = s->floor;
-        *ceiling = s->ceiling;
     }
 
     return sector;
 
 
 int World::getSector(int room, float x, float z) {
-    int sector;
+    assert(room >= 0);
-    room_mesh_t *r;
+    assert(room < mRooms.size());
-
-    if ((room < 0) || (room >= (int)mRooms.size()))
-        return -1;
-
-    r = mRooms[room];
-
-    if (!r)
-        return -1;
 
-    sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
+    vec3_t pos;
-            (((int)z - (int)r->pos[2]) / 1024));
+    mRooms.at(room)->getPos(pos);
+    int sector = (((((int)x - (int)pos[0]) / 1024) *
+        mRooms.at(room)->getNumZSectors()) + (((int)z - (int)pos[2]) / 1024));
 
     if (sector < 0)
         return -1;
 
 
 unsigned int World::getRoomInfo(int room) {
-    room_mesh_t *r;
+    assert(room >= 0);
-
+    assert(room < mRooms.size());
-    if ((room >= (int)mRooms.size()) || (room < 0))
-        return 0;
-
-    r = mRooms[room];
-
-    if (!r)
-        return 0;
 
-    return r->flags;
+    return mRooms.at(room)->getFlags();
 }
 
 
 bool World::isWall(int room, int sector) {
-    room_mesh_t *r;
+    assert(room >= 0);
-    sector_t *sect;
+    assert(room < mRooms.size());
-
+    assert(sector >= 0);
-    if ((room >= (int)mRooms.size()) || (room < 0))
+    assert(sector < mRooms.at(room)->sizeSectors());
-        return true;
-
-    r = mRooms[room];
-
-    if ((!r) || (sector >= (int)r->sectors.size()) || (sector < 0))
-        return true;
-
-    sect = r->sectors[sector];
-
-    if (!sect)
-        return true;
 
-    return ((sector > 0) && sect->wall); //! \fixme is (sector > 0) correct??
+    //! \fixme is (sector > 0) correct??
+    return ((sector > 0) && mRooms.at(room)->getSector(sector).isWall());
 }
 
 
-bool World::getHeightAtPosition(int index, float x, float *y, float z)
+void World::getHeightAtPosition(int index, float x, float *y, float z) {
-{
+    assert(index >= 0);
-    room_mesh_t *room = mRooms[index];
+    assert(index < mRooms.size());
-    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)
+    int sector = getSector(index, x, z);
-    {
+    if ((sector >= 0) && (sector < mRooms.at(index)->sizeSectors()))
-        return true;
+        *y = mRooms.at(index)->getSector(sector).getFloor();
-    }
-
-    *y = sect->floor;
-
-    return true;
 }
 
 
 void World::destroy()
 {
-    room_mesh_t *room;
+    for (unsigned int i = 0; i != mRooms.size(); i++)
+        delete mRooms[i];
+
+    for (unsigned int i = 0; i != mSprites.size(); i++)
+        delete mSprites[i];
+
     model_mesh_t *mesh;
-    sprite_seq_t *sprite;
     skeletal_model_t *model;
     bone_frame_t *boneframe;
     bone_tag_t *tag;
 
     for (std::vector<int>::size_type i = 0; i != mEntities.size(); i++)
         delete mEntities[i];
-    mEntities.clear();
-
-    for (std::vector<int>::size_type i = 0; i != mRooms.size(); i++) {
-        room = mRooms[i];
-
-        if (room) {
-            //! \fixme Causes "freeing already freed pointer" exceptions or EXEC_BAD_ACCESS
-
-            //for (std::vector<int>::size_type j = 0; j != room->portals.size(); j++)
-            //    delete room->portals[i];
-            room->portals.clear();
-
-            //for (std::vector<int>::size_type j = 0; j != room->models.size(); j++)
-            //    delete room->models[i];
-            room->models.clear();
-
-            //for (std::vector<int>::size_type j = 0; j != room->sprites.size(); j++)
-            //    delete room->sprites[i];
-            room->sprites.clear();
-
-            //for (std::vector<int>::size_type j = 0; j != room->sectors.size(); j++)
-            //    delete room->sectors[i];
-            room->sectors.clear();
-
-            //for (std::vector<int>::size_type j = 0; j != room->boxes.size(); j++)
-            //    delete room->boxes[i];
-            room->boxes.clear();
-
-            delete room;
-        }
-    }
 
     for (std::vector<int>::size_type i = 0; i != mMeshes.size(); i++) {
         mesh = mMeshes[i];
 
     mMeshes.clear();
 
-    for (std::vector<int>::size_type i = 0; i != mSprites.size(); i++) {
-        sprite = mSprites[i];
-
-        if (!sprite)
-            continue;
-
-        if (sprite->sprite)
-            delete [] sprite->sprite;
-
-        delete sprite;
-    }
-
-    mSprites.clear();
-
     for (std::vector<int>::size_type i = 0; i != mModels.size(); i++) {
         model = mModels[i];