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

Timestamp:

07/23/14 15:24:03 (11 years ago)

Author:

epyon

Message:

• mesh_data_pack's in every format
• md5_mesh_data removed, uses standard mesh_data
• BONE_ARRAY in NMD is now a simple set of animation nodes
• bone and animation node concepts merged
• several minor changes

File:

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

trunk/src/formats/md5_loader.cc

@@ -10 +10 @@
 #include "nv/logging.hh"
 #include "nv/io/std_stream.hh"
-#include "nv/profiler.hh"
 #include <cstring>
 
@@ -45 +44 @@
 bool md5_loader::load( stream& source )
 {
-        NV_PROFILE( "Load MD5" ); // 16XXms original
         std_stream sstream( &source );
         std::string command;
@@ -96 +94 @@
                 else if ( command == "mesh" )
                 {
-                        md5_mesh_data* mesh = new md5_mesh_data();
-
-                        int num_verts, num_tris, num_weights;
+                        mesh_data* mesh = new mesh_data("md5_mesh");
+
+                        int num_verts   = 0;
+                        int num_tris    = 0;
+                        int num_weights = 0;
 
                         discard( sstream, "{" );
@@ -106 +106 @@
                                 if ( command == "shader" )
                                 {
-                                        sstream >> mesh->m_shader;
-                                        remove_quotes( mesh->m_shader );
-                                        // texturePath.replace_extension( ".tga" );
+                                        std::string shader;
+                                        sstream >> shader;
+                                        remove_quotes( shader );
                                         next_line( sstream );
                                 }
@@ -115 +115 @@
                                         sstream >> num_verts; 
 
+                                        md5_vtx_t* tdata = nullptr;
                                         {
                                                 mesh_raw_channel* ch_pnt = mesh_raw_channel::create<md5_vtx_pnt>( num_verts );
                                                 mesh_raw_channel* ch_t   = mesh_raw_channel::create<md5_vtx_t>( num_verts );
-                                                mesh->m_pntdata          = (md5_vtx_pnt*)ch_pnt->data;
-                                                mesh->m_tdata            = (md5_vtx_t*)ch_t->data;
+                                                mesh_raw_channel* ch_pntiw = mesh_raw_channel::create<md5_vtx_pntiw>( num_verts );
+                                                tdata = (md5_vtx_t*)ch_t->data;
                                                 mesh->add_channel( ch_pnt );
                                                 mesh->add_channel( ch_t );
+                                                // TODO: hack to prevent rendering
+                                                ch_pntiw->count = 0;
+                                                mesh->add_channel( ch_pntiw );
                                         }
-                                        mesh->m_vtx_data.resize( num_verts );
                                         weight_info.resize( num_verts );
 
@@ -138 +141 @@
                                                 weight_info[i].start_weight = start_weight;
                                                 weight_info[i].weight_count = weight_count;
-                                                mesh->m_tdata[i].texcoord = texcoord;
+                                                tdata[i].texcoord = texcoord;
                                         }  
                                 }
@@ -147 +150 @@
                                         mesh_raw_channel* ch_i = mesh_raw_channel::create_index<uint32>( num_tris * 3 );
                                         uint32* vtx_i                = (uint32*)ch_i->data;
-                                        mesh->m_idata                = vtx_i;
                                         uint32 idx = 0;
                                         mesh->add_channel( ch_i );
@@ -190 +192 @@
                         }
 
-                        prepare_mesh( mesh, weights.data(), weight_info.data() );
+                        prepare_mesh( weight_info.size(), mesh, weights.data(), weight_info.data() );
 
                         m_meshes[ m_num_meshes ] = mesh;
@@ -201 +203 @@
 }
 
-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;
-
-        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();
-        }
+bool md5_loader::prepare_mesh( uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info )
+{
+        md5_vtx_pnt* vtcs = (md5_vtx_pnt*)mdata->get_channel< md5_vtx_pnt >()->data; 
+        md5_vtx_pntiw* vtx_data = (md5_vtx_pntiw*)mdata->get_channel< md5_vtx_pntiw >()->data; 
 
         for ( uint32 i = 0; i < vtx_count; ++i )
@@ -217 +212 @@
                 size_t start_weight = weight_info[i].start_weight;
                 size_t weight_count = weight_info[i].weight_count;
-                md5_vtx_data& vdata = mdata->m_vtx_data[i];
+                md5_vtx_pntiw& vdata = vtx_data[i];
                 md5_vtx_pnt& vtc = vtcs[i];
 
@@ -268 +263 @@
         }
 
+        const uint32*    idata = (uint32*)mdata->get_index_channel()->data;
+        const md5_vtx_t* tdata = mdata->get_channel_data<md5_vtx_t>();
+
         // Prepare normals
         uint32 tri_count = mdata->get_count() / 3;
         for ( unsigned int i = 0; i < tri_count; ++i )
         {
-                uint32 ti0 = mdata->m_idata[ i * 3 ];
-                uint32 ti1 = mdata->m_idata[ i * 3 + 1 ];
-                uint32 ti2 = mdata->m_idata[ i * 3 + 2 ];
+                uint32 ti0 = idata[ i * 3 ];
+                uint32 ti1 = idata[ i * 3 + 1 ];
+                uint32 ti2 = idata[ i * 3 + 2 ];
  
                 glm::vec3 v1 = vtcs[ ti0 ].position;
@@ -288 +286 @@
                 vtcs[ ti2 ].normal += normal;
 
-                const vec2& w1 = mdata->m_tdata[ ti0 ].texcoord;
-                const vec2& w2 = mdata->m_tdata[ ti1 ].texcoord;
-                const vec2& w3 = mdata->m_tdata[ ti2 ].texcoord;
+                const vec2& w1 = tdata[ ti0 ].texcoord;
+                const vec2& w2 = tdata[ ti1 ].texcoord;
+                const vec2& w3 = tdata[ ti2 ].texcoord;
 
                 vec2 st1 = w3 - w1;
@@ -306 +304 @@
         for ( size_t i = 0; i < vtx_count; ++i )
         {
-                md5_vtx_data& vdata = mdata->m_vtx_data[i];
+                md5_vtx_pntiw& vdata = vtx_data[i];
 
                 glm::vec3 normal  = glm::normalize( vtcs[i].normal );
@@ -541 +539 @@
 }
 
-md5_mesh_instance* nv::md5_mesh_data::spawn() const
-{
-        return new md5_mesh_instance( this );
-}
+mesh_nodes_data* nv::md5_loader::release_mesh_nodes_data()
+{
+        mesh_node_data* nodes = new mesh_node_data[ m_num_joints ];
+        for ( uint32 i = 0; i < m_num_joints; ++i )
+        {
+                mesh_node_data& node = nodes[i];
+                node.name      = m_joints[i].name;
+                node.target_id = -1;
+                node.parent_id = -1;
+                node.transform = transform( m_joints[i].pos, m_joints[i].orient ).inverse().extract();
+                node.data      = nullptr;
+        }
+        return new mesh_nodes_data( "nodes", m_num_joints, nodes );
+}
+
+mesh_data_pack* nv::md5_loader::release_mesh_data_pack()
+{
+        uint32 size = m_meshes.size();
+        mesh_data* meshes = new mesh_data[ size ];
+        for ( uint32 i = 0; i < size; ++i )
+        {
+                m_meshes[i]->move_to( meshes[i] );
+                delete m_meshes[i];
+                m_meshes[i] = nullptr;
+        }
+        return new mesh_data_pack( size, meshes, release_mesh_nodes_data() );
+}
+
 
 nv::md5_loader::~md5_loader()
@@ -551 +573 @@
 }
 
-nv::md5_mesh_instance::md5_mesh_instance( const md5_mesh_data* a_data ) 
-        : m_data( a_data ), m_indices( 0 )
-{
-        m_indices = m_data->get_count();
-        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");
-        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];
-        }
-
-        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];
-                md5_vtx_pnt& result = m_pntdata[i];
-
-                for ( size_t j = 0; j < 4; ++j )
-                {
-                        int   index  = vert.boneindex[j];
-                        float weight = vert.boneweight[j];
-                        const quat& orient      = skeleton[index].get_orientation();
-                        const transform& offset = m_pos_offset[index];
-                        result.position += offset.transformed( vert.position )        * weight;
-                        result.normal   += ( orient * vert.normal  ) * weight;
-                        result.tangent  += ( orient * vert.tangent ) * weight;
-                }
-        }
-}