Changeset 282 for trunk/src/formats/assimp_loader.cc

Timestamp:

07/10/14 00:29:34 (11 years ago)

Author:

epyon

Message:

• key_slots - another template hell similar to vertex definitions
• animation data is now stored using key_raw_channel's similarly to mesh_raw_channels
• automatic compile-time templated interpolation generation for any type of animation key
• QUAT and TRANSFORM as registered types for channels
• a ton of minor cleanups
• do not open vertex.hh if you want to stay sane

File:

• trunk/src/formats/assimp_loader.cc (modified) (8 diffs)

trunk/src/formats/assimp_loader.cc

@@ -314 +314 @@
 }
 
-assimp_animation* nv::assimp_loader::release_animation( size_t, bool pre_transform, const std::vector< assimp_bone >* bone_data )
+assimp_animation* nv::assimp_loader::release_animation( size_t, bool pre_transform )
 {
         if ( m_scene == nullptr ) return nullptr;
@@ -332 +332 @@
 
         load_node( result, root, 0, -1 );
-        // TODO: this is not used when pretransformed, is it used otherwise?
-
-        if ( bone_data )
-        {
-                std::unordered_map< std::string, uint16 > names;
-                for ( uint16 bi = 0; bi < bone_data->size(); ++bi )
-                {
-                        names[ (*bone_data)[bi].name ] = bi;
-                }
-
-                for ( unsigned i = 0; i < result->nodes.size(); ++i )
-                {
-                        assimp_animated_node_data& node = result->nodes[i];
-                        node.bone_id = -1;
-                        auto bi = names.find( node.name );
-                        if ( bi != names.end() )
-                        {
-                                node.bone_id = bi->second;
-                        }
-                        if ( node.parent_id != -1 ) 
-                        {
-                                result->nodes[ node.parent_id ].children.push_back( &node );
-                        }
-                }
-        }
-
         return result;
 }
@@ -391 +365 @@
         a_data.name      = name;
         a_data.parent_id = parent_id;
-        a_data.bone_id = -1;
         // This value is ignored by the create_transformed_keys, but needed by create_direct_keys!
         // TODO: find a common solution!
@@ -397 +370 @@
         //       node's without keys
         a_data.transform = nv::assimp_mat4_cast( node->mTransformation );
+        a_data.channel_count = 0;
 
         if (anode) 
@@ -402 +376 @@
                 if ( data->pretransformed )
                 {
-                        a_data.keys = create_transformed_keys( anode, parent_id >= 0 ? data->nodes[ parent_id ].keys : nullptr );
+                        create_transformed_keys( &a_data, anode, parent_id >= 0 ? &(data->nodes[ parent_id ]) : nullptr );
                 }
                 else
                 {
-                        a_data.keys = create_direct_keys( anode );
+                        create_direct_keys( &a_data, anode );
                 }
         }
@@ -418 +392 @@
 }
 
-key_animation_data* nv::assimp_loader::create_transformed_keys( const void* vnode, const key_animation_data* parent_keys )
+void nv::assimp_loader::create_transformed_keys( assimp_animated_node_data* data, const void* vnode, const assimp_animated_node_data* parent )
 {
         const aiNodeAnim* node = (const aiNodeAnim*)vnode;
         size_t max_keys = glm::max( node->mNumPositionKeys, node->mNumRotationKeys );
-        nv::transform_vector* keys = new nv::transform_vector;
+
+        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));
+
         for ( unsigned n = 0; n < max_keys; ++n )
         {
@@ -431 +409 @@
                 // TODO: only do the calculation when a rotate transform is present!
                 nv::transform ptr( vec3(), glm::quat_cast( m_rotate_transform ) );
-                if ( parent_keys )
-                {
-                        const nv::transform_vector* pv = (const nv::transform_vector*)parent_keys;
-                        if ( pv && pv->size() > 0 ) ptr = pv->get( glm::min( n, pv->size()-1 ) );
+                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;
+                        }
                 }
                 nv::transform key( ptr * nv::transform( pos * m_scale, rot ) );
-                keys->insert( key );
-        }
-        return keys;
-}
-
-key_animation_data* nv::assimp_loader::create_direct_keys( const void* vnode )
-{
+                channel[n].tform = key;
+        }
+}
+
+void nv::assimp_loader::create_direct_keys( assimp_animated_node_data* data, const void* vnode )
+{
+        data->channel_count = 0;
         // TODO : support for m_rotate_transform and m_scale! ( should be easy )
         const aiNodeAnim* node = (const aiNodeAnim*)vnode;
-        if ( node->mNumPositionKeys == 0 && node->mNumRotationKeys == 0 && node->mNumScalingKeys == 0 ) return nullptr;
-        key_vectors_prs* keys = new key_vectors_prs;
+        if ( node->mNumPositionKeys == 0 && node->mNumRotationKeys == 0 && node->mNumScalingKeys == 0 )
+        {
+                return;
+        }
+
+        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));
 
         for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )
         {
-                keys->insert_position( (float)node->mPositionKeys[np].mTime, m_scale * assimp_vec3_cast(node->mPositionKeys[np].mValue) );
+                pchannel[np].time     = (float)node->mPositionKeys[np].mTime;
+                pchannel[np].position = assimp_vec3_cast(node->mPositionKeys[np].mValue);
         }
         for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
         {
-                keys->insert_rotation( (float)node->mRotationKeys[np].mTime, assimp_quat_cast(node->mRotationKeys[np].mValue) );
+                rchannel[np].time     = (float)node->mRotationKeys[np].mTime;
+                rchannel[np].rotation = assimp_quat_cast(node->mRotationKeys[np].mValue);
         }
         if ( node->mNumScalingKeys > 0 )
@@ -466 +459 @@
                         for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
                         {
-                                keys->insert_scale( (float)node->mScalingKeys[np].mTime, assimp_vec3_cast(node->mScalingKeys[np].mValue) );
-                        }
-                }
-        }
-        return keys;
-}
-
+                                schannel[np].time  = (float)node->mScalingKeys[np].mTime;
+                                schannel[np].scale = assimp_vec3_cast(node->mScalingKeys[np].mValue);
+                        }
+                }
+        }
+}
+