triangleview.cpp

详细介绍c++编程

void CTriangleView::OnInitialUpdate() 
{
	CView::OnInitialUpdate();
	InitAnim();
	InitScene();

	CMainFrame *pMainFrame;
	LPANIMATION pAnim = this->GetCurrentAnimation();

	pMainFrame = (CMainFrame*)AfxGetMainWnd();
	
	pMainFrame->SetCurrentView(this);
	pMainFrame->SetRoot();

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

	pMainFrame->AddGroupString(&str);

	pMainFrame->SetCurrentAnim(&str);

	this->UpdateFrameInfo();
	this->PlaySpeed(UP);

	SetTimer(1, 100, NULL);	
}

void CTriangleView::SetActiveBody(int index)
{
	body_id = index; 
	ManipulateBody(0.0f, 0.0f);
	Invalidate(FALSE);
}

BOOL CTriangleView::PreCreateWindow(CREATESTRUCT& cs)
{
	// Add Window styles required for OpenGL before window is created
	cs.style |= (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CS_OWNDC);

	return CView::PreCreateWindow(cs);
}

void CTriangleView::OnDraw(CDC* pDC)
{
	// Make the rendering context current
	wglMakeCurrent(m_hDC,m_hRC);

	// Call our external OpenGL code
	GLRenderScene(NULL);
	
	// Swap our scene to the front
	SwapBuffers(m_hDC);

	// Allow other rendering contexts to co-exist
	wglMakeCurrent(m_hDC,NULL);
}

#ifdef _DEBUG
void CTriangleView::AssertValid() const
{
	CView::AssertValid();
}

void CTriangleView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CTriangleDoc* CTriangleView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTriangleDoc)));
	return (CTriangleDoc*)m_pDocument;
}
#endif //_DEBUG

void CTriangleView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CTriangleView::OnTimer(UINT nIDEvent) 
{
	LPANIMATION pAnim = this->GetCurrentAnimation();

	if(m_bPlay == TRUE)
	{
		m_iPlayCount++;
		if(m_iPlayCount >= m_iPlaySpeed)
		{
			m_iPlayCount = 0;
			pAnim->m_iCurrentFrame ++;
			if(pAnim->m_iCurrentFrame > pAnim->m_iTotalFrame)
			{
				pAnim->m_iCurrentFrame = 1;
			}

			this->UpdateFrameInfo();
			Invalidate(FALSE);
		}
	}

	CView::OnTimer(nIDEvent);
}

void CTriangleView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	m_bLeftCapture = TRUE;
	m_iLeftCurrentX = point.x;
	m_iLeftCurrentY = point.y;
	m_iLeftOldX = point.x;
	m_iLeftOldY = point.y;
	
	CView::OnLButtonDown(nFlags, point);
}

void CTriangleView::OnLButtonUp(UINT nFlags, CPoint point) 
{
	m_bLeftCapture = FALSE;

	CView::OnLButtonUp(nFlags, point);
}

void CTriangleView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	m_bRightCapture = TRUE;
	m_iRightCurrentX = point.x;
	m_iRightCurrentY = point.y;
	m_iRightOldX = point.x;
	m_iRightOldY = point.y;
	
	CView::OnRButtonDown(nFlags, point);
}

void CTriangleView::OnRButtonUp(UINT nFlags, CPoint point) 
{
	m_bRightCapture = FALSE;
	
	CView::OnRButtonUp(nFlags, point);
}

void CTriangleView::OnMouseMove(UINT nFlags, CPoint point) 
{
	float offsetX;
	float offsetY;
	float offsetZ;

	LPANIMATION pAnim = this->GetCurrentAnimation();
	LPFRAME pFrame = this->GetCurrentFrame(pAnim);

	int WinW, WinH;
	RECT rect;

	this->GetClientRect(&rect);

	WinW = rect.left - rect.right;
	WinH = rect.bottom - rect.top;

	if(WinW < 0)
	{
		WinW = -WinW;
	}

	if(WinH < 0)
	{
		WinH = -WinH;
	}

	if(TRUE == m_bLeftCapture)
	{
		m_iLeftOldX = m_iLeftCurrentX;
		m_iLeftOldY = m_iLeftCurrentY;
		m_iLeftCurrentX = point.x;
		m_iLeftCurrentY = point.y;
		offsetX = (float)(m_iLeftCurrentX - m_iLeftOldX);
		offsetY = (float)(m_iLeftCurrentY - m_iLeftOldY);
		offsetZ = offsetY;

		if(TRUE == m_bConstrainX)
		{
			offsetX = 0.0f;
		}

		if(TRUE == m_bConstrainY)
		{
			offsetY = 0.0f;
		}

		if(TRUE == m_bConstrainZ)
		{
			offsetZ = 0.0f;
		}

		switch(m_iManipulateMode)
		{
		  case TRACKBALL:
			m_vTrackBallOffset[X] += offsetX;
			m_vTrackBallOffset[Y] += offsetY;

			  if(m_vTrackBallOffset[X] >= 360.0f)
			  {
				  m_vTrackBallOffset[X] -= 360.0f;
			  }

			  if(m_vTrackBallOffset[Y] >= 360.0f)
			  {
				  m_vTrackBallOffset[Y] -= 360.0f;
			  }

			  if(m_vTrackBallOffset[X] <= 0.0f)
			  {
				  m_vTrackBallOffset[X] += 360.0f;
			  }

			  if(m_vTrackBallOffset[Y] <= 0.0f)
			  {
				  m_vTrackBallOffset[Y] += 360.0f;
			  }
		  break;

		 case TRANSLATE:
			m_vTranslateOffset[X] += offsetX/50.0f;
			m_vTranslateOffset[Y] += -(offsetY/50.0f);
		 break;

		  case DRIVE:
			m_vTrackBallOffset[Z] += offsetY;
		  break;

		  case SELECTBODY:
			ManipulateBody(offsetX, offsetY);
		  break;

		  case TRANSLATEBODY:
			  this->TranslateBody(offsetY);
		  break;
		}
	}

	if(m_bRightCapture)
	{
		m_iRightOldX = m_iRightCurrentX;
		m_iRightOldY = m_iRightCurrentY;
		m_iRightCurrentX = point.x;
		m_iRightCurrentY = point.y;

		lightangle[X] = (m_iRightCurrentX - WinW/2.0f) * 2.0f * M_PI/WinW;
		lightangle[Y] = (WinH/2.0f - m_iRightCurrentY) * 2.0f * M_PI/WinH;

		lightpos[Y] = sin(lightangle[Y]);
		lightpos[X] = cos(lightangle[Y]) * sin(lightangle[X]);
		lightpos[Z] =  cos(lightangle[Y]) * cos(lightangle[X]);
		lightpos[W] = 0.0f;
		lightchanged[UPDATE_OGL] = GL_TRUE;
		lightchanged[UPDATE_TEX] = GL_TRUE;
	}

	Invalidate(FALSE);
	CView::OnMouseMove(nFlags, point);
}

void CTriangleView::TranslateBody(float Height)
{
	LPANIMATION pAnim = this->GetCurrentAnimation();
	LPFRAME pFrame = this->GetCurrentFrame(pAnim);

	m_fHeight -= (Height/100.0f);

	if(pFrame->m_iFrame == 1)
	{
		pAnim->m_fBaseHeight = m_fHeight;
	}
	pFrame->m_fTranslateY = m_fHeight;
	this->UpdateFrameInfo();
}

void CTriangleView::ManipulateBody(float offsetX, float offsetY)
{
	LPANIMATION pAnim = this->GetCurrentAnimation();
	LPFRAME pFrame = this->GetCurrentFrame(pAnim);

	float tempX;
	float tempY;

	this->GetMotionBody(pFrame, body_id, &tempX, &tempY);

	tempX += offsetX;
	tempY -= offsetY;

	this->SetMotionBody(pFrame, body_id, tempX, tempY);

	this->UpdateFrameInfo();
}

void CTriangleView::OnTrackballmode() 
{
	m_iManipulateMode = TRACKBALL;	
}

void CTriangleView::OnUpdateTrackballmode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == TRACKBALL)
	{
		pCmdUI->SetCheck(TRUE);
	}else
	{
		pCmdUI->SetCheck(FALSE);
	}
}

void CTriangleView::OnTranslatemode() 
{
	m_iManipulateMode = TRANSLATE;	
}

void CTriangleView::OnUpdateTranslatemode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == TRANSLATE)
	{
		pCmdUI->SetCheck(TRUE);
	}else
	{
		pCmdUI->SetCheck(FALSE);
	}	
}

void CTriangleView::OnDrivemode() 
{
	m_iManipulateMode = DRIVE;	
}

void CTriangleView::OnUpdateDrivemode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == DRIVE)
	{
		pCmdUI->SetCheck(TRUE);
	}else
	{
		pCmdUI->SetCheck(FALSE);
	}
}

void CTriangleView::OnSelectbodymode() 
{
	m_iManipulateMode = SELECTBODY;		
}

void CTriangleView::OnUpdateSelectbodymode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == SELECTBODY)
	{
		pCmdUI->SetCheck(TRUE);
	}else
	{
		pCmdUI->SetCheck(FALSE);
	}
}

void CTriangleView::OnTranslatebodymode() 
{
	m_iManipulateMode = TRANSLATEBODY;		
}

void CTriangleView::OnUpdateTranslatebodymode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == TRANSLATEBODY)
	{
		pCmdUI->SetCheck(TRUE);
	}else
	{
		pCmdUI->SetCheck(FALSE);
	}
}


void CTriangleView::OnConstrainXmode() 
{
	if(TRUE == m_bConstrainX)
	{
		m_bConstrainX = FALSE;
	}else
	{
		m_bConstrainX = TRUE;
	}
}

void CTriangleView::OnUpdateConstrainXmode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == TRACKBALL ||
		m_iManipulateMode == TRANSLATE ||
		m_iManipulateMode == SELECTBODY)
	{
		pCmdUI->Enable(TRUE);
		if(TRUE == m_bConstrainX)
		{
			pCmdUI->SetCheck(TRUE);
		}else
		{
			pCmdUI->SetCheck(FALSE);
		}
	}else
	{
		pCmdUI->Enable(FALSE);
	}
}

void CTriangleView::OnConstrainYmode() 
{
	if(TRUE == m_bConstrainY)
	{
		m_bConstrainY = FALSE;
	}else
	{
		m_bConstrainY = TRUE;
	}	
}

void CTriangleView::OnUpdateConstrainYmode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == TRACKBALL ||
		m_iManipulateMode == TRANSLATE ||
		m_iManipulateMode == SELECTBODY ||
		m_iManipulateMode == TRANSLATEBODY)
	{
		pCmdUI->Enable(TRUE);
		if(TRUE == m_bConstrainY)
		{
			pCmdUI->SetCheck(TRUE);
		}else
		{
			pCmdUI->SetCheck(FALSE);
		}
	}else
	{
		pCmdUI->Enable(FALSE);
	}
}

void CTriangleView::OnConstrainZmode() 
{
	if(TRUE == m_bConstrainZ)
	{
		m_bConstrainZ = FALSE;
	}else
	{
		m_bConstrainZ = TRUE;
	}		
}

void CTriangleView::OnUpdateConstrainZmode(CCmdUI* pCmdUI) 
{
	if(m_iManipulateMode == DRIVE)
	{
		pCmdUI->Enable(TRUE);
		if(TRUE == m_bConstrainZ)
		{
			pCmdUI->SetCheck(TRUE);
		}else
		{
			pCmdUI->SetCheck(FALSE);
		}
	}else
	{
		pCmdUI->Enable(FALSE);
	}
}

//Frame Management
void CTriangleView::FramePlay(void)
{
	m_bPlay = TRUE;
}

void CTriangleView::FrameStop(void)
{
	m_bPlay = FALSE;
}

void CTriangleView::FrameAddGroup(void)
{
	NameDlg dlg;
	CString sName;
	
	if(dlg.DoModal() == IDOK)
	{
		sName = dlg.m_sName;
	
		this->AddGroup(&sName);
		this->UpdateFrameInfo();
		this->UpdateGroupInfo();

		LPANIMATION pAnim = this->GetCurrentAnimation();
		CMainFrame *pMainFrame;
		pMainFrame = (CMainFrame*)AfxGetMainWnd();
	
		CString str;
		str.GetBuffer(20);
		str.Format("%s", pAnim->name);

		pMainFrame->AddGroupString(&str);
		pMainFrame->SetCurrentAnim(&str);
	}
	Invalidate(FALSE);
}

void CTriangleView::FrameDelGroup(void)
{
	LPANIMATION pAnim = this->GetCurrentAnimation();

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

	if(pAnim->m_iID == 0)
	{
		AfxMessageBox("You can't delete the default group");
	}else
	{
		m_iTotalGroup--;
		if(m_iTotalGroup < 0)
		{
			AfxMessageBox("Frame Management Error Occur");
			return;
		}else
		{
			this->DelGroup(pAnim);
			str.GetBuffer(20);
			str.Format("%s", pAnim->name);

			m_pCurrentAnim = &Anim;
			str.Empty();
			str.GetBuffer(20);
			str.Format("%s", m_pCurrentAnim->name);
			pMainFrame->SetCurrentAnim(&str);
		}
	}
	this->UpdateFrameInfo();
	Invalidate(FALSE);
}

void CTriangleView::FrameAddFrame(void)