triangleview.cpp

详细介绍c++编程

}

void CTriangleView::OnScenemodel() 
{
	if(TRUE == m_bSceneMode)
	{
		m_bSceneMode = FALSE;
	}else
	{
		m_bSceneMode = TRUE;
	}

	Invalidate(FALSE);
}

void CTriangleView::OnUpdateScenemodel(CCmdUI* pCmdUI) 
{
	if(TRUE == m_bSceneMode)
	{
		pCmdUI->SetCheck(TRUE);
	}else
	{
		pCmdUI->SetCheck(FALSE);
	}
}

void CTriangleView::OnRefreshscreen() 
{
	Invalidate(FALSE);	
}

void CTriangleView::LinkFrame(LPFRAME pFrame, LPFRAME pLast)
{
	pFrame->next = pLast->next;
	pFrame->prev = pLast;
	pLast->next->prev = pFrame;
	pLast->next = pFrame;
}

void CTriangleView::DelFrame(LPFRAME pLast)
{
	pLast->next->prev = pLast->prev;
	pLast->prev->next = pLast->next;

	LocalFree(pLast);
}

void CTriangleView::DelGroup(LPANIMATION pLastAnim, BOOL bClearString)
{
	pLastAnim->next->prev =  pLastAnim->prev;
	pLastAnim->prev->next = pLastAnim->next;
	
	CMainFrame *pMainFrame;
	pMainFrame = (CMainFrame*)AfxGetMainWnd();

	CString str;
	str.GetBuffer(20);
	str.Format("%s", pLastAnim->name);

	if(bClearString == TRUE)
		pMainFrame->DelGroupString(&str);

	ClearGroupFrame(pLastAnim);

	LocalFree(pLastAnim);
}

void CTriangleView::ClearGroupFrame(LPANIMATION pAnim)
{
	LPFRAME current;
	LPFRAME last;
	LPFRAME die;

	current = &pAnim->FrameList;
	last = &pAnim->FrameList;

	do
	{
		if(current->m_iFrame != 1)
		{
			die = current;
			current = current->next;
			DelFrame(die);
		}else
		{
			current = current->next;
		}
	}
	while(current != last);
}

void CTriangleView::AddGroup(CString *str)
{
	LPANIMATION pAnim;
	LPANIMATION pLastAnim = Anim.prev;

	m_iTotalGroup ++;

	pAnim = (LPANIMATION)LocalAlloc(LPTR, sizeof(ANIMATION));

	if(pAnim == NULL)
	{
		AfxMessageBox("Error of add group into list");
		return;
	}

	pAnim->m_iID = pLastAnim->m_iID + 1;
	
	strcpy(pAnim->name, (char*)(LPCSTR)(LPCTSTR)*str);

	pAnim->FrameList.next = pAnim->FrameList.prev = &pAnim->FrameList;

	pAnim->m_iTotalFrame = 1;
	pAnim->m_iCurrentFrame = 1;

	pAnim->m_fBaseHeight = 0.0f;

	pAnim->FrameList.m_iFrame = 1;

	pAnim->FrameList.m_fHeadX = 0.0f;
	pAnim->FrameList.m_fHeadY = 0.0f;

	pAnim->FrameList.m_fShoulderX = 0.0f;
	pAnim->FrameList.m_fShoulderY = 0.0f;

	pAnim->FrameList.m_fLeftUpperArmX = 0.0f;
	pAnim->FrameList.m_fLeftUpperArmY = 0.0f;

	pAnim->FrameList.m_fLeftLowerArmX = 0.0f;
	pAnim->FrameList.m_fLeftLowerArmY = 0.0f;

	pAnim->FrameList.m_fLeftHandX = 0.0f;
	pAnim->FrameList.m_fLeftHandY = 0.0f;

	pAnim->FrameList.m_fRightUpperArmX = 0.0f;
	pAnim->FrameList.m_fRightUpperArmY = 0.0f;

	pAnim->FrameList.m_fRightLowerArmX = 0.0f;
	pAnim->FrameList.m_fRightLowerArmY = 0.0f;

	pAnim->FrameList.m_fRightHandX = 0.0f;
	pAnim->FrameList.m_fRightHandY = 0.0f;

	pAnim->FrameList.m_fUpperBodyX = 0.0f;
	pAnim->FrameList.m_fUpperBodyY = 0.0f;

	pAnim->FrameList.m_fLowerBodyX = 0.0f;
	pAnim->FrameList.m_fLowerBodyY = 0.0f;

	pAnim->FrameList.m_fLeftUpperLegX = 0.0f;
	pAnim->FrameList.m_fLeftUpperLegY = 0.0f;

	pAnim->FrameList.m_fLeftLowerLegX = 0.0f;
	pAnim->FrameList.m_fLeftLowerLegY = 0.0f;

	pAnim->FrameList.m_fLeftFootX = 0.0f;
	pAnim->FrameList.m_fLeftFootY = 0.0f;

	pAnim->FrameList.m_fRightUpperLegX = 0.0f;
	pAnim->FrameList.m_fRightUpperLegY = 0.0f;

	pAnim->FrameList.m_fRightLowerLegX = 0.0f;
	pAnim->FrameList.m_fRightLowerLegY = 0.0f;

	pAnim->FrameList.m_fRightFootX = 0.0f;
	pAnim->FrameList.m_fRightFootY = 0.0f;

	pAnim->FrameList.m_fTranslateY = 0.0f;	

	m_pCurrentAnim = pAnim;

	this->LinkGroup(pAnim, pLastAnim);
}

void CTriangleView::LinkGroup(LPANIMATION pAnim, LPANIMATION pLastAnim)
{
	pAnim->next = pLastAnim->next;
	pAnim->prev = pLastAnim;
	pLastAnim->next->prev = pAnim;
	pLastAnim->next = pAnim;
}

void CTriangleView::AddFrame(LPANIMATION pAnim)
{
	LPFRAME pFrame;

	pAnim->m_iTotalFrame ++;
	pAnim->m_iCurrentFrame = pAnim->m_iTotalFrame;

	pFrame = (LPFRAME)LocalAlloc(LPTR, sizeof(FRAME));

	if(pFrame == NULL)
	{
		AfxMessageBox("Error of add frame into list");
		return;
	}

	LPFRAME pLast;
	pLast = pAnim->FrameList.prev;

	pFrame->m_iFrame = pLast->m_iFrame + 1;

	pFrame->m_fHeadX = pLast->m_fHeadX;
	pFrame->m_fHeadY = pLast->m_fHeadY;

	pFrame->m_fShoulderX = pLast->m_fShoulderX;
	pFrame->m_fShoulderY = pLast->m_fShoulderY;

	pFrame->m_fLeftUpperArmX = pLast->m_fLeftUpperArmX;
	pFrame->m_fLeftUpperArmY = pLast->m_fLeftUpperArmY;

	pFrame->m_fLeftLowerArmX = pLast->m_fLeftLowerArmX;
	pFrame->m_fLeftLowerArmY= pLast->m_fLeftLowerArmY;

	pFrame->m_fLeftHandX = pLast->m_fLeftHandX;
	pFrame->m_fLeftHandY = pLast->m_fLeftHandY;

	pFrame->m_fRightUpperArmX = pLast->m_fRightUpperArmX;
	pFrame->m_fRightUpperArmY = pLast->m_fRightUpperArmY;

	pFrame->m_fRightLowerArmX = pLast->m_fRightLowerArmX;
	pFrame->m_fRightLowerArmY= pLast->m_fRightLowerArmY;

	pFrame->m_fRightHandX = pLast->m_fRightHandX;
	pFrame->m_fRightHandY = pLast->m_fRightHandY;

	pFrame->m_fUpperBodyX = pLast->m_fUpperBodyX;
	pFrame->m_fUpperBodyY = pLast->m_fUpperBodyY;

	pFrame->m_fLowerBodyX = pLast->m_fLowerBodyX;
	pFrame->m_fLowerBodyY = pLast->m_fLowerBodyY;

	pFrame->m_fLeftUpperLegX = pLast->m_fLeftUpperLegX;
	pFrame->m_fLeftUpperLegY = pLast->m_fLeftUpperLegY;

	pFrame->m_fLeftLowerLegX = pLast->m_fLeftLowerLegX;
	pFrame->m_fLeftLowerLegY = pLast->m_fLeftLowerLegY;

	pFrame->m_fLeftFootX = pLast->m_fLeftFootX;
	pFrame->m_fLeftFootY = pLast->m_fLeftFootY;

	pFrame->m_fRightUpperLegX = pLast->m_fRightUpperLegX;
	pFrame->m_fRightUpperLegY = pLast->m_fRightUpperLegY;

	pFrame->m_fRightLowerLegX = pLast->m_fRightLowerLegX;
	pFrame->m_fRightLowerLegY = pLast->m_fRightLowerLegY;

	pFrame->m_fRightFootX = pLast->m_fRightFootX;
	pFrame->m_fRightFootY = pLast->m_fRightFootY;

	pFrame->m_fTranslateY = pLast->m_fTranslateY;

	LinkFrame(pFrame, pLast);
}

LPFRAME CTriangleView::GetCurrentFrame(LPANIMATION pAnim)
{
	LPFRAME current;
	LPFRAME last;

	current = &pAnim->FrameList;
	last = &pAnim->FrameList;

	do
	{
		if(current->m_iFrame == pAnim->m_iCurrentFrame)
		{
			return current;
		}
		current = current->next;
	}//do-while
	while(current != last);

	return &pAnim->FrameList;
}

LPANIMATION CTriangleView::GetCurrentAnimation(void)
{
	return m_pCurrentAnim;
}

void CTriangleView::PlaySpeed(int updown)
{
	if(updown == UP)
	{
		m_iPlaySpeed--;
		if(m_iPlaySpeed <= 0)
		{
			m_iPlaySpeed = 0;
		}
	}else
	{
		m_iPlaySpeed ++;
		if(m_iPlaySpeed >= 30)
		{
			m_iPlaySpeed = 30;
		}
	}

	CMainFrame *pMainFrame;
	pMainFrame = (CMainFrame*)AfxGetMainWnd();

	pMainFrame->UpdatePlaySpeedInfo(30 - m_iPlaySpeed);
}

void CTriangleView::ChangeCurrentAnimation(int i, CString& str)
{
	LPANIMATION current;
	LPANIMATION last;

	current = &Anim;
	last = &Anim;

//	int index = 0;
	CString name;
	name.GetBuffer(20);
	do
	{
		name.Format("%s", current->name);
		if(str == name)
		{
			m_pCurrentAnim =  current;
			m_pCurrentAnim->m_iCurrentFrame = 1;
			this->UpdateFrameInfo();
			Invalidate(FALSE);
			return;
		}
		current = current->next;
//		index++;
	}//do-while
	while(current != last);

	this->UpdateFrameInfo();
	m_pCurrentAnim = &Anim;
	m_pCurrentAnim->m_iCurrentFrame = 1;
	Invalidate(FALSE);
}

void CTriangleView::UpdateGroupInfo(void)
{
}

void CTriangleView::UpdateFrameInfo(void)
{
	float x, y;
	CMainFrame *pMainFrame;
	pMainFrame = (CMainFrame*)AfxGetMainWnd();

	LPANIMATION pAnim = this->GetCurrentAnimation();
	LPFRAME pFrame = this->GetCurrentFrame(pAnim);
	pMainFrame->UpdateFrame(pAnim->m_iCurrentFrame, pAnim->m_iTotalFrame);

	this->GetMotionBody(pFrame, body_id, &x, &y);

	pMainFrame->UpdateOrientation(body_id, x, y);
	pMainFrame->UpdatePosition(pFrame->m_fTranslateY);
}

void CTriangleView::ChangeGroupName()
{
	LPANIMATION pAnim = GetCurrentAnimation();
	NameDlg dlg;
	CString sName;
	CString temp;
	
	temp.GetBuffer(20);
	sName.GetBuffer(20);

	if(dlg.DoModal() == IDOK)
	{
		sName = dlg.m_sName;
	
	
	CMainFrame *pMainFrame;
	pMainFrame = (CMainFrame*)AfxGetMainWnd();
	
	temp.Format("%s", pAnim->name);

	pMainFrame->DelGroupString(&temp);

	strcpy(pAnim->name, (char*)(LPCSTR)(LPCTSTR)sName);

	pMainFrame->AddGroupString(&sName);
	pMainFrame->SetCurrentAnim(&sName);
	this->ChangeCurrentAnimation(0, sName);
	}
}

void CTriangleView::GetMotionBody(LPFRAME pFrame, int body_id, float *fOffsetX, float *fOffsetY)
{
	switch(body_id)
	{
	  case HEAD:
		  *fOffsetX = pFrame->m_fHeadX;
		  *fOffsetY = pFrame->m_fHeadY;
	  break;

	  case SHOULDER:
		  *fOffsetX = pFrame->m_fShoulderX;
		  *fOffsetY = pFrame->m_fShoulderY;
	  break;

	  case UPPER_BODY:
		  *fOffsetX = pFrame->m_fUpperBodyX;
		  *fOffsetY = pFrame->m_fUpperBodyY;
	  break;

	  case LOWER_BODY:
		  *fOffsetX = pFrame->m_fLowerBodyX;
		  *fOffsetY = pFrame->m_fLowerBodyY;
	  break;

	  case LEFT_UPPER_ARM:
		  *fOffsetX = pFrame->m_fLeftUpperArmX;
		  *fOffsetY = pFrame->m_fLeftUpperArmY;
	  break;

	  case LEFT_LOWER_ARM:
		  *fOffsetX = pFrame->m_fLeftLowerArmX;
		  *fOffsetY = pFrame->m_fLeftLowerArmY;
	  break;

	  case LEFT_HAND:
		  *fOffsetX = pFrame->m_fLeftHandX;
		  *fOffsetY = pFrame->m_fLeftHandY;
	  break;

	  case RIGHT_UPPER_ARM:
		  *fOffsetX = pFrame->m_fRightUpperArmX;
		  *fOffsetY = pFrame->m_fRightUpperArmY;
	  break;

	  case RIGHT_LOWER_ARM:
		  *fOffsetX = pFrame->m_fRightLowerArmX;
		  *fOffsetY = pFrame->m_fRightLowerArmY;
	  break;

	  case RIGHT_HAND:
		  *fOffsetX = pFrame->m_fRightHandX;
		  *fOffsetY = pFrame->m_fRightHandY;
	  break;

	  case LEFT_UPPER_LEG:
		  *fOffsetX = pFrame->m_fLeftUpperLegX;
		  *fOffsetY = pFrame->m_fLeftUpperLegY;
	  break;

	  case LEFT_LOWER_LEG:
		  *fOffsetX = pFrame->m_fLeftLowerLegX;
		  *fOffsetY = pFrame->m_fLeftLowerLegY;
	  break;

	  case LEFT_FOOT:
		  *fOffsetX = pFrame->m_fLeftFootX;
		  *fOffsetY = pFrame->m_fLeftFootY;
	  break;

	  case RIGHT_UPPER_LEG:
		  *fOffsetX = pFrame->m_fRightUpperLegX;
		  *fOffsetY = pFrame->m_fRightUpperLegY;
	  break;

	  case RIGHT_LOWER_LEG:
		  *fOffsetX = pFrame->m_fRightLowerLegX;
		  *fOffsetY = pFrame->m_fRightLowerLegY;
	  break;

	  case RIGHT_FOOT:
		  *fOffsetX = pFrame->m_fRightFootX;
		  *fOffsetY = pFrame->m_fRightFootY;
	  break;

	  default:
		  *fOffsetX = 0;
		  *fOffsetY = 0;
	  break;
	}
}

void CTriangleView::CheckAngle(float *x, float *y)
{
	if(*x > 360.0f)
	{
		*x -= 360.0f;
	} 

	if(*x < 0.0f)
	{
		*x += 360.0f;
	}

	if(*y > 360.0f)
	{
		*y -= 360.0f;
	} 

	if(*y < 0.0f)
	{
		*y+= 360.0f;
	}
}

void CTriangleView::SetMotionBody(LPFRAME pFrame, int body_id, float fOffsetX, float fOffsetY)
{
	switch(body_id)
	{
	  case HEAD:
		  pFrame->m_fHeadX = fOffsetX;
		  pFrame->m_fHeadY = fOffsetY;
		  this->CheckAngle(&pFrame->m_fHeadX, &pFrame->m_fHeadY);
	  break;

	  case SHOULDER:
		  pFrame->m_fShoulderX = fOffsetX;
		  pFrame->m_fShoulderY = fOffsetY;
		  this->CheckAngle(&pFrame->m_fShoulderX, &pFrame->m_fShoulderY);
	  break;

	  case UPPER_BODY:
		  pFrame->m_fUpperBodyX = fOffsetX;
		  pFrame->m_fUpperBodyY = fOffsetY;
		  this->CheckAngle(&pFrame->m_fUpperBodyX, &pFrame->m_fUpperBodyY);
	  break;

	  case LOWER_BODY:
		  pFrame->m_fLowerBodyX = fOffsetX;
		  pFrame->m_fLowerBodyY = fOffsetY;
		  this->CheckAngle(&pFrame->m_fLowerBodyX, &pFrame->m_fLowerBodyY);
	  break;

	  case LEFT_UPPER_ARM:
		  pFrame->m_fLeftUpperArmX = fOffsetX;
		  pFrame->m_fLeftUpperArmY = fOffsetY;
		  this->CheckAngle(&pFrame->m_fLeftUpperArmX, &pFrame->m_fLeftUpperArmY);
	  break;

	  case LEFT_LOWER_ARM:
		  pFrame->m_fLeftLowerArmX = fOffsetX;
		  pFrame->m_fLeftLowerArmY = fOffsetY;
		  this->CheckAngle(&pFrame->m_fLeftLowerArmX, &pFrame->m_fLeftLowerArmY);
	  break;

	  case LEFT_HAND: