less warnings

include/Camera.h

      * \brief Get angle/yaw of camera
      * \returns theta angle/yaw of camera
      */
-    double getRadianYaw();
+    vec_t getRadianYaw();
     /*------------------------------------------------------
      * Pre  :
      * Post : Returns theta angle/yaw of camera
      * \brief Get angle/pitch of camera
      * \returns phi angle/pitch of camera
      */
-    double getRadianPitch();
+    vec_t getRadianPitch();
 
     /*!
      * \brief Check if the coordinate is behind camera eye
     unsigned int mId;             //!< Unique id
     Quaternion mQ;                //!< Quaternion for rotation
     unsigned int mFlags;          //!< For testing with flags
-    double mPos[4];               //!< Location in 3 space (aka eye)
-    double mTarget[4];            //!< Postition we're looking at
-    double mUp[4];                //!< Up vector
-    double mSide[4];              //!< Side vector
-    double mViewDistance;         //!< Distance from target
-    double mTranslateDelta;       //!< Step size to move
-    double mRotateDelta;          //!< Radians to rotate Y
-    double mTheta;                //!< View angle Y
-    double mRotateDelta2;         //!< Radians to rotate Z
-    double mTheta2;               //!< View angle Z
+    vec_t mPos[4];               //!< Location in 3 space (aka eye)
+    vec_t mTarget[4];            //!< Postition we're looking at
+    vec_t mUp[4];                //!< Up vector
+    vec_t mSide[4];              //!< Side vector
+    vec_t mViewDistance;         //!< Distance from target
+    vec_t mTranslateDelta;       //!< Step size to move
+    vec_t mRotateDelta;          //!< Radians to rotate Y
+    vec_t mTheta;                //!< View angle Y
+    vec_t mRotateDelta2;         //!< Radians to rotate Z
+    vec_t mTheta2;               //!< View angle Z
     bool mUpdate;                 //!< Check to see if view needs updating
     static unsigned int mCounter; //!< Id system use
 };

include/MatMath.h

 #ifndef _MATMATH_H
 #define _MATMATH_H
 
-#define HEL_PI           M_PI //!< pi
-#define HEL_2_PI         (M_PI * 2.0) //!< pi*2
-#define HEL_PI_OVER_4    M_PI_4 //!< pi/4
-#define HEL_PI_OVER_180  (M_PI / 180.0) //!< pi/180
-#define HEL_180_OVER_PI  (180.0 / M_PI) //!< 180/pi
+#define HEL_PI           ((float)M_PI) //!< pi
+#define HEL_2_PI         (HEL_PI * 2.0f) //!< pi*2
+#define HEL_PI_OVER_4    (M_PI_4 / 4.0f) //!< pi/4
+#define HEL_PI_OVER_180  (HEL_PI / 180.0f) //!< pi/180
+#define HEL_180_OVER_PI  (180.0f / HEL_PI) //!< 180/pi
 
 #define HEL_RAD_TO_DEG(x) ((x) * HEL_180_OVER_PI) //!< Convert radians to degrees
 #define HEL_DEG_TO_RAD(x) ((x) * HEL_PI_OVER_180) //!< Convert degrees to radians

include/Matrix.h

 
     /*!
      * \brief Multiplies v vector and this matrix
-     * \param v double[4] vector
-     * \param result where the result will be stored, may be same as v
-     */
-    void multiply4d(double *v, double *result);
-
-    /*!
-     * \brief Multiplies v vector and this matrix
      * \param v vector
      * \param result where the result will be stored, may be same as v
      */

include/Network.h

 
     unsigned int getUID();
 
-    float getRandom(float from, float to);
-
     int getPort();
 
     void setDebug(bool toggle);

src/Camera.cpp

 {
     mId = ++mCounter;
     mFlags = 0;
-    mViewDistance = 14.0;
-    mTranslateDelta = 256.0;
-    mRotateDelta = HEL_DEG_TO_RAD(15.0);
-    mRotateDelta2 = HEL_DEG_TO_RAD(5.0);
+    mViewDistance = 14.0f;
+    mTranslateDelta = 256.0f;
+    mRotateDelta = HEL_DEG_TO_RAD(15.0f);
+    mRotateDelta2 = HEL_DEG_TO_RAD(5.0f);
     mFlags &= Camera_FlyMode;
     reset();
 }
 }
 
 
