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

Last change on this file since 416 was 416, checked in by epyon, 10 years ago
  • mesh_data and key_data are data_channel_set (WIP)
  • massive cleanup of privacy in data_channels
File size: 15.3 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/unordered_map.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( const std::string& a_ext, uint32 a_assimp_flags /*= 0 */ )
60        : 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.c_str() );
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 /*= 0 */ )
108{
109        if ( index >= m_mesh_count ) return nullptr;
110        data_channel_set* result = data_channel_set_creator::create( 2 );
111        load_mesh_data( result, index );
112        return result;
113}
114void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index )
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        raw_data_channel_creator channel( desc, mesh->mNumVertices );
127        uint8* cdata = channel.raw_data();
128
129        if ( mesh->mTangents && mesh->mBitangents )
130                for ( unsigned int i = 0; i < mesh->mNumVertices; i++ )
131                {
132                        vec3 v = assimp_vec3_cast( mesh->mVertices[i] );
133                        vec3 n = glm::normalize( assimp_vec3_cast( mesh->mNormals[i] ) );
134                        vec3 t = glm::normalize( assimp_vec3_cast( mesh->mTangents[i] ) );
135                        vec3 b = glm::normalize( assimp_vec3_cast( mesh->mBitangents[i] ) );
136                        vec2 s = assimp_st_cast( mesh->mTextureCoords[0][i] );
137
138                        glm::vec3 t_i = glm::normalize( t - n * glm::dot( n, t ) );
139                        float det = ( glm::dot( glm::cross( n, t ), b ) );
140                        det = ( det < 0.0f ? -1.0f : 1.0f );
141                        nv::vec4 vt( t_i[0], t_i[1], t_i[2], det );
142                        if ( skinned )
143                                reinterpret_cast<assimp_skinned_vtx*>( cdata )[i] = assimp_skinned_vtx( v, s, n, vt );
144                        else
145                                reinterpret_cast<assimp_plain_vtx*>( cdata )[i] = assimp_plain_vtx( v, s, n, vt );
146                }
147
148        if ( skinned )
149        {
150                assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( cdata );
151                for (unsigned int m=0; m<mesh->mNumBones; m++)
152                {
153                        aiBone* bone  = mesh->mBones[m];
154                        for (unsigned int w=0; w<bone->mNumWeights; w++)
155                        {
156                                assimp_skinned_vtx& v = vtx[ bone->mWeights[w].mVertexId ];
157                                bool found = false;
158                                for ( int i = 0 ; i < 4; ++i )
159                                {
160                                        if ( v.boneweight[i] <= 0.0f )
161                                        {
162                                                v.boneindex[i]  = int( m );
163                                                v.boneweight[i] = bone->mWeights[w].mWeight;
164                                                found = true;
165                                                break;
166                                        }
167                                }
168                                NV_ASSERT( found, "Too many weights!" );
169                        }
170                }
171        }
172
173        data_channel_creator< index_u16 > ichannel( mesh->mNumFaces * 3 );
174        uint16* indices = reinterpret_cast<uint16*>( ichannel.raw_data() );
175        for (unsigned int i=0; i<mesh->mNumFaces; i++)
176        {
177                const aiFace* face = &mesh->mFaces[i];
178                for (unsigned int j=0; j<face->mNumIndices; j++)
179                {
180                        indices[ i*3 + j ] = uint16( face->mIndices[j] );
181                }
182        }
183
184        data_channel_set_creator maccess( data );
185        maccess.set_name( mesh->mName.data );
186        maccess.add_channel( channel.release() );
187        maccess.add_channel( ichannel.release() );
188}
189
190nv::assimp_loader::~assimp_loader()
191{
192        if ( m_scene != nullptr ) aiReleaseImport( reinterpret_cast<const aiScene*>( m_scene ) );
193}
194
195bool nv::assimp_loader::load_bones( size_t index, array_ref< mesh_node_data > bones )
196{
197        if ( m_scene == nullptr ) return false;
198        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
199        const aiMesh*  mesh  = scene->mMeshes[ index ];
200
201        for (unsigned int m=0; m<mesh->mNumBones; m++)
202        {
203                aiBone* bone   = mesh->mBones[m];
204                mat4    offset = assimp_mat4_cast( bone->mOffsetMatrix );
205                bones[m].name = bone->mName.data;
206                bones[m].data = nullptr;
207                bones[m].parent_id = -1;
208                bones[m].target_id = -1;
209                bones[m].transform = offset;
210        }
211        return true;
212}
213
214void nv::assimp_loader::scene_report() const
215{
216        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
217        if ( scene == nullptr ) return;
218
219        NV_LOG_NOTICE( "------------------------" );
220        NV_LOG_NOTICE( "Texture   count - ", scene->mNumTextures );
221        NV_LOG_NOTICE( "Animation count - ", scene->mNumAnimations );
222        NV_LOG_NOTICE( "Material  count - ", scene->mNumMaterials );
223        NV_LOG_NOTICE( "Meshes    count - ", scene->mNumMeshes );
224        NV_LOG_NOTICE( "------------------------" );
225
226        aiNode* root = scene->mRootNode;
227        if (root)
228        {
229                NV_LOG_NOTICE( "Root node  - ", root->mName.data );
230                NV_LOG_NOTICE( "  meshes   - ", root->mNumMeshes );
231                NV_LOG_NOTICE( "  children - ", root->mNumChildren );
232        }
233        else
234        {
235                NV_LOG_NOTICE( "No root node!" );
236        }
237        NV_LOG_NOTICE( "------------------------" );
238
239        if ( scene->mNumMeshes > 0 )
240        {
241                for ( nv::uint32 mc = 0; mc < scene->mNumMeshes; mc++ )
242                {
243                        aiMesh* mesh = scene->mMeshes[mc];
244
245                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( static_cast<char*>( mesh->mName.data ) ) );
246                        NV_LOG_NOTICE( "  bones   - ", mesh->mNumBones );
247                        NV_LOG_NOTICE( "  uvs     - ", mesh->mNumUVComponents[0] );
248                        NV_LOG_NOTICE( "  verts   - ", mesh->mNumVertices );
249                        NV_LOG_NOTICE( "  faces   - ", mesh->mNumFaces );
250
251                        //                      NV_LOG_NOTICE(  "Bones:" );
252                        //                      for (unsigned int m=0; m<mesh->mNumBones; m++)
253                        //                      {
254                        //                              aiBone* bone  = mesh->mBones[m];
255                        //                              NV_LOG_NOTICE( bone->mName.C_Str() );
256                        //                      }
257                }
258        }
259        else
260        {
261                NV_LOG_NOTICE( "No meshes!" );
262        }
263        NV_LOG_NOTICE( "------------------------" );
264
265
266        //      if ( scene->mNumMaterials > 0 )
267        //      {
268        //              for (unsigned int m=0; m < scene->mNumMaterials; m++)
269        //              {
270        //                      int texIndex = 0;
271        //                      aiReturn texFound = aiReturn_SUCCESS;
272        //                      aiString path;  // filename
273        //                      while (texFound == aiReturn_SUCCESS)
274        //                      {
275        //                              texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path);
276        //                              NV_LOG_NOTICE( "  material - ", path.data );
277        //                              texIndex++;
278        //                      }
279        //              }
280        //      }
281        //      else
282        //      {
283        //              NV_LOG_NOTICE( "No materials" );
284        //      }
285        //      NV_LOG_NOTICE( "------------------------" );
286
287}
288
289mesh_nodes_data* nv::assimp_loader::release_merged_bones( data_channel_set* meshes )
290{
291        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
292        vector< mesh_node_data > final_bones;
293        unordered_map< std::string, uint16 > names;
294        for ( unsigned int m = 0; m < m_mesh_count; ++m )
295        {
296                uint16 translate[MAX_BONES];
297                vector< mesh_node_data > bones;
298                const aiMesh*  mesh  = scene->mMeshes[ m ];
299                if ( mesh->mNumBones != 0 )
300                {
301                        bones.resize( mesh->mNumBones );
302                        load_bones( m, bones );
303                        for ( unsigned int b = 0; b < mesh->mNumBones; ++b )
304                        {
305
306                                mesh_node_data& bone = bones[b];
307                                auto iname = names.find( bone.name );
308                                if ( iname == names.end() )
309                                {
310                                        NV_ASSERT( final_bones.size() < MAX_BONES, "Too many bones to merge!" );
311                                        uint16 index = uint16( final_bones.size() );
312                                        final_bones.push_back( bone );
313                                        names[ bone.name ] = index;
314                                        translate[b] = index;
315                                }
316                                else
317                                {
318                                        translate[b] = iname->second;
319                                }
320                        }
321                        if ( m > 0 && bones.size() > 0 )
322                        {
323                                data_channel_creator< assimp_skinned_vtx > channel( const_cast< raw_data_channel* >( meshes[m].get_channel(0) ) );
324                                for ( unsigned v = 0; v < channel.size(); ++v )
325                                {
326                                        assimp_skinned_vtx& vertex = channel.data()[v];
327
328                                        for ( int i = 0 ; i < 4; ++i)
329                                        {
330                                                if ( vertex.boneweight[i] > 0.0f )
331                                                {
332                                                        vertex.boneindex[i] = int( translate[vertex.boneindex[i]] );
333                                                }
334                                        }
335                                }
336                        }
337                }       
338        }
339        mesh_node_data* bones = new mesh_node_data[ final_bones.size() ];
340        raw_copy( final_bones.begin(), final_bones.end(), bones );
341        return new mesh_nodes_data( "bones", final_bones.size(), bones );
342}
343
344mesh_nodes_data* nv::assimp_loader::release_mesh_nodes_data( size_t index /*= 0*/ )
345{
346        if ( m_scene == nullptr ) return nullptr;
347        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
348        if ( scene->mRootNode == nullptr || scene->mAnimations == nullptr || scene->mAnimations[index] == nullptr) return nullptr;
349
350        const aiNode*      root = scene->mRootNode;
351        const aiAnimation* anim = scene->mAnimations[index];
352
353        uint32 count = count_nodes( scene->mRootNode );
354        mesh_node_data* data    = new mesh_node_data[count];
355
356        uint16 frame_rate     = static_cast<uint16>( anim->mTicksPerSecond );
357        float  duration       = static_cast<float>( anim->mDuration );
358        bool   flat           = false;
359
360        load_node( index, data, root, 0, -1 );
361
362        return new mesh_nodes_data( anim->mName.data, count, data, frame_rate, duration, flat );
363}
364
365nv::uint32 nv::assimp_loader::count_nodes( const void* node ) const
366{
367        const aiNode* ainode = reinterpret_cast< const aiNode* >( node );
368        nv::uint32 count = 1;
369        for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
370        {
371                count += count_nodes( ainode->mChildren[i] );
372        }
373        return count;
374}
375
376nv::sint16 nv::assimp_loader::load_node( uint32 anim_id, mesh_node_data* nodes, const void* vnode, sint16 this_id, sint16 parent_id )
377{
378        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
379        const aiNode*  node  = reinterpret_cast<const aiNode*>( vnode );
380        std::string name( node->mName.data );
381        const aiAnimation* anim  = scene->mAnimations[anim_id];
382        const aiNodeAnim*  anode = nullptr;
383
384        for ( unsigned i = 0 ; i < anim->mNumChannels ; i++ )
385        {
386                anode = anim->mChannels[i];
387                if ( std::string( anode->mNodeName.data ) == name ) break;
388                anode = nullptr;
389        }
390
391        mesh_node_data& a_data = nodes[ this_id ];
392
393        a_data.name      = name;
394        a_data.target_id = -1;
395        a_data.parent_id = parent_id;
396        // This value is ignored by the create_transformed_keys, but needed by create_direct_keys!
397        // TODO: find a common solution!
398        //       This is bad because create_transformed_keys never uses node-transformations for
399        //       node's without keys
400        a_data.transform = nv::assimp_mat4_cast( node->mTransformation );
401        if (this_id == 0)
402                a_data.transform = mat4();
403        a_data.data = nullptr;
404
405        if (anode) create_keys( &a_data, anode );
406
407        nv::sint16 next = this_id + 1;
408        for ( unsigned i = 0; i < node->mNumChildren; ++i )
409        {
410                next = load_node( anim_id, nodes, node->mChildren[i], next, this_id );
411        }
412
413        return next;
414}
415
416void nv::assimp_loader::create_keys( mesh_node_data* data, const void* vnode )
417{
418        const aiNodeAnim* node = reinterpret_cast< const aiNodeAnim* >( vnode );
419        if ( node->mNumPositionKeys == 0 && node->mNumRotationKeys == 0 && node->mNumScalingKeys == 0 )
420        {
421                return;
422        }
423
424        data->data = new key_data;
425        data_channel_creator< assimp_key_p > pchannel_creator( node->mNumPositionKeys );
426        data_channel_creator< assimp_key_r > rchannel_creator( node->mNumRotationKeys );
427//      data_channel_creator< assimp_key_s > schannel_creator( node->mNumScalingKeys );
428
429        assimp_key_p* pchannel = pchannel_creator.data();
430        assimp_key_r* rchannel = rchannel_creator.data();
431        //assimp_key_s* schannel = ((assimp_key_s*)(raw_schannel->data));
432
433        for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )
434        {
435                pchannel[np].time        = static_cast<float>( node->mPositionKeys[np].mTime );
436                pchannel[np].translation = assimp_vec3_cast(node->mPositionKeys[np].mValue);
437        }
438        for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
439        {
440                rchannel[np].time     = static_cast<float>( node->mRotationKeys[np].mTime );
441                rchannel[np].rotation = assimp_quat_cast(node->mRotationKeys[np].mValue );
442        }
443//      if ( node->mNumScalingKeys > 0 )
444//      {
445//              nv::vec3 scale_vec0 = assimp_vec3_cast( node->mScalingKeys[0].mValue );
446//              float scale_value   = glm::length( glm::abs( scale_vec0 - nv::vec3(1,1,1) ) );
447//              if ( node->mNumScalingKeys > 1 || scale_value > 0.001 )
448//              {
449//                      NV_LOG( nv::LOG_WARNING, "scale key significant!" );
450//                      for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
451//                      {
452//                              schannel[np].time  = (float)node->mScalingKeys[np].mTime;
453//                              schannel[np].scale = assimp_vec3_cast(node->mScalingKeys[np].mValue);
454//                      }
455//              }
456//              else
457//              {
458//                      schannel[0].time  = (float)node->mScalingKeys[0].mTime;
459//                      schannel[0].scale = assimp_vec3_cast(node->mScalingKeys[0].mValue);
460//              }
461//      }
462        data->data->add_key_channel( pchannel_creator.release() );
463        data->data->add_key_channel( rchannel_creator.release() );
464//      data->data->add_key_channel( schannel_creator.release() );
465}
466
467mesh_data_pack* nv::assimp_loader::release_mesh_data_pack()
468{
469        if ( m_scene == nullptr || m_mesh_count == 0 ) return nullptr;
470        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
471        bool has_bones = false;
472        data_channel_set* meshes = data_channel_set_creator::create_array( m_mesh_count, 2 );
473        for ( size_t m = 0; m < m_mesh_count; ++m )
474        {
475                const aiMesh* mesh = scene->mMeshes[ m ];
476                data_channel_set_creator( &meshes[m] ).set_name( mesh->mName.data );
477                if ( mesh->mNumBones > 0 ) has_bones = true;
478                load_mesh_data(&meshes[m],m);
479        }
480
481        mesh_nodes_data* nodes = ( has_bones ? release_merged_bones( meshes ) : release_mesh_nodes_data(0) );
482        return new mesh_data_pack( m_mesh_count, meshes, nodes );
483}
484
485nv::size_t nv::assimp_loader::get_nodes_data_count() const
486{
487        if ( m_scene == nullptr ) return 0;
488        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
489        return scene->mNumAnimations;   
490}
491
492
Note: See TracBrowser for help on using the repository browser.