Changeset 482 for trunk/src


Ignore:
Timestamp:
11/12/15 19:02:08 (10 years ago)
Author:
epyon
Message:
  • skeletal animation updated
Location:
trunk/src
Files:
5 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;

  • trunk/src/gfx/mesh_creator.cc

    r480 r482  
    1313struct nv_key_transform { nv::transform tform; };
    1414
    15 void nv::mesh_nodes_creator::pre_transform_keys()
    16 {
    17         if ( m_data->m_flat ) return;
    18         merge_keys();
    19         uint16 max_frames = 0;
    20 
    21         nv::vector< sint16 > ids;
    22         {
    23                 // TODO: simplify this shit!
    24                 // The complexity here is that we cannot pre-transform in any order
    25                 // as the bones depend on previous bones, but ARE NOT IN ORDER
    26                 //
    27                 // Either rewrite this a lot nicer, or sort the bones on creation
    28                 // by tree-order.
    29 
    30                 ids.reserve( m_data->m_data.size() );
    31                 {
    32                         nv::vector< sint16 > ids_next;
    33                         ids_next.reserve( m_data->m_data.size() );
    34                         ids_next.push_back( -1 );
    35                         while ( !ids_next.empty() )
    36                         {
    37                                 sint16 pid = ids_next.back();
    38                                 ids_next.pop_back();
    39                                 for ( sint16 i = 0; i < sint16(m_data->m_data.size()); ++i )
    40                                         if ( m_data->m_data[i]->get_parent_id() == pid )
    41                                         {
    42                                                 sint16* it = nv::find( ids.begin(), ids.end(), i );
    43                                                 if ( it == ids.end() )
    44                                                 {
    45                                                         ids.push_back( i );
    46                                                         ids_next.push_back( i );
    47                                                 }
    48                                         }
    49                         }
    50                 }
    51 
    52                 if ( ids.size() != m_data->m_data.size() )
    53                 {
    54                         NV_LOG_WARNING( "Bad skeleton!" );
    55                 }
    56         }
    57 
    58         NV_LOG_DEBUG( "ID/PID" );
    59         for ( auto id : ids )
    60         {
    61                 data_channel_set* keys = m_data->m_data[id];
    62                 sint16 parent_id = keys->get_parent_id();
    63                 NV_LOG_DEBUG( "Id : ", id, " PID", parent_id );
    64                 data_channel_set* pkeys = ( parent_id != -1 ? m_data->m_data[parent_id] : nullptr );
    65                 size_t count     = ( keys ? keys->get_channel_size(0) : 0 );
    66                 size_t pcount    = ( pkeys ? pkeys->get_channel_size(0) : 0 );
    67                 max_frames = nv::max<uint16>( uint16( count ), max_frames );
    68                 if ( pkeys && pkeys->size() > 0 && keys && keys->size() > 0 )
    69                 {
    70                         data_channel_access< nv_key_transform > channel_creator( keys, 0 );
    71 
    72                         nv_key_transform* channel = channel_creator.data();
    73                         const nv_key_transform* pchannel = pkeys->get_channel(0)->data_cast< nv_key_transform >();
    74                         for ( unsigned n = 0; n < count; ++n )
    75                         {
    76                                 channel[n].tform = pchannel[ nv::min( n, pcount-1 ) ].tform * channel[n].tform;
    77                         }
    78                 }
    79         }
    80 
    81         // DAE pre_transform hack
    82         if ( m_data->m_frame_rate == 1 )
    83         {
    84                 m_data->m_frame_rate  = 32;
    85                 m_data->m_frame_count = max_frames;
    86         }
    87 
    88         m_data->m_flat = true;
    89 }
    90 
    91 
    9215void nv::mesh_nodes_creator::merge_keys()
    9316{
    … …  
    11033                        data_channel_set* new_keys = data_channel_set_creator::create_set( 1 );
    11134                        data_channel_set_creator nk_access( new_keys );
    112                         nk_access.set_name( old_keys->get_name() );
    113                         nk_access.set_parent_id( old_keys->get_parent_id() );
    114                         nk_access.set_transform( old_keys->get_transform() );
    11535                        data_channel_access< nv_key_transform > kt_channel( nk_access.add_channel<nv_key_transform>( max_keys ) );
    11636
    … …  
    14565        for ( auto node : m_data->m_data )
    14666        {
    147                 node->m_transform = pre_transform * node->m_transform * post_transform;
    148 
    14967                for ( size_t c = 0; c < node->size(); ++c )
    15068                {
    … …  
    15876        }
    15977}
     78
     79void nv::data_node_list_creator::transform( float scale, const mat3& r33 )
     80{
     81        mat3 ri33 = math::inverse( r33 );
     82        mat4 pre_transform( scale * r33 );
     83        mat4 post_transform( 1.f / scale * ri33 );
     84
     85        for ( auto& node : m_data->m_data )
     86                node.transform = pre_transform * node.transform * post_transform;
     87}
     88
    16089
    16190void nv::mesh_data_creator::transform( float scale, const mat3& r33 )
    … …  
    209138        nv::vec4 tangent;
    210139};
     140
    211141
    212142void nv::mesh_data_creator::flip_normals()
    … …  
    434364}
    435365
     366
    436367template < typename T >
    437368static inline void swap_culling_impl( nv::raw_data_channel* index_channel )
    … …  
    650581        initialize();
    651582}
    652 

  • trunk/src/gfx/skeleton_instance.cc

    r481 r482  
    99#include "nv/core/profiler.hh"
    1010
    11 void nv::skeleton_binding::prepare( const mesh_nodes_data* node_data, const mesh_nodes_data* bone_data )
     11void nv::skeleton_binding::prepare( const mesh_nodes_data* node_data, const data_node_list& bone_data )
    1212{
    1313        if ( m_indices.empty() )
    … …  
    1616                hash_store< shash64, uint16 > bone_names;
    1717                m_indices.resize( node_data->size() );
    18                
    19                 for ( nv::uint16 bi = 0; bi < bone_data->size(); ++bi )
    20                 {
    21                         const data_channel_set* bone = ( *bone_data )[bi];
    22                         bone_names[bone->get_name()] = bi;
    23                 }
     18
     19                for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
     20                        bone_names[bone_data[bi].name] = bi;
    2421
    2522                for ( uint32 n = 0; n < node_data->size(); ++n )
    2623                {
    27                         const data_channel_set* node = ( *node_data )[n];
    2824                        sint16 bone_id = -1;
    29 
    30                         auto bi = bone_names.find( node->get_name() );
     25                        auto bi = bone_names.find( node_data->get_info( n ).name );
    3126                        if ( bi != bone_names.end() )
    3227                        {
    … …  
    3631
    3732                }
    38                 m_bone_count = bone_data->size();
     33                m_bone_count = bone_data.size();
    3934        }
    4035
    … …  
    4843                        }
    4944        }
    50 
    51 
    5245}
    53 
    54 // void nv::skeleton_instance::animate_( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame )
    55 // {
    56 //      if ( m_matrix.size() > 0 )
    57 //      {
    58 //              if ( node_data->is_flat() )
    59 //              {
    60 //                      animate_flat( node_data, binding, frame );
    61 //              }
    62 //              else
    63 //              {
    64 //                      for ( uint32 n = 0; n < node_data->size(); ++n )
    65 //                              if ( ( *node_data )[n]->get_parent_id() == -1 )
    66 //                                      animate_rec( node_data, binding, frame, n, transform() );
    67 //              }
    68 //      }
    69 // }
    70 //
    71 // void nv::skeleton_instance::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent )
    72 // {
    73 //      // TODO: fix transforms, which are now embedded,
    74 //      //       see note in assimp_loader.cc:load_node
    75 //      const data_channel_set* node = ( *node_data )[id];
    76 //      transform node_mat( node->get_transform() );
    77 //
    78 //      if ( node->size() > 0 )
    79 //      {
    80 //              raw_channel_interpolator interpolator( node, binding.m_key );
    81 //              node_mat = interpolator.get< transform >( frame );
    82 //      }
    83 //
    84 //      transform global_mat = parent * node_mat;
    85 //
    86 //      sint16 bone_id = binding.m_indices[id];
    87 //      if ( bone_id >= 0 )
    88 //      {
    89 //              m_matrix[bone_id] = global_mat.extract() * binding.m_offsets[bone_id];
    90 //      }
    91 //
    92 //      for ( auto child : node_data->children( id ) )
    93 //      {
    94 //              animate_rec( node_data, binding, frame, child, global_mat );
    95 //      }
    96 // }
    97 //
    98 // void nv::skeleton_instance::animate_flat( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame )
    99 // {
    100 //      for ( uint32 n = 0; n < node_data->size(); ++n )
    101 //              if ( binding.m_indices[n] >= 0 )
    102 //              {
    103 //                      const data_channel_set* node = ( *node_data )[n];
    104 //                      nv::mat4 node_mat( node->get_transform() );
    105 //
    106 //                      if ( node->size() > 0 )
    107 //                      {
    108 //                              raw_channel_interpolator interpolator( node, binding.m_key );
    109 //                              node_mat = interpolator.get< mat4 >( frame );
    110 //                      }
    111 //                      sint16 bone_id = binding.m_indices[n];
    112 //                      m_matrix[bone_id] = node_mat * binding.m_offsets[bone_id];
    113 //              }
    114 // }
    11546
    11647void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const bone_transforms& bones )
    … …  
    12051        const transform* transforms = skeleton.transforms();
    12152        for ( uint32 n = 0; n < skeleton.size(); ++n )
     53        {
    12254                m_matrix[n] = transforms[n].extract() * bones.m_offsets[n];
     55        }
    12356}
    12457
    … …  
    12962}
    13063
    131 void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent )
     64void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame )
     65{
     66        if ( m_transforms.size() != binding.skeleton_size() )
     67                m_transforms.resize( binding.skeleton_size() );
     68        for ( uint32 n = 0; n < node_data->size(); ++n )
     69        {
     70                const data_channel_set* node = ( *node_data )[n];
     71                sint16 bone_id = binding.m_indices[n];
     72                if ( bone_id >= 0 )
     73                {
     74                        if ( node->size() > 0 )
     75                                m_transforms[bone_id] = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame );
     76                        int confirm_that_not_needed;
     77//                      else
     78//                              m_transforms[bone_id] = transform( node->get_transform() );
     79                }
     80        }
     81}
     82
     83void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, float blend )
     84{
     85        if ( m_transforms.size() != binding.skeleton_size() )
     86                m_transforms.resize( binding.skeleton_size() );
     87        for ( uint32 n = 0; n < node_data->size(); ++n )
     88        {
     89                const data_channel_set* node = ( *node_data )[n];
     90                sint16 bone_id = binding.m_indices[n];
     91                if ( bone_id >= 0 )
     92                {
     93                       
     94                        transform tr = node->size() > 0 ? raw_channel_interpolator( node, binding.m_key ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed;
     95                        m_transforms[bone_id] = nv::interpolate( m_transforms[bone_id], tr, blend );
     96                }
     97        }
     98}
     99
     100void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, const skeleton_binding& binding, uint32 id, const transform& parent )
     101{
     102        sint16 bone_id = binding.m_indices[id];
     103        transform global_mat = parent;
     104        if ( bone_id >= 0 )
     105        {
     106                global_mat *= m_transforms[bone_id];
     107                m_transforms[bone_id] = global_mat;
     108        }
     109        for ( auto child : node_data.children( id ) )
     110        {
     111                delocalize_rec( node_data, binding, child, global_mat );
     112        }
     113}
     114
     115void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local )
    132116{
    133117        const data_channel_set* node = ( *node_data )[id];
    134         transform node_mat( node->get_transform() );
     118        transform node_mat;
     119
     120        if ( node->size() > 0 )
     121                node_mat = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame );
     122        int confirm_that_not_needed;
     123        //      else
     124//              node_mat = transform( node->get_transform() );
     125        sint16 bone_id = binding.m_indices[id];
     126        transform global_mat = parent * node_mat;
     127        if ( bone_id >= 0 )
     128        {
     129                m_transforms[bone_id] = local ? node_mat : global_mat;
     130        }
     131        for ( auto child : node_data->children( id ) )
     132        {
     133                animate_rec( node_data, binding, frame, child, global_mat, local );
     134        }
     135}
     136
     137void nv::skeleton_transforms::blend_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local, float blend )
     138{
     139        const data_channel_set* node = ( *node_data )[id];
     140        int confirm_that_not_needed;
     141        transform node_mat/*( node->get_transform() )*/;
    135142
    136143        if ( node->size() > 0 )
    … …  
    143150        if ( bone_id >= 0 )
    144151        {
    145                 m_transforms[bone_id] = global_mat;
     152                m_transforms[bone_id] = nv::interpolate( m_transforms[bone_id], local ? node_mat : global_mat, blend );
    146153        }
    147154        for ( auto child : node_data->children( id ) )
    148155        {
    149                 animate_rec( node_data, binding, frame, child, global_mat );
     156                blend_rec( node_data, binding, frame, child, global_mat, local, blend );
    150157        }
    151158}
    152159
    153 void nv::bone_transforms::prepare( const mesh_nodes_data* bone_data )
     160
     161void nv::bone_transforms::prepare( const data_node_list& bone_data )
    154162{
    155163        if ( m_offsets.empty() )
    156164        {
    157                 m_offsets.resize( bone_data->size() );
     165                m_offsets.resize( bone_data.size() );
    158166
    159                 for ( nv::uint16 bi = 0; bi < bone_data->size(); ++bi )
    160                 {
    161                         const data_channel_set* bone = ( *bone_data )[bi];
    162                         m_offsets[bi] = bone->get_transform();
    163                 }
     167                for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
     168                        m_offsets[bi] = bone_data[bi].transform;
    164169        }
    165170}
Note: See TracChangeset for help on using the changeset viewer.