Fixed many 64 to 32 bit warnings

CMakeLists.txt

     set (WARNINGS "${WARNINGS} -Wno-documentation-unknown-command -Wno-c++98-compat-pedantic")
 
     set (WARNINGS "${WARNINGS} -Wno-sign-conversion")
-    #set (WARNINGS "${WARNINGS} -Wno-shorten-64-to-32")
 
     set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -std=c++11")
     set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0 -ftrapv")

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140706 ]
+    * Use cmake to check for sys/time.h availability
+    * Use long nearly everywhere where STL containers are interfaced,
+      thereby fixing most 64 to 32 bit conversion warnings
+
     [ 20140705 ]
     * Added basic Travis CI support
     * Removed global object, using lazy initialization

TODO.md

 
 # Travis CI
 
-* Currently only building on Linux
-    * Should also build on Mac, but needs different before_install / install scripts,
-      that can detect the platform they’re running on
+* Run resulting executable, upload screenshot, post link in IRC
 

include/Entity.h

     void setAngles(float a[3]);
     float getPos(unsigned int i);
     float getAngle(unsigned int i);
-    int getRoom();
+    long getRoom();
 
     // Animation State
-    unsigned int getAnimation();
-    void setAnimation(unsigned int index);
-    unsigned int getBoneFrame();
-    void setBoneFrame(unsigned int index);
-    unsigned int getIdleAnimation();
-    void setIdleAnimation(unsigned int index);
+    unsigned long getAnimation();
+    void setAnimation(unsigned long index);
+    unsigned long getBoneFrame();
+    void setBoneFrame(unsigned long index);
+    unsigned long getIdleAnimation();
+    void setIdleAnimation(unsigned long index);
 
 private:
     float pos[3];
     float angles[3];
-    int room;
+    long room;
 
     unsigned int skeletalModel;
     MoveType moveType;
     int objectId;
 
     // Animation State
-    unsigned int boneFrame;
-    unsigned int animationFrame;
-    unsigned int idleAnimation;
+    unsigned long boneFrame;
+    unsigned long animationFrame;
+    unsigned long idleAnimation;
 };
 
 #endif

include/Game.h

     unsigned int mTextureStart;
     unsigned int mTextureOffset;
 
-    int mLara;
+    long mLara;
 };
 
 Game &getGame();

include/Menu.h

     void play();
 
     bool mVisible;
-    unsigned int mCursor;
-    unsigned int mMin;
+    unsigned long mCursor;
+    unsigned long mMin;
 
     FontString mainText;
 

include/Render.h

 
 private:
 
+    static void lightRoom(Room &room);
+
     void drawLoadScreen();
 
     /*!

include/Room.h

     Mesh &getMesh();
     void display(bool alpha);
 
-    bool isWall(unsigned int sector);
-    int getSector(float x, float z, float *floor, float *ceiling);
-    int getSector(float x, float z);
+    bool isWall(unsigned long sector);
+    long getSector(float x, float z, float *floor, float *ceiling);
+    long getSector(float x, float z);
     void getHeightAtPosition(float x, float *y, float z);
     int getAdjoiningRoom(float x, float y, float z,
         float x2, float y2, float z2);
     void setFlags(unsigned int f);
     unsigned int getFlags();
 
-    unsigned int sizeAdjacentRooms();
-    int getAdjacentRoom(unsigned int index);
+    unsigned long sizeAdjacentRooms();
+    long getAdjacentRoom(unsigned long index);
 
-    unsigned int sizePortals();
-    Portal &getPortal(unsigned int index);
+    unsigned long sizePortals();
+    Portal &getPortal(unsigned long index);
 
-    unsigned int sizeSectors();
-    Sector &getSector(unsigned int index);
+    unsigned long sizeSectors();
+    Sector &getSector(unsigned long index);
 
-    unsigned int sizeBox();
-    Box &getBox(unsigned int index);
+    unsigned long sizeBox();
+    Box &getBox(unsigned long index);
 
-    unsigned int sizeModels();
-    StaticModel &getModel(unsigned int index);
+    unsigned long sizeModels();
+    StaticModel &getModel(unsigned long index);
 
-    unsigned int sizeLights();
-    Light &getLight(unsigned int index);
+    unsigned long sizeLights();
+    Light &getLight(unsigned long index);
 
-    unsigned int sizeSprites();
-    Sprite &getSprite(unsigned int index);
+    unsigned long sizeSprites();
+    Sprite &getSprite(unsigned long index);
 
 private:
     void sortModels();
     BoundingBox bbox;
     Mesh mesh;
 
-    std::vector<int> adjacentRooms;
+    std::vector<long> adjacentRooms;
     std::vector<Sprite *> sprites;
     std::vector<StaticModel *> models;
     std::vector<Portal *> portals;

include/SkeletalModel.h

 
     void getPosition(float p[3]);
 
-    unsigned int size();
-    BoneTag &get(unsigned int i);
+    unsigned long size();
+    BoneTag &get(unsigned long i);
 
 private:
     float pos[3];
     AnimationFrame(TombRaider &tr, unsigned int index, int a, unsigned int *frame_offset, int frame_step);
     ~AnimationFrame();
 
-    unsigned int size();
-    BoneFrame &get(unsigned int i);
+    unsigned long size();
+    BoneFrame &get(unsigned long i);
 
 private:
     char rate;
 public:
     SkeletalModel(TombRaider &tr, unsigned int index, int objectId);
     ~SkeletalModel();
-    void display(unsigned int aframe, unsigned int bframe);
+    void display(unsigned long aframe, unsigned long bframe);
 
     int getId();
     void setPigTail(bool b);
     void setPonyPos(float x, float y, float z, float angle);
 
-    unsigned int size();
-    AnimationFrame &get(unsigned int i);
+    unsigned long size();
+    AnimationFrame &get(unsigned long i);
 
 private:
     int id;
     bool tr4Overlay;
     bool pigtails;
-    int ponytailId;
+    long ponytailId;
     float ponytail[3];
-    int ponytailMeshId;
+    long ponytailMeshId;
     unsigned int ponytailNumMeshes;
     float ponytailAngle;
     float ponyOff;

include/Sound.h

      * \brief Get number of registered sources
      * \returns number of registered sources
      */
