Context Navigation

mesh.cpp @ 692

Revision 692, 19.2 KB checked in by mattausch, 19 years ago (diff)
adding ogre 1.2 and dependencies

Line
1	#include "mesh.h"
2
3	namespace OgreMayaExporter
4	{
5	/*** Class Mesh ***/
6	// constructor
7	Mesh::Mesh(const MString& name)
8	{
9	m_name = name;
10	m_numTriangles = 0;
11	m_pSkinCluster = NULL;
12	m_pSkeleton = NULL;
13	}
14
15	// destructor
16	Mesh::~Mesh()
17	{
18	clear();
19	}
20
21	// clear data
22	void Mesh::clear()
23	{
24	m_name = "";
25	m_numTriangles = 0;
26	for (int i=0; i<m_submeshes.size(); i++)
27	delete m_submeshes[i];
28	m_vertices.clear();
29	m_uvsets.clear();
30	m_submeshes.clear();
31	if (m_pSkinCluster)
32	delete m_pSkinCluster;
33	m_pSkinCluster = NULL;
34	if (m_pSkeleton)
35	delete m_pSkeleton;
36	m_pSkeleton = NULL;
37	}
38
39	// get pointer to linked skeleton
40	Skeleton* Mesh::getSkeleton()
41	{
42	return m_pSkeleton;
43	}
44
45	/*******************************************************************************
46	* Load mesh data from a maya Fn *
47	*******************************************************************************/
48	MStatus Mesh::load(MDagPath& meshDag,ParamList &params)
49	{
50	MStatus stat;
51	// check that given DagPath corresponds to a mesh node
52	if (!meshDag.hasFn(MFn::kMesh))
53	return MS::kFailure;
54
55	// get the mesh object
56	MFnMesh mesh(meshDag);
57	//initialise variables
58	std::vector<MFloatArray> weights;
59	std::vector<MIntArray> jointIds;
60	unsigned int numJoints = 0;
61	std::vector<vertexInfo> vertices;
62	MFloatPointArray points;
63	MFloatVectorArray normals;
64	vertices.resize(mesh.numVertices());
65	weights.resize(mesh.numVertices());
66	jointIds.resize(mesh.numVertices());
67	// get uv texture coordinate sets' names
68	MStringArray uvsets;
69	if (mesh.numUVSets() > 0)
70	{
71	stat = mesh.getUVSetNames(uvsets);
72	if (MS::kSuccess != stat)
73	{
74	std::cout << "Error retrieving UV sets names\n";
75	return MS::kFailure;
76	}
77	}
78	//Save uvsets info
79	for (int i=m_uvsets.size(); i<uvsets.length(); i++)
80	{
81	uvset uv;
82	uv.size = 2;
83	m_uvsets.push_back(uv);
84	}
85
86	// check the "opposite" attribute to see if we have to flip normals
87	bool opposite = false;
88	mesh.findPlug("opposite",true).getValue(opposite);
89
90	if (params.exportVBA \|\| params.exportSkeleton)
91	{
92	// get connected skin cluster (if present)
93	bool foundSkinCluster = false;
94	MItDependencyNodes kDepNodeIt( MFn::kSkinClusterFilter );
95	for( ;!kDepNodeIt.isDone() && !foundSkinCluster; kDepNodeIt.next())
96	{
97	MObject kObject = kDepNodeIt.item();
98	m_pSkinCluster = new MFnSkinCluster(kObject);
99	unsigned int uiNumGeometries = m_pSkinCluster->numOutputConnections();
100	for(unsigned int uiGeometry = 0; uiGeometry < uiNumGeometries; ++uiGeometry )
101	{
102	unsigned int uiIndex = m_pSkinCluster->indexForOutputConnection(uiGeometry);
103	MObject kOutputObject = m_pSkinCluster->outputShapeAtIndex(uiIndex);
104	if(kOutputObject == mesh.object())
105	{
106	std:: cout << "Found skin cluster " << m_pSkinCluster->name().asChar() << " for mesh "
107	<< mesh.name().asChar() << "\n";
108	foundSkinCluster = true;
109	}
110	else
111	{
112	delete m_pSkinCluster;
113	m_pSkinCluster = NULL;
114	}
115	}
116	}
117
118	// load connected skeleton (if present)
119	if (m_pSkinCluster)
120	{
121	std::cout << "Loading skeleton data...\n";
122	if (!m_pSkeleton)
123	m_pSkeleton = new Skeleton();
124	stat = m_pSkeleton->load(m_pSkinCluster,params);
125	if (MS::kSuccess != stat)
126	{
127	std::cout << "Error loading skeleton data\n";
128	}
129	else
130	std::cout << "OK\n";
131	}
132	}
133	// get connected shaders
134	MObjectArray shaders;
135	MIntArray shaderPolygonMapping;
136	stat = mesh.getConnectedShaders(0,shaders,shaderPolygonMapping);
137	if (MS::kSuccess != stat)
138	{
139	std::cout << "Error getting connected shaders\n";
140	return MS::kFailure;
141	}
142	std::cout << "Found " << shaders.length() << " connected shaders\n";
143	if (shaders.length() <= 0)
144	{
145	std::cout << "No connected shaders, skipping mesh\n";
146	return MS::kFailure;
147	}
148
149	// create a series of arrays of faces for each different submesh
150	std::vector<faceArray> polygonSets;
151	polygonSets.resize(shaders.length());
152
153	// Get faces data
154	// prepare vertex table
155	for (int i=0; i<vertices.size(); i++)
156	vertices[i].next = -2;
157	//get vertex positions from mesh data
158	if (params.exportWorldCoords)
159	mesh.getPoints(points,MSpace::kWorld);
160	else
161	mesh.getPoints(points,MSpace::kTransform);
162	//get list of normals from mesh data
163	if (params.exportWorldCoords)
164	mesh.getNormals(normals,MSpace::kWorld);
165	else
166	mesh.getNormals(normals,MSpace::kTransform);
167	//get list of vertex weights
168	if (m_pSkinCluster)
169	{
170	std::cout << "Get vbas\n";
171	MItGeometry iterGeom(meshDag);
172	for (i=0; !iterGeom.isDone(); iterGeom.next(), i++)
173	{
174	MObject component = iterGeom.component();
175	MFloatArray vertexWeights;
176	stat=m_pSkinCluster->getWeights(meshDag,component,vertexWeights,numJoints);
177	weights[i]=vertexWeights;
178	if (MS::kSuccess != stat)
179	{
180	std::cout << "Error retrieving vertex weights\n";
181	}
182	// get ids for the joints
183	if (m_pSkeleton)
184	{
185	MDagPathArray influenceObjs;
186	m_pSkinCluster->influenceObjects(influenceObjs,&stat);
187	if (MS::kSuccess != stat)
188	{
189	std::cout << "Error retrieving influence objects for given skin cluster\n";
190	}
191	jointIds[i].setLength(weights[i].length());
192	for (int j=0; j<influenceObjs.length(); j++)
193	{
194	bool foundJoint = false;
195	for (int k=0; k<m_pSkeleton->getJoints().size() && !foundJoint; k++)
196	{
197	if (influenceObjs[j].partialPathName() == m_pSkeleton->getJoints()[k].name)
198	{
199	foundJoint=true;
200	jointIds[i][j] = m_pSkeleton->getJoints()[k].id;
201	}
202	}
203	}
204	}
205	}
206	}
207	// create an iterator to go through mesh polygons
208	if (mesh.numPolygons() > 0)
209	{
210	std::cout << "Iterate over mesh polygons\n";
211	MItMeshPolygon faceIter(mesh.object(),&stat);
212	if (MS::kSuccess != stat)
213	{
214	std::cout << "Error accessing mesh polygons\n";
215	return MS::kFailure;
216	}
217	std::cout << "num polygons = " << mesh.numPolygons() << "\n";
218	// iterate over mesh polygons
219	for (; !faceIter.isDone(); faceIter.next())
220	{
221	int numTris=0;
222	faceIter.numTriangles(numTris);
223	// for every triangle composing current polygon extract triangle info
224	for (int iTris=0; iTris<numTris; iTris++)
225	{
226	MPointArray triPoints;
227	MIntArray tempTriVertexIdx,triVertexIdx;
228	int idx;
229	// create a new face to store triangle info
230	face newFace;
231	// extract triangle vertex indices
232	faceIter.getTriangle(iTris,triPoints,tempTriVertexIdx);
233	// convert indices to face-relative indices
234	MIntArray polyIndices;
235	faceIter.getVertices(polyIndices);
236	unsigned int iPoly, iObj;
237	for (iObj=0; iObj < tempTriVertexIdx.length(); ++iObj)
238	{
239	// iPoly is face-relative vertex index
240	for (iPoly=0; iPoly < polyIndices.length(); ++iPoly)
241	{
242	if (tempTriVertexIdx[iObj] == polyIndices[iPoly])
243	{
244	triVertexIdx.append(iPoly);
245	break;
246	}
247	}
248	}
249	// iterate over triangle's vertices
250	for (int i=0; i<3; i++)
251	{
252	bool different = true;
253	int vtxIdx = faceIter.vertexIndex(triVertexIdx[i]);
254	int nrmIdx = faceIter.normalIndex(triVertexIdx[i]);
255
256	// get vertex color
257	MColor color;
258	if (faceIter.hasColor(triVertexIdx[i]))
259	{
260	stat = faceIter.getColor(color,triVertexIdx[i]);
261	if (MS::kSuccess != stat)
262	{
263	color = MColor(1,1,1,1);
264	}
265	if (color.r > 1)
266	color.r = 1;
267	if (color.g > 1)
268	color.g = 1;
269	if (color.b > 1)
270	color.b = 1;
271	if (color.a > 1)
272	color.a = 1;
273	}
274	else
275	{
276	color = MColor(1,1,1,1);
277	}
278	if (vertices[vtxIdx].next == -2) // first time we encounter a vertex in this position
279	{
280	// save vertex position
281	points[vtxIdx].cartesianize();
282	vertices[vtxIdx].pointIdx = vtxIdx;
283	// save vertex normal
284	vertices[vtxIdx].normalIdx = nrmIdx;
285	// save vertex colour
286	vertices[vtxIdx].r = color.r;
287	vertices[vtxIdx].g = color.g;
288	vertices[vtxIdx].b = color.b;
289	vertices[vtxIdx].a = color.a;
290	// save vertex texture coordinates
291	vertices[vtxIdx].u.resize(uvsets.length());
292	vertices[vtxIdx].v.resize(uvsets.length());
293	// save vbas
294	vertices[vtxIdx].vba.resize(weights[vtxIdx].length());
295	for (int j=0; j<weights[vtxIdx].length(); j++)
296	{
297	vertices[vtxIdx].vba[j] = (weights[vtxIdx])[j];
298	}
299	// save joint ids
300	vertices[vtxIdx].jointIds.resize(jointIds[vtxIdx].length());
301	for (int j=0; j<jointIds[vtxIdx].length(); j++)
302	{
303	vertices[vtxIdx].jointIds[j] = (jointIds[vtxIdx])[j];
304	}
305	// save uv sets data
306	for (int j=0; j<uvsets.length(); j++)
307	{
308	float2 uv;
309	stat = faceIter.getUV(triVertexIdx[i],uv,&uvsets[j]);
310	if (MS::kSuccess != stat)
311	{
312	uv[0] = 0;
313	uv[1] = 0;
314	}
315	vertices[vtxIdx].u[j] = uv[0];
316	vertices[vtxIdx].v[j] = (-1)*(uv[1]-1);
317	}
318	// save vertex index in face info
319	newFace.v[i] = m_vertices.size() + vtxIdx;
320	// update value of index to next vertex info (-1 means nothing next)
321	vertices[vtxIdx].next = -1;
322	}
323	else // already found at least 1 vertex in this position
324	{
325	// check if a vertex with same attributes has been saved already
326	for (int k=vtxIdx; k!=-1 && different; k=vertices[k].next)
327	{
328	different = false;
329
330	if (params.exportVertNorm)
331	{
332	MFloatVector n1 = normals[vertices[k].normalIdx];
333	MFloatVector n2 = normals[nrmIdx];
334	if (n1.x!=n2.x \|\| n1.y!=n2.y \|\| n1.z!=n2.z)
335	{
336	different = true;
337	}
338	}
339
340	if ((params.exportVertCol) &&
341	(vertices[k].r!=color.r \|\| vertices[k].g!=color.g \|\| vertices[k].b!= color.b \|\| vertices[k].a!=color.a))
342	{
343	different = true;
344	}
345
346	if (params.exportTexCoord)
347	{
348	for (int j=0; j<uvsets.length(); j++)
349	{
350	float2 uv;
351	stat = faceIter.getUV(triVertexIdx[i],uv,&uvsets[j]);
352	if (MS::kSuccess != stat)
353	{
354	uv[0] = 0;
355	uv[1] = 0;
356	}
357	uv[1] = (-1)*(uv[1]-1);
358	if (vertices[k].u[j]!=uv[0] \|\| vertices[k].v[j]!=uv[1])
359	{
360	different = true;
361	}
362	}
363	}
364	idx = k;
365	}
366	// if no identical vertex has been saved, then save the vertex info
367	if (different)
368	{
369	vertexInfo vtx;
370	// save vertex position
371	vtx.pointIdx = vtxIdx;
372	// save vertex normal
373	vtx.normalIdx = nrmIdx;
374	// save vertex colour
375	vtx.r = color.r;
376	vtx.g = color.g;
377	vtx.b = color.b;
378	vtx.a = color.a;
379	// save vertex vba
380	vtx.vba.resize(weights[vtxIdx].length());
381	for (int j=0; j<weights[vtxIdx].length(); j++)
382	{
383	vtx.vba[j] = (weights[vtxIdx])[j];
384	}
385	// save joint ids
386	vtx.jointIds.resize(jointIds[vtxIdx].length());
387	for (j=0; j<jointIds[vtxIdx].length(); j++)
388	{
389	vtx.jointIds[j] = (jointIds[vtxIdx])[j];
390	}
391	// save vertex texture coordinates
392	vtx.u.resize(uvsets.length());
393	vtx.v.resize(uvsets.length());
394	for (j=0; j<uvsets.length(); j++)
395	{
396	float2 uv;
397	stat = faceIter.getUV(triVertexIdx[i],uv,&uvsets[j]);
398	if (MS::kSuccess != stat)
399	{
400	uv[0] = 0;
401	uv[1] = 0;
402	}
403	vtx.u[j] = uv[0];
404	vtx.v[j] = (-1)*(uv[1]-1);
405	}
406	vtx.next = -1;
407	vertices.push_back(vtx);
408	// save vertex index in face info
409	newFace.v[i] = m_vertices.size() + vertices.size()-1;
410	vertices[idx].next = vertices.size()-1;
411	}
412	else
413	{
414	newFace.v[i] = m_vertices.size() + idx;
415	}
416	}
417	} // end iteration of triangle vertices
418	// add face info to the array corresponding to the submesh it belongs
419	// skip faces with no shaders assigned
420	if (shaderPolygonMapping[faceIter.index()] >= 0)
421	polygonSets[shaderPolygonMapping[faceIter.index()]].push_back(newFace);
422	} // end iteration of triangles
423	}
424	}
425	std::cout << "done reading mesh triangles\n";
426
427	// if we are using shared geometry, then create a list of vertices for the whole mesh
428	if (params.useSharedGeom)
429	{
430	std::cout << "Create list of shared vertices\n";
431	for (i=0; i<vertices.size(); i++)
432	{
433	vertex v;
434	vertexInfo vInfo = vertices[i];
435	// save vertex coordinates
436	v.x = points[vInfo.pointIdx].x;
437	v.y = points[vInfo.pointIdx].y;
438	v.z = points[vInfo.pointIdx].z;
439	// save vertex normal
440	if (opposite)
441	{
442	v.n.x = -normals[vInfo.normalIdx].x;
443	v.n.y = -normals[vInfo.normalIdx].y;
444	v.n.z = -normals[vInfo.normalIdx].z;
445	}
446	else
447	{
448	v.n.x = normals[vInfo.normalIdx].x;
449	v.n.y = normals[vInfo.normalIdx].y;
450	v.n.z = normals[vInfo.normalIdx].z;
451	}
452	v.n.normalize();
453	// save vertex color
454	v.r = vInfo.r;
455	v.g = vInfo.g;
456	v.b = vInfo.b;
457	v.a = vInfo.a;
458	// save vertex bone assignements
459	for (int k=0; k<vInfo.vba.size(); k++)
460	{
461	vba newVba;
462	newVba.jointIdx = vInfo.jointIds[k];
463	newVba.weight = vInfo.vba[k];
464	v.vbas.push_back(newVba);
465	}
466	// save texture coordinates
467	for (k=0; k<vInfo.u.size(); k++)
468	{
469	texcoords newTexCoords;
470	newTexCoords.u = vInfo.u[k];
471	newTexCoords.v = vInfo.v[k];
472	newTexCoords.w = 0;
473	v.texcoords.push_back(newTexCoords);
474	}
475	// add newly created vertex to vertices list
476	m_vertices.push_back(v);
477	}
478	std::cout << "done creating vertices list\n";
479	}
480
481	// create a submesh for every different shader linked to the mesh
482	for (i=0; i<shaders.length(); i++)
483	{
484	// check if the submesh has at least 1 triangle
485	if (polygonSets[i].size() > 0)
486	{
487	//create new submesh
488	Submesh* pSubmesh = new Submesh();
489
490	//load linked shader
491	stat = pSubmesh->loadMaterial(shaders[i],uvsets,params);
492	if (stat != MS::kSuccess)
493	{
494	MFnDependencyNode shadingGroup(shaders[i]);
495	std::cout << "Error loading submesh linked to shader " << shadingGroup.name().asChar() << "\n";
496	return MS::kFailure;
497	}
498
499	//load vertex and face data
500	stat = pSubmesh->load(polygonSets[i],vertices,points,normals,uvsets,params,opposite);
501
502	//add submesh to current mesh
503	m_submeshes.push_back(pSubmesh);
504	//update number of triangles composing the mesh
505	m_numTriangles += pSubmesh->numTriangles();
506	}
507	}
508
509	return MS::kSuccess;
510	}
511
512
513	// Write mesh data to Ogre XML
514	MStatus Mesh::writeXML(ParamList &params)
515	{
516	MStatus stat;
517	// start mesh description
518	params.outMesh << "<mesh>\n";
519	// write shared geometry (if used)
520	if (params.useSharedGeom)
521	{
522	params.outMesh << "\t<sharedgeometry vertexcount=\"" << m_vertices.size() << "\">\n";
523	params.outMesh << "\t\t<vertexbuffer positions=\"true\" normals=";
524	if (params.exportVertNorm)
525	params.outMesh << "\"true\"";
526	else
527	params.outMesh << "\"false\"";
528	params.outMesh << " colours_diffuse=";
529	if (params.exportVertCol)
530	params.outMesh << "\"true\"";
531	else
532	params.outMesh << "\"false\"";
533	params.outMesh << " colours_specular=\"false\" texture_coords=\"";
534	if (params.exportTexCoord)
535	params.outMesh << m_uvsets.size() << "\">\n";
536	else
537	params.outMesh << 0 << "\">\n";
538	// write vertex data
539	for (int i=0; i < m_vertices.size(); i++)
540	{
541	params.outMesh << "\t\t\t<vertex>\n";
542	//write vertex position
543	params.outMesh << "\t\t\t\t<position x=\"" << m_vertices[i].x << "\" y=\""
544	<< m_vertices[i].y << "\" " << "z=\"" << m_vertices[i].z << "\"/>\n";
545	//write vertex normal
546	if (params.exportVertNorm)
547	{
548	params.outMesh << "\t\t\t\t<normal x=\"" << m_vertices[i].n.x << "\" y=\""
549	<< m_vertices[i].n.y << "\" " << "z=\"" << m_vertices[i].n.z << "\"/>\n";
550	}
551	//write vertex colour
552	if (params.exportVertCol)
553	{
554	float r,g,b,a;
555	if (params.exportVertColWhite)
556	{
557	r = g = b = a = 1.0f;
558	}
559	else
560	{
561	r = m_vertices[i].r;
562	g = m_vertices[i].g;
563	b = m_vertices[i].b;
564	a = m_vertices[i].a;
565	}
566
567	params.outMesh << "\t\t\t\t<colour_diffuse value=\"" << r << " " << g
568	<< " " << b << " " << a << "\"/>\n";
569	}//write vertex texture coordinates
570	if (params.exportTexCoord)
571	{
572	for (int j=0; j<m_uvsets.size(); j++)
573	{
574	if (j < m_vertices[i].texcoords.size())
575	{
576	params.outMesh << "\t\t\t\t<texcoord u=\"" << m_vertices[i].texcoords[j].u << "\" v=\"" <<
577	m_vertices[i].texcoords[j].v << "\"/>\n";
578	}
579	else
580	{
581	params.outMesh << "\t\t\t\t<texcoord u=\"0\" v=\"0\"/>\n";
582	}
583	}
584	}
585	params.outMesh << "\t\t\t</vertex>\n";
586	}
587	params.outMesh << "\t\t</vertexbuffer>\n";
588	params.outMesh << "\t</sharedgeometry>\n";
589	}
590	// write submeshes data
591	params.outMesh << "\t<submeshes>\n";
592	for (int i=0; i < m_submeshes.size(); i++)
593	{
594	stat = m_submeshes[i]->writeXML(params);
595	if (MS::kSuccess != stat)
596	{
597	std::cout << "Error writing submesh " << m_submeshes[i]->name().asChar() << ", aborting operation\n";
598	return MS::kFailure;
599	}
600	}
601	params.outMesh << "\t</submeshes>\n";
602	// write skeleton link
603	if (params.exportSkeleton && m_pSkeleton)
604	{
605	int ri = params.skeletonFilename.rindex('\\');
606	int end = params.skeletonFilename.length() - 1;
607	MString filename = params.skeletonFilename.substring(ri+1,end);
608	if (filename.substring(filename.length()-4,filename.length()-1) == MString(".xml")
609	&& filename.length() >= 5)
610	filename = filename.substring(0,filename.length()-5);
611	params.outMesh << "\t<skeletonlink name=\"" << filename.asChar() << "\"/>\n";
612	}
613	// Write shared geometry bone assignments
614	if (params.useSharedGeom && params.exportVBA)
615	{
616	params.outMesh << "\t<boneassignments>\n";
617	for (int i=0; i<m_vertices.size(); i++)
618	{
619	for (int j=0; j<m_vertices[i].vbas.size(); j++)
620	{
621	if (m_vertices[i].vbas[j].weight > 0.001)
622	{
623	params.outMesh << "\t\t<vertexboneassignment vertexindex=\"" << i
624	<< "\" boneindex=\"" << m_vertices[i].vbas[j].jointIdx << "\" weight=\""
625	<< m_vertices[i].vbas[j].weight <<"\"/>\n";
626	}
627	}
628	}
629	params.outMesh << "\t</boneassignments>\n";
630	}
631	// write submesh names
632	params.outMesh << "\t<submeshnames>\n";
633	for (i=0; i<m_submeshes.size(); i++)
634	{
635	if (m_submeshes[i]->name() != "")
636	params.outMesh << "\t\t<submeshname name=\"" << m_submeshes[i]->name().asChar() << "\" index=\"" << i << "\"/>\n";
637	}
638	params.outMesh << "\t</submeshnames>\n";
639	// end mesh description
640	params.outMesh << "</mesh>\n";
641
642	return MS::kSuccess;
643	}
644
645	}; //end of namespace

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

Context Navigation

source: OGRE/trunk/ogrenew/Tools/MayaExport/src/mesh.cpp @ 692

Download in other formats: