Changeset 482 for trunk/src/formats


Ignore:
Timestamp:
11/12/15 19:02:08 (10 years ago)
Author:
epyon
Message:
  • skeletal animation updated
Location:
trunk/src/formats
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/formats/assimp_loader.cc

    r480 r482  
    105105}
    106106
    107 data_channel_set* nv::assimp_loader::release_mesh_data( size_t index /*= 0 */ )
     107data_channel_set* nv::assimp_loader::release_mesh_data( size_t index, data_node_info& info )
    108108{
    109109        if ( index >= m_mesh_count ) return nullptr;
    110110        data_channel_set* result = data_channel_set_creator::create_set( 2 );
    111         load_mesh_data( result, index );
     111        load_mesh_data( result, index, info );
    112112        return result;
    113113}
    114 void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index )
     114void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index, data_node_info& info )
    115115{
    116116        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
    … …  
    126126        data_channel_set_creator maccess( data );
    127127        const char* name = mesh->mName.data;
    128         maccess.set_name( make_name( name ) );
     128        info.name = make_name( name );
     129        info.parent_id = -1;
    129130        uint8*  cdata   = maccess.add_channel( desc, mesh->mNumVertices ).raw_data();
    130131        uint16* indices = reinterpret_cast<uint16*>( maccess.add_channel< index_u16 >( mesh->mNumFaces * 3 ).raw_data() );
    … …  
    190191}
    191192
    192 bool nv::assimp_loader::load_bones( size_t index, array_ref< data_channel_set* > bones )
     193bool nv::assimp_loader::load_bones( size_t index, array_ref< data_node_info > bones )
    193194{
    194195        if ( m_scene == nullptr ) return false;
    … …  
    200201                aiBone* bone   = mesh->mBones[m];
    201202                mat4    offset = assimp_mat4_cast( bone->mOffsetMatrix );
    202                 bones[m] = data_channel_set_creator::create_set( 0 );
    203                 data_channel_set_creator access( bones[m] );
    204203                const char* name = bone->mName.data;
    205                 access.set_name( make_name( name ) );
    206                 access.set_transform( offset );
     204                bones[m].name = make_name( name );
     205                bones[m].transform = offset;
    207206        }
    208207        return true;
    … …  
    284283}
    285284
    286 mesh_nodes_data* nv::assimp_loader::release_merged_bones( data_channel_set* meshes )
    287 {
    288         const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
    289         mesh_nodes_data* result = new mesh_nodes_data( make_name( "bones" ) );
     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" ) );
    290289        hash_store< shash64, uint16 > names;
    291290        for ( unsigned int m = 0; m < m_mesh_count; ++m )
    292291        {
    293292                uint16 translate[MAX_BONES];
    294                 vector< data_channel_set* > bones;
     293                vector< data_node_info > bones;
    295294                const aiMesh*  mesh  = scene->mMeshes[ m ];
    296295                if ( mesh->mNumBones != 0 )
    297296                {
    298297                        bones.resize( mesh->mNumBones );
     298                        NV_ASSERT( false, "parent ids for bones are not loaded!" );
    299299                        load_bones( m, bones );
    300300                        for ( unsigned int b = 0; b < mesh->mNumBones; ++b )
    301301                        {
    302302
    303                                 data_channel_set* bone = bones[b];
    304                                 auto iname = names.find( bone->get_name() );
     303                                data_node_info bone = bones[b];
     304                                auto iname = names.find( bone.name );
    305305                                if ( iname == names.end() )
    306306                                {
    … …  
    308308                                        uint16 index = uint16( result->size() );
    309309                                        result->append( bone );
    310                                         names[ bone->get_name() ] = index;
     310                                        names[ bone.name ] = index;
    311311                                        translate[b] = index;
    312312                                }
    … …  
    334334                }       
    335335        }
    336         result->initialize();
     336        //result->initialize();
    337337
    338338        return result;
    … …  
    352352        uint16 frame_rate     = static_cast<uint16>( anim->mTicksPerSecond );
    353353        uint16 duration       = static_cast<uint16>( anim->mDuration );
    354         bool   flat           = false;
    355 
    356         data_channel_set** temp = new data_channel_set*[ count ];
     354
     355        data_channel_set** temp  = new data_channel_set*[ count ];
     356        data_node_info*    temp2 = new data_node_info[count];
    357357        array_ref< data_channel_set* > temp_ref( temp, count );
    358         load_node( index, temp_ref, root, 0, -1 );
    359 
    360         mesh_nodes_data* result = new mesh_nodes_data( make_name( static_cast<const char*>( anim->mName.data ) ), frame_rate, duration, flat );
    361         for ( auto set : temp_ref )
    362         {
    363                 result->append( set );
     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] );
    364365        }
    365366        result->initialize();
    366367        delete temp;
     368        delete temp2;
    367369        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;
    368389}
    369390
    … …  
    379400}
    380401
    381 nv::sint16 nv::assimp_loader::load_node( uint32 anim_id, array_ref< data_channel_set* > nodes, const void* vnode, sint16 this_id, sint16 parent_id )
     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 )
    382403{
    383404        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
    … …  
    396417        nodes[ this_id ] = anode ? create_keys( anode ) : data_channel_set_creator::create_set( 0 );
    397418
    398         data_channel_set_creator access( nodes[this_id] );
    399         access.set_name( make_name( name ) );
    400         access.set_parent_id( parent_id );
     419        infos[this_id].name      = make_name( name );
     420        infos[this_id].parent_id = parent_id;
    401421        // This value is ignored by the create_transformed_keys, but needed by create_direct_keys!
    402422        // TODO: find a common solution!
    403423        //       This is bad because create_transformed_keys never uses node-transformations for
    404424        //       node's without keys
    405         access.set_transform( nv::assimp_mat4_cast( node->mTransformation ) );
    406         if ( this_id == 0 ) access.set_transform( mat4() );
     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();
    407428
    408429        nv::sint16 next = this_id + 1;
    409430        for ( unsigned i = 0; i < node->mNumChildren; ++i )
    410431        {
    411                 next = load_node( anim_id, nodes, node->mChildren[i], next, this_id );
     432                next = load_node( anim_id, nodes, infos, node->mChildren[i], next, this_id );
    412433        }
    413434

  • trunk/src/formats/nmd_loader.cc

    r480 r482  
    3737{
    3838        data_channel_set* mesh = data_channel_set_creator::create_set( e.children );
    39         load_channel_set( source, mesh, e );
     39        data_node_info info;
     40        load_channel_set( source, mesh, info, e );
    4041//      m_mesh_names.push_back( e.name );
     42        m_infos.push_back( info );
    4143        m_meshes.push_back( mesh );
    4244        return true;
    4345}
    4446
    45 data_channel_set* nv::nmd_loader::release_mesh_data( size_t index )
     47data_channel_set* nv::nmd_loader::release_mesh_data( size_t index, data_node_info& info )
    4648{
    4749        data_channel_set* result = m_meshes[ index ];
     50        info = m_infos[ index ];
    4851        m_meshes[ index ] = nullptr;
    4952        return result;
    … …  
    5457        for ( auto mesh : m_meshes ) if ( mesh ) delete mesh;
    5558        if ( m_node_data ) delete m_node_data;
     59        if ( m_bone_data ) delete m_bone_data;
    5660        m_meshes.clear();
    5761
    58         m_node_data  = nullptr;
     62        m_node_data = nullptr;
     63        m_bone_data = nullptr;
    5964}
    6065
    … …  
    8590        nmd_animation_header animation_header;
    8691        source.read( &animation_header, sizeof( animation_header ), 1 );
    87         m_node_data = new mesh_nodes_data( e.name, animation_header.frame_rate, animation_header.frame_count, animation_header.flat );
     92        m_node_data = new mesh_nodes_data( e.name, animation_header.frame_rate, animation_header.frame_count );
     93        m_bone_data = new data_node_list( e.name );
    8894        for ( uint32 i = 0; i < e.children; ++i )
    8995        {
    … …  
    9399                NV_ASSERT( element_header.type == nmd_type::NODE, "NODE expected!" );
    94100                data_channel_set* set = data_channel_set_creator::create_set( element_header.children );
    95                 load_channel_set( source, set, element_header );
    96                 m_node_data->append( set );
     101                data_node_info info;
     102                load_channel_set( source, set, info, element_header );
     103                m_bone_data->append( info );
     104                m_node_data->append( set, info );
    97105        }
    98106        m_node_data->initialize();
    … …  
    110118}
    111119
    112 bool nv::nmd_loader::load_channel_set( stream& source, data_channel_set* channel_set, const nmd_element_header& e )
     120bool nv::nmd_loader::load_channel_set( stream& source, data_channel_set* channel_set, data_node_info& info, const nmd_element_header& e )
    113121{
    114122        data_channel_set_creator kaccess( channel_set );
    … …  
    117125                load_channel( source, channel_set );
    118126        }
    119         data_channel_set_creator access( channel_set );
    120         access.set_name( e.name );
    121         access.set_parent_id( e.parent_id );
    122         access.set_transform( e.transform );
     127        info.name = e.name;
     128        info.parent_id = e.parent_id;
     129        info.transform = e.transform;
    123130        return true;
    124131}
    … …  
    126133mesh_nodes_data* nv::nmd_loader::release_mesh_nodes_data( size_t )
    127134{
    128         if ( m_node_data )
    129         {
    130                 mesh_nodes_data* result = m_node_data;
    131                 m_node_data = nullptr;
    132                 return result;
    133         }
    134         return nullptr;
     135        mesh_nodes_data* result = m_node_data;
     136        m_node_data = nullptr;
     137        return result;
     138}
     139
     140data_node_list* nv::nmd_loader::release_data_node_list( size_t )
     141{
     142        data_node_list* result = m_bone_data;
     143        m_bone_data = nullptr;
     144        return result;
     145}
     146
     147bool nv::nmd_loader::is_animated( size_t /*= 0 */ )
     148{
     149        if ( !m_node_data ) return false;
     150        return m_node_data->is_animated();
    135151}
    136152
    … …  
    150166}
    151167
    152 void nv::nmd_dump_element( stream& stream_out, const data_channel_set& data, nmd_type type )
     168void nv::nmd_dump_element( stream& stream_out, const data_channel_set& data, const data_node_info& info, nmd_type type )
    153169{
    154170        uint32 size = 0;
    … …  
    163179        eheader.children   = static_cast<uint16>( data.size() );
    164180        eheader.size       = size;
    165         eheader.name       = data.get_name();
    166         eheader.transform  = data.get_transform();
    167         eheader.parent_id  = data.get_parent_id();
     181        eheader.name       = info.name;
     182        eheader.transform  = info.transform;
     183        eheader.parent_id  = info.parent_id;
    168184        eheader.attributes = 0;
    169185        stream_out.write( &eheader, sizeof( eheader ), 1 );
    … …  
    205221        aheader.frame_rate  = nodes.get_fps();
    206222        aheader.frame_count = nodes.get_frame_count();
    207         aheader.flat = nodes.is_flat();
     223        aheader.unused      = false;
    208224        stream_out.write( &aheader, sizeof( aheader ), 1 );
    209225
     226        for ( uint32 i = 0; i < nodes.size(); ++i )
     227        {
     228                nmd_dump_element( stream_out, *nodes[i], nodes.get_info(i), nv::nmd_type::NODE );
     229        }
     230}
     231
     232void nv::nmd_dump_bones( stream& stream_out, const data_node_list& nodes )
     233{
     234        uint32 total = sizeof( nmd_animation_header );
    210235        for ( auto node : nodes )
    211236        {
    212                 nmd_dump_element( stream_out, *node, nv::nmd_type::NODE );
     237                total += sizeof( nmd_element_header );
     238        }
     239
     240        nmd_element_header header;
     241        header.type = nmd_type::ANIMATION;
     242        header.children = static_cast<uint16>( nodes.size() );
     243        header.size = total;
     244        header.name = nodes.get_name();
     245        header.transform = mat4();
     246        header.parent_id = -1;
     247        header.attributes = 0;
     248
     249        stream_out.write( &header, sizeof( header ), 1 );
     250
     251        nmd_animation_header aheader;
     252        aheader.frame_rate = 0;
     253        aheader.frame_count = 0;
     254        aheader.unused = false;
     255        stream_out.write( &aheader, sizeof( aheader ), 1 );
     256
     257        for ( auto node : nodes )
     258        {
     259                nmd_element_header eheader;
     260                eheader.type = nv::nmd_type::NODE;
     261                eheader.children = 0;
     262                eheader.size = 0;
     263                eheader.name = node.name;
     264                eheader.transform = node.transform;
     265                eheader.parent_id = node.parent_id;
     266                eheader.attributes = 0;
     267                stream_out.write( &eheader, sizeof( eheader ), 1 );
    213268        }
    214269}
    … …  
    227282}
    228283
    229 void nv::nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, const mesh_nodes_data* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ )
     284void nv::nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, array_view< data_node_info > infos, const mesh_nodes_data* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ )
    230285{
    231286        uint32 elements = ( strings ? 1 : 0 ) // +1 string array
    … …  
    237292        {
    238293                NV_ASSERT( meshes[i], "mesh is null!" );
    239                 nmd_dump_element( stream_out, *meshes[i], nv::nmd_type::MESH );
     294                nmd_dump_element( stream_out, *meshes[i], infos[i], nv::nmd_type::MESH );
    240295        }
    241296
    … …  
    243298        {
    244299                nmd_dump_nodes( stream_out, *nodes );
     300        }
     301
     302        if ( strings )
     303        {
     304                nmd_dump_strings( stream_out, *strings );
     305        }
     306}
     307
     308void nv::nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, array_view< data_node_info > infos, const nv::data_node_list* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ )
     309{
     310        uint32 elements = ( strings ? 1 : 0 ) // +1 string array
     311                + meshes.size() // meshes
     312                + ( nodes && nodes->size() > 0 ? 1 : 0 ); // nodes
     313        nmd_dump_header( stream_out, elements, name );
     314
     315        for ( uint32 i = 0; i < meshes.size(); ++i )
     316        {
     317                NV_ASSERT( meshes[i], "mesh is null!" );
     318                nmd_dump_element( stream_out, *meshes[i], infos[i], nv::nmd_type::MESH );
     319        }
     320
     321        if ( nodes && nodes->size() > 0 )
     322        {
     323                nmd_dump_bones( stream_out, *nodes );
    245324        }
    246325

  • trunk/src/formats/obj_loader.cc

    r480 r482  
    327327       
    328328                data_channel_set* result = data_channel_set_creator::create_set( 1 );
    329                 data_channel_set_creator raccess( result );
    330                 raccess.set_name( make_name( reader->name ) );
    331                 uint8* rdata = raccess.add_channel( m_descriptor, reader->size * 3 ).raw_data();
     329
     330                uint8* rdata = data_channel_set_creator(result).add_channel( m_descriptor, reader->size * 3 ).raw_data();
    332331
    333332                if ( reader->raw_size() > 0 )
    … …  
    335334                        raw_copy_n( reader->raw_pointer(), reader->raw_size(), rdata );
    336335                }
    337 
     336                data_node_info info;
     337                info.name = make_name( reader->name );
     338                info.parent_id = -1;
     339                m_infos.push_back( info );
    338340                m_meshes.push_back( result );
    339341
    … …  
    345347}
    346348
    347 data_channel_set* nv::obj_loader::release_mesh_data( size_t index )
     349data_channel_set* nv::obj_loader::release_mesh_data( size_t index, data_node_info& info )
    348350{
    349351        data_channel_set* result = m_meshes[ index ];
     352        info = m_infos[index];
    350353        m_meshes[ index ] = nullptr;
    351354        return result;
Note: See TracChangeset for help on using the changeset viewer.