-    virtual int registeredSources() = 0;
+    virtual unsigned long registeredSources() = 0;
 
     /*!
      * \brief Remove all loaded sounds
      * \param source valid source id
      * \param pos new position for source
      */
-    virtual void sourceAt(int source, float pos[3]) = 0;
+    virtual void sourceAt(unsigned long source, float pos[3]) = 0;
 
     /*!
      * \brief Load wav file from disk
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addFile(const char *filename, int *source, unsigned int flags) = 0;
+    virtual int addFile(const char *filename, unsigned long *source, unsigned int flags) = 0;
 
     /*!
      * \brief Load wav file from buffer
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags) = 0;
+    virtual int addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags) = 0;
 
     /*!
      * \brief Play sound source
      * \param source sound source to play
      */
-    virtual void play(int source) = 0;
+    virtual void play(unsigned long source) = 0;
 
     /*!
      * \brief Stop playing sound source
      * \param source sound source to stop
      */
-    virtual void stop(int source) = 0;
+    virtual void stop(unsigned long source) = 0;
 };
 
 Sound &getSound();

include/SoundAL.h

      * \brief Get number of registered sources
      * \returns number of registered sources
      */
-    virtual int registeredSources();
+    virtual unsigned long registeredSources();
 
     /*!
      * \brief Remove all loaded sounds
      * \param source valid source id
      * \param pos new position for source
      */
-    virtual void sourceAt(int source, float pos[3]);
+    virtual void sourceAt(unsigned long source, float pos[3]);
 
     /*!
      * \brief Load wav file from disk
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addFile(const char *filename, int *source, unsigned int flags);
+    virtual int addFile(const char *filename, unsigned long *source, unsigned int flags);
 
     /*!
      * \brief Load wav file from buffer
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags);
+    virtual int addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags);
 
     /*!
      * \brief Play sound source
      * \param source sound source to play
      */
-    virtual void play(int source);
+    virtual void play(unsigned long source);
 
     /*!
      * \brief Stop playing sound source
      * \param source sound source to stop
      */
-    virtual void stop(int source);
+    virtual void stop(unsigned long source);
 
 private:
 
     bool mEnabled;
-    bool mInit;                        //!< Guard to ensure ausio system is active
-    float mVolume;                     //!< Listener gain
+    bool mInit;                         //!< Guard to ensure ausio system is active
+    float mVolume;                      //!< Listener gain
     std::vector<unsigned int> mBuffer; //!< Audio buffer id list
     std::vector<unsigned int> mSource; //!< Audio source id list
 };

include/SoundNull.h

      * \brief Get number of registered sources
      * \returns number of registered sources
      */
-    virtual int registeredSources();
+    virtual unsigned long registeredSources();
 
     /*!
      * \brief Remove all loaded sounds
      * \param source valid source id
      * \param pos new position for source
      */
-    virtual void sourceAt(int source, float pos[3]);
+    virtual void sourceAt(unsigned long source, float pos[3]);
 
     /*!
      * \brief Load wav file from disk
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addFile(const char *filename, int *source, unsigned int flags);
+    virtual int addFile(const char *filename, unsigned long *source, unsigned int flags);
 
     /*!
      * \brief Load wav file from buffer
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags);
+    virtual int addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags);
 
     /*!
      * \brief Play sound source
      * \param source sound source to play
      */
-    virtual void play(int source);
+    virtual void play(unsigned long source);
 
     /*!
      * \brief Stop playing sound source
      * \param source sound source to stop
      */
-    virtual void stop(int source);
+    virtual void stop(unsigned long source);
 };
 
 #endif

include/Sprite.h

     SpriteSequence(TombRaider &tr, unsigned int item, unsigned int sequence);
     ~SpriteSequence();
 
-    unsigned int size();
-    Sprite &get(unsigned int index);
+    unsigned long size();
+    Sprite &get(unsigned long index);
 
 private:
     std::vector<Sprite *> sprites;

include/Window.h

 
     virtual void glExit2D();
 
+    virtual void lookAt(float eyeX, float eyeY, float eyeZ,
+                        float lookAtX, float lookAtY, float lookAtZ,
+                        float upX, float upY, float upZ);
+
 protected:
     bool mInit;
     bool mFullscreen;

include/World.h

     void destroy();
 
     void addRoom(Room &room);
-    unsigned int sizeRoom();
-    Room &getRoom(unsigned int index);
+    unsigned long sizeRoom();
+    Room &getRoom(unsigned long index);
 
     void addSprite(SpriteSequence &sprite);
-    unsigned int sizeSprite();
-    SpriteSequence &getSprite(unsigned int index);
+    unsigned long sizeSprite();
+    SpriteSequence &getSprite(unsigned long index);
 
     void addEntity(Entity &entity);
-    unsigned int sizeEntity();
-    Entity &getEntity(unsigned int index);
+    unsigned long sizeEntity();
+    Entity &getEntity(unsigned long index);
 
     void addSkeletalModel(SkeletalModel &model);
-    unsigned int sizeSkeletalModel();
-    SkeletalModel &getSkeletalModel(unsigned int index);
+    unsigned long sizeSkeletalModel();
+    SkeletalModel &getSkeletalModel(unsigned long index);
 
     void addStaticMesh(StaticMesh &model);
-    unsigned int sizeStaticMesh();
-    StaticMesh &getStaticMesh(unsigned int index);
+    unsigned long sizeStaticMesh();
+    StaticMesh &getStaticMesh(unsigned long index);
 
     /*!
      * \brief Find room a location is in.
      * \param z Z coordinate
      * \returns correct room index or -1 for unknown
      */
-    int getRoomByLocation(int index, float x, float y, float z);
+    long getRoomByLocation(long index, float x, float y, float z);
 
     /*!
      * \brief Find room a location is in.
      * \param z Z coordinate
      * \returns correct room index or -1 for unknown
      */
-    int getRoomByLocation(float x, float y, float z);
+    long getRoomByLocation(float x, float y, float z);
 
 private:
     std::vector<Room *> mRooms;

include/config.h.in

 #cmakedefine HAVE_CLOSEDIR
 #cmakedefine HAVE_DT_DIR
 
+#cmakedefine HAVE_SYS_TIME_H
+#cmakedefine HAVE_GETTIMEOFDAY
+
 #endif
 

include/utils/time.h

 #ifndef _UTILS_TIME_H_
 #define _UTILS_TIME_H_
 
+extern unsigned long systemTimerStart;
+
 /*!
  * \brief Read the system timer
  * \returns number of ticks

src/CMakeLists.txt

 check_function_exists (closedir HAVE_CLOSEDIR)
 check_symbol_exists (DT_DIR "dirent.h" HAVE_DT_DIR)
 
+# gettimeofday() for timing
+check_include_files (sys/time.h HAVE_SYS_TIME_H)
+check_function_exists (gettimeofday HAVE_GETTIMEOFDAY)
+
 #################################################################
 
 # Configuration Header file
 #################################################################
 
 # Add target to run executable
-add_custom_target(run COMMAND OpenRaider DEPENDS OpenRaider WORKING_DIRECTORY ${CMAKE_PROJECT_DIR})
+if (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" OR ${CMAKE_GENERATOR} STREQUAL "MinGW Makefiles")
+    add_custom_target(run COMMAND OpenRaider DEPENDS OpenRaider WORKING_DIRECTORY ${CMAKE_PROJECT_DIR})
+endif (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" OR ${CMAKE_GENERATOR} STREQUAL "MinGW Makefiles") 

src/Console.cpp

         glRecti(0, 0, getWindow().getWidth(), getWindow().getHeight() / 2);
         glEnable(GL_TEXTURE_2D);
 
-        int scrollIndicator;
+        unsigned long scrollIndicator;
         if (mHistory.size() > lineCount) {
             scrollIndicator = (mHistory.size() - lineCount - mLineOffset) * 100 / (mHistory.size() - lineCount);
         } else {
                 "%s uptime %lus scroll %d%%", VERSION, systemTimerGet() / 1000, scrollIndicator);
 
         // Draw output log
-        int end = lineCount;
-        int drawOffset = 0;
-        int historyOffset = 0;
+        long end = lineCount;
+        long drawOffset = 0;
+        long historyOffset = 0;
         if (mHistory.size() < lineCount) {
             end = mHistory.size();
             drawOffset = lineCount - mHistory.size();
             historyOffset = mHistory.size() - lineCount;
         }
         for (int i = 0; i < end; i++) {
-            getFont().drawText(10, ((i + drawOffset) * lineSteps) + firstLine,
+            getFont().drawText(10, (unsigned int)((i + drawOffset) * lineSteps) + firstLine,
                     0.75f, BLUE, "%s", mHistory[i + historyOffset - mLineOffset]);
         }
 

src/Entity.cpp

     const float testd = 220.0f;
     const float camHeight = 8.0f;
     float x, y, z, pitch, h, floor, ceiling;
-    int roomNew, sector;
+    long roomNew, sector;
     bool wall;
     unsigned int roomFlags;
 
                 x, y, z);
 
         if (roomNew > -1)
-            getConsole().print("Crossing from room %i to %i", room, roomNew);
+            getConsole().print("Crossing from room %li to %li", room, roomNew);
         else
             //! \fixme mRooms, sectors, ... are now std::vector, but often upper bound checks are missing
             return;
 
 void Entity::print() {
     getConsole().print("Entity %d:", objectId);
-    getConsole().print("  Room %i (0x%X)", room, getWorld().getRoom(room).getFlags());
+    getConsole().print("  Room %li (0x%X)", room, getWorld().getRoom(room).getFlags());
     getConsole().print("  %.1fx %.1fy %.1fz", pos[0], pos[1], pos[2]);
     getConsole().print("  %.1f Yaw", OR_RAD_TO_DEG(angles[1]));
 }
     return angles[i];
 }
 
-int Entity::getRoom() {
+long Entity::getRoom() {
     return room;
 }
 
-unsigned int Entity::getAnimation() {
+unsigned long Entity::getAnimation() {
     return animationFrame;
 }
 
-void Entity::setAnimation(unsigned int index) {
+void Entity::setAnimation(unsigned long index) {
     animationFrame = index;
     boneFrame = 0;
 }
 
-unsigned int Entity::getBoneFrame() {
+unsigned long Entity::getBoneFrame() {
     return boneFrame;
 }
 
-void Entity::setBoneFrame(unsigned int index) {
+void Entity::setBoneFrame(unsigned long index) {
     boneFrame = index;
 }
 
-unsigned int Entity::getIdleAnimation() {
+unsigned long Entity::getIdleAnimation() {
     return idleAnimation;
 }
 
-void Entity::setIdleAnimation(unsigned int index) {
+void Entity::setIdleAnimation(unsigned long index) {
     idleAnimation = index;
 }
 

src/Game.cpp

         char *tmp = bufferString("%sMAIN.SFX", level); // Ensure theres enough space
         size_t length = strlen(tmp);
         size_t dir = 0;
-        for (int i = length - 1; i >= 0; i--) {
+        for (long i = length - 1; i >= 0; i--) {
             if ((tmp[i] == '/') || (tmp[i] == '\\')) {
                 dir = i + 1; // Find where the filename (bla.tr2) starts
                 break;
     //tr2_sound_details_t *detail;
     //float pos[3];
     unsigned int i;
-    int id;
+    unsigned long id;
 
     /* detail
        short sample;

src/Menu.cpp

     int items = (getWindow().getHeight() - 110) / 25;
 
     // Select which part of the list to show
-    int min, max;
-    if (((int)mCursor - (items / 2)) > 0)
+    long min, max;
+    if (((long)mCursor - (items / 2)) > 0)
         min = mCursor - (items / 2);
     else
         min = 0;
         else
             mCursor = 0;
     } else if (key == rightKey) {
-        int i = 10;
+        long i = 10;
         if (mCursor > (mMapList.size() - 11))
             i = mMapList.size() - 1 - mCursor;
         while (i-- > 0)
             handleKeyboard(downKey, true);
     } else if (key == leftKey) {
-        int i = 10;
+        long i = 10;
         if (mCursor < 10)
             i = mCursor;
         while (i-- > 0)

src/Render.cpp

 }
 
 
-void setLighting(bool on)
-{
-    if (on)
-    {
-        float color[4];
-        color[0] = WHITE[0] * 256.0f;
-        color[1] = WHITE[1] * 256.0f;
-        color[2] = WHITE[2] * 256.0f;
-        color[3] = WHITE[3] * 256.0f;
-
-        glEnable(GL_LIGHTING);
-        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
-        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
-        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
-
-        color[0] = GREY[0] * 256.0f;
-        color[1] = GREY[1] * 256.0f;
-        color[2] = GREY[2] * 256.0f;
-        color[3] = GREY[3] * 256.0f;
-        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, color);
-    }
-    else
-    {
-        glDisable(GL_LIGHTING);
-    }
-}
-
-
-void lightRoom(Room &room)
+void Render::lightRoom(Room &room)
 {
     for (unsigned int i = 0; i < room.sizeLights(); ++i)
     {
 
     if (flags & Render::fGL_Lights)
     {
-        setLighting(false);
+        glDisable(GL_LIGHTING);
     }
 }
 
 
     if (flags & Render::fGL_Lights)
     {
-        setLighting(true);
+        float color[4];
+        color[0] = WHITE[0] * 256.0f;
+        color[1] = WHITE[1] * 256.0f;
+        color[2] = WHITE[2] * 256.0f;
+        color[3] = WHITE[3] * 256.0f;
+
+        glEnable(GL_LIGHTING);
+        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
+        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
+        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
+
+        color[0] = GREY[0] * 256.0f;
+        color[1] = GREY[1] * 256.0f;
+        color[2] = GREY[2] * 256.0f;
+        color[3] = GREY[3] * 256.0f;
+        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, color);
     }
 }
 
     }
 }
 
-// Replaced the deprecated gluLookAt with slightly modified code from here:
-// http://www.khronos.org/message_boards/showthread.php/4991
-void gluLookAt(float eyeX, float eyeY, float eyeZ,
-        float lookAtX, float lookAtY, float lookAtZ,
-        float upX, float upY, float upZ) {
-    // calculating the viewing vector
-    float f[3] = {
-        lookAtX - eyeX,
-        lookAtY - eyeY,
-        lookAtZ - eyeZ
-    };
-
-    // normalizing the viewing vector
-    float fMag = sqrtf(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
-    f[0] /= fMag;
-    f[1] /= fMag;
-    f[2] /= fMag;
-
-    float s[3] = {
-        (f[1] * upZ) - (upY * f[2]),
-        (upX * f[2]) - (f[0] * upZ),
-        (f[0] * upY) - (upX * f[1])
-    };
-
-    float u[3] = {
-        (s[1] * f[2]) - (f[1] * s[2]),
-        (f[0] * s[2]) - (s[0] * f[2]),
-        (s[0] * f[1]) - (f[0] * s[1])
-    };
-
-    float m[16] = {
-        s[0], u[0], -f[0], 0,
-        s[1], u[1], -f[1], 0,
-        s[2], u[2], -f[2], 0,
-           0,    0,     0, 1
-    };
-    glMultMatrixf(m);
-    glTranslatef(-eyeX, -eyeY, -eyeZ);
-}
 
 void Render::display()
 {
     camPos[1] = curPos[1] - camOffsetH; // UP is lower val
     camPos[2] = curPos[2] - (1024.0f * cosf(yaw));
 
-    int index = getGame().getLara().getRoom();
-    int sector = getWorld().getRoom(index).getSector(camPos[0], camPos[2]);
+    long index = getGame().getLara().getRoom();
+    long sector = getWorld().getRoom(index).getSector(camPos[0], camPos[2]);
 
     // Handle camera out of world
     if ((sector < 0) ||
     getCamera().update();
     getCamera().getTarget(atPos);
     // Mongoose 2002.08.13, Quick fix to render OpenRaider upside down
-    gluLookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0f, -1.0f, 0.0f);
+    getWindow().lookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0f, -1.0f, 0.0f);
 
     // Update view volume for vising
     updateViewVolume();

src/Room.cpp

     }
 }
 
-bool Room::isWall(unsigned int sector) {
-    assert(sector >= 0);
+bool Room::isWall(unsigned long sector) {
     assert(sector < sectors.size());
 
     //! \fixme is (sector > 0) correct??
     return ((sector > 0) && sectors.at(sector)->isWall());
 }
 
-int Room::getSector(float x, float z, float *floor, float *ceiling) {
+long Room::getSector(float x, float z, float *floor, float *ceiling) {
     assert(floor != NULL);
     assert(ceiling != NULL);
 
-    int sector = getSector(x, z);
+    long sector = getSector(x, z);
 
-    if ((sector >= 0) && (sector < (int)sectors.size())) {
+    if ((sector >= 0) && (sector < (long)sectors.size())) {
         *floor = sectors.at(sector)->getFloor();
         *ceiling = sectors.at(sector)->getCeiling();
     }
     return sector;
 }
 
-int Room::getSector(float x, float z) {
-    int sector = (((((int)x - (int)pos[0]) / 1024) *
+long Room::getSector(float x, float z) {
+    long sector = (((((int)x - (int)pos[0]) / 1024) *
         numZSectors) + (((int)z - (int)pos[2]) / 1024));
 
     if (sector < 0)
 }
 
 void Room::getHeightAtPosition(float x, float *y, float z) {
-    int sector = getSector(x, z);
-    if ((sector >= 0) && (sector < (int)sectors.size()))
+    long sector = getSector(x, z);
+    if ((sector >= 0) && (sector < (long)sectors.size()))
         *y = sectors.at(sector)->getFloor();
 }
 
     p1[0] = x;  p1[1] = y;  p1[2] = z;
     p2[0] = x2; p2[1] = y2; p2[2] = z2;
 
-    for (unsigned int i = 0; i < portals.size(); i++) {
+    for (unsigned long i = 0; i < portals.size(); i++) {
         portals.at(i)->getVertices(vertices);
         if (intersectionLinePolygon(intersect, p1, p2, //4,
                     vertices))
         p[i] = pos[i];
 }
 
-unsigned int Room::sizeAdjacentRooms() {
+unsigned long Room::sizeAdjacentRooms() {
     return adjacentRooms.size();
 }
 
-int Room::getAdjacentRoom(unsigned int index) {
+long Room::getAdjacentRoom(unsigned long index) {
     assert(index < adjacentRooms.size());
     return adjacentRooms.at(index);
 }
 
-unsigned int Room::sizePortals() {
+unsigned long Room::sizePortals() {
     return portals.size();
 }
 
-Portal &Room::getPortal(unsigned int index) {
+Portal &Room::getPortal(unsigned long index) {
     assert(index < portals.size());
     return *portals.at(index);
 }
 
-unsigned int Room::sizeSectors() {
+unsigned long Room::sizeSectors() {
     return sectors.size();
 }
 
-Sector &Room::getSector(unsigned int index) {
+Sector &Room::getSector(unsigned long index) {
     assert(index < sectors.size());
     return *sectors.at(index);
 }
 
-unsigned int Room::sizeBox() {
+unsigned long Room::sizeBox() {
     return boxes.size();
 }
 
-Box &Room::getBox(unsigned int index) {
+Box &Room::getBox(unsigned long index) {
     assert(index < boxes.size());
     return *boxes.at(index);
 }
 
-unsigned int Room::sizeModels() {
+unsigned long Room::sizeModels() {
     return models.size();
 }
 
-StaticModel &Room::getModel(unsigned int index) {
+StaticModel &Room::getModel(unsigned long index) {
     assert(index < models.size());
     return *models.at(index);
 }
     std::sort(models.begin(), models.end());
 }
 
-unsigned int Room::sizeLights() {
+unsigned long Room::sizeLights() {
     return lights.size();
 }
 
-Light &Room::getLight(unsigned int index) {
+Light &Room::getLight(unsigned long index) {
     assert(index < lights.size());
     return *lights.at(index);
 }
 
-unsigned int Room::sizeSprites() {
+unsigned long Room::sizeSprites() {
     return sprites.size();
 }
 
-Sprite &Room::getSprite(unsigned int index) {
+Sprite &Room::getSprite(unsigned long index) {
     assert(index < sprites.size());
     return *sprites.at(index);
 }

src/SkeletalModel.cpp

 }
 
 BoneFrame::~BoneFrame() {
-    for (unsigned int i = 0; i < tag.size(); i++)
+    for (unsigned long i = 0; i < tag.size(); i++)
         delete tag[i];
 }
 
-unsigned int BoneFrame::size() {
+unsigned long BoneFrame::size() {
     return tag.size();
 }
 
-BoneTag &BoneFrame::get(unsigned int i) {
+BoneTag &BoneFrame::get(unsigned long i) {
     assert(i < tag.size());
     return *tag.at(i);
 }
 }
 
 AnimationFrame::~AnimationFrame() {
-    for (unsigned int i = 0; i < frame.size(); i++)
+    for (unsigned long i = 0; i < frame.size(); i++)
         delete frame[i];
 }
 
-unsigned int AnimationFrame::size() {
+unsigned long AnimationFrame::size() {
     return frame.size();
 }
 
-BoneFrame &AnimationFrame::get(unsigned int i) {
+BoneFrame &AnimationFrame::get(unsigned long i) {
     assert(i < frame.size());
     return *frame.at(i);
 }
 }
 
 SkeletalModel::~SkeletalModel() {
-    for (unsigned int i = 0; i < animation.size(); i++)
+    for (unsigned long i = 0; i < animation.size(); i++)
         delete animation[i];
 }
 
-void SkeletalModel::display(unsigned int aframe, unsigned int bframe) {
+void SkeletalModel::display(unsigned long aframe, unsigned long bframe) {
     assert(aframe < size());
     assert(bframe < get(aframe).size());
 
     ponytailAngle = angle;
 }
 
-unsigned int SkeletalModel::size() {
+unsigned long SkeletalModel::size() {
     return animation.size();
 }
 
-AnimationFrame &SkeletalModel::get(unsigned int i) {
+AnimationFrame &SkeletalModel::get(unsigned long i) {
     assert(i < animation.size());
     return *animation.at(i);
 }

src/SoundAL.cpp

     mVolume = vol;
 }
 
-int SoundAL::registeredSources() {
+unsigned long SoundAL::registeredSources() {
     assert(mSource.size() == mBuffer.size());
 
     if ((!mEnabled) || (!mInit))
     alListenerfv(AL_ORIENTATION, angle);
 }
 
-void SoundAL::sourceAt(int source, float pos[3]) {
+void SoundAL::sourceAt(unsigned long source, float pos[3]) {
     assert(mSource.size() == mBuffer.size());
-    assert(source >= 0);
-    assert(source < (int)mSource.size());
+    assert(source < mSource.size());
     assert(pos != NULL);
 
     if ((!mEnabled) || (!mInit))
 }
 
 //! \fixme Seperate sourcing and buffering, Mongoose 2002.01.04
-int SoundAL::addFile(const char *filename, int *source, unsigned int flags) {
+int SoundAL::addFile(const char *filename, unsigned long *source, unsigned int flags) {
     ALsizei size;
     ALfloat freq;
     ALenum format;
     ALvoid *data;
-    int id;
+    unsigned long id;
 
     assert(mSource.size() == mBuffer.size());
     assert(filename != NULL);
         return 0;
     }
 
-    *source = -1;
     id = mSource.size();
 
     mSource.push_back(0);
     return 0;
 }
 
-int SoundAL::addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags) {
+int SoundAL::addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags) {
     ALsizei size;
     ALfloat freq;
     ALenum format;
     ALvoid *data;
     int error = 0;
-    int id;
+    unsigned long id;
 
     assert(mSource.size() == mBuffer.size());
     assert(wav != NULL);
         return 0;
     }
 
-    *source = -1;
     id = mSource.size();
 
     mSource.push_back(0);
     return 0;
 }
 
-void SoundAL::play(int source) {
+void SoundAL::play(unsigned long source) {
+    assert(mInit);
     assert(mSource.size() == mBuffer.size());
-    assert(source >= 0);
-    assert(source < (int)mSource.size());
+    assert(source < mSource.size());
 
-    if ((!mEnabled) || (!mInit))
+    if (!mEnabled)
         return;
 
     alSourcePlay(mSource[source]);
 }
 
-void SoundAL::stop(int source) {
+void SoundAL::stop(unsigned long source) {
+    assert(mInit);
     assert(mSource.size() == mBuffer.size());
-    assert(source >= 0);
-    assert(source < (int)mSource.size());
+    assert(source < mSource.size());
 
-    if ((!mEnabled) || (!mInit))
+    if (!mEnabled)
         return;
 
     alSourceStop(mSource[source]);

src/SoundNull.cpp

 void SoundNull::setVolume(float vol) {
 }
 
-int SoundNull::registeredSources() {
+unsigned long SoundNull::registeredSources() {
     return 0;
 }
 
 void SoundNull::listenAt(float pos[3], float angle[3]) {
 }
 
-void SoundNull::sourceAt(int source, float pos[3]) {
+void SoundNull::sourceAt(unsigned long source, float pos[3]) {
 }
 
-int SoundNull::addFile(const char *filename, int *source, unsigned int flags) {
+int SoundNull::addFile(const char *filename, unsigned long *source, unsigned int flags) {
     return 0;
 }
 
-int SoundNull::addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags) {
+int SoundNull::addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags) {
     return 0;
 }
 
-void SoundNull::play(int source) {
+void SoundNull::play(unsigned long source) {
 }
 
-void SoundNull::stop(int source) {
+void SoundNull::stop(unsigned long source) {
 }
 

src/Sprite.cpp

         delete sprites.at(i);
 }
 
-unsigned int SpriteSequence::size() {
+unsigned long SpriteSequence::size() {
     return sprites.size();
 }
 
-Sprite &SpriteSequence::get(unsigned int index) {
+Sprite &SpriteSequence::get(unsigned long index) {
+    assert(index < sprites.size());
     return *sprites.at(index);
 }
 

src/Window.cpp

     glMatrixMode(GL_MODELVIEW);
 }
 
+// Replaced the deprecated gluLookAt with slightly modified code from here:
+// http://www.khronos.org/message_boards/showthread.php/4991
+void Window::lookAt(float eyeX, float eyeY, float eyeZ,
+        float lookAtX, float lookAtY, float lookAtZ,
+        float upX, float upY, float upZ) {
+    // calculating the viewing vector
+    float f[3] = {
+        lookAtX - eyeX,
+        lookAtY - eyeY,
+        lookAtZ - eyeZ
+    };
+
+    // normalizing the viewing vector
+    float fMag = sqrtf(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
+    f[0] /= fMag;
+    f[1] /= fMag;
+    f[2] /= fMag;
+
+    float s[3] = {
+        (f[1] * upZ) - (upY * f[2]),
+        (upX * f[2]) - (f[0] * upZ),
+        (f[0] * upY) - (upX * f[1])
+    };
+
+    float u[3] = {
+        (s[1] * f[2]) - (f[1] * s[2]),
+        (f[0] * s[2]) - (s[0] * f[2]),
+        (s[0] * f[1]) - (f[0] * s[1])
+    };
+
+    float m[16] = {
+        s[0], u[0], -f[0], 0,
+        s[1], u[1], -f[1], 0,
+        s[2], u[2], -f[2], 0,
+           0,    0,     0, 1
+    };
+    glMultMatrixf(m);
+    glTranslatef(-eyeX, -eyeY, -eyeZ);
+}
+

src/World.cpp

     mRooms.push_back(&room);
 }
 
-unsigned int World::sizeRoom() {
+unsigned long World::sizeRoom() {
     return mRooms.size();
 }
 
-Room &World::getRoom(unsigned int index) {
+Room &World::getRoom(unsigned long index) {
     assert(index < mRooms.size());
     return *mRooms.at(index);
 }
     mSprites.push_back(&sprite);
 }
 
-unsigned int World::sizeSprite() {
+unsigned long World::sizeSprite() {
     return mSprites.size();
 }
 
-SpriteSequence &World::getSprite(unsigned int index) {
+SpriteSequence &World::getSprite(unsigned long index) {
     assert(index < mSprites.size());
     return *mSprites.at(index);
 }
     mEntities.push_back(&entity);
 }
 
-unsigned int World::sizeEntity() {
+unsigned long World::sizeEntity() {
     return mEntities.size();
 }
 
-Entity &World::getEntity(unsigned int index) {
+Entity &World::getEntity(unsigned long index) {
     assert(index < mEntities.size());
     return *mEntities.at(index);
 }
     mModels.push_back(&model);
 }
 
-unsigned int World::sizeSkeletalModel() {
+unsigned long World::sizeSkeletalModel() {
     return mModels.size();
 }
 
-SkeletalModel &World::getSkeletalModel(unsigned int index) {
+SkeletalModel &World::getSkeletalModel(unsigned long index) {
     assert(index < mModels.size());
     return *mModels.at(index);
 }
     mMeshes.push_back(&model);
 }
 
-unsigned int World::sizeStaticMesh() {
+unsigned long World::sizeStaticMesh() {
     return mMeshes.size();
 }
 
-StaticMesh &World::getStaticMesh(unsigned int index) {
+StaticMesh &World::getStaticMesh(unsigned long index) {
     assert(index < mMeshes.size());
     return *mMeshes.at(index);
 }
 
 
-int World::getRoomByLocation(int index, float x, float y, float z)
+long World::getRoomByLocation(long index, float x, float y, float z)
 {
     assert(index >= 0);
-    assert(index < (int)mRooms.size());
+    assert(index < (long)mRooms.size());
     Room &room = *mRooms.at(index);
 
     if (room.getBoundingBox().inBox(x, y, z))
 }
 
 
-int World::getRoomByLocation(float x, float y, float z) {
-    int hop = -1;
+long World::getRoomByLocation(float x, float y, float z) {
+    long hop = -1;
 
-    for (unsigned int i = 0; i < mRooms.size(); i++) {
+    for (unsigned long i = 0; i < mRooms.size(); i++) {
         if (mRooms.at(i)->getBoundingBox().inBoxPlane(x, z)) {
             if (mRooms.at(i)->getBoundingBox().inBox(x, y, z))
                 return i;
 
 
 void World::destroy() {
-    for (unsigned int i = 0; i < mRooms.size(); i++)
+    for (unsigned long i = 0; i < mRooms.size(); i++)
         delete mRooms[i];
     mRooms.clear();
 
-    for (unsigned int i = 0; i < mSprites.size(); i++)
+    for (unsigned long i = 0; i < mSprites.size(); i++)
         delete mSprites[i];
     mSprites.clear();
 
-    for (unsigned int i = 0; i < mEntities.size(); i++)
+    for (unsigned long i = 0; i < mEntities.size(); i++)
         delete mEntities[i];
     mEntities.clear();
 
-    for (unsigned int i = 0; i < mModels.size(); i++)
+    for (unsigned long i = 0; i < mModels.size(); i++)
         delete mModels[i];
     mModels.clear();
 
-    for (unsigned int i = 0; i < mMeshes.size(); i++)
+    for (unsigned long i = 0; i < mMeshes.size(); i++)
         delete mMeshes[i];
     mMeshes.clear();
 }

src/main.cpp

 #error No Windowing Library selected!
 #endif
 
+void cleanupHandler(void);
+
 Camera &getCamera() {
     static Camera gCamera;
     return gCamera;

src/utils/png.cpp

 
     png_read_update_info(png_ptr, info_ptr);
 
-    int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+    png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 
     png_byte *image_data = new png_byte[(rowbytes * *height) + 15];
     png_bytep *row_pointers = new png_bytep[*height];

src/utils/strings.cpp

 }
 
 char *fullPath(const char *path, char end) {
-    unsigned int lenPath;
+    size_t lenPath;
     char *dir;
 
     assert(path != NULL);
         wordexp_t word;
 
 #ifdef __APPLE__
-        // Workaround for Mac OS X. See:
+        // Workunsigned long systemTimerStart = 0;around for Mac OS X. See:
         // http://stackoverflow.com/questions/20534788/why-does-wordexp-fail-with-wrde-syntax-on-os-x
         signal(SIGCHLD, SIG_DFL);
 #endif
         dir = new char[lenPath + 2]; // space for end char
 
         // Copy segments into new string
-        unsigned int offset = 0;
+        size_t offset = 0;
         for (unsigned int i = 0; i < word.we_wordc; i++) {
-            unsigned int len = strlen(word.we_wordv[i]);
+            size_t len = strlen(word.we_wordv[i]);
             strncpy(dir + offset, word.we_wordv[i], len);
             offset += len;
         }
         char newPath[MAX_PATH];
         if (SHGetFolderPath(NULL, CSIDL_PROFILE, NULL, 0, newPath) == S_OK) {
             lenPath = strlen(newPath);
-            unsigned int lenPath2 = strlen(path);
+            size_t lenPath2 = strlen(path);
             dir = new char[lenPath + lenPath2 + 2]; // space for end char
             strncpy(dir, newPath, lenPath);
             strncpy((dir + lenPath), (path + 1), lenPath2 - 1);
             lenPath += lenPath2 - 1;
-			for (unsigned int i = 0; i < lenPath; i++)
-				if(dir[i] == '\\')
-					dir[i] = '/';
+            for (unsigned int i = 0; i < lenPath; i++)
+                if(dir[i] == '\\')
+                    dir[i] = '/';
         } else {
             printf("WARNING: Could not get home folder location for tilde expansion!\n");
             lenPath = strlen(path);

src/utils/time.cpp

 #include "global.h"
 #include "utils/time.h"
 
-#if defined(unix) || defined(__APPLE__) || defined (__linux__)
+unsigned long systemTimerStart = 0;
 
-#include <sys/time.h>
+#if defined(HAVE_SYS_TIME_H) && defined(HAVE_GETTIMEOFDAY)
 
-struct timeval system_timer_start;
-struct timeval system_timer_stop;
-struct timezone system_timer_zone;
+#include <sys/time.h>
 
 unsigned long systemTimerGet() {
-    gettimeofday(&system_timer_stop, &system_timer_zone);
-    return ((system_timer_stop.tv_sec - system_timer_start.tv_sec) * 1000)
-        + (((system_timer_stop.tv_usec - system_timer_start.tv_usec) / 1000));
+    struct timeval time;
+    struct timezone zone;
+    gettimeofday(&time, &zone);
+    return ((time.tv_sec * 1000) + (time.tv_usec / 1000)) - systemTimerStart;
 }
 
 void systemTimerReset() {
-    gettimeofday(&system_timer_start, &system_timer_zone);
+    struct timeval time;
+    struct timezone zone;
+    gettimeofday(&time, &zone);
+    systemTimerStart = (time.tv_sec * 1000) + (time.tv_usec / 1000);
 }
 
 #elif defined(_WIN32)
 
 #include <Windows.h>
 
-DWORD system_timer_start = 0;
-
 unsigned long systemTimerGet() {
-    return GetTickCount() - system_timer_start;
+    return GetTickCount() - systemTimerStart;
 }
 
 void systemTimerReset() {
-    system_timer_start = GetTickCount();
+    systemTimerStart = GetTickCount();
 }
 
 #else
-
 #error "No support for timer on this platform!"
-
 #endif