modelbuilder.cpp

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

	if(ModelTextureAnimation == NULL) return FALSE;

	if(!Model.AddTextureAnimation(ModelTextureAnimation)) return FALSE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates an event object track
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateEventObjectTrack(INT EventObjectId, INT Time)
{
	MODEL_EVENT_OBJECT* ModelEventObject;

	if(!Model.Data().EventObjectContainer.ValidIndex(EventObjectId))
	{
		std::stringstream Stream;
		Stream << "Unable to create an event object track, event object ID " << EventObjectId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelEventObject = Model.Data().EventObjectContainer[EventObjectId];

	ModelEventObject->Data().EventTrack.push_back(Time);

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a geoset vertex
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateGeosetVertex(INT GeosetId, CONST WAR3_MODEL_VERTEX& Vertex)
{
	MODEL_GEOSET* ModelGeoset;
	MODEL_GEOSET_VERTEX* ModelGeosetVertex;

	if(!Model.Data().GeosetContainer.ValidIndex(GeosetId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a geoset vertex, geoset ID " << GeosetId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelGeoset = Model.Data().GeosetContainer[GeosetId];

	ModelGeosetVertex = new MODEL_GEOSET_VERTEX();
	if(ModelGeosetVertex == NULL) return FALSE;

	ModelGeosetVertex->Position.x = Vertex.Position.X;
	ModelGeosetVertex->Position.y = Vertex.Position.Y;
	ModelGeosetVertex->Position.z = Vertex.Position.Z;
	ModelGeosetVertex->Normal.x = Vertex.Normal.X;
	ModelGeosetVertex->Normal.y = Vertex.Normal.Y;
	ModelGeosetVertex->Normal.z = Vertex.Normal.Z;
	ModelGeosetVertex->TexturePosition.x = Vertex.TexturePosition.X;
	ModelGeosetVertex->TexturePosition.y = Vertex.TexturePosition.Y;
	ModelGeosetVertex->VertexGroup = Vertex.Group;

	if(!ModelGeoset->AddVertex(ModelGeosetVertex)) return FALSE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a geoset face
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateGeosetFace(INT GeosetId, CONST WAR3_MODEL_FACE& Face)
{
	MODEL_GEOSET* ModelGeoset;
	MODEL_GEOSET_FACE* ModelGeosetFace;

	if(!Model.Data().GeosetContainer.ValidIndex(GeosetId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a geoset vertex, geoset ID " << GeosetId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelGeoset = Model.Data().GeosetContainer[GeosetId];

	ModelGeosetFace = new MODEL_GEOSET_FACE();
	if(ModelGeosetFace == NULL) return FALSE;

	ModelGeosetFace->Index1 = Face.Index1;
	ModelGeosetFace->Index2 = Face.Index2;
	ModelGeosetFace->Index3 = Face.Index3;

	if(!ModelGeoset->AddFace(ModelGeosetFace)) return FALSE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a geoset extent
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateGeosetExtent(INT GeosetId, CONST WAR3_MODEL_EXTENT& Extent)
{
	MODEL_GEOSET* ModelGeoset;
	EXTENT* ModelExtent;

	if(!Model.Data().GeosetContainer.ValidIndex(GeosetId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a geoset vertex, geoset ID " << GeosetId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelGeoset = Model.Data().GeosetContainer[GeosetId];

	ModelExtent = new EXTENT();
	if(ModelExtent == NULL) return FALSE;

	ModelExtent->Radius = Extent.Radius;
	ModelExtent->Min.x = Extent.Min.X;
	ModelExtent->Min.y = Extent.Min.Y;
	ModelExtent->Min.z = Extent.Min.Z;
	ModelExtent->Max.x = Extent.Max.X;
	ModelExtent->Max.y = Extent.Max.Y;
	ModelExtent->Max.z = Extent.Max.Z;

	if(!ModelGeoset->AddExtent(ModelExtent)) return FALSE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a geoset group
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateGeosetGroup(INT GeosetId)
{
	MODEL_GEOSET* ModelGeoset;
	MODEL_GEOSET_GROUP* ModelGeosetGroup;

	if(!Model.Data().GeosetContainer.ValidIndex(GeosetId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a geoset vertex, geoset ID " << GeosetId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelGeoset = Model.Data().GeosetContainer[GeosetId];

	ModelGeosetGroup = new MODEL_GEOSET_GROUP();
	if(ModelGeosetGroup == NULL) return FALSE;

	if(!ModelGeoset->AddGroup(ModelGeosetGroup)) return FALSE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a geoset group bone
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateGeosetGroupBone(INT GeosetId, INT GeosetGroupId, INT BoneId)
{
	MODEL_GEOSET* ModelGeoset;
	MODEL_GEOSET_GROUP* ModelGeosetGroup;
	MODEL_GEOSET_GROUP_NODE* ModelGeosetGroupNode;

	if(!Model.Data().GeosetContainer.ValidIndex(GeosetId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a geoset group bone, geoset ID " << GeosetId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelGeoset = Model.Data().GeosetContainer[GeosetId];

	if(!ModelGeoset->Data().GroupContainer.ValidIndex(GeosetGroupId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a geoset group bone, geoset group ID " << GeosetGroupId << " in geoset ID " << GeosetId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelGeosetGroup = ModelGeoset->Data().GroupContainer[GeosetGroupId];

	ModelGeosetGroupNode = new MODEL_GEOSET_GROUP_NODE();
	if(ModelGeosetGroupNode == NULL) return FALSE;

	ModelGeosetGroupNode->NodeId = BoneId;

	if(!ModelGeosetGroup->MatrixList.Add(ModelGeosetGroupNode)) return FALSE;

	ModelGeosetGroup->MatrixListSize++;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a material layer
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateMaterialLayer(INT MaterialId, CONST WAR3_MODEL_MATERIAL_LAYER& MaterialLayer)
{
	MODEL_MATERIAL* ModelMaterial;
	MODEL_MATERIAL_LAYER* ModelMaterialLayer;

	if(!Model.Data().MaterialContainer.ValidIndex(MaterialId))
	{
		std::stringstream Stream;
		Stream << "Unable to create a material layer, material ID " << MaterialId << " does not exist!";
		Error.SetMessage(Stream.str());
		return FALSE;
	}

	ModelMaterial = Model.Data().MaterialContainer[MaterialId];

	ModelMaterialLayer = new MODEL_MATERIAL_LAYER();
	if(ModelMaterialLayer == NULL) return FALSE;

	ModelMaterialLayer->Data().FilterMode = static_cast<FILTER_MODE>(MaterialLayer.FilterMode);

	ModelMaterialLayer->Data().TextureId = MaterialLayer.TextureId;
	ModelMaterialLayer->Data().TextureAnimationId = MaterialLayer.TextureAnimationId;

	ModelMaterialLayer->Data().AnimatedTextureId.SetStaticScalarInt(MaterialLayer.TextureId);
	ModelMaterialLayer->Data().Alpha.SetStaticScalar(MaterialLayer.Alpha);

	ModelMaterialLayer->Data().Unshaded = MaterialLayer.Unshaded;
	ModelMaterialLayer->Data().Unfogged = MaterialLayer.Unfogged;
	ModelMaterialLayer->Data().TwoSided = MaterialLayer.TwoSided;
	ModelMaterialLayer->Data().SphereEnvironmentMap = MaterialLayer.SphereEnvironmentMap;
	ModelMaterialLayer->Data().NoDepthTest = MaterialLayer.NoDepthTest;
	ModelMaterialLayer->Data().NoDepthSet = MaterialLayer.NoDepthSet;

	if(!ModelMaterial->AddLayer(ModelMaterialLayer)) return FALSE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates an interpolator
//+-----------------------------------------------------------------------------
BOOL MODEL_BUILDER::CreateInterpolator()
{
	CurrentInterpolator = INTERPOLATOR();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Sets the interpolator type
//+-----------------------------------------------------------------------------
VOID MODEL_BUILDER::SetInterpolatorType(WAR3_INTERPOLATOR_TYPE InterpolatorType)
{
	CurrentInterpolator.SetType(static_cast<INTERPOLATOR_TYPE>(InterpolatorType));
}


//+-----------------------------------------------------------------------------
//| Sets the interpolator interpolation type
//+-----------------------------------------------------------------------------
VOID MODEL_BUILDER::SetInterpolatorInterpolationType(WAR3_INTERPOLATION_TYPE InterpolationType)
{
	CurrentInterpolator.SetInterpolationType(static_cast<INTERPOLATION_TYPE>(InterpolationType));
}


//+-----------------------------------------------------------------------------
//| Sets the interpolator global sequence ID
//+-----------------------------------------------------------------------------
VOID MODEL_BUILDER::SetInterpolatorGlobalSequenceId(INT GlobalSequenceId)
{
	CurrentInterpolator.SetGlobalSequenceId(GlobalSequenceId);
}


//+-----------------------------------------------------------------------------
//| Adds a scalar to the interpolator
//+-----------------------------------------------------------------------------
VOID MODEL_BUILDER::AddScalar(INT Time, FLOAT Scalar, FLOAT InTan, FLOAT OutTan)
{
	INTERPOLATOR_NODE Node;

	Node.Time = Time;
	Node.Vector.x = Scalar;
	Node.InTan.x = InTan;
	Node.OutTan.x = OutTan;

	CurrentInterpolator.AddNode(Node);
}


//+-----------------------------------------------------------------------------
//| Adds an integer scalar to the interpolator
//+-----------------------------------------------------------------------------
VOID MODEL_BUILDER::AddScalarInt(INT Time, INT Scalar, INT InTan, INT OutTan)
{
	INTERPOLATOR_NODE Node;

	Node.Time = Time;
	Node.Vector.x = static_cast<FLOAT>(Scalar);
	Node.InTan.x = static_cast<FLOAT>(InTan);
	Node.OutTan.x = static_cast<FLOAT>(OutTan);

	CurrentInterpolator.AddNode(Node);
}


//+-----------------------------------------------------------------------------
//| Adds a 2-dimensional vector to the interpolator
//+-----------------------------------------------------------------------------
VOID MODEL_BUILDER::AddVector2(INT Time, CONST WAR3_MODEL_VECTOR_2& Vector, CONST WAR3_MODEL_VECTOR_2& InTan, CONST WAR3_MODEL_VECTOR_2& OutTan)
{
	INTERPOLATOR_NODE Node;