Changeset 283

Timestamp:

07/10/14 20:58:27 (11 years ago)

Author:

epyon

Message:

• Nova Model Data format loader added
• keyframed mesh and skeletal mesh don't store time info anymore
• NMD loader has a temporary utility class for fast usage

Location:

trunk

Files:

• nv/formats/nmd_loader.hh (added)
• nv/gfx/keyframed_mesh.hh (modified) (2 diffs)
• nv/gfx/skeletal_mesh.hh (modified) (4 diffs)
• nv/interface/animated_mesh.hh (modified) (1 diff)
• src/formats/nmd_loader.cc (added)
• src/gfx/keyframed_mesh.cc (modified) (6 diffs)
• src/gfx/skeletal_mesh.cc (modified) (3 diffs)

trunk/nv/gfx/keyframed_mesh.hh

@@ -44 +44 @@
                 virtual void setup_animation( uint32 start, uint32 count, uint32 fps, bool loop );
                 virtual void set_frame( uint32 frame );
-                virtual void update( uint32 ms );
+                virtual void update_animation( animation_entry*, uint32 a_anim_time );
                 virtual void update( program* a_program ) const;
                 virtual ~keyframed_mesh();
@@ -65 +65 @@
                 uint32 m_last_frame;
                 uint32 m_next_frame;
-                uint32 m_time;
                 uint32 m_fps;
                 f32    m_interpolation;

trunk/nv/gfx/skeletal_mesh.hh

@@ -12 +12 @@
 #include <nv/interface/animated_mesh.hh>
 #include <nv/formats/md5_loader.hh>
+#include <nv/formats/nmd_loader.hh>
 
 namespace nv
@@ -26 +27 @@
                 virtual uint32 get_frame_count() const { return m_animation->get_frame_count(); }
                 virtual bool is_looping() const { return m_looping; }
+                uint32 get_num_joints() const { return m_animation->get_num_joints();}
+                void update_skeleton( transform* tr, float time ) const { return m_animation->update_skeleton( tr, time );}
         protected:
                 md5_animation* m_animation;
@@ -31 +34 @@
         };
 
-        // TODO: INSTANCING! currently md5_mesh data is deleted!
         class skeletal_mesh : public animated_mesh
         {
@@ -38 +40 @@
                 virtual size_t get_index_count() const { return m_mesh_data->get_index_count(); }
                 virtual void run_animation( animation_entry* a_anim );
-                virtual void setup_animation( md5_animation* a_anim );
-                virtual void update( uint32 ms );
+                virtual void update_animation( animation_entry* a_anim, uint32 a_anim_time );
                 virtual ~skeletal_mesh();
         protected:
                 md5_mesh_instance* m_mesh_data;
-                md5_animation*     m_animation;
+                std::vector< transform > m_transform;
+        };
 
-                std::vector< transform > m_transform;
-                uint32                   m_animation_time;
+        class skeletal_animation_entry_gpu : public animation_entry
+        {
+        public:
+                skeletal_animation_entry_gpu( const std::string& name, nmd_temp_animation* anim, bool a_looping ) 
+                        : animation_entry( name ), m_animation( anim ), m_looping( a_looping ), m_prepared( false ) {}
+                virtual uint32 get_frame_rate() const { return 0; }
+                virtual uint32 get_frame_count() const { return 0; }
+                virtual bool is_looping() const { return m_looping; }
+                void prepare( const nmd_temp_model* m_model );
+                void update_skeleton( mat4* tr, uint32 time );
+        protected:
+                nmd_temp_animation* m_animation;
+                bool           m_prepared;
+                bool           m_looping;
+        };
+
+        class skeletal_mesh_gpu : public animated_mesh
+        {
+        public:
+                skeletal_mesh_gpu( device* a_device, const nmd_temp_model* a_model, uint32 index, bool primary );
+                virtual size_t get_index_count() const { return m_index_count; }
+                virtual void run_animation( animation_entry* a_anim );
+                virtual void update( program* a_program ) const;
+                virtual void update_animation( animation_entry* a_anim, uint32 
+                        a_anim_time );
+        protected:
+                const nmd_temp_model* m_model;
+                bool m_primary;
+                uint32 m_index_count;
+                std::vector< mat4 > m_transform;
         };
 

trunk/nv/interface/animated_mesh.hh

@@ -39 +39 @@
         public:
                 animated_mesh() {}
+                virtual void update_animation( animation_entry*, uint32 ) {}
                 virtual void run_animation( animation_entry* ) {}
                 virtual transform get_tag( const std::string& ) const { return transform(); }

trunk/src/gfx/keyframed_mesh.cc

@@ -23 +23 @@
         , m_last_frame( 0 )
         , m_next_frame( 0 )
-        , m_time( 0 )
         , m_fps( 0 )
         , m_interpolation( 0.0f )
@@ -56 +55 @@
         m_fps           = fps;
         m_active        = count > 1;
-        m_time          = 0;
         m_last_frame    = start;
         m_next_frame    = (count > 1 ? start + 1 : start );
@@ -70 +68 @@
 }
 
