Context Navigation

MeshExploder.cpp @ 2304

Revision 2304, 18.8 KB checked in by szirmay, 18 years ago (diff)

Line
1	#include "dxstdafx.h"
2	#include ".\meshexploder.h"
3	#include "TriangleMesh.h"
4	#include "Vector.hpp"
5	#include "L.h"
6	#include <vector>
7	#include <fstream>
8	#include "xmlwriter.h"
9	#include "FlexVertex.h"
10
11	using namespace xmlw;
12
13	MeshExploder::MeshExploder(LPDIRECT3DDEVICE9 device, LPD3DXMESH originalMesh, D3DXMATERIAL* originalMaterials, wchar_t** materialNames, D3DXEFFECTINSTANCE* originalShaders, unsigned int nPieces)
14	{
15	this->device = device;
16	this->originalMesh = originalMesh;
17	this->originalMaterials = originalMaterials;
18	this->originalShaders = originalShaders;
19	this->nPieces = nPieces;
20
21	this->materialNames = materialNames;
22
23	fragmentMeshes = NULL;
24	fragmentAttribIndices = NULL;
25	composedMaterials = NULL;
26	composedShaders = NULL;
27	composedMaterialNames = NULL;
28	}
29
30	MeshExploder::~MeshExploder(void)
31	{
32	if(fragmentMeshes)
33	{
34	for(int f=0; f<nPieces; f++)
35	{
36	fragmentMeshes[f]->Release();
37	}
38	delete [] fragmentMeshes;
39	}
40	if(fragmentAttribIndices)
41	delete [] fragmentAttribIndices;
42
43	//we need these as output
44	/* if(composedMaterials)
45	delete [] composedMaterials;
46	if(composedShaders)
47	delete [] composedShaders;*/
48
49	if(composedMaterialNames)
50	delete [] composedMaterialNames;
51	}
52
53	struct Tri
54	{
55	unsigned short origMeshIndex;
56	Vector pos;
57	Vector normal;
58	};
59
60	void MeshExploder::explode()
61	{
62	fragmentMeshes = new LPD3DXMESH[nPieces];
63	fragmentAttribIndices = new DWORD[nPieces];
64
65	originalMesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);
66
67	LPDIRECT3DVERTEXBUFFER9 vertexBuffer;
68	originalMesh->GetVertexBuffer(&vertexBuffer);
69
70	FlexVertexArray vertexData(originalMesh->GetNumBytesPerVertex());
71	D3DVERTEXELEMENT9 elem[64]; originalMesh->GetDeclaration(elem); vertexData.setFormat(elem);
72	vertexBuffer->Lock(0,originalMesh->GetNumVertices()*originalMesh->GetNumBytesPerVertex(),vertexData.getDataPointerReference(),0);
73
74	LPDIRECT3DINDEXBUFFER9 indexBuffer;
75	originalMesh->GetIndexBuffer(&indexBuffer);
76
77	DWORD nSubsets;
78	originalMesh->GetAttributeTable(NULL, &nSubsets);
79	D3DXATTRIBUTERANGE* subsetRanges = new D3DXATTRIBUTERANGE[nSubsets];
80	originalMesh->GetAttributeTable(subsetRanges, &nSubsets);
81
82	unsigned int piecesToGo = nPieces;
83	unsigned int facesToGo = originalMesh->GetNumFaces();
84	int iPiece=0;
85
86	for(int iSubset=0; iSubset<nSubsets; iSubset++)
87	{
88
89	unsigned int nTris = subsetRanges[iSubset].FaceCount;
90
91	unsigned int pcsPerSubset = piecesToGo * nTris / facesToGo;
92	while(piecesToGo - pcsPerSubset < nSubsets - 1 - iSubset )
93	pcsPerSubset--;
94	if(pcsPerSubset < 1)
95	pcsPerSubset = 1;
96	piecesToGo -= pcsPerSubset;
97	facesToGo -= nTris;
98
99	unsigned short* indexData;
100	indexBuffer->Lock(subsetRanges[iSubset].FaceStart3sizeof(unsigned short),
101	nTris3sizeof(unsigned short),
102	(void**)&indexData,0);
103
104	Tri* tris = new Tri[nTris];
105	//partition to small meshes
106	for(int g=0; g<nTris; g++)
107	{
108	tris[g].origMeshIndex = g;
109	tris[g].pos = (vertexData[indexData[g * 3]].pos() +
110	vertexData[indexData[g * 3 + 1]].pos() +
111	vertexData[indexData[g * 3 + 2]].pos()) * 0.33333333333333;
112	tris[g].normal = (vertexData[indexData[g * 3]].normal() +
113	vertexData[indexData[g * 3 + 1]].normal() +
114	vertexData[indexData[g * 3 + 2]].normal());
115	tris[g].normal.normalize();
116	}
117
118	int* slabNTris = new int[pcsPerSubset];
119	clusterTrisKMeans(tris, nTris, pcsPerSubset, slabNTris);
120	int triClusterStart = 0;
121
122	for(int ict=0; ict<pcsPerSubset; ict++)
123	{
124	// count vertices
125	unsigned short* ill = new unsigned short[originalMesh->GetNumVertices()];
126	for(int zzz=0; zzz<originalMesh->GetNumVertices(); zzz++)
127	ill[zzz] = 0;
128	for(int rmi = triClusterStart; rmi<triClusterStart + slabNTris[ict]; rmi++)
129	{
130	ill[indexData[tris[rmi].origMeshIndex*3]] = 1;
131	ill[indexData[tris[rmi].origMeshIndex*3+1]] = 1;
132	ill[indexData[tris[rmi].origMeshIndex*3+2]] = 1;
133	}
134
135	int nVertices = 0;
136	for(int ccc=0; ccc<originalMesh->GetNumVertices(); ccc++)
137	if(ill[ccc])
138	nVertices++;
139
140	LPD3DXMESH fragMesh;
141	// create new mesh
142	HRESULT dhre = D3DXCreateMeshFVF(
143	slabNTris[ict],
144	nVertices,
145	0,
146	originalMesh->GetFVF(),
147	device,
148	&fragMesh);
149	// fill with tris
150	LPDIRECT3DVERTEXBUFFER9 svertexBuffer;
151	fragMesh->GetVertexBuffer(&svertexBuffer);
152	FlexVertexArray svertexData(fragMesh->GetNumBytesPerVertex());
153	svertexBuffer->Lock(0, nVertices * fragMesh->GetNumBytesPerVertex(),svertexData.getDataPointerReference(),0);
154	LPDIRECT3DINDEXBUFFER9 sindexBuffer;
155	fragMesh->GetIndexBuffer(&sindexBuffer);
156	unsigned short* sindexData;
157	sindexBuffer->Lock(0,slabNTris[ict]3sizeof(unsigned short),(void**)&sindexData,0);
158
159	int ufi = 0;
160	for(int ifi=0; ifi<originalMesh->GetNumVertices(); ifi++)
161	if(ill[ifi])
162	{
163	//svertexData[ufi] = vertexData[ifi];
164	svertexData.assign(ufi, vertexData[ifi]);
165	ill[ifi] = ufi;
166	ufi++;
167	}
168	else
169	ill[ifi] = 0xffff;
170
171	for(int trifi=0; trifi<slabNTris[ict]; trifi++)
172	{
173	sindexData[trifi3] = ill[indexData[tris[trifi+triClusterStart].origMeshIndex3]];
174	sindexData[trifi3+1] = ill[indexData[tris[trifi+triClusterStart].origMeshIndex3+1]];
175	sindexData[trifi3+2] = ill[indexData[tris[trifi+triClusterStart].origMeshIndex3+2]];
176	}
177
178	svertexBuffer->Unlock();
179	sindexBuffer->Unlock();
180	svertexBuffer->Release();
181	sindexBuffer->Release();
182
183	triClusterStart += slabNTris[ict];
184
185	fragmentMeshes[iPiece] = fragMesh;
186	fragmentAttribIndices[iPiece] = iSubset;
187	iPiece++;
188	}
189
190	indexBuffer->Unlock();
191	}
192
193	vertexBuffer->Unlock();
194	vertexBuffer->Release();
195	indexBuffer->Release();
196
197	delete subsetRanges;
198	}
199
200
201	void MeshExploder::clusterTrisKMeans(Tri* triArray, int nTris, int nClusters, int* clusterLenghts)
202	{
203	Tri* centroids = new Tri[nClusters];
204	std::vector<Tri>* result = new std::vector<Tri>[nClusters];
205
206	//initial clusters: uniform length
207	for(unsigned int i=0; i<nClusters; i++)
208	clusterLenghts[i] = nTris / nClusters;
209	clusterLenghts[nClusters - 1] = nTris - (nClusters - 1) * (nTris / nClusters);
210	for(unsigned int iKMeans = 0; iKMeans < 128; iKMeans++)
211	{
212	//find centroids
213	unsigned int iTri = 0;
214	for(unsigned int i=0; i<nClusters; i++)
215	{
216	centroids[i].pos = Vector::RGBBLACK;
217	centroids[i].normal = Vector::RGBBLACK;
218	for(unsigned int iTriInCluster=0; iTriInCluster < clusterLenghts[i]; iTriInCluster++, iTri++)
219	{
220	centroids[i].pos += triArray[iTri].pos;
221	centroids[i].normal += triArray[iTri].normal;
222	}
223	centroids[i].pos *= 1.0f / (float)clusterLenghts[i];
224	centroids[i].normal.normalize();
225	}
226
227	for(unsigned int i=0; i<nClusters; i++)
228	result[i].clear();
229
230	//sort radions to centroids
231	iTri = 0;
232	for(unsigned int i=0; i<nClusters; i++)
233	{
234	for(unsigned int iTriInCluster=0; iTriInCluster < clusterLenghts[i]; iTriInCluster++, iTri++)
235	{
236	unsigned int minimumDistanceClusterIndex = 0;
237	float minimumDistance = FLT_MAX;
238	for(unsigned int u=0; u<nClusters; u++)
239	{
240	float dirDist = (triArray[iTri].normal * centroids[u].normal);
241	float dist = (triArray[iTri].pos - centroids[u].pos).norm() * pow(2.0, 1.0 - (double)dirDist);
242	if(dist < minimumDistance)
243	{
244	minimumDistanceClusterIndex = u;
245	minimumDistance = dist;
246	}
247	}
248	result[minimumDistanceClusterIndex].push_back( triArray[iTri] );
249	}
250	}
251	//refill bushStarters, set cluster lengths
252	iTri = 0;
253	for(unsigned int i=0; i<nClusters; i++)
254	{
255	clusterLenghts[i] = result[i].size();
256	for(unsigned int iTriInCluster=0; iTriInCluster < clusterLenghts[i]; iTriInCluster++, iTri++)
257	{
258	triArray[iTri] = result[i].at(iTriInCluster);
259	}
260	}
261	//eliminate empty clusters
262	for(unsigned int i=1; i<nClusters; i++)
263	{
264	if(clusterLenghts[i] == 0)
265	{
266	clusterLenghts[i] = clusterLenghts[i-1] >> 1;
267	clusterLenghts[i-1] -= clusterLenghts[i-1] >> 1;
268	}
269	}
270	for(int i=nClusters - 1; i >= 0; i--)
271	{
272	if(clusterLenghts[i] == 0)
273	{
274	clusterLenghts[i] = clusterLenghts[i+1] >> 1;
275	clusterLenghts[i+1] -= clusterLenghts[i+1] >> 1;
276	}
277	}
278	}
279	delete [] centroids;
280	delete [] result;
281	}
282
283	void MeshExploder::saveFragMeshes()
284	{
285	for(int i=0; i<nPieces; i++)
286	{
287	char sname[256];
288	sprintf(sname, "media/explode_fragment%d.x", i);
289	HRESULT hr = D3DXSaveMeshToX(L::l+sname, //LPCTSTR pFilename,
290	fragmentMeshes[i], //LPD3DXMESH pMesh,
291	NULL, //CONST DWORD * pAdjacency,
292	NULL, //CONST D3DXMATERIAL * pMaterials,
293	NULL, //CONST D3DXEFFECTINSTANCE * pEffectInstances,
294	0, //DWORD NumMaterials,
295	D3DXF_FILEFORMAT_TEXT //DWORD Format
296	);
297	}
298	}
299
300	void MeshExploder::generateAtlas(int atlasSize)
301	{
302	for(int i=0; i<nPieces; i++)
303	{
304
305	LPD3DXMESH tempMesh;
306
307	float maxStretchApplied;
308	unsigned int nCharts;
309
310	unsigned int atlasIndex = (originalMesh->GetFVF() & D3DFVF_TEXCOUNT_MASK) / D3DFVF_TEX1 - 1;
311
312	HRESULT hr =
313	D3DXUVAtlasCreate(
314	fragmentMeshes[i], // LPD3DXMESH pMesh,
315	0, // UINT dwMaxChartNumber,
316	1.0f, // FLOAT fMaxStretch,
317	atlasSize - 4, // UINT dwWidth,
318	atlasSize - 4, // UINT dwHeight,
319	2.0f, // FLOAT fGutter,
320	atlasIndex, // DWORD dwTextureIndex,
321	NULL, // CONST DWORD * pdwAdjacency,
322	NULL, // CONST CHAR * pcFalseEdges,
323	NULL, // FLOAT * pfIMTArray,
324	NULL, // LPD3DXUVATLASCB pCallback,
325	0.001f, // FLOAT fCallbackFrequency,
326	NULL, // LPVOID pUserContent,
327	0, // options
328	&tempMesh, // LPD3DXMESH * ppMeshOut,
329	NULL, // LPD3DXBUFFER * ppFacePartitioning,
330	NULL, // LPD3DXBUFFER * ppVertexRemapArray,
331	&maxStretchApplied, // FLOAT * pfMaxStretchOut,
332	&nCharts // UINT * pdwNumChartsOut
333	);
334
335	if(hr == S_OK)
336	{
337	//forget the old mesh
338	fragmentMeshes[i]->Release();
339	fragmentMeshes[i] = tempMesh;
340	}
341	else
342	{
343	MessageBoxA( NULL, "Sorry!", "Impossible to create UVatlas, please increase PRM resolution!", MB_OK);
344	}
345
346	LPDIRECT3DVERTEXBUFFER9 vertexBuffer;
347	fragmentMeshes[i]->GetVertexBuffer(&vertexBuffer);
348	FlexVertexArray vertexData(fragmentMeshes[i]->GetNumBytesPerVertex());
349	D3DVERTEXELEMENT9 elem[64]; fragmentMeshes[i]->GetDeclaration(elem); vertexData.setFormat(elem);
350	vertexBuffer->Lock(0,fragmentMeshes[i]->GetNumVertices()*fragmentMeshes[i]->GetNumBytesPerVertex(),vertexData.getDataPointerReference(),0);
351
352	for(unsigned int u=0; u < fragmentMeshes[i]->GetNumVertices(); u++ )
353	vertexData[u].tex(atlasIndex) = (vertexData[u].tex(atlasIndex) * (atlasSize - 4) + D3DXVECTOR2(2.0,2.0)) / (float)atlasSize;
354
355	vertexBuffer->Unlock();
356	vertexBuffer->Release();
357	}
358	}
359
360	void MeshExploder::merge()
361	{
362	int sumVertices=0;
363	int sumFaces=0;
364	for(int i=0; i<nPieces; i++)
365	{
366	sumVertices += fragmentMeshes[i]->GetNumVertices();
367	sumFaces += fragmentMeshes[i]->GetNumFaces();
368	}
369
370	composedMaterials = new D3DXMATERIAL[nPieces];
371	composedShaders = new D3DXEFFECTINSTANCE[nPieces];
372	composedMaterialNames = new wchar_t*[nPieces];
373
374	for(int t=0; t<nPieces; t++)
375	{
376	composedMaterials[t] = originalMaterials[fragmentAttribIndices[t]];
377	composedShaders[t] = originalShaders[fragmentAttribIndices[t]];
378	composedMaterialNames[t] = materialNames[fragmentAttribIndices[t]];
379	}
380
381	HRESULT dhre = D3DXCreateMeshFVF(
382	sumFaces,
383	sumVertices,
384	0,
385	originalMesh->GetFVF(),
386	device,
387	&composedMesh);
388
389	LPDIRECT3DVERTEXBUFFER9 composedVertexBuffer;
390	composedMesh->GetVertexBuffer(&composedVertexBuffer);
391	FlexVertexArray composedVertexData(composedMesh->GetNumBytesPerVertex());
392	D3DVERTEXELEMENT9 elem[64]; composedMesh->GetDeclaration(elem); composedVertexData.setFormat(elem);
393	composedVertexBuffer->Lock(0,composedMesh->GetNumVertices()*composedMesh->GetNumBytesPerVertex(),composedVertexData.getDataPointerReference(),0);
394
395	LPDIRECT3DINDEXBUFFER9 composedIndexBuffer;
396	composedMesh->GetIndexBuffer(&composedIndexBuffer);
397	unsigned short* composedIndexData;
398	composedIndexBuffer->Lock(0,
399	composedMesh->GetNumFaces()3sizeof(unsigned short),
400	(void**)&composedIndexData,0);
401
402	DWORD* composedAttributeData;
403	composedMesh->LockAttributeBuffer(0, &composedAttributeData);
404
405	int vertexOffset = 0;
406	int faceOffset = 0;
407
408	for(int f=0; f<nPieces; f++)
409	{
410	LPDIRECT3DVERTEXBUFFER9 fragmentVertexBuffer;
411	fragmentMeshes[f]->GetVertexBuffer(&fragmentVertexBuffer);
412	FlexVertexArray fragmentVertexData(fragmentMeshes[f]->GetNumBytesPerVertex());
413	fragmentVertexBuffer->Lock(0,fragmentMeshes[f]->GetNumVertices()*fragmentMeshes[f]->GetNumBytesPerVertex(),fragmentVertexData.getDataPointerReference(),0);
414
415	LPDIRECT3DINDEXBUFFER9 fragmentIndexBuffer;
416	fragmentMeshes[f]->GetIndexBuffer(&fragmentIndexBuffer);
417	unsigned short* fragmentIndexData;
418	fragmentIndexBuffer->Lock(0,
419	fragmentMeshes[f]->GetNumFaces()3sizeof(unsigned short),
420	(void**)&fragmentIndexData,0);
421
422	for(int iv=0; iv<fragmentMeshes[f]->GetNumVertices(); iv++)
423	composedVertexData.assign(iv + vertexOffset, fragmentVertexData[iv]);
424	//composedVertexData[iv + vertexOffset] = fragmentVertexData[iv];
425	for(int ic=0; ic<fragmentMeshes[f]->GetNumFaces(); ic++)
426	{
427	composedAttributeData[ic + faceOffset] = f;
428	composedIndexData[(ic + faceOffset) * 3] = fragmentIndexData[ic * 3] + vertexOffset;
429	composedIndexData[(ic + faceOffset) * 3 + 1] = fragmentIndexData[ic * 3 + 1] + vertexOffset;
430	composedIndexData[(ic + faceOffset) * 3 + 2] = fragmentIndexData[ic * 3 + 2] + vertexOffset;
431	}
432	fragmentVertexBuffer->Unlock();
433	fragmentVertexBuffer->Release();
434	fragmentIndexBuffer->Unlock();
435	fragmentIndexBuffer->Release();
436
437	vertexOffset += fragmentMeshes[f]->GetNumVertices();
438	faceOffset += fragmentMeshes[f]->GetNumFaces();
439	}
440
441	composedMesh->UnlockAttributeBuffer();
442
443	composedVertexBuffer->Unlock();
444	composedVertexBuffer->Release();
445	composedIndexBuffer->Unlock();
446	composedIndexBuffer->Release();
447	}
448
449	void MeshExploder::saveComposedMesh(LPCSTR name)
450	{
451	char sname[256];
452	sprintf(sname, "processedMeshes/%s.x", name);
453	HRESULT hr = D3DXSaveMeshToX(L::l+sname, //LPCTSTR pFilename,
454	composedMesh, //LPD3DXMESH pMesh,
455	NULL, //CONST DWORD * pAdjacency,
456	composedMaterials, //CONST D3DXMATERIAL * pMaterials,
457	composedShaders, //CONST D3DXEFFECTINSTANCE * pEffectInstances,
458	nPieces, //DWORD NumMaterials,
459	D3DXF_FILEFORMAT_TEXT //DWORD Format
460	);
461	}
462
463	void MeshExploder::saveComposedMeshToOgreXML(LPCSTR name)
464	{
465	char sname[256];
466	sprintf(sname, "processedMeshes/%s.mesh.xml", name);
467
468	std::ofstream f(sname);
469	XmlStream xml(f);
470
471	DWORD mfvf = composedMesh->GetFVF();
472	unsigned int nTexCoords = ( mfvf & D3DFVF_TEXCOUNT_MASK) / D3DFVF_TEX1;
473
474	xml << tag("mesh");
475	xml << tag("sharedgeometry")
476	<< attr("vertexcount") << composedMesh->GetNumVertices();
477
478	xml << tag("vertexbuffer");
479	if(mfvf & D3DFVF_XYZ)
480	xml << attr("positions") << "true";
481	else
482	xml << attr("positions") << "false";
483	if(mfvf & D3DFVF_NORMAL)
484	xml << attr("normals") << "true";
485	else
486	xml << attr("normals") << "false";
487	if(mfvf & D3DFVF_DIFFUSE)
488	xml << attr("colours_diffuse") << "true";
489	else
490	xml << attr("colours_diffuse") << "false";
491	if(mfvf & D3DFVF_SPECULAR)
492	xml << attr("colours_specular") << "true";
493	else
494	xml << attr("colours_specular") << "false";
495	xml << attr("texture_coords") << nTexCoords;
496
497	LPDIRECT3DVERTEXBUFFER9 composedVertexBuffer;
498	composedMesh->GetVertexBuffer(&composedVertexBuffer);
499	FlexVertexArray composedVertexData(composedMesh->GetNumBytesPerVertex());
500	D3DVERTEXELEMENT9 elem[64]; composedMesh->GetDeclaration(elem); composedVertexData.setFormat(elem);
501	composedVertexBuffer->Lock(0,composedMesh->GetNumVertices()*composedMesh->GetNumBytesPerVertex(),composedVertexData.getDataPointerReference(),0);
502
503	LPDIRECT3DINDEXBUFFER9 composedIndexBuffer;
504	composedMesh->GetIndexBuffer(&composedIndexBuffer);
505	unsigned short* composedIndexData;
506	composedIndexBuffer->Lock(0,
507	composedMesh->GetNumFaces()3sizeof(unsigned short),
508	(void**)&composedIndexData,0);
509
510	DWORD* composedAttributeData;
511	composedMesh->LockAttributeBuffer(0, &composedAttributeData);
512
513	for(int xvi = 0; xvi < composedMesh->GetNumVertices(); xvi++)
514	{
515	xml << tag("vertex");
516	if(mfvf & D3DFVF_XYZ)
517	{
518	xml << tag("position");
519	xml << attr("x") << composedVertexData[xvi].pos().x;
520	xml << attr("y") << composedVertexData[xvi].pos().y;
521	xml << attr("z") << composedVertexData[xvi].pos().z;
522	xml << endtag();
523	}
524	if(mfvf & D3DFVF_NORMAL)
525	{
526	xml << tag("normal");
527	xml << attr("x") << composedVertexData[xvi].normal().x;
528	xml << attr("y") << composedVertexData[xvi].normal().y;
529	xml << attr("z") << composedVertexData[xvi].normal().z;
530	xml << endtag();
531	}
532	if(mfvf & D3DFVF_DIFFUSE)
533	{
534	char colval[256];
535	D3DCOLOR dc = composedVertexData[xvi].diffuse();
536	unsigned char* pdc = (unsigned char*)&dc;
537	sprintf(colval, "%f %f %f %f",
538	pdc[3],
539	pdc[0],
540	pdc[1],
541	pdc[2]
542	);
543	xml << tag("colours_diffuse");
544	xml << attr("value") << colval;
545	xml << endtag();
546	}
547	if(mfvf & D3DFVF_SPECULAR)
548	{
549	char colval[256];
550	D3DCOLOR dc = composedVertexData[xvi].specular();
551	unsigned char* pdc = (unsigned char*)&dc;
552	sprintf(colval, "%f %f %f %f",
553	pdc[3],
554	pdc[0],
555	pdc[1],
556	pdc[2]
557	);
558	xml << tag("colours_specular");
559	xml << attr("value") << colval;
560	xml << endtag();
561	}
562	for(int taxi=0; taxi<nTexCoords; taxi++)
563	{
564	xml << tag("texcoord");
565	xml << attr("u") << composedVertexData[xvi].tex(taxi).x;
566	xml << attr("v") << composedVertexData[xvi].tex(taxi).y;
567	xml << endtag();
568	}
569
570	xml << endtag();
571	}
572
573	xml << endtag(); // end vertexbuffer
574	xml << endtag(); // end sharedgeometry
575
576	xml << tag("submeshes");
577	int faceOffset = 0;
578	for(int xai = 0; xai < nPieces; xai++)
579	{
580	xml << tag("submesh")
581	<< attr("material") << LC::c-composedMaterialNames[xai]
582	<< attr("use32bitindexes") << "true"
583	<< attr("usesharedvertices") << "true"
584	<< attr("operationtype") << "triangle_list";
585
586	xml << tag("faces")
587	<< attr("count") << fragmentMeshes[xai]->GetNumFaces();
588	for(int ic = 0; ic < fragmentMeshes[xai]->GetNumFaces(); ic++)
589	{
590	xml << tag("face")
591	<< attr("v1") << composedIndexData[(ic + faceOffset) * 3]
592	<< attr("v2") << composedIndexData[(ic + faceOffset) * 3 + 1]
593	<< attr("v3") << composedIndexData[(ic + faceOffset) * 3 + 2];
594	xml << endtag();
595	}
596	faceOffset += fragmentMeshes[xai]->GetNumFaces();
597	xml << endtag();
598	xml << endtag();
599	}
600	xml << endtag(); // submeshes
601	xml << tag("submeshnames");
602	xml << endtag();
603
604	composedMesh->UnlockAttributeBuffer();
605
606	composedVertexBuffer->Unlock();
607	composedVertexBuffer->Release();
608	composedIndexBuffer->Unlock();
609	composedIndexBuffer->Release();
610	}

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

Context Navigation

source: GTP/trunk/App/Demos/Illum/pathmap/MeshExploder.cpp @ 2304

Download in other formats: