modelloadermdx.cpp

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

			TotalSize += Model.Data().BoneContainer[i]->GetSize();
		}
	}

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model bone
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveBone(MODEL_BONE& Bone, DATA_OUT_STREAM& DataStream)
{
	if(!SaveBaseData(Bone.BaseData(), DataStream, NODE_FLAG_BONE)) return FALSE;

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

	return TRUE;
}


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

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

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

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model light
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveLight(MODEL_LIGHT& Light, DATA_OUT_STREAM& DataStream)
{
	D3DXVECTOR3 TempVector;

	DataStream.WriteDWord(Light.GetSize());

	if(!SaveBaseData(Light.BaseData(), DataStream, NODE_FLAG_LIGHT)) return FALSE;

	DataStream.WriteDWord(Light.Data().Type);

	DataStream.WriteFloat(Light.Data().AttenuationStart.GetScalar());
	DataStream.WriteFloat(Light.Data().AttenuationEnd.GetScalar());

	TempVector = Light.Data().Color.GetVector3();

	DataStream.WriteFloat(TempVector.z);
	DataStream.WriteFloat(TempVector.y);
	DataStream.WriteFloat(TempVector.x);
	DataStream.WriteFloat(Light.Data().Intensity.GetScalar());

	TempVector = Light.Data().AmbientColor.GetVector3();

	DataStream.WriteFloat(TempVector.z);
	DataStream.WriteFloat(TempVector.y);
	DataStream.WriteFloat(TempVector.x);
	DataStream.WriteFloat(Light.Data().AmbientIntensity.GetScalar());

	if(Light.Data().Visibility.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KLAV'));
		if(!Light.Data().Visibility.Save(DataStream)) return FALSE;
	}

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

	if(Light.Data().Intensity.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KLAI'));
		if(!Light.Data().Intensity.Save(DataStream)) return FALSE;
	}

	if(Light.Data().AmbientColor.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KLBC'));
		if(!Light.Data().AmbientColor.Save(DataStream)) return FALSE;
	}

	if(Light.Data().AmbientIntensity.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KLBI'));
		if(!Light.Data().AmbientIntensity.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


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

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

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

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model helper
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveHelper(MODEL_HELPER& Helper, DATA_OUT_STREAM& DataStream)
{
	if(!SaveBaseData(Helper.BaseData(), DataStream, NODE_FLAG_HELPER)) return FALSE;

	return TRUE;
}


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

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

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

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model attachment
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveAttachment(MODEL_ATTACHMENT& Attachment, DATA_OUT_STREAM& DataStream)
{
	DataStream.WriteDWord(Attachment.GetSize());

	if(!SaveBaseData(Attachment.BaseData(), DataStream, NODE_FLAG_ATTACHMENT)) return FALSE;

	DataStream.WriteString(Attachment.Data().Path, MODEL_NAME_ATTACHMENT_SIZE);
	DataStream.WriteDWord(0); //What's this? (always 0?)
	DataStream.WriteDWord(Attachment.Data().AttachmentId);

	if(Attachment.Data().Visibility.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KATV'));
		if(!Attachment.Data().Visibility.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves the model pivot points
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SavePivotPoints(MODEL& Model, DATA_OUT_STREAM& DataStream)
{
	INT i;
	D3DXVECTOR3* Vector;

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

	DataStream.WriteDWord(ReverseDWord('PIVT'));
	DataStream.WriteDWord(Model.Data().PivotPointContainer.GetSize() * 12);

	for(i = 0; i < Model.Data().PivotPointContainer.GetTotalSize(); i++)
	{
		if(Model.Data().PivotPointContainer.ValidIndex(i))
		{
			Vector = Model.Data().PivotPointContainer[i];

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

	return TRUE;
}


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

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

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

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model particle emitter
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveParticleEmitter(MODEL_PARTICLE_EMITTER& ParticleEmitter, DATA_OUT_STREAM& DataStream)
{
	DWORD NodeType;

	DataStream.WriteDWord(ParticleEmitter.GetSize());

	NodeType = NODE_FLAG_PARTICLE_EMITTER;
	if(ParticleEmitter.Data().EmitterUsesMdl) NodeType |= NODE_FLAG_EMITTER_USES_MDL;
	if(ParticleEmitter.Data().EmitterUsesTga) NodeType |= NODE_FLAG_EMITTER_USES_TGA;

	if(!SaveBaseData(ParticleEmitter.BaseData(), DataStream, NodeType)) return FALSE;

	DataStream.WriteFloat(ParticleEmitter.Data().EmissionRate.GetScalar());
	DataStream.WriteFloat(ParticleEmitter.Data().Gravity.GetScalar());
	DataStream.WriteFloat(ParticleEmitter.Data().Longitude.GetScalar());
	DataStream.WriteFloat(ParticleEmitter.Data().Latitude.GetScalar());

	DataStream.WriteString(ParticleEmitter.Data().ParticleFileName, MODEL_NAME_PARTICLE_EMITTER_SIZE);

	DataStream.WriteDWord(0); //What's this? Always 0?

	DataStream.WriteFloat(ParticleEmitter.Data().ParticleLifeSpan.GetScalar());
	DataStream.WriteFloat(ParticleEmitter.Data().ParticleInitialVelocity.GetScalar());

	if(ParticleEmitter.Data().Visibility.GetNrOfNodes() > 0)
	{
		DataStream.WriteDWord(ReverseDWord('KPEV'));
		if(!ParticleEmitter.Data().Visibility.Save(DataStream)) return FALSE;
	}

	return TRUE;
}


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

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

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

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

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

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Saves a model particle emitter 2
//+-----------------------------------------------------------------------------
BOOL MODEL_LOADER_MDX::SaveParticleEmitter2(MODEL_PARTICLE_EMITTER_2& ParticleEmitter2, DATA_OUT_STREAM& DataStream)
{
	DWORD NodeType;

	DataStream.WriteDWord(ParticleEmitter2.GetSize());

	NodeType = NODE_FLAG_PARTICLE_EMITTER;
	if(ParticleEmitter2.Data().XYQuad) NodeType |= NODE_FLAG_XY_QUAD;
	if(ParticleEmitter2.Data().Unshaded) NodeType |= NODE_FLAG_UNSHADED;
	if(ParticleEmitter2.Data().Unfogged) NodeType |= NODE_FLAG_UNFOGGED;
	if(ParticleEmitter2.Data().ModelSpace) NodeType |= NODE_FLAG_MODEL_SPACE;
	if(ParticleEmitter2.Data().LineEmitter) NodeType |= NODE_FLAG_LINE_EMITTER;
	if(ParticleEmitter2.Data().SortPrimitivesFarZ) NodeType |= NODE_FLAG_SORT_PRIMITIVES_FAR_Z;

	if(!SaveBaseData(ParticleEmitter2.BaseData(), DataStream, NodeType)) return FALSE;

	DataStream.WriteFloat(ParticleEmitter2.Data().Speed.GetScalar());
	DataStream.WriteFloat(ParticleEmitter2.Data().Variation.GetScalar());
	DataStream.WriteFloat(ParticleEmitter2.Data().Latitude.GetScalar());
	DataStream.WriteFloat(ParticleEmitter2.Data().Gravity.GetScalar());
	DataStream.WriteFloat(ParticleEmitter2.Data().LifeSpan);
	DataStream.WriteFloat(ParticleEmitter2.Data().EmissionRate.GetScalar());
	DataStream.WriteFloat(ParticleEmitter2.Data().Length.GetScalar());
	DataStream.WriteFloat(ParticleEmitter2.Data().Width.GetScalar());

	switch(ParticleEmitter2.Data().FilterMode)
	{
		case FILTER_MODE_BLEND:
		{
			DataStream.WriteDWord(0);
			break;
		}

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

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

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

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

	DataStream.WriteDWord(ParticleEmitter2.Data().Rows);
	DataStream.WriteDWord(ParticleEmitter2.Data().Columns);

	if(ParticleEmitter2.Data().Head)
	{
		if(ParticleEmitter2.Data().Tail)
		{
			DataStream.WriteDWord(2);
		}
		else
		{