Changeset 198 for trunk/src/formats

Timestamp:

08/11/13 17:19:03 (12 years ago)

Author:

epyon

Message:

• warning cleanup for clang and gcc

Location:

trunk/src/formats

Files:

• md2_loader.cc (modified) (15 diffs)
• md3_loader.cc (modified) (8 diffs)
• md5_loader.cc (modified) (7 diffs)
• obj_loader.cc (modified) (2 diffs)

trunk/src/formats/md2_loader.cc

@@ -17 +17 @@
 
 // assuming low-endian
-#define MD2_MAGIC         "IDP2"
 #define MD2_MAX_FRAMES    512
 #define MD2_MAX_SKINS     32
@@ -75 +74 @@
 struct md2_vertex_t
 {
-        unsigned char v[3];
-        unsigned char n;
+        uint8 v[3];
+        uint8 n;
 };
 
@@ -127 +126 @@
 }
 
-static bool read_md2_frame( md2_frame_t* frame, int vcount, nv::stream& source )
+static bool read_md2_frame( md2_frame_t* frame, unsigned vcount, nv::stream& source )
 {
         frame->vertices = new md2_vertex_t[ vcount ];
@@ -170 +169 @@
         
         source.seek( md2->header.offset_skins, origin::SET );
-        source.read( md2->skins, sizeof(md2_skin_t), md2->header.num_skins );
+        source.read( md2->skins, sizeof(md2_skin_t), static_cast<size_t>( md2->header.num_skins ) );
 
         source.seek( md2->header.offset_st, origin::SET );
-        source.read( md2->texcoords, sizeof(md2_texcoord_t), md2->header.num_st );
+        source.read( md2->texcoords, sizeof(md2_texcoord_t), static_cast<size_t>( md2->header.num_st ) );
 
         source.seek( md2->header.offset_tris, origin::SET );
-        source.read( md2->triangles, sizeof(md2_triangle_t), md2->header.num_tris );
+        source.read( md2->triangles, sizeof(md2_triangle_t), static_cast<size_t>( md2->header.num_tris ) );
 
         source.seek( md2->header.offset_glcmds, origin::SET);
-        source.read( md2->glcmds, sizeof(int), md2->header.num_glcmds );
+        source.read( md2->glcmds, sizeof(int), static_cast<size_t>( md2->header.num_glcmds ) );
 
         md2->frames    = new md2_frame_t   [ md2->header.num_frames ];
@@ -185 +184 @@
         for ( int i = 0; i < md2->header.num_frames; ++i )
         {
-                if (!read_md2_frame( &(md2->frames[i]), md2->header.num_vertices, source ) ) return false;
+                if (!read_md2_frame( &(md2->frames[i]), static_cast<unsigned>( md2->header.num_vertices ), source ) ) return false;
         }
 
@@ -197 +196 @@
 }
 
-static inline vec3 md2_normal( char normal )
+static inline vec3 md2_normal( uint8 normal )
 {
         return md2_vec3( md2_normal_table[normal] );
@@ -269 +268 @@
 }
 
-sint32 md2_loader::get_max_frames() const
-{
-        return ((md2_t*)m_md2)->header.num_frames;
+size_t md2_loader::get_max_frames() const
+{
+        return static_cast< size_t >( ((md2_t*)m_md2)->header.num_frames );
 }
 
@@ -277 +276 @@
 {
         md2_t* md2 = (md2_t*)m_md2;
-        sint32 num_frames = md2->header.num_frames;
-        sint32 num_verts  = m_new_vindexes.size();
+        size_t num_frames = static_cast< size_t >( md2->header.num_frames );
+        size_t num_verts  =     m_new_vindexes.size();
         p.clear();
-        sint32 current_frame = ( frame == -1 ? 0 : frame );
-        sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
+        size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t >( frame ) );
+        size_t frame_count   = ( frame == -1 ? num_frames : 1 );
 
         p.reserve( num_verts * frame_count );
@@ -287 +286 @@
         while ( frame_count > 0 )
         {
-                const md2_frame_t& frame = md2->frames[current_frame];
-                NV_LOG( LOG_INFO, "FrameID = " << frame.name );
-
-                vec3 scale     = md2_vec3( frame.scale );
-                vec3 translate = md2_vec3( frame.translate );
-
-                for (sint32 i = 0; i < num_verts; ++i )
+                const md2_frame_t& cframe = md2->frames[current_frame];
+                NV_LOG( LOG_INFO, "FrameID = " << cframe.name );
+
+                vec3 scale     = md2_vec3( cframe.scale );
+                vec3 translate = md2_vec3( cframe.translate );
+
+                for (size_t i = 0; i < num_verts; ++i )
                 {
-                        const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
+                        const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
                         p.push_back( vec3( v.v[0], v.v[2], v.v[1] ) * scale + translate );
                 }
@@ -306 +305 @@
 {
         md2_t* md2 = (md2_t*)m_md2;
-        sint32 num_frames = md2->header.num_frames;
-        sint32 num_verts  =     m_new_vindexes.size();
+        size_t num_frames = static_cast< size_t >( md2->header.num_frames );
+        size_t num_verts  =     m_new_vindexes.size();
         n.clear();
-        sint32 current_frame = ( frame == -1 ? 0 : frame );
-        sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
+        size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t>( frame ) );
+        size_t frame_count   = ( frame == -1 ? num_frames : 1 );
 
         n.reserve( num_verts * frame_count );
@@ -316 +315 @@
         while ( frame_count > 0 )
         {
-                const md2_frame_t& frame = md2->frames[current_frame];
-
-                for (sint32 i = 0; i < num_verts; ++i )
+                const md2_frame_t& cframe = md2->frames[current_frame];
+
+                for (size_t i = 0; i < num_verts; ++i )
                 {
-                        const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
+                        const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
                         n.push_back( s_md2_normal_cache[ v.n ] );
                 }
@@ -331 +330 @@
 {
         md2_t* md2 = (md2_t*)m_md2;
-        sint32 num_verts  = m_new_vindexes.size();
+        size_t num_verts  = m_new_vindexes.size();
 
         t.clear();
@@ -338 +337 @@
         vec2 scale( 1.0f / (float) md2->header.skinwidth, 1.0f / (float) md2->header.skinheight );
 
-        for (sint32 i = 0; i < num_verts; ++i )
+        for (size_t i = 0; i < num_verts; ++i )
         {
                 const md2_texcoord_t& st = md2->texcoords[ m_new_tindexes[ i ] ];
@@ -354 +353 @@
 {
         md2_t* md2 = (md2_t*)m_md2;
-        uint32 num_indexes = md2->header.num_tris * 3;
+        uint32 num_indexes = static_cast< uint32 >( md2->header.num_tris * 3 );
 
         uint32 stats_reuse      = 0;
@@ -373 +372 @@
                 for ( int j = 0; j < 3; ++j )
                 {
-                        short index  = t.vertex[j];
-                        short tindex = t.st[j];
+                        uint16 index  = t.vertex[j];
+                        uint16 tindex = t.st[j];
 
                         if ( index_translation[ index ] != -1 )
                         {
-                                uint16 prev = index_translation[ index ];
+                                uint16 prev = static_cast< uint16 >( index_translation[ index ] );
                                 if ( m_new_tindexes[ prev ] == tindex )
                                 {

trunk/src/formats/md3_loader.cc

@@ -17 +17 @@
 
 // assuming low-endian
-#define MD3_MAGIC         "IDP3"
 #define MD3_MAX_FRAMES    1024
 #define MD3_MAX_TAGS      16
@@ -149 +148 @@
 static bool read_surface( md3_surface_t * surface, nv::stream& source )
 {
-        sint32 pos = source.tell();
+        sint32 pos = static_cast< sint32 >( source.tell() );
         source.read( &surface->header, sizeof(md3_surface_header_t), 1 );
 
@@ -164 +163 @@
 
         source.seek( pos + surface->header.ofs_shaders, origin::SET );
-        source.read( surface->shaders, sizeof( md3_shader_t ), surface->header.num_shaders );
+        source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<size_t>( surface->header.num_shaders ) );
 
         source.seek( pos + surface->header.ofs_triangles, origin::SET );
-        source.read( surface->triangles, sizeof( md3_triangle_t ), surface->header.num_triangles );
+        source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<size_t>( surface->header.num_triangles ) );
 
         source.seek( pos + surface->header.ofs_st, origin::SET );
-        source.read( surface->st, sizeof( md3_texcoord_t ), surface->header.num_verts );
+        source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<size_t>( surface->header.num_verts ) );
 
         source.seek( pos + surface->header.ofs_xyznormal, origin::SET );
-        source.read( surface->vertices, sizeof( md3_vertex_t ), surface->header.num_verts * surface->header.num_frames );
+        source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<size_t>( surface->header.num_verts * surface->header.num_frames ) );
 
         if ( source.tell() != static_cast<std::size_t>( pos + surface->header.ofs_end ) ) return false;
@@ -201 +200 @@
         md3->tags     = new md3_tag_t    [ md3->header.num_tags * md3->header.num_frames ];
         md3->surfaces = new md3_surface_t[ md3->header.num_surfaces ];
-        std::memset( md3->surfaces, 0, md3->header.num_surfaces * sizeof(md3_surface_t) );
+        std::memset( md3->surfaces, 0, static_cast< size_t >( md3->header.num_surfaces ) * sizeof(md3_surface_t) );
 
         source.seek( md3->header.ofs_frames, origin::SET );
-        source.read( md3->frames, sizeof( md3_frame_t ), md3->header.num_frames );
+        source.read( md3->frames, sizeof( md3_frame_t ), static_cast<size_t>( md3->header.num_frames ) );
 
         source.seek( md3->header.ofs_tags, origin::SET );
-        source.read( md3->tags, sizeof( md3_tag_t ), md3->header.num_tags * md3->header.num_frames );
+        source.read( md3->tags, sizeof( md3_tag_t ), static_cast<size_t>( md3->header.num_tags * md3->header.num_frames ) );
 
         source.seek( md3->header.ofs_surfaces, origin::SET );
@@ -351 +350 @@
 }
 
-sint32 md3_loader::get_max_frames() const
-{
-        return ((md3_t*)m_md3)->header.num_frames;
+size_t md3_loader::get_max_frames() const
+{
+        return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );
 }
 
@@ -401 +400 @@
         sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
 
-        p.reserve( md3->vertices_per_frame * frame_count );
+        p.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
 
         while ( frame_count > 0 )
@@ -430 +429 @@
         sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
 
-        n.reserve( md3->vertices_per_frame * frame_count );
+        n.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
 
         while ( frame_count > 0 )
@@ -476 +475 @@
         {
                 const md3_surface_t& surface = md3->surfaces[i];
-                const sint32         tcount  = surface.header.num_triangles;
+                const size_t         tcount  = static_cast< size_t >( surface.header.num_triangles );
 
                 idx.reserve( idx.size() + tcount * 3 );
-                for (sint32 j = 0; j < tcount; ++j )
+                for (size_t j = 0; j < tcount; ++j )
                 {
                         const md3_triangle_t& t = surface.triangles[j];

trunk/src/formats/md5_loader.cc

@@ -36 +36 @@
 }
 
-void unit_quat_w( glm::quat& quat )
+static void unit_quat_w( glm::quat& quat )
 {
         float t = 1.0f - ( quat.x * quat.x ) - ( quat.y * quat.y ) - ( quat.z * quat.z );
@@ -354 +354 @@
                 {
                         discard( sstream, "{" );
-                        for ( int i = 0; i < m_num_joints; ++i )
+                        for ( size_t i = 0; i < m_num_joints; ++i )
                         {
                                 md5_joint_info joint;
@@ -368 +368 @@
                         discard( sstream, "{" );
                         next_line( sstream ); 
-                        for ( int i = 0; i < m_num_frames; ++i ) 
+                        for ( size_t i = 0; i < m_num_frames; ++i ) 
                         {
                                 md5_bound bound;
@@ -390 +390 @@
                         next_line( sstream ); 
 
-                        for ( int i = 0; i < m_num_joints; ++i )
+                        for ( size_t i = 0; i < m_num_joints; ++i )
                         {
                                 md5_base_frame base_frame;
@@ -412 +412 @@
                         next_line( sstream ); 
 
-                        for ( int i = 0; i < m_num_animated_components; ++i )
+                        for ( size_t i = 0; i < m_num_animated_components; ++i )
                         {
                                 float frameData;
@@ -436 +436 @@
         m_anim_time = 0.0f;
 
-        assert( m_joint_infos.size() == (size_t)m_num_joints );
-        assert( m_bounds.size()      == (size_t)m_num_frames );
-        assert( m_base_frames.size() == (size_t)m_num_joints );
-        assert( m_frames.size()      == (size_t)m_num_frames );
-        assert( m_skeletons.size()   == (size_t)m_num_frames );
+        assert( m_joint_infos.size() == m_num_joints );
+        assert( m_bounds.size()      == m_num_frames );
+        assert( m_base_frames.size() == m_num_joints );
+        assert( m_frames.size()      == m_num_frames );
+        assert( m_skeletons.size()   == m_num_frames );
 
         return true;
@@ -506 +506 @@
 void md5_animation::interpolate_skeletons( md5_frame_skeleton& final_skeleton, const md5_frame_skeleton& skeleton0, const md5_frame_skeleton& skeleton1, float interpolate )
 {
-        for ( int i = 0; i < m_num_joints; ++i )
+        for ( size_t i = 0; i < m_num_joints; ++i )
         {
                 md5_skeleton_joint& final_joint = final_skeleton.joints[i];

trunk/src/formats/obj_loader.cc

@@ -119 +119 @@
 struct mesh_obj_reader : public obj_reader
 {
-        mesh_obj_reader( mesh* m ) : m_mesh( m ), m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ) {}
+        mesh_obj_reader( mesh* m ) : m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ), m_mesh( m ) {}
         virtual std::size_t add_face( uint32* v, uint32* t, uint32* n, size_t count );
         virtual void calculate_tangents();
@@ -206 +206 @@
                 vec3 xyz1 = v2 - v1;
                 vec3 xyz2 = v3 - v1;
-                vec2 st1  = w2 - w1;
-                vec2 st2  = w3 - w1;
+                //vec2 st1  = w2 - w1;
+                //vec2 st2  = w3 - w1;
 
                 float s1 = w2.x - w1.x;