TempAnim.FirstFrame = 0;
	TempAnim.NumFrames = 0;

	for (UINT i = 0; i < Header.NumFrames; ++i)
	{
		iFile.read(reinterpret_cast <char *> (&TempFrame), sizeof(MD2::FileFrame));

		TempFrame.Position;

		StripNumber(TempFrame.Name);

		if (LastAniName == std::string(TempFrame.Name))
			++(TempAnim.NumFrames);
		else
		{
			LastAniName = TempFrame.Name;
			++TempAnim.NumFrames;
			Animations.push_back(TempAnim);
			TempAnim.Name = LastAniName;
			TempAnim.FirstFrame = i;
			TempAnim.NumFrames = 0;	
		}

		for (UINT j = 0; j < Header.NumVertices; ++j)
		{
			iFile.read(reinterpret_cast <char *> (&TempFileVertex), sizeof(MD2::FileVertex));

			TempVertex.x = TempFileVertex.x * TempFrame.Scale.x;
			TempVertex.y = TempFileVertex.z * TempFrame.Scale.z;
			TempVertex.z = TempFileVertex.y * TempFrame.Scale.y;

			TempVertex += TempFrame.Position;
			TempVertex *= MD2::SCALE;

			FileVertices.push_back(TempVertex);
		}
		memset(&TempFrame, 0, sizeof(MD2::FileFrame));
	}

	iFile.close();

	//HACK
	Animations.erase(Animations.begin());

	Vertices.reserve(Header.NumTriangles * Header.NumFrames * 3);
	TexCoords.reserve(Header.NumTriangles * 3);

	for (UINT Tri = 0; Tri < Header.NumTriangles; ++Tri)
		for (UINT Vert = 0; Vert < 3; ++Vert)
		{
			TexCoords.push_back(CVector2(((FileTexCoords[FileTriangles[Tri].TextureCoordIndices[Vert]].s)
										/ static_cast <float> (Header.TextureWidth)),
										 (FileTexCoords[FileTriangles[Tri].TextureCoordIndices[Vert]].t - 1.0f)
										/ static_cast <float> (Header.TextureHeight * -1.0f)
								));
		}

	for (UINT Frame = 0; Frame < Header.NumFrames; ++Frame)
		for (UINT Tri = 0; Tri < Header.NumTriangles; ++Tri)
		{
			for (UINT Vert = 0; Vert < 3; ++Vert)
				Vertices.push_back(FileVertices[FileTriangles[Tri].VertexIndices[Vert]
									+ Header.NumVertices * Frame]);
		}

struct FileVertex
{
	union
	{
		BYTE Arr[3];
		struct
		{
			BYTE x, y, z;
		};
	};
	BYTE normalIndex;
};

struct FileFrame
{
	CVector3 Scale;
	CVector3 Position;
	char Name[16];
};

struct Frame
{
	std::string & Name;
	UINT	FirstFrame;
	UINT	LastFrame;
};

struct Triangle
{
	USHORT VertexIndices[3];
	USHORT TextureCoordIndices[3];
};

struct GLCommandVertex
{
	CVector2 TexCoord;
	UINT Index;
};

struct GLCommand
{
	UINT Type;
	UINT NumVertices;
	GLCommandVertex * Vertices;
};

struct Shader
{
	char Path[MAX_QPATH];
	unsigned int ShaderIndex;
};

struct Header
{
	GLubyte IDP2[4];
	GLuint Version;
	GLuint TextureWidth;
	GLuint TextureHeight;
	GLuint FrameSize;		// = sizeof(MD2Frame) + num vertices * sizeof(MD2Vertex)   ??
	GLuint NumTextureNames;
	GLuint NumVertices;
	GLuint NumTexCoords;
	GLuint NumTriangles;
	GLuint NumGLCommands;
	GLuint NumFrames;

	GLuint OffsetTextureNames;
	GLuint OffsetTexCoords;
	GLuint OffsetTriangles;
	GLuint OffsetFrames;
	GLuint OffsetGLCommands;
	GLuint OffsetEnd;
};

struct FileTexCoord
{
	union
	{
		struct
		{
			USHORT s, t;
		};
		struct
		{
			USHORT u, v;
		};
		USHORT Arr[2];
	};
};

struct Animation
{
public:
	std::string	Name;
	USHORT	FirstFrame;
	USHORT	NumFrames;
};