Changeset 470 for trunk/src

Timestamp:

09/17/15 17:19:14 (10 years ago)

Author:

epyon

Message:

• animation time definition fixes

Location:

trunk/src

Files:

• formats/assimp_loader.cc (modified) (1 diff)
• formats/nmd_loader.cc (modified) (2 diffs)
• gfx/keyframed_mesh.cc (modified) (1 diff)
• gfx/mesh_creator.cc (modified) (4 diffs)
• gfx/skeletal_mesh.cc (modified) (7 diffs)
• wx/wx_canvas.cc (modified) (2 diffs)

trunk/src/formats/assimp_loader.cc

@@ -350 +350 @@
 
         uint16 frame_rate     = static_cast<uint16>( anim->mTicksPerSecond );
-        float  duration       = static_cast<float>( anim->mDuration );
+        int check_this;
+        uint16 duration       = static_cast<uint16>( anim->mDuration );
         bool   flat           = false;
 

trunk/src/formats/nmd_loader.cc

@@ -98 +98 @@
         nmd_animation_header animation_header;
         source.read( &animation_header, sizeof( animation_header ), 1 );
-        m_node_data = new mesh_nodes_data( e.name, animation_header.frame_rate, animation_header.duration, animation_header.flat );
+        m_node_data = new mesh_nodes_data( e.name, animation_header.frame_rate, animation_header.frame_count, animation_header.flat );
         for ( uint32 i = 0; i < e.children; ++i )
         {
@@ -215 +215 @@
 
         nmd_animation_header aheader;
-        aheader.frame_rate = nodes.get_frame_rate();
-        aheader.duration = nodes.get_duration();
+        aheader.frame_rate  = nodes.get_fps();
+        aheader.frame_count = nodes.get_frame_count();
         aheader.flat = nodes.is_flat();
         stream_out.write( &aheader, sizeof( aheader ), 1 );

trunk/src/gfx/keyframed_mesh.cc

@@ -72 +72 @@
 }
 
-void nv::keyframed_mesh::update_animation( animation_entry* anim, uint32 a_anim_time )
+void nv::keyframed_mesh::update_animation( animation_entry* anim, uint32 a_ms_anim_time )
 {
         if ( m_active )
         {
-                float tick_time = ( static_cast<float>( a_anim_time ) * 0.001f ) * anim->get_frame_rate();
-                float duration  = anim->is_looping() ? anim->get_duration() + 1.0f : anim->get_duration();
-                if ( tick_time >= duration )
+                float  fframe   = ( static_cast<float>( a_ms_anim_time ) * 0.001f ) * anim->get_fps();
+                uint32 frame    = uint32( fframe );
+                float  reminder = fframe - static_cast<float>( frame );
+                uint32 duration = anim->is_looping() ? anim->get_frame_count() + 1 : anim->get_frame_count();
+
+                if ( frame >= duration )
                 {
                         if ( anim->is_looping() )
                         {
-                                tick_time = fmodf( tick_time, duration );
+                                frame  = frame % duration;
+                                fframe = static_cast<float>( frame ) + reminder;
                         }
                         else
                         {
-                                m_active     = false;
-                                m_last_frame = static_cast<uint32>( anim->get_end() );
-                                m_next_frame = m_last_frame;
+                                m_active        = false;
+                                m_last_frame    = anim->get_end_frame();
+                                m_next_frame    = m_last_frame;
                                 m_interpolation = 0.0f;
                                 return;
                         }
                 }
-                m_last_frame    = static_cast<uint32>( math::floor( tick_time ) + anim->get_start() );
+                m_last_frame    = frame + anim->get_start_frame();
                 m_next_frame    = m_last_frame + 1;
-                if ( m_next_frame > static_cast<uint32>( anim->get_end() ) ) m_next_frame = static_cast<uint32>( anim->get_start() );
-                m_interpolation = tick_time - math::floor( tick_time );
+                if ( m_next_frame > anim->get_end_frame() ) m_next_frame = anim->get_start_frame();
+                m_interpolation = reminder;
         }
 }

trunk/src/gfx/mesh_creator.cc

@@ -9 +9 @@
 #include "nv/interface/data_channel_access.hh"
 
+#include "nv/core/logging.hh"
+
 struct nv_key_transform { nv::transform tform; };
 
@@ -16 +18 @@
         merge_keys();
         uint32 max_frames = 0;
-        for ( auto keys : m_data->m_data )
-        {
+
+        nv::vector< sint16 > ids;
+        {
+                // TODO: simplify this shit!
+                // The complexity here is that we cannot pre-transform in any order
+                // as the bones depend on previous bones, but ARE NOT IN ORDER
+                // 
+                // Either rewrite this a lot nicer, or sort the bones on creation
+                // by tree-order.
+
+                ids.reserve( m_data->m_data.size() );
+                {
+                        nv::vector< sint16 > ids_next;
+                        ids_next.reserve( m_data->m_data.size() );
+                        ids_next.push_back( -1 );
+                        while ( !ids_next.empty() )
+                        {
+                                sint16 pid = ids_next.back();
+                                ids_next.pop_back();
+                                for ( sint16 i = 0; i < sint16(m_data->m_data.size()); ++i )
+                                        if ( m_data->m_data[i]->get_parent_id() == pid )
+                                        {
+                                                sint16* it = nv::find( ids.begin(), ids.end(), i );
+                                                if ( it == ids.end() )
+                                                {
+                                                        ids.push_back( i );
+                                                        ids_next.push_back( i );
+                                                }
+                                        }
+                        }
+                }
+
+                if ( ids.size() != m_data->m_data.size() )
+                {
+                        NV_LOG_WARNING( "Bad skeleton!" );
+                }
+        }
+
+        NV_LOG_DEBUG( "ID/PID" );
+        for ( auto id : ids )
+        {
+                data_channel_set* keys = m_data->m_data[id];
                 sint16 parent_id = keys->get_parent_id();
-                data_channel_set* pkeys  = ( parent_id != -1 ? m_data->m_data[parent_id] : nullptr );
+                NV_LOG_DEBUG( "Id : ", id, " PID", parent_id );
+                data_channel_set* pkeys = ( parent_id != -1 ? m_data->m_data[parent_id] : nullptr );
                 size_t count     = ( keys ? keys->get_channel_size(0) : 0 );
                 size_t pcount    = ( pkeys ? pkeys->get_channel_size(0) : 0 );
@@ -26 +69 @@
                 {
                         data_channel_access< nv_key_transform > channel_creator( keys, 0 );
+
                         nv_key_transform* channel = channel_creator.data();
                         const nv_key_transform* pchannel = pkeys->get_channel(0)->data_cast< nv_key_transform >();
@@ -38 +82 @@
         if ( m_data->m_frame_rate == 1 )
         {
-                m_data->m_frame_rate = 32;
-                m_data->m_duration   = static_cast<float>( max_frames );
+                m_data->m_frame_rate  = 32;
+                m_data->m_frame_count = max_frames;
         }
 

trunk/src/gfx/skeletal_mesh.cc

@@ -13 +13 @@
 void nv::skeletal_animation_entry::initialize()
 {
+        m_root      = uint32(-1);
         m_prepared  = false;
         m_children  = nullptr;
@@ -30 +31 @@
                                 m_children[ node->get_parent_id()].push_back( n );
                         }
-                }
-        }
-}
-
-void nv::skeletal_animation_entry::update_skeleton( mat4* data, uint32 time ) const
-{
-        float tick_time = ( time * 0.001f ) * m_frame_rate;
-        float anim_time = m_start;
-        if ( m_duration > 0.0f ) anim_time += fmodf( tick_time, m_duration );
+                        else
+                        {
+                                if ( m_root >= 0 )
+                                {
+                                        m_root = uint32( -2 );
+                                }
+                                else
+                                        m_root = n;
+                        }
+                }
+                NV_ASSERT( m_root != uint32( -1 ), "Animation without root!" );
+        }
+}
+
+void nv::skeletal_animation_entry::update_skeleton( mat4* data, uint32 a_ms_time ) const
+{
+        float  fframe   = ( a_ms_time * 0.001f ) * m_fps;
+        uint32 frame    = math::floor( fframe );
+        float  reminder = fframe - static_cast<float>( frame );
+        uint32 duration = get_frame_count();
+        if ( duration == 0 )
+        {
+                frame  = get_start_frame();
+                fframe = static_cast<float>( frame );
+        }
+        else if ( frame >= duration )
+        {
+                if ( is_looping() )
+                {
+                        frame  = frame % duration;
+                        fframe = static_cast<float>( frame ) + reminder;
+                }
+                else
+                {
+                        frame  = get_end_frame();
+                        fframe = static_cast<float>( frame );
+                }
+        }
 
         if ( !m_node_data->is_flat() )
         {
-                animate_rec( data, anim_time, 0, mat4() );
+                if ( m_root == uint32( -2 ) ) // multi-root
+                {
+                        for ( uint32 n = 0; n < m_node_data->size(); ++n )
+                                if ( ( *m_node_data )[n]->get_parent_id() == -1 )
+                                        animate_rec( data, fframe, n, mat4() );
+                }
+                else
+                        animate_rec( data, fframe, m_root, mat4() );
                 return;
         }
@@ -55 +92 @@
                         {
                                 raw_channel_interpolator interpolator( node, m_interpolation_key );
-                                node_mat = interpolator.get< mat4 >( anim_time );
+                                node_mat = interpolator.get< mat4 >( fframe );
                         }
 
@@ -66 +103 @@
 {
         if ( m_prepared ) return;
-        unordered_map< uint64, uint16 > bone_names;
+        nv::hash_store< shash64, uint16 > bone_names;
         m_offsets = new mat4[ bones->size() ];
         for ( nv::uint16 bi = 0; bi < bones->size(); ++bi )
         {
                 const data_channel_set* bone = (*bones)[ bi ];
-                bone_names[ bone->get_name().value() ] = bi;
+                bone_names[ bone->get_name() ] = bi;
                 m_offsets[bi] = bone->get_transform();
         }
@@ -80 +117 @@
                 sint16 bone_id = -1;
 
-                auto bi = bone_names.find( node->get_name().value() );
+                auto bi = bone_names.find( node->get_name() );
                 if ( bi != bone_names.end() )
                 {
@@ -129 +166 @@
 
 nv::skeletal_mesh::skeletal_mesh( context* a_context, const data_channel_set* a_mesh, const mesh_nodes_data* a_bone_data )
-        : m_context( a_context ), m_bone_data( a_bone_data ), m_index_count( 0 ), m_transform( nullptr )
+        : m_context( a_context ), m_bone_data( a_bone_data ), m_index_count( 0 ), m_transform( nullptr ), m_parent_id(-1)
 {
         if ( a_mesh )
@@ -135 +172 @@
                 m_va = a_context->create_vertex_array( a_mesh, nv::STATIC_DRAW );
                 m_index_count = a_mesh->get_channel_size( slot::INDEX );
+                m_parent_id = a_mesh->get_parent_id();
         }
         if ( m_bone_data )

trunk/src/wx/wx_canvas.cc

@@ -6 +6 @@
 
 #include <nv/wx/wx_canvas.hh>
+
+#include <nv/core/time.hh>
 
 wxBEGIN_EVENT_TABLE( nv::wx_gl_canvas, wxWindow )
@@ -51 +53 @@
 void nv::wx_gl_canvas::on_idle( wxIdleEvent& evt )
 {
+        nv::sleep( 10 );
         if ( m_render )
         {