modelwindow.cpp

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

		ViewList[CurrentView].Scale += (static_cast<FLOAT>(ModelMouse.GetDZ()) * CAMERA_FACTOR_DISTANCE * ViewList[CurrentView].Scale);

		if(ViewList[CurrentView].Scale < 0.01f) ViewList[CurrentView].Scale = 0.01f;
		if(ViewList[CurrentView].Scale > 100.0f) ViewList[CurrentView].Scale = 100.0f;
	}

	if(ModelMouse.ButtonDown(BUTTON_RIGHT) && (ActiveRightButtonView != INVALID_INDEX))
	{
		FLOAT TempX;
		FLOAT TempY;

		TempX = static_cast<FLOAT>(ModelMouse.GetDX()) * 2.0f / ViewList[ActiveRightButtonView].Scale;
		TempY = static_cast<FLOAT>(-ModelMouse.GetDY()) * 2.0f / ViewList[ActiveRightButtonView].Scale;

		switch(ViewList[ActiveRightButtonView].ViewType)
		{
			case VIEW_TYPE_NONE:
			{
				break;
			}

			case VIEW_TYPE_XY_FRONT:
			{
				ViewList[ActiveRightButtonView].Position.x += TempX;
				ViewList[ActiveRightButtonView].Position.y += TempY;
				break;
			}

			case VIEW_TYPE_XY_BACK:
			{
				ViewList[ActiveRightButtonView].Position.x -= TempX;
				ViewList[ActiveRightButtonView].Position.y += TempY;
				break;
			}

			case VIEW_TYPE_XZ_FRONT:
			{
				ViewList[ActiveRightButtonView].Position.x += TempX;
				ViewList[ActiveRightButtonView].Position.z += TempY;
				break;
			}

			case VIEW_TYPE_XZ_BACK:
			{
				ViewList[ActiveRightButtonView].Position.x -= TempX;
				ViewList[ActiveRightButtonView].Position.z += TempY;
				break;
			}

			case VIEW_TYPE_YZ_FRONT:
			{
				ViewList[ActiveRightButtonView].Position.y += TempX;
				ViewList[ActiveRightButtonView].Position.z += TempY;
				break;
			}

			case VIEW_TYPE_YZ_BACK:
			{
				ViewList[ActiveRightButtonView].Position.y -= TempX;
				ViewList[ActiveRightButtonView].Position.z += TempY;
				break;
			}
		}
	}

	if(!WindowActive) return;

	for(i = 0; i < 4; i++)
	{
		if(Graphics.BeginRender(ViewList[i].GraphicsWindow))
		{
			RenderView(i, ViewList[i].ViewType);
			Graphics.EndRender();
		}
	}
}


//+-----------------------------------------------------------------------------
//| Translates the selected vertices
//+-----------------------------------------------------------------------------
BOOL MODEL_WINDOW::Translate()
{
	INT i;
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_VERTEX* GeosetVertex;
	TRANSLATE_INFO TranslateInfo;
	std::set<INT>::iterator j;

	if(!TranslateDialog.Display(Window, TranslateInfo)) return TRUE;

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			Geoset = Model.Data().GeosetContainer[i];
			j = Geoset->SelectedVertices.begin();
			while(j != Geoset->SelectedVertices.end())
			{
				GeosetVertex = Geoset->Data().VertexContainer[*j];
				GeosetVertex->Position += TranslateInfo.Translation;
				j++;
			}
		}
	}

	Model.Rebuild();
	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Rotates the selected vertices
//+-----------------------------------------------------------------------------
BOOL MODEL_WINDOW::Rotate()
{
	INT i;
	FLOAT Angle;
	D3DXMATRIX Matrix;
	D3DXMATRIX TempMatrix;
	D3DXVECTOR3 Centre;
	D3DXVECTOR4 TempVector;
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_VERTEX* GeosetVertex;
	ROTATE_INFO RotateInfo;
	std::set<INT>::iterator j;

	RotateInfo.PivotPoint = PivotPoint;

	if(!RotateDialog.Display(Window, RotateInfo)) return TRUE;

	if(RotateInfo.AroundPivotPoint)
	{
		PivotPoint = RotateInfo.PivotPoint;
		Centre = PivotPoint;
	}
	else
	{
		Centre = CalculateMassCentre();
	}

	Angle = RotateInfo.Angle;
	if(!RotateInfo.Radians) Angle *= (D3DX_PI / 180.0f);

	switch(RotateInfo.Type)
	{
		case ROTATION_TYPE_X:
		{
			D3DXMatrixRotationX(&Matrix, Angle);
			break;
		}

		case ROTATION_TYPE_Y:
		{
			D3DXMatrixRotationY(&Matrix, Angle);
			break;
		}

		case ROTATION_TYPE_Z:
		{
			D3DXMatrixRotationZ(&Matrix, Angle);
			break;
		}

		case ROTATION_TYPE_AXIS:
		{
			D3DXMatrixRotationAxis(&Matrix, &RotateInfo.Axis, Angle);
			break;
		}

		case ROTATION_TYPE_QUATERNION:
		{
			D3DXMatrixRotationQuaternion(&Matrix, &RotateInfo.Quaternion);
			break;
		}

		default:
		{
			D3DXMatrixIdentity(&Matrix);
			break;
		}
	}

	D3DXMatrixTranslation(&TempMatrix, -Centre.x, -Centre.y, -Centre.z);
	D3DXMatrixMultiply(&Matrix, &TempMatrix, &Matrix);
	D3DXMatrixTranslation(&TempMatrix, Centre.x, Centre.y, Centre.z);
	D3DXMatrixMultiply(&Matrix, &Matrix, &TempMatrix);

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			Geoset = Model.Data().GeosetContainer[i];
			j = Geoset->SelectedVertices.begin();
			while(j != Geoset->SelectedVertices.end())
			{
				GeosetVertex = Geoset->Data().VertexContainer[*j];
				D3DXVec3Transform(&TempVector, &GeosetVertex->Position, &Matrix);
				GeosetVertex->Position.x = TempVector.x;
				GeosetVertex->Position.y = TempVector.y;
				GeosetVertex->Position.z = TempVector.z;
				j++;
			}
		}
	}

	Model.Rebuild();
	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Scales the selected vertices
//+-----------------------------------------------------------------------------
BOOL MODEL_WINDOW::Scale()
{
	INT i;
	D3DXVECTOR3 Centre;
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_VERTEX* GeosetVertex;
	SCALE_INFO ScaleInfo;
	std::set<INT>::iterator j;

	ScaleInfo.PivotPoint = PivotPoint;

	if(!ScaleDialog.Display(Window, ScaleInfo)) return TRUE;

	if(ScaleInfo.AroundPivotPoint)
	{
		PivotPoint = ScaleInfo.PivotPoint;
		Centre = PivotPoint;
	}
	else
	{
		Centre = CalculateMassCentre();
	}

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			Geoset = Model.Data().GeosetContainer[i];
			j = Geoset->SelectedVertices.begin();
			while(j != Geoset->SelectedVertices.end())
			{
				GeosetVertex = Geoset->Data().VertexContainer[*j];
				GeosetVertex->Position -= Centre;
				GeosetVertex->Position.x *= ScaleInfo.Scaling.x;
				GeosetVertex->Position.y *= ScaleInfo.Scaling.y;
				GeosetVertex->Position.z *= ScaleInfo.Scaling.z;
				GeosetVertex->Position += Centre;
				j++;
			}
		}
	}

	Model.Rebuild();
	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Selects vertices and faces
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::Select()
{
	INT i;
	INT j;
	D3DXVECTOR3 Min;
	D3DXVECTOR3 Max;
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_VERTEX* GeosetVertex;
	std::set<INT>::iterator Iterator;

	if(SelectingView == INVALID_INDEX) return;

	Min.x = std::min(SelectionStart.x, SelectionEnd.x);
	Min.y = std::min(SelectionStart.y, SelectionEnd.y);
	Min.z = std::min(SelectionStart.z, SelectionEnd.z);
	Max.x = std::max(SelectionStart.x, SelectionEnd.x);
	Max.y = std::max(SelectionStart.y, SelectionEnd.y);
	Max.z = std::max(SelectionStart.z, SelectionEnd.z);

	switch(ViewList[SelectingView].ViewType)
	{
		case VIEW_TYPE_XY_FRONT:
		case VIEW_TYPE_XY_BACK:
		{
			Min.z = -std::numeric_limits<FLOAT>::max();
			Max.z = std::numeric_limits<FLOAT>::max();
			break;
		}

		case VIEW_TYPE_XZ_FRONT:
		case VIEW_TYPE_XZ_BACK:
		{
			Min.y = -std::numeric_limits<FLOAT>::max();
			Max.y = std::numeric_limits<FLOAT>::max();
			break;
		}

		case VIEW_TYPE_YZ_FRONT:
		case VIEW_TYPE_YZ_BACK:
		{
			Min.x = -std::numeric_limits<FLOAT>::max();
			Max.x = std::numeric_limits<FLOAT>::max();
			break;
		}
	}

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			Geoset = Model.Data().GeosetContainer[i];
			for(j = 0; j < Geoset->Data().VertexContainer.GetTotalSize(); j++)
			{
				if(Geoset->Data().VertexContainer.ValidIndex(j))
				{
					GeosetVertex = Geoset->Data().VertexContainer[j];
					while(TRUE)
					{
						if(GeosetVertex->Position.x < Min.x) break;
						if(GeosetVertex->Position.y < Min.y) break;
						if(GeosetVertex->Position.z < Min.z) break;
						if(GeosetVertex->Position.x > Max.x) break;
						if(GeosetVertex->Position.y > Max.y) break;
						if(GeosetVertex->Position.z > Max.z) break;

						if(DeselectMode)
						{
							Iterator = Geoset->SelectedVertices.find(j);
							if(Iterator != Geoset->SelectedVertices.end())
							{
								Geoset->SelectedVertices.erase(Iterator);
							}
						}
						else
						{
							Geoset->SelectedVertices.insert(j);
						}

						break;
					}
				}
			}
		}
	}
}


//+-----------------------------------------------------------------------------
//| Selects all vertices
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::SelectAllVertices()
{
	INT i;
	INT j;
	MODEL_GEOSET* Geoset;

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			Geoset = Model.Data().GeosetContainer[i];
			for(j = 0; j < Geoset->Data().VertexContainer.GetTotalSize(); j++)
			{
				if(Geoset->Data().VertexContainer.ValidIndex(j))
				{
					Geoset->SelectedVertices.insert(j);
				}
			}
		}
	}
}


//+-----------------------------------------------------------------------------
//| Selects all faces
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::SelectAllFaces()
{
	INT i;
	INT j;
	MODEL_GEOSET* Geoset;

	for(i = 0; i < Model.Data().GeosetContainer.GetTotalSize(); i++)
	{
		if(Model.Data().GeosetContainer.ValidIndex(i))
		{
			Geoset = Model.Data().GeosetContainer[i];
			for(j = 0; j < Geoset->Data().FaceContainer.GetTotalSize(); j++)
			{
				if(Geoset->Data().VertexContainer.ValidIndex(j))
				{
					Geoset->SelectedFaces.insert(j);
				}
			}
		}
	}
}


//+-----------------------------------------------------------------------------
//| Selects no vertices
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::SelectNoVertices()
{
	INT i;

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


//+-----------------------------------------------------------------------------
//| Selects no faces
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::SelectNoFaces()
{
	INT i;

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


//+-----------------------------------------------------------------------------
//| Renders a view
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::RenderView(INT Index, VIEW_TYPE ViewType)
{
	INT i;
	D3DXMATRIX Matrix;
	D3DXMATRIX TempMatrix;

	if(Index == CurrentView) Graphics.RenderFill(COLOR_BACKGROUND_SELECTED);
	else Graphics.RenderFill(COLOR_BACKGROUND_UNSELECTED);

	Graphics.PrepareForViews();
	BuildViewMatrices(Index, ViewType);

	if(ViewList[Index].ViewType != VIEW_TYPE_NONE)