Changeset 285 for trunk/src

Timestamp:

07/21/14 02:19:34 (11 years ago)

Author:

epyon

Message:

• full pure data model for animation
• all loaders now use pure data model instead of the template/virtual one

Location:

trunk/src

Files:

• formats/assimp_loader.cc (modified) (5 diffs)
• formats/md3_loader.cc (modified) (1 diff)
• formats/nmd_loader.cc (modified) (5 diffs)
• gfx/keyframed_mesh.cc (modified) (1 diff)

trunk/src/formats/assimp_loader.cc

@@ -367 +367 @@
         if (this_id == 0)
                 a_data.transform = mat4();
-        a_data.channel_count = 0;
+        a_data.data = nullptr;
 
         if (anode) 
@@ -394 +394 @@
         size_t max_keys = glm::max( node->mNumPositionKeys, node->mNumRotationKeys );
 
-        data->channel_count = 1;
-        data->channels[0] = key_raw_channel::create<assimp_key_tr>( max_keys );
-        assimp_key_tr* channel = ((assimp_key_tr*)(data->channels[0]->data));
+        key_raw_channel* raw_channel = key_raw_channel::create<assimp_key_tr>( max_keys );
+        data->data = new key_data;
+        data->data->add_channel( raw_channel );
+        assimp_key_tr* channel = ((assimp_key_tr*)(raw_channel->data));
 
         for ( unsigned n = 0; n < max_keys; ++n )
@@ -406 +407 @@
                 // TODO: only do the calculation when a rotate transform is present!
                 nv::transform ptr;
-                if ( parent )
-                {
-                        key_raw_channel* pchannel = parent->channels[0];
-                        if ( parent->channels[0] && parent->channels[0]->count > 0 )
-                        {
-                                ptr = ((assimp_key_tr*)pchannel->data)[ glm::min( n, parent->channels[0]->count-1 ) ].tform;
+                if ( parent && parent->data )
+                {
+                        const key_raw_channel* pchannel = parent->data->get_channel(0);
+                        if ( pchannel && pchannel->count > 0 )
+                        {
+                                ptr = ((assimp_key_tr*)pchannel->data)[ glm::min( n, pchannel->count-1 ) ].tform;
                         }
                 }
@@ -422 +423 @@
 void nv::assimp_loader::create_direct_keys( assimp_animated_node_data* data, const void* vnode )
 {
-        data->channel_count = 0;
         const aiNodeAnim* node = (const aiNodeAnim*)vnode;
         if ( node->mNumPositionKeys == 0 && node->mNumRotationKeys == 0 && node->mNumScalingKeys == 0 )
@@ -429 +429 @@
         }
 
-        data->channel_count = 3;
-        data->channels[0] = key_raw_channel::create<assimp_key_p>( node->mNumPositionKeys );
-        data->channels[1] = key_raw_channel::create<assimp_key_r>( node->mNumRotationKeys );
-        data->channels[2] = key_raw_channel::create<assimp_key_s>( node->mNumScalingKeys );
-        assimp_key_p* pchannel = ((assimp_key_p*)(data->channels[0]->data));
-        assimp_key_r* rchannel = ((assimp_key_r*)(data->channels[1]->data));
-        assimp_key_s* schannel = ((assimp_key_s*)(data->channels[2]->data));
+        data->data = new key_data;
+        key_raw_channel* raw_pchannel = key_raw_channel::create<assimp_key_p>( node->mNumPositionKeys );
+        key_raw_channel* raw_rchannel = key_raw_channel::create<assimp_key_r>( node->mNumRotationKeys );
+        key_raw_channel* raw_schannel = key_raw_channel::create<assimp_key_s>( node->mNumScalingKeys );
+        data->data->add_channel( raw_pchannel );
+        data->data->add_channel( raw_rchannel );
+        data->data->add_channel( raw_schannel );
+        assimp_key_p* pchannel = ((assimp_key_p*)(raw_pchannel->data));
+        assimp_key_r* rchannel = ((assimp_key_r*)(raw_rchannel->data));
+        assimp_key_s* schannel = ((assimp_key_s*)(raw_schannel->data));
 
         for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )

trunk/src/formats/md3_loader.cc

@@ -407 +407 @@
         for ( sint32 i = 0; i < md3->header.num_tags; ++i )
         {
-                const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags];
+                const md3_tag_t& rtag = md3->tags[i];
                 std::string name( (char*)(rtag.name) );
-                nv::key_raw_channel* keys = load_tags( name );
-                result->insert( name, keys );
+
+                key_data* data = new key_data;
+                data->add_channel( load_tags( name ) );
+                result->insert( name, data );
         }
         return result;
 }
 
+mesh_node_data* nv::md3_loader::release_mesh_node_data( size_t index )
+{
+        md3_t* md3 = (md3_t*)m_md3;
+        const md3_tag_t& rtag = md3->tags[index];
+        std::string name( (char*)(rtag.name) );
+
+        mesh_node_data* result = new mesh_node_data;
+        result->transform = mat4();
+        result->name      = name;
+        result->parent_id = -1;
+        result->target_id = -1;
+        result->data = new key_data;
+        
+        key_raw_channel* keys = load_tags( name );
+        result->data->add_channel( keys );
+        return result;
+}
+
+size_t nv::md3_loader::get_node_count() const
+{
+        return ((md3_t*)m_md3)->header.num_tags;
+}
+
 size_t md3_loader::get_max_frames() const
 {

trunk/src/formats/nmd_loader.cc

@@ -138 +138 @@
                 m_animation->nodes[i].parent_id     = node_header.parent_id;
                 m_animation->nodes[i].transform     = node_header.transform;
-                m_animation->nodes[i].channel_count = ch_count;
-                m_animation->nodes[i].channels      = nullptr;
+                m_animation->nodes[i].data          = nullptr;
                 if ( ch_count > 0 )
                 {
-                        m_animation->nodes[i].channels      = new key_raw_channel* [ch_count];
+                        key_data* kdata = new key_data;
+                        m_animation->nodes[i].data = kdata;
                         for ( uint32 c = 0; c < ch_count; ++c )
                         {
@@ -151 +151 @@
                                 key_raw_channel* channel = key_raw_channel::create( cheader.format, cheader.count );
                                 source.read( channel->data, channel->desc.size, channel->count );
-                                m_animation->nodes[i].channels[c] = channel;
+                                kdata->add_channel( channel );
                         }
                 }
@@ -168 +168 @@
         {
                 nmd_node& node = m_animation->nodes[n];
-                key_animation_data* keys = nullptr;
-                if ( node.channel_count > 1 )
-                {
-                        keys = new nv::key_vectors_prs( node.channels[0], node.channels[1], node.channels[2] );
-                }
-                else if ( node.channel_count == 1 )
-                {
-                        keys      =  new nv::transform_vector( node.channels[0] );
-                        node.channels[0] = nullptr;
-                        node.channel_count = 0;
-                }
-                m_data.push_back( keys );
+                m_data.push_back( node.data );
+                node.data = nullptr;
         }
 
@@ -239 +229 @@
                         nv::mat4 node_mat( node->transform );
 
-                        if ( m_data[n] && !m_data[n]->empty() )
+                        if ( m_data[n] )
                         {
                                 node_mat = m_data[n]->get_matrix( anim_time );
@@ -257 +247 @@
         mat4 node_mat( node->transform );
 
-        if ( m_data[ node_id ] && !m_data[ node_id ]->empty() )
+        if ( m_data[ node_id ] )
         {
                 node_mat = m_data[ node_id ]->get_matrix( time );

trunk/src/gfx/keyframed_mesh.cc

@@ -40 +40 @@
 }
 
-transform keyframed_mesh::get_tag( const std::string& tag ) const
+transform keyframed_mesh::get_tag( uint32 tag ) const
 {
         NV_ASSERT( m_tag_map, "TAGMAP FAIL" );
-        const transform* transforms = m_tag_map->get_tag( tag );
-        NV_ASSERT( transforms, "TAG FAIL" );
-        return interpolate( transforms[ m_last_frame ], transforms[ m_next_frame ], m_interpolation  );
+        const key_data* data = m_tag_map->get_tag( tag );
+        NV_ASSERT( data, "TAG FAIL" );
+        transform last = data->get_raw_transform( m_last_frame );
+        transform next = data->get_raw_transform( m_next_frame );
+        return interpolate( last, next, m_interpolation  );
 }