Changeset 484


Ignore:
Timestamp:
12/02/15 18:42:02 (10 years ago)
Author:
epyon
Message:
  • resource manager updates
  • nv-image added
  • missing stl memory added
  • several other missing files
Location:
trunk
Files:
15 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv.lua

    r471 r484  
    8888        links { "nv-core", "nv-lib", "nv-lua" }
    8989
     90project "nv-image"
     91        location (_ACTION.."/"..NV_RUNTIME)
     92        language "C++"
     93        kind "StaticLib"
     94        includedirs { "." }
     95        files { "nv/image/**.hh", "src/image/**.cc" }
     96        links { "nv-core" }
     97
    9098project "nv-formats"
    9199        location (_ACTION.."/"..NV_RUNTIME)

  • trunk/nv/core/resource.hh

    r481 r484  
    1717#include <nv/stl/string.hh>
    1818#include <nv/stl/hash_store.hh>
     19#include <nv/stl/vector.hh>
    1920
    2021
    … …  
    3132        class resource_handler
    3233        {
    33 
    34         protected:
    35                 virtual const void* lock( resource_id id, resource_type_id type_hash, bool checked = true ) = 0;
    36 //              virtual const void* create( resource_id id, resource_type_id type_hash ) = 0;
    37                 virtual void unlock( resource_id id, resource_type_id type_hash ) = 0;
    38                 virtual void release( resource_id id, resource_type_id type_hash ) = 0;
     34        public:
     35                resource_handler( resource_type_id id ) : m_type_id( id ) {}
     36
     37        protected:
     38                virtual const void* raw_lock( resource_id id, bool checked = true ) = 0;
     39                virtual void raw_add( resource_id id, void* value ) = 0;
     40                virtual void unlock( resource_id id ) = 0;
     41                virtual void release( resource_id id ) = 0;
     42                virtual bool exists( resource_id id ) = 0;
     43                virtual bool load_resource( const string_view& id ) = 0;
    3944
    4045                template< typename T >
    4146                const T* lock( resource_id id, bool checked = true )
    4247                {
    43                         return reinterpret_cast< const T* >( lock( id, shash64( rtti_type_hash<T>::hash() ), checked ) );
     48                        NV_ASSERT( rtti_type_hash<T>::hash() == m_type_id.value(), "Wrong type lock!" );
     49                        return reinterpret_cast< const T* >( raw_lock( id, checked ) );
    4450                }
    4551                template< typename T >
    4652                resource< T > create( resource_id id )
    4753                {
     54                        NV_ASSERT( rtti_type_hash<T>::hash() == m_type_id.value(), "Wrong type creation!" );
    4855                        resource< T > result;
    4956                        result.m_id = id;
    … …  
    5259                }
    5360
    54 //              template< typename T >
    55 //              resource< T > create( resource_id id )
    56 //              {
    57 //                      return reinterpret_cast<const T*>( create( id, rtti_type_hash<T>::hash() ) );
    58 //              }
     61
    5962
    6063                template < typename T >
    … …  
    6467                template < typename T >
    6568                friend class resource_lock;
    66 //              friend class resource_manager;
     69                friend class resource_manager;
     70
     71                resource_type_id m_type_id;
    6772        };
    6873
    … …  
    7984                ~resource()
    8085                {
    81                         if ( m_handler ) m_handler->release( m_id, shash64( rtti_type_hash<T>::hash() ) );
     86                        if ( m_handler ) m_handler->release( m_id );
    8287                }
    8388        protected:
    … …  
    156161                        , m_handler( r.m_handler )
    157162                        , m_resource( r.m_handler->lock<T>( r.m_id ) ) {}
    158                 explicit resource_lock( const resource_handle< T >& r, resource_handler* handler ) : m_id( r.m_id ), m_handler( handler ), m_resource( handler->lock( r.m_id, shash64( hash_value ) ) ) {}
     163                explicit resource_lock( const resource_handle< T >& r, resource_handler* handler ) : m_id( r.m_id ), m_handler( handler ), m_resource( handler->raw_lock( r.m_id ) ) {}
    159164                resource_lock( const resource_lock& ) = delete;
    160165                resource_lock& operator=( const resource_lock& other ) = delete;
    … …  
    170175                        if ( this != &other )
    171176                        {
    172                                 if ( m_handler ) m_handler->unlock( m_id, shash64( rtti_type_hash<T>::value ) );
     177                                if ( m_handler ) m_handler->unlock( m_id );
    173178                                m_id       = other.m_id;
    174179                                m_handler  = other.m_handler;
    … …  
    184189                ~resource_lock()
    185190                {
    186                         if ( m_handler ) m_handler->unlock( m_id, shash64( rtti_type_hash<T>::value ) );
     191                        if ( m_handler ) m_handler->unlock( m_id );
    187192                }
    188193        private:
    … …  
    193198
    194199
    195 //      class resource_manager : public resource_handler
    196 //      {
    197 //      public:
    198 //              template < typename T >
    199 //              shash64 register_resource_handler( resource_handler* handler )
    200 //              {
    201 //                      return register_resource_handler( handler, rtti_type_hash<T>::hash() );
    202 //              }
    203 //
    204 //              ~resource_manager()
    205 //              {
    206 //                      for ( auto p : m_handlers )
    207 //                      {
    208 //                              delete p.second;
    209 //                      }
    210 //              }
    211 //      protected:
    212 //              virtual const void* lock( resource_id id, resource_type_id type_hash )
    213 //              {
    214 //                      auto handler = m_handlers.find( type_hash );
    215 //                      NV_ASSERT( handler != m_handlers.end(), "Handler not registered!" );
    216 //                      return handler->second->lock( id, type_hash );
    217 //              }
    218 //
    219 // //           virtual const void* create( resource_id id, resource_type_id type_hash )
    220 // //           {
    221 // //                   auto handler = m_handlers.find( type_hash );
    222 // //                   NV_ASSERT( handler != m_handlers.end(), "Handler not registered!" );
    223 // //                   return handler->second->create( id, type_hash );
    224 // //           }
    225 //
    226 //              virtual void unlock( resource_id id, resource_type_id type_hash )
    227 //              {
    228 //                      auto handler = m_handlers.find( type_hash );
    229 //                      NV_ASSERT( handler != m_handlers.end(), "Handler not registered!" );
    230 //                      handler->second->unlock( id, type_hash );
    231 //              }
    232 //
    233 //              virtual void release( resource_id id, resource_type_id type_hash )
    234 //              {
    235 //                      auto handler = m_handlers.find( type_hash );
    236 //                      NV_ASSERT( handler != m_handlers.end(), "Handler not registered!" );
    237 //                      handler->second->release( id, type_hash );
    238 //              }
    239 //
    240 //              resource_type_id register_resource_handler( resource_handler* handler, resource_type_id type_hash )
    241 //              {
    242 //                      NV_ASSERT( m_handlers.find( type_hash ) == m_handlers.end(), "Handler already registered!" );
    243 //                      m_handlers[type_hash] = handler;
    244 //              }
    245 //
    246 //      protected:
    247 //              hash_store< resource_type_id, resource_handler* > m_handlers;
    248 //      };
     200        class resource_manager
     201        {
     202        public:
     203                template < typename T, typename Manager >
     204                Manager* register_resource_handler( Manager* handler )
     205                {
     206                        return static_cast<Manager*>( register_resource_handler( handler, resource_type_id( rtti_type_hash<T>::value ) ) );
     207                }
     208
     209                template < typename T >
     210                resource< T > get( const string_view& id )
     211                {
     212                        auto m = m_handlers.find( resource_type_id( rtti_type_hash<T>::value ) );
     213                        NV_ASSERT( m != m_handlers.end(), "Resource type unrecognized!" );
     214                        if ( m->second->exists( id ) || m->second->load_resource( id ) )
     215                                return m->second->create< T >( id );
     216                        // NV_ASSERT( false, "resource_manager.get failed!" );
     217                        return resource< T >();
     218                }
     219
     220                template < typename T >
     221                resource< T > get( uint64 id )
     222                {
     223                        auto m = m_handlers.find( resource_type_id( rtti_type_hash<T>::value ) );
     224                        NV_ASSERT( m != m_handlers.end(), "Resource type unrecognized!" );
     225                        if ( m->second->exists( id ) )
     226                        {
     227                                return m->second->create< T >( id );
     228                        }
     229                        // NV_ASSERT( false, "resource_manager.get failed!" );
     230                        return resource< T >();
     231                }
     232
     233                template < typename T >
     234                resource< T > add( shash64 id, T* value )
     235                {
     236                        auto m = m_handlers.find( resource_type_id( rtti_type_hash<T>::value ) );
     237                        NV_ASSERT( m != m_handlers.end(), "Resource type unrecognized!" );
     238                        m->second->raw_add( id, value );
     239                        return m->second->create< T >( id );
     240                }
     241
     242                virtual ~resource_manager()
     243                {
     244                        // reverse destruction order
     245                        for ( auto i = m_handler_list.rbegin(); i != m_handler_list.rend(); ++i )
     246                                delete *i;
     247                }
     248        protected:
     249
     250                resource_handler* register_resource_handler( resource_handler* handler, resource_type_id type_hash )
     251                {
     252                        NV_ASSERT( m_handlers.find( type_hash ) == m_handlers.end(), "Handler already registered!" );
     253                        m_handlers[type_hash] = handler;
     254                        m_handler_list.push_back( handler );
     255                        return handler;
     256                }
     257
     258        protected:
     259                // needed for destruction order
     260                vector< resource_handler* > m_handler_list;
     261                hash_store< resource_type_id, resource_handler* > m_handlers;
     262        };
    249263}
    250264

  • trunk/nv/engine/resource_system.hh

    r480 r484  
    3333                static void free( T* value ) { delete value; }
    3434                static T* to_pointer( T* value ) { return value; }
     35                static T* to_stored( void* value ) { return reinterpret_cast<T*>( value ); }
    3536        };
    3637
    … …  
    4142                static void free( T ) {}
    4243                static T* to_pointer( T& value ) { return &value; }
     44                static T to_stored( void* value ) { return *reinterpret_cast<T*>( value ); }
    4345        };
    4446
    4547        class resource_system;
    4648
    47         class custom_resource_manager_base : public resource_handler
    48         {
    49         public:
    50                 custom_resource_manager_base() {}
    51                 virtual void clear() = 0;
    52                 virtual bool load_resource( const string_view& id ) = 0;
    53         protected:
    54                 virtual void unlock( resource_id, resource_type_id ) {};
    55                 virtual void release( resource_id, resource_type_id ) {};
    56         };
    57 
    5849        class lua_resource_manager_base : public resource_handler
    5950        {
    6051        public:
    61                 lua_resource_manager_base() : m_lua( nullptr ) {}
     52                lua_resource_manager_base( resource_type_id id ) : resource_handler( id ), m_lua( nullptr ) {}
    6253                void initialize( lua::state* state );
    6354                virtual string_view get_storage_name() const = 0;
    … …  
    6556                virtual void clear() = 0;
    6657                void load_all();
    67                 bool load_resource( const string_view& id );
     58                virtual bool load_resource( const string_view& id );
    6859                virtual ~lua_resource_manager_base() {}
    6960        protected:
    7061                virtual bool load_resource( lua::table_guard& table, shash64 id ) = 0;
    71                 //              virtual const void* lock( resource_id id, resource_type_id );
    72                 virtual void unlock( resource_id, resource_type_id ) {};
    73                 virtual void release( resource_id, resource_type_id ) {};
    74 
    7562                lua::state* m_lua;
    7663        };
    7764
    78         template < typename T, bool Heap = true, typename Base = custom_resource_manager_base >
     65        template < typename T, bool Heap = true, typename Base = resource_handler >
    7966        class custom_resource_manager : public Base
    8067        {
    8168        public:
    8269                typedef resource_storage_policy< T, Heap > policy_type;
     70                typedef Base                       base_type;
    8371                typedef T                          value_type;
    8472                typedef resource< T >              resource_type;
    8573                typedef typename policy_type::type stored_type;
    8674
    87                 custom_resource_manager() {}
     75                custom_resource_manager() : base_type( resource_type_id( rtti_type_hash<T>::hash() ) ) {}
    8876                resource_type get( const string_view& id )
    8977                {
    90                         auto m = m_store.find( id );
    91                         if ( m != m_store.end() )
    92                         {
     78                        if ( exists( id ) )
    9379                                return create< T >( id );
    94                         }
    9580                        else
    9681                        {
    … …  
    10691                resource_type get( uint64 id )
    10792                {
    108                         auto m = m_store.find( shash64( id ) );
    109                         if ( m != m_store.end() )
    110                         {
    111                                 return create< T >( shash64( id ) );
    112                         }
     93                        if ( exists( shash64( id ) ) ) return create< T >( shash64( id ) );
    11394                        // NV_ASSERT( false, "resource_manager.get failed!" );
    11495                        return resource_type();
    … …  
    130111                }
    131112        protected:
     113
    132114                resource_type add( shash64 id, stored_type resource )
    133115                {
    … …  
    141123                }
    142124
    143                 virtual const void* lock( resource_id id, resource_type_id, bool )
     125                virtual bool exists( resource_id id )
     126                {
     127                        return m_store.find( shash64( id ) ) != m_store.end();
     128                }
     129
     130                virtual void raw_add( resource_id id, void* value )
     131                {
     132                        add( id, policy_type::to_stored( value ) );
     133                }
     134
     135
     136                virtual const void* raw_lock( resource_id id, bool )
    144137                {
    145138                        auto m = m_store.find( id );
    … …  
    147140                }
    148141
     142                virtual void unlock( resource_id ) {};
     143                virtual void release( resource_id ) {};
    149144                virtual void release( stored_type ) {}
    150145

  • trunk/nv/gfx/skeleton_instance.hh

    r483 r484  
    8686                void assign( const data_node_list* node_data );
    8787                void assign( const skeleton_transforms& other );
    88                 void interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t );
     88                void interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t );
     89                void interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t );
     90                void interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t );
     91                void interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t );
     92                void interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t );
    8993                void animate_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame );
    9094                void animate( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, bool local = false )

  • trunk/nv/interface/device.hh

    r473 r484  
    194194                virtual string_view get_shader_header() const = 0;
    195195
    196                 virtual texture create_texture( image_data* data, sampler asampler )
     196                virtual texture create_texture( const image_data* data, sampler asampler )
    197197                {
    198198                        return create_texture( data->get_size(), data->get_format(), asampler, data->get_data() );

  • trunk/nv/io/c_stream.hh

    r442 r484  
    3434                virtual bool gets( char* buffer, size_t max_count );
    3535                virtual bool seek( long offset, origin orig );
     36                virtual bool eof();
    3637                virtual size_t tell();
    3738                virtual size_t size();

  • trunk/nv/stl/math/quaternion.hh

    r471 r484  
    1717#include <nv/stl/math/constants.hh>
    1818#include <nv/stl/math/geometric.hh>
     19#include <nv/stl/math/exponential.hh>
    1920#include <nv/stl/math/angle.hh>
    2021#include <nv/base/cmath.hh>
    … …  
    150151                inline T length( const tquat<T>& q )
    151152                {
    152                         return math::sqrt( dot( q, q ) );
     153                        return nv::sqrt( dot( q, q ) );
    153154                }
    154155
    … …  
    157158                {
    158159                        T len = math::length( q );
    159                         if ( len <= T( 0 ) ) return tquat<T>( 1, 0, 0, 0 );
     160                        if ( len <= T( 0 ) )
     161                                return tquat<T>( 1, 0, 0, 0 );
    160162                        T rlen = T( 1 ) / len;
    161163                        return tquat<T>( q.w * rlen, q.x * rlen, q.y * rlen, q.z * rlen );
    … …  
    188190                        {
    189191                                T angle = nv::acos( cos_theta );
    190                                 return ( sin( ( T( 1 ) - m ) * angle ) * a + sin( m * angle ) * b ) / sin( angle );
     192                                return ( nv::sin( ( T( 1 ) - m ) * angle ) * a + nv::sin( m * angle ) * b ) / nv::sin( angle );
    191193                        }
    192194                }
    … …  
    195197                inline tquat<T> lerp( const tquat<T>& a, const tquat<T>& b, T m )
    196198                {
    197                         NV_ASSERT( m >= static_cast<T>( 0 ), "Bad argument to lerp!" );
    198                         NV_ASSERT( m <= static_cast<T>( 1 ), "Bad argument to lerp!" );
    199 
    200199                        return a * ( T( 1 ) - m ) + ( b * m );
     200                }
     201
     202                template < typename T >
     203                inline tquat<T> nlerp( const tquat<T>& a, const tquat<T>& b, T m )
     204                {
     205                        tquat<T> result( a * ( T( 1 ) - m ) + ( b * m ) );
     206                        return normalize( result );
    201207                }
    202208
    … …  
    224230                                return ( nv::sin( ( T( 1 ) - m ) * angle ) * x + nv::sin( m * angle ) * z ) / nv::sin( angle );
    225231                        }
     232                }
     233
     234                template < typename T >
     235                inline tquat<T> weighted_slerp( const tquat<T>& x, const tquat<T>& y, T m, T m1 )
     236                {
     237                        tquat<T> z = y;
     238                        T cos_theta = dot( x, y );
     239                        if ( cos_theta < T( 0 ) )
     240                        {
     241                                z = -y;
     242                                cos_theta = -cos_theta;
     243                        }
     244                        if ( cos_theta > T( 1 ) - epsilon<T>() )
     245                        {
     246                                return tquat<T>(
     247                                        x.w * m + z.w * m1,
     248                                        x.x * m + z.x * m1,
     249                                        x.y * m + z.y * m1,
     250                                        x.z * m + z.z * m1 );
     251                        }
     252                        else
     253                        {
     254                                T angle = nv::acos( cos_theta );
     255                                return ( nv::sin( m1 * angle ) * x + nv::sin( m * angle ) * z ) / nv::sin( angle );
     256                        }
     257                }
     258
     259
     260                template < typename T >
     261                inline tquat<T> exp( const tquat<T>& q )
     262                {
     263                        tvec3<T> u( q.x, q.y, q.z );
     264                        T angle = math::length( u );
     265                        if ( angle < epsilon<T>() )
     266                                return tquat<T>();
     267
     268                        tvec3<T> v( u / angle );
     269                        return tquat<T>( nv::cos( angle ), nv::sin( angle ) * v );
     270                }
     271
     272                template < typename T >
     273                inline tquat<T> pow( const tquat<T>& x, const T& y )
     274                {
     275                        if ( abs( x.w ) > ( static_cast<T>( 1 ) - epsilon<T>() ) )
     276                                return x;
     277                        T angle = acos( y );
     278                        T nangle = angle * y;
     279                        T div = sin( nangle ) / sin( angle );
     280                        return normalize( tquat<T>(
     281                                cos( nangle ),
     282                                x.x * div,
     283                                x.y * div,
     284                                x.z * div ) );
     285                }
     286                template < typename T >
     287                inline tquat<T> log( const tquat<T>& q )
     288                {
     289                        tvec3<T> u( q.x, q.y, q.z );
     290                        T veclen = length( u );
     291
     292                        if ( veclen < epsilon<T>() )
     293                        {
     294                                if ( q.w > T( 0 ) )
     295                                        return tquat<T>( nv::log( q.w ), T( 0 ), T( 0 ), T( 0 ) );
     296                                else if ( q.w < T( 0 ) )
     297                                        return tquat<T>( nv::log( -q.w ), pi<T>(), T( 0 ), T( 0 ) );
     298                                else
     299                                        return tquat<T>( INFINITY, INFINITY, INFINITY, INFINITY );
     300                        }
     301                        else
     302                        {
     303                                T quatlen = nv::sqrt( veclen * veclen + q.w * q.w );
     304                                T t = nv::atan2( veclen, T( q.w ) ) / veclen;
     305                                return tquat<T>( nv::log( quatlen ), t * q.x, t * q.y, t * q.z );
     306                        }
     307                }
     308
     309                template < typename T >
     310                tquat<T> intermediate( const tquat<T>& prev, const tquat<T>& curr, const tquat<T>& next )
     311                {
     312                        tquat<T> inv = inverse( curr );
     313                        return curr * math::exp( ( math::log( inv * next ) + math::log( inv * prev ) ) / T( -4 ) );
     314                }
     315
     316
     317                template <typename T>
     318                inline tquat<T> squad( const tquat<T>& q1, const tquat<T>& q2, const tquat<T>& s1, const tquat<T>& s2, const T& h )
     319                {
     320                        return slerp( slerp( q1, q2, h ), slerp( s1, s2, h ), T( 2 ) * ( T( 1 ) - h ) * h );
    226321                }
    227322

  • trunk/nv/stl/stream.hh

    r442 r484  
    3636                virtual bool gets( char* buffer, size_t max_count ) = 0;
    3737                virtual bool seek( long offset, origin orig ) = 0;
     38                virtual bool eof() = 0;
    3839                virtual size_t tell() = 0;
    3940                virtual size_t size() = 0;

  • trunk/src/gfx/skeleton_instance.cc

    r483 r484  
    5252        for ( uint32 n = 0; n < skeleton.size(); ++n )
    5353        {
    54                 m_matrix[n] = transforms[n].extract() * bones.m_offsets[n];
     54                transform tr( bones.m_offsets[n] );
     55                tr.set_orientation( normalize( tr.get_orientation() ) );
     56                m_matrix[n] = ( transforms[n] * tr ).extract();
     57        //      m_matrix[n] = transforms[n].extract() * bones.m_offsets[n];
    5558        }
    5659}
    … …  
    7477}
    7578
    76 void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     79void nv::skeleton_transforms::interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t )
    7780{
    7881        NV_ASSERT( a.size() == b.size(), "!!!" );
    … …  
    8184        for ( uint32 n = 0; n < a.size(); ++n )
    8285        {
     86                m_transforms[n] = transform(
     87                        math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
     88                        math::lerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
     89                        );
     90        }
     91
     92        if ( m_transforms.size() > 0 )
     93                m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t );
     94}
     95
     96void nv::skeleton_transforms::interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     97{
     98        NV_ASSERT( a.size() == b.size(), "!!!" );
     99        if ( m_transforms.size() != a.size() )
     100                m_transforms.resize( a.size() );
     101
     102        for ( uint32 n = 0; n < a.size(); ++n )
     103        {
     104                m_transforms[n] = transform(
     105                        math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
     106                        math::nlerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
     107                        );
     108        }
     109
     110        if ( m_transforms.size() > 0 )
     111                m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t );
     112}
     113
     114
     115void nv::skeleton_transforms::interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     116{
     117        NV_ASSERT( a.size() == b.size(), "!!!" );
     118        if ( m_transforms.size() != a.size() )
     119                m_transforms.resize( a.size() );
     120        for ( uint32 n = 0; n < a.size(); ++n )
     121        {
    83122                m_transforms[n] = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t );
    84123        }
     124}
     125
     126void nv::skeleton_transforms::interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
     127{
     128        NV_ASSERT( s1.size() == s2.size(), "!!!" );
     129        NV_ASSERT( v1.size() == v2.size(), "!!!" );
     130        NV_ASSERT( s1.size() == v1.size(), "!!!" );
     131        if ( m_transforms.size() != s1.size() )
     132                m_transforms.resize( s1.size() );
     133        float interp_squared = t*t;
     134        float interp_cubed = interp_squared*t;
     135        float weights[4];
     136        weights[0] = 0.5f * ( -interp_cubed + 2.0f * interp_squared - t );
     137        weights[1] = 0.5f * ( 3.0f * interp_cubed - 5.0f * interp_squared + 2.0f );
     138        weights[2] = 0.5f * ( -3.0f * interp_cubed + 4.0f * interp_squared + t );
     139        weights[3] = 0.5f * ( interp_cubed - interp_squared );
     140
     141        for ( uint32 n = 0; n < s1.size(); ++n )
     142        {
     143                quat qs1 = s1.m_transforms[n].get_orientation();
     144                quat qs2 = s2.m_transforms[n].get_orientation();
     145                quat qv1 = v1.m_transforms[n].get_orientation();
     146                quat qv2 = v2.m_transforms[n].get_orientation();
     147
     148                float a = dot( qv1, qv2 ) > 0.0f ? 1.0f : -1.0f;
     149
     150                quat qr = weights[0] * qs1
     151                                + weights[1] * (a * qv1 )
     152                                + weights[2] * qv2
     153                                + weights[3] * qs2;
     154
     155                qr = normalize( qr );
     156
     157                if ( n == 0 )
     158                        qr = nv::math::slerp( v1.m_transforms[n].get_orientation(), v2.m_transforms[n].get_orientation(), t );
     159
     160                m_transforms[n] = transform(
     161                        weights[0] * s1.m_transforms[n].get_position() +
     162                        weights[1] * v1.m_transforms[n].get_position() +
     163                        weights[2] * v2.m_transforms[n].get_position() +
     164                        weights[3] * s2.m_transforms[n].get_position(),
     165                        qr
     166                );
     167        }
     168}
     169
     170
     171void nv::skeleton_transforms::interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
     172{
     173        NV_ASSERT( s1.size() == s2.size(), "!!!" );
     174        NV_ASSERT( v1.size() == v2.size(), "!!!" );
     175        NV_ASSERT( s1.size() == v1.size(), "!!!" );
     176        if ( m_transforms.size() != s1.size() )
     177                m_transforms.resize( s1.size() );
     178
     179        for ( uint32 n = 0; n < s1.size(); ++n )
     180        {
     181                nv::quat ss1 = s1.m_transforms[n].get_orientation();
     182                nv::quat ss2 = s2.m_transforms[n].get_orientation();
     183                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 ),
     188                        t ) );
     189                if ( n == 0 ) q = nv::math::slerp(
     190                        v1.m_transforms[n].get_orientation(),
     191                        v2.m_transforms[n].get_orientation(), t );
     192
     193                m_transforms[n] = transform(
     194                        mix( v1.m_transforms[n].get_position(), v2.m_transforms[n].get_position(), t ),
     195                        q
     196                        );
     197        }
     198
    85199}
    86200
    … …  
    101215                {
    102216                        if ( node->size() > 0 )
     217                        {
    103218                                m_transforms[bone_id] = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame );
     219                        }
    104220                        int confirm_that_not_needed;
    105221//                      else
    … …  
    189305void nv::bone_transforms::prepare( const data_node_list& bone_data )
    190306{
    191         if ( m_offsets.empty() )
    192         {
    193                 m_offsets.resize( bone_data.size() );
    194 
    195                 for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
    196                         m_offsets[bi] = bone_data[bi].transform;
    197         }
    198 }
     307        m_offsets.resize( bone_data.size() );
     308
     309        for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
     310                m_offsets[bi] = bone_data[bi].transform;
     311}

  • trunk/src/io/c_stream.cc

    r442 r484  
    9393        }
    9494}
     95
     96bool nv::c_stream::eof()
     97{
     98        if ( m_file != nullptr )
     99        {
     100                return ::feof( reinterpret_cast<FILE*>( m_file ) );
     101        }
     102}
Note: See TracChangeset for help on using the changeset viewer.