Changeset 419 for trunk


Ignore:
Timestamp:
07/14/15 20:19:52 (10 years ago)
Author:
epyon
Message:
  • animation - key_channel_set simplified to data_channel_set
  • animation - raw_channel_interpolator
Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/gfx/animation.hh

    r418 r419  
    2020{
    2121
    22         class key_channel_set : public data_channel_set
     22        class raw_channel_interpolator
    2323        {
    2424        public:
    25                 mat4 get_raw_matrix( uint32 index ) const
    26                 {
    27                         float key[ 16 ];
     25                explicit raw_channel_interpolator( const data_channel_set* set )
     26                        : m_set( set ), m_interpolation_key( set->get_interpolation_key() )
     27                {
     28                }
     29                raw_channel_interpolator( const data_channel_set* set, const data_descriptor& ikey )
     30                        : m_set( set ), m_interpolation_key( ikey )
     31                { }
     32
     33                template < typename T >
     34                T get_raw( uint32 index ) const
     35                {
     36                        float key[16];
    2837                        float* pkey = key;
    29                         for ( uint16 i = 0; i < size(); ++i )
    30                         {
    31                                 pkey += get_raw( m_channels[i], index, pkey );
    32                         }
    33                         return extract_matrix_raw( m_final_key, key );
    34                 }
    35 
    36                 transform get_raw_transform( uint32 index ) const
    37                 {
    38                         float key[ 16 ];
     38                        for ( const auto& channel : *m_set )
     39                        {
     40                                pkey += get_raw( channel, index, pkey );
     41                        }
     42                        return extract_key_raw< T >( m_interpolation_key, key );
     43                }
     44
     45                template < typename T >
     46                T get( float time ) const
     47                {
     48                        float key[16];
    3949                        float* pkey = key;
    40                         for ( uint16 i = 0; i < size(); ++i )
    41                         {
    42                                 pkey += get_raw( m_channels[i], index, pkey );
    43                         }
    44                         return extract_transform_raw( m_final_key, key );
    45                 }
    46 
    47                 mat4 get_matrix( float time ) const
    48                 {
    49                         float key[ 16 ];
    50                         float* pkey = key;
    51                         for ( uint16 i = 0; i < size(); ++i )
    52                         {
    53                                 pkey += interpolate_raw( m_channels[i], time, pkey );
    54                         }
    55                         return extract_matrix_raw( m_final_key, key );
    56                 }
    57 
    58                 transform get_transform( float time ) const
    59                 {
    60                         float key[ 16 ];
    61                         float* pkey = key;
    62                         for ( uint16 i = 0; i < size(); ++i )
    63                         {
    64                                 pkey += interpolate_raw( m_channels[i], time, pkey );
    65                         }
    66                         return extract_transform_raw( m_final_key, key );
    67                 }
    68 
    69                 const data_descriptor& get_final_key() const { return m_final_key; }
     50                        for ( const auto& channel : *m_set )
     51                        {
     52                                pkey += interpolate_raw( channel, time, pkey );
     53                        }
     54                        return extract_key_raw< T >( m_interpolation_key, key );
     55                }
     56
     57                template < typename T >
     58                T  get( uint32 index1, uint32 index2, float interpolation ) const
     59                {
     60                        T t1 = get_raw< T >( index1 );
     61                        T t2 = get_raw< T >( index2 );
     62                        return interpolate( t1, t2, interpolation );
     63                }
    7064
    7165                static uint32 get_raw( const raw_data_channel& channel, uint32 index, float* result )
    … …  
    138132                        return ret;
    139133                }
    140 
    141         private:
    142                 friend class key_channel_set_creator;
    143 
    144                 key_channel_set() {}
    145 
    146                 data_descriptor m_final_key;
     134                const data_descriptor& get_interpolation_key() { return m_interpolation_key; }
     135        protected:
     136                const data_channel_set* m_set;
     137                data_descriptor m_interpolation_key;
    147138        };
    148139
    149         template < typename KEY, bool TIMED >
    150         class key_channel_interpolator;
    151 
    152 
    153         template < typename KEY >
    154         class key_channel_interpolator< KEY, false >
    155         {
    156         public:
    157                 key_channel_interpolator() : m_data( nullptr ) {}
    158                 key_channel_interpolator( const raw_data_channel* data ) : m_data( nullptr ) { set_data( data ); }
    159                 key_channel_interpolator( const raw_data_channel* data, bool ) : m_data( data ) {}
    160                 void set_data( const raw_data_channel* data )
    161                 {
    162                         m_data = data;
    163                         data_descriptor desc;
    164                         desc.initialize<KEY>();
    165                         NV_ASSERT( data->descriptor() == desc, "Bad channel passed!" );
    166                 }
    167                 void get_interpolated( KEY& result, float frame ) const
    168                 {
    169                         NV_ASSERT( m_data, "Data is null!" );
    170                         const KEY* keys = m_data->data_cast<KEY>( );
    171                         uint32 count = m_data->size();
    172                         if ( count == 0 ) return;
    173                         if ( count == 1 )
    174                         {
    175                                 result = keys[0];
    176                                 return;
    177                         }
    178                         size_t index = glm::clamp<size_t>( size_t( frame ), 0, count - 2 );
    179                         float factor = glm::clamp<float> ( frame - index, 0.0f, 1.0f );
    180                         interpolate_key( result, keys[index], keys[index+1], factor );
    181                 }
    182 
    183         private:
    184                 const raw_data_channel* m_data;
    185         };
    186 
    187         template < typename KEY >
    188         class key_channel_interpolator< KEY, true >
    189         {
    190         public:
    191                 key_channel_interpolator() : m_data( nullptr ) {}
    192                 key_channel_interpolator( const raw_data_channel* data ) : m_data( nullptr ) { set_data( data ); }
    193                 void set_data( const raw_data_channel* data )
    194                 {
    195                         m_data = data;
    196                         data_descriptor desc;
    197                         desc.initialize<KEY>();
    198                         NV_ASSERT( data->descriptor() == desc, "Bad channel passed!" );
    199                 }
    200                 void get_interpolated( KEY& result, float time ) const
    201                 {
    202                         // TODO: this probably could be optimized
    203                         NV_ASSERT( m_data, "Data is null!" );
    204                         const KEY* keys = m_data->data_cast<KEY>( );
    205                         uint32 count = m_data->size();
    206                         if ( count == 0 ) return;
    207                         if ( count == 1 )
    208                         {
    209                                 result = keys[0];
    210                                 return;
    211                         }
    212                         int index = -1;
    213                         for ( int i = 0 ; i < int( count ) - 1 ; i++ )
    214                         {
    215                                 if ( time < keys[i + 1].time ) { index = i; break; }
    216                         }
    217                         NV_ASSERT( index >= 0, "animation time fail!");
    218                         float delta  = keys[index + 1].time - keys[index].time;
    219                         float factor = glm::clamp( (time - keys[index].time) / delta, 0.0f, 1.0f );
    220                         interpolate_key( result, keys[index], keys[index+1], factor );
    221                 }
    222 
    223         private:
    224                 const raw_data_channel* m_data;
    225         };
    226 
     140//      template < typename KEY, bool TIMED >
     141//      class key_channel_interpolator;
     142//
     143//
     144//      template < typename KEY >
     145//      class key_channel_interpolator< KEY, false >
     146//      {
     147//      public:
     148//              key_channel_interpolator() : m_data( nullptr ) {}
     149//              key_channel_interpolator( const raw_data_channel* data ) : m_data( nullptr ) { set_data( data ); }
     150//              key_channel_interpolator( const raw_data_channel* data, bool ) : m_data( data ) {}
     151//              void set_data( const raw_data_channel* data )
     152//              {
     153//                      m_data = data;
     154//                      data_descriptor desc;
     155//                      desc.initialize<KEY>();
     156//                      NV_ASSERT( data->descriptor() == desc, "Bad channel passed!" );
     157//              }
     158//              void get_interpolated( KEY& result, float frame ) const
     159//              {
     160//                      NV_ASSERT( m_data, "Data is null!" );
     161//                      const KEY* keys = m_data->data_cast<KEY>( );
     162//                      uint32 count = m_data->size();
     163//                      if ( count == 0 ) return;
     164//                      if ( count == 1 )
     165//                      {
     166//                              result = keys[0];
     167//                              return;
     168//                      }
     169//                      size_t index = glm::clamp<size_t>( size_t( frame ), 0, count - 2 );
     170//                      float factor = glm::clamp<float> ( frame - index, 0.0f, 1.0f );
     171//                      interpolate_key( result, keys[index], keys[index+1], factor );
     172//              }
     173//
     174//      private:
     175//              const raw_data_channel* m_data;
     176//      };
     177//
     178//      template < typename KEY >
     179//      class key_channel_interpolator< KEY, true >
     180//      {
     181//      public:
     182//              key_channel_interpolator() : m_data( nullptr ) {}
     183//              key_channel_interpolator( const raw_data_channel* data ) : m_data( nullptr ) { set_data( data ); }
     184//              void set_data( const raw_data_channel* data )
     185//              {
     186//                      m_data = data;
     187//                      data_descriptor desc;
     188//                      desc.initialize<KEY>();
     189//                      NV_ASSERT( data->descriptor() == desc, "Bad channel passed!" );
     190//              }
     191//              void get_interpolated( KEY& result, float time ) const
     192//              {
     193//                      // TODO: this probably could be optimized
     194//                      NV_ASSERT( m_data, "Data is null!" );
     195//                      const KEY* keys = m_data->data_cast<KEY>( );
     196//                      uint32 count = m_data->size();
     197//                      if ( count == 0 ) return;
     198//                      if ( count == 1 )
     199//                      {
     200//                              result = keys[0];
     201//                              return;
     202//                      }
     203//                      int index = -1;
     204//                      for ( int i = 0 ; i < int( count ) - 1 ; i++ )
     205//                      {
     206//                              if ( time < keys[i + 1].time ) { index = i; break; }
     207//                      }
     208//                      NV_ASSERT( index >= 0, "animation time fail!");
     209//                      float delta  = keys[index + 1].time - keys[index].time;
     210//                      float factor = glm::clamp( (time - keys[index].time) / delta, 0.0f, 1.0f );
     211//                      interpolate_key( result, keys[index], keys[index+1], factor );
     212//              }
     213//
     214//      private:
     215//              const raw_data_channel* m_data;
     216//      };
     217//
    227218//      template < typename KEY1, typename KEY2 = void, typename KEY3 = void >
    228219//      class key_data_interpolator
    … …  
    230221//
    231222//      };
    232 
    233         class key_animation_data
    234         {
    235         public:
    236                 virtual mat4 get_matrix( float time ) const = 0;
    237                 virtual transform get_transform( float time ) const = 0;
    238                 virtual bool empty() const = 0;
    239                 virtual size_t size() const = 0;
    240                 virtual uint32 raw_size() const = 0;
    241                 virtual ~key_animation_data() {}
    242         };
    243 
    244 
    245         class key_vectors_prs : public key_animation_data
    246         {
    247                 struct key_p { float time; vec3 position; };
    248                 struct key_r { float time; quat rotation; };
    249                 struct key_s { float time; vec3 scale; };
    250         public:
    251                 explicit key_vectors_prs( const raw_data_channel* p, const raw_data_channel* r, const raw_data_channel* s )
    252                 {
    253                         m_pchannel = p;
    254                         m_rchannel = r;
    255                         m_schannel = s;
    256                         m_pinter.set_data( m_pchannel );
    257                         m_rinter.set_data( m_rchannel );
    258                         m_sinter.set_data( m_schannel );
    259                 }
    260                 size_t size() const { return 0; } // TODO: remove?
    261                 bool empty() const {
    262                         return m_pchannel->size() == 0
    263                                 && m_rchannel->size() == 0
    264                                 && m_schannel->size() == 0; }
    265                 virtual mat4 get_matrix( float time ) const
    266                 {
    267                         key_p p;
    268                         key_r r;
    269                         key_s s;
    270 
    271                         m_pinter.get_interpolated( p, time );
    272                         m_rinter.get_interpolated( r, time );
    273                         m_sinter.get_interpolated( s, time );
    274 
    275                         return extract_matrix( p ) * extract_matrix( r ) * extract_matrix( s );
    276                 }
    277                 virtual transform get_transform( float time ) const
    278                 {
    279                         key_p p;
    280                         key_r r;
    281 
    282                         m_pinter.get_interpolated( p, time );
    283                         m_rinter.get_interpolated( r, time );
    284 
    285                         return transform( p.position, r.rotation );
    286                 }
    287                 virtual uint32 raw_size() const
    288                 {
    289                         return 3 * sizeof( size_t )
    290                                 + m_pchannel->size() * sizeof( key_p )
    291                                 + m_rchannel->size() * sizeof( key_r )
    292                                 + m_schannel->size() * sizeof( key_s );
    293                 }
    294                 ~key_vectors_prs()
    295                 {
    296                 }
    297         protected:
    298                 const raw_data_channel* m_pchannel;
    299                 const raw_data_channel* m_rchannel;
    300                 const raw_data_channel* m_schannel;
    301                 key_channel_interpolator< key_p, true > m_pinter;
    302                 key_channel_interpolator< key_r, true > m_rinter;
    303                 key_channel_interpolator< key_s, true > m_sinter;
    304         };
    305 
    306         class transform_vector : public key_animation_data
    307         {
    308                 struct key
    309                 {
    310                         transform tform;
    311                 };
    312         public:
    313                 explicit transform_vector( const raw_data_channel* channel )
    314                 {
    315                         data_descriptor kd;
    316                         kd.initialize<key>();
    317                         NV_ASSERT( kd == channel->descriptor(), "bad channel!" );
    318                         m_channel = channel;
    319                         m_interpolator.set_data( m_channel );
    320                 }
    321 
    322                 ~transform_vector()
    323                 {
    324                         delete m_channel;
    325                 }
    326                 bool empty() const { return m_channel->size() == 0; }
    327                 size_t size() const { return m_channel->size(); }
    328                 const transform& get( size_t index ) const { return m_channel->data_cast< key >()[ index ].tform; }
    329                 const transform* data() const { return &(m_channel->data_cast< key >()[0].tform); }
    330 
    331                 virtual uint32 raw_size() const
    332                 {
    333                         return sizeof( size_t ) + m_channel->size() * sizeof( key );
    334                 }
    335 
    336                 virtual mat4 get_matrix( float time ) const
    337                 {
    338                         return get_transform( time ).extract();
    339                 }
    340                 virtual transform get_transform( float time ) const
    341                 {
    342                         key result;
    343                         m_interpolator.get_interpolated( result, time );
    344                         return extract_transform< key >( result );
    345                 }
    346         protected:
    347                 key_channel_interpolator< key, false > m_interpolator;
    348                 const raw_data_channel* m_channel;
    349         };
     223//
     224//      class key_animation_data
     225//      {
     226//      public:
     227//              virtual mat4 get_matrix( float time ) const = 0;
     228//              virtual transform get_transform( float time ) const = 0;
     229//              virtual bool empty() const = 0;
     230//              virtual size_t size() const = 0;
     231//              virtual uint32 raw_size() const = 0;
     232//              virtual ~key_animation_data() {}
     233//      };
     234
     235//      class transform_vector : public key_animation_data
     236//      {
     237//              struct key
     238//              {
     239//                      transform tform;
     240//              };
     241//      public:
     242//              explicit transform_vector( const raw_data_channel* channel )
     243//              {
     244//                      data_descriptor kd;
     245//                      kd.initialize<key>();
     246//                      NV_ASSERT( kd == channel->descriptor(), "bad channel!" );
     247//                      m_channel = channel;
     248//                      m_interpolator.set_data( m_channel );
     249//              }
     250//
     251//              ~transform_vector()
     252//              {
     253//                      delete m_channel;
     254//              }
     255//              bool empty() const { return m_channel->size() == 0; }
     256//              size_t size() const { return m_channel->size(); }
     257//              const transform& get( size_t index ) const { return m_channel->data_cast< key >()[ index ].tform; }
     258//              const transform* data() const { return &(m_channel->data_cast< key >()[0].tform); }
     259//
     260//              virtual uint32 raw_size() const
     261//              {
     262//                      return sizeof( size_t ) + m_channel->size() * sizeof( key );
     263//              }
     264//
     265//              virtual mat4 get_matrix( float time ) const
     266//              {
     267//                      return get_transform( time ).extract();
     268//              }
     269//              virtual transform get_transform( float time ) const
     270//              {
     271//                      key result;
     272//                      m_interpolator.get_interpolated( result, time );
     273//                      return extract_transform< key >( result );
     274//              }
     275//      protected:
     276//              key_channel_interpolator< key, false > m_interpolator;
     277//              const raw_data_channel* m_channel;
     278//      };
    350279
    351280

  • trunk/nv/gfx/keyframed_mesh.hh

    r417 r419  
    5353                const mesh_nodes_data*  m_tag_map;
    5454
     55                data_descriptor m_interpolation_key;
    5556                buffer       m_pbuffer;
    5657                vertex_array m_va;

  • trunk/nv/gfx/skeletal_mesh.hh

    r412 r419  
    3232                vertex_array m_va;
    3333                context*     m_context;
     34                data_descriptor m_interpolation_key;
    3435        };
    3536
    … …  
    3839        public:
    3940                skeletal_animation_entry_cpu( const std::string& name, const mesh_nodes_data* a_animation, bool a_looping )
    40                         : animation_entry( name, a_looping, a_animation->get_frame_rate(), 0.0f, a_animation->get_duration() ), m_node_data( a_animation ) {}
     41                        : animation_entry( name, a_looping, a_animation->get_frame_rate(), 0.0f, a_animation->get_duration() ), m_node_data( a_animation )
     42                {
     43                        initialize();
     44                }
    4145                skeletal_animation_entry_cpu( const std::string& name, mesh_nodes_data* a_animation, float time_start, float time_end, bool a_looping )
    42                         : animation_entry( name, a_looping, a_animation->get_frame_rate(), time_start, time_end ), m_node_data( a_animation ) {}
     46                        : animation_entry( name, a_looping, a_animation->get_frame_rate(), time_start, time_end ), m_node_data( a_animation )
     47                {
     48                        initialize();
     49                }
     50                void initialize();
    4351                void update_skeleton( transform* skeleton, float time ) const;
    4452        protected:
    4553                const mesh_nodes_data* m_node_data;
     54                data_descriptor m_interpolation_key;
    4655        };
    4756
    … …  
    93102                mat4* m_offsets;
    94103                bool m_prepared;
     104                data_descriptor m_interpolation_key;
    95105        };
    96106

  • trunk/nv/interface/data_channel.hh

    r418 r419  
    6868                friend class data_channel_creator;
    6969                friend class data_channel_set;
    70                 friend class key_channel_set_creator;
    7170
    7271                raw_data_channel() : m_data( nullptr ), m_size( 0 ) {}
    … …  
    168167                }
    169168
     169                data_descriptor get_interpolation_key() const
     170                {
     171                        data_descriptor result;
     172                        for ( uint32 c = 0; c < m_size; ++c )
     173                        {
     174                                for ( const auto& cslot : m_channels[c].descriptor() )
     175                                        if ( cslot.vslot != slot::TIME )
     176                                        result.push_slot( cslot.etype, cslot.vslot );
     177                        }
     178                        return result;
     179                }
     180
    170181                const_iterator begin() const { return &m_channels[0]; }
    171182                const_iterator end()   const { return &m_channels[ m_size ]; }

  • trunk/nv/interface/data_channel_access.hh

    r418 r419  
    1010#include <nv/common.hh>
    1111#include <nv/interface/data_channel.hh>
    12 #include <nv/gfx/animation.hh> // TODO: remove, key creator separate file?
    1312
    1413namespace nv
    … …  
    162161
    163162
    164         class key_channel_set_creator
    165         {
    166                 typedef data_channel_set::const_iterator const_iterator;
    167         public:
    168 
    169                 static key_channel_set* create( size_t )
    170                 {
    171                         return new key_channel_set;
    172                 }
    173 
    174                 static key_channel_set* create_array( size_t size, size_t )
    175                 {
    176                         return new key_channel_set[size];
    177                 }
    178 
    179                 explicit key_channel_set_creator( key_channel_set* set ) : m_set( set ) {}
    180 
    181                 template < typename Struct >
    182                 data_channel_access< Struct > add_channel( uint32 size )
    183                 {
    184                         raw_data_channel channel = data_channel_creator::create( data_descriptor::create< Struct >(), size );
    185                         for ( const auto& cslot : channel.descriptor() )
    186                                 if ( cslot.vslot != slot::TIME )
    187                                 m_set->m_final_key.push_slot( cslot.etype, cslot.vslot );
    188                         uint32 index = m_set->m_size;
    189                         m_set->m_channels[index] = move( channel );
    190                         m_set->m_size++;
    191                         return data_channel_access< Struct >( &m_set->m_channels[index] );
    192                 }
    193 
    194                 raw_data_channel_access add_channel( const data_descriptor& desc, uint32 size )
    195                 {
    196                         raw_data_channel channel = data_channel_creator::create( desc, size );
    197                         for ( const auto& cslot : channel.descriptor() )
    198                                 if ( cslot.vslot != slot::TIME )
    199                                 m_set->m_final_key.push_slot( cslot.etype, cslot.vslot );
    200                         uint32 index = m_set->m_size;
    201                         m_set->m_channels[index] = move( channel );
    202                         m_set->m_size++;
    203                         return raw_data_channel_access( &m_set->m_channels[index] );
    204                 }
    205 
    206                 const raw_data_channel* operator []( uint32 i ) const { return &m_set->m_channels[i]; }
    207                 const_iterator begin() const { return m_set->begin(); }
    208                 const_iterator end()   const { return m_set->end(); }
    209 
    210         protected:
    211                 key_channel_set* m_set;
    212         };
    213 
    214163}
    215164

  • trunk/nv/interface/data_descriptor.hh

    r417 r419  
    263263                }
    264264
     265
     266
    265267                const_iterator begin() const { return &m_slots[0]; }
    266268                const_iterator end() const { return &m_slots[m_size]; }

  • trunk/nv/interface/interpolation_raw.hh

    r415 r419  
    5757        }
    5858
    59         inline mat4 extract_matrix_raw( const data_descriptor& desc, const float* data )
     59        template < typename T >
     60        inline T extract_key_raw( const data_descriptor& desc, const float* data );
     61
     62        template <>
     63        inline mat4 extract_key_raw( const data_descriptor& desc, const float* data )
    6064        {
    6165                if ( desc.size() == 1 )
    … …  
    98102        }
    99103
    100         inline transform extract_transform_raw( const data_descriptor& desc, const float* data )
     104        template <>
     105        inline transform extract_key_raw( const data_descriptor& desc, const float* data )
    101106        {
    102107                if ( desc.size() == 1 )

  • trunk/nv/interface/mesh_data.hh

    r417 r419  
    2828                sint16    parent_id;
    2929                mat4      transform;
    30                 key_channel_set* data;
     30                data_channel_set* data;
    3131        };
    3232
    … …  
    7575                }
    7676
    77                 key_channel_set* release_node_data( size_t i )
     77                data_channel_set* release_node_data( size_t i )
    7878                {
    79                         key_channel_set* result = m_nodes[i].data;
     79                        data_channel_set* result = m_nodes[i].data;
    8080                        m_nodes[i].data = nullptr;
    8181                        return result;

  • trunk/src/formats/assimp_loader.cc

    r417 r419  
    418418        }
    419419
    420         data->data = key_channel_set_creator::create( 2 );
    421         key_channel_set_creator key_set( data->data );
     420        data->data = data_channel_set_creator::create( 2 );
     421        data_channel_set_creator key_set( data->data );
    422422
    423423        assimp_key_p* pchannel = key_set.add_channel< assimp_key_p >( node->mNumPositionKeys ).data();

  • trunk/src/formats/md3_loader.cc

    r417 r419  
    429429                nodes[i].parent_id = -1;
    430430                nodes[i].target_id = -1;
    431                 nodes[i].data      = key_channel_set_creator::create( 1 );
    432                 load_tags( key_channel_set_creator( nodes[i].data ).add_channel<md3_key>( uint32( md3->header.num_frames ) ).channel(), name );
     431                nodes[i].data      = data_channel_set_creator::create( 1 );
     432                load_tags( data_channel_set_creator( nodes[i].data ).add_channel<md3_key>( uint32( md3->header.num_frames ) ).channel(), name );
    433433        }
    434434        return new mesh_nodes_data( "tags", node_count, nodes );

  • trunk/src/formats/md5_loader.cc

    r417 r419  
    250250                                nodes[i].transform = mat4();
    251251                                nodes[i].target_id = -1;
    252                                 nodes[i].data = key_channel_set_creator::create( 1 );
    253                                 key_channel_set_creator( nodes[i].data ).add_channel< md5_key_t >( num_frames );
     252                                nodes[i].data = data_channel_set_creator::create( 1 );
     253                                data_channel_set_creator( nodes[i].data ).add_channel< md5_key_t >( num_frames );
    254254                                next_line( sstream );
    255255                        }

  • trunk/src/formats/nmd_loader.cc

    r418 r419  
    121121                if ( ch_count > 0 )
    122122                {
    123                         key_channel_set* kdata = key_channel_set_creator::create( ch_count );
    124                         key_channel_set_creator kaccess( kdata );
     123                        data_channel_set* kdata = data_channel_set_creator::create( ch_count );
     124                        data_channel_set_creator kaccess( kdata );
    125125                        m_node_array[i].data = kdata;
    126126                        for ( uint32 c = 0; c < ch_count; ++c )

  • trunk/src/gfx/keyframed_mesh.cc

    r417 r419  
    3939        m_frame_count  = pos_size / m_vertex_count;
    4040        m_pbuffer      = buffer();
     41
     42        if ( m_tag_map && m_tag_map->get_count() > 0 )
     43        {
     44                m_interpolation_key = m_tag_map->get_node( 0 )->data->get_interpolation_key();
     45        }
    4146}
    4247
    … …  
    5055        if ( !m_tag_map ) return transform();
    5156        NV_ASSERT( node_id < m_tag_map->get_count(), "TAGMAP FAIL" );
    52         const key_channel_set* data = m_tag_map->get_node( node_id )->data;
     57        const data_channel_set* data = m_tag_map->get_node( node_id )->data;
    5358        NV_ASSERT( data, "TAG FAIL" );
    54         transform last = data->get_raw_transform( m_last_frame );
    55         transform next = data->get_raw_transform( m_next_frame );
    56         return interpolate( last, next, m_interpolation  );
     59        raw_channel_interpolator interpolator( data, m_interpolation_key );
     60        return interpolator.get< transform >( m_last_frame, m_next_frame, m_interpolation );
    5761}
    5862

  • trunk/src/gfx/mesh_creator.cc

    r418 r419  
    1919        {
    2020                sint16 parent_id = m_data->m_nodes[i].parent_id;
    21                 key_channel_set* keys   = m_data->m_nodes[i].data;
    22                 key_channel_set* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
     21                data_channel_set* keys   = m_data->m_nodes[i].data;
     22                data_channel_set* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
    2323                size_t count     = ( keys ? keys->get_channel_size(0) : 0 );
    2424                size_t pcount    = ( pkeys ? pkeys->get_channel_size(0) : 0 );
    … …  
    4646}
    4747
    48 // TODO: DELETE
    49 struct assimp_key_p  { float time; nv::vec3 position; };
    50 struct assimp_key_r  { float time; nv::quat rotation; };
    51 
    5248
    5349void nv::mesh_nodes_creator::merge_keys()
    … …  
    5551        for ( size_t i = 0; i < m_data->get_count(); ++i )
    5652        {
    57                 key_channel_set* old_keys = m_data->m_nodes[i].data;
     53                data_channel_set* old_keys = m_data->m_nodes[i].data;
    5854                if ( old_keys && old_keys->size() > 0 )
    5955                {
    … …  
    6965                        }
    7066
    71                         key_channel_set* new_keys = key_channel_set_creator::create( 1 );
    72                         key_channel_set_creator nk_access( new_keys );
     67                        data_channel_set* new_keys = data_channel_set_creator::create( 1 );
     68                        data_channel_set_creator nk_access( new_keys );
    7369                        data_channel_access< nv_key_transform > kt_channel( nk_access.add_channel<nv_key_transform>( max_keys ) );
    7470
    75                         data_descriptor final_key = old_keys->get_final_key();
     71                        raw_channel_interpolator interpolator( old_keys );
     72                        data_descriptor final_key = interpolator.get_interpolation_key();
    7673
    7774                        for ( unsigned n = 0; n < max_keys; ++n )
    … …  
    8380                                {
    8481                                        size_t idx = nv::min( old_keys->get_channel_size(c) - 1, n );
    85                                         pkey += old_keys->get_raw( *old_keys->get_channel(c), idx, pkey );
    86                                 }
    87                                 kt_channel.data()[n].tform = extract_transform_raw( final_key, key );
     82                                        pkey += raw_channel_interpolator::get_raw( *old_keys->get_channel(c), idx, pkey );
     83                                }
     84                                kt_channel.data()[n].tform = extract_key_raw< nv::transform >( final_key, key );
    8885                        }
    8986
    … …  
    106103                if ( node.data )
    107104                {
    108                         key_channel_set* kdata  = node.data;
     105                        data_channel_set* kdata  = node.data;
    109106                        for ( size_t c = 0; c < kdata->size(); ++c )
    110107                        {
    … …  
    332329                }
    333330        }
    334         delete tangents2;
     331        delete[] tangents2;
    335332
    336333        data_channel_set_creator( m_data ).set_channel( n_channel_index, merge_channels( *n_channel, g_channel ) );

  • trunk/src/gfx/skeletal_mesh.cc

    r418 r419  
    9191
    9292
     93void nv::skeletal_animation_entry_cpu::initialize()
     94{
     95        for ( size_t i = 0; i < m_node_data->get_count(); ++i )
     96        {
     97                if ( m_node_data->get_node( i )->data )
     98                {
     99                        m_interpolation_key = m_node_data->get_node( i )->data->get_interpolation_key();
     100                        break;
     101                }
     102        }
     103}
     104
    93105void nv::skeletal_animation_entry_cpu::update_skeleton( transform* skeleton, float time ) const
    94106{
    … …  
    100112        for ( size_t i = 0; i < m_node_data->get_count(); ++i )
    101113        {
    102                 skeleton[i] = m_node_data->get_node(i)->data->get_transform( frame_num );
     114                raw_channel_interpolator interpolator( m_node_data->get_node( i )->data, m_interpolation_key );
     115                skeleton[i] = interpolator.get< transform >( frame_num );
    103116        }
    104117}
    … …  
    112125        m_bone_ids  = new sint16[ node_count ];
    113126
     127        NV_ASSERT( m_node_data, "node data empty!" );
     128
    114129        if ( !m_node_data->is_flat() )
    115130        {
    … …  
    146161                        if ( node->data )
    147162                        {
    148                                 node_mat = node->data->get_matrix( anim_time );
     163                                raw_channel_interpolator interpolator( node->data, m_interpolation_key );
     164                                node_mat = interpolator.get< mat4 >( anim_time );
    149165                        }
    150166
    … …  
    177193                }
    178194                m_bone_ids[n] = bone_id;
     195
     196                if ( m_interpolation_key.size() == 0 && node->data )
     197                        m_interpolation_key = node->data->get_interpolation_key();
     198
    179199        }
    180200        m_prepared = true;
    … …  
    190210        if ( node->data )
    191211        {
    192                 node_mat = node->data->get_matrix( time );
     212                raw_channel_interpolator interpolator( node->data, m_interpolation_key );
     213                node_mat = interpolator.get< mat4 >( time );
    193214        }
    194215
Note: See TracChangeset for help on using the changeset viewer.