📄 modelwindow.cpp

📁 骨骼动画....把魔兽模型解出的代码..
💻 CPP
📖 第 1 页 / 共 3 页
字号:
上一页 1 23
	{
		Graphics.GetDevice()->SetRenderState(D3DRS_BLENDFACTOR, COLOR_FACE);
		Graphics.GetDevice()->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

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

		Graphics.GetDevice()->SetFVF(LINE_VERTEX::FORMAT);
		Graphics.GetDevice()->SetRenderState(D3DRS_BLENDFACTOR, 0xFFFFFFFF);

		RenderVertices(Index);
		RenderCross(Index, PivotPoint, 10.0f, COLOR_PIVOT_POINT);

		if(Selecting && (Index == SelectingView)) RenderSelectionBox();
	}

	Graphics.RenderText(VIEW_NAME[ViewType], 0, 0, COLOR_TEXT);
}


//+-----------------------------------------------------------------------------
//| Renders a cross
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::RenderCross(INT ViewIndex, CONST D3DXVECTOR3& Position, FLOAT Scale, D3DCOLOR Color)
{
	FLOAT Size;

	Size = (ViewList[ViewIndex].Scale == 0.0f) ? Scale : Scale / ViewList[ViewIndex].Scale;

	Graphics.RenderLine(Position - D3DXVECTOR3(Size, 0.0f, 0.0f), Position + D3DXVECTOR3(Size, 0.0f, 0.0f), Color);
	Graphics.RenderLine(Position - D3DXVECTOR3(0.0f, Size, 0.0f), Position + D3DXVECTOR3(0.0f, Size, 0.0f), Color);
	Graphics.RenderLine(Position - D3DXVECTOR3(0.0f, 0.0f, Size), Position + D3DXVECTOR3(0.0f, 0.0f, Size), Color);
}


//+-----------------------------------------------------------------------------
//| Renders the selection box
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::RenderSelectionBox()
{
	D3DCOLOR Color;
	D3DXVECTOR3 Corner1;
	D3DXVECTOR3 Corner2;
	D3DXVECTOR3 Corner3;
	D3DXVECTOR3 Corner4;
	D3DXVECTOR3 Corner5;
	D3DXVECTOR3 Corner6;
	D3DXVECTOR3 Corner7;
	D3DXVECTOR3 Corner8;

	Color = DeselectMode ? COLOR_FRAME_DESELECT : COLOR_FRAME_SELECT;

	Corner1 = D3DXVECTOR3(SelectionStart.x, SelectionStart.y, SelectionStart.z);
	Corner2 = D3DXVECTOR3(SelectionStart.x, SelectionStart.y, SelectionEnd.z);
	Corner3 = D3DXVECTOR3(SelectionStart.x, SelectionEnd.y, SelectionStart.z);
	Corner4 = D3DXVECTOR3(SelectionStart.x, SelectionEnd.y, SelectionEnd.z);
	Corner5 = D3DXVECTOR3(SelectionEnd.x, SelectionStart.y, SelectionStart.z);
	Corner6 = D3DXVECTOR3(SelectionEnd.x, SelectionStart.y, SelectionEnd.z);
	Corner7 = D3DXVECTOR3(SelectionEnd.x, SelectionEnd.y, SelectionStart.z);
	Corner8 = D3DXVECTOR3(SelectionEnd.x, SelectionEnd.y, SelectionEnd.z);

	Graphics.GetDevice()->SetFVF(LINE_VERTEX::FORMAT);
	Graphics.GetDevice()->SetRenderState(D3DRS_BLENDFACTOR, 0xFFFFFFFF);

	Graphics.RenderLine(Corner1, Corner2, Color);
	Graphics.RenderLine(Corner1, Corner3, Color);
	Graphics.RenderLine(Corner1, Corner5, Color);
	Graphics.RenderLine(Corner2, Corner4, Color);
	Graphics.RenderLine(Corner2, Corner6, Color);
	Graphics.RenderLine(Corner3, Corner4, Color);
	Graphics.RenderLine(Corner3, Corner7, Color);
	Graphics.RenderLine(Corner4, Corner8, Color);
	Graphics.RenderLine(Corner5, Corner6, Color);
	Graphics.RenderLine(Corner5, Corner7, Color);
	Graphics.RenderLine(Corner6, Corner8, Color);
	Graphics.RenderLine(Corner7, Corner8, Color);
}


//+-----------------------------------------------------------------------------
//| Renders the vertices
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::RenderVertices(INT ViewIndex)
{
	INT i;
	INT j;
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_VERTEX* GeosetVertex;

	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];
					if(Geoset->SelectedVertices.find(j) != Geoset->SelectedVertices.end())
					{
						RenderCross(ViewIndex, GeosetVertex->Position, 2.5f, COLOR_VERTEX_SELECTED);
					}
					else
					{
						RenderCross(ViewIndex, GeosetVertex->Position, 2.5f, COLOR_VERTEX_DESELECTED);
					}
				}
			}
		}
	}
}


//+-----------------------------------------------------------------------------
//| Builds the matrices for a view
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::BuildViewMatrices(INT Index, VIEW_TYPE ViewType)
{
	D3DXMATRIX Matrix;
	D3DXMATRIX TempMatrix;

	D3DXMatrixTranslation(&Matrix, ViewList[Index].Position.x, ViewList[Index].Position.y, ViewList[Index].Position.z);
	D3DXMatrixScaling(&TempMatrix, ViewList[Index].Scale, ViewList[Index].Scale, ViewList[Index].Scale);
	D3DXMatrixMultiply(&Matrix, &Matrix, &TempMatrix);
	Graphics.SetWorldMatrix(Matrix);

	switch(ViewList[Index].ViewType)
	{
		case VIEW_TYPE_NONE:
		{
			D3DXMatrixIdentity(&Matrix);
			break;
		}

		case VIEW_TYPE_XY_FRONT:
		{
			D3DXMatrixIdentity(&Matrix);
			break;
		}

		case VIEW_TYPE_XY_BACK:
		{
			D3DXMatrixRotationY(&Matrix, D3DX_PI);
			break;
		}

		case VIEW_TYPE_XZ_FRONT:
		{
			D3DXMatrixRotationX(&Matrix, (1.5f * D3DX_PI));
			break;
		}

		case VIEW_TYPE_XZ_BACK:
		{
			D3DXMatrixRotationX(&Matrix, (1.5f * D3DX_PI));
			D3DXMatrixRotationY(&TempMatrix, D3DX_PI);
			D3DXMatrixMultiply(&Matrix, &Matrix, &TempMatrix);
			break;
		}

		case VIEW_TYPE_YZ_FRONT:
		{
			D3DXMatrixRotationX(&Matrix, (1.5f * D3DX_PI));
			D3DXMatrixRotationY(&TempMatrix, (1.5f * D3DX_PI));
			D3DXMatrixMultiply(&Matrix, &Matrix, &TempMatrix);
			break;
		}

		case VIEW_TYPE_YZ_BACK:
		{
			D3DXMatrixRotationX(&Matrix, (1.5f * D3DX_PI));
			D3DXMatrixRotationY(&TempMatrix, (0.5f * D3DX_PI));
			D3DXMatrixMultiply(&Matrix, &Matrix, &TempMatrix);
			break;
		}
	}

	Graphics.SetViewMatrix(Matrix);

	D3DXMatrixOrthoRH(&Matrix, static_cast<FLOAT>(ViewList[Index].Width), static_cast<FLOAT>(ViewList[Index].Height), Properties().NearDistance, Properties().FarDistance);
	Graphics.SetProjectionMatrix(Matrix);
}


//+-----------------------------------------------------------------------------
//| Builds a projection plane from the view
//+-----------------------------------------------------------------------------
D3DXPLANE MODEL_WINDOW::BuildProjectionPlane(INT ViewIndex, CONST D3DXVECTOR3& Point)
{
	D3DXPLANE Plane;
	D3DXVECTOR3 PlaneNormal;

	switch(ViewList[ViewIndex].ViewType)
	{
		case VIEW_TYPE_XY_FRONT:
		{
			PlaneNormal = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
			break;
		}

		case VIEW_TYPE_XY_BACK:
		{
			PlaneNormal = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
			break;
		}

		case VIEW_TYPE_XZ_FRONT:
		{
			PlaneNormal = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
			break;
		}

		case VIEW_TYPE_XZ_BACK:
		{
			PlaneNormal = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
			break;
		}

		case VIEW_TYPE_YZ_FRONT:
		{
			PlaneNormal = D3DXVECTOR3(1.0f, 0.0f, 0.0f);
			break;
		}

		case VIEW_TYPE_YZ_BACK:
		{
			PlaneNormal = D3DXVECTOR3(1.0f, 0.0f, 0.0f);
			break;
		}

		default:
		{
			PlaneNormal = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
			break;
		}
	}

	D3DXPlaneFromPointNormal(&Plane, &Point, &PlaneNormal);

	return Plane;
}


//+-----------------------------------------------------------------------------
//| Converts a screen position to a world position
//+-----------------------------------------------------------------------------
D3DXVECTOR3 MODEL_WINDOW::ScreenPositionToWorldPosition(INT ViewIndex, CONST D3DXPLANE& ProjectionPlane, INT X, INT Y)
{
	D3DVIEWPORT9 ViewPort;
	D3DXVECTOR3 TempVector;
	D3DXVECTOR3 TempVector1;
	D3DXVECTOR3 TempVector2;

	if(ViewIndex == INVALID_INDEX) return D3DXVECTOR3(0.0f, 0.0f, 0.0f);

	BuildViewMatrices(ViewIndex, ViewList[ViewIndex].ViewType);

	ViewPort.X = 0;
	ViewPort.Y = 0;
	ViewPort.Width = ViewList[ViewIndex].GraphicsWindow.GetWidth();
	ViewPort.Height = ViewList[ViewIndex].GraphicsWindow.GetHeight();
	ViewPort.MinZ = 0.0f;
	ViewPort.MaxZ = 1.0f;

	D3DXVec3Unproject(&TempVector1, &D3DXVECTOR3(static_cast<FLOAT>(X), static_cast<FLOAT>(Y), 0.0f), &ViewPort, &Graphics.GetProjectionMatrix(), &Graphics.GetViewMatrix(), &Graphics.GetWorldMatrix());
	D3DXVec3Unproject(&TempVector2, &D3DXVECTOR3(static_cast<FLOAT>(X), static_cast<FLOAT>(Y), 1.0f), &ViewPort, &Graphics.GetProjectionMatrix(), &Graphics.GetViewMatrix(), &Graphics.GetWorldMatrix());
	D3DXPlaneIntersectLine(&TempVector, &ProjectionPlane, &TempVector1, &TempVector2);

	return TempVector;
}


//+-----------------------------------------------------------------------------
//| Creates a view
//+-----------------------------------------------------------------------------
HWND MODEL_WINDOW::CreateView()
{
	HWND View;
	DWORD Style;

	Style = WS_VISIBLE | WS_CHILD | WS_THICKFRAME;

	View = CreateWindowEx(0, "STATIC", "", Style, 0, 0, 1, 1, Window, NULL, GetModuleHandle(NULL), NULL);
	if(View == NULL)
	{
		Error.SetMessage("Unable to create a new view!");
		return FALSE;
	}

	return View;
}


//+-----------------------------------------------------------------------------
//| Resizes the views
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::ResizeViews()
{
	INT i;
	INT Width;
	INT Height;
	INT HalfWidth;
	INT HalfHeight;

	Width = GetWidth();
	Height = GetHeight();
	HalfWidth = Width / 2;
	HalfHeight = Height / 2;

	ViewList[VIEW_INDEX_TOP_LEFT].X = 0;
	ViewList[VIEW_INDEX_TOP_LEFT].Y = 0;
	ViewList[VIEW_INDEX_TOP_LEFT].Width = HalfWidth;
	ViewList[VIEW_INDEX_TOP_LEFT].Height = HalfHeight;

	ViewList[VIEW_INDEX_TOP_RIGHT].X = HalfWidth;
	ViewList[VIEW_INDEX_TOP_RIGHT].Y = 0;
	ViewList[VIEW_INDEX_TOP_RIGHT].Width = (Width - HalfWidth);
	ViewList[VIEW_INDEX_TOP_RIGHT].Height = HalfHeight;

	ViewList[VIEW_INDEX_BOTTOM_LEFT].X = 0;
	ViewList[VIEW_INDEX_BOTTOM_LEFT].Y = HalfHeight;
	ViewList[VIEW_INDEX_BOTTOM_LEFT].Width = HalfWidth;
	ViewList[VIEW_INDEX_BOTTOM_LEFT].Height = (Height - HalfHeight);

	ViewList[VIEW_INDEX_BOTTOM_RIGHT].X = HalfWidth;
	ViewList[VIEW_INDEX_BOTTOM_RIGHT].Y = HalfHeight;
	ViewList[VIEW_INDEX_BOTTOM_RIGHT].Width = (Width - HalfWidth);
	ViewList[VIEW_INDEX_BOTTOM_RIGHT].Height = (Height - HalfHeight);

	for(i = 0; i < 4; i++)
	{
		::SetWindowPos(ViewList[i].Window, NULL, ViewList[i].X, ViewList[i].Y, ViewList[i].Width, ViewList[i].Height, SWP_NOACTIVATE | SWP_NOZORDER);
		ViewList[i].GraphicsWindow.Resize();
	}
}


//+-----------------------------------------------------------------------------
//| Selects a specific view
//+-----------------------------------------------------------------------------
VOID MODEL_WINDOW::SelectView(INT View)
{
	DWORD Style;

	if(CurrentView != INVALID_INDEX)
	{
		Style = GetWindowLong(ViewList[CurrentView].Window, GWL_STYLE);
		//Style &= ~WS_BORDER;
		SetWindowLong(ViewList[CurrentView].Window, GWL_STYLE, Style);
		CurrentView = INVALID_INDEX;
	}

	CurrentView = View;

	if(CurrentView != INVALID_INDEX)
	{
		Style = GetWindowLong(ViewList[CurrentView].Window, GWL_STYLE);
		//Style |= WS_BORDER;
		SetWindowLong(ViewList[CurrentView].Window, GWL_STYLE, Style);
	}

	InvalidateRect(Window, NULL, FALSE);
}


//+-----------------------------------------------------------------------------
//| Selects a specific view
//+-----------------------------------------------------------------------------
INT MODEL_WINDOW::GetView(INT X, INT Y)
{
	INT View;
	INT Width;
	INT Height;
	INT HalfWidth;
	INT HalfHeight;

	Width = GetWidth();
	Height = GetHeight();
	HalfWidth = Width / 2;
	HalfHeight = Height / 2;

	if(X < 1) return INVALID_INDEX;
	if(Y < 1) return INVALID_INDEX;
	if(X >= (Width - 1)) return INVALID_INDEX;
	if(Y >= (Height - 1)) return INVALID_INDEX;

	if(X < HalfWidth)
	{
		if(Y < HalfHeight)
		{
			View = VIEW_INDEX_TOP_LEFT;
		}
		else
		{
			View = VIEW_INDEX_BOTTOM_LEFT;
		}
	}
	else
	{
		if(Y < HalfHeight)
		{
			View = VIEW_INDEX_TOP_RIGHT;
		}
		else
		{
			View = VIEW_INDEX_BOTTOM_RIGHT;
		}
	}

	return View;
}


//+-----------------------------------------------------------------------------
//| Calculates the mass centre of all selected vertices
//+-----------------------------------------------------------------------------
D3DXVECTOR3 MODEL_WINDOW::CalculateMassCentre()
{
	INT i;
	INT Amount;
	FLOAT Scale;
	D3DXVECTOR3 Centre;
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_VERTEX* GeosetVertex;
	std::set<INT>::iterator j;

	Amount = 0;
	Centre = D3DXVECTOR3(0.0f, 0.0f, 0.0f);

	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];
				Centre += GeosetVertex->Position;
				Amount++;
				j++;
			}
		}
	}

	Scale = (Amount == 0) ? 1.0f : (1.0f / static_cast<FLOAT>(Amount));
	Centre.x *= Scale;
	Centre.y *= Scale;
	Centre.z *= Scale;

	return Centre;
}
上一页 1 23
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -