modelloadermdx.cpp

骨骼动画....把魔兽模型解出的代码..

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

				case FILTER_MODE_BLEND:
				{
					DataStream.WriteDWord(2);
					break;
				}

				case FILTER_MODE_ADDITIVE:
				{
					DataStream.WriteDWord(3);
					break;
				}

				case FILTER_MODE_ADD_ALPHA:
				{
					DataStream.WriteDWord(4);
					break;
				}

				case FILTER_MODE_MODULATE:
				{
					DataStream.WriteDWord(5);
					break;
				}

				default:
				{
					DataStream.WriteDWord(0);
					break;
				}
			}

			Flags = 0;
			if(Layer->Data().Unshaded) Flags |= 1;
			if(Layer->Data().SphereEnvironmentMap) Flags |= 2;
			if(Layer->Data().TwoSided) Flags |= 16;
			if(Layer->Data().Unfogged) Flags |= 32;
			if(Layer->Data().NoDepthTest) Flags |= 64;
			if(Layer->Data().NoDepthSet) Flags |= 128;

			DataStream.WriteDWord(Flags);

			Temp = static_cast<DWORD>(Layer->Data().AnimatedTextureId.GetScalar());

			DataStream.WriteDWord((Temp == INVALID_INDEX) ? 0xFFFFFFFF : Temp);
			DataStream.WriteDWord((Layer->Data().TextureAnimationId == INVALID_INDEX) ? 0xFFFFFFFF : Layer->Data().TextureAnimationId);

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

			DataStream.WriteFloat(Layer->Data().Alpha.GetScalar());

			if(Layer->Data().Alpha.GetNrOfNodes() > 0)
			{
				DataStream.WriteDWord(ReverseDWord('KMTA'));
				if(!Layer->Data().Alpha.Save(DataStream)) return FALSE;
			}

			if(Layer->Data().AnimatedTextureId.GetNrOfNodes() > 0)
			{
				DataStream.WriteDWord(ReverseDWord('KMTF'));
				if(!Layer->Data().AnimatedTextureId.Save(DataStream)) return FALSE;
			}
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model texture animations
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveTextureAnimations(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().TextureAnimationContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().TextureAnimationContainer.GetTotalSize(); i++)
	{
		if(Model.Data().TextureAnimationContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().TextureAnimationContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('TXAN'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().TextureAnimationContainer.GetTotalSize(); i++)
	{
		if(Model.Data().TextureAnimationContainer.ValidIndex(i))
		{
			if(!SaveTextureAnimation(*(Model.Data().TextureAnimationContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model texture animation
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveTextureAnimation(MODEL_TEXTURE_ANIMATION& TextureAnimation, DATA_OUT_STREAM& DataStream)
{
	DataStream.WriteDWord(TextureAnimation.GetSize());

	if(TextureAnimation.Data().Translation.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KTAT'));
		if(!TextureAnimation.Data().Translation.Save(DataStream)) return FALSE;
	}

	if(TextureAnimation.Data().Rotation.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KTAR'));
		if(!TextureAnimation.Data().Rotation.Save(DataStream)) return FALSE;
	}

	if(TextureAnimation.Data().Scaling.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KTAS'));
		if(!TextureAnimation.Data().Scaling.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model geosets
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveGeosets(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().GeosetContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().GeosetContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('GEOS'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			if(!SaveGeoset(*(Model.Data().GeosetContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model geoset
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveGeoset(MODEL_GEOSET& Geoset, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT j;
	INT Size;
	std::list<INT> GroupList;
	std::list<INT>::iterator GroupListIterator;
	MODEL_GEOSET_FACE* Face;
	MODEL_GEOSET_GROUP* Group;
	MODEL_GEOSET_VERTEX* Vertex;
	EXTENT* Extent;

	DataStream.WriteDWord(Geoset.GetSize());

	DataStream.WriteDWord(ReverseDWord('VRTX'));

	DataStream.WriteDWord(Geoset.Data().VertexContainer.GetSize());
	for(i = 0; i < Geoset.Data().VertexContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().VertexContainer.ValidIndex(i))
		{
			Vertex = Geoset.Data().VertexContainer[i];

			DataStream.WriteFloat(Vertex->Position.x);
			DataStream.WriteFloat(Vertex->Position.y);
			DataStream.WriteFloat(Vertex->Position.z);
		}
	}

	DataStream.WriteDWord(ReverseDWord('NRMS'));

	DataStream.WriteDWord(Geoset.Data().VertexContainer.GetSize());
	for(i = 0; i < Geoset.Data().VertexContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().VertexContainer.ValidIndex(i))
		{
			Vertex = Geoset.Data().VertexContainer[i];

			DataStream.WriteFloat(Vertex->Normal.x);
			DataStream.WriteFloat(Vertex->Normal.y);
			DataStream.WriteFloat(Vertex->Normal.z);
		}
	}

	DataStream.WriteDWord(ReverseDWord('PTYP'));

	DataStream.WriteDWord(1);
	DataStream.WriteDWord(4);

	DataStream.WriteDWord(ReverseDWord('PCNT'));

	DataStream.WriteDWord(1);
	DataStream.WriteDWord(Geoset.Data().FaceContainer.GetSize() * 3);

	DataStream.WriteDWord(ReverseDWord('PVTX'));

	DataStream.WriteDWord(Geoset.Data().FaceContainer.GetSize() * 3);
	for(i = 0; i < Geoset.Data().FaceContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().FaceContainer.ValidIndex(i))
		{
			Face = Geoset.Data().FaceContainer[i];

			DataStream.WriteWord(Face->Index1);
			DataStream.WriteWord(Face->Index2);
			DataStream.WriteWord(Face->Index3);
		}
	}

	DataStream.WriteDWord(ReverseDWord('GNDX'));

	DataStream.WriteDWord(Geoset.Data().VertexContainer.GetSize());
	for(i = 0; i < Geoset.Data().VertexContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().VertexContainer.ValidIndex(i))
		{
			Vertex = Geoset.Data().VertexContainer[i];

			DataStream.WriteChar(Vertex->VertexGroup);
		}
	}

	DataStream.WriteDWord(ReverseDWord('MTGC'));

	DataStream.WriteDWord(Geoset.Data().GroupContainer.GetSize());
	for(i = 0; i < Geoset.Data().GroupContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().GroupContainer.ValidIndex(i))
		{
			DataStream.WriteDWord(Geoset.Data().GroupContainer[i]->MatrixListSize);
		}
	}

	DataStream.WriteDWord(ReverseDWord('MATS'));

	Size = 0;
	for(i = 0; i < Geoset.Data().GroupContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().GroupContainer.ValidIndex(i))
		{
			Group = Geoset.Data().GroupContainer[i];

			Size += Group->MatrixListSize;
			for(j = 0; j < Group->MatrixList.GetTotalSize(); j++)
			{
				if(Group->MatrixList.ValidIndex(j))
				{
					GroupList.push_back(Group->MatrixList[j]->NodeId);
				}
			}
		}
	}

	DataStream.WriteDWord(Size);

	GroupListIterator = GroupList.begin();
	while(GroupListIterator != GroupList.end())
	{
		DataStream.WriteDWord(*GroupListIterator);
		GroupListIterator++;
	}

	DataStream.WriteDWord((Geoset.Data().MaterialId == INVALID_INDEX) ? 0 : Geoset.Data().MaterialId);
	DataStream.WriteDWord((Geoset.Data().SelectionGroup == INVALID_INDEX) ? 0 : Geoset.Data().SelectionGroup);
	DataStream.WriteDWord(Geoset.Data().Unselectable ? 4 : 0);

	DataStream.WriteFloat(Geoset.Data().Extent.Radius);
	DataStream.WriteFloat(Geoset.Data().Extent.Min.x);
	DataStream.WriteFloat(Geoset.Data().Extent.Min.y);
	DataStream.WriteFloat(Geoset.Data().Extent.Min.z);
	DataStream.WriteFloat(Geoset.Data().Extent.Max.x);
	DataStream.WriteFloat(Geoset.Data().Extent.Max.y);
	DataStream.WriteFloat(Geoset.Data().Extent.Max.z);

	DataStream.WriteDWord(Geoset.Data().ExtentContainer.GetSize());
	for(i = 0; i < Geoset.Data().ExtentContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().ExtentContainer.ValidIndex(i))
		{
			Extent = Geoset.Data().ExtentContainer[i];

			DataStream.WriteFloat(Extent->Radius);
			DataStream.WriteFloat(Extent->Min.x);
			DataStream.WriteFloat(Extent->Min.y);
			DataStream.WriteFloat(Extent->Min.z);
			DataStream.WriteFloat(Extent->Max.x);
			DataStream.WriteFloat(Extent->Max.y);
			DataStream.WriteFloat(Extent->Max.z);
		}
	}

	DataStream.WriteDWord(ReverseDWord('UVAS'));

	DataStream.WriteDWord(1);

	DataStream.WriteDWord(ReverseDWord('UVBS'));

	DataStream.WriteDWord(Geoset.Data().VertexContainer.GetSize());
	for(i = 0; i < Geoset.Data().VertexContainer.GetTotalSize(); i++)
	{
		if(Geoset.Data().VertexContainer.ValidIndex(i))
		{
			Vertex = Geoset.Data().VertexContainer[i];

			DataStream.WriteFloat(Vertex->TexturePosition.x);
			DataStream.WriteFloat(Vertex->TexturePosition.y);
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model geoset animations
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveGeosetAnimations(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().GeosetAnimationContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().GeosetAnimationContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetAnimationContainer.ValidIndex(i))
		{
			TotalSize += Model.Data().GeosetAnimationContainer[i]->GetSize();
		}
	}

	DataStream.WriteDWord(ReverseDWord('GEOA'));
	DataStream.WriteDWord(TotalSize);

	for(i = 0; i < Model.Data().GeosetAnimationContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetAnimationContainer.ValidIndex(i))
		{
			if(!SaveGeosetAnimation(*(Model.Data().GeosetAnimationContainer[i]), DataStream)) return FALSE;
		}
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model geoset animation
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveGeosetAnimation(MODEL_GEOSET_ANIMATION& GeosetAnimation, DATA_OUT_STREAM& DataStream)
{
	DWORD Flags;

	DataStream.WriteDWord(GeosetAnimation.GetSize());

	DataStream.WriteFloat(GeosetAnimation.Data().Color.GetScalar());

	Flags = 0;
	if(GeosetAnimation.Data().DropShadow) Flags |= 1;
	if(GeosetAnimation.Data().UseColor) Flags |= 2;

	DataStream.WriteDWord(Flags);

	DataStream.WriteFloat(GeosetAnimation.Data().Color.GetVector3().z);
	DataStream.WriteFloat(GeosetAnimation.Data().Color.GetVector3().y);
	DataStream.WriteFloat(GeosetAnimation.Data().Color.GetVector3().x);

	DataStream.WriteDWord((GeosetAnimation.Data().GeosetId == INVALID_INDEX) ? 0xFFFFFFFF : GeosetAnimation.Data().GeosetId);

	if(GeosetAnimation.Data().Alpha.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KGAO'));
		if(!GeosetAnimation.Data().Alpha.Save(DataStream)) return FALSE;
	}

	if(GeosetAnimation.Data().Color.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KGAC'));
		if(!GeosetAnimation.Data().Color.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model bones
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveBones(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	INT TotalSize = 0;

	if(Model.Data().BoneContainer.GetSize() <= 0) return TRUE;

	for(i = 0; i < Model.Data().BoneContainer.GetTotalSize(); i++)
	{
		if(Model.Data().BoneContainer.ValidIndex(i))
		{