source: trunk/src/formats/assimp_loader.cc @ 483

Last change on this file since 483 was 482, checked in by epyon, 10 years ago
  • skeletal animation updated
File size: 16.1 KB
Line 
1// Copyright (C) 2014-2015 ChaosForge Ltd
2// http://chaosforge.org/
3//
4// This file is part of Nova libraries.
5// For conditions of distribution and use, see copying.txt file in root folder.
6
7#include "nv/formats/assimp_loader.hh"
8
9#include "nv/interface/data_channel_access.hh"
10#include "nv/stl/hash_store.hh"
11#include "nv/lib/assimp.hh"
12
13using namespace nv;
14
15const unsigned MAX_BONES = 64;
16
17struct assimp_plain_vtx
18{
19        vec3 position;
20        vec3 normal;
21        vec2 texcoord;
22        vec4 tangent;
23
24        assimp_plain_vtx() {}
25        assimp_plain_vtx( const vec3& v, const vec2& t, const vec3& n, const vec4& g )
26        {
27                position = v;
28                texcoord = t;
29                normal   = n;
30                tangent  = g;
31        }
32};
33
34struct assimp_skinned_vtx
35{
36        vec3  position;
37        vec3  normal;
38        vec2  texcoord;
39        vec4  tangent;
40        ivec4 boneindex;
41        vec4  boneweight;
42
43        assimp_skinned_vtx() {}
44        assimp_skinned_vtx( const vec3& v, const vec2& t, const vec3& n, const vec4& g )
45        {
46                position = v;
47                texcoord = t;
48                normal   = n;
49                tangent  = g;
50        }
51};
52
53struct assimp_key_p  { float time; vec3 translation; };
54struct assimp_key_r  { float time; quat rotation; };
55struct assimp_key_s  { float time; vec3 scale; };
56struct assimp_key_tr { transform tform; };
57
58
59nv::assimp_loader::assimp_loader( string_table* strings, const string_view& a_ext, uint32 a_assimp_flags /*= 0 */ )
60        : mesh_loader( strings ), m_scene( nullptr ), m_mesh_count(0)
61{
62        m_ext   = a_ext;
63        m_assimp_flags = a_assimp_flags;
64        if ( m_assimp_flags == 0 )
65        {
66                m_assimp_flags = (
67                        aiProcess_CalcTangentSpace                              | 
68                        aiProcess_GenSmoothNormals                              | 
69                        aiProcess_JoinIdenticalVertices                 |   
70                        aiProcess_ImproveCacheLocality                  | 
71                        aiProcess_LimitBoneWeights                              | 
72                        aiProcess_RemoveRedundantMaterials      | 
73                        aiProcess_SplitLargeMeshes                              | 
74                        aiProcess_Triangulate                                   | 
75                        aiProcess_GenUVCoords                   | 
76                        aiProcess_SortByPType                   | 
77                        aiProcess_FindDegenerates               | 
78                        aiProcess_FindInvalidData               | 
79                        0 );
80        }
81}
82
83
84bool nv::assimp_loader::load( stream& source )
85{
86        load_assimp_library();
87        if ( m_scene != nullptr ) aiReleaseImport( reinterpret_cast<const aiScene*>( m_scene ) );
88        m_scene = nullptr;
89        m_mesh_count = 0;
90        NV_LOG_NOTICE( "AssImp loading file..." );
91        size_t size = source.size();
92        char* data  = new char[ size ];
93        source.read( data, size, 1 );
94        const aiScene* scene = aiImportFileFromMemory( data, size, m_assimp_flags, m_ext.data() );
95
96        if( !scene)
97        {
98                NV_LOG_ERROR( aiGetErrorString() );
99                return false;
100        }
101        m_scene      = scene;
102        m_mesh_count = scene->mNumMeshes;
103        NV_LOG_NOTICE( "Loading successfull" );
104        return true;
105}
106
107data_channel_set* nv::assimp_loader::release_mesh_data( size_t index, data_node_info& info )
108{
109        if ( index >= m_mesh_count ) return nullptr;
110        data_channel_set* result = data_channel_set_creator::create_set( 2 );
111        load_mesh_data( result, index, info );
112        return result;
113}
114void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index, data_node_info& info )
115{
116        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
117        const aiMesh*  mesh  = scene->mMeshes[ index ];
118
119        bool skinned = mesh->mNumBones > 0;
120
121        data_descriptor desc;
122        if ( skinned )
123                desc.initialize< assimp_skinned_vtx >();
124        else
125                desc.initialize< assimp_plain_vtx >();
126        data_channel_set_creator maccess( data );
127        const char* name = mesh->mName.data;
128        info.name = make_name( name );
129        info.parent_id = -1;
130        uint8*  cdata   = maccess.add_channel( desc, mesh->mNumVertices ).raw_data();
131        uint16* indices = reinterpret_cast<uint16*>( maccess.add_channel< index_u16 >( mesh->mNumFaces * 3 ).raw_data() );
132
133        if ( mesh->mTangents && mesh->mBitangents )
134                for ( unsigned int i = 0; i < mesh->mNumVertices; i++ )
135                {
136                        vec3 v = assimp_vec3_cast( mesh->mVertices[i] );
137                        vec3 n = math::normalize( assimp_vec3_cast( mesh->mNormals[i] ) );
138                        vec3 t = math::normalize( assimp_vec3_cast( mesh->mTangents[i] ) );
139                        vec3 b = math::normalize( assimp_vec3_cast( mesh->mBitangents[i] ) );
140                        vec2 s = assimp_st_cast( mesh->mTextureCoords[0][i] );
141
142                        vec3 t_i = math::normalize( t - n * math::dot( n, t ) );
143                        float det = ( math::dot( math::cross( n, t ), b ) );
144                        det = ( det < 0.0f ? -1.0f : 1.0f );
145                        nv::vec4 vt( t_i[0], t_i[1], t_i[2], det );
146                        if ( skinned )
147                                reinterpret_cast<assimp_skinned_vtx*>( cdata )[i] = assimp_skinned_vtx( v, s, n, vt );
148                        else
149                                reinterpret_cast<assimp_plain_vtx*>( cdata )[i] = assimp_plain_vtx( v, s, n, vt );
150                }
151
152        if ( skinned )
153        {
154                assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( cdata );
155                for (unsigned int m=0; m<mesh->mNumBones; m++)
156                {
157                        aiBone* bone  = mesh->mBones[m];
158                        for (unsigned int w=0; w<bone->mNumWeights; w++)
159                        {
160                                assimp_skinned_vtx& v = vtx[ bone->mWeights[w].mVertexId ];
161                                bool found = false;
162                                for ( int i = 0 ; i < 4; ++i )
163                                {
164                                        if ( v.boneweight[i] <= 0.0f )
165                                        {
166                                                v.boneindex[i]  = int( m );
167                                                v.boneweight[i] = bone->mWeights[w].mWeight;
168                                                found = true;
169                                                break;
170                                        }
171                                }
172                                NV_ASSERT( found, "Too many weights!" );
173                        }
174                }
175        }
176
177        for (unsigned int i=0; i<mesh->mNumFaces; i++)
178        {
179                const aiFace* face = &mesh->mFaces[i];
180                for (unsigned int j=0; j<face->mNumIndices; j++)
181                {
182                        indices[ i*3 + j ] = uint16( face->mIndices[j] );
183                }
184        }
185
186}
187
188nv::assimp_loader::~assimp_loader()
189{
190        if ( m_scene != nullptr ) aiReleaseImport( reinterpret_cast<const aiScene*>( m_scene ) );
191}
192
193bool nv::assimp_loader::load_bones( size_t index, array_ref< data_node_info > bones )
194{
195        if ( m_scene == nullptr ) return false;
196        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
197        const aiMesh*  mesh  = scene->mMeshes[ index ];
198
199        for (unsigned int m=0; m<mesh->mNumBones; m++)
200        {
201                aiBone* bone   = mesh->mBones[m];
202                mat4    offset = assimp_mat4_cast( bone->mOffsetMatrix );
203                const char* name = bone->mName.data;
204                bones[m].name = make_name( name );
205                bones[m].transform = offset;
206        }
207        return true;
208}
209
210void nv::assimp_loader::scene_report() const
211{
212        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
213        if ( scene == nullptr ) return;
214
215        NV_LOG_NOTICE( "------------------------" );
216        NV_LOG_NOTICE( "Texture   count - ", scene->mNumTextures );
217        NV_LOG_NOTICE( "Animation count - ", scene->mNumAnimations );
218        NV_LOG_NOTICE( "Material  count - ", scene->mNumMaterials );
219        NV_LOG_NOTICE( "Meshes    count - ", scene->mNumMeshes );
220        NV_LOG_NOTICE( "------------------------" );
221
222        aiNode* root = scene->mRootNode;
223        if (root)
224        {
225                NV_LOG_NOTICE( "Root node  - ", root->mName.data );
226                NV_LOG_NOTICE( "  meshes   - ", root->mNumMeshes );
227                NV_LOG_NOTICE( "  children - ", root->mNumChildren );
228        }
229        else
230        {
231                NV_LOG_NOTICE( "No root node!" );
232        }
233        NV_LOG_NOTICE( "------------------------" );
234
235        if ( scene->mNumMeshes > 0 )
236        {
237                for ( nv::uint32 mc = 0; mc < scene->mNumMeshes; mc++ )
238                {
239                        aiMesh* mesh = scene->mMeshes[mc];
240
241                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( static_cast<char*>( mesh->mName.data ) ) );
242                        NV_LOG_NOTICE( "  bones   - ", mesh->mNumBones );
243                        NV_LOG_NOTICE( "  uvs     - ", mesh->mNumUVComponents[0] );
244                        NV_LOG_NOTICE( "  verts   - ", mesh->mNumVertices );
245                        NV_LOG_NOTICE( "  faces   - ", mesh->mNumFaces );
246
247                        //                      NV_LOG_NOTICE(  "Bones:" );
248                        //                      for (unsigned int m=0; m<mesh->mNumBones; m++)
249                        //                      {
250                        //                              aiBone* bone  = mesh->mBones[m];
251                        //                              NV_LOG_NOTICE( bone->mName.C_Str() );
252                        //                      }
253                }
254        }
255        else
256        {
257                NV_LOG_NOTICE( "No meshes!" );
258        }
259        NV_LOG_NOTICE( "------------------------" );
260
261
262        //      if ( scene->mNumMaterials > 0 )
263        //      {
264        //              for (unsigned int m=0; m < scene->mNumMaterials; m++)
265        //              {
266        //                      int texIndex = 0;
267        //                      aiReturn texFound = aiReturn_SUCCESS;
268        //                      aiString path;  // filename
269        //                      while (texFound == aiReturn_SUCCESS)
270        //                      {
271        //                              texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path);
272        //                              NV_LOG_NOTICE( "  material - ", path.data );
273        //                              texIndex++;
274        //                      }
275        //              }
276        //      }
277        //      else
278        //      {
279        //              NV_LOG_NOTICE( "No materials" );
280        //      }
281        //      NV_LOG_NOTICE( "------------------------" );
282
283}
284
285data_node_list* nv::assimp_loader::release_merged_bones( data_channel_set* meshes )
286{
287        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
288        data_node_list* result = new data_node_list( make_name( "bones" ) );
289        hash_store< shash64, uint16 > names;
290        for ( unsigned int m = 0; m < m_mesh_count; ++m )
291        {
292                uint16 translate[MAX_BONES];
293                vector< data_node_info > bones;
294                const aiMesh*  mesh  = scene->mMeshes[ m ];
295                if ( mesh->mNumBones != 0 )
296                {
297                        bones.resize( mesh->mNumBones );
298                        NV_ASSERT( false, "parent ids for bones are not loaded!" );
299                        load_bones( m, bones );
300                        for ( unsigned int b = 0; b < mesh->mNumBones; ++b )
301                        {
302
303                                data_node_info bone = bones[b];
304                                auto iname = names.find( bone.name );
305                                if ( iname == names.end() )
306                                {
307                                        NV_ASSERT( result->size() < MAX_BONES, "Too many bones to merge!" );
308                                        uint16 index = uint16( result->size() );
309                                        result->append( bone );
310                                        names[ bone.name ] = index;
311                                        translate[b] = index;
312                                }
313                                else
314                                {
315                                        translate[b] = iname->second;
316                                }
317                        }
318                        if ( m > 0 && bones.size() > 0 )
319                        {
320                                data_channel_access< assimp_skinned_vtx > channel( const_cast< raw_data_channel* >( meshes[m].get_channel(0) ) );
321                                for ( unsigned v = 0; v < channel.size(); ++v )
322                                {
323                                        assimp_skinned_vtx& vertex = channel.data()[v];
324
325                                        for ( int i = 0 ; i < 4; ++i)
326                                        {
327                                                if ( vertex.boneweight[i] > 0.0f )
328                                                {
329                                                        vertex.boneindex[i] = int( translate[vertex.boneindex[i]] );
330                                                }
331                                        }
332                                }
333                        }
334                }       
335        }
336        //result->initialize();
337
338        return result;
339}
340
341mesh_nodes_data* nv::assimp_loader::release_mesh_nodes_data( size_t index /*= 0*/ )
342{
343        if ( m_scene == nullptr ) return nullptr;
344        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
345        if ( scene->mRootNode == nullptr || scene->mAnimations == nullptr || scene->mAnimations[index] == nullptr) return nullptr;
346
347        const aiNode*      root = scene->mRootNode;
348        const aiAnimation* anim = scene->mAnimations[index];
349
350        uint32 count = count_nodes( scene->mRootNode );
351
352        uint16 frame_rate     = static_cast<uint16>( anim->mTicksPerSecond );
353        uint16 duration       = static_cast<uint16>( anim->mDuration );
354
355        data_channel_set** temp  = new data_channel_set*[ count ];
356        data_node_info*    temp2 = new data_node_info[count];
357        array_ref< data_channel_set* > temp_ref( temp, count );
358        array_ref< data_node_info >    temp2_ref( temp2, count );
359        load_node( index, temp_ref, temp2_ref, root, 0, -1 );
360
361        mesh_nodes_data* result = new mesh_nodes_data( make_name( static_cast<const char*>( anim->mName.data ) ), frame_rate, duration );
362        for ( nv::uint32 i = 0; i < count; ++i )
363        {
364                result->append( temp_ref[i], temp2_ref[i] );
365        }
366        result->initialize();
367        delete temp;
368        delete temp2;
369        return result;
370}
371
372data_node_list* nv::assimp_loader::release_data_node_list( size_t index /*= 0 */ )
373{
374        int this_is_incorrect;
375        NV_ASSERT( false, "unimplemented!" );
376//      mesh_nodes_data* half_result = release_mesh_nodes_data( index );
377//      data_node_list* result = new data_node_list( half_result->get_name() );
378//      for ( auto node : *half_result )
379//              result->append( node->get_info() );
380//      delete half_result;
381//      return result;
382        return nullptr;
383}
384
385bool nv::assimp_loader::is_animated( size_t /*= 0 */ )
386{
387        int this_is_incorrect;
388        return false;
389}
390
391nv::uint32 nv::assimp_loader::count_nodes( const void* node ) const
392{
393        const aiNode* ainode = reinterpret_cast< const aiNode* >( node );
394        nv::uint32 count = 1;
395        for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
396        {
397                count += count_nodes( ainode->mChildren[i] );
398        }
399        return count;
400}
401
402nv::sint16 nv::assimp_loader::load_node( uint32 anim_id, array_ref< data_channel_set* > nodes, array_ref< data_node_info > infos, const void* vnode, sint16 this_id, sint16 parent_id )
403{
404        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
405        const aiNode*  node  = reinterpret_cast<const aiNode*>( vnode );
406        string_view name( static_cast< const char* >( node->mName.data ) );
407        const aiAnimation* anim  = scene->mAnimations[anim_id];
408        const aiNodeAnim*  anode = nullptr;
409
410        for ( unsigned i = 0 ; i < anim->mNumChannels ; i++ )
411        {
412                anode = anim->mChannels[i];
413                if ( string_view( static_cast< const char* >( anode->mNodeName.data ) ) == name ) break;
414                anode = nullptr;
415        }
416
417        nodes[ this_id ] = anode ? create_keys( anode ) : data_channel_set_creator::create_set( 0 );
418
419        infos[this_id].name      = make_name( name );
420        infos[this_id].parent_id = parent_id;
421        // This value is ignored by the create_transformed_keys, but needed by create_direct_keys!
422        // TODO: find a common solution!
423        //       This is bad because create_transformed_keys never uses node-transformations for
424        //       node's without keys
425        // TODO: this can probably be deleted
426        infos[this_id].transform = nv::assimp_mat4_cast( node->mTransformation );
427        if ( this_id == 0 ) infos[this_id].transform = mat4();
428
429        nv::sint16 next = this_id + 1;
430        for ( unsigned i = 0; i < node->mNumChildren; ++i )
431        {
432                next = load_node( anim_id, nodes, infos, node->mChildren[i], next, this_id );
433        }
434
435        return next;
436}
437
438data_channel_set* nv::assimp_loader::create_keys( const void* vnode )
439{
440        const aiNodeAnim* node = reinterpret_cast< const aiNodeAnim* >( vnode );
441        if ( node->mNumPositionKeys == 0 && node->mNumRotationKeys == 0 && node->mNumScalingKeys == 0 )
442        {
443                return data_channel_set_creator::create_set( 0 );
444        }
445       
446        data_channel_set* set = data_channel_set_creator::create_set( 2 );
447        data_channel_set_creator key_set( set );
448
449        assimp_key_p* pchannel = key_set.add_channel< assimp_key_p >( node->mNumPositionKeys ).data();
450        assimp_key_r* rchannel = key_set.add_channel< assimp_key_r >( node->mNumRotationKeys ).data();
451//      assimp_key_s* schannel = key_set.add_channel< assimp_key_s >( node->mNumScalingKeys ).data();
452
453        for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )
454        {
455                pchannel[np].time        = static_cast<float>( node->mPositionKeys[np].mTime );
456                pchannel[np].translation = assimp_vec3_cast(node->mPositionKeys[np].mValue);
457        }
458        for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
459        {
460                rchannel[np].time     = static_cast<float>( node->mRotationKeys[np].mTime );
461                rchannel[np].rotation = assimp_quat_cast(node->mRotationKeys[np].mValue );
462        }
463//      if ( node->mNumScalingKeys > 0 )
464//      {
465//              vec3 scale_vec0 = assimp_vec3_cast( node->mScalingKeys[0].mValue );
466//              float scale_value   = math::length( math::abs( scale_vec0 - vec3(1,1,1) ) );
467//              if ( node->mNumScalingKeys > 1 || scale_value > 0.001 )
468//              {
469//                      NV_LOG( nv::LOG_WARNING, "scale key significant!" );
470//                      for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
471//                      {
472//                              schannel[np].time  = (float)node->mScalingKeys[np].mTime;
473//                              schannel[np].scale = assimp_vec3_cast(node->mScalingKeys[np].mValue);
474//                      }
475//              }
476//              else
477//              {
478//                      schannel[0].time  = (float)node->mScalingKeys[0].mTime;
479//                      schannel[0].scale = assimp_vec3_cast(node->mScalingKeys[0].mValue);
480//              }
481//      }
482        return set;
483}
484
485// mesh_data_pack* nv::assimp_loader::release_mesh_data_pack()
486// {
487//      if ( m_scene == nullptr || m_mesh_count == 0 ) return nullptr;
488//      const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
489//      bool has_bones = false;
490//      data_channel_set* meshes = data_channel_set_creator::create_set_array( m_mesh_count, 2 );
491//      for ( size_t m = 0; m < m_mesh_count; ++m )
492//      {
493//              const aiMesh* mesh = scene->mMeshes[ m ];
494//              data_channel_set_creator( &meshes[m] ).set_name( make_name( static_cast<const char*>( mesh->mName.data ) ) );
495//              if ( mesh->mNumBones > 0 ) has_bones = true;
496//              load_mesh_data(&meshes[m],m);
497//      }
498//
499//      mesh_nodes_data* nodes = ( has_bones ? release_merged_bones( meshes ) : release_mesh_nodes_data(0) );
500//      return new mesh_data_pack( m_mesh_count, meshes, nodes );
501// }
502
503nv::size_t nv::assimp_loader::get_nodes_data_count() const
504{
505        if ( m_scene == nullptr ) return 0;
506        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
507        return scene->mNumAnimations;   
508}
509
510
Note: See TracBrowser for help on using the repository browser.