Changeset 230

Timestamp:

05/06/14 12:39:51 (11 years ago)

Author:

epyon

Message:

• animated_mesh, scene_node, camera and transform classes added
• order in mesh hierarchies
• simplified and generified animation class hierarchy

Location:

trunk

Files:

• nv/formats/md3_loader.hh (modified) (3 diffs)
• nv/gfx/keyframed_mesh.hh (modified) (4 diffs)
• nv/gfx/mesh_data.hh (modified) (2 diffs)
• nv/gfx/skeletal_mesh.hh (modified) (3 diffs)
• nv/interface/animated_mesh.hh (added)
• nv/interface/camera.hh (added)
• nv/interface/font.hh (added)
• nv/interface/scene_node.hh (added)
• nv/transform.hh (added)
• src/formats/md3_loader.cc (modified) (4 diffs)
• src/gfx/keyframed_mesh.cc (modified) (7 diffs)
• src/gfx/skeletal_mesh.cc (modified) (3 diffs)
• tests/md3_test (added)
• tests/md5_test (added)

trunk/nv/formats/md3_loader.hh

@@ -17 +17 @@
 #include <unordered_map>
 #include <vector>
+#include <nv/transform.hh>
 #include <nv/gfx/mesh_data.hh>
 #include <nv/interface/mesh_loader.hh>
@@ -26 +27 @@
         {
                 std::string name;
-                mat4 transform;
+                transform   trans;
         };
 
@@ -40 +41 @@
 
                 virtual const md3_tag* get_tag( const std::string& name ) const;
-                virtual mat4 get_tag( sint32 frame, const std::string& name ) const;
+                virtual transform get_tag( sint32 frame, const std::string& name ) const;
                 size_t get_max_frames() const;
                 void load_tag_names( std::vector< std::string >& tags );
-                void load_tags( std::vector<mat4>& t, const std::string& tag );
+                void load_tags( std::vector<transform>& t, const std::string& tag );
                 void load_positions( std::vector<vec3>& p, sint32 frame =-1 );
                 void load_normals( std::vector<vec3>& n, sint32 frame =-1 );

trunk/nv/gfx/keyframed_mesh.hh

@@ -10 +10 @@
 #include <nv/common.hh>
 #include <nv/interface/context.hh>
+#include <nv/interface/animated_mesh.hh>
 #include <nv/formats/md3_loader.hh>
 
@@ -15 +16 @@
 {
 
-        class keyframed_mesh
+        class keyframed_animation_entry : public animation_entry
         {
         public:
-                keyframed_mesh( context* a_context, mesh_data* a_data, program* a_program );
+                friend class keyframed_mesh;
+
+                keyframed_animation_entry( const std::string& name, uint32 a_start, uint32 a_frames, uint32 a_fps, bool a_loop )
+                        : animation_entry( name ), m_start( a_start ), m_frames( a_frames ), m_fps( a_fps ), m_looping( a_loop ) {}
+                virtual uint32 get_frame_rate() const { return m_fps; }
+                virtual uint32 get_frame_count() const { return m_frames; }
+                virtual bool is_looping() const { return m_looping; }
+        protected:
+                uint32 m_start;
+                uint32 m_frames;
+                uint32 m_fps;
+                bool   m_looping;
+        };
+
+
+        class keyframed_mesh : public animated_mesh
+        {
+        public:
+                keyframed_mesh( context* a_context, mesh_data* a_data );
+                virtual size_t get_index_count() const { return m_data->get_index_count(); }
+                virtual void run_animation( animation_entry* a_anim );
                 size_t get_max_frames() const;
-                mat4 get_tag( const std::string& tag ) const;
+                transform get_tag( const std::string& tag ) const;
                 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 draw( render_state& rstate );
-                program* get_program() { return m_program; }
+                virtual void update( program* a_program );
                 virtual ~keyframed_mesh();
         protected:
-                context*      m_context;
                 mesh_data*    m_data;
-                program*      m_program;
-                vertex_array* m_va;
 
                 uint32 m_start_frame;
@@ -49 +66 @@
         public:
                 keyframed_mesh_gpu( context* a_context, mesh_data* a_data, program* a_program );
-                void draw( render_state& rstate );
+                void update( uint32 ms );
         private:
                 int m_loc_next_position;
@@ -61 +78 @@
         {
         public:
-                keyframed_mesh_cpu( context* a_context, mesh_data* a_data, program* a_program );
+                keyframed_mesh_cpu( context* a_context, mesh_data* a_data );
                 void update( uint32 ms );
         private:

trunk/nv/gfx/mesh_data.hh

@@ -11 +11 @@
 #include <unordered_map>
 #include <vector>
+#include <nv/math.hh>
+#include <nv/transform.hh>
 #include <nv/interface/device.hh>
-#include <nv/math.hh>
 
 namespace nv
@@ -20 +21 @@
         public:
                 friend class mesh_data_creator;
-                typedef std::vector< mat4 > transforms;
+                typedef std::vector< transform > transforms;
                 typedef std::unordered_map< std::string, transforms > tag_map;
 

trunk/nv/gfx/skeletal_mesh.hh

@@ -10 +10 @@
 #include <nv/common.hh>
 #include <nv/interface/context.hh>
+#include <nv/interface/animated_mesh.hh>
 #include <nv/formats/md5_loader.hh>
 
@@ -15 +16 @@
 {
 
-        class skeletal_mesh
+        class skeletal_animation_entry : public animation_entry
         {
         public:
-                skeletal_mesh( context* a_context, program* a_program, md5_loader* a_loader );
+                friend class skeletal_mesh;
+
+                skeletal_animation_entry( const std::string& name, md5_animation* a_animation, bool a_looping ) 
+                        : animation_entry( name ), m_animation( a_animation ), m_looping( a_looping ) {}
+                virtual uint32 get_frame_rate() const { return m_animation->get_frame_rate(); }
+                virtual uint32 get_frame_count() const { return m_animation->get_frame_count(); }
+                virtual bool is_looping() const { return m_looping; }
+        protected:
+                md5_animation* m_animation;
+                bool           m_looping;
+        };
+
+        class skeletal_mesh : public animated_mesh
+        {
+        public:
+                skeletal_mesh( context* a_context, md5_loader* a_loader );
+                virtual size_t get_index_count() const { return m_data->get_index_count(0); }
+                virtual void run_animation( animation_entry* a_anim );
                 virtual void setup_animation( md5_animation* a_anim );
                 virtual void update( uint32 ms );
-                virtual void draw( render_state& rstate );
-                program* get_program() { return m_program; }
                 virtual ~skeletal_mesh();
         protected:
-                context*      m_context;
-                program*      m_program;
-                vertex_array* m_va;
-
                 vertex_buffer* m_vb_position;
                 vertex_buffer* m_vb_normal;
@@ -35 +47 @@
                 md5_loader*    m_data;
                 md5_animation* m_animation;
-
-                uint32 m_start_frame;
-                uint32 m_stop_frame;
-                uint32 m_last_frame;
-                uint32 m_next_frame;
-                uint32 m_time;
-                uint32 m_fps;
-                f32    m_interpolation;
-                bool   m_looping;
-                bool   m_active;
         };
 

trunk/src/formats/md3_loader.cc

@@ -328 +328 @@
 */
 
-void nv::md3_loader::load_tags( std::vector<mat4>& t, const std::string& tag )
+void nv::md3_loader::load_tags( std::vector<transform>& t, const std::string& tag )
 {
         md3_t* md3 = (md3_t*)m_md3;
@@ -340 +340 @@
                         if (rname == tag)
                         {
-                                vec4 axisx     = vec4( md3_vec3( rtag.axis[0] ), 0.0 );
-                                vec4 axisz     = vec4( md3_vec3( rtag.axis[1] ), 0.0 );
-                                vec4 axisy     = vec4( md3_vec3( rtag.axis[2] ), 0.0 );
-                                vec4 origin    = vec4( md3_vec3( rtag.origin ),  1.0 );
-                                t.emplace_back( axisx, axisy, axisz, origin );
+                                vec3 axisx  ( md3_vec3( rtag.axis[0] ) );
+                                vec3 axisz  ( md3_vec3( rtag.axis[1] ) );
+                                vec3 axisy  ( md3_vec3( rtag.axis[2] ) );
+                                vec3 origin ( md3_vec3( rtag.origin )  );
+                                t.emplace_back( origin, quat( mat3( axisx, axisy, axisz ) ) );
                         }
                 }
@@ -406 +406 @@
 }
 
-mat4 md3_loader::get_tag( sint32 frame, const std::string& name ) const
+transform md3_loader::get_tag( sint32 frame, const std::string& name ) const
 {
         md3_t* md3 = (md3_t*)m_md3;
@@ -415 +415 @@
                 if (rname == name)
                 {
-                        vec4 axisx     = vec4( md3_vec3( rtag.axis[0] ), 0.0 );
-                        vec4 axisz     = vec4( md3_vec3( rtag.axis[1] ), 0.0 );
-                        vec4 axisy     = vec4( md3_vec3( rtag.axis[2] ), 0.0 );
-                        vec4 origin    = vec4( md3_vec3( rtag.origin ),  1.0 );
-                        return glm::mat4( axisx, axisy, axisz, origin );
-                }
-        }
-        return glm::mat4();
+                        vec3 axisx ( md3_vec3( rtag.axis[0] ) );
+                        vec3 axisz ( md3_vec3( rtag.axis[1] ) );
+                        vec3 axisy ( md3_vec3( rtag.axis[2] ) );
+                        vec3 origin( md3_vec3( rtag.origin ) );
+                        return transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
+                }
+        }
+        return transform();
 }
 

trunk/src/gfx/keyframed_mesh.cc

@@ -15 +15 @@
 using namespace nv;
 
-keyframed_mesh::keyframed_mesh( context* a_context, mesh_data* a_data, program* a_program )
-        : m_context( a_context )
+keyframed_mesh::keyframed_mesh( context* a_context, mesh_data* a_data )
+        : animated_mesh( a_context )
         , m_data( a_data )
-        , m_program( a_program )
-        , m_va( nullptr )
         , m_start_frame( false )
         , m_stop_frame( false )
@@ -38 +36 @@
 }
 
-mat4 keyframed_mesh::get_tag( const std::string& tag ) const
-{
-        const std::vector< nv::mat4 >& transforms = m_data->get_tag_map().at( tag );
-        return glm::interpolate( transforms[ m_last_frame ], transforms[ m_next_frame ], m_interpolation );
+transform keyframed_mesh::get_tag( const std::string& tag ) const
+{
+        const std::vector< transform >& transforms = m_data->get_tag_map().at( tag );
+        return interpolate( transforms[ m_last_frame ], transforms[ m_next_frame ], m_interpolation );
 }
 
@@ -101 +99 @@
 }
 
-void nv::keyframed_mesh::draw( render_state& rstate )
-{
-        m_program->set_opt_uniform( "nv_interpolate", m_interpolation );
-        m_context->draw( nv::TRIANGLES, rstate, m_program, m_va, m_data->get_index_count() );
+void nv::keyframed_mesh::update( program* a_program )
+{
+        a_program->set_opt_uniform( "nv_interpolate", m_interpolation );
 }
 
@@ -112 +109 @@
 }
 
+void nv::keyframed_mesh::run_animation( animation_entry* a_anim )
+{
+        keyframed_animation_entry * anim = down_cast<keyframed_animation_entry>(a_anim);
+        setup_animation( anim->m_start, anim->m_frames, anim->m_fps, anim->m_looping );
+}
+
 keyframed_mesh_gpu::keyframed_mesh_gpu( context* a_context, mesh_data* a_data, program* a_program )
-        : keyframed_mesh( a_context, a_data, a_program )
+        : keyframed_mesh( a_context, a_data )
         , m_loc_next_position( 0 )
         , m_loc_next_normal( 0 )
@@ -120 +123 @@
 {
         nv::vertex_buffer* vb;
-        m_loc_next_position = m_program->get_attribute( "nv_next_position" )->get_location();
-        m_loc_next_normal   = m_program->get_attribute( "nv_next_normal" )->get_location();
+        m_loc_next_position = a_program->get_attribute( "nv_next_position" )->get_location();
+        m_loc_next_normal   = a_program->get_attribute( "nv_next_normal" )->get_location();
 
         vb = m_context->get_device()->create_vertex_buffer( nv::STATIC_DRAW, m_data->get_vertex_count() * sizeof( nv::vec3 ) * m_data->get_frame_count(), (void*)m_data->get_positions().data() );
@@ -137 +140 @@
 }
 
-void nv::keyframed_mesh_gpu::draw( render_state& rstate )
-{
+void nv::keyframed_mesh_gpu::update( uint32 ms )
+{
+        keyframed_mesh::update( ms );
+
         size_t vtx_count = m_data->get_vertex_count();
         if ( m_gpu_last_frame != m_last_frame )
@@ -152 +157 @@
                 m_gpu_next_frame = m_next_frame;
         }
-        keyframed_mesh::draw( rstate );
-}
-
-
-nv::keyframed_mesh_cpu::keyframed_mesh_cpu( context* a_context, mesh_data* a_data, program* a_program )
-        : keyframed_mesh( a_context, a_data, a_program )
+}
+
+
+nv::keyframed_mesh_cpu::keyframed_mesh_cpu( context* a_context, mesh_data* a_data )
+        : keyframed_mesh( a_context, a_data )
 {
         m_vb_position = m_context->get_device()->create_vertex_buffer( nv::STATIC_DRAW, m_data->get_vertex_count() * sizeof( nv::vec3 ), (void*)m_data->get_position_frame(0) );

trunk/src/gfx/skeletal_mesh.cc

@@ -11 +11 @@
 
 
-nv::skeletal_mesh::skeletal_mesh( context* a_context, program* a_program, md5_loader* a_loader )
-        : m_context( a_context )
-        , m_program( a_program )
-        , m_va( nullptr )
+nv::skeletal_mesh::skeletal_mesh( context* a_context, md5_loader* a_loader )
+        : animated_mesh( a_context )
         , m_data( a_loader )
         , m_animation( nullptr )
@@ -38 +36 @@
         if ( m_animation ) m_animation->reset_animation();
         m_animation = a_anim;
+        // TODO : INSTANCE!
         m_animation->reset_animation();
 }
@@ -64 +63 @@
 }
 
-void nv::skeletal_mesh::draw( render_state& rstate )
-{
-        m_context->draw( nv::TRIANGLES, rstate, m_program, m_va, m_data->get_index_count(0) );
-}
-
 nv::skeletal_mesh::~skeletal_mesh()
 {
         delete m_va;
 }
+
+void nv::skeletal_mesh::run_animation( animation_entry* a_anim )
+{
+        skeletal_animation_entry * anim = down_cast<skeletal_animation_entry>(a_anim);
+        // TODO : INSTANCE!
+        setup_animation( anim->m_animation );
+}