model.cpp

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

	{
		if(ModelData.ParticleEmitterContainer.ValidIndex(i))
		{
			if(ModelData.ParticleEmitterContainer[i] == ParticleEmitter)
			{
				ModelData.ParticleEmitterContainer.Remove(i);
				break;
			}
		}
	}

	delete ParticleEmitter;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a particle emitter 2
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveParticleEmitter2(MODEL_PARTICLE_EMITTER_2* ParticleEmitter2, HWND Window)
{
	INT i;

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

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

	delete ParticleEmitter2;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a ribbon emitter
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveRibbonEmitter(MODEL_RIBBON_EMITTER* RibbonEmitter, HWND Window)
{
	INT i;

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

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

	delete RibbonEmitter;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a camera
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveCamera(MODEL_CAMERA* Camera, HWND Window)
{
	INT i;

	CameraManagerWindow.RemoveName(reinterpret_cast<INT>(Camera));

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

	delete Camera;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a geoset
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveGeoset(MODEL_GEOSET* Geoset, HWND Window)
{
	INT i;

	if(Geoset->BoneNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some bones still references this geoset! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the geoset!");
			return FALSE;
		}

		Geoset->BoneNodes.Clear();
		MainWindow.MakeModelUnsaved();
	}

	if(Geoset->GeosetAnimationNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some geoset animations still references this geoset! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the geoset!");
			return FALSE;
		}

		Geoset->GeosetAnimationNodes.Clear();
	}

	GeosetManagerWindow.RemoveName(reinterpret_cast<INT>(Geoset));

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

	delete Geoset;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a geoset animation
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveGeosetAnimation(MODEL_GEOSET_ANIMATION* GeosetAnimation, HWND Window)
{
	INT i;

	if(GeosetAnimation->BoneNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some bones still references this geoset animation! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the geoset animation!");
			return FALSE;
		}

		GeosetAnimation->BoneNodes.Clear();
	}

	GeosetAnimationManagerWindow.RemoveName(reinterpret_cast<INT>(GeosetAnimation));

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

	delete GeosetAnimation;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a global sequence
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveGlobalSequence(MODEL_GLOBAL_SEQUENCE* GlobalSequence, HWND Window)
{
	INT i;

	if(GlobalSequence->EventObjectNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some event objects still references this global sequence! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the global sequence!");
			return FALSE;
		}

		GlobalSequence->EventObjectNodes.Clear();
		MainWindow.MakeModelUnsaved();
	}

	if(GlobalSequence->InterpolatorNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some interpolators still references this global sequence! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the global sequence!");
			return FALSE;
		}

		GlobalSequence->InterpolatorNodes.Clear();
	}

	GlobalSequenceManagerWindow.RemoveName(reinterpret_cast<INT>(GlobalSequence));

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

	delete GlobalSequence;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a material
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveMaterial(MODEL_MATERIAL* Material, HWND Window)
{
	INT i;

	if(Material->GeosetNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some geosets still references this material! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the material!");
			return FALSE;
		}

		Material->GeosetNodes.Clear();
		MainWindow.MakeModelUnsaved();
	}

	if(Material->RibbonEmitterNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some ribbon emitters still references this material! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the material!");
			return FALSE;
		}

		Material->RibbonEmitterNodes.Clear();
	}

	MaterialManagerWindow.RemoveName(reinterpret_cast<INT>(Material));

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

	delete Material;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a pivot point
//+-----------------------------------------------------------------------------
BOOL MODEL::RemovePivotPoint(D3DXVECTOR3* PivotPoint, HWND Window)
{
	INT i;

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

	delete PivotPoint;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a sequence
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveSequence(MODEL_SEQUENCE* Sequence, HWND Window)
{
	INT i;

	if(Sequence->ModelNodes.GetReferenceCount() > 0)
	{
		Error.SetMessage("Unable to remove the sequence, this sequence is currently being played!");
		return FALSE;
	}

	AnimationWindow.RemoveAnimation(reinterpret_cast<INT>(Sequence));
	SequenceManagerWindow.RemoveName(reinterpret_cast<INT>(Sequence));

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

	delete Sequence;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a texture
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveTexture(MODEL_TEXTURE* Texture, HWND Window)
{
	INT i;

	if(Texture->MaterialLayerNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some material layers still references this texture! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the texture!");
			return FALSE;
		}

		Texture->MaterialLayerNodes.Clear();
		MainWindow.MakeModelUnsaved();
	}

	if(Texture->ParticleEmitter2Nodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some particle emitters 2 still references this texture! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the texture!");
			return FALSE;
		}

		Texture->ParticleEmitter2Nodes.Clear();
	}

	TextureManagerWindow.RemoveName(reinterpret_cast<INT>(Texture));

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

	delete Texture;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Removes a texture animation
//+-----------------------------------------------------------------------------
BOOL MODEL::RemoveTextureAnimation(MODEL_TEXTURE_ANIMATION* TextureAnimation, HWND Window)
{
	INT i;

	if(TextureAnimation->MaterialLayerNodes.GetReferenceCount() > 0)
	{
		if(MessageBox(Window, "Some material layers still references this texture animation! Detach?", "Message", MB_YESNO | MB_ICONQUESTION) == IDNO)
		{
			Error.SetMessage("Unable to remove the texture animation!");
			return FALSE;
		}

		TextureAnimation->MaterialLayerNodes.Clear();
	}

	TextureAnimationManagerWindow.RemoveName(reinterpret_cast<INT>(TextureAnimation));

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

	delete TextureAnimation;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Returns the node with a specific object ID
//+-----------------------------------------------------------------------------
MODEL_BASE* MODEL::GetNode(INT ObjectId)
{
	INT i;

	for(i = 0; i < ModelData.BaseContainer.GetTotalSize(); i++)
	{
		if(ModelData.BaseContainer.ValidIndex(i))
		{
			if(ModelData.BaseContainer[i]->BaseData()->ObjectId == ObjectId)
			{
				return ModelData.BaseContainer[i];