Turned conversion warnings on

Makefile

 WARNINGS+=-Wno-disabled-macro-expansion -Wno-missing-variable-declarations
 WARNINGS+=-Wno-missing-prototypes -Wno-pedantic
 
-WARNINGS+=-Wno-conversion -Wno-sign-conversion -Wno-shorten-64-to-32
+WARNINGS+=-Wno-shorten-64-to-32 -Wno-sign-conversion
 
 FLAGS_ALL=-std=c++11
 

src/Particle.cpp

 {
     setActive(true);
     TextureId(0);
-    Speed(2000.0, 2000.0, 2000.0);
-    Color(1.0, 1.0, 1.0);
-    Force(0.0, 0.8, 0.0);
+    Speed(2000.0f, 2000.0f, 2000.0f);
+    Color(1.0f, 1.0f, 1.0f);
+    Force(0.0f, 0.8f, 0.0f);
 
     Reset();
 }

src/Quaternion.cpp

 
     m[ 8] = 2.0f * (mX*mZ - mW*mY);
     m[ 9] = 2.0f * (mY*mZ + mW*mX);
-    m[10] = 1.0 - 2.0f * (mX*mX + mY*mY);
+    m[10] = 1.0f - 2.0f * (mX*mX + mY*mY);
     m[11] = 0.0f;
 
     m[12] = 0.0f;
 
 vec_t Quaternion::magnitude()
 {
-    return sqrt(dot(*this, *this));
+    return sqrtf(dot(*this, *this));
 }
 
 

src/SDLSystem.cpp

     // gluPerspective is deprecated!
     // gluPerspective(m_fovY, aspect, m_clipNear, m_clipFar);
     // fix: http://stackoverflow.com/a/2417756
-    GLfloat fH = tan(float(m_fovY / 360.0f * 3.14159f) ) * m_clipNear;
+    GLfloat fH = tanf(m_fovY / 360.0f * 3.14159f) * m_clipNear;
     GLfloat fW = fH * aspect;
     glFrustum(-fW, fW, -fH, fH, m_clipNear, m_clipFar);
 

src/Sound.cpp

         return -3;
     }
 
-    alBufferData(mBuffer[mNextBuffer], format, data, size, freq);
+    alBufferData(mBuffer[mNextBuffer], format, data, size, static_cast<ALsizei>(freq));
 
     alSourcei(mSource[mNextSource], AL_BUFFER, mBuffer[mNextBuffer]);
 
     }
 
 
-    alBufferData(mBuffer[mNextBuffer], format, data, size, freq);
+    alBufferData(mBuffer[mNextBuffer], format, data, size, static_cast<ALsizei>(freq));
 
     alSourcei(mSource[mNextSource], AL_BUFFER, mBuffer[mNextBuffer]);
 

src/System.cpp

     // gluPerspective is deprecated!
     // gluPerspective(m_fovY, ((GLdouble)w)/((GLdouble)h), m_clipNear, m_clipFar);
     // Fix: http://stackoverflow.com/a/2417756
-    GLfloat fH = tan(float(m_fovY / 360.0f * 3.14159f)) * m_clipNear;
-    GLfloat fW = fH * ((GLdouble)w)/((GLdouble)h);
+    GLfloat fH = tanf(m_fovY / 360.0f * 3.14159f) * m_clipNear;
+    GLfloat fW = fH * ((GLfloat)w)/((GLfloat)h);
     glFrustum(-fW, fW, -fH, fH, m_clipNear, m_clipFar);
 
     glMatrixMode(GL_MODELVIEW);

src/Vector3d.cpp

 
 vec_t Vector3d::magnitude()
 {
-    return sqrt(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
+    return sqrtf(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
 }
 
 

src/ViewVolume.cpp

     mFrustum[0][3] = clip[15] - clip[12];
 
     /* Normalize the result */
-    t = sqrt(mFrustum[0][0] * mFrustum[0][0] +
+    t = sqrtf(mFrustum[0][0] * mFrustum[0][0] +
             mFrustum[0][1] * mFrustum[0][1] +
             mFrustum[0][2] * mFrustum[0][2]);
     mFrustum[0][0] /= t;
     mFrustum[1][3] = clip[15] + clip[12];
 
     /* Normalize the result */
-    t = sqrt(mFrustum[1][0] * mFrustum[1][0] +
+    t = sqrtf(mFrustum[1][0] * mFrustum[1][0] +
             mFrustum[1][1] * mFrustum[1][1] +
             mFrustum[1][2] * mFrustum[1][2]);
     mFrustum[1][0] /= t;
     mFrustum[2][3] = clip[15] + clip[13];
 
     /* Normalize the result */
-    t = sqrt(mFrustum[2][0] * mFrustum[2][0] +
+    t = sqrtf(mFrustum[2][0] * mFrustum[2][0] +
             mFrustum[2][1] * mFrustum[2][1] +
             mFrustum[2][2] * mFrustum[2][2]);
     mFrustum[2][0] /= t;
     mFrustum[3][3] = clip[15] - clip[13];
 
     /* Normalize the result */
-    t = sqrt(mFrustum[3][0] * mFrustum[3][0] +
+    t = sqrtf(mFrustum[3][0] * mFrustum[3][0] +
             mFrustum[3][1] * mFrustum[3][1] +
             mFrustum[3][2] * mFrustum[3][2]);
     mFrustum[3][0] /= t;
     mFrustum[4][3] = clip[15] - clip[14];
 
     /* Normalize the result */
-    t = sqrt(mFrustum[4][0] * mFrustum[4][0] +
+    t = sqrtf(mFrustum[4][0] * mFrustum[4][0] +
             mFrustum[4][1] * mFrustum[4][1] +
             mFrustum[4][2] * mFrustum[4][2]);
     mFrustum[4][0] /= t;
     mFrustum[5][3] = clip[15] + clip[14];
 
     /* Normalize the result */
-    t = sqrt(mFrustum[5][0] * mFrustum[5][0] +
+    t = sqrtf(mFrustum[5][0] * mFrustum[5][0] +
             mFrustum[5][1] * mFrustum[5][1] +
             mFrustum[5][2] * mFrustum[5][2]);
     mFrustum[5][0] /= t;

src/World.cpp

     switch (movement)
     {
         case 'f':
-            x = e->pos[0] + (testd * sin(e->angles[1]));
-            y = e->pos[1] + (testd * sin(pitch));
-            z = e->pos[2] + (testd * cos(e->angles[1]));
+            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 * sin(e->angles[1]));
-            y = e->pos[1] - (testd * sin(pitch));
-            z = e->pos[2] - (testd * cos(e->angles[1]));
+            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 * sin(e->angles[1] + 90.0));
+            x = e->pos[0] - (testd * sinf(e->angles[1] + 90.0f));
             y = e->pos[1];
-            z = e->pos[2] - (testd * cos(e->angles[1] + 90.0));
+            z = e->pos[2] - (testd * cosf(e->angles[1] + 90.0f));
             break;
         case 'r':
-            x = e->pos[0] + (testd * sin(e->angles[1] + 90.0));
+            x = e->pos[0] + (testd * sinf(e->angles[1] + 90.0f));
             y = e->pos[1];
-            z = e->pos[2] + (testd * cos(e->angles[1] + 90.0));
+            z = e->pos[2] + (testd * cosf(e->angles[1] + 90.0f));
             break;
         default:
             return;
         switch (movement)
         {
             case 'f':
-                x = e->pos[0] + (moved * sin(e->angles[1]));
-                y = e->pos[1] + (moved * sin(pitch));
-                z = e->pos[2] + (moved * cos(e->angles[1]));
+                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 * sin(e->angles[1]));
-                y = e->pos[1] - (moved * sin(pitch));
-                z = e->pos[2] - (moved * cos(e->angles[1]));
+                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 * sin(e->angles[1] + 90.0));
-                z = e->pos[2] - (moved * cos(e->angles[1] + 90.0));
+                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 * sin(e->angles[1] + 90.0));
-                z = e->pos[2] + (moved * cos(e->angles[1] + 90.0));
+                x = e->pos[0] + (moved * sinf(e->angles[1] + 90.0f));
+                z = e->pos[2] + (moved * cosf(e->angles[1] + 90.0f));
                 break;
         }
 

src/tga.cpp

     strncpy(comment, "OpenRaider TGA", 63);
     comment[63] = 0;
 
-    header.comment_lenght = strlen(comment);
+    header.comment_lenght = (unsigned char)strlen(comment);
     header.colormap_type = 0;
 
     // No colormaps
     header.colormap_bbp = 0;
 
     header.origin_x = header.origin_y = 0;
-    header.width = width;
-    header.height = height;
+    header.width = (unsigned short)width;
+    header.height = (unsigned short)height;
 
     header.desc_flags = 0;