-double Camera::getRadianYaw()
+vec_t Camera::getRadianYaw()
 {
     return mTheta;
 }
 
 
-double Camera::getRadianPitch()
+vec_t Camera::getRadianPitch()
 {
     return mTheta2;
 }
 {
     Quaternion t, n;
     Matrix matrix;
-    double side[4] = { 1, 0,  0, 1 };
-    double up[4] =   { 0, 1,  0, 1 };
-    double look[4] = { 0, 0, -1, 1 };
+    vec_t side[4] = { 1.0f, 0.0f,  0.0f, 1.0f };
+    vec_t up[4] =   { 0.0f, 1.0f,  0.0f, 1.0f };
+    vec_t look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
     unsigned int i;
     matrix_t m;
 
 
     n.getMatrix(m);
     matrix.setMatrix(m);
-    matrix.multiply4d(side, mSide);
-    matrix.multiply4d(look, mTarget);
-    matrix.multiply4d(up, mUp);
+    matrix.multiply4v(side, mSide);
+    matrix.multiply4v(look, mTarget);
+    matrix.multiply4v(up, mUp);
 
     for (i = 0; i < 3; ++i)
     {
 void Camera::translate(float x, float y, float z)
 {
     int i;
-    double result[4];
-    double v[4];
+    vec_t result[4];
+    vec_t v[4];
     matrix_t m;
     Matrix matrix;
 
     m[15] = 1;
 
     matrix.setMatrix(m);
-    matrix.multiply4d(v, result);
+    matrix.multiply4v(v, result);
 
     for (i = 0; i < 3; ++i)
     {
 
 void Camera::reset()
 {
-    mTheta = 0.0;
-    mTheta2 = 0.0;
+    mTheta = 0.0f;
+    mTheta2 = 0.0f;
 
-    mPos[0] = 0.0;
-    mPos[1] = 0.0;
-    mPos[2] = 0.0;
+    mPos[0] = 0.0f;
+    mPos[1] = 0.0f;
+    mPos[2] = 0.0f;
 
-    mTarget[0] = 0.0;
-    mTarget[1] = 0.0;
+    mTarget[0] = 0.0f;
+    mTarget[1] = 0.0f;
     mTarget[2] = mViewDistance;
 
-    mSide[0] = 1.0;
-    mSide[1] = 0.0;
-    mSide[2] = 0.0;
+    mSide[0] = 1.0f;
+    mSide[1] = 0.0f;
+    mSide[2] = 0.0f;
 
-    mUp[0] = 0.0;
-    mUp[1] = 1.0;
-    mUp[2] = 0.0;
+    mUp[0] = 0.0f;
+    mUp[1] = 1.0f;
+    mUp[2] = 0.0f;
 
     mQ.setIdentity();
-    translate(0.0, 0.0, 0.0);
+    translate(0.0f, 0.0f, 0.0f);
 }
 
 
         case CAMERA_MOVE_FORWARD:
             if (mFlags & Camera_FlyMode)
             {
-                mPos[2] += (mTranslateDelta * cos(mTheta));
+                mPos[2] += (mTranslateDelta * cosf(mTheta));
             }
 
-            mPos[0] += (mTranslateDelta * sin(mTheta));
-            mPos[1] += (mTranslateDelta * sin(mTheta2));
+            mPos[0] += (mTranslateDelta * sinf(mTheta));
+            mPos[1] += (mTranslateDelta * sinf(mTheta2));
             break;
         case CAMERA_MOVE_BACKWARD:
             if (mFlags & Camera_FlyMode)
             {
-                mPos[2] -= (mTranslateDelta * cos(mTheta));
+                mPos[2] -= (mTranslateDelta * cosf(mTheta));
             }
 
-            mPos[0] -= (mTranslateDelta * sin(mTheta));
-            mPos[1] -= (mTranslateDelta * sin(mTheta2));
+            mPos[0] -= (mTranslateDelta * sinf(mTheta));
+            mPos[1] -= (mTranslateDelta * sinf(mTheta2));
             break;
         case CAMERA_MOVE_LEFT:
-            mPos[0] -= (mTranslateDelta * sin(mTheta - 90.0f));
-            mPos[2] -= (mTranslateDelta * cos(mTheta - 90.0f));
+            mPos[0] -= (mTranslateDelta * sinf(mTheta - 90.0f));
+            mPos[2] -= (mTranslateDelta * cosf(mTheta - 90.0f));
             break;
         case CAMERA_MOVE_RIGHT:
-            mPos[0] -= (mTranslateDelta * sin(mTheta + 90.0f));
-            mPos[2] -= (mTranslateDelta * cos(mTheta + 90.0f));
+            mPos[0] -= (mTranslateDelta * sinf(mTheta + 90.0f));
+            mPos[2] -= (mTranslateDelta * cosf(mTheta + 90.0f));
             break;
         case CAMERA_ROTATE_UP:
             if (mTheta2 < (M_PI / 2)) {
                 mTheta2 += mRotateDelta2;
-                rotate(mTheta2, 1.0, 0.0, 0.0);
+                rotate(mTheta2, 1.0f, 0.0f, 0.0f);
             }
             break;
         case CAMERA_ROTATE_DOWN:
             if (mTheta2 > -(M_PI / 2)) {
                 mTheta2 -= mRotateDelta2;
-                rotate(mTheta2, 1.0, 0.0, 0.0);
+                rotate(mTheta2, 1.0f, 0.0f, 0.0f);
             }
             break;
         case CAMERA_ROTATE_RIGHT:
             mTheta += mRotateDelta;
-            rotate(mTheta, 0.0, 1.0, 0.0);
+            rotate(mTheta, 0.0f, 1.0f, 0.0f);
             break;
         case CAMERA_ROTATE_LEFT:
             mTheta -= mRotateDelta;
-            rotate(mTheta, 0.0, 1.0, 0.0);
+            rotate(mTheta, 0.0f, 1.0f, 0.0f);
             break;
         case CAMERA_MOVE_UP:
-            mPos[1] -= mTranslateDelta / 2.0;
-            mTarget[1] -= mTranslateDelta / 2.0;
+            mPos[1] -= mTranslateDelta / 2.0f;
+            mTarget[1] -= mTranslateDelta / 2.0f;
             break;
         case CAMERA_MOVE_DOWN:
-            mPos[1] += mTranslateDelta / 2.0;
-            mTarget[1] += mTranslateDelta / 2.0;
+            mPos[1] += mTranslateDelta / 2.0f;
+            mTarget[1] += mTranslateDelta / 2.0f;
             break;
         case CAMERA_SPEED_UP:
             ++mTranslateDelta;
             break;
         case CAMERA_SPEED_DOWN:
-            if (--mTranslateDelta < 0.0)
-                mTranslateDelta = 1.0;
+            if (--mTranslateDelta < 0.0f)
+                mTranslateDelta = 1.0f;
             break;
         default:
             ;
 //! \fixme Mostly invalid for QUAT_CAM (can rotate on XYZ)
 bool Camera::isBehind(int x, int z)
 {
-    double bTheta, bCameraX, bCameraZ, Distance;
+    vec_t bTheta, bCameraX, bCameraZ, Distance;
 
 
     // Set up a "virtual camera" a huge distance behind us
         bTheta -= HEL_2_PI;
 
     // 64k is a fair distance away...
-    bCameraX = (65536.0 * sin(bTheta)) + mPos[0];
-    bCameraZ = (65536.0 * cos(bTheta)) + mPos[2];
+    bCameraX = (65536.0f * sinf(bTheta)) + mPos[0];
+    bCameraZ = (65536.0f * cosf(bTheta)) + mPos[2];
 
     bCameraX -= x;
     bCameraZ -= z;
-    Distance = sqrt((bCameraX * bCameraX) + (bCameraZ * bCameraZ));
+    Distance = sqrtf((bCameraX * bCameraX) + (bCameraZ * bCameraZ));
 
-    return (Distance < 65536.0);
+    return (Distance < 65536.0f);
 }
 
 
 
 void Camera::update()
 {
-    mTarget[2] = (mViewDistance * cos(mTheta)) + mPos[2];
-    mTarget[0] = (mViewDistance * sin(mTheta)) + mPos[0];
-    mTarget[1] = (mViewDistance * sin(mTheta2)) + mPos[1]; // + height_offset;
+    mTarget[2] = (mViewDistance * cosf(mTheta)) + mPos[2];
+    mTarget[0] = (mViewDistance * sinf(mTheta)) + mPos[0];
+    mTarget[1] = (mViewDistance * sinf(mTheta2)) + mPos[1]; // + height_offset;
 }
 
 

src/Emitter.cpp

             // Render tristrip quad
             glBegin(GL_TRIANGLE_STRIP);
             glTexCoord2d(1.0, 1.0);
-            glVertex3f(x + 0.5, y + 0.5, z);
+            glVertex3f(x + 0.5f, y + 0.5f, z);
 
             glTexCoord2d(0.0, 1.0);
-            glVertex3f(x - 0.5, y + 0.5, z);
+            glVertex3f(x - 0.5f, y + 0.5f, z);
 
             glTexCoord2d(1.0, 0.0);
-            glVertex3f(x + 0.5, y - 0.5, z);
+            glVertex3f(x + 0.5f, y - 0.5f, z);
 
             glTexCoord2d(0.0, 0.0);
-            glVertex3f(x - 0.5, y - 0.5, z);
+            glVertex3f(x - 0.5f, y - 0.5f, z);
             glEnd();
 
             // Update particle's attributes for it's life cycle

src/GLString.cpp

     va_end(args);
 
     // Mongoose 2002.01.04, Remeber string size, for future rebuffering use
-    _string[_num_string].len = sz;
+    _string[_num_string].len = (unsigned short)sz;
 
     // Mongoose 2002.01.01, Incement string counter, since we just
     //   allocated a string

src/MatMath.cpp

         // Two intersections
 
         // First intersection
-        mu = (-b + sqrt( square(b) - 4*a*c)) / (2*a);
+        mu = (-b + sqrtf( square(b) - 4.0f*a*c)) / (2.0f*a);
         intersectionA[1] = posA[0] + mu*(posB[0]-posA[0]);
         intersectionA[2] = posA[1] + mu*(posB[1]-posA[1]);
         intersectionA[3] = posA[2] + mu*(posB[2]-posA[2]);
 
         // Second intersection
-        mu = (-b - sqrt(square(b) - 4*a*c)) / (2*a);
+        mu = (-b - sqrtf(square(b) - 4.0f*a*c)) / (2.0f*a);
         intersectionB[0] = posA[0] + mu*(posB[0]-posA[0]);
         intersectionB[1] = posA[1] + mu*(posB[1]-posA[1]);
         intersectionB[2] = posA[2] + mu*(posB[2]-posA[2]);
 
 vec_t helDist3v(vec3_t a, vec3_t b)
 {
-    return (sqrt( ((b[0] - a[0]) * (b[0] - a[0])) +
+    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 helMidpoint3v(vec3_t a, vec3_t b, vec3_t mid)
 {
-    mid[0] = (a[0] + b[0]) / 2;
-    mid[1] = (a[1] + b[1]) / 2;
-    mid[2] = (a[2] + b[2]) / 2;
+    mid[0] = (a[0] + b[0]) / 2.0f;
+    mid[1] = (a[1] + b[1]) / 2.0f;
+    mid[2] = (a[2] + b[2]) / 2.0f;
 }
 
 
 vec_t helNorm4v(vec4_t v)
 {
-    return (sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2] + v[3]*v[3]));
+    return (sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2] + v[3]*v[3]));
 }
 
 
 vec_t helNorm3v(vec3_t v)
 {
-    return (sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]));
+    return (sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]));
 }
 
 
 vec_t helNorm2v(vec2_t v)
 {
-    return (sqrt(v[0]*v[0] + v[1]*v[1]));
+    return (sqrtf(v[0]*v[0] + v[1]*v[1]));
 }
 
 
 vec_t helRandomNum(vec_t from, vec_t to)
 {
-    return from + ((to - from) * rand() / (RAND_MAX + 1.0));
+    return from + ((to - from) * rand() / (RAND_MAX + 1.0f));
 }
 

