Changeset 323 for trunk/src/formats

Timestamp:

08/26/14 04:03:10 (11 years ago)

Author:

epyon

Message:

• nova now compiles again under all three compilers with -Winsane and no warnings

Location:

trunk/src/formats

Files:

• assimp_loader.cc (modified) (7 diffs)
• md3_loader.cc (modified) (8 diffs)
• md5_loader.cc (modified) (5 diffs)
• nmd_loader.cc (modified) (1 diff)

trunk/src/formats/assimp_loader.cc

@@ -14 +14 @@
 using namespace nv;
 
-const int MAX_BONES = 64;
+const unsigned MAX_BONES = 64;
 
 struct assimp_plain_vtx 
@@ -90 +90 @@
         m_mesh_count = 0;
         NV_LOG( nv::LOG_NOTICE, "AssImp loading file..." );
-        int size = (int)source.size();
+        size_t size = source.size();
         char* data  = new char[ size ];
         source.read( data, size, 1 );
@@ -159 +159 @@
                                         if ( v.boneweight[i] <= 0.0f ) 
                                         {
-                                                v.boneindex[i] = m;
+                                                v.boneindex[i]  = (int)m;
                                                 v.boneweight[i] = bone->mWeights[w].mWeight;
                                                 found = true;
@@ -289 +289 @@
         for ( unsigned int m = 0; m < m_mesh_count; ++m )
         {
-                sint16 translate[MAX_BONES];
+                uint16 translate[MAX_BONES];
                 std::vector< mesh_node_data > bones;
                 const aiMesh*  mesh  = scene->mMeshes[ m ];
@@ -304 +304 @@
                                 {
                                         NV_ASSERT( final_bones.size() < MAX_BONES, "Too many bones to merge!" );
-                                        sint16 index = (sint16)final_bones.size();
+                                        uint16 index = (uint16)final_bones.size();
                                         final_bones.push_back( bone );
                                         names[ bone.name ] = index;
@@ -311 +311 @@
                                 else
                                 {
-                                        translate[b] = (sint16)iname->second;
+                                        translate[b] = iname->second;
                                 }
                         }
@@ -326 +326 @@
                                                 if ( vertex.boneweight[i] > 0.0f ) 
                                                 {
-                                                        vertex.boneindex[i] = translate[vertex.boneindex[i]];
+                                                        vertex.boneindex[i] = (int)translate[vertex.boneindex[i]];
                                                 }
                                         }

trunk/src/formats/md3_loader.cc

@@ -234 +234 @@
 
 md3_loader::md3_loader( bool merge_all )
-        : m_md3( nullptr ), m_merge_all( merge_all )
+        : m_merge_all( merge_all ), m_md3( nullptr )
 {
         if ( !s_normal_ready )
@@ -286 +286 @@
 {
         md3_t* md3 = (md3_t*)m_md3;
-        key_raw_channel* result = key_raw_channel::create<md3_key>( md3->header.num_frames );
+        key_raw_channel* result = key_raw_channel::create<md3_key>( (uint32)md3->header.num_frames );
         // TODO: is this brain damaged in efficiency (loop nest order) or what?
         for ( sint32 f = 0; f < md3->header.num_frames; ++f )
@@ -322 +322 @@
 {
         mesh_data* data = new mesh_data;
-        release_mesh_frame( data, -1, index );
+        release_mesh_frame( data, -1, (sint32)index );
         return data;
 }
@@ -329 +329 @@
 {
         md3_t* md3 = (md3_t*)m_md3;
-        sint32 num_surfaces  = md3->header.num_surfaces;
-        sint32 num_verts     = 0;
-        sint32 current_frame = ( frame == -1 ? 0 : frame );
-        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
-        sint32 current_surf  = ( surface == -1 ? 0 : surface );
-        sint32 surf_count    = ( surface == -1 ? md3->header.num_surfaces : 1 );
-        sint32 index_count   = 0;
+        uint32 num_surfaces  = (uint32)md3->header.num_surfaces;
+        uint32 num_verts     = 0;
+        uint32 current_frame = ( frame == -1 ? 0 : (uint32)frame );
+        uint32 frame_count   = ( frame == -1 ? (uint32)md3->header.num_frames : 1 );
+        uint32 current_surf  = ( surface == -1 ? 0 : (uint32)surface );
+        uint32 surf_count    = ( surface == -1 ? (uint32)md3->header.num_surfaces : 1 );
+        uint32 index_count   = 0;
 
         if ( surface >= 0 )
         {
-                index_count = md3->surfaces[surface].header.num_triangles * 3;
-                num_verts   = md3->surfaces[surface].header.num_verts;
+                index_count = (uint32)md3->surfaces[(uint32)surface].header.num_triangles * 3;
+                num_verts   = (uint32)md3->surfaces[(uint32)surface].header.num_verts;
         }
         else
-                for ( sint32 i = 0; i < num_surfaces; ++i )
-                {
-                        index_count += md3->surfaces[i].header.num_triangles * 3;
-                        num_verts   += md3->surfaces[i].header.num_verts;
+                for ( uint32 i = 0; i < num_surfaces; ++i )
+                {
+                        index_count += (uint32)md3->surfaces[i].header.num_triangles * 3;
+                        num_verts   += (uint32)md3->surfaces[i].header.num_verts;
                 }
 
@@ -362 +362 @@
         while ( surf_count > 0 )
         {
-                const md3_surface_t& surface = md3->surfaces[ current_surf ];
-                const uint32         vcount  = static_cast< uint32 >( surface.header.num_verts );
-                const uint32         tcount  = static_cast< uint32 >( surface.header.num_triangles );
+                const md3_surface_t& sface  = md3->surfaces[ current_surf ];
+                const uint32         vcount = static_cast< uint32 >( sface.header.num_verts );
+                const uint32         tcount = static_cast< uint32 >( sface.header.num_triangles );
 
                 for (uint32 j = 0; j < vcount; ++j )
                 {
-                        vtx_t[index++].texcoord = md3_texcoord( surface.st[j] );
+                        vtx_t[index++].texcoord = md3_texcoord( sface.st[j] );
                 }
 
                 for (size_t j = 0; j < tcount; ++j )
                 {
-                        const md3_triangle_t& t = surface.triangles[j];
+                        const md3_triangle_t& t = sface.triangles[j];
                         icp[iindex++] = static_cast< uint16 >( index_base + t.indexes[0] );
                         icp[iindex++] = static_cast< uint16 >( index_base + t.indexes[1] );
                         icp[iindex++] = static_cast< uint16 >( index_base + t.indexes[2] );
                 }
-                index_base += surface.header.num_verts;
+                index_base += sface.header.num_verts;
                 ++current_surf;
                 --surf_count;
@@ -386 +386 @@
         while ( frame_count > 0 )
         {
-                current_surf  = ( surface == -1 ? 0 : surface );
-                surf_count    = ( surface == -1 ? md3->header.num_surfaces : 1 );
+                current_surf  = ( surface == -1 ? 0 : (uint32)surface );
+                surf_count    = ( surface == -1 ? (uint32)md3->header.num_surfaces : 1 );
 
                 while ( surf_count > 0 )
                 {
-                        md3_surface_t& surface = md3->surfaces[current_surf];
-                        sint32         vcount  = surface.header.num_verts;
-                        sint32         offset  = vcount * current_frame;
-                        sint32         limit   = vcount + offset;
-                        for (sint32 j = offset; j < limit; ++j )
+                        md3_surface_t& sface  = md3->surfaces[current_surf];
+                        uint32         vcount = (uint32)sface.header.num_verts;
+                        uint32         offset = vcount * current_frame;
+                        uint32         limit  = vcount + offset;
+                        for (uint32 j = offset; j < limit; ++j )
                         {
-                                md3_vertex_t& v = surface.vertices[j];
+                                md3_vertex_t& v = sface.vertices[j];
                                 vtx_pn[index].position = vec3( v.x * MD3_XYZ_SCALE, v.z * MD3_XYZ_SCALE, v.y * MD3_XYZ_SCALE );
                                 vtx_pn[index].normal   = s_normal_cache[ v.normal ];
@@ -418 +418 @@
 {
         md3_t* md3 = (md3_t*)m_md3;
-        uint32 node_count = md3->header.num_tags;
+        uint32 node_count = (uint32)md3->header.num_tags;
         if ( node_count == 0 ) return nullptr;;
         mesh_node_data* nodes = new mesh_node_data[ node_count ];
@@ -451 +451 @@
         else
         {
-                count = md3->header.num_surfaces;
+                count = (uint32)md3->header.num_surfaces;
                 data = new mesh_data[ count ];
                 for ( uint32 i = 0; i < count; ++i )
                 {
-                        release_mesh_frame( &data[i], -1, i );
+                        release_mesh_frame( &data[i], -1, (sint32)i );
                         data[i].set_name( (char*)md3->surfaces[i].header.name );
                 }

trunk/src/formats/md5_loader.cc

@@ -135 +135 @@
                         mesh_data* mesh = new mesh_data("md5_mesh");
 
-                        int num_verts   = 0;
-                        int num_tris    = 0;
-                        int num_weights = 0;
+                        uint32 num_verts   = 0;
+                        uint32 num_tris    = 0;
+                        uint32 num_weights = 0;
 
                         discard( sstream, "{" );
@@ -170 +170 @@
                                         next_line( sstream );
                                         std::string line;
-                                        for ( int i = 0; i < num_verts; ++i )
+                                        for ( uint32 i = 0; i < num_verts; ++i )
                                         {
                                                 size_t weight_count;
@@ -194 +194 @@
                                         next_line( sstream );
                                         std::string line;
-                                        for ( int i = 0; i < num_tris; ++i )
+                                        for ( uint32 i = 0; i < num_tris; ++i )
                                         {
                                                 size_t ti0;
@@ -214 +214 @@
                                         next_line( sstream );
                                         std::string line;
-                                        for ( int i = 0; i < num_weights; ++i )
+                                        for ( uint32 i = 0; i < num_weights; ++i )
                                         {
                                                 md5_weight weight;
@@ -368 +368 @@
                         if ( j < weight_count )
                         {
-                                vdata.boneindex[j]  = weights[start_weight + j].joint_id;
+                                vdata.boneindex[j]  = (int)weights[start_weight + j].joint_id;
                                 vdata.boneweight[j] = weights[start_weight + j].bias;
                         }

trunk/src/formats/nmd_loader.cc

@@ -242 +242 @@
 
                 nmd_node_header nheader;
-                nheader.parent_id = (uint16)node->parent_id;
+                nheader.parent_id = node->parent_id;
                 nheader.transform = node->transform;
                 stream_out.write( &nheader, sizeof( nheader ), 1 );