model.cpp

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

	if(!ModelData.EventObjectContainer.Add(EventObject))
	{
		Error.SetMessage("Unable to add a new event object!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a helper
//+-----------------------------------------------------------------------------
BOOL MODEL::AddHelper(MODEL_HELPER* Helper, MODEL_BASE* ParentNode)
{
	if(!AddBaseNode(Helper, ParentNode)) return FALSE;

	if(!ModelData.HelperContainer.Add(Helper))
	{
		Error.SetMessage("Unable to add a new helper!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a light
//+-----------------------------------------------------------------------------
BOOL MODEL::AddLight(MODEL_LIGHT* Light, MODEL_BASE* ParentNode)
{
	if(!AddBaseNode(Light, ParentNode)) return FALSE;

	if(!ModelData.LightContainer.Add(Light))
	{
		Error.SetMessage("Unable to add a new light!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a particle emitter
//+-----------------------------------------------------------------------------
BOOL MODEL::AddParticleEmitter(MODEL_PARTICLE_EMITTER* ParticleEmitter, MODEL_BASE* ParentNode)
{
	if(!AddBaseNode(ParticleEmitter, ParentNode)) return FALSE;

	if(!ModelData.ParticleEmitterContainer.Add(ParticleEmitter))
	{
		Error.SetMessage("Unable to add a new particle emitter!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a particle emitter 2
//+-----------------------------------------------------------------------------
BOOL MODEL::AddParticleEmitter2(MODEL_PARTICLE_EMITTER_2* ParticleEmitter2, MODEL_BASE* ParentNode)
{
	if(!AddBaseNode(ParticleEmitter2, ParentNode)) return FALSE;

	if(!ModelData.ParticleEmitter2Container.Add(ParticleEmitter2))
	{
		Error.SetMessage("Unable to add a new particle emitter 2!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a ribbon emitter
//+-----------------------------------------------------------------------------
BOOL MODEL::AddRibbonEmitter(MODEL_RIBBON_EMITTER* RibbonEmitter, MODEL_BASE* ParentNode)
{
	if(!AddBaseNode(RibbonEmitter, ParentNode)) return FALSE;

	if(!ModelData.RibbonEmitterContainer.Add(RibbonEmitter))
	{
		Error.SetMessage("Unable to add a new ribbon emitter!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a camera
//+-----------------------------------------------------------------------------
BOOL MODEL::AddCamera(MODEL_CAMERA* Camera)
{
	if(!ModelData.CameraContainer.Add(Camera))
	{
		Error.SetMessage("Unable to add a new camera!");
		return FALSE;
	}

	CameraManagerWindow.AddName(reinterpret_cast<INT>(Camera), Camera->Data().Name);

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a geoset
//+-----------------------------------------------------------------------------
BOOL MODEL::AddGeoset(MODEL_GEOSET* Geoset, BOOL Imported)
{
	std::stringstream Stream;

	if(!ModelData.GeosetContainer.Add(Geoset))
	{
		Error.SetMessage("Unable to add a new geoset!");
		return FALSE;
	}

	if(Imported) Stream << "Imported";
	Stream << "Geoset " << Geoset;
	GeosetManagerWindow.AddName(reinterpret_cast<INT>(Geoset), Stream.str());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a geoset animation
//+-----------------------------------------------------------------------------
BOOL MODEL::AddGeosetAnimation(MODEL_GEOSET_ANIMATION* GeosetAnimation)
{
	std::stringstream Stream;

	if(!ModelData.GeosetAnimationContainer.Add(GeosetAnimation))
	{
		Error.SetMessage("Unable to add a new geoset animation!");
		return FALSE;
	}

	Stream << "GeosetAnimation " << GeosetAnimation;
	GeosetAnimationManagerWindow.AddName(reinterpret_cast<INT>(GeosetAnimation), Stream.str());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a global sequence
//+-----------------------------------------------------------------------------
BOOL MODEL::AddGlobalSequence(MODEL_GLOBAL_SEQUENCE* GlobalSequence)
{
	std::stringstream Stream;

	if(!ModelData.GlobalSequenceContainer.Add(GlobalSequence))
	{
		Error.SetMessage("Unable to add a new global sequence!");
		return FALSE;
	}

	Stream << "GlobalSequence " << GlobalSequence;
	GlobalSequenceManagerWindow.AddName(reinterpret_cast<INT>(GlobalSequence), Stream.str());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a material
//+-----------------------------------------------------------------------------
BOOL MODEL::AddMaterial(MODEL_MATERIAL* Material)
{
	std::stringstream Stream;

	if(!ModelData.MaterialContainer.Add(Material))
	{
		Error.SetMessage("Unable to add a new material!");
		return FALSE;
	}

	Stream << "Material " << Material;
	MaterialManagerWindow.AddName(reinterpret_cast<INT>(Material), Stream.str());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a pivot point
//+-----------------------------------------------------------------------------
BOOL MODEL::AddPivotPoint(D3DXVECTOR3* PivotPoint)
{
	if(!ModelData.PivotPointContainer.Add(PivotPoint))
	{
		Error.SetMessage("Unable to add a new PivotPoint!");
		return FALSE;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a sequence
//+-----------------------------------------------------------------------------
BOOL MODEL::AddSequence(MODEL_SEQUENCE* Sequence)
{
	if(!ModelData.SequenceContainer.Add(Sequence))
	{
		Error.SetMessage("Unable to add a new sequence!");
		return FALSE;
	}

	AnimationWindow.AddAnimation(reinterpret_cast<INT>(Sequence), Sequence->Data().Name);
	SequenceManagerWindow.AddName(reinterpret_cast<INT>(Sequence), Sequence->Data().Name);

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a texture
//+-----------------------------------------------------------------------------
BOOL MODEL::AddTexture(MODEL_TEXTURE* Texture)
{
	std::stringstream Stream;

	if(!ModelData.TextureContainer.Add(Texture))
	{
		Error.SetMessage("Unable to add a new texture!");
		return FALSE;
	}

	if(Texture->Data().FileName == "")
	{
		Stream << "Replaceable ID " << Texture->Data().ReplaceableId;
	}
	else
	{
		Stream << Texture->Data().FileName;
	}

	TextureManagerWindow.AddName(reinterpret_cast<INT>(Texture), Stream.str());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Adds a texture animation
//+-----------------------------------------------------------------------------
BOOL MODEL::AddTextureAnimation(MODEL_TEXTURE_ANIMATION* TextureAnimation)
{
	std::stringstream Stream;

	if(!ModelData.TextureAnimationContainer.Add(TextureAnimation))
	{
		Error.SetMessage("Unable to add a new texture animation!");
		return FALSE;
	}

	Stream << "TextureAnimation " << TextureAnimation;
	TextureAnimationManagerWindow.AddName(reinterpret_cast<INT>(TextureAnimation), Stream.str());

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes an attachment
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveAttachment(MODEL_ATTACHMENT* Attachment, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(Attachment, Window)) return FALSE;

	for(i = 0; i < ModelData.AttachmentContainer.GetTotalSize(); i++)
	{
		if(ModelData.AttachmentContainer.ValidIndex(i))
		{
			if(ModelData.AttachmentContainer[i] == Attachment)
			{
				ModelData.AttachmentContainer.Remove(i);
				break;
			}
		}
	}

	delete Attachment;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a bone
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveBone(MODEL_BONE* Bone, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(Bone, Window)) return FALSE;

	for(i = 0; i < ModelData.BoneContainer.GetTotalSize(); i++)
	{
		if(ModelData.BoneContainer.ValidIndex(i))
		{
			if(ModelData.BoneContainer[i] == Bone)
			{
				ModelData.BoneContainer.Remove(i);
				break;
			}
		}
	}

	delete Bone;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a collision shape
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveCollisionShape(MODEL_COLLISION_SHAPE* CollisionShape, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(CollisionShape, Window)) return FALSE;

	for(i = 0; i < ModelData.CollisionShapeContainer.GetTotalSize(); i++)
	{
		if(ModelData.CollisionShapeContainer.ValidIndex(i))
		{
			if(ModelData.CollisionShapeContainer[i] == CollisionShape)
			{
				ModelData.CollisionShapeContainer.Remove(i);
				break;
			}
		}
	}

	delete CollisionShape;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes an event object
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveEventObject(MODEL_EVENT_OBJECT* EventObject, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(EventObject, Window)) return FALSE;

	for(i = 0; i < ModelData.EventObjectContainer.GetTotalSize(); i++)
	{
		if(ModelData.EventObjectContainer.ValidIndex(i))
		{
			if(ModelData.EventObjectContainer[i] == EventObject)
			{
				ModelData.EventObjectContainer.Remove(i);
				break;
			}
		}
	}

	delete EventObject;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a helper
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveHelper(MODEL_HELPER* Helper, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(Helper, Window)) return FALSE;

	for(i = 0; i < ModelData.HelperContainer.GetTotalSize(); i++)
	{
		if(ModelData.HelperContainer.ValidIndex(i))
		{
			if(ModelData.HelperContainer[i] == Helper)
			{
				ModelData.HelperContainer.Remove(i);
				break;
			}
		}
	}

	delete Helper;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a light
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveLight(MODEL_LIGHT* Light, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(Light, Window)) return FALSE;

	for(i = 0; i < ModelData.LightContainer.GetTotalSize(); i++)
	{
		if(ModelData.LightContainer.ValidIndex(i))
		{
			if(ModelData.LightContainer[i] == Light)
			{
				ModelData.LightContainer.Remove(i);
				break;
			}
		}
	}

	delete Light;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a particle emitter
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveParticleEmitter(MODEL_PARTICLE_EMITTER* ParticleEmitter, HWND Window)
{
	INT i;

	if(!RemoveBaseNode(ParticleEmitter, Window)) return FALSE;

	for(i = 0; i < ModelData.ParticleEmitterContainer.GetTotalSize(); i++)