Changeset 261 for trunk/src/formats/md5_loader.cc

Timestamp:

06/18/14 20:05:35 (11 years ago)

Author:

epyon

Message:

• md5_loader using dynamic_array
• skeleton animation via pointer, not vector
• minor fixes

File:

• trunk/src/formats/md5_loader.cc (modified) (10 diffs)

trunk/src/formats/md5_loader.cc

@@ -45 +45 @@
 bool md5_loader::load( stream& source )
 {
+        NV_PROFILE( "Load MD5" ); // 16XXms original
         std_stream sstream( &source );
         std::string command;
-        std::vector< md5_weight > weights;
-        std::vector< md5_weight_info > weight_info;
+        dynamic_array< md5_weight > weights;
+        dynamic_array< md5_weight_info > weight_info;
 
         sstream >> command;
@@ -65 +66 @@
                 {
                         sstream >> m_num_joints;
-                        m_joints.reserve( m_num_joints );
+                        m_joints.resize( m_num_joints );
                 }
                 else if ( command == "numMeshes" )
                 {
                         sstream >> m_num_meshes;
-                        m_meshes.reserve( m_num_meshes );
+                        m_meshes.resize( m_num_meshes );
+                        m_num_meshes = 0;
                 }
                 else if ( command == "joints" )
@@ -87 +89 @@
                                 remove_quotes( joint.name );
                                 unit_quat_w( joint.orient );
-                                m_joints.push_back( joint );
+                                m_joints[i] = joint;
                                 next_line( sstream );
                         }
@@ -168 +170 @@
                                 {
                                         sstream >> num_weights;
-                                        weights.reserve( num_weights );
+                                        weights.resize( num_weights );
                                         next_line( sstream );
                                         std::string line;
@@ -177 +179 @@
                                                 std::getline( sstream, line );
                                                 sscanf( line.c_str(), "%*s %*u %u %f ( %f %f %f )", &(weight.joint_id), &(weight.bias), &(weight.pos.x), &(weight.pos.y), &(weight.pos.z));
-                                                weights.push_back(weight);
+                                                weights[i] = weight;
                                         }
                                 }
@@ -188 +190 @@
                         }
 
-                        prepare_mesh( mesh, weights, weight_info );
-
-                        m_meshes.push_back(mesh);
+                        prepare_mesh( mesh, weights.data(), weight_info.data() );
+
+                        m_meshes[ m_num_meshes ] = mesh;
+                        m_num_meshes++;
                 }
                 sstream >> command;
         }
 
-        assert( m_joints.size() == m_num_joints );
-        assert( m_meshes.size() == m_num_meshes );
         return true;
 }
 
-bool md5_loader::prepare_mesh( md5_mesh_data* mdata, std::vector< md5_weight >& weights, std::vector< md5_weight_info >& weight_info )
+bool md5_loader::prepare_mesh( md5_mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info )
 {
         uint32 vtx_count = mdata->m_vtx_data.size();
         md5_vtx_pnt* vtcs = mdata->m_pntdata;
 
-        for ( auto joint : m_joints )
-        {
-                transform j( joint.pos, joint.orient );
-                mdata->m_bone_offset.push_back(j.inverse());
+        mdata->m_bone_offset.resize( m_joints.size() );
+        for ( uint32 i = 0; i < m_joints.size(); ++i )
+        {
+                transform j( m_joints[i].pos, m_joints[i].orient );
+                mdata->m_bone_offset[i] = j.inverse();
         }
 
@@ -222 +224 @@
                 vtc.tangent  = glm::vec3(0);
 
-                std::sort( weights.begin() + start_weight, weights.begin() + start_weight + weight_count, [](const md5_weight& a, const md5_weight& b) -> bool { return a.bias > b.bias; } );
+                std::sort( weights + start_weight, weights + start_weight + weight_count, [](const md5_weight& a, const md5_weight& b) -> bool { return a.bias > b.bias; } );
 
                 if ( weight_count > 4 )
@@ -475 +477 @@
 
 
-void nv::md5_animation::update_skeleton( std::vector<transform>& skeleton, float anim_time ) const
-{
-        NV_ASSERT( skeleton.size() == m_num_joints, "Incompatible skeleton passed!" );
+void nv::md5_animation::update_skeleton( transform* skeleton, float anim_time ) const
+{
         anim_time = glm::clamp( anim_time, 0.0f, m_anim_duration );
         float frame_num = anim_time * (float)m_frame_rate;
@@ -551 +552 @@
 
 nv::md5_mesh_instance::md5_mesh_instance( const md5_mesh_data* a_data ) 
-        : m_data( a_data ), m_size( 0 ), m_indices( 0 ), m_pntdata( nullptr )
-{
-        m_size = m_data->m_vtx_data.size();
+        : m_data( a_data ), m_indices( 0 )
+{
         m_indices = m_data->get_count();
-        m_pntdata = new md5_vtx_pnt[ m_size ];
-        std::copy_n( m_data->m_pntdata, m_size, m_pntdata );
-}
-
-void nv::md5_mesh_instance::apply( const std::vector< transform >& skeleton )
+        m_pntdata.assign( m_data->m_pntdata, m_data->m_vtx_data.size() );
+}
+
+void nv::md5_mesh_instance::apply( const transform* skeleton )
 {
         NV_PROFILE("md5::apply");
-        m_pos_offset.resize( skeleton.size() );
-        for ( unsigned int i = 0; i < skeleton.size(); ++i )
+        size_t skeleton_size = m_data->m_bone_offset.size();
+        size_t vertex_count  = m_pntdata.size();
+        m_pos_offset.resize( skeleton_size );
+        for ( unsigned int i = 0; i < skeleton_size; ++i )
         {
                 m_pos_offset[i] = skeleton[i] * m_data->m_bone_offset[i];
         }
 
-        char* fill_ptr = (char*)&(m_pntdata[0]);
-        std::fill( fill_ptr, fill_ptr + m_size * ( sizeof( md5_vtx_pnt ) ), 0 );
-        for ( unsigned int i = 0; i < m_size; ++i )
+        std::fill( m_pntdata.raw_data(), m_pntdata.raw_data() + m_pntdata.raw_size(), 0 );
+        for ( unsigned int i = 0; i < vertex_count; ++i )
         {
                 const md5_vtx_data& vert = m_data->m_vtx_data[i];
@@ -579 +579 @@
                         int   index  = vert.boneindex[j];
                         float weight = vert.boneweight[j];
-                        transform joint  = skeleton[index];
-                        transform offset = m_pos_offset[index];
+                        const quat& orient      = skeleton[index].get_orientation();
+                        const transform& offset = m_pos_offset[index];
                         result.position += offset.transformed( vert.position )        * weight;
-                        result.normal   += ( joint.get_orientation() * vert.normal  ) * weight;
-                        result.tangent  += ( joint.get_orientation() * vert.tangent ) * weight;
-                }
-        }
-}
+                        result.normal   += ( orient * vert.normal  ) * weight;
+                        result.tangent  += ( orient * vert.tangent ) * weight;
+                }
+        }
+}