Model.Data().Info.Extent.Radius = DataStream.ReadFloat();
	Model.Data().Info.Extent.Min.x = DataStream.ReadFloat();
	Model.Data().Info.Extent.Min.y = DataStream.ReadFloat();
	Model.Data().Info.Extent.Min.z = DataStream.ReadFloat();
	Model.Data().Info.Extent.Max.x = DataStream.ReadFloat();
	Model.Data().Info.Extent.Max.y = DataStream.ReadFloat();
	Model.Data().Info.Extent.Max.z = DataStream.ReadFloat();

	Model.Data().Info.BlendTime = static_cast<INT>(DataStream.ReadDWord());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the model sequences
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadSequences(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	INT CurrentSize;
	INT SequenceSize;
	MODEL_SEQUENCE* Sequence;

	CurrentSize = 0;
	while(CurrentSize < Size)
	{
		Sequence = new MODEL_SEQUENCE();
		if(Sequence == NULL)
		{
			Error.SetMessage("Unable to load \"" + CurrentFileName + "\", memory allocation failed!");
			return FALSE;
		}

		if(!LoadSequence((*Sequence), DataStream, 0))
		{
			delete Sequence;
			return FALSE;
		}

		if(!Model.AddSequence(Sequence))
		{
			delete Sequence;
			return FALSE;
		}

		SequenceSize = Sequence->GetSize();
		CurrentSize += SequenceSize;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads a model sequence
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadSequence(MODEL_SEQUENCE& Sequence, DATA_IN_STREAM& DataStream, INT Size)
{
	CHAR Buffer[MODEL_NAME_SEQUENCE_SIZE + 1];

	Buffer[MODEL_NAME_SEQUENCE_SIZE] = '\0';

	if(!DataStream.Read(Buffer, MODEL_NAME_SEQUENCE_SIZE)) return FALSE;
	Sequence.Data().Name = Buffer;

	Sequence.Data().Interval.x = static_cast<FLOAT>(DataStream.ReadDWord());
	Sequence.Data().Interval.y = static_cast<FLOAT>(DataStream.ReadDWord());
	Sequence.Data().MoveSpeed = DataStream.ReadFloat();
	Sequence.Data().NonLooping = (DataStream.ReadDWord() == 1);
	Sequence.Data().Rarity = DataStream.ReadFloat();

	DataStream.ReadDWord(); //What is this?

	Sequence.Data().Extent.Radius = DataStream.ReadFloat();
	Sequence.Data().Extent.Min.x = DataStream.ReadFloat();
	Sequence.Data().Extent.Min.y = DataStream.ReadFloat();
	Sequence.Data().Extent.Min.z = DataStream.ReadFloat();
	Sequence.Data().Extent.Max.x = DataStream.ReadFloat();
	Sequence.Data().Extent.Max.y = DataStream.ReadFloat();
	Sequence.Data().Extent.Max.z = DataStream.ReadFloat();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the global model sequences
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadGlobalSequences(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	INT CurrentSize;
	INT GlobalSequenceSize;
	MODEL_GLOBAL_SEQUENCE* GlobalSequence;

	CurrentSize = 0;
	while(CurrentSize < Size)
	{
		GlobalSequence = new MODEL_GLOBAL_SEQUENCE();
		if(GlobalSequence == NULL)
		{
			Error.SetMessage("Unable to load \"" + CurrentFileName + "\", memory allocation failed!");
			return FALSE;
		}

		GlobalSequence->Data().Duration = DataStream.ReadDWord();

		if(!Model.AddGlobalSequence(GlobalSequence))
		{
			delete GlobalSequence;
			return FALSE;
		}

		GlobalSequenceSize = GlobalSequence->GetSize();
		CurrentSize += GlobalSequenceSize;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the model textures
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadTextures(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	INT CurrentSize;
	INT TextureSize;
	MODEL_TEXTURE* Texture;

	TextureSize = 268;

	CurrentSize = 0;
	while(CurrentSize < Size)
	{
		CurrentSize += TextureSize;

		Texture = new MODEL_TEXTURE();
		if(Texture == NULL)
		{
			Error.SetMessage("Unable to load \"" + CurrentFileName + "\", memory allocation failed!");
			return FALSE;
		}

		if(!LoadTexture((*Texture), DataStream, TextureSize))
		{
			delete Texture;
			return FALSE;
		}

		if(!Model.AddTexture(Texture))
		{
			delete Texture;
			return FALSE;
		}

		if(Texture->Data().FileName != "")
		{
			if(!TextureManager.Load(Texture->Data().FileName)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads a model texture
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadTexture(MODEL_TEXTURE& Texture, DATA_IN_STREAM& DataStream, INT Size)
{
	DWORD Flags;
	CHAR Buffer[MODEL_NAME_TEXTURE_SIZE + 1];

	Buffer[MODEL_NAME_TEXTURE_SIZE] = '\0';

	Texture.Data().ReplaceableId = static_cast<INT>(DataStream.ReadDWord());

	if(!DataStream.Read(Buffer, MODEL_NAME_TEXTURE_SIZE)) return FALSE;
	Texture.Data().FileName = Buffer;

	DataStream.ReadDWord(); //What is this? (always 0?)

	Flags = DataStream.ReadDWord();
	Texture.Data().WrapWidth = (Flags & 1);
	Texture.Data().WrapHeight = (Flags & 2);

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the model materials
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadMaterials(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	INT CurrentSize;
	INT MaterialSize;
	MODEL_MATERIAL* Material;

	CurrentSize = 0;
	while(CurrentSize < Size)
	{
		MaterialSize = DataStream.ReadDWord();
		CurrentSize += MaterialSize;

		Material = new MODEL_MATERIAL();
		if(Material == NULL)
		{
			Error.SetMessage("Unable to load \"" + CurrentFileName + "\", memory allocation failed!");
			return FALSE;
		}

		if(!LoadMaterial((*Material), DataStream, MaterialSize))
		{
			delete Material;
			return FALSE;
		}

		if(!Model.AddMaterial(Material))
		{
			delete Material;
			return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads a model material
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadMaterial(MODEL_MATERIAL& Material, DATA_IN_STREAM& DataStream, INT Size)
{
	INT i;
	DWORD Tag;
	DWORD Temp;
	DWORD Flags;
	DWORD NrOfLayerBytes;
	DWORD NrOfLayers;
	MODEL_MATERIAL_LAYER* Layer;
	std::stringstream Stream;

	Material.Data().PriorityPlane = DataStream.ReadDWord();
	Flags = DataStream.ReadDWord();

	Material.Data().ConstantColor = (Flags & 1);
	Material.Data().SortPrimitivesFarZ = (Flags & 16);
	Material.Data().FullResolution = (Flags & 32);

	if(!ExpectTag(DataStream, 'LAYS')) return FALSE;

	NrOfLayers = DataStream.ReadDWord();
	for(i = 0; i < static_cast<INT>(NrOfLayers); i++)
	{
		Layer = new MODEL_MATERIAL_LAYER();
		if(Layer == NULL)
		{
			Error.SetMessage("Unable to load \"" + CurrentFileName + "\", memory allocation failed!");
			return FALSE;
		}

		NrOfLayerBytes = DataStream.ReadDWord();

		Temp = DataStream.ReadDWord();
		switch(Temp)
		{
			case 1:
			{
				Layer->Data().FilterMode = FILTER_MODE_TRANSPARENT;
				break;
			}

			case 2:
			{
				Layer->Data().FilterMode = FILTER_MODE_BLEND;
				break;
			}

			case 3:
			{
				Layer->Data().FilterMode = FILTER_MODE_ADDITIVE;
				break;
			}

			case 4:
			{
				Layer->Data().FilterMode = FILTER_MODE_ADD_ALPHA;
				break;
			}

			case 5:
			{
				Layer->Data().FilterMode = FILTER_MODE_MODULATE;
				break;
			}

			default:
			{
				Layer->Data().FilterMode = FILTER_MODE_NONE;
				break;
			}
		}

		Flags = DataStream.ReadDWord();
		Layer->Data().Unshaded = (Flags & 1);
		Layer->Data().SphereEnvironmentMap = (Flags & 2);
		Layer->Data().TwoSided = (Flags & 16);
		Layer->Data().Unfogged = (Flags & 32);
		Layer->Data().NoDepthTest = (Flags & 64);
		Layer->Data().NoDepthSet = (Flags & 128);

		Layer->Data().TextureId = DataStream.ReadDWord();
		Layer->Data().AnimatedTextureId.SetStaticScalarInt(Layer->Data().TextureId);
		Layer->Data().TextureAnimationId = DataStream.ReadDWord();

		DataStream.ReadDWord(); //What is this? (always 0?)

		Layer->Data().Alpha.SetStaticScalar(DataStream.ReadFloat());

		NrOfLayerBytes -= Layer->GetSize();
		while(NrOfLayerBytes > 0)
		{
			Tag = ReverseDWord(DataStream.ReadDWord());

			if(Tag == 'KMTA')
			{
				if(!Layer->Data().Alpha.Load(DataStream)) return FALSE;
				NrOfLayerBytes -= Layer->Data().Alpha.GetSize();
			}
			else if(Tag == 'KMTF')
			{
				if(!Layer->Data().AnimatedTextureId.Load(DataStream)) return FALSE;
				NrOfLayerBytes -= Layer->Data().AnimatedTextureId.GetSize();
				Layer->Data().TextureId = INVALID_INDEX;
			}
			else
			{
				Error.SetMessage("Unknown tag \"" + GroupToString(Tag) + "\" in Material.Layer!");
				return FALSE;
			}
		}

		if(!Material.AddLayer(Layer)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads the model texture animations
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadTextureAnimations(MODEL& Model, DATA_IN_STREAM& DataStream, INT Size)
{
	INT CurrentSize;
	INT TextureAnimationSize;
	MODEL_TEXTURE_ANIMATION* TextureAnimation;

	CurrentSize = 0;
	while(CurrentSize < Size)
	{
		TextureAnimationSize = DataStream.ReadDWord();
		CurrentSize += TextureAnimationSize;

		TextureAnimation = new MODEL_TEXTURE_ANIMATION();
		if(TextureAnimation == NULL)
		{
			Error.SetMessage("Unable to load \"" + CurrentFileName + "\", memory allocation failed!");
			return FALSE;
		}

		if(!LoadTextureAnimation((*TextureAnimation), DataStream, TextureAnimationSize))
		{
			delete TextureAnimation;
			return FALSE;
		}

		if(!Model.AddTextureAnimation(TextureAnimation))
		{
			delete TextureAnimation;
			return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads a model texture animation
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::LoadTextureAnimation(MODEL_TEXTURE_ANIMATION& TextureAnimation, DATA_IN_STREAM& DataStream, INT Size)
{
	DWORD Tag;

	Size -= 4;

	while(Size > 0)
	{
		Tag = ReverseDWord(DataStream.ReadDWord());

		if(Tag == 'KTAT')
		{
			if(!TextureAnimation.Data().Translation.Load(DataStream)) return FALSE;
			Size -= TextureAnimation.Data().Translation.GetSize();
		}
		else if(Tag == 'KTAR')
		{
			if(!TextureAnimation.Data().Rotation.Load(DataStream)) return FALSE;
			Size -= TextureAnimation.Data().Rotation.GetSize();
		}
		else if(Tag == 'KTAS')
		{
			if(!TextureAnimation.Data().Scaling.Load(DataStream)) return FALSE;
			Size -= TextureAnimation.Data().Scaling.GetSize();
		}
		else
		{
			Error.SetMessage("Unknown tag \"" + GroupToString(Tag) + "\" in TextureAnimation!");
			return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads