No more conversion warnings

src/Matrix.cpp

 
     r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
         r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
-        r0[4] = 1.0, r0[5] = r0[6] = r0[7] = 0.0,
+        r0[4] = 1.0f, r0[5] = r0[6] = r0[7] = 0.0f,
 
         r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
         r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
-        r1[5] = 1.0, r1[4] = r1[6] = r1[7] = 0.0,
+        r1[5] = 1.0f, r1[4] = r1[6] = r1[7] = 0.0f,
 
         r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
         r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
-        r2[6] = 1.0, r2[4] = r2[5] = r2[7] = 0.0,
+        r2[6] = 1.0f, r2[4] = r2[5] = r2[7] = 0.0f,
 
         r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
         r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
-        r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
+        r3[7] = 1.0f, r3[4] = r3[5] = r3[6] = 0.0f;
 
     /* choose pivot - or die */
     if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
     if (fabs(r2[0])>fabs(r1[0])) SWAP_ROWS(r2, r1);
     if (fabs(r1[0])>fabs(r0[0])) SWAP_ROWS(r1, r0);
-    if (0.0 == r0[0])  return false;
+    if (0.0f == r0[0])  return false;
 
     /* eliminate first variable     */
     m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
     s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
     s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
     s = r0[4];
-    if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
+    if (s != 0.0f) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
     s = r0[5];
-    if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
+    if (s != 0.0f) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
     s = r0[6];
-    if (s != 0.0) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
+    if (s != 0.0f) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
     s = r0[7];
-    if (s != 0.0) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
+    if (s != 0.0f) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
 
     /* choose pivot - or die */
     if (fabs(r3[1])>fabs(r2[1])) SWAP_ROWS(r3, r2);
     if (fabs(r2[1])>fabs(r1[1])) SWAP_ROWS(r2, r1);
-    if (0.0 == r1[1])  return false;
+    if (0.0f == r1[1])  return false;
 
     /* eliminate second variable */
     m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
     r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
     r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
-    s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
-    s = r1[5]; if (0.0 != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
-    s = r1[6]; if (0.0 != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
-    s = r1[7]; if (0.0 != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
+    s = r1[4]; if (0.0f != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
+    s = r1[5]; if (0.0f != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
+    s = r1[6]; if (0.0f != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
+    s = r1[7]; if (0.0f != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
 
     /* choose pivot - or die */
     if (fabs(r3[2])>fabs(r2[2])) SWAP_ROWS(r3, r2);
-    if (0.0 == r2[2])  return false;
+    if (0.0f == r2[2])  return false;
 
     /* eliminate third variable */
     m3 = r3[2]/r2[2];
         r3[7] -= m3 * r2[7];
 
     /* last check */
-    if (0.0 == r3[3]) return false;
+    if (0.0f == r3[3]) return false;
 
-    s = 1.0/r3[3];              /* now back substitute row 3 */
+    s = 1.0f/r3[3];              /* now back substitute row 3 */
     r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
 
     m2 = r2[3];                 /* now back substitute row 2 */
-    s  = 1.0/r2[2];
+    s  = 1.0f/r2[2];
     r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
         r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
     m1 = r1[3];
         r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
 
     m1 = r1[2];                 /* now back substitute row 1 */
-    s  = 1.0/r1[1];
+    s  = 1.0f/r1[1];
     r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
         r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
     m0 = r0[2];
         r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
 
     m0 = r0[1];                 /* now back substitute row 0 */
-    s  = 1.0/r0[0];
+    s  = 1.0f/r0[0];
     r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
         r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
 
     matrix_t xmat, ymat, zmat, tmp, tmp2;
 
     xmat[ 0]=1;        xmat[ 1]=0;        xmat[ 2]=0;        xmat[ 3]=0;
-    xmat[ 4]=0;        xmat[ 5]=cos(ax);  xmat[ 6]=sin(ax);  xmat[ 7]=0;
-    xmat[ 8]=0;        xmat[ 9]=-sin(ax); xmat[10]=cos(ax);  xmat[11]=0;
+    xmat[ 4]=0;        xmat[ 5]=cosf(ax);  xmat[ 6]=sinf(ax);  xmat[ 7]=0;
+    xmat[ 8]=0;        xmat[ 9]=-sinf(ax); xmat[10]=cosf(ax);  xmat[11]=0;
     xmat[12]=0;        xmat[13]=0;        xmat[14]=0;        xmat[15]=1;
 
-    ymat[ 0]=cos(ay);  ymat[ 1]=0;        ymat[ 2]=-sin(ay); ymat[ 3]=0;
+    ymat[ 0]=cosf(ay);  ymat[ 1]=0;        ymat[ 2]=-sinf(ay); ymat[ 3]=0;
     ymat[ 4]=0;        ymat[ 5]=1;        ymat[ 6]=0;        ymat[ 7]=0;
-    ymat[ 8]=sin(ay);  ymat[ 9]=0;        ymat[10]=cos(ay);  ymat[11]=0;
+    ymat[ 8]=sinf(ay);  ymat[ 9]=0;        ymat[10]=cosf(ay);  ymat[11]=0;
     ymat[12]=0;        ymat[13]=0;        ymat[14]=0;        ymat[15]=1;
 
-    zmat[ 0]=cos(az);  zmat[ 1]=sin(az);  zmat[ 2]=0;        zmat[ 3]=0;
-    zmat[ 4]=-sin(az); zmat[ 5]=cos(az);  zmat[ 6]=0;        zmat[ 7]=0;
+    zmat[ 0]=cosf(az);  zmat[ 1]=sinf(az);  zmat[ 2]=0;        zmat[ 3]=0;
+    zmat[ 4]=-sinf(az); zmat[ 5]=cosf(az);  zmat[ 6]=0;        zmat[ 7]=0;
     zmat[ 8]=0;        zmat[ 9]=0;        zmat[10]=1;        zmat[11]=0;
     zmat[12]=0;        zmat[13]=0;        zmat[14]=0;        zmat[15]=1;
 

src/OpenRaider.cpp

             case '\r':
             case '\n':
                 strncpy(lastCmd, buffer, 63);
-                lastCmd[0] = i;
+                lastCmd[0] = (char)i;
 
                 command("[OpenRaider.Console]");
                 command(buffer);
                 if (mod & (SYS_MOD_KEY_RSHIFT | SYS_MOD_KEY_LSHIFT) &&
                         key > 96 && key < 122)
                 {
-                    buffer[i++] = (key - 32);
+                    buffer[i++] = (char)(key - 32);
                 }
                 else
                 {
                             key = '_';
                     }
 
-                    buffer[i++] = key;
+                    buffer[i++] = (char)key;
                 }
 
                 buffer[i] = 0;
                     r_mesh->sprite[l].pos[2] = item[i].z;
                     r_mesh->sprite[l].texture = sprite->tile + m_texOffset;
 
-                    r_mesh->sprite[l].radius = width2 / 2.0;
+                    r_mesh->sprite[l].radius = width2 / 2.0f;
 
-                    r_mesh->sprite[l].vertex[0].pos[0] = -width2 / 2.0;
-                    r_mesh->sprite[l].vertex[1].pos[0] = -width2 / 2.0;
-                    r_mesh->sprite[l].vertex[2].pos[0] = width2 / 2.0;
-                    r_mesh->sprite[l].vertex[3].pos[0] = width2 / 2.0;
+                    r_mesh->sprite[l].vertex[0].pos[0] = -width2 / 2.0f;
+                    r_mesh->sprite[l].vertex[1].pos[0] = -width2 / 2.0f;
+                    r_mesh->sprite[l].vertex[2].pos[0] = width2 / 2.0f;
+                    r_mesh->sprite[l].vertex[3].pos[0] = width2 / 2.0f;
 
                     r_mesh->sprite[l].vertex[0].pos[1] = 0;
                     r_mesh->sprite[l].vertex[1].pos[1] = -height2;
                     r_mesh->sprite[l].vertex[2].pos[2] = 0;
                     r_mesh->sprite[l].vertex[3].pos[2] = 0;
 
-                    r_mesh->sprite[l].texel[3].st[0] = (double)(x+width)/TexelScale;
-                    r_mesh->sprite[l].texel[3].st[1] = (double)(y+height)/TexelScale;
+                    r_mesh->sprite[l].texel[3].st[0] = (vec_t)(x+width)/TexelScale;
+                    r_mesh->sprite[l].texel[3].st[1] = (vec_t)(y+height)/TexelScale;
 
-                    r_mesh->sprite[l].texel[2].st[0] = (double)(x+width)/TexelScale;
-                    r_mesh->sprite[l].texel[2].st[1] = (double)(y)/TexelScale;
+                    r_mesh->sprite[l].texel[2].st[0] = (vec_t)(x+width)/TexelScale;
+                    r_mesh->sprite[l].texel[2].st[1] = (vec_t)(y)/TexelScale;
 
-                    r_mesh->sprite[l].texel[1].st[0] = (double)(x) /TexelScale;
-                    r_mesh->sprite[l].texel[1].st[1] = (double)(y) /TexelScale;
+                    r_mesh->sprite[l].texel[1].st[0] = (vec_t)(x) /TexelScale;
+                    r_mesh->sprite[l].texel[1].st[1] = (vec_t)(y) /TexelScale;
 
-                    r_mesh->sprite[l].texel[0].st[0] = (double)(x) / TexelScale;
-                    r_mesh->sprite[l].texel[0].st[1] = (double)(y+height)/TexelScale;
+                    r_mesh->sprite[l].texel[0].st[0] = (vec_t)(x) / TexelScale;
+                    r_mesh->sprite[l].texel[0].st[1] = (vec_t)(y+height)/TexelScale;
 
                     printf(".");
                     fflush(stdout);
                     tag->off[0] = mesh_tree->x;
                     tag->off[1] = mesh_tree->y;
                     tag->off[2] = mesh_tree->z;
-                    tag->flag = mesh_tree->flags;
+                    tag->flag = (char)mesh_tree->flags;
                 }
 
                 // Setup tag rotations
     }
     else if (rc_command("sensitivity.x", cmd))
     {
-        m_mouseX = atof(cmd);
+        m_mouseX = static_cast<float>(atof(cmd));
     }
     else if (rc_command("sensitivity.y", cmd))
     {
-        m_mouseY = atof(cmd);
+        m_mouseY = static_cast<float>(atof(cmd));
     }
     else if (rc_command("r_pigtails", cmd))
     {
         case 3: // [Input.Mouse]
             if (rc_command("SensitivityX", cmd))
             {
-                m_mouseX = atof(cmd);
+                m_mouseX = static_cast<float>(atof(cmd));
             }
             else if (rc_command("SensitivityY", cmd))
             {
-                m_mouseY = atof(cmd);
+                m_mouseY = static_cast<float>(atof(cmd));
             }
             else
             {

src/Render.cpp

 extern World gWorld;
 
 // Colors
-const float BLACK[]        = {  0.0,  0.0,  0.0, 1.0 };
-const float DIM_WHITE[]    = {  0.5,  0.5,  0.5, 1.0 };
-const float WHITE[]        = {  1.0,  1.0,  1.0, 1.0 };
-const float RED[]          = {  1.0,  0.0,  0.0, 1.0 };
-const float GREEN[]        = {  0.0,  1.0,  0.0, 1.0 };
-const float NEXT_PURPLE[]  = {  0.3,  0.3,  0.5, 1.0 };
-const float OR_BLUE[]      = {  0.5,  0.7,  1.0, 1.0 };
-const float PINK[]         = {  1.0,  0.0,  1.0, 1.0 };
-const float YELLOW[]       = {  1.0,  1.0,  0.0, 1.0 };
-const float CYAN[]         = {  0.0,  1.0,  1.0, 1.0 };
+const float BLACK[]        = {  0.0f,  0.0f,  0.0f, 1.0f };
+const float DIM_WHITE[]    = {  0.5f,  0.5f,  0.5f, 1.0f };
+const float WHITE[]        = {  1.0f,  1.0f,  1.0f, 1.0f };
+const float RED[]          = {  1.0f,  0.0f,  0.0f, 1.0f };
+const float GREEN[]        = {  0.0f,  1.0f,  0.0f, 1.0f };
+const float NEXT_PURPLE[]  = {  0.3f,  0.3f,  0.5f, 1.0f };
+const float OR_BLUE[]      = {  0.5f,  0.7f,  1.0f, 1.0f };
+const float PINK[]         = {  1.0f,  0.0f,  1.0f, 1.0f };
+const float YELLOW[]       = {  1.0f,  1.0f,  0.0f, 1.0f };
+const float CYAN[]         = {  0.0f,  1.0f,  1.0f, 1.0f };
 
 ViewVolume gViewVolume; /* View volume for frustum culling */
 
 {
     const float widthStart = 10.0f; //5.0f;
     const float widthEnd = 10.0f;
-    float delta = 0.01 + (0.15*rand()/(RAND_MAX+1.0)); // for flicker fx
+    float delta = helRandomNum(0.01f, 0.16f); // for flicker fx
 
 
     // Draw two long quads that skrink and fade the they go further out
     switch (color)
     {
         case 0:
-            glColor3f(0.9 - delta, 0.2, 0.2);
+            glColor3f(0.9f - delta, 0.2f, 0.2f);
             break;
         case 1:
-            glColor3f(0.2, 0.9 - delta, 0.2);
+            glColor3f(0.2f, 0.9f - delta, 0.2f);
             break;
         case 2:
         default:
-            glColor3f(0.2, 0.2, 0.9 - delta);
+            glColor3f(0.2f, 0.2f, 0.9f - delta);
     }
 
     glVertex3f(start[0], start[1], start[2]);
     {
         glEnable(GL_FOG);
         glFogf(GL_FOG_MODE, GL_EXP2);
-        glFogf(GL_FOG_DENSITY, 0.00008);
-        glFogf(GL_FOG_START, 30000.0);
-        glFogf(GL_FOG_END, 50000.0);
+        glFogf(GL_FOG_DENSITY, 0.00008f);
+        glFogf(GL_FOG_START, 30000.0f);
+        glFogf(GL_FOG_END, 50000.0f);
         glFogfv(GL_FOG_COLOR, BLACK);
     }
 
     f[1] = lookAtY - eyeY;
     f[2] = lookAtZ - eyeZ;
     float fMag, upMag;
-    fMag = sqrt(f[0]*f[0] + f[1]*f[1] + f[2]*f[2]);
-    upMag = sqrt(upX*upX + upY*upY + upZ*upZ);
+    fMag = sqrtf(f[0]*f[0] + f[1]*f[1] + f[2]*f[2]);
+    upMag = sqrtf(upX*upX + upY*upY + upZ*upZ);
     // normalizing the viewing vector
     f[0] = f[0]/fMag;
     f[1] = f[1]/fMag;
         camPos[1] = curPos[1] - camOffsetH; // UP is lower val
         camPos[2] = curPos[2];
 
-        camPos[0] -= (1024.0 * sin(yaw));
-        camPos[2] -= (1024.0 * cos(yaw));
+        camPos[0] -= (1024.0f * sinf(yaw));
+        camPos[2] -= (1024.0f * cosf(yaw));
 
         sector = gWorld.getSector(index, camPos[0], camPos[2]);
 
         // Handle camera out of world
         if (sector < 0 || gWorld.isWall(index, sector))
         {
-            camPos[0] = curPos[0] + (64.0 * sin(yaw));
-            camPos[1] -= 64.0;
-            camPos[2] = curPos[2] + (64.0 * cos(yaw));
+            camPos[0] = curPos[0] + (64.0f * sinf(yaw));
+            camPos[1] -= 64.0f;
+            camPos[2] = curPos[2] + (64.0f * cosf(yaw));
         }
 
         mCamera->setPosition(camPos);
     // 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.0, -1.0, 0.0);
 
-    deprecated_gluLookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0, -1.0, 0.0);
+    deprecated_gluLookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0f, -1.0f, 0.0f);
 
     // Update view volume for vising
     updateViewVolume();
 
             // Center of LARA
             u[0] = curPos[0];
-            u[1] = curPos[1] - 512.0;
+            u[1] = curPos[1] - 512.0f;
             u[2] = curPos[2];
 
             // Location LARA is aiming at?  ( Not finished yet )
-            v[0] = u[0] + (9000.0 * sin(LARA->angles[1]));
-            v[1] = u[1] + (9000.0 * sin(LARA->angles[2]));
-            v[2] = u[2] + (9000.0 * cos(LARA->angles[1]));
+            v[0] = u[0] + (9000.0f * sinf(LARA->angles[1]));
+            v[1] = u[1] + (9000.0f * sinf(LARA->angles[2]));
+            v[2] = u[2] + (9000.0f * cosf(LARA->angles[1]));
 
             //mtkVectorSubtract(u, v, t);
             //mtkVectorSubtract(u, curPos, s);
         glDisable(GL_LIGHTING);
 
     // Mongoose 2002.01.01, Draw logo/load screen
-    glTranslatef(0.0, 0.0, -2000.0);
-    glRotatef(180.0, 1.0, 0.0, 0.0);
+    glTranslatef(0.0f, 0.0f, -2000.0f);
+    glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
 
     // Mongoose 2002.03.26, Account for particle system not using new binds
     //   by not using them here either
         mTexture.bindMultiTexture(1, 3);
 
         glBegin(GL_TRIANGLE_STRIP);
-        mTexture.useMultiTexture(1.0, 1.0, 0.5 - wrap, 1.0);
+        mTexture.useMultiTexture(1.0f, 1.0f, 0.5f - wrap, 1.0f);
         glColor3fv(WHITE);
         glVertex3f(x + w, y + h, z);
-        mTexture.useMultiTexture(0.0, 1.0, 0.0 - wrap, 1.0);
+        mTexture.useMultiTexture(0.0f, 1.0f, 0.0f - wrap, 1.0f);
         glColor3fv(WHITE);
         glVertex3f(x - w, y + h, z);
-        mTexture.useMultiTexture(1.0, 0.0, 0.5 - wrap, 0.5);
+        mTexture.useMultiTexture(1.0f, 0.0f, 0.5f - wrap, 0.5f);
         glColor3fv(WHITE);
         glVertex3f(x + w, y - h, z);
-        mTexture.useMultiTexture(0.0, 0.0, 0.0 - wrap, 0.5);
+        mTexture.useMultiTexture(0.0f, 0.0f, 0.0f - wrap, 0.5f);
         glColor3fv(WHITE);
         glVertex3f(x - w, y - h, z);
         glEnd();
         // The Loading Screen sat around for 25s, doing nothing.
         // Incrementing wrap by a much bigger number speeds up the animation
         // thus greatly reducing startup time?! -- xythobuz
-        wrap += 0.05;
+        wrap += 0.075f;
 
         if (wrap > 1.121096f)
             mTexture.disableMultiTexture();
 
         if (boneframe->tag.getCurrentIndex() == 0)
         {
-            if (tag->rot[1])
+            if (!equalEpsilon(tag->rot[1], 0.0f)) // was just if (tag->rot[1])
                 glRotatef(tag->rot[1], 0, 1, 0);
 
-            if (tag->rot[0])
+            if (!equalEpsilon(tag->rot[0], 0.0f))
                 glRotatef(tag->rot[0], 1, 0, 0);
 
-            if (tag->rot[2])
+            if (!equalEpsilon(tag->rot[2], 0.0f))
                 glRotatef(tag->rot[2], 0, 0, 1);
         }
         else
 
             glTranslatef(tag->off[0], tag->off[1], tag->off[2]);
 
-            if (tag->rot[1])
+            if (!equalEpsilon(tag->rot[1], 0.0f))
                 glRotatef(tag->rot[1], 0, 1, 0);
 
-            if (tag->rot[0])
+            if (!equalEpsilon(tag->rot[0], 0.0f))
                 glRotatef(tag->rot[0], 1, 0, 0);
 
-            if (tag->rot[2])
+            if (!equalEpsilon(tag->rot[2], 0.0f))
                 glRotatef(tag->rot[2], 0, 0, 1);
         }
 
                 //   since no vertex welds are implemented yet
                 if (mdl->tr4Overlay == 1)
                 {
-                    glScalef(1.20, 1.20, 1.20);
+                    glScalef(1.20f, 1.20f, 1.20f);
                 }
 
 #ifdef EXPERIMENTAL_NON_ITEM_RENDER
 
                     if (i > 0)
                     {
-                        glRotatef(helRandomNum(-8.0, -10.0), 1, 0, 0);
-                        glRotatef(helRandomNum(-5.0, 5.0), 0, 1, 0);
-                        glRotatef(helRandomNum(-5.0, 5.0), 0, 0, 1);
+                        glRotatef(helRandomNum(-8.0f, -10.0f), 1, 0, 0);
+                        glRotatef(helRandomNum(-5.0f, 5.0f), 0, 1, 0);
+                        glRotatef(helRandomNum(-5.0f, 5.0f), 0, 0, 1);
 
                         glTranslatef(0.0, 0.0, mdl->ponyOff);
                     }

src/TombRaider.cpp

             for (j = 0; j < (int)_num_animations; ++j)
             {
                 int fo = _animations[j].frame_offset / 2;
-                _animations[j].frame_size = (_frames[fo + 9] * 2) + 10;
+                _animations[j].frame_size = (unsigned char)(_frames[fo + 9] * 2) + 10;
             }
 
             for (i = 0; i < (int)_num_frames; )
 
             for (j = 0; j < _num_boxes; ++j)
             {
-                _boxes[j].zmin = tr1box[j].zmin / 1024;
-                _boxes[j].zmax = tr1box[j].zmax / 1024;
-                _boxes[j].xmin = tr1box[j].xmin / 1024;
-                _boxes[j].xmax = tr1box[j].xmax / 1024;
+                _boxes[j].zmin = (unsigned char)(tr1box[j].zmin / 1024);
+                _boxes[j].zmax = (unsigned char)(tr1box[j].zmax / 1024);
+                _boxes[j].xmin = (unsigned char)(tr1box[j].xmin / 1024);
+                _boxes[j].xmax = (unsigned char)(tr1box[j].xmax / 1024);
                 _boxes[j].true_floor = tr1box[j].true_floor;
                 _boxes[j].overlap_index = tr1box[j].overlap_index;
             }
             {
                 colour_tmp = _palette8[_textile8[i].tile[j]].r & 0x3f;
                 colour_tmp = colour_tmp * 31.0 / 63.0;
-                argb = ((int)colour_tmp) << 10;
+                argb = (unsigned short)(((int)colour_tmp) << 10);
                 colour_tmp = _palette8[_textile8[i].tile[j]].g & 0x3f;
                 colour_tmp = colour_tmp * 31.0 / 63.0;
-                argb |= ((int)colour_tmp) << 5;
+                argb |= (unsigned short)(((int)colour_tmp) << 5);
                 colour_tmp = _palette8[_textile8[i].tile[j]].b & 0x3f;
                 colour_tmp = colour_tmp * 31.0 / 63.0;
-                argb |= ((int)colour_tmp);
-                argb &= 0x7fff;   // ???
+                argb |= (unsigned short)((int)colour_tmp);
+                argb &= 0x7fff; // ???
 
                 if (_textile8[i].tile[j] != 0)
                     argb |= 0x8000;
     else
         texel--;
 
-    return ((float)texel / 255.0);
+    return ((float)texel / 255.0f);
 }
 
 
         float *x, float *y, float *z)
 {
     unsigned short itmp, itmp2;
-    double angle;
+    float angle;
 
 
     itmp = (*frame)[(*frame_offset) + (*angle_offset)++];
     //x += ((char)st->xcoordinate >= 0) ? 1 : -1;
     //y += ((char)st->ycoordinate >= 0) ? 1 : -1;
 
-    *u = (float)x / 255.0;
-    *v = (float)y / 255.0;
+    *u = (float)x / 255.0f;
+    *v = (float)y / 255.0f;
 }
 
 
     switch (getEngine())
     {
         case TR_VERSION_1:
-            color[0] = _palette8[index].r / 64.0;
-            color[1] = _palette8[index].g / 64.0;
-            color[2] = _palette8[index].b / 64.0;
-            //color[0] = (_palette8[index].r & 0xfd) / 64.0;
-            //color[1] = (_palette8[index].g & 0xfd) / 64.0;
-            //color[2] = (_palette8[index].b & 0xfd) / 64.0;
+            color[0] = _palette8[index].r / 64.0f;
+            color[1] = _palette8[index].g / 64.0f;
+            color[2] = _palette8[index].b / 64.0f;
+            //color[0] = (_palette8[index].r & 0xfd) / 64.0f;
+            //color[1] = (_palette8[index].g & 0xfd) / 64.0f;
+            //color[2] = (_palette8[index].b & 0xfd) / 64.0f;
             color[3] = 1.0;
             break;
         case TR_VERSION_2:
         case TR_VERSION_5:
         case TR_VERSION_UNKNOWN:
         default:
-            color[0] = (float)(_palette16[index] & 0xff) / 256.0;
-            color[1] = (float)((_palette16[index] >> 8) & 0xff) / 256.0;
-            color[2] = (float)((_palette16[index] >> 16) & 0xff) / 256.0;
+            color[0] = (float)(_palette16[index] & 0xff) / 256.0f;
+            color[1] = (float)((_palette16[index] >> 8) & 0xff) / 256.0f;
+            color[2] = (float)((_palette16[index] >> 16) & 0xff) / 256.0f;
             color[3] = 1.0;
     }
 }
                 case TR_VERSION_5:
                 case TR_VERSION_UNKNOWN:
                 default:
-                    colorValue = (1.0 - (colorValue / 8192.0));
+                    colorValue = (1.0f - (colorValue / 8192.0f));
                     break;
             }
 
         case TR_VERSION_3:
         case TR_VERSION_4:
         case TR_VERSION_5:
-            xyzA[0] = (unsigned short)_boxes[index].xmin * 1024.0;
+            xyzA[0] = (unsigned short)_boxes[index].xmin * 1024.0f;
             xyzA[1] = (short)_boxes[index].true_floor;
-            xyzA[2] = (unsigned short)_boxes[index].zmin * 1024.0;
+            xyzA[2] = (unsigned short)_boxes[index].zmin * 1024.0f;
 
-            xyzB[0] = (unsigned short)_boxes[index].xmax * 1024.0;
+            xyzB[0] = (unsigned short)_boxes[index].xmax * 1024.0f;
             xyzB[1] = (short)_boxes[index].true_floor;
-            xyzB[2] = (unsigned short)_boxes[index].zmin * 1024.0;
+            xyzB[2] = (unsigned short)_boxes[index].zmin * 1024.0f;
 
-            xyzC[0] = (unsigned short)_boxes[index].xmax * 1024.0;
+            xyzC[0] = (unsigned short)_boxes[index].xmax * 1024.0f;
             xyzC[1] = (short)_boxes[index].true_floor;
-            xyzC[2] = (unsigned short)_boxes[index].zmax * 1024.0;
+            xyzC[2] = (unsigned short)_boxes[index].zmax * 1024.0f;
 
-            xyzD[0] = (unsigned short)_boxes[index].xmin * 1024.0;
+            xyzD[0] = (unsigned short)_boxes[index].xmin * 1024.0f;
             xyzD[1] = (short)_boxes[index].true_floor;
-            xyzD[2] = (unsigned short)_boxes[index].zmax * 1024.0;
+            xyzD[2] = (unsigned short)_boxes[index].zmax * 1024.0f;
     }
 
     return 0;
             pos[2] = _rooms[roomIndex].lights[index].z;
             pos[3] = 1.0f;
 
-            color[0] = _rooms[roomIndex].lights[index].intensity1 / 409.60;
+            color[0] = _rooms[roomIndex].lights[index].intensity1 / 409.60f;
             color[1] = color[0];
             color[2] = color[0];
             color[3] = 1.0f;
     height2 = height * scale;
 
     // Quad
-    vertices[0] = -width2 / 2.0;
+    vertices[0] = -width2 / 2.0f;
     vertices[1] = 0;
     vertices[2] = 0;
-    vertices[3] = -width2 / 2.0;
+    vertices[3] = -width2 / 2.0f;
     vertices[4] = -height2;
     vertices[5] = 0;
-    vertices[6] = width2 / 2.0;
+    vertices[6] = width2 / 2.0f;
     vertices[7] = -height2;
     vertices[8] = 0;
-    vertices[9] = width2 / 2.0;
+    vertices[9] = width2 / 2.0f;
     vertices[10] = 0;
     vertices[11] = 0;
 
             {
                 case TR_VERSION_1:
                     color_value = _rooms[index].room_data.vertices[i].attributes;
-                    color_value = (1.1 - (color_value / 8192.0));
+                    color_value = (1.1f - (color_value / 8192.0f));
 
                     rgba[0] = color_value;
                     rgba[1] = color_value;
                 case TR_VERSION_UNKNOWN:
                 default:
                     color_value = _rooms[index].room_data.vertices[i].lighting1;
-                    color_value = (1.1 - (color_value / 8192.0));
+                    color_value = (1.1f - (color_value / 8192.0f));
 
                     rgba[0] = color_value;
                     rgba[1] = color_value;
                 {
                     case TR_VERSION_1:
                         color_value = _rooms[roomIndex].room_data.vertices[i].attributes;
-                        color_value = (1.1 - (color_value / 8192.0));
+                        color_value = (1.1f - (color_value / 8192.0f));
                         break;
                     case TR_VERSION_4:
                     case TR_VERSION_3:
                     case TR_VERSION_UNKNOWN:
                     default:
                         color_value = _rooms[roomIndex].room_data.vertices[i].lighting1;
-                        color_value = (1.1 - (color_value / 8192.0));
+                        color_value = (1.1f - (color_value / 8192.0f));
                 }
 
                 switch (getEngine())
                                         k = image[index] + image[index + 1] + image[index + 2];
 
                                         // Set transparency based upon intensity
-                                        image[index + 3] =  (k / 3);
+                                        image[index + 3] = (unsigned char)(k / 3);
                                     }
                                     else
                                     {
 
                                         // Set transparency based upon intensity
                                         if (offset & 0x8000)
-                                            image[index + 3] = (k / 3);
+                                            image[index + 3] = (unsigned char)(k / 3);
                                         else
                                             image[index + 3] = 0;
                                     }