src/Matrix.cpp

     result[2] = mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11];
 }
 
-void Matrix::multiply4d(double *v, double *result)
-{
-    double x = v[0], y = v[1], z = v[2], w = v[3];
-
-    result[0] = mMatrix[ 0]*x + mMatrix[ 1]*y + mMatrix[ 2]*z + mMatrix[ 3]*w;
-    result[1] = mMatrix[ 4]*x + mMatrix[ 5]*y + mMatrix[ 6]*z + mMatrix[ 7]*w;
-    result[2] = mMatrix[ 8]*x + mMatrix[ 9]*y + mMatrix[10]*z + mMatrix[11]*w;
-    result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
-}
-
 void Matrix::multiply4v(vec4_t v, vec4_t result)
 {
     vec_t x = v[0], y = v[1], z = v[2], w = v[3];

src/Network.cpp

 #include <arpa/inet.h>
 #include <stdlib.h>
 
+#include <MatMath.h> // Random Number
+
 //#define LOCAL_BCAST
 #define MAX_CLIENTS 32
 
 
     srand(tv.tv_usec);
 
-    return ((unsigned int)(tv.tv_sec * getRandom(2.0, 3.3) -
-                tv.tv_sec * getRandom(1.0, 2.0)) +
-            (unsigned int)(tv.tv_usec * getRandom(2.0, 3.3) -
-                tv.tv_usec * getRandom(1.0, 2.0)) +
-            (unsigned int)getRandom(666.0, 5000.0));
-}
-
-
-float Network::getRandom(float from, float to)
-{
-    return from + (to*rand()/(RAND_MAX+1.0));
+    return ((unsigned int)(tv.tv_sec * helRandomNum(2.0f, 3.3f) -
+                tv.tv_sec * helRandomNum(1.0f, 2.0f)) +
+            (unsigned int)(tv.tv_usec * helRandomNum(2.0f, 3.3f) -
+                tv.tv_usec * helRandomNum(1.0f, 2.0f)) +
+            (unsigned int)helRandomNum(666.0f, 5000.0f));
 }
 
 

src/Texture.cpp

 
     for (i = 0; i < count; ++i)
     {
-        glyph = TTF_RenderGlyph_Blended(font, i + utf8Offset, sdlColor);
+        glyph = TTF_RenderGlyph_Blended(font, (Uint16)(i + utf8Offset), sdlColor);
 
         if (glyph)
         {
             image = (unsigned char*)glyph->pixels;
 
-            TTF_GlyphMetrics(font, i + utf8Offset,
+            TTF_GlyphMetrics(font, (Uint16)(i + utf8Offset),
                     &texture->glyphs[i].minx, &texture->glyphs[i].maxx,
                     &texture->glyphs[i].miny, &texture->glyphs[i].maxy,
                     &texture->glyphs[i].advance);
 
     delete [] swap_row;
 
-    comment_lenght = strlen(comment);
+    comment_lenght = (unsigned char)strlen(comment);
     colormap_type = 0;
     image_type = 2;
     colormap_index = 0;
     colormap_lenght = 0;
     colormap_bbp = 0;
     origin_x = origin_y = 0;
-    swidth = width;
-    sheight = height;
+    swidth = (unsigned short)width;
+    sheight = (unsigned short)height;
     bpp = 24;
     desc_flags = 32;
 
 
                 for (k = 0; k < components; ++k)
                 {
-                    s1 = *src00++ * (1.0 - beta) + *src01++ * beta;
-                    s2 = *src10++ * (1.0 - beta) + *src11++ * beta;
-                    *dst++ = s1 * (1.0 - alpha) + s2 * alpha;
+                    s1 = *src00++ * (1.0f - beta) + *src01++ * beta;
+                    s2 = *src10++ * (1.0f - beta) + *src11++ * beta;
+                    *dst++ = s1 * (1.0f - alpha) + s2 * alpha;
                 }
             }
         }