-void keyframed_mesh::update( uint32 ms )
+void nv::keyframed_mesh::update_animation( animation_entry*, uint32 a_anim_time )
 {
         if ( m_active )
         {
-                m_time += ms;
                 uint32 f_diff = (m_stop_frame - m_start_frame);
-                float f_time  = 1000 / (float)m_fps;
+                float  f_time = 1000 / (float)m_fps;
                 float f_max   = ( m_looping ? ( f_diff + 1 ) : f_diff ) * f_time;
-                float f_pos   = m_time / f_time;
-
-                m_last_frame    = (uint32)glm::floor( f_pos ) + m_start_frame;
-                m_next_frame    = m_last_frame + 1;
-                if ( m_next_frame > m_stop_frame )
-                {
-                        m_next_frame = m_start_frame;
-                }
-
-                if ( m_time >= f_max )
+                uint32 time   = a_anim_time;
+                if ( time >= f_max )
                 {
                         if ( m_looping )
                         {
-                                uint32 left = m_time - static_cast< uint32 >( f_max );
-                                m_time = 0;
-                                update( left );
+                                time = time % static_cast< uint32 >( f_max );
                         }
                         else
@@ -102 +89 @@
                         }
                 }
+                float f_pos   = time / f_time;
+
+                m_last_frame    = (uint32)glm::floor( f_pos ) + m_start_frame;
+                m_next_frame    = m_last_frame + 1;
+                if ( m_next_frame > m_stop_frame ) m_next_frame = m_start_frame;
                 m_interpolation = f_pos - glm::floor( f_pos );
         }
 }
+
 
 void nv::keyframed_mesh::update( program* a_program ) const
@@ -148 +141 @@
 void nv::keyframed_mesh_gpu::update( uint32 ms )
 {
-        keyframed_mesh::update( ms );
+        animated_mesh::update( ms );
 
         if ( m_gpu_last_frame != m_last_frame )
@@ -181 +174 @@
 void nv::keyframed_mesh_cpu::update( uint32 ms )
 {
-        keyframed_mesh::update( ms );
+        animated_mesh::update( ms );
 
         const vertex_pn* data = m_mesh_data->get_channel_data<vertex_pn>();

trunk/src/gfx/skeletal_mesh.cc

@@ -14 +14 @@
         : animated_mesh()
         , m_mesh_data( nullptr )
-        , m_animation( nullptr )
-        , m_animation_time( 0 )
 {
         m_mesh_data = a_mesh_data->spawn();
@@ -21 +19 @@
 }
 
-
-void nv::skeletal_mesh::setup_animation( md5_animation* a_anim )
+void nv::skeletal_mesh::update_animation( animation_entry* a_anim, uint32 a_anim_time )
 {
-        m_animation      = a_anim;
-        m_animation_time = 0;
-        if ( m_animation )
+        if ( a_anim )
         {
-                m_transform.resize( m_animation->get_num_joints() );
-                update( 0 );
-        }
-}
-
-void nv::skeletal_mesh::update( uint32 ms )
-{
-        if ( m_animation )
-        {
-                m_animation_time += ms;
-                float frame_duration = 1000.f / (float)m_animation->get_frame_rate();
-                uint32 anim_duration = uint32( frame_duration * (float)m_animation->get_frame_count() );
-                while ( m_animation_time >= anim_duration ) m_animation_time -= anim_duration;
-                m_animation->update_skeleton( m_transform.data(), (float)m_animation_time * 0.001f );
+                skeletal_animation_entry * anim = (skeletal_animation_entry*)a_anim;
+                float frame_duration = 1000.f / (float)anim->get_frame_rate();
+                uint32 anim_duration = uint32( frame_duration * (float)anim->get_frame_count() );
+                uint32 new_time = a_anim_time % anim_duration;
+                anim->update_skeleton( m_transform.data(), (float)new_time * 0.001f );
                 m_mesh_data->apply( m_transform.data() );
                 vertex_buffer* vb = m_va->find_buffer( nv::slot::POSITION );
@@ -60 +46 @@
         if ( a_anim != nullptr )
         {
-                skeletal_animation_entry * anim = down_cast<skeletal_animation_entry>(a_anim);
-                setup_animation( anim->m_animation );
-        }
-        else
-        {
-                setup_animation( nullptr );
+                skeletal_animation_entry * anim = (skeletal_animation_entry*)(a_anim);
+                m_transform.resize( anim->get_num_joints() );
+                update_animation( a_anim, 0 );
         }
 }
+
+void nv::skeletal_animation_entry_gpu::update_skeleton( mat4* data, uint32 time )
+{
+        m_animation->animate( data, time );
+}
+
+void nv::skeletal_animation_entry_gpu::prepare( const nmd_temp_model* m_model )
+{
+        m_animation->prepare( m_model );
+}
+
+nv::skeletal_mesh_gpu::skeletal_mesh_gpu( device* a_device, const nmd_temp_model* a_model, uint32 index, bool primary )
+        : animated_mesh(), m_primary( primary ), m_model( a_model )
+{
+        const mesh_data* data = a_model->get_data( index );
+        m_va          = a_device->create_vertex_array( data, nv::STATIC_DRAW );
+        m_index_count = data->get_count();
+}
+
+void nv::skeletal_mesh_gpu::run_animation( animation_entry* a_anim )
+{
+        if ( m_primary && a_anim != nullptr )
+        {
+                skeletal_animation_entry_gpu * anim = (skeletal_animation_entry_gpu*)(a_anim);
+                m_transform.resize( m_model->get_bone_count() );
+                anim->prepare( m_model );
+                update_animation( a_anim, 0 );
+        }
+}
+
+void nv::skeletal_mesh_gpu::update_animation( animation_entry* a_anim, uint32 a_anim_time )
+{
+        if ( m_primary && a_anim )
+        {
+                skeletal_animation_entry_gpu * anim = (skeletal_animation_entry_gpu*)a_anim;
+                anim->update_skeleton( m_transform.data(), a_anim_time );
+        }
+}
+
+void nv::skeletal_mesh_gpu::update( program* a_program ) const
+{
+        if (m_primary)
+                a_program->set_uniform_array( "nv_m_bones", m_transform );
+}