Context Navigation

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

Revision 1070, 16.6 KB checked in by gumbau, 18 years ago (diff)

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

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

Download in other formats: