- Timestamp:
- 11/12/15 19:02:08 (10 years ago)
- Location:
- trunk
- Files:
-
- 16 edited
-
nv/core/transform.hh (modified) (2 diffs)
-
nv/formats/assimp_loader.hh (modified) (1 diff)
-
nv/formats/nmd_loader.hh (modified) (4 diffs)
-
nv/formats/obj_loader.hh (modified) (2 diffs)
-
nv/gfx/mesh_creator.hh (modified) (2 diffs)
-
nv/gfx/skeleton_instance.hh (modified) (3 diffs)
-
nv/interface/data_channel.hh (modified) (4 diffs)
-
nv/interface/data_channel_access.hh (modified) (1 diff)
-
nv/interface/mesh_data.hh (modified) (8 diffs)
-
nv/interface/mesh_loader.hh (modified) (1 diff)
-
nv/stl/hash_map.hh (modified) (4 diffs)
-
src/formats/assimp_loader.cc (modified) (10 diffs)
-
src/formats/nmd_loader.cc (modified) (13 diffs)
-
src/formats/obj_loader.cc (modified) (3 diffs)
-
src/gfx/mesh_creator.cc (modified) (7 diffs)
-
src/gfx/skeleton_instance.cc (modified) (7 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/nv/core/transform.hh
r454 r482 76 76 return m_orientation * v + m_position; 77 77 } 78 79 transform scaled( float v ) const 80 { 81 return transform( v * m_position, v * m_orientation ); 82 } 83 78 84 private: 79 85 vec3 m_position; … … 92 98 } 93 99 100 inline transform operator*( float value, const transform& lhs ) 101 { 102 return lhs.scaled( value ); 103 } 104 94 105 template <> struct enum_to_type< TRANSFORM > { typedef transform type; }; 95 106 template <> struct type_to_enum< transform > { static const datatype type = TRANSFORM; }; -
trunk/nv/formats/assimp_loader.hh
r480 r482 22 22 explicit assimp_loader( string_table* strings, const string_view& a_ext, uint32 a_assimp_flags = 0 ); 23 23 virtual bool load( stream& source ); 24 virtual data_channel_set* release_mesh_data( size_t index = 0);24 virtual data_channel_set* release_mesh_data( size_t index, data_node_info& info ); 25 25 virtual size_t get_mesh_count() const { return m_mesh_count; } 26 26 virtual ~assimp_loader(); 27 27 virtual size_t get_nodes_data_count() const; 28 28 virtual mesh_nodes_data* release_mesh_nodes_data( size_t index = 0 ); 29 virtual data_node_list* release_data_node_list( size_t = 0 ); 30 virtual bool is_animated( size_t = 0 ); 29 31 void scene_report() const; 30 32 private: 31 mesh_nodes_data* release_merged_bones( data_channel_set* meshes );32 bool load_bones( size_t index, array_ref< data_ channel_set*> bones );33 void load_mesh_data( data_channel_set* data, size_t index );34 sint16 load_node( uint32 anim_id, array_ref< data_channel_set* > nodes, const void* vnode, sint16 this_id, sint16 parent_id );33 data_node_list* release_merged_bones( data_channel_set* meshes ); 34 bool load_bones( size_t index, array_ref< data_node_info > bones ); 35 void load_mesh_data( data_channel_set* data, size_t index, data_node_info& info ); 36 sint16 load_node( uint32 anim_id, array_ref< data_channel_set* > nodes, array_ref< data_node_info > infos, const void* vnode, sint16 this_id, sint16 parent_id ); 35 37 uint32 count_nodes( const void* node ) const; 36 38 data_channel_set* create_keys( const void* vnode ); -
trunk/nv/formats/nmd_loader.hh
r480 r482 66 66 uint16 frame_rate; 67 67 uint16 frame_count; 68 bool flat;68 bool unused; 69 69 }; 70 70 … … 78 78 { 79 79 public: 80 explicit nmd_loader( string_table* strings ) : mesh_loader( strings ), m_node_data( nullptr ) {}80 explicit nmd_loader( string_table* strings ) : mesh_loader( strings ), m_node_data( nullptr ), m_bone_data( nullptr ) {} 81 81 virtual bool load( stream& source ); 82 virtual data_channel_set* release_mesh_data( size_t index = 0);82 virtual data_channel_set* release_mesh_data( size_t index, data_node_info& info ); 83 83 virtual size_t get_nodes_data_count() const { return 1; } 84 84 virtual mesh_nodes_data* release_mesh_nodes_data( size_t = 0 ); 85 virtual data_node_list* release_data_node_list( size_t = 0 ); 86 virtual bool is_animated( size_t = 0 ); 85 87 virtual size_t get_mesh_count() const { return m_meshes.size(); } 86 88 virtual ~nmd_loader(); … … 92 94 bool load_animation( stream& source, const nmd_element_header& e ); 93 95 bool load_channel( stream& source, data_channel_set* channel_set ); 94 bool load_channel_set( stream& source, data_channel_set* channel_set, const nmd_element_header& e );96 bool load_channel_set( stream& source, data_channel_set* channel_set, data_node_info& info, const nmd_element_header& e ); 95 97 96 98 mesh_nodes_data* m_node_data; 99 data_node_list* m_bone_data; 100 vector< data_node_info > m_infos; 97 101 vector< data_channel_set* > m_meshes; 98 102 }; … … 101 105 void nmd_dump_header( stream& stream_out, uint32 elements, uint64 name ); 102 106 void nmd_dump_strings( stream& stream_out, const string_table& strings ); 103 void nmd_dump_element( stream& stream_out, const data_channel_set& data, nmd_type type );107 void nmd_dump_element( stream& stream_out, const data_channel_set& data, const data_node_info& info, nmd_type type ); 104 108 void nmd_dump_nodes( stream& stream_out, const mesh_nodes_data& nodes ); 105 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 ); 109 void nmd_dump_bones( stream& stream_out, const data_node_list& nodes ); 110 void nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, array_view< data_node_info > infos, const nv::data_node_list* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ ); 111 void nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, array_view< data_node_info > infos, const mesh_nodes_data* nodes, const string_table* strings = nullptr, uint64 name = 0 ); 106 112 void nmd_dump( stream& stream_out, const mesh_nodes_data& animation, const string_table* strings = nullptr, uint64 name = 0 ); 107 113 -
trunk/nv/formats/obj_loader.hh
r480 r482 27 27 obj_loader( string_table* strings, bool normals = true, bool tangents = false ); 28 28 virtual bool load( stream& source ); 29 virtual data_channel_set* release_mesh_data( size_t index = 0);29 virtual data_channel_set* release_mesh_data( size_t index, data_node_info& info ); 30 30 virtual size_t get_mesh_count() const { return m_meshes.size(); } 31 31 ~obj_loader(); … … 35 35 data_descriptor m_descriptor; 36 36 vector< data_channel_set* > m_meshes; 37 vector< data_node_info > m_infos; 37 38 }; 38 39 -
trunk/nv/gfx/mesh_creator.hh
r480 r482 71 71 {} 72 72 // assumes that keys are equally spaced 73 void pre_transform_keys();74 // assumes that keys are equally spaced75 73 void merge_keys(); 76 74 void transform( float scale, const mat3& r33 ); … … 79 77 }; 80 78 79 class data_node_list_creator 80 { 81 public: 82 data_node_list_creator( data_node_list* data ) : m_data( data ) {} 83 void transform( float scale, const mat3& r33 ); 84 private: 85 data_node_list* m_data; 86 }; 87 88 81 89 } 82 90 -
trunk/nv/gfx/skeleton_instance.hh
r481 r482 54 54 public: 55 55 bone_transforms() {} 56 void prepare( const mesh_nodes_data*bone_data );56 void prepare( const data_node_list& bone_data ); 57 57 uint32 size() const { return m_offsets.size(); }; 58 58 protected: … … 66 66 public: 67 67 skeleton_binding() {} 68 void prepare( const mesh_nodes_data* node_data, const mesh_nodes_data*bone_data );68 void prepare( const mesh_nodes_data* node_data, const data_node_list& bone_data ); 69 69 uint32 size() const { return m_indices.size(); }; 70 70 uint32 skeleton_size() const { return m_bone_count; }; … … 84 84 const transform* transforms() const { return m_transforms.data(); } 85 85 size_t size() const { return m_transforms.size(); } 86 void animate( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame ) 86 void animate_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame ); 87 void animate( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, bool local = false ) 87 88 { 89 if ( local ) 90 { 91 animate_local( node_data, binding, frame ); 92 return; 93 } 88 94 if ( m_transforms.size() != binding.skeleton_size() ) 89 95 m_transforms.resize( binding.skeleton_size() ); 90 NV_ASSERT( !node_data->is_flat(), "animation data is flat!" );91 96 for ( uint32 n = 0; n < node_data->size(); ++n ) 92 if ( ( *node_data )[n]->get_parent_id()== -1 )93 animate_rec( node_data, binding, frame, n, transform() );97 if ( node_data->get_info(n).parent_id == -1 ) 98 animate_rec( node_data, binding, frame, n, transform(), false ); 94 99 } 100 void blend_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, float blend ); 101 void blend( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, float blend, bool local = false ) 102 { 103 NV_ASSERT( m_transforms.size() == binding.skeleton_size(), "skeleton size wrong!" ); 104 if ( local ) 105 { 106 blend_local( node_data, binding, frame, blend ); 107 return; 108 } 109 for ( uint32 n = 0; n < node_data->size(); ++n ) 110 if ( node_data->get_info( n ).parent_id == -1 ) 111 blend_rec( node_data, binding, frame, n, transform(), false, blend); 112 } 113 114 void delocalize( const data_node_tree& node_data, const skeleton_binding& binding ) 115 { 116 NV_ASSERT( m_transforms.size() == binding.skeleton_size(), "skeleton size wrong!" ); 117 for ( uint32 n = 0; n < node_data.size(); ++n ) 118 if ( node_data[ n ].parent_id == -1 ) 119 delocalize_rec( node_data, binding, n, transform() ); 120 } 121 122 void delocalize_rec( const data_node_tree& node_data, const skeleton_binding& binding, uint32 id, const transform& parent ); 123 void animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local ); 124 void blend_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local, float blend ); 95 125 protected: 96 void animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent );97 126 dynamic_array< transform > m_transforms; 98 127 }; -
trunk/nv/interface/data_channel.hh
r456 r482 14 14 namespace nv 15 15 { 16 struct data_node_info 17 { 18 shash64 name; 19 sint16 parent_id; 20 mat4 transform; 21 }; 16 22 17 23 struct raw_data_channel … … 99 105 m_channels[c] = move( other.m_channels[c] ); 100 106 m_size = other.m_size; 101 m_parent_id = other.m_parent_id;102 m_transform = other.m_transform;103 m_name = other.m_name;104 107 other.m_size = 0; 105 108 } … … 112 115 m_channels[c] = move( other.m_channels[c] ); 113 116 m_size = other.m_size; 114 m_parent_id = other.m_parent_id;115 m_transform = other.m_transform;116 m_name = other.m_name;117 117 other.m_size = 0; 118 118 } … … 216 216 const_iterator end() const { return &m_channels[ m_size ]; } 217 217 218 shash64 get_name() const { return m_name; }219 sint16 get_parent_id() const { return m_parent_id; }220 const mat4& get_transform() const { return m_transform; }221 222 218 protected: 223 219 224 220 data_channel_set() 225 221 { 226 m_size = 0; 227 m_parent_id = -1; 222 m_size = 0; 228 223 } 229 224 230 225 raw_data_channel m_channels[4]; 231 232 uint32 m_size; 233 shash64 m_name; 234 sint16 m_parent_id; 235 mat4 m_transform; 226 uint32 m_size; 236 227 }; 237 228 -
trunk/nv/interface/data_channel_access.hh
r456 r482 165 165 const_iterator begin() const { return m_set->begin(); } 166 166 const_iterator end() const { return m_set->end(); } 167 168 void set_transform( const mat4& tr ) { m_set->m_transform = tr; }169 const mat4& get_transform() const { return m_set->m_transform; }170 171 void set_name( shash64 name ) { m_set->m_name = name; }172 shash64 get_name() const { return m_set->m_name; }173 174 void set_parent_id( sint16 name ) { m_set->m_parent_id = name; }175 sint16 get_parent_id() const { return m_set->m_parent_id; }176 167 protected: 177 168 data_channel_set* m_set; -
trunk/nv/interface/mesh_data.hh
r480 r482 21 21 22 22 //using mesh_data = data_channel_set; 23 24 23 // TODO : attribute/property implementation and read/write on every nmd::command 25 24 26 class mesh_nodes_data 27 { 28 25 class child_list : noncopyable 26 { 29 27 static constexpr size_t MAX_CHILDREN = 7; 30 class child_list : noncopyable 31 { 32 33 public: 34 child_list() : m_size( 0 ) 35 { 36 nv::raw_fill_n( m_data, MAX_CHILDREN, 0 ); 37 } 38 void push( uint8 id ) 39 { 40 NV_ASSERT( m_size < MAX_CHILDREN, "Range error" ); 41 m_data[m_size++] = id; 42 } 43 const uint8* begin() const { return m_data; } 44 const uint8* end() const { return m_data + m_size; } 45 private: 46 uint8 m_size; 47 uint8 m_data[MAX_CHILDREN]; 48 }; 49 static_assert( sizeof( child_list ) == 8, "Align/Padding fail for child_list" ); 50 28 public: 29 child_list() : m_size( 0 ) 30 { 31 nv::raw_fill_n( m_data, MAX_CHILDREN, 0 ); 32 } 33 void push( uint8 id ) 34 { 35 NV_ASSERT( m_size < MAX_CHILDREN, "Range error" ); 36 m_data[m_size++] = id; 37 } 38 const uint8* begin() const { return m_data; } 39 const uint8* end() const { return m_data + m_size; } 40 private: 41 uint8 m_size; 42 uint8 m_data[MAX_CHILDREN]; 43 }; 44 static_assert( sizeof( child_list ) == 8, "Align/Padding fail for child_list" ); 45 46 class data_node_list 47 { 51 48 friend class mesh_creator; 52 49 friend class mesh_nodes_creator; 50 friend class data_node_list_creator; 51 public: 52 typedef vector< data_node_info > storage; 53 typedef storage::const_iterator const_iterator; 54 55 explicit data_node_list( shash64 name ) 56 : m_name( name ) 57 { 58 } 59 60 void assign( const data_node_list& other ) 61 { 62 m_name = other.m_name; 63 for ( auto node : other ) 64 m_data.assign( other.m_data ); 65 } 66 67 data_node_list( data_node_list&& other ) 68 : m_name( other.m_name ), m_data( nv::move( other.m_data ) ) 69 { 70 } 71 72 void append( const data_node_info& set ) 73 { 74 m_data.push_back( set ); 75 } 76 77 size_t size() const { return m_data.size(); } 78 bool empty() const { return m_data.empty(); } 79 80 const data_node_info& operator[]( size_t i ) const 81 { 82 return m_data[i]; 83 } 84 85 const_iterator begin() const { return m_data.begin(); } 86 const_iterator end() const { return m_data.end(); } 87 88 shash64 get_name() const { return m_name; } 89 90 protected: 91 vector< data_node_info > m_data; 92 shash64 m_name; 93 }; 94 95 96 class data_node_tree : public data_node_list 97 { 98 friend class mesh_creator; 99 friend class mesh_nodes_creator; 100 friend class data_node_list_creator; 101 public: 102 103 explicit data_node_tree( shash64 name ) : data_node_list( name ) {} 104 105 void initialize() 106 { 107 m_children.resize( size() ); 108 for ( uint8 n = 0; n < uint8( m_data.size() ); ++n ) 109 { 110 if ( m_data[n].parent_id != -1 ) 111 m_children[m_data[n].parent_id].push( n ); 112 } 113 } 114 115 const child_list& children( size_t i ) const 116 { 117 return m_children[i]; 118 } 119 120 protected: 121 vector< child_list > m_children; 122 }; 123 124 125 class mesh_nodes_data 126 { 127 friend class mesh_nodes_creator; 53 128 public: 54 129 typedef vector< data_channel_set* > storage; … … 56 131 57 132 explicit mesh_nodes_data( shash64 name ) 58 : m_name( name ), m_frame_rate(0), m_frame_count(0), m_flat( false ) 59 { 60 } 61 62 explicit mesh_nodes_data( shash64 name, uint16 a_fps, uint16 a_frames, bool a_flat ) 63 : m_name( name ), m_frame_rate(a_fps), m_frame_count(a_frames), m_flat( a_flat ) 64 { 65 } 66 67 void append( data_channel_set* set ) 68 { 133 : m_info( name ), m_frame_rate(0), m_frame_count(0) 134 { 135 } 136 137 explicit mesh_nodes_data( shash64 name, uint16 a_fps, uint16 a_frames ) 138 : m_info( name ), m_frame_rate(a_fps), m_frame_count(a_frames) 139 { 140 } 141 142 void append( data_channel_set* set, data_node_info info ) 143 { 144 m_info.append( info ); 69 145 m_data.push_back( set ); 70 146 } … … 72 148 void initialize() 73 149 { 74 m_children.resize( m_data.size() ); 75 for ( uint8 n = 0; n < uint8( m_data.size() ); ++n ) 76 { 77 const data_channel_set* node = m_data[n]; 78 if ( node->get_parent_id() != -1 ) 79 { 80 m_children[node->get_parent_id()].push( n ); 81 } 82 } 150 m_info.initialize(); 83 151 } 84 152 85 153 const child_list& children( size_t i ) const 86 154 { 87 return m_ children[i];155 return m_info.children(i); 88 156 } 89 157 … … 108 176 const data_channel_set* get_by_hash( shash64 h ) const 109 177 { 110 for ( auto data : m_data ) 111 { 112 if ( data->get_name() == h ) return data; 178 for ( uint32 i = 0; i < m_info.size(); ++i ) 179 { 180 if ( m_info[i].name == h ) 181 return m_data[i]; 113 182 } 114 183 return nullptr; … … 119 188 for ( uint32 i = 0; i < m_data.size(); ++i ) 120 189 { 121 if ( m_ data[ i ]->get_name()== h )190 if ( m_info[ i ].name == h ) 122 191 return int( i ); 123 192 } … … 128 197 { 129 198 return m_data[i]; 199 } 200 const data_node_info& get_info( size_t i ) const 201 { 202 return m_info[i]; 203 } 204 const data_node_tree& get_info() const 205 { 206 return m_info; 130 207 } 131 208 … … 133 210 const_iterator end() const { return m_data.end(); } 134 211 135 bool is_flat() const { return m_flat; }136 212 uint16 get_fps() const { return m_frame_rate; } 137 213 uint16 get_frame_count() const { return m_frame_count; } 138 shash64 get_name() const { return m_ name; }214 shash64 get_name() const { return m_info.get_name(); } 139 215 140 216 ~mesh_nodes_data() … … 144 220 145 221 private: 222 data_node_tree m_info; 146 223 vector< data_channel_set* > m_data; 147 vector< child_list > m_children;148 shash64 m_name;149 224 uint16 m_frame_rate; 150 225 uint16 m_frame_count; 151 bool m_flat;152 226 }; 153 227 -
trunk/nv/interface/mesh_loader.hh
r480 r482 31 31 virtual ~mesh_loader() {} 32 32 virtual bool load( stream& source ) = 0; 33 virtual data_channel_set* release_mesh_data( size_t index = 0) = 0;33 virtual data_channel_set* release_mesh_data( size_t index, data_node_info& ) = 0; 34 34 virtual size_t get_mesh_count() const = 0; 35 35 virtual size_t get_nodes_data_count() const { return 0; } 36 36 virtual mesh_nodes_data* release_mesh_nodes_data( size_t = 0 ) { return nullptr; } 37 virtual data_node_list* release_data_node_list( size_t = 0 ) { return nullptr; } 38 virtual bool is_animated( size_t = 0 ) { return false; } 37 39 protected: 38 40 inline shash64 make_name( const string_view& name ) -
trunk/nv/stl/hash_map.hh
r432 r482 126 126 iterator it = base_type::find( key ); 127 127 NV_ASSERT_ALWAYS( it != base_type::end(), "Key not found in map!" ); 128 return *it;128 return it->second; 129 129 } 130 130 … … 133 133 const_iterator it = base_type::find( key ); 134 134 NV_ASSERT_ALWAYS( it != base_type::cend(), "Key not found in map!" ); 135 return *it;135 return it->second; 136 136 } 137 137 … … 142 142 iterator it = base_type::find( key ); 143 143 NV_ASSERT_ALWAYS( it != base_type::end(), "Key not found in map!" ); 144 return *it;144 return it->second; 145 145 } 146 146 … … 151 151 const_iterator it = base_type::find( key ); 152 152 NV_ASSERT_ALWAYS( it != base_type::cend(), "Key not found in map!" ); 153 return *it;153 return it->second; 154 154 } 155 155 -
trunk/src/formats/assimp_loader.cc
r480 r482 105 105 } 106 106 107 data_channel_set* nv::assimp_loader::release_mesh_data( size_t index /*= 0 */)107 data_channel_set* nv::assimp_loader::release_mesh_data( size_t index, data_node_info& info ) 108 108 { 109 109 if ( index >= m_mesh_count ) return nullptr; 110 110 data_channel_set* result = data_channel_set_creator::create_set( 2 ); 111 load_mesh_data( result, index );111 load_mesh_data( result, index, info ); 112 112 return result; 113 113 } 114 void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index )114 void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index, data_node_info& info ) 115 115 { 116 116 const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene ); … … 126 126 data_channel_set_creator maccess( data ); 127 127 const char* name = mesh->mName.data; 128 maccess.set_name( make_name( name ) ); 128 info.name = make_name( name ); 129 info.parent_id = -1; 129 130 uint8* cdata = maccess.add_channel( desc, mesh->mNumVertices ).raw_data(); 130 131 uint16* indices = reinterpret_cast<uint16*>( maccess.add_channel< index_u16 >( mesh->mNumFaces * 3 ).raw_data() ); … … 190 191 } 191 192 192 bool nv::assimp_loader::load_bones( size_t index, array_ref< data_ channel_set*> bones )193 bool nv::assimp_loader::load_bones( size_t index, array_ref< data_node_info > bones ) 193 194 { 194 195 if ( m_scene == nullptr ) return false; … … 200 201 aiBone* bone = mesh->mBones[m]; 201 202 mat4 offset = assimp_mat4_cast( bone->mOffsetMatrix ); 202 bones[m] = data_channel_set_creator::create_set( 0 );203 data_channel_set_creator access( bones[m] );204 203 const char* name = bone->mName.data; 205 access.set_name( make_name( name ));206 access.set_transform( offset );204 bones[m].name = make_name( name ); 205 bones[m].transform = offset; 207 206 } 208 207 return true; … … 284 283 } 285 284 286 mesh_nodes_data* nv::assimp_loader::release_merged_bones( data_channel_set* meshes )287 { 288 const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene ); 289 mesh_nodes_data* result = new mesh_nodes_data( make_name( "bones" ) );285 data_node_list* nv::assimp_loader::release_merged_bones( data_channel_set* meshes ) 286 { 287 const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene ); 288 data_node_list* result = new data_node_list( make_name( "bones" ) ); 290 289 hash_store< shash64, uint16 > names; 291 290 for ( unsigned int m = 0; m < m_mesh_count; ++m ) 292 291 { 293 292 uint16 translate[MAX_BONES]; 294 vector< data_ channel_set*> bones;293 vector< data_node_info > bones; 295 294 const aiMesh* mesh = scene->mMeshes[ m ]; 296 295 if ( mesh->mNumBones != 0 ) 297 296 { 298 297 bones.resize( mesh->mNumBones ); 298 NV_ASSERT( false, "parent ids for bones are not loaded!" ); 299 299 load_bones( m, bones ); 300 300 for ( unsigned int b = 0; b < mesh->mNumBones; ++b ) 301 301 { 302 302 303 data_ channel_set*bone = bones[b];304 auto iname = names.find( bone ->get_name());303 data_node_info bone = bones[b]; 304 auto iname = names.find( bone.name ); 305 305 if ( iname == names.end() ) 306 306 { … … 308 308 uint16 index = uint16( result->size() ); 309 309 result->append( bone ); 310 names[ bone ->get_name()] = index;310 names[ bone.name ] = index; 311 311 translate[b] = index; 312 312 } … … 334 334 } 335 335 } 336 result->initialize();336 //result->initialize(); 337 337 338 338 return result; … … 352 352 uint16 frame_rate = static_cast<uint16>( anim->mTicksPerSecond ); 353 353 uint16 duration = static_cast<uint16>( anim->mDuration ); 354 bool flat = false; 355 356 data_ channel_set** temp = new data_channel_set*[ count];354 355 data_channel_set** temp = new data_channel_set*[ count ]; 356 data_node_info* temp2 = new data_node_info[count]; 357 357 array_ref< data_channel_set* > temp_ref( temp, count ); 358 load_node( index, temp_ref, root, 0, -1 ); 359 360 mesh_nodes_data* result = new mesh_nodes_data( make_name( static_cast<const char*>( anim->mName.data ) ), frame_rate, duration, flat ); 361 for ( auto set : temp_ref ) 362 { 363 result->append( set ); 358 array_ref< data_node_info > temp2_ref( temp2, count ); 359 load_node( index, temp_ref, temp2_ref, root, 0, -1 ); 360 361 mesh_nodes_data* result = new mesh_nodes_data( make_name( static_cast<const char*>( anim->mName.data ) ), frame_rate, duration ); 362 for ( nv::uint32 i = 0; i < count; ++i ) 363 { 364 result->append( temp_ref[i], temp2_ref[i] ); 364 365 } 365 366 result->initialize(); 366 367 delete temp; 368 delete temp2; 367 369 return result; 370 } 371 372 data_node_list* nv::assimp_loader::release_data_node_list( size_t index /*= 0 */ ) 373 { 374 int this_is_incorrect; 375 NV_ASSERT( false, "unimplemented!" ); 376 // mesh_nodes_data* half_result = release_mesh_nodes_data( index ); 377 // data_node_list* result = new data_node_list( half_result->get_name() ); 378 // for ( auto node : *half_result ) 379 // result->append( node->get_info() ); 380 // delete half_result; 381 // return result; 382 return nullptr; 383 } 384 385 bool nv::assimp_loader::is_animated( size_t /*= 0 */ ) 386 { 387 int this_is_incorrect; 388 return false; 368 389 } 369 390 … … 379 400 } 380 401 381 nv::sint16 nv::assimp_loader::load_node( uint32 anim_id, array_ref< data_channel_set* > nodes, const void* vnode, sint16 this_id, sint16 parent_id )402 nv::sint16 nv::assimp_loader::load_node( uint32 anim_id, array_ref< data_channel_set* > nodes, array_ref< data_node_info > infos, const void* vnode, sint16 this_id, sint16 parent_id ) 382 403 { 383 404 const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene ); … … 396 417 nodes[ this_id ] = anode ? create_keys( anode ) : data_channel_set_creator::create_set( 0 ); 397 418 398 data_channel_set_creator access( nodes[this_id] ); 399 access.set_name( make_name( name ) ); 400 access.set_parent_id( parent_id ); 419 infos[this_id].name = make_name( name ); 420 infos[this_id].parent_id = parent_id; 401 421 // This value is ignored by the create_transformed_keys, but needed by create_direct_keys! 402 422 // TODO: find a common solution! 403 423 // This is bad because create_transformed_keys never uses node-transformations for 404 424 // node's without keys 405 access.set_transform( nv::assimp_mat4_cast( node->mTransformation ) ); 406 if ( this_id == 0 ) access.set_transform( mat4() ); 425 // TODO: this can probably be deleted 426 infos[this_id].transform = nv::assimp_mat4_cast( node->mTransformation ); 427 if ( this_id == 0 ) infos[this_id].transform = mat4(); 407 428 408 429 nv::sint16 next = this_id + 1; 409 430 for ( unsigned i = 0; i < node->mNumChildren; ++i ) 410 431 { 411 next = load_node( anim_id, nodes, node->mChildren[i], next, this_id );432 next = load_node( anim_id, nodes, infos, node->mChildren[i], next, this_id ); 412 433 } 413 434 -
trunk/src/formats/nmd_loader.cc
r480 r482 37 37 { 38 38 data_channel_set* mesh = data_channel_set_creator::create_set( e.children ); 39 load_channel_set( source, mesh, e ); 39 data_node_info info; 40 load_channel_set( source, mesh, info, e ); 40 41 // m_mesh_names.push_back( e.name ); 42 m_infos.push_back( info ); 41 43 m_meshes.push_back( mesh ); 42 44 return true; 43 45 } 44 46 45 data_channel_set* nv::nmd_loader::release_mesh_data( size_t index )47 data_channel_set* nv::nmd_loader::release_mesh_data( size_t index, data_node_info& info ) 46 48 { 47 49 data_channel_set* result = m_meshes[ index ]; 50 info = m_infos[ index ]; 48 51 m_meshes[ index ] = nullptr; 49 52 return result; … … 54 57 for ( auto mesh : m_meshes ) if ( mesh ) delete mesh; 55 58 if ( m_node_data ) delete m_node_data; 59 if ( m_bone_data ) delete m_bone_data; 56 60 m_meshes.clear(); 57 61 58 m_node_data = nullptr; 62 m_node_data = nullptr; 63 m_bone_data = nullptr; 59 64 } 60 65 … … 85 90 nmd_animation_header animation_header; 86 91 source.read( &animation_header, sizeof( animation_header ), 1 ); 87 m_node_data = new mesh_nodes_data( e.name, animation_header.frame_rate, animation_header.frame_count, animation_header.flat ); 92 m_node_data = new mesh_nodes_data( e.name, animation_header.frame_rate, animation_header.frame_count ); 93 m_bone_data = new data_node_list( e.name ); 88 94 for ( uint32 i = 0; i < e.children; ++i ) 89 95 { … … 93 99 NV_ASSERT( element_header.type == nmd_type::NODE, "NODE expected!" ); 94 100 data_channel_set* set = data_channel_set_creator::create_set( element_header.children ); 95 load_channel_set( source, set, element_header ); 96 m_node_data->append( set ); 101 data_node_info info; 102 load_channel_set( source, set, info, element_header ); 103 m_bone_data->append( info ); 104 m_node_data->append( set, info ); 97 105 } 98 106 m_node_data->initialize(); … … 110 118 } 111 119 112 bool nv::nmd_loader::load_channel_set( stream& source, data_channel_set* channel_set, const nmd_element_header& e )120 bool nv::nmd_loader::load_channel_set( stream& source, data_channel_set* channel_set, data_node_info& info, const nmd_element_header& e ) 113 121 { 114 122 data_channel_set_creator kaccess( channel_set ); … … 117 125 load_channel( source, channel_set ); 118 126 } 119 data_channel_set_creator access( channel_set ); 120 access.set_name( e.name ); 121 access.set_parent_id( e.parent_id ); 122 access.set_transform( e.transform ); 127 info.name = e.name; 128 info.parent_id = e.parent_id; 129 info.transform = e.transform; 123 130 return true; 124 131 } … … 126 133 mesh_nodes_data* nv::nmd_loader::release_mesh_nodes_data( size_t ) 127 134 { 128 if ( m_node_data ) 129 { 130 mesh_nodes_data* result = m_node_data; 131 m_node_data = nullptr; 132 return result; 133 } 134 return nullptr; 135 mesh_nodes_data* result = m_node_data; 136 m_node_data = nullptr; 137 return result; 138 } 139 140 data_node_list* nv::nmd_loader::release_data_node_list( size_t ) 141 { 142 data_node_list* result = m_bone_data; 143 m_bone_data = nullptr; 144 return result; 145 } 146 147 bool nv::nmd_loader::is_animated( size_t /*= 0 */ ) 148 { 149 if ( !m_node_data ) return false; 150 return m_node_data->is_animated(); 135 151 } 136 152 … … 150 166 } 151 167 152 void nv::nmd_dump_element( stream& stream_out, const data_channel_set& data, nmd_type type )168 void nv::nmd_dump_element( stream& stream_out, const data_channel_set& data, const data_node_info& info, nmd_type type ) 153 169 { 154 170 uint32 size = 0; … … 163 179 eheader.children = static_cast<uint16>( data.size() ); 164 180 eheader.size = size; 165 eheader.name = data.get_name();166 eheader.transform = data.get_transform();167 eheader.parent_id = data.get_parent_id();181 eheader.name = info.name; 182 eheader.transform = info.transform; 183 eheader.parent_id = info.parent_id; 168 184 eheader.attributes = 0; 169 185 stream_out.write( &eheader, sizeof( eheader ), 1 ); … … 205 221 aheader.frame_rate = nodes.get_fps(); 206 222 aheader.frame_count = nodes.get_frame_count(); 207 aheader. flat = nodes.is_flat();223 aheader.unused = false; 208 224 stream_out.write( &aheader, sizeof( aheader ), 1 ); 209 225 226 for ( uint32 i = 0; i < nodes.size(); ++i ) 227 { 228 nmd_dump_element( stream_out, *nodes[i], nodes.get_info(i), nv::nmd_type::NODE ); 229 } 230 } 231 232 void nv::nmd_dump_bones( stream& stream_out, const data_node_list& nodes ) 233 { 234 uint32 total = sizeof( nmd_animation_header ); 210 235 for ( auto node : nodes ) 211 236 { 212 nmd_dump_element( stream_out, *node, nv::nmd_type::NODE ); 237 total += sizeof( nmd_element_header ); 238 } 239 240 nmd_element_header header; 241 header.type = nmd_type::ANIMATION; 242 header.children = static_cast<uint16>( nodes.size() ); 243 header.size = total; 244 header.name = nodes.get_name(); 245 header.transform = mat4(); 246 header.parent_id = -1; 247 header.attributes = 0; 248 249 stream_out.write( &header, sizeof( header ), 1 ); 250 251 nmd_animation_header aheader; 252 aheader.frame_rate = 0; 253 aheader.frame_count = 0; 254 aheader.unused = false; 255 stream_out.write( &aheader, sizeof( aheader ), 1 ); 256 257 for ( auto node : nodes ) 258 { 259 nmd_element_header eheader; 260 eheader.type = nv::nmd_type::NODE; 261 eheader.children = 0; 262 eheader.size = 0; 263 eheader.name = node.name; 264 eheader.transform = node.transform; 265 eheader.parent_id = node.parent_id; 266 eheader.attributes = 0; 267 stream_out.write( &eheader, sizeof( eheader ), 1 ); 213 268 } 214 269 } … … 227 282 } 228 283 229 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 */ )284 void nv::nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, array_view< data_node_info > infos, const mesh_nodes_data* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ ) 230 285 { 231 286 uint32 elements = ( strings ? 1 : 0 ) // +1 string array … … 237 292 { 238 293 NV_ASSERT( meshes[i], "mesh is null!" ); 239 nmd_dump_element( stream_out, *meshes[i], nv::nmd_type::MESH );294 nmd_dump_element( stream_out, *meshes[i], infos[i], nv::nmd_type::MESH ); 240 295 } 241 296 … … 243 298 { 244 299 nmd_dump_nodes( stream_out, *nodes ); 300 } 301 302 if ( strings ) 303 { 304 nmd_dump_strings( stream_out, *strings ); 305 } 306 } 307 308 void nv::nmd_dump( stream& stream_out, array_view< data_channel_set* > meshes, array_view< data_node_info > infos, const nv::data_node_list* nodes, const string_table* strings /*= nullptr*/, uint64 name /*= 0 */ ) 309 { 310 uint32 elements = ( strings ? 1 : 0 ) // +1 string array 311 + meshes.size() // meshes 312 + ( nodes && nodes->size() > 0 ? 1 : 0 ); // nodes 313 nmd_dump_header( stream_out, elements, name ); 314 315 for ( uint32 i = 0; i < meshes.size(); ++i ) 316 { 317 NV_ASSERT( meshes[i], "mesh is null!" ); 318 nmd_dump_element( stream_out, *meshes[i], infos[i], nv::nmd_type::MESH ); 319 } 320 321 if ( nodes && nodes->size() > 0 ) 322 { 323 nmd_dump_bones( stream_out, *nodes ); 245 324 } 246 325 -
trunk/src/formats/obj_loader.cc
r480 r482 327 327 328 328 data_channel_set* result = data_channel_set_creator::create_set( 1 ); 329 data_channel_set_creator raccess( result ); 330 raccess.set_name( make_name( reader->name ) ); 331 uint8* rdata = raccess.add_channel( m_descriptor, reader->size * 3 ).raw_data(); 329 330 uint8* rdata = data_channel_set_creator(result).add_channel( m_descriptor, reader->size * 3 ).raw_data(); 332 331 333 332 if ( reader->raw_size() > 0 ) … … 335 334 raw_copy_n( reader->raw_pointer(), reader->raw_size(), rdata ); 336 335 } 337 336 data_node_info info; 337 info.name = make_name( reader->name ); 338 info.parent_id = -1; 339 m_infos.push_back( info ); 338 340 m_meshes.push_back( result ); 339 341 … … 345 347 } 346 348 347 data_channel_set* nv::obj_loader::release_mesh_data( size_t index )349 data_channel_set* nv::obj_loader::release_mesh_data( size_t index, data_node_info& info ) 348 350 { 349 351 data_channel_set* result = m_meshes[ index ]; 352 info = m_infos[index]; 350 353 m_meshes[ index ] = nullptr; 351 354 return result; -
trunk/src/gfx/mesh_creator.cc
r480 r482 13 13 struct nv_key_transform { nv::transform tform; }; 14 14 15 void nv::mesh_nodes_creator::pre_transform_keys()16 {17 if ( m_data->m_flat ) return;18 merge_keys();19 uint16 max_frames = 0;20 21 nv::vector< sint16 > ids;22 {23 // TODO: simplify this shit!24 // The complexity here is that we cannot pre-transform in any order25 // as the bones depend on previous bones, but ARE NOT IN ORDER26 //27 // Either rewrite this a lot nicer, or sort the bones on creation28 // by tree-order.29 30 ids.reserve( m_data->m_data.size() );31 {32 nv::vector< sint16 > ids_next;33 ids_next.reserve( m_data->m_data.size() );34 ids_next.push_back( -1 );35 while ( !ids_next.empty() )36 {37 sint16 pid = ids_next.back();38 ids_next.pop_back();39 for ( sint16 i = 0; i < sint16(m_data->m_data.size()); ++i )40 if ( m_data->m_data[i]->get_parent_id() == pid )41 {42 sint16* it = nv::find( ids.begin(), ids.end(), i );43 if ( it == ids.end() )44 {45 ids.push_back( i );46 ids_next.push_back( i );47 }48 }49 }50 }51 52 if ( ids.size() != m_data->m_data.size() )53 {54 NV_LOG_WARNING( "Bad skeleton!" );55 }56 }57 58 NV_LOG_DEBUG( "ID/PID" );59 for ( auto id : ids )60 {61 data_channel_set* keys = m_data->m_data[id];62 sint16 parent_id = keys->get_parent_id();63 NV_LOG_DEBUG( "Id : ", id, " PID", parent_id );64 data_channel_set* pkeys = ( parent_id != -1 ? m_data->m_data[parent_id] : nullptr );65 size_t count = ( keys ? keys->get_channel_size(0) : 0 );66 size_t pcount = ( pkeys ? pkeys->get_channel_size(0) : 0 );67 max_frames = nv::max<uint16>( uint16( count ), max_frames );68 if ( pkeys && pkeys->size() > 0 && keys && keys->size() > 0 )69 {70 data_channel_access< nv_key_transform > channel_creator( keys, 0 );71 72 nv_key_transform* channel = channel_creator.data();73 const nv_key_transform* pchannel = pkeys->get_channel(0)->data_cast< nv_key_transform >();74 for ( unsigned n = 0; n < count; ++n )75 {76 channel[n].tform = pchannel[ nv::min( n, pcount-1 ) ].tform * channel[n].tform;77 }78 }79 }80 81 // DAE pre_transform hack82 if ( m_data->m_frame_rate == 1 )83 {84 m_data->m_frame_rate = 32;85 m_data->m_frame_count = max_frames;86 }87 88 m_data->m_flat = true;89 }90 91 92 15 void nv::mesh_nodes_creator::merge_keys() 93 16 { … … 110 33 data_channel_set* new_keys = data_channel_set_creator::create_set( 1 ); 111 34 data_channel_set_creator nk_access( new_keys ); 112 nk_access.set_name( old_keys->get_name() );113 nk_access.set_parent_id( old_keys->get_parent_id() );114 nk_access.set_transform( old_keys->get_transform() );115 35 data_channel_access< nv_key_transform > kt_channel( nk_access.add_channel<nv_key_transform>( max_keys ) ); 116 36 … … 145 65 for ( auto node : m_data->m_data ) 146 66 { 147 node->m_transform = pre_transform * node->m_transform * post_transform;148 149 67 for ( size_t c = 0; c < node->size(); ++c ) 150 68 { … … 158 76 } 159 77 } 78 79 void nv::data_node_list_creator::transform( float scale, const mat3& r33 ) 80 { 81 mat3 ri33 = math::inverse( r33 ); 82 mat4 pre_transform( scale * r33 ); 83 mat4 post_transform( 1.f / scale * ri33 ); 84 85 for ( auto& node : m_data->m_data ) 86 node.transform = pre_transform * node.transform * post_transform; 87 } 88 160 89 161 90 void nv::mesh_data_creator::transform( float scale, const mat3& r33 ) … … 209 138 nv::vec4 tangent; 210 139 }; 140 211 141 212 142 void nv::mesh_data_creator::flip_normals() … … 434 364 } 435 365 366 436 367 template < typename T > 437 368 static inline void swap_culling_impl( nv::raw_data_channel* index_channel ) … … 650 581 initialize(); 651 582 } 652 -
trunk/src/gfx/skeleton_instance.cc
r481 r482 9 9 #include "nv/core/profiler.hh" 10 10 11 void nv::skeleton_binding::prepare( const mesh_nodes_data* node_data, const mesh_nodes_data*bone_data )11 void nv::skeleton_binding::prepare( const mesh_nodes_data* node_data, const data_node_list& bone_data ) 12 12 { 13 13 if ( m_indices.empty() ) … … 16 16 hash_store< shash64, uint16 > bone_names; 17 17 m_indices.resize( node_data->size() ); 18 19 for ( nv::uint16 bi = 0; bi < bone_data->size(); ++bi ) 20 { 21 const data_channel_set* bone = ( *bone_data )[bi]; 22 bone_names[bone->get_name()] = bi; 23 } 18 19 for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi ) 20 bone_names[bone_data[bi].name] = bi; 24 21 25 22 for ( uint32 n = 0; n < node_data->size(); ++n ) 26 23 { 27 const data_channel_set* node = ( *node_data )[n];28 24 sint16 bone_id = -1; 29 30 auto bi = bone_names.find( node->get_name() ); 25 auto bi = bone_names.find( node_data->get_info( n ).name ); 31 26 if ( bi != bone_names.end() ) 32 27 { … … 36 31 37 32 } 38 m_bone_count = bone_data ->size();33 m_bone_count = bone_data.size(); 39 34 } 40 35 … … 48 43 } 49 44 } 50 51 52 45 } 53 54 // void nv::skeleton_instance::animate_( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame )55 // {56 // if ( m_matrix.size() > 0 )57 // {58 // if ( node_data->is_flat() )59 // {60 // animate_flat( node_data, binding, frame );61 // }62 // else63 // {64 // for ( uint32 n = 0; n < node_data->size(); ++n )65 // if ( ( *node_data )[n]->get_parent_id() == -1 )66 // animate_rec( node_data, binding, frame, n, transform() );67 // }68 // }69 // }70 //71 // void nv::skeleton_instance::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent )72 // {73 // // TODO: fix transforms, which are now embedded,74 // // see note in assimp_loader.cc:load_node75 // const data_channel_set* node = ( *node_data )[id];76 // transform node_mat( node->get_transform() );77 //78 // if ( node->size() > 0 )79 // {80 // raw_channel_interpolator interpolator( node, binding.m_key );81 // node_mat = interpolator.get< transform >( frame );82 // }83 //84 // transform global_mat = parent * node_mat;85 //86 // sint16 bone_id = binding.m_indices[id];87 // if ( bone_id >= 0 )88 // {89 // m_matrix[bone_id] = global_mat.extract() * binding.m_offsets[bone_id];90 // }91 //92 // for ( auto child : node_data->children( id ) )93 // {94 // animate_rec( node_data, binding, frame, child, global_mat );95 // }96 // }97 //98 // void nv::skeleton_instance::animate_flat( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame )99 // {100 // for ( uint32 n = 0; n < node_data->size(); ++n )101 // if ( binding.m_indices[n] >= 0 )102 // {103 // const data_channel_set* node = ( *node_data )[n];104 // nv::mat4 node_mat( node->get_transform() );105 //106 // if ( node->size() > 0 )107 // {108 // raw_channel_interpolator interpolator( node, binding.m_key );109 // node_mat = interpolator.get< mat4 >( frame );110 // }111 // sint16 bone_id = binding.m_indices[n];112 // m_matrix[bone_id] = node_mat * binding.m_offsets[bone_id];113 // }114 // }115 46 116 47 void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const bone_transforms& bones ) … … 120 51 const transform* transforms = skeleton.transforms(); 121 52 for ( uint32 n = 0; n < skeleton.size(); ++n ) 53 { 122 54 m_matrix[n] = transforms[n].extract() * bones.m_offsets[n]; 55 } 123 56 } 124 57 … … 129 62 } 130 63 131 void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent ) 64 void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame ) 65 { 66 if ( m_transforms.size() != binding.skeleton_size() ) 67 m_transforms.resize( binding.skeleton_size() ); 68 for ( uint32 n = 0; n < node_data->size(); ++n ) 69 { 70 const data_channel_set* node = ( *node_data )[n]; 71 sint16 bone_id = binding.m_indices[n]; 72 if ( bone_id >= 0 ) 73 { 74 if ( node->size() > 0 ) 75 m_transforms[bone_id] = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame ); 76 int confirm_that_not_needed; 77 // else 78 // m_transforms[bone_id] = transform( node->get_transform() ); 79 } 80 } 81 } 82 83 void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, float blend ) 84 { 85 if ( m_transforms.size() != binding.skeleton_size() ) 86 m_transforms.resize( binding.skeleton_size() ); 87 for ( uint32 n = 0; n < node_data->size(); ++n ) 88 { 89 const data_channel_set* node = ( *node_data )[n]; 90 sint16 bone_id = binding.m_indices[n]; 91 if ( bone_id >= 0 ) 92 { 93 94 transform tr = node->size() > 0 ? raw_channel_interpolator( node, binding.m_key ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed; 95 m_transforms[bone_id] = nv::interpolate( m_transforms[bone_id], tr, blend ); 96 } 97 } 98 } 99 100 void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, const skeleton_binding& binding, uint32 id, const transform& parent ) 101 { 102 sint16 bone_id = binding.m_indices[id]; 103 transform global_mat = parent; 104 if ( bone_id >= 0 ) 105 { 106 global_mat *= m_transforms[bone_id]; 107 m_transforms[bone_id] = global_mat; 108 } 109 for ( auto child : node_data.children( id ) ) 110 { 111 delocalize_rec( node_data, binding, child, global_mat ); 112 } 113 } 114 115 void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local ) 132 116 { 133 117 const data_channel_set* node = ( *node_data )[id]; 134 transform node_mat( node->get_transform() ); 118 transform node_mat; 119 120 if ( node->size() > 0 ) 121 node_mat = raw_channel_interpolator( node, binding.m_key ).get< transform >( frame ); 122 int confirm_that_not_needed; 123 // else 124 // node_mat = transform( node->get_transform() ); 125 sint16 bone_id = binding.m_indices[id]; 126 transform global_mat = parent * node_mat; 127 if ( bone_id >= 0 ) 128 { 129 m_transforms[bone_id] = local ? node_mat : global_mat; 130 } 131 for ( auto child : node_data->children( id ) ) 132 { 133 animate_rec( node_data, binding, frame, child, global_mat, local ); 134 } 135 } 136 137 void nv::skeleton_transforms::blend_rec( const mesh_nodes_data* node_data, const skeleton_binding& binding, float frame, uint32 id, const transform& parent, bool local, float blend ) 138 { 139 const data_channel_set* node = ( *node_data )[id]; 140 int confirm_that_not_needed; 141 transform node_mat/*( node->get_transform() )*/; 135 142 136 143 if ( node->size() > 0 ) … … 143 150 if ( bone_id >= 0 ) 144 151 { 145 m_transforms[bone_id] = global_mat;152 m_transforms[bone_id] = nv::interpolate( m_transforms[bone_id], local ? node_mat : global_mat, blend ); 146 153 } 147 154 for ( auto child : node_data->children( id ) ) 148 155 { 149 animate_rec( node_data, binding, frame, child, global_mat);156 blend_rec( node_data, binding, frame, child, global_mat, local, blend ); 150 157 } 151 158 } 152 159 153 void nv::bone_transforms::prepare( const mesh_nodes_data* bone_data ) 160 161 void nv::bone_transforms::prepare( const data_node_list& bone_data ) 154 162 { 155 163 if ( m_offsets.empty() ) 156 164 { 157 m_offsets.resize( bone_data ->size() );165 m_offsets.resize( bone_data.size() ); 158 166 159 for ( nv::uint16 bi = 0; bi < bone_data->size(); ++bi ) 160 { 161 const data_channel_set* bone = ( *bone_data )[bi]; 162 m_offsets[bi] = bone->get_transform(); 163 } 167 for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi ) 168 m_offsets[bi] = bone_data[bi].transform; 164 169 } 165 170 }
Note: See TracChangeset
for help on using the changeset viewer.
