Context Navigation

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

Revision 2341, 18.5 KB checked in by gumbau, 17 years ago (diff)

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

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

Download in other formats: