Changeset 249 for trunk/src

Timestamp:

05/30/14 18:14:17 (11 years ago)

Author:

epyon

Message:

• formats/assimp - full animation support
• two animation formats - merged keys and separate key channels

File:

• trunk/src/formats/assimp_loader.cc (modified) (1 diff)

trunk/src/formats/assimp_loader.cc

@@ -270 +270 @@
 }
 
+assimp_animation* nv::assimp_loader::release_animation( size_t, bool pre_transform, const std::vector< assimp_bone >* bone_data )
+{
+        if ( m_scene == nullptr ) return nullptr;
+        const aiScene* scene = (const aiScene*)m_scene;
+        if ( scene->mRootNode == nullptr || scene->mAnimations[0] == nullptr ) return nullptr;
+        assimp_animation* result = new assimp_animation;
+
+        // need resize not to copy!
+        result->nodes.resize( count_nodes( scene->mRootNode ) );
+
+        const aiNode*      root = scene->mRootNode;
+        const aiAnimation* anim = scene->mAnimations[0]; // if implemented, change in load_node also
+
+        result->fps            = (float)anim->mTicksPerSecond;
+        result->duration       = (float)anim->mDuration;
+        result->pretransformed = pre_transform;
+
+        load_node( result, root, 0, -1 );
+        result->nodes[0].transform = glm::scale( m_scale, m_scale, m_scale ) * result->nodes[0].transform;
+
+        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;
+}
+
+nv::uint32 nv::assimp_loader::count_nodes( const void* node ) const
+{
+        const aiNode* ainode = (const aiNode*)node;
+        nv::uint32 count = 1;
+        for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
+        {
+                count += count_nodes( ainode->mChildren[i] );
+        }
+        return count;
+}
+
+nv::uint32 nv::assimp_loader::load_node( assimp_animation* data, const void* vnode, sint32 this_id, sint32 parent_id )
+{
+        const aiScene* scene = (const aiScene*)m_scene;
+        const aiNode*  node  = (const aiNode*)vnode;
+        string name( node->mName.data );
+        const aiAnimation* anim  = scene->mAnimations[0];
+        const aiNodeAnim*  anode = nullptr;
+
+        for ( unsigned i = 0 ; i < anim->mNumChannels ; i++ )
+        {
+                anode = anim->mChannels[i];
+                if ( std::string( anode->mNodeName.data ) == name ) break;
+                anode = nullptr;
+        }
+
+        assimp_animated_node_data& a_data = data->nodes[ this_id ];
+
+        a_data.name      = name;
+        a_data.parent_id = parent_id;
+        a_data.bone_id = -1;
+        a_data.transform = nv::assimp_mat4_cast( node->mTransformation );
+
+        if (anode) 
+        {
+                if ( data->pretransformed )
+                {
+                        a_data.keys = create_transformed_keys( anode, parent_id >= 0 ? data->nodes[ parent_id ].keys : nullptr );
+                }
+                else
+                {
+                        a_data.keys = create_direct_keys( anode );
+                }
+        }
+
+        nv::uint32 next = this_id + 1;
+        for ( unsigned i = 0; i < node->mNumChildren; ++i )
+        {
+                next = load_node( data, node->mChildren[i], next, this_id );
+        }
+        return next;
+}
+
+key_animation_data* nv::assimp_loader::create_transformed_keys( const void* vnode, const key_animation_data* parent_keys )
+{
+        const aiNodeAnim* node = (const aiNodeAnim*)vnode;
+        size_t max_keys = glm::max( node->mNumPositionKeys, node->mNumRotationKeys );
+        nv::transform_vector* keys = new nv::transform_vector;
+        for ( unsigned n = 0; n < max_keys; ++n )
+        {
+                size_t pn = glm::min( node->mNumPositionKeys - 1, n );
+                size_t rn = glm::min( node->mNumRotationKeys - 1, n );
+                nv::vec3 pos = nv::assimp_vec3_cast(node->mPositionKeys[pn].mValue);
+                nv::quat rot = nv::assimp_quat_cast(node->mRotationKeys[rn].mValue);
+                nv::transform ptr;
+                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 ) );
+                }
+
+                nv::vec3 rot_pos = ptr.get_orientation() * pos;
+                pos = ptr.get_position() + rot_pos;
+                rot = glm::normalize( ptr.get_orientation() * rot );
+                keys->insert( nv::transform( pos, rot ) );
+        }
+        return keys;
+}
+
+key_animation_data* nv::assimp_loader::create_direct_keys( const void* vnode )
+{
+        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;
+
+        for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )
+        {
+                keys->insert_position( (float)node->mPositionKeys[np].mTime, 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) );
+        }
+        if ( node->mNumScalingKeys > 0 )
+        {
+                nv::vec3 scale_vec0 = assimp_vec3_cast( node->mScalingKeys[0].mValue );
+                float scale_value   = glm::length( glm::abs( scale_vec0 - nv::vec3(1,1,1) ) );
+                if ( node->mNumScalingKeys > 1 || scale_value > 0.001 ) 
+                {
+                        NV_LOG( nv::LOG_WARNING, "scale key significant!" );
+                        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;
+}
+