Context Navigation

source: trunk/src/formats/md5_loader.cc @ 412

Last change on this file since 412 was 412, checked in by epyon, 10 years ago
refactoring of raw_data_channel and data_descriptor access
File size: 15.2 KB

Line
1	// Copyright (C) 2012-2015 ChaosForge Ltd
2	// http://chaosforge.org/
3	//
4	// This file is part of Nova libraries.
5	// For conditions of distribution and use, see copying.txt file in root folder.
6
7	#include "nv/formats/md5_loader.hh"
8
9	#include "nv/core/logging.hh"
10	#include "nv/stl/vector.hh"
11	#include "nv/io/std_stream.hh"
12
13	#include <stdio.h> // sscanf
14	#include <stdlib.h> // atof
15
16	using namespace nv;
17
18	static void next_line( std::istream& stream )
19	{
20	stream.ignore( 1024*1024, '\n' );
21	}
22
23	static inline void discard( std::istream& stream, const std::string& token )
24	{
25	std::string discarded;
26	stream >> discarded;
27	assert( discarded == token );
28	}
29
30	static void remove_quotes( std::string& str )
31	{
32	nv::size_t n;
33	while ( ( n = str.find('\"') ) != std::string::npos ) str.erase(n,1);
34	}
35
36	static void unit_quat_w( nv::quat& quat )
37	{
38	float t = 1.0f - ( quat.x * quat.x ) - ( quat.y * quat.y ) - ( quat.z * quat.z );
39	quat.w = ( t < 0.0f ? 0.0f : -sqrtf(t) );
40	}
41
42	bool md5_loader::load( stream& source )
43	{
44	reset();
45	std_stream sstream( &source );
46	std::string command;
47	mesh_node_data* nodes = nullptr;
48	size_t num_joints = 0;
49
50	// MESH data
51	dynamic_array< md5_weight > weights;
52	dynamic_array< md5_weight_info > weight_info;
53	size_t num_meshes = 0;
54
55	// MESH data
56	dynamic_array< md5_joint_info > joint_infos;
57	vector< transform > base_frames;
58	size_t num_animated_components = 0;
59	size_t frame_rate = 0;
60	size_t num_frames = 0;
61
62	sstream >> command;
63	while ( !sstream.eof() )
64	{
65	if ( command == "MD5Version" )
66	{
67	sstream >> m_md5_version;
68	assert( m_md5_version == 10 );
69	}
70	else if ( command == "commandline" )
71	{
72	next_line( sstream );
73	}
74	else if ( command == "numJoints" )
75	{
76	sstream >> num_joints;
77	next_line( sstream );
78	}
79	else if ( command == "numMeshes" )
80	{
81	assert( m_type == UNKNOWN );
82	m_type = MESH;
83	sstream >> num_meshes;
84	m_meshes.resize( num_meshes );
85	num_meshes = 0;
86	}
87	else if ( command == "numFrames" )
88	{
89	assert( m_type == UNKNOWN \|\| m_type == ANIMATION );
90	m_type = ANIMATION;
91	sstream >> num_frames;
92	next_line( sstream );
93	}
94	else if ( command == "frameRate" )
95	{
96	assert( m_type == UNKNOWN \|\| m_type == ANIMATION );
97	m_type = ANIMATION;
98	sstream >> frame_rate;
99	next_line( sstream );
100	}
101	else if ( command == "numAnimatedComponents" )
102	{
103	assert( m_type == UNKNOWN \|\| m_type == ANIMATION );
104	m_type = ANIMATION;
105	sstream >> num_animated_components;
106	next_line( sstream );
107	}
108	else if ( command == "joints" )
109	{
110	assert( m_type == MESH );
111	assert( m_nodes == nullptr );
112	nodes = new mesh_node_data[ num_joints ];
113	m_nodes = new mesh_nodes_data( "md5_bones", num_joints, nodes );
114	discard( sstream, "{" );
115	for ( size_t i = 0; i < m_nodes->get_count(); ++i )
116	{
117	sstream >> nodes[i].name >> nodes[i].parent_id;
118	vec3 pos;
119	quat orient;
120	discard( sstream, "(" );
121	sstream >> pos.x >> pos.y >> pos.z;
122	discard( sstream, ")" );
123	discard( sstream, "(" );
124	sstream >> orient.x >> orient.y >> orient.z;
125	unit_quat_w( orient );
126	remove_quotes( nodes[i].name );
127	nodes[i].target_id = -1;
128	nodes[i].parent_id = -1;
129	nodes[i].transform = transform( pos, orient ).inverse().extract();
130	nodes[i].data = nullptr;
131	next_line( sstream );
132	}
133	discard( sstream, "}" );
134	}
135	else if ( command == "mesh" )
136	{
137	assert( m_type == MESH );
138	mesh_data* mesh = new mesh_data("md5_mesh");
139	raw_data_channel* ch_pntiw = nullptr;
140
141	uint32 num_verts = 0;
142	uint32 num_tris = 0;
143	uint32 num_weights = 0;
144
145	discard( sstream, "{" );
146	sstream >> command;
147	while ( command != "}" )
148	{
149	if ( command == "shader" )
150	{
151	std::string shader;
152	sstream >> shader;
153	remove_quotes( shader );
154	next_line( sstream );
155	}
156	else if ( command == "numverts")
157	{
158	sstream >> num_verts;
159
160	md5_vtx_t* tdata = nullptr;
161	{
162	raw_data_channel* ch_pnt = raw_data_channel::create<md5_vtx_pnt>( num_verts );
163	raw_data_channel* ch_t = raw_data_channel::create<md5_vtx_t>( num_verts );
164	ch_pntiw = raw_data_channel::create<md5_vtx_pntiw>( num_verts );
165	tdata = reinterpret_cast< md5_vtx_t* >( ch_t->data );
166	mesh->add_channel( ch_pnt );
167	mesh->add_channel( ch_t );
168	// TODO: hack to prevent rendering
169	//ch_pntiw->m_count = 0;
170	mesh->add_channel( ch_pntiw );
171	}
172	weight_info.resize( num_verts );
173
174	next_line( sstream );
175	std::string line;
176	for ( uint32 i = 0; i < num_verts; ++i )
177	{
178	size_t weight_count;
179	size_t start_weight;
180	vec2 texcoord;
181
182	std::getline( sstream, line );
183	sscanf( line.c_str(), "%s %u ( %f %f ) %u %u", &(texcoord.x), &(texcoord.y), &(start_weight), &(weight_count) );
184	weight_info[i].start_weight = start_weight;
185	weight_info[i].weight_count = weight_count;
186	tdata[i].texcoord = texcoord;
187	}
188	}
189	else if ( command == "numtris" )
190	{
191	sstream >> num_tris;
192
193	raw_data_channel* ch_i = raw_data_channel::create<index_u32>( num_tris * 3 );
194	uint32* vtx_i = reinterpret_cast< uint32* >( ch_i->data );
195	uint32 idx = 0;
196	mesh->add_channel( ch_i );
197
198	next_line( sstream );
199	std::string line;
200	for ( uint32 i = 0; i < num_tris; ++i )
201	{
202	unsigned ti0;
203	unsigned ti1;
204	unsigned ti2;
205
206	std::getline( sstream, line );
207	sscanf( line.c_str(), "%s %u %u %u %u )", &(ti0), &(ti1), &(ti2));
208
209	vtx_i[idx++] = ti0;
210	vtx_i[idx++] = ti1;
211	vtx_i[idx++] = ti2;
212	}
213	}
214	else if ( command == "numweights" )
215	{
216	sstream >> num_weights;
217	weights.resize( num_weights );
218	next_line( sstream );
219	std::string line;
220	for ( uint32 i = 0; i < num_weights; ++i )
221	{
222	md5_weight weight;
223
224	std::getline( sstream, line );
225	sscanf( line.c_str(), "%s %u %u %f ( %f %f %f )", &(weight.joint_id), &(weight.bias), &(weight.pos.x), &(weight.pos.y), &(weight.pos.z));
226	weights[i] = weight;
227	}
228	}
229	else
230	{
231	next_line( sstream );
232	}
233
234	sstream >> command;
235	}
236
237	prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( ch_pntiw->data ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() );
238
239	m_meshes[ num_meshes ] = mesh;
240	num_meshes++;
241	} // mesh
242	else if ( command == "hierarchy" )
243	{
244	assert( m_type == ANIMATION );
245	assert( nodes == nullptr );
246	nodes = new mesh_node_data[ num_joints ];
247	m_nodes = new mesh_nodes_data( "md5_animation", num_joints, nodes, static_cast< nv::uint16 >( frame_rate ), static_cast< float >( num_frames ), true );
248	joint_infos.resize( num_joints );
249
250	discard( sstream, "{" );
251	for ( size_t i = 0; i < m_nodes->get_count(); ++i )
252	{
253	std::string name;
254	sstream >> nodes[i].name >> nodes[i].parent_id >> joint_infos[i].flags >> joint_infos[i].start_index;
255	remove_quotes( name );
256	nodes[i].transform = mat4();
257	nodes[i].target_id = -1;
258	nodes[i].data = new key_data;
259	nodes[i].data->add_channel( raw_data_channel::create< md5_key_t >( num_frames ) );
260	next_line( sstream );
261	}
262	discard( sstream, "}" );
263	}
264	else if ( command == "bounds" )
265	{
266	assert( m_type == ANIMATION );
267	discard( sstream, "{" );
268	next_line( sstream );
269	for ( size_t i = 0; i < num_frames; ++i )
270	{
271	// vec3 min;
272	// vec3 max;
273	// discard( sstream, "(" );
274	// sstream >> min.x >> min.y >> min.z;
275	// discard( sstream, ")" );
276	// discard( sstream, "(" );
277	// sstream >> max.x >> max.y >> max.z;
278	// m_bounds.push_back( bound );
279	next_line( sstream );
280	}
281
282	discard( sstream, "}" );
283	next_line( sstream );
284	}
285	else if ( command == "baseframe" )
286	{
287	assert( m_type == ANIMATION );
288	discard( sstream, "{" );
289	next_line( sstream );
290
291	for ( size_t i = 0; i < m_nodes->get_count(); ++i )
292	{
293	transform base_frame;
294	vec3 pos;
295	quat orient;
296	discard( sstream, "(" );
297	sstream >> pos.x >> pos.y >> pos.z;
298	discard( sstream, ")" );
299	discard( sstream, "(" );
300	sstream >> orient.x >> orient.y >> orient.z;
301	next_line( sstream );
302
303	base_frames.emplace_back( pos, orient );
304	}
305	discard( sstream, "}" );
306	next_line( sstream );
307	}
308	else if ( command == "frame" )
309	{
310	vector<float> frame;
311	uint32 frame_id;
312	sstream >> frame_id;
313	discard( sstream, "{" );
314	next_line( sstream );
315
316	frame.reserve( num_animated_components );
317	char buf[50];
318	for ( size_t i = 0; i < num_animated_components; ++i )
319	{
320	sstream >> buf;
321	frame.push_back( static_cast< float >( atof(buf) ) );
322	}
323
324	build_frame_skeleton( nodes, frame_id, joint_infos, base_frames, frame );
325
326	discard( sstream, "}" );
327	next_line( sstream );
328	}
329
330	sstream >> command;
331	}
332
333	return true;
334	}
335
336	bool md5_loader::prepare_mesh( md5_vtx_pntiw* vtx_data, mesh_node_data* nodes, uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info )
337	{
338	assert( m_type == MESH );
339	md5_vtx_pnt* vtcs = reinterpret_cast< md5_vtx_pnt* >( mdata->get_channel< md5_vtx_pnt >()->data );
340
341	for ( uint32 i = 0; i < vtx_count; ++i )
342	{
343	size_t start_weight = weight_info[i].start_weight;
344	size_t weight_count = weight_info[i].weight_count;
345	md5_vtx_pntiw& vdata = vtx_data[i];
346	md5_vtx_pnt& vtc = vtcs[i];
347
348	vtc.position = vec3(0);
349	vtc.normal = vec3(0);
350	vtc.tangent = vec3(0);
351
352	stable_sort( weights + start_weight, weights + start_weight + weight_count, [] ( const md5_weight& a, const md5_weight& b ) -> bool { return a.bias > b.bias; } );
353	//std::sort( weights + start_weight, weights + start_weight + weight_count, [](const md5_weight& a, const md5_weight& b) -> bool { return a.bias > b.bias; } );
354
355	if ( weight_count > 4 )
356	{
357	float sum = 0.0f;
358	for ( size_t j = 0; j < 4; ++j )
359	{
360	sum += weights[start_weight + j].bias;
361	}
362	float ratio = 1.0f / sum;
363	for ( size_t j = 0; j < 4; ++j )
364	{
365	weights[start_weight + j].bias = ratio * weights[start_weight + j].bias;
366	}
367	weight_count = 4;
368	}
369
370	for ( int j = 0; j < 4; ++j )
371	{
372	if ( j < int(weight_count) )
373	{
374	vdata.boneindex[j] = int( weights[int(start_weight) + j].joint_id );
375	vdata.boneweight[j] = weights[int(start_weight) + j].bias;
376	}
377	else
378	{
379	vdata.boneindex[j] = 0;
380	vdata.boneweight[j] = 0.0f;
381	}
382	}
383
384	for ( size_t j = 0; j < 4; ++j )
385	{
386	if ( j < weight_count )
387	{
388	md5_weight& weight = weights[start_weight + j];
389	const mesh_node_data& joint = nodes[weight.joint_id];
390	const transform tr = transform( joint.transform ).inverse();
391	vec3 rot_pos = tr.get_orientation() * weight.pos;
392
393	vtc.position += ( tr.get_position() + rot_pos ) * weight.bias;
394	}
395	}
396	}
397
398	const uint32* idata = reinterpret_cast< uint32* >( mdata->get_index_channel()->data );
399	const md5_vtx_t* tdata = mdata->get_channel_data<md5_vtx_t>();
400
401	// Prepare normals
402	uint32 tri_count = mdata->get_count() / 3;
403	for ( unsigned int i = 0; i < tri_count; ++i )
404	{
405	uint32 ti0 = idata[ i * 3 ];
406	uint32 ti1 = idata[ i * 3 + 1 ];
407	uint32 ti2 = idata[ i * 3 + 2 ];
408
409	vec3 v1 = vtcs[ ti0 ].position;
410	vec3 v2 = vtcs[ ti1 ].position;
411	vec3 v3 = vtcs[ ti2 ].position;
412	vec3 xyz1 = v3 - v1;
413	vec3 xyz2 = v2 - v1;
414
415	vec3 normal = glm::cross( xyz1, xyz2 );
416
417	vtcs[ ti0 ].normal += normal;
418	vtcs[ ti1 ].normal += normal;
419	vtcs[ ti2 ].normal += normal;
420
421	const vec2& w1 = tdata[ ti0 ].texcoord;
422	const vec2& w2 = tdata[ ti1 ].texcoord;
423	const vec2& w3 = tdata[ ti2 ].texcoord;
424
425	vec2 st1 = w3 - w1;
426	vec2 st2 = w2 - w1;
427
428	float coef = 1.0f / (st1.x * st2.y - st2.x * st1.y);
429
430	vec3 tangent = (( xyz1 * st2.y ) - ( xyz2 * st1.y )) * coef;
431
432	vtcs[ ti0 ].tangent += tangent;
433	vtcs[ ti1 ].tangent += tangent;
434	vtcs[ ti2 ].tangent += tangent;
435	}
436
437	for ( size_t i = 0; i < vtx_count; ++i )
438	{
439	md5_vtx_pntiw& vdata = vtx_data[i];
440
441	vec3 normal = glm::normalize( vtcs[i].normal );
442	vec3 tangent = glm::normalize( vtcs[i].tangent );
443	vtcs[i].normal = normal;
444	vtcs[i].tangent = tangent;
445
446	vdata.position = vtcs[i].position;
447	vdata.normal = vec3(0);
448	vdata.tangent = vec3(0);
449
450	for ( int j = 0; j < 4; ++j )
451	{
452	const mesh_node_data& joint = nodes[vdata.boneindex[j]];
453	const transform tr = transform( joint.transform ).inverse();
454	vdata.normal += ( normal * tr.get_orientation() ) * vdata.boneweight[j];
455	vdata.tangent += ( tangent * tr.get_orientation() ) * vdata.boneweight[j];
456	}
457	}
458
459	return true;
460	}
461
462	void md5_loader::build_frame_skeleton( mesh_node_data* nodes, uint32 index, const array_view<md5_joint_info>& joint_infos, const array_view<transform>& base_frames, const array_view<float>& frame_data )
463	{
464	assert( m_type == ANIMATION );
465	for ( unsigned int i = 0; i < joint_infos.size(); ++i )
466	{
467	unsigned int j = 0;
468
469	const md5_joint_info& jinfo = joint_infos[i];
470	mesh_node_data& joint = nodes[i];
471	int parent_id = joint.parent_id;
472
473	vec3 pos = base_frames[i].get_position();
474	quat orient = base_frames[i].get_orientation();
475	if ( jinfo.flags & 1 ) pos.x = frame_data[ jinfo.start_index + j++ ];
476	if ( jinfo.flags & 2 ) pos.y = frame_data[ jinfo.start_index + j++ ];
477	if ( jinfo.flags & 4 ) pos.z = frame_data[ jinfo.start_index + j++ ];
478	if ( jinfo.flags & 8 ) orient.x = frame_data[ jinfo.start_index + j++ ];
479	if ( jinfo.flags & 16 ) orient.y = frame_data[ jinfo.start_index + j++ ];
480	if ( jinfo.flags & 32 ) orient.z = frame_data[ jinfo.start_index + j++ ];
481	unit_quat_w( orient );
482
483	if ( parent_id >= 0 ) // Has a parent joint
484	{
485	const mesh_node_data& pjoint = nodes[parent_id];
486	const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->data );
487	transform ptr;
488	if ( pjoint.data->get_channel(0)->element_count() > index ) ptr = ptv[ index ];
489	vec3 rot_pos = ptr.get_orientation() * pos;
490
491	pos = ptr.get_position() + rot_pos;
492	orient = ptr.get_orientation() * orient;
493
494	orient = glm::normalize( orient );
495	}
496
497	reinterpret_cast< transform* >( joint.data->get_channel(0)->data )[index] = transform( pos, orient );
498	}
499	}
500
501	mesh_data* nv::md5_loader::release_mesh_data( size_t index )
502	{
503	mesh_data* result = m_meshes[ index ];
504	m_meshes[ index ] = nullptr;
505	return result;
506	}
507
508	mesh_nodes_data* nv::md5_loader::release_mesh_nodes_data( size_t )
509	{
510	mesh_nodes_data* nodes = m_nodes;
511	m_nodes = nullptr;
512	return nodes;
513	}
514
515	mesh_data_pack* nv::md5_loader::release_mesh_data_pack()
516	{
517	uint32 size = m_meshes.size();
518	mesh_data* meshes = new mesh_data[ size ];
519	for ( uint32 i = 0; i < size; ++i )
520	{
521	m_meshes[i]->move_to( meshes[i] );
522	delete m_meshes[i];
523	m_meshes[i] = nullptr;
524	}
525	return new mesh_data_pack( size, meshes, release_mesh_nodes_data() );
526	}
527
528
529	nv::md5_loader::~md5_loader()
530	{
531	reset();
532	}
533
534	void nv::md5_loader::reset()
535	{
536	if ( m_nodes ) delete m_nodes;
537	for ( auto m : m_meshes ) { if (m) delete m; }
538	m_meshes.resize(0);
539	m_nodes = nullptr;
540	}
541

Note: See TracBrowser for help on using the repository browser.

Download in other formats: