Index: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoSubMesh.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoSubMesh.h	(revision 980)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoSubMesh.h	(revision 1009)
@@ -51,5 +51,4 @@
 		char			mMaterialName[255];	///<	Material name
 
-		//OSCAR
 		std::vector <VertexBoneAssignment> mBones;
 	};
@@ -57,2 +56,3 @@
 
 #endif
+
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoVertexBuffer.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoVertexBuffer.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoVertexBuffer.h	(revision 1009)
@@ -8,6 +8,6 @@
 
 
-namespace Geometry {
-
+namespace Geometry
+{
 	/// VertexBuffer interface Class
 	/**
@@ -40,7 +40,10 @@
 		void Save(Serializer &s);
 		
-        unsigned int mVertexInfo;  ///< Type of info stored by vertex
+		unsigned int mVertexInfo;  ///< Type of info stored by vertex
 		size_t  mVertexCount;      ///< Number of vertices
-		Vector3 *mPosition; ///< Position array of each Vertex, only valid if (vertexInfo & VERTEX_POSITON) == true
+		
+/// Position array of each Vertex, only valid if (vertexInfo & VERTEX_POSITON) == true
+		Vector3 *mPosition;
+		
 		Vector3 *mNormal;   ///< Normal array of each Vertex, only valid if (vertexInfo & VERTEX_NORMAL) == true
 		Vector2 *mTexCoords;///< Texture Coordinates array of each Vertex, only valid if (vertexInfo & VERTEX_TEXCOORDS) == true
@@ -50,2 +53,3 @@
 
 #endif
+
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoLodStripsLibrary.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoLodStripsLibrary.h	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoLodStripsLibrary.h	(revision 1009)
@@ -21,6 +21,6 @@
 	//typedef unsigned long int SmallInt;
 	typedef unsigned long SmallInt;
-	typedef unsigned long			ULong;
-	typedef	long							Long;
+	typedef unsigned long	ULong;
+	typedef	long					Long;
 	
 	typedef struct
@@ -101,12 +101,8 @@
 			Mesh	*mGeoMesh;
 
-			/*
-				Copa STL vectors to C arrays.
-			*/
+			//	Copa STL vectors to C arrays.
 			void	CopyVectors2Arrays();
 
-			/*
-				Loads Mesh
-			*/
+			//	Loads Mesh.
 			void	LoadStripMesh(char *name, Mesh *geomesh);
 
@@ -159,4 +155,4 @@
 }
 
+#endif
 
-#endif
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoSerializer.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoSerializer.h	(revision 980)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoSerializer.h	(revision 1009)
@@ -6,80 +6,77 @@
 #include "GeoVector3.h"
 
-namespace Geometry {
-
+namespace Geometry
+{
 	/// Serializer interface
 	/** Serializer is a helper class than manages file input/output.
 	*/
-    class Serializer
-    {
-    public:
+	class Serializer
+	{
+		public:
 
-		enum Mode
-		{
-			READ,
-			WRITE,
-			APPEND
-		};
+			enum Mode
+			{
+				READ,
+				WRITE,
+				APPEND
+			};
 
-		///Constructor
-		Serializer(String name, Mode mode);
+			///	Constructor.
+			Serializer(String name, Mode mode);
 
-		///Destructor
-		virtual ~Serializer();
+			///	Destructor.
+			virtual ~Serializer();
 
-		/// Copy constructor
-		//Serializer(const Serializer&);
+			/// Copy constructor.
+			//Serializer(const Serializer&);
 
-		/// Assignment operator
-		//Serializer& operator =(const Serializer&);
+			/// Assignment operator.
+			//Serializer& operator =(const Serializer&);
 
+		public:
 
-	public:
-		void WriteData(const void* const buf, size_t size, size_t count);
-        void WriteArray(const float* const pfloat, size_t count);
-        void WriteArray(const uint16* const pShort, size_t count);
-        void WriteArray(const uint32* const pInt, size_t count); 
-        void WriteArray(const bool* const pLong, size_t count);
-		void WriteArray(const Vector3* const pvector3, size_t count);
-		void WriteArray(const Vector2* const pvector3, size_t count);
-		   
-		void ReadData(void *buf, size_t size, size_t count);
-		void miReadData2(void *buf, size_t size, size_t count);
-		char *miReadData(char *pDest, size_t pDestsize);
-        void ReadArray(bool *pDest, size_t count);
-        void ReadArray(float *pDest, size_t count);
-        void ReadArray(uint16 *pDest, size_t count);
-        void ReadArray(uint32 *pDest, size_t count);
-		void ReadArray(Vector3 *pDest, size_t count);
-		void ReadArray(Vector2 *pDest, size_t count);
+			void WriteData(const void* const buf, size_t size, size_t count);
+			void WriteArray(const float* const pfloat, size_t count);
+			void WriteArray(const uint16* const pShort, size_t count);
+			void WriteArray(const uint32* const pInt, size_t count); 
+			void WriteArray(const bool* const pLong, size_t count);
+			void WriteArray(const Vector3* const pvector3, size_t count);
+			void WriteArray(const Vector2* const pvector3, size_t count);
 
-		//	GPR.
-		void	WriteData(const	String	&string);
-		void	WriteData(const char		*string);
-		//	fin GPR.
+			void 		ReadData(void *buf, size_t size, size_t count);
+			char *	ReadData(char *pDest, size_t pDestsize);
+			void ReadArray(bool *pDest, size_t count);
+			void ReadArray(float *pDest, size_t count);
+			void ReadArray(uint16 *pDest, size_t count);
+			void ReadArray(uint32 *pDest, size_t count);
+			void ReadArray(Vector3 *pDest, size_t count);
+			void ReadArray(Vector2 *pDest, size_t count);
 
-		virtual size_t GetSize() 
-		{
-			return mSize;
-		}
+			void	WriteData(const	String	&string);
+			void	WriteData(const char		*string);
 
-		int serializereof() {
-			return feof(mFile);
-		}
+			virtual size_t GetSize() 
+			{
+				return mSize;
+			}
 
-    protected:
+			int serializereof() {
+				return feof(mFile);
+			}
 
-		size_t mSize;
-        FILE   *mFile;
-		Mode   mMode;
+		protected:
 
-		void FlipToLittleEndian(void *pData, size_t size, size_t count = 1);
-		void FlipFromLittleEndian(void *pData, size_t size, size_t count = 1);
-		void FlipEndian(void *pData, size_t size, size_t count);
-		void FlipEndian(void *pData, size_t size);
-    };
+			size_t mSize;
+			FILE   *mFile;
+			Mode   mMode;
+
+			void FlipToLittleEndian(void *pData, size_t size, size_t count = 1);
+			void FlipFromLittleEndian(void *pData, size_t size, size_t count = 1);
+			void FlipEndian(void *pData, size_t size, size_t count);
+			void FlipEndian(void *pData, size_t size);
+	};
 
 }
 
+#endif
 
-#endif
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSubMesh.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSubMesh.cpp	(revision 980)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSubMesh.cpp	(revision 1009)
@@ -3,52 +3,86 @@
 using namespace Geometry;
 
+//---------------------------------------------------------------------------
+//	Constructor.
+//---------------------------------------------------------------------------
 SubMesh::SubMesh():
-	mIndex(0), mVertexBuffer(0), mIndexCount(0),mSharedVertexBuffer(false), mStrip(0), mStripCount(0), mType(GEO_TRIANGLE_LIST)
+	mIndex(0),
+	mVertexBuffer(0),
+	mIndexCount(0),
+	mSharedVertexBuffer(false),
+	mStrip(0),
+	mStripCount(0),
+	mType(GEO_TRIANGLE_LIST)
 {
 	strcpy(mMaterialName,"");
 }
 
+//---------------------------------------------------------------------------
+//	Destroyer.
+//---------------------------------------------------------------------------
 SubMesh::~SubMesh()
 {
-	delete[] mIndex;
-	if (!mSharedVertexBuffer) delete mVertexBuffer;
-}
-
-void SubMesh::Load(Serializer &s)
-{
-	//Clear Data:
-	delete[] mIndex; mIndex = 0;
+	delete	[]	mIndex;
+	
 	if (!mSharedVertexBuffer)
 	{
 		delete mVertexBuffer;
-		mVertexBuffer = 0;
 	}
-	mIndexCount = 0;
+}
 
-	//Load Data from Serializer
-	s.ReadArray(&mSharedVertexBuffer,1);
+//---------------------------------------------------------------------------
+//	Load data from a serializer.
+//---------------------------------------------------------------------------
+void SubMesh::Load(Serializer &s)
+{
+	//	Clear Data.
+	delete	[]	mIndex;
+	
+	mIndex	=	0;
+	
+	if (!mSharedVertexBuffer)
+	{
+		delete mVertexBuffer;
+		
+		mVertexBuffer	=	0;
+	}
+	
+	mIndexCount	=	0;
+
+	//	Load Data from Serializer.
+	s.ReadArray(&mSharedVertexBuffer,	1);
+	
 	if (mSharedVertexBuffer)
 	{
-		mVertexBuffer = 0;
+		mVertexBuffer	=	0;
 	}
 	else
 	{
-		mVertexBuffer = new VertexBuffer();
+		mVertexBuffer	=	new VertexBuffer();
+		
 		mVertexBuffer->Load(s);
-	};
+	}
 
-	s.ReadArray(&mIndexCount,1);
-	mIndex = new Index[mIndexCount];
-	s.ReadArray(mIndex,mIndexCount);
+	s.ReadArray(&mIndexCount,	1);
+	
+	mIndex	=	new Index[mIndexCount];
+	
+	s.ReadArray(mIndex,	mIndexCount);
 }
 
+//---------------------------------------------------------------------------
+//	Save data to a serializer.
+//---------------------------------------------------------------------------
 void SubMesh::Save(Serializer &s)
 {
-	s.WriteArray(&mSharedVertexBuffer,1);
+	s.WriteArray(&mSharedVertexBuffer,	1);
+	
 	if (!mSharedVertexBuffer)
 	{
 		mVertexBuffer->Save(s);
 	}
-	s.WriteArray(&mIndexCount,1);
-	s.WriteArray(mIndex,mIndexCount);
+	
+	s.WriteArray(&mIndexCount,	1);
+	s.WriteArray(mIndex,	mIndexCount);
 }
+
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoVertexBuffer.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoVertexBuffer.cpp	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoVertexBuffer.cpp	(revision 1009)
@@ -3,17 +3,22 @@
 using namespace Geometry;
 
-//---------------------------------------------------------------------
+//---------------------------------------------------------------------------
+//	Destroyer.
+//---------------------------------------------------------------------------
 VertexBuffer::~VertexBuffer()
 {
-	delete[] mPosition;
-	delete[] mNormal;
-	delete[] mTexCoords;
+	delete	[] mPosition;
+	delete	[] mNormal;
+	delete	[] mTexCoords;
 }
 
-//---------------------------------------------------------------------
+//---------------------------------------------------------------------------
+//	Save to a serializer.
+//---------------------------------------------------------------------------
 void VertexBuffer::Save(Serializer &s)
 {
-	s.WriteArray(&mVertexInfo,1);
-	s.WriteArray(&mVertexCount,1);
+	s.WriteArray(&mVertexInfo,	1);
+	s.WriteArray(&mVertexCount,	1);
+	
 	if (mVertexInfo & VERTEX_POSITION)
 	{
@@ -30,44 +35,64 @@
 }
 
-//---------------------------------------------------------------------
+//---------------------------------------------------------------------------
+//	Loads from a serializer.
+//---------------------------------------------------------------------------
 void VertexBuffer::Load(Serializer &s)
 {
-	//Clear data
-	delete[] mPosition;  mPosition = 0;
-	delete[] mNormal;    mNormal = 0;
-	delete[] mTexCoords; mTexCoords = 0;
+	//	Clear data.
+	delete	[]	mPosition;
+	
+	mPosition = 0;
+	
+	delete	[]	mNormal;
+	
+	mNormal	=	0;
+	
+	delete	[]	mTexCoords;
+	
+	mTexCoords	=	0;
 
 	s.ReadArray(&mVertexInfo,1);
 	s.ReadArray(&mVertexCount,1);
+	
 	if (mVertexInfo & VERTEX_POSITION)
 	{
-		mPosition = new Vector3[mVertexCount];
+		mPosition	=	new Vector3[mVertexCount];
+		
 		s.ReadArray(mPosition, mVertexCount);
 	}
+	
 	if (mVertexInfo & VERTEX_NORMAL)
 	{
-		mNormal = new Vector3[mVertexCount];
+		mNormal	=	new Vector3[mVertexCount];
+		
 		s.ReadArray(mNormal, mVertexCount);
 	}
+	
 	if (mVertexInfo & VERTEX_TEXCOORDS)
 	{
-		mTexCoords = new Vector2[mVertexCount];
+		mTexCoords	=	new Vector2[mVertexCount];
+		
 		s.ReadArray(mTexCoords, mVertexCount);
 	}
 }
 
-//---------------------------------------------------------------------
+//---------------------------------------------------------------------------
+//	Copy contents of vertex buffer to another.
+//---------------------------------------------------------------------------
 VertexBuffer *VertexBuffer::Clone() const
 {
-	VertexBuffer *vnew = new VertexBuffer();
-	vnew->mVertexInfo = mVertexInfo;
-	vnew->mVertexCount = mVertexCount;
-	vnew->mPosition = new Vector3[mVertexCount];
-	vnew->mNormal = new Vector3[mVertexCount];
-	vnew->mTexCoords = new Vector2[mVertexCount];
+	VertexBuffer *vnew	=	new VertexBuffer();
+	vnew->mVertexInfo		=	mVertexInfo;
+	vnew->mVertexCount	=	mVertexCount;
+	vnew->mPosition			=	new Vector3[mVertexCount];
+	vnew->mNormal				=	new Vector3[mVertexCount];
+	vnew->mTexCoords		=	new Vector2[mVertexCount];
 
 	memcpy(vnew->mPosition, mPosition, mVertexCount*sizeof(Vector3));
 	memcpy(vnew->mNormal, mNormal, mVertexCount*sizeof(Vector3));
 	memcpy(vnew->mTexCoords, mTexCoords, mVertexCount*sizeof(Vector2));
-	return vnew;
+	
+	return	vnew;
 }
+
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsLibrary.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsLibrary.cpp	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsLibrary.cpp	(revision 1009)
@@ -1,12 +1,12 @@
-/*	==========================================================================
+/*==========================================================================
  *	(C) 2005 Universitat Jaume I
- *	==========================================================================
+ *==========================================================================
  *	PROYECT:	GAME TOOLS
- *	==========================================================================*/
-/**	CONTENT:	
-	*
-	*
-	*	@file	GeoLodStripsLibrary.cpp
-/*===========================================================================*/
+ *==========================================================================
+ *	CONTENT:
+ *
+ *
+ *	@file	GeoLodStripsLibrary.cpp
+ *===========================================================================*/
 
 #include "GeoLodStripsLibrary.h"
@@ -47,7 +47,7 @@
 //-----------------------------------------------------------------------------
 
-/*
-	Go to the level of detail.
-*/
+//-----------------------------------------------------------------------------
+//	Go to the level of detail.
+//-----------------------------------------------------------------------------
 uint32 LodStripsLibrary::GoToLod(uint32 newLOD)
 {
@@ -308,7 +308,7 @@
 
 
-/*
-	Gets the maximum level of detail.
-*/
+//-----------------------------------------------------------------------------
+//	Gets the maximum level of detail.
+//-----------------------------------------------------------------------------
 uint32 LodStripsLibrary::MaxLod()
 {
@@ -316,7 +316,7 @@
 }
 
-/*
-	Gets the minimum level of detail.
-*/
+//-----------------------------------------------------------------------------
+//	Gets the minimum level of detail.
+//-----------------------------------------------------------------------------
 uint32 LodStripsLibrary::MinLod()
 {
@@ -324,5 +324,7 @@
 }
 
-/// Returns the number of vertices of the highest LOD.
+//-----------------------------------------------------------------------------
+//	Returns the number of vertices of the highest LOD.
+//-----------------------------------------------------------------------------
 uint32	LodStripsLibrary::MaxVertices()
 {
@@ -330,5 +332,7 @@
 }
 
-/// Returns the number of vertices of the lowest LOD.
+//-----------------------------------------------------------------------------
+//	Returns the number of vertices of the lowest LOD.
+//-----------------------------------------------------------------------------
 uint32	LodStripsLibrary::MinVertices()
 {
@@ -341,5 +345,7 @@
 }
 
-/// Returns the number of triangles of the highest LOD.
+//-----------------------------------------------------------------------------
+//	Returns the number of triangles of the highest LOD.
+//-----------------------------------------------------------------------------
 uint32	LodStripsLibrary::MaxFaces()
 {
@@ -364,5 +370,7 @@
 }
 
-/// Returns the number of triangles of the lowest LOD.
+//-----------------------------------------------------------------------------
+//	Returns the number of triangles of the lowest LOD.
+//-----------------------------------------------------------------------------
 uint32	LodStripsLibrary::MinFaces()
 {
@@ -386,6 +394,8 @@
 }
 
-/// Establishes the new LOD range.
-/// Only the LODs in that range are stored and used.
+//-----------------------------------------------------------------------------
+//	Establishes the new LOD range.
+//	Only the LODs in that range are stored and used.
+//-----------------------------------------------------------------------------
 void		LodStripsLibrary::TrimByLod(uint32 minLod, uint32 maxLod)
 {
@@ -397,4 +407,7 @@
 }
 
+//-----------------------------------------------------------------------------
+//	Get strip count.
+//-----------------------------------------------------------------------------
 uint32	LodStripsLibrary::GetStripCount() const
 {
@@ -402,4 +415,7 @@
 }
 
+//-----------------------------------------------------------------------------
+//	Get Index by strip.
+//-----------------------------------------------------------------------------
 uint32	LodStripsLibrary::GetIndexCountByStrip(uint32 istrip) const
 {
@@ -411,7 +427,7 @@
 //-----------------------------------------------------------------------------
 
-/*
-	Copy a STL vector to a C array.
-*/
+//-----------------------------------------------------------------------------
+//	Copy a STL vector to a C array.
+//-----------------------------------------------------------------------------
 void LodStripsLibrary::CopyVectors2Arrays()
 {
@@ -487,5 +503,5 @@
 
 //-----------------------------------------------------------------------------
-// LoadStripMesh
+//	LoadStripMesh
 //-----------------------------------------------------------------------------
 void LodStripsLibrary::LoadStripMesh(char *name, Mesh *geomesh)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSerializer.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSerializer.cpp	(revision 980)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSerializer.cpp	(revision 1009)
@@ -1,243 +1,281 @@
 #include "GeoSerializer.h"
 
-
-namespace Geometry
-{
-	//---------------------------------------------------------------------
-	Serializer::Serializer(String name, Mode mode)
-		: mMode(mode)
-		{
-			char *char_mode = 0;
-			switch (mMode)
-			{
-				case READ : 
-					char_mode = "rb"; 
-					break;
-				case APPEND:
-					char_mode = "a+b";
-					break;
-				case WRITE:
-					char_mode = "wb";
-					break;
-			}
-
-			mFile = fopen(name.c_str(),char_mode);
-			mSize = 0;
-			assert(mFile);
-		}
-
-	//---------------------------------------------------------------------
-	Serializer::~Serializer()
-	{
-		fflush(mFile);
-		fclose(mFile);
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::WriteArray(const float* const pFloat, size_t count)
-	{
-#	if GEO_ENDIAN == GEO_ENDIAN_BIG
-		float *float_to_write = (float *)malloc(sizeof(float) * count);
-		memcpy(float_to_write, pFloat, sizeof(float) * count);
-
-		flipToLittleEndian(float_to_write, sizeof(float), count);
-		writeData(float_to_write, sizeof(float), count);
-
-		free(float_to_write);
+using	namespace	Geometry;
+
+//---------------------------------------------------------------------------
+//	Constructor.
+//---------------------------------------------------------------------------
+Serializer::Serializer(String name, Mode mode): mMode(mode)
+{
+	char *char_mode = 0;
+
+	switch (mMode)
+	{
+		case READ : 
+			char_mode = "rb"; 
+			break;
+		case APPEND:
+			char_mode = "a+b";
+			break;
+		case WRITE:
+			char_mode = "wb";
+			break;
+	}
+
+	mFile = fopen(name.c_str(),char_mode);
+	mSize = 0;
+
+	assert(mFile);
+}
+
+//---------------------------------------------------------------------------
+//	Destroyer.
+//---------------------------------------------------------------------------
+Serializer::~Serializer()
+{
+	fflush(mFile);
+	fclose(mFile);
+}
+
+//---------------------------------------------------------------------------
+//	Write array of floats.
+//---------------------------------------------------------------------------
+void Serializer::WriteArray(const float* const pFloat, size_t count)
+{
+#	if GEO_ENDIAN == GEO_ENDIAN_BIG
+	float *float_to_write = (float *)malloc(sizeof(float) * count);
+	memcpy(float_to_write, pFloat, sizeof(float) * count);
+
+	flipToLittleEndian(float_to_write, sizeof(float), count);
+	writeData(float_to_write, sizeof(float), count);
+
+	free(float_to_write);
 # 	else
-		WriteData(pFloat, sizeof(float), count);
-#	endif
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::WriteArray(const uint16* const pShort, size_t count = 1)
-	{
-#	if GEO_ENDIAN == GEO_ENDIAN_BIG
-		unsigned short *short_to_write = (unsigned short *)malloc(sizeof(unsigned short) * count);
-		memcpy(short_to_write, pShort, sizeof(unsigned short) * count);
-
-		flipToLittleEndian(short_to_write, sizeof(unsigned short), count);
-		WriteData(short_to_write, sizeof(unsigned short), count);
-
-		free(short_to_write);
+	WriteData(pFloat, sizeof(float), count);
+#	endif
+}
+
+//---------------------------------------------------------------------------
+//	Write array of shots.
+//---------------------------------------------------------------------------
+void Serializer::WriteArray(const uint16* const pShort, size_t count = 1)
+{
+#	if GEO_ENDIAN == GEO_ENDIAN_BIG
+	unsigned short *short_to_write = (unsigned short *)malloc(sizeof(unsigned short) * count);
+	memcpy(short_to_write, pShort, sizeof(unsigned short) * count);
+
+	flipToLittleEndian(short_to_write, sizeof(unsigned short), count);
+	WriteData(short_to_write, sizeof(unsigned short), count);
+
+	free(short_to_write);
 # 	else
-		WriteData(pShort, sizeof(unsigned short), count);
-#	endif
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::WriteArray(const uint32* const pInt, size_t count = 1)
-	{
-#	if GEO_ENDIAN == GEO_ENDIAN_BIG
-		unsigned int *int_to_write = (unsigned int *)malloc(sizeof(unsigned int) * count);
-		memcpy(int_to_write, pInt, sizeof(unsigned int) * count);
-
-		FlipToLittleEndian(int_to_write, sizeof(unsigned int), count);
-		WriteData(int_to_write, sizeof(unsigned int), count);
-
-		free(int_to_write);
+	WriteData(pShort, sizeof(unsigned short), count);
+#	endif
+}
+	
+//---------------------------------------------------------------------------
+//	Write array of integers.
+//---------------------------------------------------------------------------
+void Serializer::WriteArray(const uint32* const pInt, size_t count = 1)
+{
+#	if GEO_ENDIAN == GEO_ENDIAN_BIG
+	unsigned int *int_to_write = (unsigned int *)malloc(sizeof(unsigned int) * count);
+	memcpy(int_to_write, pInt, sizeof(unsigned int) * count);
+
+	FlipToLittleEndian(int_to_write, sizeof(unsigned int), count);
+	WriteData(int_to_write, sizeof(unsigned int), count);
+
+	free(int_to_write);
 # 	else
-		WriteData(pInt, sizeof(unsigned int), count);
-#	endif
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::WriteArray(const bool* const pBool, size_t count = 1)
-	{
-		//TODO: Apple has problems 
-		WriteData(pBool, sizeof(bool), count);
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::WriteArray(const Vector3* const pDest, size_t count)
-	{
-		for(size_t i = 0; i < count; ++i)
-		{
-			WriteArray(pDest[i].val,3);
-		}
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::WriteArray(const Vector2* const pDest, size_t count)
-	{
-		for(size_t i = 0; i < count; ++i)
-		{
-			WriteArray(pDest[i].val,2);
-		}
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::WriteData(const void* const buf, size_t size, size_t count)
-	{
-		size_t wcount = fwrite((void* const)buf, size, count, mFile);
-		assert(wcount == count);
-		mSize += size*count;
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::ReadData(void *pDest, size_t size, size_t count)
-	{
-		size_t rcount = fread(pDest,size,count,mFile);
-		assert(rcount == count);
-		mSize += size*count;
-	};
-
-
-	// JGA
-	char * Serializer::miReadData(char *pDest, size_t pDestsize)
-	{
-		return fgets(pDest, (int)pDestsize, mFile);
-	};
-
-	void Serializer::miReadData2(void *pDest, size_t size, size_t count)
-	{
-		size_t rcount = fread(pDest,size,count,mFile);
-		assert(rcount == count);
-		mSize += size*count;
-	};
-	// fin JGA
-
-	//	GPR.
-	void	Serializer::WriteData(const	String	&string)
-	{
-		fputs(string.c_str(), mFile);
-
-		// Write terminating newline char
-		//fputc('\n', mFile);
-
-		mSize	+=	string.length();
-	}
-	//	fin	GPR
-
-	void	Serializer::WriteData(const char	*string)
-	{
-		fputs(string, mFile);
-
-		// Write terminating newline char
-		//fputc('\n', mFile);
-
-		mSize	+=	strlen(string) /*+ 1*/;
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::ReadArray(bool *pDest, size_t count)
-	{
-		//TODO:: Apple has problmes with bools
-		ReadData(pDest,sizeof(bool), count);
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::ReadArray(float *pDest, size_t count)
-	{
-		ReadData(pDest, sizeof(float), count);
-		FlipFromLittleEndian(pDest, sizeof(float), count);
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::ReadArray(unsigned short *pDest, size_t count)
-	{
-		ReadData(pDest, sizeof(unsigned short), count);
-		FlipFromLittleEndian(pDest, sizeof(unsigned short), count);
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::ReadArray(unsigned int *pDest, size_t count)
-	{
-		ReadData(pDest, sizeof(unsigned int), count);
-		FlipFromLittleEndian(pDest, sizeof(unsigned int), count);
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::ReadArray(Vector3 *pDest, size_t count)
-	{
-		for(size_t i = 0; i < count; ++i)
-		{
-			ReadArray(pDest[i].val,3);
-		}
-	}
-	
-	//---------------------------------------------------------------------
-	void Serializer::ReadArray(Vector2 *pDest, size_t count)
-	{
-		for(size_t i = 0; i < count; ++i)
-		{
-			ReadArray(pDest[i].val,2);
-		}
-	}
-
-	//---------------------------------------------------------------------
-	void Serializer::FlipToLittleEndian(void *pData, size_t size, size_t count)
-	{
-#	if GEO_ENDIAN == GEO_ENDIAN_BIG
-		FlipEndian(pData, size, count);
-#	endif
-	}
-
-	void Serializer::FlipFromLittleEndian(void *pData, size_t size, size_t count)
-	{
-#	if GEO_ENDIAN == GEO_ENDIAN_BIG
-		FlipEndian(pData, size, count);
-#	endif
-	}
-
-	void Serializer::FlipEndian(void *pData, size_t size, size_t count)
-	{
-		for(unsigned int index = 0; index < count; index++)
-		{
-			FlipEndian((void *)((char*)pData + (index * size)), size);
-		}
-	}
-
-	void Serializer::FlipEndian(void *pData, size_t size)
-	{
-		char swapByte;
-		for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++)
-		{
-			swapByte = *((char *)pData + byteIndex);
-			*((char *)pData + byteIndex) = *((char *)pData + size - byteIndex - 1);
-			*((char *)pData + size - byteIndex - 1) = swapByte;
-		}
-	}
-
-}
-
+	WriteData(pInt, sizeof(unsigned int), count);
+#	endif
+}
+
+//---------------------------------------------------------------------------
+//	Write array of booleans.
+//---------------------------------------------------------------------------
+void Serializer::WriteArray(const bool* const pBool, size_t count = 1)
+{
+	//TODO: Apple has problems 
+	WriteData(pBool, sizeof(bool), count);
+}
+	
+//---------------------------------------------------------------------------
+//	Write array of Vector3.
+//---------------------------------------------------------------------------
+void Serializer::WriteArray(const Vector3* const pDest, size_t count)
+{
+	for(size_t i = 0; i < count; ++i)
+	{
+		WriteArray(pDest[i].val,3);
+	}
+}
+	
+//---------------------------------------------------------------------------
+//	Write array of Vector2.
+//---------------------------------------------------------------------------
+void Serializer::WriteArray(const Vector2* const pDest, size_t count)
+{
+	for(size_t i = 0; i < count; ++i)
+	{
+		WriteArray(pDest[i].val,2);
+	}
+}
+
+//---------------------------------------------------------------------------
+//	Write data.
+//---------------------------------------------------------------------------
+void Serializer::WriteData(const void* const buf, size_t size, size_t count)
+{
+	size_t wcount = fwrite((void* const)buf, size, count, mFile);
+	assert(wcount == count);
+	mSize += size*count;
+}
+
+//---------------------------------------------------------------------------
+//	Read data.
+//---------------------------------------------------------------------------
+void Serializer::ReadData(void *pDest, size_t size, size_t count)
+{
+	size_t rcount = fread(pDest,size,count,mFile);
+	assert(rcount == count);
+	mSize += size*count;
+}
+
+//---------------------------------------------------------------------------
+//	Read data.
+//---------------------------------------------------------------------------
+char * Serializer::ReadData(char *pDest, size_t pDestsize)
+{
+	return fgets(pDest, (int)pDestsize, mFile);
+}
+
+//---------------------------------------------------------------------------
+//	Write data.
+//---------------------------------------------------------------------------
+void	Serializer::WriteData(const	String	&string)
+{
+	fputs(string.c_str(), mFile);
+
+	// Write terminating newline char
+	//fputc('\n', mFile);
+
+	mSize	+=	string.length();
+}
+
+//---------------------------------------------------------------------------
+//	Write string data.
+//---------------------------------------------------------------------------
+void	Serializer::WriteData(const char	*string)
+{
+	fputs(string, mFile);
+
+	// Write terminating newline char
+	//fputc('\n', mFile);
+
+	mSize	+=	strlen(string) /*+ 1*/;
+}
+
+//---------------------------------------------------------------------------
+//	Read array of booleans.
+//---------------------------------------------------------------------------
+void Serializer::ReadArray(bool *pDest, size_t count)
+{
+	//TODO:: Apple has problmes with bools
+	ReadData(pDest,sizeof(bool), count);
+}
+
+//---------------------------------------------------------------------------
+//	Read array of floats.
+//---------------------------------------------------------------------------
+void Serializer::ReadArray(float *pDest, size_t count)
+{
+	ReadData(pDest, sizeof(float), count);
+	FlipFromLittleEndian(pDest, sizeof(float), count);
+}
+	
+//---------------------------------------------------------------------------
+//	Read array of unsigned shots.
+//---------------------------------------------------------------------------
+void Serializer::ReadArray(unsigned short *pDest, size_t count)
+{
+	ReadData(pDest, sizeof(unsigned short), count);
+	FlipFromLittleEndian(pDest, sizeof(unsigned short), count);
+}
+	
+//---------------------------------------------------------------------------
+//	Read array of unsigned integers.
+//---------------------------------------------------------------------------
+void Serializer::ReadArray(unsigned int *pDest, size_t count)
+{
+	ReadData(pDest, sizeof(unsigned int), count);
+	FlipFromLittleEndian(pDest, sizeof(unsigned int), count);
+}
+	
+//---------------------------------------------------------------------------
+//	Read array of Vector3.
+//---------------------------------------------------------------------------
+void Serializer::ReadArray(Vector3 *pDest, size_t count)
+{
+	for(size_t i = 0; i < count; ++i)
+	{
+		ReadArray(pDest[i].val,3);
+	}
+}
+	
+//---------------------------------------------------------------------------
+//	Read array of Vector2.
+//---------------------------------------------------------------------------
+void Serializer::ReadArray(Vector2 *pDest, size_t count)
+{
+	for(size_t i = 0; i < count; ++i)
+	{
+		ReadArray(pDest[i].val,2);
+	}
+}
+
+//---------------------------------------------------------------------------
+//	Flip to Little Endian.
+//---------------------------------------------------------------------------
+void Serializer::FlipToLittleEndian(void *pData, size_t size, size_t count)
+{
+#	if GEO_ENDIAN == GEO_ENDIAN_BIG
+	FlipEndian(pData, size, count);
+#	endif
+}
+
+//---------------------------------------------------------------------------
+//	Flip from Little Endian.
+//---------------------------------------------------------------------------
+void Serializer::FlipFromLittleEndian(void *pData, size_t size, size_t count)
+{
+#	if GEO_ENDIAN == GEO_ENDIAN_BIG
+	FlipEndian(pData, size, count);
+#	endif
+}
+
+//---------------------------------------------------------------------------
+//	Flip Endian.
+//---------------------------------------------------------------------------
+void Serializer::FlipEndian(void *pData, size_t size, size_t count)
+{
+	for(unsigned int index = 0; index < count; index++)
+	{
+		FlipEndian((void *)((char*)pData + (index * size)), size);
+	}
+}
+
+//---------------------------------------------------------------------------
+//	Flip Endian.
+//---------------------------------------------------------------------------
+void Serializer::FlipEndian(void *pData, size_t size)
+{
+	char swapByte;
+	for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++)
+	{
+		swapByte = *((char *)pData + byteIndex);
+		*((char *)pData + byteIndex) = *((char *)pData + size - byteIndex - 1);
+		*((char *)pData + size - byteIndex - 1) = swapByte;
+	}
+}
+
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/include/change.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/include/change.h	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/include/change.h	(revision 1009)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/change.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/change.cpp	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/change.cpp	(revision 1009)
@@ -369,2 +369,3 @@
 	mVMISteps.push_back(step);
 }
+
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimpSequence.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimpSequence.cpp	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimpSequence.cpp	(revision 1009)
@@ -20,5 +20,5 @@
 	char name[256];
 
-	if (s.miReadData(buffer,256) != NULL)
+	if (s.ReadData(buffer,256) != NULL)
 	{
 		sscanf(buffer,"%s",&name);
@@ -27,5 +27,5 @@
 	}
 
-	while (s.miReadData(buffer,256) != NULL)
+	while (s.ReadData(buffer,256) != NULL)
 	{
 		Geometry::MeshSimplificationSequence::Step simplifstep;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimplifier.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimplifier.cpp	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimplifier.cpp	(revision 1009)
@@ -310,8 +310,4 @@
 	msimpsequence	=	new MeshSimplificationSequence();
 	
-	//	Debug.
-	cout	<<	"GetMeshsimpSequence VMI"
-				<<	endl;
-
 	//	For each simplification step.
 	for (unsigned	int i = 0;	i < VMI::mVMISteps.size();	i++)
@@ -336,10 +332,4 @@
 		}
 		
-		//	Debug.
-		cout	<<	"Step "
-					<<	i
-					<<	" added."
-					<<	endl;
-		
 		msimpsequence->mSteps.push_back(current_step);
 	}
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoTreeSimpSequence.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoTreeSimpSequence.cpp	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoTreeSimpSequence.cpp	(revision 1009)
@@ -23,5 +23,5 @@
 	int cont; 
 
-	if (s.miReadData(buffer,256) != NULL) 
+	if (s.ReadData(buffer,256) != NULL) 
 	{
 		sscanf(buffer,"%s",&nombre);
@@ -30,5 +30,5 @@
 	}
 
-	while (s.miReadData(buffer,256) != NULL) 
+	while (s.ReadData(buffer,256) != NULL) 
 	{
 		Geometry::TreeSimplificationSequence::Step pasosimp;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMesh.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMesh.cpp	(revision 986)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMesh.cpp	(revision 1009)
@@ -10,10 +10,10 @@
 	mVertexBuffer(0), mSubMeshCount(0), mSubMesh(0), hasSkeleton(false)
 {
-	mMeshBounds.maxX					=	0.0;
-	mMeshBounds.maxY					=	0.0;
-	mMeshBounds.maxZ					=	0.0;
-	mMeshBounds.minX					=	0.0;
-	mMeshBounds.minY					=	0.0;
-	mMeshBounds.minZ					=	0.0;
+	mMeshBounds.maxX				=	0.0;
+	mMeshBounds.maxY				=	0.0;
+	mMeshBounds.maxZ				=	0.0;
+	mMeshBounds.minX				=	0.0;
+	mMeshBounds.minY				=	0.0;
+	mMeshBounds.minZ				=	0.0;
 	mMeshBounds.scaleFactor	=	0.0;
 }
@@ -24,98 +24,92 @@
 Mesh::~Mesh()
 {
-	delete[] mSubMesh;
-	delete mVertexBuffer;
-}
-
+	delete	[]	mSubMesh;
+	delete 	mVertexBuffer;
+}
 
 //---------------------------------------------------------------------------
 //	Copy constructor.
 //---------------------------------------------------------------------------
-Mesh::Mesh(const Mesh &objmesh) 
-{
-	// constructor copia
+Mesh::Mesh(const Mesh &mesh)
+{
 	mVertexBuffer	=	new VertexBuffer();
-	mSubMeshCount	=	objmesh.mSubMeshCount;
-	mSubMesh			=	new SubMesh[objmesh.mSubMeshCount];
+	mSubMeshCount	=	mesh.mSubMeshCount;
+	mSubMesh			=	new SubMesh[mesh.mSubMeshCount];
 
 	//	Fill up bounding box settings.
-	mMeshBounds.maxX					=	objmesh.mMeshBounds.maxX;
-	mMeshBounds.maxY					=	objmesh.mMeshBounds.maxY;
-	mMeshBounds.maxZ					=	objmesh.mMeshBounds.maxZ;
-	mMeshBounds.minX					=	objmesh.mMeshBounds.minX;
-	mMeshBounds.minY					=	objmesh.mMeshBounds.minY;
-	mMeshBounds.minZ					=	objmesh.mMeshBounds.minZ;
-	mMeshBounds.radius				=	objmesh.mMeshBounds.radius;
-	mMeshBounds.scaleFactor		=	objmesh.mMeshBounds.scaleFactor;
+	mMeshBounds.maxX					=	mesh.mMeshBounds.maxX;
+	mMeshBounds.maxY					=	mesh.mMeshBounds.maxY;
+	mMeshBounds.maxZ					=	mesh.mMeshBounds.maxZ;
+	mMeshBounds.minX					=	mesh.mMeshBounds.minX;
+	mMeshBounds.minY					=	mesh.mMeshBounds.minY;
+	mMeshBounds.minZ					=	mesh.mMeshBounds.minZ;
+	mMeshBounds.radius				=	mesh.mMeshBounds.radius;
+	mMeshBounds.scaleFactor		=	mesh.mMeshBounds.scaleFactor;
 	
 	//	For each submesh.
-	for(size_t i = 0; i < objmesh.mSubMeshCount; i++)
+	for (size_t i = 0; i < mesh.mSubMeshCount; i++)
 	{
 		mSubMesh[i].mSharedVertexBuffer					=	false;
 		mSubMesh[i].mVertexBuffer								=	new VertexBuffer();
-		mSubMesh[i].mVertexBuffer->mPosition		=	new Vector3[objmesh.mSubMesh[i].mVertexBuffer->mVertexCount];
-		mSubMesh[i].mVertexBuffer->mNormal			=	new Vector3[objmesh.mSubMesh[i].mVertexBuffer->mVertexCount];
-		mSubMesh[i].mVertexBuffer->mTexCoords 	= new Vector2[objmesh.mSubMesh[i].mVertexBuffer->mVertexCount];
-		mSubMesh[i].mVertexBuffer->mVertexCount =	objmesh.mSubMesh[i].mVertexBuffer->mVertexCount;
-		mSubMesh[i].mVertexBuffer->mVertexInfo	=	objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo;
-		mSubMesh[i].mType												=	objmesh.mSubMesh[i].mType;
-		strcpy(mSubMesh[i].mMaterialName,objmesh.mSubMesh[i].mMaterialName);
-		
-		if(objmesh.mSubMesh[i].mSharedVertexBuffer) 
-		{
-			for(size_t s	=	0;
-					s<objmesh.mSubMesh[i].mVertexBuffer->mVertexCount;
+		mSubMesh[i].mVertexBuffer->mPosition		=	new Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
+		mSubMesh[i].mVertexBuffer->mNormal			=	new Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
+		mSubMesh[i].mVertexBuffer->mTexCoords 	= new Vector2[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
+		mSubMesh[i].mVertexBuffer->mVertexCount =	mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
+		mSubMesh[i].mVertexBuffer->mVertexInfo	=	mesh.mSubMesh[i].mVertexBuffer->mVertexInfo;
+		mSubMesh[i].mType												=	mesh.mSubMesh[i].mType;
+
+		strcpy(mSubMesh[i].mMaterialName,mesh.mSubMesh[i].mMaterialName);
+		
+		if (mesh.mSubMesh[i].mSharedVertexBuffer)
+		{
+			for (size_t	s	=	0;
+					s < mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
 					s++)
 			{
-				//	Copy mPosition.
-				if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_POSITION)
+				if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_POSITION)
 				{
-					mSubMesh[i].mVertexBuffer->mPosition[s].x = objmesh.mVertexBuffer->mPosition[s].x;
-					mSubMesh[i].mVertexBuffer->mPosition[s].y = objmesh.mVertexBuffer->mPosition[s].y;
-					mSubMesh[i].mVertexBuffer->mPosition[s].z = objmesh.mVertexBuffer->mPosition[s].z;
+					mSubMesh[i].mVertexBuffer->mPosition[s].x	=	mesh.mVertexBuffer->mPosition[s].x;
+					mSubMesh[i].mVertexBuffer->mPosition[s].y	=	mesh.mVertexBuffer->mPosition[s].y;
+					mSubMesh[i].mVertexBuffer->mPosition[s].z	=	mesh.mVertexBuffer->mPosition[s].z;
 				}
 				
-				//	Copy mNormal.
-				if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_NORMAL)
+				if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_NORMAL)
 				{
-					mSubMesh[i].mVertexBuffer->mNormal[s].x = objmesh.mVertexBuffer->mNormal[s].x;
-					mSubMesh[i].mVertexBuffer->mNormal[s].y = objmesh.mVertexBuffer->mNormal[s].y;
-					mSubMesh[i].mVertexBuffer->mNormal[s].z = objmesh.mVertexBuffer->mNormal[s].z;
+					mSubMesh[i].mVertexBuffer->mNormal[s].x	=	mesh.mVertexBuffer->mNormal[s].x;
+					mSubMesh[i].mVertexBuffer->mNormal[s].y	=	mesh.mVertexBuffer->mNormal[s].y;
+					mSubMesh[i].mVertexBuffer->mNormal[s].z	=	mesh.mVertexBuffer->mNormal[s].z;
 				}
 
-				//	Copy mTexCoords.
-				if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_TEXCOORDS)
+				if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_TEXCOORDS)
 				{
-					mSubMesh[i].mVertexBuffer->mTexCoords[s].x = objmesh.mVertexBuffer->mTexCoords[s].x;
-					mSubMesh[i].mVertexBuffer->mTexCoords[s].y = objmesh.mVertexBuffer->mTexCoords[s].y;
+					mSubMesh[i].mVertexBuffer->mTexCoords[s].x	=	mesh.mVertexBuffer->mTexCoords[s].x;
+					mSubMesh[i].mVertexBuffer->mTexCoords[s].y	=	mesh.mVertexBuffer->mTexCoords[s].y;
 				}
 			}
-			objmesh.mSubMesh[i].mSharedVertexBuffer = false;
+			
+			mesh.mSubMesh[i].mSharedVertexBuffer	=	false;
 		}
 		else
 		{
-			for(size_t s = 0; s < objmesh.mSubMesh[i].mVertexBuffer->mVertexCount; s++)
-			{
-				//	Copy mPosition.
-				if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_POSITION)
+			for	(size_t s	=	0;	s < mesh.mSubMesh[i].mVertexBuffer->mVertexCount; s++)
+			{
+				if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_POSITION)
 				{
-					mSubMesh[i].mVertexBuffer->mPosition[s].x = objmesh.mSubMesh[i].mVertexBuffer->mPosition[s].x;
-					mSubMesh[i].mVertexBuffer->mPosition[s].y = objmesh.mSubMesh[i].mVertexBuffer->mPosition[s].y;
-					mSubMesh[i].mVertexBuffer->mPosition[s].z = objmesh.mSubMesh[i].mVertexBuffer->mPosition[s].z;
+					mSubMesh[i].mVertexBuffer->mPosition[s].x	=	mesh.mSubMesh[i].mVertexBuffer->mPosition[s].x;
+					mSubMesh[i].mVertexBuffer->mPosition[s].y	=	mesh.mSubMesh[i].mVertexBuffer->mPosition[s].y;
+					mSubMesh[i].mVertexBuffer->mPosition[s].z	=	mesh.mSubMesh[i].mVertexBuffer->mPosition[s].z;
 				}
 				
-				//Copiamos mNormal
-				if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_NORMAL)
+				if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_NORMAL)
 				{
-					mSubMesh[i].mVertexBuffer->mNormal[s].x = objmesh.mSubMesh[i].mVertexBuffer->mNormal[s].x;
-					mSubMesh[i].mVertexBuffer->mNormal[s].y = objmesh.mSubMesh[i].mVertexBuffer->mNormal[s].y;
-					mSubMesh[i].mVertexBuffer->mNormal[s].z = objmesh.mSubMesh[i].mVertexBuffer->mNormal[s].z;
+					mSubMesh[i].mVertexBuffer->mNormal[s].x = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].x;
+					mSubMesh[i].mVertexBuffer->mNormal[s].y = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].y;
+					mSubMesh[i].mVertexBuffer->mNormal[s].z = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].z;
 				}
 
-				//Copiamos mTexCoords
-				if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_TEXCOORDS)
+				if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & VERTEX_TEXCOORDS)
 				{
-					mSubMesh[i].mVertexBuffer->mTexCoords[s].x = objmesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].x;
-					mSubMesh[i].mVertexBuffer->mTexCoords[s].y = objmesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].y;
+					mSubMesh[i].mVertexBuffer->mTexCoords[s].x = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].x;
+					mSubMesh[i].mVertexBuffer->mTexCoords[s].y = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].y;
 				}
 			}
@@ -124,29 +118,34 @@
 		
 		// Copy indices.
-		mSubMesh[i].mIndexCount	=	objmesh.mSubMesh[i].mIndexCount;
+		mSubMesh[i].mIndexCount	=	mesh.mSubMesh[i].mIndexCount;
 		mSubMesh[i].mIndex			=	new Index[mSubMesh[i].mIndexCount];
 		
-		memcpy(mSubMesh[i].mIndex,objmesh.mSubMesh[i].mIndex,objmesh.mSubMesh[i].mIndexCount*sizeof(Index));
+		memcpy(	mSubMesh[i].mIndex,
+						mesh.mSubMesh[i].mIndex,
+						mesh.mSubMesh[i].mIndexCount * sizeof(Index));
 
 		// Copy strips.
-		__w64 int offset	=	0; // offset between memory positions.
-		mSubMesh[i].mStripCount=objmesh.mSubMesh[i].mStripCount;
-		if (objmesh.mSubMesh[i].mStripCount>0) 
-		{
-			mSubMesh[i].mStrip = new Index*[objmesh.mSubMesh[i].mStripCount];
-
-			offset	= &(mSubMesh[i].mIndex[0]) - &(objmesh.mSubMesh[i].mIndex[0]);
-			for (size_t j=0;j<objmesh.mSubMesh[i].mStripCount;j++)
-			{
-				mSubMesh[i].mStrip[j]=objmesh.mSubMesh[i].mStrip[j] + offset;
+		// offset between memory positions.
+		__w64	int	offset				=	0; 
+		mSubMesh[i].mStripCount	=	mesh.mSubMesh[i].mStripCount;
+		
+		if (mesh.mSubMesh[i].mStripCount > 0)
+		{
+			mSubMesh[i].mStrip	=	new Index*[mesh.mSubMesh[i].mStripCount];
+
+			offset	= &(mSubMesh[i].mIndex[0]) - &(mesh.mSubMesh[i].mIndex[0]);
+			
+			for (size_t	j	=	0;	j < mesh.mSubMesh[i].mStripCount;	j++)
+			{
+				mSubMesh[i].mStrip[j]	=	mesh.mSubMesh[i].mStrip[j] + offset;
 			}
 		}
 
 		//	Copy submesh bones.
-		if (!objmesh.mSubMesh[i].mBones.empty())
-		{
-			for (unsigned int j = 0; j < objmesh.mSubMesh[i].mBones.size(); j++)
-			{
-				mSubMesh[i].mBones.push_back(objmesh.mSubMesh[i].mBones[j]);
+		if (!mesh.mSubMesh[i].mBones.empty())
+		{
+			for (unsigned int j = 0; j < mesh.mSubMesh[i].mBones.size(); j++)
+			{
+				mSubMesh[i].mBones.push_back(mesh.mSubMesh[i].mBones[j]);
 			}
 		}
@@ -154,17 +153,17 @@
 	
 	//	Copy skeleton name.
-	if (objmesh.hasSkeleton)
+	if (mesh.hasSkeleton)
 	{
 		hasSkeleton	=	true;
 		
-		strcpy(mSkeletonName,objmesh.mSkeletonName);
+		strcpy(mSkeletonName,	mesh.mSkeletonName);
 	}
 
 	//	Copy mesh bones.
-	if (!objmesh.mBones.empty())
-	{
-		for (unsigned int j = 0; j < objmesh.mBones.size(); j++)
-		{
-			mBones.push_back(objmesh.mBones[j]);
+	if (!mesh.mBones.empty())
+	{
+		for (unsigned	int	j	=	0;	j < mesh.mBones.size();	j++)
+		{
+			mBones.push_back(mesh.mBones[j]);
 		}
 	}
@@ -175,95 +174,92 @@
 //	Assignment operator.
 //---------------------------------------------------------------------------
-Mesh &Mesh::operator =(const Geometry::Mesh &objmesh)
-{
-	// Operador de asignación
-	bool copiados	=	false; // indica si los vértices compartidos han sido copiados
+Mesh &Mesh::operator =(const	Mesh &mesh)
+{
+	bool copied		=	false;
 	mVertexBuffer	=	new VertexBuffer();
-	mSubMeshCount	=	objmesh.mSubMeshCount;
-	mSubMesh			=	new Geometry::SubMesh[objmesh.mSubMeshCount];
+	mSubMeshCount	=	mesh.mSubMeshCount;
+	mSubMesh			=	new Geometry::SubMesh[mesh.mSubMeshCount];
 	
 	//	Fill up bounding box settings.
-	mMeshBounds.maxX					=	objmesh.mMeshBounds.maxX;
-	mMeshBounds.maxY					=	objmesh.mMeshBounds.maxY;
-	mMeshBounds.maxZ					=	objmesh.mMeshBounds.maxZ;
-	mMeshBounds.minX					=	objmesh.mMeshBounds.minX;
-	mMeshBounds.minY					=	objmesh.mMeshBounds.minY;
-	mMeshBounds.minZ					=	objmesh.mMeshBounds.minZ;
-	mMeshBounds.radius				=	objmesh.mMeshBounds.radius;
-	mMeshBounds.scaleFactor		=	objmesh.mMeshBounds.scaleFactor;
+	mMeshBounds.maxX					=	mesh.mMeshBounds.maxX;
+	mMeshBounds.maxY					=	mesh.mMeshBounds.maxY;
+	mMeshBounds.maxZ					=	mesh.mMeshBounds.maxZ;
+	mMeshBounds.minX					=	mesh.mMeshBounds.minX;
+	mMeshBounds.minY					=	mesh.mMeshBounds.minY;
+	mMeshBounds.minZ					=	mesh.mMeshBounds.minZ;
+	mMeshBounds.radius				=	mesh.mMeshBounds.radius;
+	mMeshBounds.scaleFactor		=	mesh.mMeshBounds.scaleFactor;
 
 	//	For each submesh.
-	for(size_t i = 0; i < objmesh.mSubMeshCount; i++)
-	{
-		mSubMesh[i].mSharedVertexBuffer					=	objmesh.mSubMesh[i].mSharedVertexBuffer; //.false;
+	for(size_t	i	=	0;	i < mesh.mSubMeshCount;	i++)
+	{
+		mSubMesh[i].mSharedVertexBuffer					=	mesh.mSubMesh[i].mSharedVertexBuffer; //.false;
 		mSubMesh[i].mVertexBuffer								=	new Geometry::VertexBuffer();
-		mSubMesh[i].mVertexBuffer->mPosition		=	new Geometry::Vector3[objmesh.mSubMesh[i].mVertexBuffer->mVertexCount];
-		mSubMesh[i].mVertexBuffer->mNormal			=	new Geometry::Vector3[objmesh.mSubMesh[i].mVertexBuffer->mVertexCount];
-		mSubMesh[i].mVertexBuffer->mTexCoords		=	new Geometry::Vector2[objmesh.mSubMesh[i].mVertexBuffer->mVertexCount];
-		mSubMesh[i].mVertexBuffer->mVertexCount	=	objmesh.mSubMesh[i].mVertexBuffer->mVertexCount;
-		mSubMesh[i].mVertexBuffer->mVertexInfo	=	objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo;
-		mSubMesh[i].mType					=	objmesh.mSubMesh[i].mType;
-		strcpy(mSubMesh[i].mMaterialName,objmesh.mSubMesh[i].mMaterialName);
-
-		if (objmesh.mSubMesh[i].mSharedVertexBuffer && !copiados)
+		mSubMesh[i].mVertexBuffer->mPosition		=	new Geometry::Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
+		mSubMesh[i].mVertexBuffer->mNormal			=	new Geometry::Vector3[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
+		mSubMesh[i].mVertexBuffer->mTexCoords		=	new Geometry::Vector2[mesh.mSubMesh[i].mVertexBuffer->mVertexCount];
+		mSubMesh[i].mVertexBuffer->mVertexCount	=	mesh.mSubMesh[i].mVertexBuffer->mVertexCount;
+		mSubMesh[i].mVertexBuffer->mVertexInfo	=	mesh.mSubMesh[i].mVertexBuffer->mVertexInfo;
+		mSubMesh[i].mType												=	mesh.mSubMesh[i].mType;
+		strcpy(mSubMesh[i].mMaterialName,mesh.mSubMesh[i].mMaterialName);
+
+		if (mesh.mSubMesh[i].mSharedVertexBuffer && !copied)
 		{
 			mVertexBuffer	=	mSubMesh[i].mVertexBuffer;
-			copiados			=	true;
-		}
-
-		for(size_t s = 0; s < objmesh.mSubMesh[i].mVertexBuffer->mVertexCount; s++)
-		{
-			//Copiamos mPosition
-			//if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_POSITION)
-			//{
-				mSubMesh[i].mVertexBuffer->mPosition[s].x = objmesh.mSubMesh[i].mVertexBuffer->mPosition[s].x;
-				mSubMesh[i].mVertexBuffer->mPosition[s].y = objmesh.mSubMesh[i].mVertexBuffer->mPosition[s].y;
-				mSubMesh[i].mVertexBuffer->mPosition[s].z = objmesh.mSubMesh[i].mVertexBuffer->mPosition[s].z;
-			//}
-			//Copiamos mNormal
-			if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
-			{
-				mSubMesh[i].mVertexBuffer->mNormal[s].x = objmesh.mSubMesh[i].mVertexBuffer->mNormal[s].x;
-				mSubMesh[i].mVertexBuffer->mNormal[s].y = objmesh.mSubMesh[i].mVertexBuffer->mNormal[s].y;
-				mSubMesh[i].mVertexBuffer->mNormal[s].z = objmesh.mSubMesh[i].mVertexBuffer->mNormal[s].z;
-			}
-
-			//Copiamos mTexCoords
-			if (objmesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
-			{
-				mSubMesh[i].mVertexBuffer->mTexCoords[s].x = objmesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].x;
-				mSubMesh[i].mVertexBuffer->mTexCoords[s].y = objmesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].y;
-			}
-		}
-
-		// Copiar los indices
-		mSubMesh[i].mIndexCount	=	objmesh.mSubMesh[i].mIndexCount;
+			copied				=	true;
+		}
+
+		for(size_t s = 0; s < mesh.mSubMesh[i].mVertexBuffer->mVertexCount; s++)
+		{
+			mSubMesh[i].mVertexBuffer->mPosition[s].x = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].x;
+			mSubMesh[i].mVertexBuffer->mPosition[s].y = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].y;
+			mSubMesh[i].mVertexBuffer->mPosition[s].z = mesh.mSubMesh[i].mVertexBuffer->mPosition[s].z;
+
+			if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
+			{
+				mSubMesh[i].mVertexBuffer->mNormal[s].x = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].x;
+				mSubMesh[i].mVertexBuffer->mNormal[s].y = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].y;
+				mSubMesh[i].mVertexBuffer->mNormal[s].z = mesh.mSubMesh[i].mVertexBuffer->mNormal[s].z;
+			}
+
+			if (mesh.mSubMesh[i].mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
+			{
+				mSubMesh[i].mVertexBuffer->mTexCoords[s].x = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].x;
+				mSubMesh[i].mVertexBuffer->mTexCoords[s].y = mesh.mSubMesh[i].mVertexBuffer->mTexCoords[s].y;
+			}
+		}
+
+		//	Copy indices.
+		mSubMesh[i].mIndexCount	=	mesh.mSubMesh[i].mIndexCount;
 		mSubMesh[i].mIndex			=	new Index[mSubMesh[i].mIndexCount];
 
 		memcpy(	mSubMesh[i].mIndex,
-						objmesh.mSubMesh[i].mIndex,
-						objmesh.mSubMesh[i].mIndexCount*sizeof(Geometry::Index));
-
-		// Copiar las tiras
-		__w64 offset	=	0; // desplazamiento entre posiciones de memoria.
-		mSubMesh[i].mStripCount	=	objmesh.mSubMesh[i].mStripCount;
-
-		if (objmesh.mSubMesh[i].mStripCount>0) 
-		{
-			mSubMesh[i].mStrip	=	new Index*[objmesh.mSubMesh[i].mStripCount];
-			offset	=	&(mSubMesh[i].mIndex[0]) - &(objmesh.mSubMesh[i].mIndex[0]);
-			
-			for (size_t j = 0; j < objmesh.mSubMesh[i].mStripCount; j++)
-			{
-				mSubMesh[i].mStrip[j]	=	objmesh.mSubMesh[i].mStrip[j] + offset;
+						mesh.mSubMesh[i].mIndex,
+						mesh.mSubMesh[i].mIndexCount*sizeof(Geometry::Index));
+
+		// Copy strips.
+		__w64 offset						=	0;
+		mSubMesh[i].mStripCount	=	mesh.mSubMesh[i].mStripCount;
+
+		if (mesh.mSubMesh[i].mStripCount > 0)
+		{
+			mSubMesh[i].mStrip	=	new Index*[mesh.mSubMesh[i].mStripCount];
+
+			offset							=	&(mSubMesh[i].mIndex[0])
+														-
+														&(mesh.mSubMesh[i].mIndex[0]);
+			
+			for (size_t	j	=	0;	j < mesh.mSubMesh[i].mStripCount;	j++)
+			{
+				mSubMesh[i].mStrip[j]	=	mesh.mSubMesh[i].mStrip[j] + offset;
 			}
 		}
 		
 		//	Copy submesh bones.
-		if (!objmesh.mSubMesh[i].mBones.empty())
-		{
-			for (unsigned int j = 0; j < objmesh.mSubMesh[i].mBones.size(); j++)
-			{
-				mSubMesh[i].mBones.push_back(objmesh.mSubMesh[i].mBones[j]);
+		if (!mesh.mSubMesh[i].mBones.empty())
+		{
+			for (unsigned	int	j	=	0;	j < mesh.mSubMesh[i].mBones.size();	j++)
+			{
+				mSubMesh[i].mBones.push_back(mesh.mSubMesh[i].mBones[j]);
 			}
 		}
@@ -271,17 +267,17 @@
 
 	//	Copy skeleton name.
-	if (objmesh.hasSkeleton)
+	if (mesh.hasSkeleton)
 	{
 		hasSkeleton	=	true;
 		
-		strcpy(mSkeletonName,objmesh.mSkeletonName);
+		strcpy(mSkeletonName,	mesh.mSkeletonName);
 	}
 
 	//	Copy mesh bones.
-	if (!objmesh.mBones.empty())
-	{
-		for (unsigned int j = 0; j < objmesh.mBones.size(); j++)
-		{
-			mBones.push_back(objmesh.mBones[j]);
+	if (!mesh.mBones.empty())
+	{
+		for (unsigned	int	j	=	0;	j < mesh.mBones.size();	j++)
+		{
+			mBones.push_back(mesh.mBones[j]);
 		}
 	}
@@ -297,10 +293,16 @@
 	bool sharedVertexBuffer	= false;
 
-	//Clear Data
-	delete[] mSubMesh;  mSubMesh = 0;
-	delete   mVertexBuffer; mVertexBuffer = 0;
+	//	Clear Data.
+	delete	[]	mSubMesh;
+	
+	mSubMesh = 0;
+	
+	delete	mVertexBuffer;
+	
+	mVertexBuffer = 0;
 	mSubMeshCount = 0;
 	
 	s.ReadArray(&sharedVertexBuffer,1);
+	
 	if (sharedVertexBuffer)
 	{
@@ -308,12 +310,16 @@
 		mVertexBuffer->Load(s);
 	}
-	s.ReadArray(&mSubMeshCount,1);
-	mSubMesh = new SubMesh[mSubMeshCount];
-	for(size_t i = 0; i < mSubMeshCount; ++i)
+	
+	s.ReadArray(&mSubMeshCount,	1);
+	
+	mSubMesh	=	new SubMesh[mSubMeshCount];
+	
+	for(size_t	i	=	0;	i < mSubMeshCount;	i++)
 	{
 		mSubMesh[i].Load(s);
+		
 		if (mSubMesh[i].mSharedVertexBuffer && sharedVertexBuffer)
 		{
-			mSubMesh[i].mVertexBuffer = mVertexBuffer;
+			mSubMesh[i].mVertexBuffer	=	mVertexBuffer;
 		}
 	}
@@ -325,12 +331,16 @@
 void Mesh::Save(Serializer &s)
 {
-	bool sharedVertexBuffer = (mVertexBuffer != 0);
+	bool sharedVertexBuffer	=	(mVertexBuffer != 0);
+	
 	s.WriteArray(&sharedVertexBuffer, 1);
+	
 	if (sharedVertexBuffer)
 	{
 		mVertexBuffer->Save(s);
 	}
+	
 	s.WriteArray(&mSubMeshCount,1);
-	for(size_t i = 0; i < mSubMeshCount; ++i)
+	
+	for(size_t	i	=	0;	i < mSubMeshCount;	i++)
 	{
 		mSubMesh[i].Save(s);
@@ -341,34 +351,43 @@
 //	Export to obj mesh.
 //---------------------------------------------------------------------------
-void Mesh::exportToOBJ(char *nomfich)
-{
-	// Genera un fichero obj con vértices, triángulos
-
-	std::ofstream obj(nomfich);
+void Mesh::exportToOBJ(char *fileName)
+{
+	std::ofstream obj(fileName);
+	
 	obj << "begin" << std::endl;
-	// Vértices
-	for (size_t i=0; i < mSubMeshCount; i++) 
-	{
-		for (size_t j=0; j < mSubMesh[i].mVertexBuffer->mVertexCount; j++) 
+
+	// Vertices.
+	for (size_t	i	=	0;	i < mSubMeshCount;	i++)
+	{
+		for (size_t	j	=	0;	j < mSubMesh[i].mVertexBuffer->mVertexCount;	j++)
 		{	
-			obj << "v " <<  mSubMesh[i].mVertexBuffer->mPosition[j].x << " " <<
-				mSubMesh[i].mVertexBuffer->mPosition[j].y << " " <<
-				mSubMesh[i].mVertexBuffer->mPosition[j].z << " " << std::endl;
-		}
-	}
-
-
-	// Caras
-	for (size_t i=0; i < mSubMeshCount; i++) 
-	{
-		for (size_t j=0; j < mSubMesh[i].mIndexCount; j=j+3) 
+			obj	<<	"v "
+					<<	mSubMesh[i].mVertexBuffer->mPosition[j].x
+					<<	" "
+					<<	mSubMesh[i].mVertexBuffer->mPosition[j].y
+					<<	" "
+					<<	mSubMesh[i].mVertexBuffer->mPosition[j].z
+					<<	" "
+					<<	std::endl;
+		}
+	}
+
+	// Faces.
+	for (size_t	i	=	0;	i < mSubMeshCount;	i++)
+	{
+		for (size_t	j = 0;	j < mSubMesh[i].mIndexCount;	j	=	j + 3)
 		{	
-			obj << "f " <<  mSubMesh[i].mIndex[j]+1 << " " << 
-				mSubMesh[i].mIndex[j+1]+1 << " " << 
-				mSubMesh[i].mIndex[j+2]+1 << std::endl;
-		}
-	}
-
-	obj << "end" << std::endl;
+			obj	<<	"f "
+					<<	mSubMesh[i].mIndex[j] + 1
+					<<	" "	
+					<<	mSubMesh[i].mIndex[j + 1] + 1
+					<<	" "
+					<<	mSubMesh[i].mIndex[j + 2] + 1
+					<<	std::endl;
+		}
+	}
+
+	obj	<<	"end"	<<	std::endl;
+	
 	obj.close();
 }
@@ -380,5 +399,5 @@
 {
 	// Move all vertex to the shared vertex buffer.
-	Mesh *mesh = new Mesh();
+	Mesh	*mesh	=	new Mesh();
 
 	if (mSubMesh[0].mSharedVertexBuffer)
@@ -390,8 +409,6 @@
 	
 	mesh->mVertexBuffer	=	new VertexBuffer();
-	mesh->mSubMeshCount =	mSubMeshCount;
-	
-	// Reserva memoria para los submeshes
-	mesh->mSubMesh	=	new SubMesh[mSubMeshCount];
+	mesh->mSubMeshCount	=	mSubMeshCount;
+	mesh->mSubMesh			=	new SubMesh[mSubMeshCount];
 
 	//	Fill up bounding box settings.
@@ -418,5 +435,5 @@
 		strcpy(mesh->mSubMesh[i].mMaterialName,mSubMesh[i].mMaterialName);
 		
-		// copiar los índices
+		// Copy indices.
 		mesh->mSubMesh[i].mIndexCount	=	mSubMesh[i].mIndexCount;
 		mesh->mSubMesh[i].mIndex			=	new Index[mSubMesh[i].mIndexCount];
@@ -429,6 +446,6 @@
 		acumVerts	+=	long(mSubMesh[i].mVertexBuffer->mVertexCount);
 
-		// Copiar las tiras
-		int offset	=	0; // desplazamiento entre posiciones de memoria.
+		// Copy strips.
+		int offset	=	0;
 		
 		mesh->mSubMesh[i].mStripCount	=	mSubMesh[i].mStripCount;
@@ -440,7 +457,7 @@
 			offset	=	int(&(mesh->mSubMesh[i].mIndex[0]) - &(mSubMesh[i].mIndex[0]));
 			
-			for (size_t j = 0;	j < mSubMesh[i].mStripCount;	j++)
-			{
-				mesh->mSubMesh[i].mStrip[j] = mSubMesh[i].mStrip[j] + offset;
+			for (size_t	j	=	0;	j < mSubMesh[i].mStripCount;	j++)
+			{
+				mesh->mSubMesh[i].mStrip[j]	=	mSubMesh[i].mStrip[j] + offset;
 			}
 		}
@@ -454,12 +471,11 @@
 	mesh->mVertexBuffer->mTexCoords		=	new Vector2[mesh->mVertexBuffer->mVertexCount];
 
-	// copiar los vértices
 	acumVerts	=	0;
 	
 	size_t	newIndex;
 	
-	for (size_t i = 0; i < mSubMeshCount;	i++)
-	{
-		for(size_t j = 0; j < mSubMesh[i].mVertexBuffer->mVertexCount; j++)
+	for (size_t	i	=	0;	i < mSubMeshCount;	i++)
+	{
+		for	(size_t	j	=	0;	j < mSubMesh[i].mVertexBuffer->mVertexCount;	j++)
 		{
 			newIndex	=	acumVerts + j;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshStripifier.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshStripifier.cpp	(revision 986)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshStripifier.cpp	(revision 1009)
@@ -19,5 +19,7 @@
 //-----------------------------------------------------------------------------
 
-///	InitList:
+//-----------------------------------------------------------------------------
+///	InitList.
+//-----------------------------------------------------------------------------
 BOOL CustomStripifier::InitList(PLISTHEAD LHead)
 {
@@ -33,5 +35,7 @@
 }
 
-///	AddHead:
+//-----------------------------------------------------------------------------
+///	AddHead.
+//-----------------------------------------------------------------------------
 BOOL CustomStripifier::AddHead(PLISTHEAD LHead, PLISTINFO LInfo)
 {
@@ -8620,5 +8624,7 @@
 //-----------------------------------------------------------------------------
 
-///	Stripify:
+//-----------------------------------------------------------------------------
+//	Stripify.
+//-----------------------------------------------------------------------------
 int CustomStripifier::Stripify()
 {
@@ -8638,5 +8644,7 @@
 }
 
-///	GetMesh: Return de current Mesh.
+//-----------------------------------------------------------------------------
+//	GetMesh: Return de current Mesh.
+//-----------------------------------------------------------------------------
 Mesh*	CustomStripifier::GetMesh()
 {
@@ -8649,5 +8657,7 @@
 }
 
+//-----------------------------------------------------------------------------
 //	Set the progress bar function.
+//-----------------------------------------------------------------------------
 void	CustomStripifier::SetProgressFunc(TIPOFUNC upb)
 {
@@ -8656,5 +8666,7 @@
 }
 
+//-----------------------------------------------------------------------------
 // Sets what is the submesh that stores the leaves.
+//-----------------------------------------------------------------------------
 void CustomStripifier::SetSubMeshLeaves(size_t	submesh)
 {
