Context Navigation

source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMesh.cpp @ 2083

Revision 2083, 17.7 KB checked in by gumbau, 17 years ago (diff)

Line
1	#include "GeoMesh.h"
2
3	using namespace Geometry;
4	using namespace std;
5
6	//-------------------------------------------------------------------------
7	// Cosntructor.
8	//-------------------------------------------------------------------------
9	Mesh::Mesh():
10	mVertexBuffer(0), mSubMeshCount(0), mSubMesh(0), hasSkeleton(false)
11	{
12	mMeshBounds.maxX = 0.0;
13	mMeshBounds.maxY = 0.0;
14	mMeshBounds.maxZ = 0.0;
15	mMeshBounds.minX = 0.0;
16	mMeshBounds.minY = 0.0;
17	mMeshBounds.minZ = 0.0;
18	mMeshBounds.scaleFactor = 0.0;
19	}
20
21	//-------------------------------------------------------------------------
22	// Destroyer.
23	//-------------------------------------------------------------------------
24	Mesh::~Mesh()
25	{
26	delete [] mSubMesh;
27	delete mVertexBuffer;
28	}
29
30	//-------------------------------------------------------------------------
31	// Copy constructor.
32	//-------------------------------------------------------------------------
33	Mesh::Mesh(const Mesh &mesh)
34	{
35	mVertexBuffer = new VertexBuffer();
36	mSubMeshCount = mesh.mSubMeshCount;
37	mSubMesh = new SubMesh[mesh.mSubMeshCount];
38
39	// Fill up bounding box settings.
40	mMeshBounds.maxX = mesh.mMeshBounds.maxX;
41	mMeshBounds.maxY = mesh.mMeshBounds.maxY;
42	mMeshBounds.maxZ = mesh.mMeshBounds.maxZ;
43	mMeshBounds.minX = mesh.mMeshBounds.minX;
44	mMeshBounds.minY = mesh.mMeshBounds.minY;
45	mMeshBounds.minZ = mesh.mMeshBounds.minZ;
46	mMeshBounds.radius = mesh.mMeshBounds.radius;
47	mMeshBounds.scaleFactor = mesh.mMeshBounds.scaleFactor;
48
49	// For each submesh.
50	for (size_t i = 0; i < mesh.mSubMeshCount; i++)
51	{
52	mSubMesh[i].mSharedVertexBuffer = false;
53	mSubMesh[i].mVertexBuffer = new VertexBuffer();
54	mSubMesh[i].mVertexBuffer->mPosition = new Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
55	mSubMesh[i].mVertexBuffer->mNormal = new Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
56	mSubMesh[i].mVertexBuffer->mTexCoords = new Vector2[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
57	mSubMesh[i].mVertexBuffer->mVertexCount = mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
58	mSubMesh[i].mVertexBuffer->mVertexInfo = mesh.mSubMesh[i].mVertexBuffer->mVertexInfo;
59	mSubMesh[i].mType = mesh.mSubMesh[i].mType;
60
61	strcpy(mSubMesh[i].mMaterialName,mesh.mSubMesh[i].mMaterialName);
62
63	if (mesh.mSubMesh[i].mSharedVertexBuffer)
64	{
65	for (size_t s = 0;
66	s < mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
67	s++)
68	{
69	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_POSITION)
70	{
71	mSubMesh[i].mVertexBuffer->mPosition[s].x = mesh.mVertexBuffer->mPosition[s].x;
72	mSubMesh[i].mVertexBuffer->mPosition[s].y = mesh.mVertexBuffer->mPosition[s].y;
73	mSubMesh[i].mVertexBuffer->mPosition[s].z = mesh.mVertexBuffer->mPosition[s].z;
74	}
75
76	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_NORMAL)
77	{
78	mSubMesh[i].mVertexBuffer->mNormal[s].x = mesh.mVertexBuffer->mNormal[s].x;
79	mSubMesh[i].mVertexBuffer->mNormal[s].y = mesh.mVertexBuffer->mNormal[s].y;
80	mSubMesh[i].mVertexBuffer->mNormal[s].z = mesh.mVertexBuffer->mNormal[s].z;
81	}
82
83	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_TEXCOORDS)
84	{
85	mSubMesh[i].mVertexBuffer->mTexCoords[s].x = mesh.mVertexBuffer->mTexCoords[s].x;
86	mSubMesh[i].mVertexBuffer->mTexCoords[s].y = mesh.mVertexBuffer->mTexCoords[s].y;
87	}
88	}
89
90	mesh.mSubMesh[i].mSharedVertexBuffer = false;
91	}
92	else
93	{
94	for (size_t s = 0; s < mesh.mSubMesh[i].mVertexBuffer->mVertexCount; s++)
95	{
96	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_POSITION)
97	{
98	mSubMesh[i].mVertexBuffer->mPosition[s].x = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].x;
99	mSubMesh[i].mVertexBuffer->mPosition[s].y = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].y;
100	mSubMesh[i].mVertexBuffer->mPosition[s].z = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].z;
101	}
102
103	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_NORMAL)
104	{
105	mSubMesh[i].mVertexBuffer->mNormal[s].x = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].x;
106	mSubMesh[i].mVertexBuffer->mNormal[s].y = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].y;
107	mSubMesh[i].mVertexBuffer->mNormal[s].z = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].z;
108	}
109
110	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_TEXCOORDS)
111	{
112	mSubMesh[i].mVertexBuffer->mTexCoords[s].x = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].x;
113	mSubMesh[i].mVertexBuffer->mTexCoords[s].y = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].y;
114	}
115	}
116
117	}
118
119	// Copy indices.
120	mSubMesh[i].mIndexCount = mesh.mSubMesh[i].mIndexCount;
121	mSubMesh[i].mIndex = new Index[mSubMesh[i].mIndexCount];
122
123	memcpy( mSubMesh[i].mIndex,
124	mesh.mSubMesh[i].mIndex,
125	mesh.mSubMesh[i].mIndexCount * sizeof(Index));
126
127	// Copy strips.
128	// offset between memory positions.
129	__w64 int offset = 0;
130	mSubMesh[i].mStripCount = mesh.mSubMesh[i].mStripCount;
131
132	if (mesh.mSubMesh[i].mStripCount > 0)
133	{
134	mSubMesh[i].mStrip = new Index*[mesh.mSubMesh[i].mStripCount];
135
136	offset = &(mSubMesh[i].mIndex[0]) - &(mesh.mSubMesh[i].mIndex[0]);
137
138	for (size_t j = 0; j < mesh.mSubMesh[i].mStripCount; j++)
139	{
140	mSubMesh[i].mStrip[j] = mesh.mSubMesh[i].mStrip[j] + offset;
141	}
142	}
143
144	// Copy submesh bones.
145	if (!mesh.mSubMesh[i].mBones.empty())
146	{
147	for (unsigned int j = 0; j < mesh.mSubMesh[i].mBones.size(); j++)
148	{
149	mSubMesh[i].mBones.push_back(mesh.mSubMesh[i].mBones[j]);
150	}
151	}
152	}
153
154	// Copy skeleton name.
155	if (mesh.hasSkeleton)
156	{
157	hasSkeleton = true;
158
159	strcpy(mSkeletonName, mesh.mSkeletonName);
160	}
161
162	// Copy mesh bones.
163	if (!mesh.mBones.empty())
164	{
165	for (unsigned int j = 0; j < mesh.mBones.size(); j++)
166	{
167	mBones.push_back(mesh.mBones[j]);
168	}
169	}
170
171	}
172
173	//-------------------------------------------------------------------------
174	// Assignment operator.
175	//-------------------------------------------------------------------------
176	Mesh &Mesh::operator =(const Mesh &mesh)
177	{
178	bool copied = false;
179	mVertexBuffer = new VertexBuffer();
180	mSubMeshCount = mesh.mSubMeshCount;
181	mSubMesh = new Geometry::SubMesh[mesh.mSubMeshCount];
182
183	// Fill up bounding box settings.
184	mMeshBounds.maxX = mesh.mMeshBounds.maxX;
185	mMeshBounds.maxY = mesh.mMeshBounds.maxY;
186	mMeshBounds.maxZ = mesh.mMeshBounds.maxZ;
187	mMeshBounds.minX = mesh.mMeshBounds.minX;
188	mMeshBounds.minY = mesh.mMeshBounds.minY;
189	mMeshBounds.minZ = mesh.mMeshBounds.minZ;
190	mMeshBounds.radius = mesh.mMeshBounds.radius;
191	mMeshBounds.scaleFactor = mesh.mMeshBounds.scaleFactor;
192
193	// For each submesh.
194	for (size_t i = 0; i < mesh.mSubMeshCount; i++)
195	{
196	mSubMesh[i].mSharedVertexBuffer = mesh.mSubMesh[i].mSharedVertexBuffer; //.false;
197	mSubMesh[i].mVertexBuffer = new Geometry::VertexBuffer();
198	mSubMesh[i].mVertexBuffer->mPosition = new Geometry::Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
199	mSubMesh[i].mVertexBuffer->mNormal = new Geometry::Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
200	mSubMesh[i].mVertexBuffer->mTexCoords = new Geometry::Vector2[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
201	mSubMesh[i].mVertexBuffer->mVertexCount = mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
202	mSubMesh[i].mVertexBuffer->mVertexInfo = mesh.mSubMesh[i].mVertexBuffer->mVertexInfo;
203	mSubMesh[i].mType = mesh.mSubMesh[i].mType;
204	strcpy(mSubMesh[i].mMaterialName,mesh.mSubMesh[i].mMaterialName);
205
206	if (mesh.mSubMesh[i].mSharedVertexBuffer && !copied)
207	{
208	mVertexBuffer = mSubMesh[i].mVertexBuffer;
209	copied = true;
210	}
211
212	for ( size_t s = 0;
213	s < mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
214	s++)
215	{
216	mSubMesh[i].mVertexBuffer->mPosition[s].x = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].x;
217	mSubMesh[i].mVertexBuffer->mPosition[s].y = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].y;
218	mSubMesh[i].mVertexBuffer->mPosition[s].z = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].z;
219
220	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
221	{
222	mSubMesh[i].mVertexBuffer->mNormal[s].x = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].x;
223	mSubMesh[i].mVertexBuffer->mNormal[s].y = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].y;
224	mSubMesh[i].mVertexBuffer->mNormal[s].z = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].z;
225	}
226
227	if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
228	{
229	mSubMesh[i].mVertexBuffer->mTexCoords[s].x = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].x;
230	mSubMesh[i].mVertexBuffer->mTexCoords[s].y = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].y;
231	}
232	}
233
234	// Copy indices.
235	mSubMesh[i].mIndexCount = mesh.mSubMesh[i].mIndexCount;
236	mSubMesh[i].mIndex = new Index[mSubMesh[i].mIndexCount];
237
238	memcpy( mSubMesh[i].mIndex,
239	mesh.mSubMesh[i].mIndex,
240	mesh.mSubMesh[i].mIndexCount*sizeof(Geometry::Index));
241
242	// Copy strips.
243	__w64 offset = 0;
244	mSubMesh[i].mStripCount = mesh.mSubMesh[i].mStripCount;
245
246	if (mesh.mSubMesh[i].mStripCount > 0)
247	{
248	mSubMesh[i].mStrip = new Index*[mesh.mSubMesh[i].mStripCount];
249
250	offset = &(mSubMesh[i].mIndex[0])
251	-
252	&(mesh.mSubMesh[i].mIndex[0]);
253
254	for (size_t j = 0; j < mesh.mSubMesh[i].mStripCount; j++)
255	{
256	mSubMesh[i].mStrip[j] = mesh.mSubMesh[i].mStrip[j] + offset;
257	}
258	}
259
260	// Copy submesh bones.
261	if (!mesh.mSubMesh[i].mBones.empty())
262	{
263	for (unsigned int j = 0; j < mesh.mSubMesh[i].mBones.size(); j++)
264	{
265	mSubMesh[i].mBones.push_back(mesh.mSubMesh[i].mBones[j]);
266	}
267	}
268	}
269
270	// Copy skeleton name.
271	if (mesh.hasSkeleton)
272	{
273	hasSkeleton = true;
274
275	strcpy(mSkeletonName, mesh.mSkeletonName);
276	}
277
278	// Copy mesh bones.
279	if (!mesh.mBones.empty())
280	{
281	for (unsigned int j = 0; j < mesh.mBones.size(); j++)
282	{
283	mBones.push_back(mesh.mBones[j]);
284	}
285	}
286
287	return *this;
288	}
289
290	//-------------------------------------------------------------------------
291	// Load mesh.
292	//-------------------------------------------------------------------------
293	void Mesh::Load(Serializer &s)
294	{
295	bool sharedVertexBuffer = false;
296
297	// Clear Data.
298	delete [] mSubMesh;
299
300	mSubMesh = 0;
301
302	delete mVertexBuffer;
303
304	mVertexBuffer = 0;
305	mSubMeshCount = 0;
306
307	s.ReadArray(&sharedVertexBuffer,1);
308
309	if (sharedVertexBuffer)
310	{
311	mVertexBuffer = new VertexBuffer;
312	mVertexBuffer->Load(s);
313	}
314
315	s.ReadArray(&mSubMeshCount, 1);
316
317	mSubMesh = new SubMesh[mSubMeshCount];
318
319	for(size_t i = 0; i < mSubMeshCount; i++)
320	{
321	mSubMesh[i].Load(s);
322
323	if (mSubMesh[i].mSharedVertexBuffer && sharedVertexBuffer)
324	{
325	mSubMesh[i].mVertexBuffer = mVertexBuffer;
326	}
327	}
328	}
329
330	//-------------------------------------------------------------------------
331	// Save mesh.
332	//-------------------------------------------------------------------------
333	void Mesh::Save(Serializer &s)
334	{
335	bool sharedVertexBuffer = (mVertexBuffer != 0);
336
337	s.WriteArray(&sharedVertexBuffer, 1);
338
339	if (sharedVertexBuffer)
340	{
341	mVertexBuffer->Save(s);
342	}
343
344	s.WriteArray(&mSubMeshCount,1);
345
346	for(size_t i = 0; i < mSubMeshCount; i++)
347	{
348	mSubMesh[i].Save(s);
349	}
350	}
351
352	//-------------------------------------------------------------------------
353	// Export to obj mesh.
354	//-------------------------------------------------------------------------
355	void Mesh::exportToOBJ(char *fileName)
356	{
357	size_t vertex_count;
358
359	vertex_count = 0;
360
361	std::ofstream obj(fileName);
362
363	obj << "begin" << std::endl;
364
365	for (size_t j = 0; j < mVertexBuffer->mVertexCount; j++)
366	{
367	obj << "v "
368	<< mVertexBuffer->mPosition[j].x
369	<< " "
370	<< mVertexBuffer->mPosition[j].y
371	<< " "
372	<< mVertexBuffer->mPosition[j].z
373	<< " "
374	<< std::endl;
375	}
376
377	// Vertices.
378	for (size_t i = 0; i < mSubMeshCount; i++)
379	{
380	if (!mSubMesh[i].mSharedVertexBuffer)
381	{
382	for (size_t j = 0; j < mSubMesh[i].mVertexBuffer->mVertexCount; j++)
383	{
384	obj << "v "
385	<< mSubMesh[i].mVertexBuffer->mPosition[j].x
386	<< " "
387	<< mSubMesh[i].mVertexBuffer->mPosition[j].y
388	<< " "
389	<< mSubMesh[i].mVertexBuffer->mPosition[j].z
390	<< " "
391	<< std::endl;
392	}
393	}
394	}
395
396	// Normals.
397	for (size_t j = 0; j < mVertexBuffer->mVertexCount; j++)
398	{
399	obj << "vn "
400	<< mVertexBuffer->mNormal[j].x
401	<< " "
402	<< mVertexBuffer->mNormal[j].y
403	<< " "
404	<< mVertexBuffer->mNormal[j].z
405	<< " "
406	<< std::endl;
407	}
408
409	for (size_t i = 0; i < mSubMeshCount; i++)
410	{
411	if (!mSubMesh[i].mSharedVertexBuffer)
412	{
413	for (size_t j = 0; j < mSubMesh[i].mVertexBuffer->mVertexCount; j++)
414	{
415	obj << "vn "
416	<< mSubMesh[i].mVertexBuffer->mNormal[j].x
417	<< " "
418	<< mSubMesh[i].mVertexBuffer->mNormal[j].y
419	<< " "
420	<< mSubMesh[i].mVertexBuffer->mNormal[j].z
421	<< " "
422	<< std::endl;
423	}
424	}
425	}
426
427	// Faces.
428	for (size_t i = 0; i < mSubMeshCount; i++)
429	{
430	for (size_t j = 0; j < mSubMesh[i].mIndexCount; j = j + 3)
431	{
432	int a = mSubMesh[i].mIndex[j] + 1 + vertex_count;
433	int b = mSubMesh[i].mIndex[j+1] + 1 + vertex_count;
434	int c = mSubMesh[i].mIndex[j+2] + 1 + vertex_count;
435	obj << "f " << a << "//" << a << " "
436	<< b << "//" << b << " "
437	<< c << "//" << c << " "
438	<< std::endl;
439
440	}
441	vertex_count += mSubMesh[i].mVertexBuffer->mVertexCount;
442	}
443
444	obj << "end" << std::endl;
445
446	obj.close();
447	}
448
449	//-------------------------------------------------------------------------
450	// Transform to shared vertex mesh.
451	//-------------------------------------------------------------------------
452	Mesh *Mesh::toSharedVertex()
453	{
454	// Move all vertex to the shared vertex buffer.
455	Mesh *mesh = new Mesh();
456
457	if (mSubMesh[0].mSharedVertexBuffer)
458	{
459	mesh = this;
460
461	return mesh;
462	}
463
464	mesh->mVertexBuffer = new VertexBuffer();
465	mesh->mSubMeshCount = mSubMeshCount;
466	mesh->mSubMesh = new SubMesh[mSubMeshCount];
467
468	// Fill up bounding box settings.
469	mesh->mMeshBounds.maxX = mMeshBounds.maxX;
470	mesh->mMeshBounds.maxY = mMeshBounds.maxY;
471	mesh->mMeshBounds.maxZ = mMeshBounds.maxZ;
472	mesh->mMeshBounds.minX = mMeshBounds.minX;
473	mesh->mMeshBounds.minY = mMeshBounds.minY;
474	mesh->mMeshBounds.minZ = mMeshBounds.minZ;
475	mesh->mMeshBounds.radius = mMeshBounds.radius;
476	mesh->mMeshBounds.scaleFactor = mMeshBounds.scaleFactor;
477
478	// construcción de los submeshes
479	long int acumVerts = 0;
480
481	for (size_t i = 0; i < mesh->mSubMeshCount; i++)
482	{
483	mesh->mSubMesh[i].mSharedVertexBuffer = true;
484	mesh->mSubMesh[i].mVertexBuffer = mesh->mVertexBuffer;
485	mesh->mSubMesh[i].mStripCount = 0;
486	mesh->mSubMesh[i].mStrip = NULL;
487	mesh->mSubMesh[i].mType = mSubMesh[i].mType;
488
489	strcpy(mesh->mSubMesh[i].mMaterialName,mSubMesh[i].mMaterialName);
490
491	// Copy indices.
492	mesh->mSubMesh[i].mIndexCount = mSubMesh[i].mIndexCount;
493	mesh->mSubMesh[i].mIndex = new Index[mSubMesh[i].mIndexCount];
494
495	for (size_t j = 0; j < mSubMesh[i].mIndexCount; j++)
496	{
497	mesh->mSubMesh[i].mIndex[j] = mSubMesh[i].mIndex[j]+acumVerts;
498	}
499
500	acumVerts += long(mSubMesh[i].mVertexBuffer->mVertexCount);
501
502	// Copy strips.
503	int offset = 0;
504
505	mesh->mSubMesh[i].mStripCount = mSubMesh[i].mStripCount;
506
507	if (mSubMesh[i].mStripCount > 0)
508	{
509	mesh->mSubMesh[i].mStrip = new Index*[mSubMesh[i].mStripCount];
510
511	offset = int(&(mesh->mSubMesh[i].mIndex[0]) - &(mSubMesh[i].mIndex[0]));
512
513	for (size_t j = 0; j < mSubMesh[i].mStripCount; j++)
514	{
515	mesh->mSubMesh[i].mStrip[j] = mSubMesh[i].mStrip[j] + offset;
516	}
517	}
518	}
519
520	mesh->mVertexBuffer->mVertexCount = acumVerts;
521	mesh->mVertexBuffer->mVertexInfo = mSubMesh[0].mVertexBuffer->mVertexInfo;
522
523	mesh->mVertexBuffer->mPosition = new Vector3[mesh->mVertexBuffer->mVertexCount];
524	mesh->mVertexBuffer->mNormal = new Vector3[mesh->mVertexBuffer->mVertexCount];
525	mesh->mVertexBuffer->mTexCoords = new Vector2[mesh->mVertexBuffer->mVertexCount];
526
527	acumVerts = 0;
528
529	size_t newIndex;
530
531	for (size_t i = 0; i < mSubMeshCount; i++)
532	{
533	for (size_t j = 0; j < mSubMesh[i].mVertexBuffer->mVertexCount; j++)
534	{
535	newIndex = acumVerts + j;
536
537	mesh->mVertexBuffer->
538	mPosition[newIndex].x = mSubMesh[i].mVertexBuffer->
539	mPosition[j].x;
540
541	mesh->mVertexBuffer->
542	mPosition[newIndex].y = mSubMesh[i].mVertexBuffer->
543	mPosition[j].y;
544
545	mesh->mVertexBuffer->
546	mPosition[newIndex].z = mSubMesh[i].mVertexBuffer->
547	mPosition[j].z;
548
549	mesh->mVertexBuffer->
550	mNormal[newIndex].x = mSubMesh[i].mVertexBuffer->
551	mNormal[j].x;
552
553	mesh->mVertexBuffer->
554	mNormal[newIndex].y = mSubMesh[i].mVertexBuffer->
555	mNormal[j].y;
556
557	mesh->mVertexBuffer->
558	mNormal[newIndex].z = mSubMesh[i].mVertexBuffer->
559	mNormal[j].z;
560
561	mesh->mVertexBuffer->
562	mTexCoords[newIndex].x = mSubMesh[i].mVertexBuffer->
563	mTexCoords[j].x;
564
565	mesh->mVertexBuffer->
566	mTexCoords[newIndex].y = mSubMesh[i].mVertexBuffer->
567	mTexCoords[j].y;
568	}
569
570	// Shared bones.
571	if (!mSubMesh[i].mBones.empty())
572	{
573	for (unsigned int j = 0; j < mSubMesh[i].mBones.size(); j++)
574	{
575	mesh->mBones.push_back(mSubMesh[i].mBones[j]);
576
577	mesh->mBones.back().vertexIndex += acumVerts;
578	}
579	}
580
581	acumVerts += long(mSubMesh[i].mVertexBuffer->mVertexCount);
582	}
583
584	// Copy skeleton name.
585	if (hasSkeleton)
586	{
587	mesh->hasSkeleton = true;
588
589	strcpy(mesh->mSkeletonName,mSkeletonName);
590	}
591
592
593	// Copy mesh bones.
594	if (!mBones.empty())
595	{
596	for (unsigned int j = 0; j < mBones.size(); j++)
597	{
598	mesh->mBones.push_back(mBones[j]);
599	}
600	}
601
602	return mesh;
603	}
604

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

Download in other formats: