Changeset 480 for trunk

Timestamp:

11/03/15 19:06:23 (10 years ago)

Author:

epyon

Message:

• cleanup of legacy code
• resource updates

Location:

trunk

Files:

• legacy/keyframed_mesh.cc (moved) (moved from trunk/src/gfx/keyframed_mesh.cc) (2 diffs)
• legacy/keyframed_mesh.hh (moved) (moved from trunk/nv/gfx/keyframed_mesh.hh) (2 diffs)
• legacy/md2_loader.cc (moved) (moved from trunk/src/formats/md2_loader.cc) (1 diff)
• legacy/md2_loader.hh (moved) (moved from trunk/nv/formats/md2_loader.hh) (1 diff)
• legacy/md2_normals.inc (moved) (moved from trunk/src/formats/md2_normals.inc)
• legacy/md3_loader.cc (moved) (moved from trunk/src/formats/md3_loader.cc) (1 diff)
• legacy/md3_loader.hh (moved) (moved from trunk/nv/formats/md3_loader.hh) (1 diff)
• legacy/skeletal_mesh.cc (moved) (moved from trunk/src/gfx/skeletal_mesh.cc) (2 diffs)
• legacy/skeletal_mesh.hh (moved) (moved from trunk/nv/gfx/skeletal_mesh.hh) (2 diffs)
• nv/core/resource.hh (modified) (5 diffs)
• nv/engine/resource_system.hh (modified) (3 diffs)
• nv/formats/assimp_loader.hh (modified) (1 diff)
• nv/formats/nmd_loader.hh (modified) (2 diffs)
• nv/formats/obj_loader.hh (modified) (1 diff)
• nv/gfx/mesh_creator.hh (modified) (3 diffs)
• nv/gfx/skeleton_instance.hh (modified) (1 diff)
• nv/interface/animated_mesh.hh (modified) (2 diffs)
• nv/interface/context.hh (modified) (1 diff)
• nv/interface/mesh_data.hh (modified) (1 diff)
• nv/interface/mesh_loader.hh (modified) (1 diff)
• src/formats/assimp_loader.cc (modified) (1 diff)
• src/formats/nmd_loader.cc (modified) (3 diffs)
• src/formats/obj_loader.cc (modified) (1 diff)
• src/gfx/mesh_creator.cc (modified) (2 diffs)
• src/gfx/skeleton_instance.cc (modified) (2 diffs)

trunk/legacy/keyframed_mesh.cc

@@ -12 +12 @@
 
 using namespace nv;
+
+#if 0
 
 nv::keyframed_mesh::keyframed_mesh( context* a_context, const data_channel_set* a_data, const mesh_nodes_data* a_tag_map )
@@ -247 +249 @@
         delete[] m_data;
 }
+
+#endif 

trunk/legacy/keyframed_mesh.hh

@@ -11 +11 @@
 #include <nv/interface/context.hh>
 #include <nv/interface/animated_mesh.hh>
-#include <nv/formats/md3_loader.hh>
 
 namespace nv
 {
+
+#if 0
 
         class keyframed_mesh : public animated_mesh
@@ -95 +96 @@
         };
 
+#endif
+
 } // namespace nv
 

trunk/legacy/md2_loader.cc

@@ -368 +368 @@
 }
 
-mesh_data_pack* nv::md2_loader::release_mesh_data_pack()
-{
-        data_channel_set* data = data_channel_set_creator::create_set_array( 1, 3 );
-        release_mesh_frame( &data[0], -1 );
-        return new mesh_data_pack( 1, data );
-}

trunk/legacy/md2_loader.hh

@@ -28 +28 @@
                 virtual bool load( stream& source );
                 virtual data_channel_set* release_mesh_data( size_t index = 0 );
-                virtual mesh_data_pack* release_mesh_data_pack();
                 virtual size_t get_mesh_count() const { return 1; }
         private:

trunk/legacy/md3_loader.cc

@@ -435 +435 @@
 }
 
-mesh_data_pack* nv::md3_loader::release_mesh_data_pack()
-{
-        md3_t* md3 = reinterpret_cast<md3_t*>( m_md3 );
-        int count = 1;
-        data_channel_set* data = nullptr;
-        if ( m_merge_all )
-        {
-                data = data_channel_set_creator::create_set_array(1,3);
-                release_mesh_frame( &data[0], -1, -1 );
-        }
-        else
-        {
-                count = md3->header.num_surfaces;
-                data = data_channel_set_creator::create_set_array( count, 3 );
-                for ( int i = 0; i < count; ++i )
-                {
-                        release_mesh_frame( &data[i], -1, i );
-                        data_channel_set_creator( &data[i] ).set_name( make_name( reinterpret_cast< char* >( md3->surfaces[i].header.name ) ) );
-                }
-        }
-        return new mesh_data_pack( uint32( count ), data, release_mesh_nodes_data() );
-}
-
 nv::size_t md3_loader::get_max_frames() const
 {

trunk/legacy/md3_loader.hh

@@ -34 +34 @@
                 virtual bool load( stream& source );
                 virtual data_channel_set* release_mesh_data( size_t index = 0 );
-                virtual mesh_data_pack* release_mesh_data_pack();
                 virtual size_t get_mesh_count() const { return 1; }
                 size_t get_max_frames() const;

trunk/legacy/skeletal_mesh.cc

@@ -12 +12 @@
 
 #include "nv/core/logging.hh"
-
+#if 0
 void nv::skeletal_animation_entry::update_skeleton( skeleton_instance& data, uint32 a_ms_time ) const
 {
@@ -39 +39 @@
         m_data.prepare( m_temp_anim, bones ? bones : m_temp_anim );
 }
-
-nv::skeletal_mesh::skeletal_mesh( context* a_context, const data_channel_set* a_mesh, const mesh_nodes_data* a_bone_data )
-        : m_skeleton( a_bone_data ? a_bone_data->size() : 0 ), m_context( a_context ), m_bone_data( a_bone_data ), m_index_count( 0 ), m_parent_id(-1)
-{
-        if ( a_mesh )
-        {
-                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();
-        }
-}
-
-void nv::skeletal_mesh::update_animation( animation_entry& a_anim, uint32 a_anim_time )
-{
-        skeletal_animation_entry& anim = static_cast<skeletal_animation_entry&>( a_anim );
-        anim.prepare( m_bone_data );
-        anim.update_skeleton( m_skeleton, a_anim_time );
-}
-
-void nv::skeletal_mesh::update_program( program a_program )
-{
-        m_context->get_device()->set_opt_uniform_array( a_program, "nv_m_bones", m_skeleton.transforms(), m_skeleton.size() );
-}
-
-nv::transform nv::skeletal_mesh::get_node_transform( uint32 node_id ) const
-{
-        return transform( get_node_matrix( node_id ) );
-}
-
-nv::mat4 nv::skeletal_mesh::get_node_matrix( uint32 node_id ) const
-{
-        return m_skeleton.transforms()[ node_id ];
-}
+#endif

trunk/legacy/skeletal_mesh.hh

@@ -16 +16 @@
 namespace nv
 {
-        
+#if 0   
         class skeletal_animation_entry : public animation_entry
         {
@@ -33 +33 @@
                 skeleton_binding m_data;
         };
-
-        class skeletal_mesh : public animated_mesh
-        {
-        public:
-                skeletal_mesh( context* a_context, const data_channel_set* a_mesh, const mesh_nodes_data* a_bone_data );
-                virtual vertex_array get_vertex_array() const { return m_va; }
-                virtual size_t get_index_count() const { return m_index_count; }
-                virtual void run_animation( animation_entry& a_anim )
-                {
-                        update_animation( a_anim, 0 );
-                }
-                virtual void update_program( program a_program );
-                virtual void update_animation( animation_entry& a_anim, uint32 a_anim_time );
-                virtual transform get_node_transform( uint32 node_id ) const;
-                virtual mat4 get_node_matrix( uint32 node_id ) const;
-                virtual sint16 get_parent_id() const { return m_parent_id; }
-                virtual uint32 get_node_count() const { return m_skeleton.size(); }
-                skeleton_instance& get_skeleton() { return m_skeleton; }
-                const mesh_nodes_data* get_bone_data() { return m_bone_data; }
-                context* get_context() { return m_context;  }
-                ~skeletal_mesh()
-                {
-                        m_context->release( m_va );
-                }
-        protected:
-                skeleton_instance m_skeleton;
-                vertex_array m_va;
-                uint32       m_index_count;
-                context*     m_context;
-                const mesh_nodes_data* m_bone_data;
-                sint16 m_parent_id;
-        };
+#endif
 
 } // namespace nv

trunk/nv/core/resource.hh

@@ -22 +22 @@
 {
 
+        struct resource_unchecked {};
         template < typename T > class resource;
         template < typename T > class resource_handle;
@@ -32 +33 @@
 
         protected:
-                virtual const void* lock( resource_id id, resource_type_id type_hash ) = 0;
+                virtual const void* lock( resource_id id, resource_type_id type_hash, bool checked = true ) = 0;
 //              virtual const void* create( resource_id id, resource_type_id type_hash ) = 0;
                 virtual void unlock( resource_id id, resource_type_id type_hash ) = 0;
@@ -38 +39 @@
 
                 template< typename T >
-                const T* lock( resource_id id )
-                {
-                        return reinterpret_cast< const T* >( lock( id, shash64( rtti_type_hash<T>::hash() ) ) );
+                const T* lock( resource_id id, bool checked = true )
+                {
+                        return reinterpret_cast< const T* >( lock( id, shash64( rtti_type_hash<T>::hash() ), checked ) );
                 }
                 template< typename T >
@@ -75 +76 @@
                 constexpr bool is_valid() const { return m_id && m_handler; }
                 constexpr explicit operator bool() const { return is_valid(); }
+                resource_lock< T > lock() const { return resource_lock< T >( *this, resource_unchecked() ); }
                 ~resource()
                 {
@@ -146 +148 @@
                 static const uint64 hash_value = rtti_type_hash<T>::value;
         public:
-                explicit resource_lock( const resource< T >& r ) : m_id( r.m_id ), m_handler( r.m_handler ), m_resource( r.m_handler->lock<T>( r.m_id ) ) {}
+                resource_lock() = delete;
+                explicit resource_lock( const resource< T >& r, resource_unchecked )
+                        : m_id( r.m_id )
+                        , m_handler( r.m_handler )
+                        , m_resource( r.m_handler ? r.m_handler->lock<T>( r.m_id, false ) : nullptr ) {}
+                explicit resource_lock( const resource< T >& r ) 
+                        : m_id( r.m_id )
+                        , m_handler( r.m_handler )
+                        , m_resource( r.m_handler->lock<T>( r.m_id ) ) {}
                 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 ) ) ) {}
+                resource_lock( const resource_lock& ) = delete;
+                resource_lock& operator=( const resource_lock& other ) = delete;
+                resource_lock( resource_lock&& other )
+                {
+                        m_id       = other.m_id;
+                        m_handler  = other.m_handler;
+                        m_resource = other.m_resource;
+                        other.m_handler = nullptr;
+                }
+                resource_lock& operator=( resource_lock&& other )
+                {
+                        if ( this != &other )
+                        {
+                                if ( m_handler ) m_handler->unlock( m_id, shash64( hash_value ) );
+                                m_id       = other.m_id;
+                                m_handler  = other.m_handler;
+                                m_resource = other.m_resource;
+                                other.m_handler = nullptr;
+                        }
+                        return *this;
+                }
                 const T& operator*() const { return *m_resource; }
                 const T* operator->() const { return m_resource; }
+                constexpr bool is_valid() const { return m_resource != nullptr; }
+                constexpr explicit operator bool() const { return is_valid(); }
                 ~resource_lock()
                 {
-                        m_handler->unlock( m_id, shash64( hash_value ) );
+                        if ( m_handler ) m_handler->unlock( m_id, shash64( hash_value ) );
                 }
         private:

trunk/nv/engine/resource_system.hh

@@ -125 +125 @@
                 }
 
-                resource_type add( shash64 id, stored_type resource )
-                {
-                        m_store[id] = resource;
-                        return create< T >( id );
-                }
-
                 virtual ~custom_resource_manager()
                 {
@@ -136 +130 @@
                 }
         protected:
-                virtual const void* lock( resource_id id, resource_type_id )
+                resource_type add( shash64 id, stored_type resource )
+                {
+                        auto m = m_store.find( shash64( id ) );
+                        if ( m != m_store.end() )
+                        {
+                                release( m->second );
+                        }
+                        m_store[id] = resource;
+                        return create< T >( id );
+                }
+
+                virtual const void* lock( resource_id id, resource_type_id, bool )
                 {
                         auto m = m_store.find( id );
@@ -150 +155 @@
         using lua_resource_manager = custom_resource_manager< T, Heap, lua_resource_manager_base >;
 
+
+        template < typename T, bool Heap = true >
+        class manual_resource_manager : public custom_resource_manager< T, Heap >
+        {
+        public:
+                manual_resource_manager() {}
+                using custom_resource_manager< T, Heap >::add;
+        protected:
+                virtual bool load_resource( const nv::string_view& ) { return false; }
+
+        };
 }
 

trunk/nv/formats/assimp_loader.hh

@@ -25 +25 @@
                 virtual size_t get_mesh_count() const { return m_mesh_count; }
                 virtual ~assimp_loader();
-                virtual mesh_data_pack* release_mesh_data_pack();
                 virtual size_t get_nodes_data_count() const;
                 virtual mesh_nodes_data* release_mesh_nodes_data( size_t index = 0 );

trunk/nv/formats/nmd_loader.hh

@@ -83 +83 @@
                 virtual size_t get_nodes_data_count() const { return 1; }
                 virtual mesh_nodes_data* release_mesh_nodes_data( size_t = 0 );
-                virtual mesh_data_pack* release_mesh_data_pack();
                 virtual size_t get_mesh_count() const { return m_meshes.size(); }
                 virtual ~nmd_loader();
@@ -104 +103 @@
         void nmd_dump_element( stream& stream_out, const data_channel_set& data, nmd_type type );
         void nmd_dump_nodes( stream& stream_out, const mesh_nodes_data& nodes );
-        void nmd_dump( stream& stream_out, const mesh_data_pack* model, const string_table* strings = nullptr, uint64 name = 0 );
+        void nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, const mesh_nodes_data* nodes, const string_table* strings = nullptr, uint64 name = 0 );
+        void nmd_dump( stream& stream_out, const mesh_nodes_data& animation, const string_table* strings = nullptr, uint64 name = 0 );
+
 
 }

trunk/nv/formats/obj_loader.hh

@@ -28 +28 @@
                 virtual bool load( stream& source );
                 virtual data_channel_set* release_mesh_data( size_t index = 0 );
-                virtual mesh_data_pack* release_mesh_data_pack();
                 virtual size_t get_mesh_count() const { return m_meshes.size(); }
                 ~obj_loader();

trunk/nv/gfx/mesh_creator.hh

@@ -18 +18 @@
         {
         public:
-                mesh_data_creator( data_channel_set* data );
+                mesh_data_creator( data_channel_set* data ) : m_data( data )
+                {
+                        initialize();
+                }
+
                 // assumes that position and normal is vec3, tangent is vec4
                 void transform( float scale, const mat3& r33 );
@@ -64 +68 @@
         {
         public:
-                mesh_nodes_creator( mesh_nodes_data* data ) : m_data( data ) {}
+                mesh_nodes_creator( mesh_nodes_data* data ) : m_data( data )
+                {}
                 // assumes that keys are equally spaced
                 void pre_transform_keys();
@@ -74 +79 @@
         };
 
-        class mesh_creator
-        {
-        public:
-                mesh_creator( mesh_data_pack* pack ) : m_pack( pack ) {}
-                void delete_mesh( uint32 index );
-                // assumes that keys are equally spaced
-                void pre_transform_keys() 
-                {
-                        if ( m_pack->m_nodes )
-                                mesh_nodes_creator( m_pack->m_nodes ).pre_transform_keys();
-                }
-                void generate_tangents()
-                {
-                        for ( size_t m = 0; m < m_pack->m_count; ++m )
-                                mesh_data_creator( &(m_pack->m_meshes[m]) ).generate_tangents();
-                }
-
-                // assumes that keys are equally spaced
-                void merge_keys() { mesh_nodes_creator( m_pack->m_nodes ).merge_keys(); }
-                // assumes that position and normal is vec3, tangent is vec4
-                void flip_normals() 
-                {
-                        for ( size_t m = 0; m < m_pack->m_count; ++m )
-                                mesh_data_creator( &(m_pack->m_meshes[m]) ).flip_normals();
-                }
-                void transform( float scale, const mat3& r33 ) 
-                {
-                        for ( size_t m = 0; m < m_pack->m_count; ++m )
-                                mesh_data_creator( &(m_pack->m_meshes[m]) ).transform( scale, r33 );
-                        if ( m_pack->m_nodes )
-                                mesh_nodes_creator( m_pack->m_nodes ).transform( scale, r33 );
-                }
-                // assumes models have same format
-                // currently only data merge
-                bool merge( mesh_data_pack* other )
-                {
-                        for ( size_t m = 0; m < m_pack->m_count; ++m )
-                        {
-                                if (!mesh_data_creator( &(m_pack->m_meshes[m]) ).is_same_format( &(other->m_meshes[m]) ) ) 
-                                        return false;
-                        }
-                        for ( size_t m = 0; m < m_pack->m_count; ++m )
-                        {
-                                mesh_data_creator(&(m_pack->m_meshes[m]) ).merge( &(other->m_meshes[m]) );
-                        }
-                        return true;
-                }
-        private:
-                mesh_data_pack* m_pack;
-        };
 }
 

trunk/nv/gfx/skeleton_instance.hh

@@ -55 +55 @@
                 void animate( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame );
         protected:
-                void animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const mat4& parent );
+                void animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent );
                 void animate_flat( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame );
 

trunk/nv/interface/animated_mesh.hh

@@ -22 +22 @@
 {
 
+#if 0
         class animation_entry
         {
@@ -51 +52 @@
                 uint32  m_fend;    /// end time (in frames)
         };
-
-        class animated_mesh : public mesh_interface
-        {
-        public:
-                animated_mesh() {}
-                virtual void update_animation( animation_entry&, uint32 ) {}
-                virtual void run_animation( animation_entry& ) {}
-                virtual transform get_node_transform( uint32 ) const { return transform(); }
-                virtual mat4 get_node_matrix( uint32 ) const { return mat4(); }
-                virtual uint32 get_node_count() const { return 0; }
-                virtual sint16 get_parent_id() const { return -1; }
-
-        };
-
+#endif
 
 }

trunk/nv/interface/context.hh

@@ -43 +43 @@
                 DRAW_FRAMEBUFFER,
                 FRAMEBUFFER,
-        };
-
-        class mesh_interface
-        {
-        public:
-                mesh_interface() {}
-                virtual void update_program( program ) {}
-                virtual nv::vertex_array get_vertex_array() const = 0;
-                virtual size_t get_index_count() const = 0;
-                virtual nv::primitive get_primitive_type() const { return nv::TRIANGLES; }
-                virtual ~mesh_interface() {}
         };
 

trunk/nv/interface/mesh_data.hh

@@ -152 +152 @@
         };
 
-        class mesh_data_pack
-        {
-                friend class mesh_creator;
-        public:
-                explicit mesh_data_pack( uint32 a_count, data_channel_set* a_meshes, mesh_nodes_data* a_nodes = nullptr )
-                {
-                        m_count  = a_count;
-                        m_meshes = a_meshes;
-                        m_nodes  = a_nodes;
-                }
-                const data_channel_set* get_mesh( uint32 index ) const
-                {
-                        if ( index >= m_count ) return nullptr;
-                        return &m_meshes[ index ];
-                }
-                const data_channel_set* get_mesh_by_hash( shash64 h ) const
-                {
-                        for ( uint32 i = 0; i < m_count; ++i )
-                        {
-                                if ( m_meshes[i].get_name() == h )
-                                        return &m_meshes[i];
-                        }
-                        return nullptr;
-                }
-                uint32 get_count() const { return m_count; }
-                data_channel_set* release_meshes() { data_channel_set* meshes = m_meshes; m_meshes = nullptr; return meshes; }
-                mesh_nodes_data* release_nodes() { mesh_nodes_data* nodes = m_nodes; m_nodes = nullptr; return nodes; }
-                const mesh_nodes_data* get_nodes() const { return m_nodes; }
-                uint32 get_node_count() const { return m_nodes ? m_nodes->size() : 0; }
-                ~mesh_data_pack()
-                {
-                        delete[] m_meshes;
-                        delete   m_nodes;
-                }
-        private:
-                uint32            m_count;
-                data_channel_set* m_meshes;
-                mesh_nodes_data*  m_nodes;
-        };
 }
 

trunk/nv/interface/mesh_loader.hh

@@ -32 +32 @@
                 virtual bool load( stream& source ) = 0;
                 virtual data_channel_set* release_mesh_data( size_t index = 0 ) = 0;
-                virtual mesh_data_pack* release_mesh_data_pack() = 0;
                 virtual size_t get_mesh_count() const = 0;
                 virtual size_t get_nodes_data_count() const { return 0; }

trunk/src/formats/assimp_loader.cc

@@ -462 +462 @@
 }
 
-mesh_data_pack* nv::assimp_loader::release_mesh_data_pack()
-{
-        if ( m_scene == nullptr || m_mesh_count == 0 ) return nullptr;
-        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
-        bool has_bones = false;
-        data_channel_set* meshes = data_channel_set_creator::create_set_array( m_mesh_count, 2 );
-        for ( size_t m = 0; m < m_mesh_count; ++m )
-        {
-                const aiMesh* mesh = scene->mMeshes[ m ];
-                data_channel_set_creator( &meshes[m] ).set_name( make_name( static_cast<const char*>( mesh->mName.data ) ) );
-                if ( mesh->mNumBones > 0 ) has_bones = true;
-                load_mesh_data(&meshes[m],m);
-        }
-
-        mesh_nodes_data* nodes = ( has_bones ? release_merged_bones( meshes ) : release_mesh_nodes_data(0) );
-        return new mesh_data_pack( m_mesh_count, meshes, nodes );
-}
+// mesh_data_pack* nv::assimp_loader::release_mesh_data_pack()
+// {
+//      if ( m_scene == nullptr || m_mesh_count == 0 ) return nullptr;
+//      const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
+//      bool has_bones = false;
+//      data_channel_set* meshes = data_channel_set_creator::create_set_array( m_mesh_count, 2 );
+//      for ( size_t m = 0; m < m_mesh_count; ++m )
+//      {
+//              const aiMesh* mesh = scene->mMeshes[ m ];
+//              data_channel_set_creator( &meshes[m] ).set_name( make_name( static_cast<const char*>( mesh->mName.data ) ) );
+//              if ( mesh->mNumBones > 0 ) has_bones = true;
+//              load_mesh_data(&meshes[m],m);
+//      }
+// 
+//      mesh_nodes_data* nodes = ( has_bones ? release_merged_bones( meshes ) : release_mesh_nodes_data(0) );
+//      return new mesh_data_pack( m_mesh_count, meshes, nodes );
+// }
 
 nv::size_t nv::assimp_loader::get_nodes_data_count() const

trunk/src/formats/nmd_loader.cc

@@ -50 +50 @@
 }
 
-mesh_data_pack* nv::nmd_loader::release_mesh_data_pack()
-{
-        uint32 size = m_meshes.size();
-        data_channel_set* meshes = data_channel_set_creator::create_set_array( size, 0 );
-        for ( uint32 i = 0; i < size; ++i )
-        {
-                meshes[i] = move( *m_meshes[i] );
-                delete m_meshes[i];
-        }
-        m_meshes.clear();
-        return new mesh_data_pack( size, meshes, release_mesh_nodes_data() );
-}
-
 void nv::nmd_loader::reset()
 {
@@ -240 +227 @@
 }
 
-void nv::nmd_dump( stream& stream_out, const mesh_data_pack* model, const string_table* strings, uint64 name )
+void nv::nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, const mesh_nodes_data* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ )
 {
         uint32 elements = ( strings ? 1 : 0 ) // +1 string array
-                + model->get_count() // meshes
-                + ( model->get_node_count() > 0 ? 1 : 0 ); // nodes
+                + meshes.size() // meshes
+                + ( nodes && nodes->size() > 0 ? 1 : 0 ); // nodes
         nmd_dump_header( stream_out, elements, name );
 
-        for ( uint32 i = 0; i < model->get_count(); ++i )
-        {
-                nmd_dump_element( stream_out, *model->get_mesh( i ), nv::nmd_type::MESH );
-        }
-
-        if ( model->get_node_count() > 0 )
-        {
-                nmd_dump_nodes( stream_out, *model->get_nodes() );
+        for ( uint32 i = 0; i < meshes.size(); ++i )
+        {
+                NV_ASSERT( meshes[i], "mesh is null!" );
+                nmd_dump_element( stream_out, *meshes[i], nv::nmd_type::MESH );
+        }
+
+        if ( nodes && nodes->size() > 0 )
+        {
+                nmd_dump_nodes( stream_out, *nodes );
         }
 
@@ -262 +250 @@
         }
 }
+
+void nv::nmd_dump( stream& stream_out, const mesh_nodes_data& animation, const string_table* strings, uint64 name )
+{
+        uint32 elements = ( strings ? 1 : 0 ) // +1 string array
+                + ( animation.size() > 0 ? 1 : 0 ); // nodes
+        nmd_dump_header( stream_out, elements, name );
+
+        if ( animation.size() > 0 )
+        {
+                nmd_dump_nodes( stream_out, animation );
+        }
+
+        if ( strings )
+        {
+                nmd_dump_strings( stream_out, *strings );
+        }
+}

trunk/src/formats/obj_loader.cc

@@ -357 +357 @@
 }
 
-mesh_data_pack* nv::obj_loader::release_mesh_data_pack()
-{
-        uint32 size = m_meshes.size();
-        data_channel_set* meshes = data_channel_set_creator::create_set_array( size, 1 );
-        for ( uint32 i = 0; i < size; ++i )
-        {
-                meshes[i] = move( *m_meshes[i] );
-                delete m_meshes[i];
-        }
-        m_meshes.clear();
-        return new mesh_data_pack( size, meshes );
-}

trunk/src/gfx/mesh_creator.cc

@@ -157 +157 @@
                 }
         }
-}
-
-nv::mesh_data_creator::mesh_data_creator( data_channel_set* data ) : m_data( data )
-{
-        initialize();
 }
 
@@ -656 +651 @@
 }
 
-void nv::mesh_creator::delete_mesh( uint32 index )
-{
-        if ( index < m_pack->get_count() )
-        {
-
-                m_pack->m_meshes[index] = move( m_pack->m_meshes[m_pack->m_count - 1] );
-                m_pack->m_count--;
-        }
-}

trunk/src/gfx/skeleton_instance.cc

@@ -6 +6 @@
 
 #include "nv/gfx/skeleton_instance.hh"
+
+#include "nv/core/profiler.hh"
 
 void nv::skeleton_binding::prepare( const mesh_nodes_data* node_data, const mesh_nodes_data* bone_data )
@@ -62 +64 @@
                         for ( uint32 n = 0; n < node_data->size(); ++n )
                                 if ( ( *node_data )[n]->get_parent_id() == -1 )
-                                        animate_rec( node_data, binding, frame, n, mat4() );
+                                        animate_rec( node_data, binding, frame, n, transform() );
                 }
         }
 }
 
-void nv::skeleton_instance::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const mat4& parent ) 
+void nv::skeleton_instance::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent )
 {
         // TODO: fix transforms, which are now embedded,
         //       see note in assimp_loader.cc:load_node
         const data_channel_set* node = ( *node_data )[id];
-        mat4 node_mat( node->get_transform() );
+        transform node_mat( node->get_transform() );
 
         if ( node->size() > 0 )
         {
                 raw_channel_interpolator interpolator( node, binding.m_key );
-                node_mat = interpolator.get< mat4 >( frame );
+                node_mat = interpolator.get< transform >( frame );
         }
 
-        mat4 global_mat = parent * node_mat;
+        transform global_mat = parent * node_mat;
 
         sint16 bone_id = binding.m_indices[id];
         if ( bone_id >= 0 )
         {
-                m_transform[bone_id] = global_mat * binding.m_offsets[bone_id];
+                m_transform[bone_id] = global_mat.extract() * binding.m_offsets[bone_id];
         }