Ignore:
Timestamp:
01/26/16 18:59:46 (9 years ago)
Author:
epyon
Message:
  • massive update (need to start doing atomics again) :/
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gfx/skeleton_instance.cc

    r484 r485  
    88
    99#include "nv/core/profiler.hh"
     10
     11void nv::skeleton_binding::assign( const skeleton_binding& other )
     12{
     13        m_indices.assign( other.m_indices );
     14        m_key        = other.m_key;
     15        m_bone_count = other.m_bone_count;
     16}
    1017
    1118void nv::skeleton_binding::prepare( const mesh_nodes_data* node_data, const data_node_list& bone_data )
    … …  
    4552}
    4653
     54void nv::skeleton_binding::prepare( const data_node_list& pose_data, const data_node_list& bone_data )
     55{
     56        if ( m_indices.empty() )
     57        {
     58                // TODO: either fixed size struct or static allocator
     59                hash_store< shash64, uint16 > bone_names;
     60                m_indices.resize( pose_data.size() );
     61
     62                for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
     63                        bone_names[bone_data[bi].name] = bi;
     64
     65                for ( uint32 n = 0; n < pose_data.size(); ++n )
     66                {
     67                        sint16 bone_id = -1;
     68                        auto bi = bone_names.find( pose_data[ n ].name );
     69                        if ( bi != bone_names.end() )
     70                        {
     71                                bone_id = sint16( bi->second );
     72                        }
     73                        m_indices[n] = bone_id;
     74
     75                }
     76                m_bone_count = bone_data.size();
     77        }
     78}
     79
     80
     81void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms& bones )
     82{
     83        if ( bones.size() != m_matrix.size() )
     84                m_matrix.resize( bones.size() );
     85        const transform* transforms = skeleton.xforms();
     86        for ( uint32 n = 0; n < skeleton.size(); ++n )
     87        {
     88                sint16 bone_id = binding.m_indices[n];
     89                if ( bone_id >= 0 )
     90                {
     91                        int too_complex;
     92                        transform tr( bones.m_offsets[bone_id] );
     93                        tr.set_orientation( normalize( tr.get_orientation() ) );
     94                        m_matrix[bone_id] = ( transforms[n] * tr ).extract();
     95                }
     96        }
     97}
     98
     99
    47100void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const bone_transforms& bones )
    48101{
    49102        if ( bones.size() != m_matrix.size() )
    50103                m_matrix.resize( bones.size() );
    51         const transform* transforms = skeleton.transforms();
     104        const transform* transforms = skeleton.xforms();
    52105        for ( uint32 n = 0; n < skeleton.size(); ++n )
    53106        {
    … …  
    90143        }
    91144
    92         if ( m_transforms.size() > 0 )
    93                 m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t );
     145//      if ( m_transforms.size() > 0 )
     146//              m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t, interpolation::SPHERICAL );
    94147}
    95148
    … …  
    107160                        );
    108161        }
    109 
    110         if ( m_transforms.size() > 0 )
    111                 m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t );
    112162}
    113163
    … …  
    120170        for ( uint32 n = 0; n < a.size(); ++n )
    121171        {
    122                 m_transforms[n] = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t );
    123         }
    124 }
     172                m_transforms[n] = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
     173        }
     174}
     175
     176void nv::skeleton_transforms::blend_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t, float blend )
     177{
     178        NV_ASSERT( a.size() == b.size(), "!!!" );
     179        if ( m_transforms.size() != a.size() )
     180                m_transforms.resize( a.size() );
     181        for ( uint32 n = 0; n < a.size(); ++n )
     182        {
     183                transform tr    = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
     184                m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
     185        }
     186}
     187
     188
    125189
    126190void nv::skeleton_transforms::interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
    … …  
    155219                qr = normalize( qr );
    156220
    157                 if ( n == 0 )
    158                         qr = nv::math::slerp( v1.m_transforms[n].get_orientation(), v2.m_transforms[n].get_orientation(), t );
    159 
    160221                m_transforms[n] = transform(
    161222                        weights[0] * s1.m_transforms[n].get_position() +
    … …  
    181242                nv::quat ss1 = s1.m_transforms[n].get_orientation();
    182243                nv::quat ss2 = s2.m_transforms[n].get_orientation();
     244                nv::quat sv1 = v1.m_transforms[n].get_orientation();
     245                nv::quat sv2 = v2.m_transforms[n].get_orientation();
     246
    183247                nv::quat q = normalize( nv::math::squad(
    184                         v1.m_transforms[n].get_orientation(),
    185                         v2.m_transforms[n].get_orientation(),
    186                         nv::math::intermediate( ss1, v1.m_transforms[n].get_orientation(), v2.m_transforms[n].get_orientation() ),
    187                         nv::math::intermediate( v1.m_transforms[n].get_orientation(), v2.m_transforms[n].get_orientation(), ss2 ),
     248                        sv1, sv2,
     249                        nv::math::intermediate( ss1, sv1, sv2 ),
     250                        nv::math::intermediate( sv1, sv2, ss2 ),
    188251                        t ) );
    189                 if ( n == 0 ) q = nv::math::slerp(
    190                         v1.m_transforms[n].get_orientation(),
    191                         v2.m_transforms[n].get_orientation(), t );
    192252
    193253                m_transforms[n] = transform(
    … …  
    196256                        );
    197257        }
    198 
     258       
    199259}
    200260
    … …  
    204264}
    205265
    206 void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame )
    207 {
    208         if ( m_transforms.size() != binding.skeleton_size() )
    209                 m_transforms.resize( binding.skeleton_size() );
    210         for ( uint32 n = 0; n < node_data->size(); ++n )
    211         {
    212                 const data_channel_set* node = ( *node_data )[n];
    213                 sint16 bone_id = binding.m_indices[n];
    214                 if ( bone_id >= 0 )
    215                 {
    216                         if ( node->size() > 0 )
    217                         {
    218                                 m_transforms[bone_id] = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame );
    219                         }
    220                         int confirm_that_not_needed;
    221 //                      else
    222 //                              m_transforms[bone_id] = transform( node->get_transform() );
    223                 }
    224         }
    225 }
    226 
    227 void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, float blend )
    228 {
    229         if ( m_transforms.size() != binding.skeleton_size() )
    230                 m_transforms.resize( binding.skeleton_size() );
    231         for ( uint32 n = 0; n < node_data->size(); ++n )
    232         {
    233                 const data_channel_set* node = ( *node_data )[n];
    234                 sint16 bone_id = binding.m_indices[n];
    235                 if ( bone_id >= 0 )
    236                 {
    237                        
    238                         transform tr = node->size() > 0 ? raw_channel_interpolator( node, binding.m_key ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed;
    239                         m_transforms[bone_id] = nv::interpolate( m_transforms[bone_id], tr, blend );
    240                 }
    241         }
    242 }
    243 
    244 void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, const skeleton_binding& binding, uint32 id, const transform& parent )
    245 {
    246         sint16 bone_id = binding.m_indices[id];
     266// void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, float frame, float blend )
     267// {
     268//      if ( m_transforms.size() != node_data->size() )
     269//              m_transforms.resize( node_data->size() );
     270//      for ( uint32 n = 0; n < node_data->size(); ++n )
     271//      {
     272//              const data_channel_set* node = ( *node_data )[n];
     273//              int inefficient_store_key;
     274//
     275//              transform tr = node->size() > 0 ? raw_channel_interpolator( node ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed;
     276//              m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
     277//      }
     278// }
     279//
     280// void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, float frame )
     281// {
     282//      if ( m_transforms.size() != node_data->size() )
     283//              m_transforms.resize( node_data->size() );
     284//      for ( uint32 n = 0; n < node_data->size(); ++n )
     285//      {
     286//              const data_channel_set* node = ( *node_data )[n];
     287//              if ( node->size() > 0 )
     288//              {
     289//                      int inefficient_store_key;
     290//                      m_transforms[n] = raw_channel_interpolator( node ).get< transform >( frame );
     291//              }
     292//      }
     293// }
     294
     295void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent )
     296{
    247297        transform global_mat = parent;
    248         if ( bone_id >= 0 )
    249         {
    250                 global_mat *= m_transforms[bone_id];
    251                 m_transforms[bone_id] = global_mat;
    252         }
     298        global_mat *= m_transforms[id];
     299        m_transforms[id] = global_mat;
    253300        for ( auto child : node_data.children( id ) )
    254301        {
    255                 delocalize_rec( node_data, binding, child, global_mat );
    256         }
    257 }
    258 
    259 void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local )
    260 {
    261         const data_channel_set* node = ( *node_data )[id];
    262         transform node_mat;
    263 
    264         if ( node->size() > 0 )
    265                 node_mat = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame );
    266         int confirm_that_not_needed;
    267         //      else
    268 //              node_mat = transform( node->get_transform() );
    269         sint16 bone_id = binding.m_indices[id];
    270         transform global_mat = parent * node_mat;
    271         if ( bone_id >= 0 )
    272         {
    273                 m_transforms[bone_id] = local ? node_mat : global_mat;
    274         }
    275         for ( auto child : node_data->children( id ) )
    276         {
    277                 animate_rec( node_data, binding, frame, child, global_mat, local );
    278         }
    279 }
    280 
    281 void 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 )
    282 {
    283         const data_channel_set* node = ( *node_data )[id];
    284         int confirm_that_not_needed;
    285         transform node_mat/*( node->get_transform() )*/;
    286 
    287         if ( node->size() > 0 )
    288         {
    289                 raw_channel_interpolator interpolator( node, binding.m_key );
    290                 node_mat = interpolator.get< transform >( frame );
    291         }
    292         sint16 bone_id = binding.m_indices[id];
    293         transform global_mat = parent * node_mat;
    294         if ( bone_id >= 0 )
    295         {
    296                 m_transforms[bone_id] = nv::interpolate( m_transforms[bone_id], local ? node_mat : global_mat, blend );
    297         }
    298         for ( auto child : node_data->children( id ) )
    299         {
    300                 blend_rec( node_data, binding, frame, child, global_mat, local, blend );
    301         }
    302 }
    303 
     302                delocalize_rec( node_data, child, global_mat );
     303        }
     304}
     305
     306// void nv::skeleton_transforms::blend_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local, float blend )
     307// {
     308//      const data_channel_set* node = ( *node_data )[id];
     309//      int confirm_that_not_needed;
     310//      transform node_mat/*( node->get_transform() )*/;
     311//
     312//      if ( node->size() > 0 )
     313//      {
     314//              int inefficient_store_key;
     315//
     316//              raw_channel_interpolator interpolator( node );
     317//              node_mat = interpolator.get< transform >( frame );
     318//      }
     319//      transform global_mat = parent * node_mat;
     320//      m_transforms[id] = nv::interpolate( m_transforms[id], local ? node_mat : global_mat, blend, interpolation::SPHERICAL );
     321//      for ( auto child : node_data->children( id ) )
     322//      {
     323//              blend_rec( node_data, frame, child, global_mat, local, blend );
     324//      }
     325//
     326// }
     327//
     328// void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local )
     329// {
     330//      const data_channel_set* node = ( *node_data )[id];
     331//      transform node_mat;
     332//      int inefficient_store_key;
     333//
     334//      if ( node->size() > 0 )
     335//              node_mat = raw_channel_interpolator( node ).get< transform >( frame );
     336//      int confirm_that_not_needed;
     337//      //      else
     338//      //              node_mat = transform( node->get_transform() );
     339//      transform global_mat = parent * node_mat;
     340//      m_transforms[id] = local ? node_mat : global_mat;
     341//      for ( auto child : node_data->children( id ) )
     342//      {
     343//              animate_rec( node_data, frame, child, global_mat, local );
     344//      }
     345//
     346// }
    304347
    305348void nv::bone_transforms::prepare( const data_node_list& bone_data )
Note: See TracChangeset for help on using the changeset viewer.