www.pudn.com > mfcopentree.rar > MfcopenView.cpp

// MfcopenView.cpp : implementation of the CMfcopenView class 
//武汉华中科技大学，2002，（C）版权所有 
//作者：金德才 联系方式：iskyflying@163.com 
//请不要将本软件的任何一部分用于商业用途 
//如果您觉得任何地方有用或者错误，请告诉作者，谢谢！ 
//如果你想引用部分源程序，请注明作者信息 
//////////////////////////////////////// 
 
#include "stdafx.h" 
#include "Mfcopen.h" 
#include "MainFrm.h" 
#include "MfcopenDoc.h" 
#include "MfcopenView.h" 
#include "math.h" 
#include "TransParaDlg.h" 
#include "Childtree.h" 
#include "PlanDlg.h" 
#include "Precisiondlg.h" 
#include "ChineseFont.h" 
#include "Welcome.h" 
 
#include "MyBitmap.h" 
 
#include  
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
enum {INT_TRANSLATE, INT_ROTATE, INT_ZOOM, INT_ZOOM_RECT, INT_FIT, INT_END}; 
enum {INT_FRONT, INT_TOP, INT_LEFT, INT_BACK, INT_NULL}; 
enum {INT_LINE, INT_PORT, INT_LAST}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMfcopenView 
int      m_gwel = 0; 
glchar_s sztemp_jin, sztemp_de, sztemp_cai; 
wchar_t  *szfont_jin = L"金"; 
wchar_t  *szfont_de  = L"德"; 
wchar_t  *szfont_cai = L"才"; 
extern int whichnode; 
extern long zongshu; 
extern double zongshu_d; 
 
const float sita = 0.8f;//测试旋转量 
float test = 0; 
int settime = 0; 
static g_createtree = 0; 
BOOL  g_bganshe = FALSE; 
 
 
IMPLEMENT_DYNCREATE(CMfcopenView, CView) 
 
BEGIN_MESSAGE_MAP(CMfcopenView, CView) 
	//{{AFX_MSG_MAP(CMfcopenView) 
	ON_WM_CREATE() 
	ON_WM_SIZE() 
	ON_WM_TIMER() 
	ON_WM_LBUTTONDOWN() 
	ON_WM_LBUTTONUP() 
	ON_WM_MOUSEMOVE() 
	ON_COMMAND(ID_TRANSLATE, OnTranslate) 
	ON_UPDATE_COMMAND_UI(ID_TRANSLATE, OnUpdateTranslate) 
	ON_UPDATE_COMMAND_UI(ID_ROTATE, OnUpdateRotate) 
	ON_COMMAND(ID_ROTATE, OnRotate) 
	ON_COMMAND(ID_ZOOM, OnZoom) 
	ON_UPDATE_COMMAND_UI(ID_ZOOM, OnUpdateZoom) 
	ON_WM_RBUTTONDOWN() 
	ON_WM_RBUTTONDBLCLK() 
	ON_WM_LBUTTONDBLCLK() 
	ON_COMMAND(ID_TREE_COLOR, OnTreeColor) 
	ON_UPDATE_COMMAND_UI(ID_TREE_COLOR, OnUpdateTreeColor) 
	ON_COMMAND(ID_TREE_HIDE, OnTreeHide) 
	ON_UPDATE_COMMAND_UI(ID_TREE_HIDE, OnUpdateTreeHide) 
	ON_COMMAND(ID_TREE_TRANSLATE, OnTreeTranslate) 
	ON_UPDATE_COMMAND_UI(ID_TREE_TRANSLATE, OnUpdateTreeTranslate) 
	ON_COMMAND(ID_PLAY, OnPlay) 
	ON_UPDATE_COMMAND_UI(ID_PLAY, OnUpdatePlay) 
	ON_COMMAND(ID_TREE_INFORMATION, OnTreeInformation) 
	ON_UPDATE_COMMAND_UI(ID_TREE_INFORMATION, OnUpdateTreeInformation) 
	ON_COMMAND(ID_TEMPSTOP, OnTempstop) 
	ON_UPDATE_COMMAND_UI(ID_TEMPSTOP, OnUpdateTempstop) 
	ON_COMMAND(ID_REPEAT, OnRepeat) 
	ON_UPDATE_COMMAND_UI(ID_REPEAT, OnUpdateRepeat) 
	ON_WM_CONTEXTMENU() 
	ON_COMMAND(ID_VIEW_FONT, OnViewFont) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_FONT, OnUpdateViewFont) 
	ON_COMMAND(ID_VIEW_LEFT, OnViewLeft) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_LEFT, OnUpdateViewLeft) 
	ON_COMMAND(ID_VIEW_TOP, OnViewTop) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_TOP, OnUpdateViewTop) 
	ON_COMMAND(ID_VIEW_POINTS, OnViewPoints) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_POINTS, OnUpdateViewPoints) 
	ON_COMMAND(ID_VIEW_TRIANGLES, OnViewTriangles) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_TRIANGLES, OnUpdateViewTriangles) 
	ON_COMMAND(ID_VIEW_LINES, OnViewLines) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_LINES, OnUpdateViewLines) 
	ON_COMMAND(ID_VIEW_REFRESH, OnViewRefresh) 
	ON_WM_KEYDOWN() 
	ON_COMMAND(ID_RECT_SCALE, OnRectScale) 
	ON_COMMAND(ID_FIND_LINE, OnFindLine) 
	ON_UPDATE_COMMAND_UI(ID_FIND_LINE, OnUpdateFindLine) 
	ON_COMMAND(ID_FIND_PORT, OnFindPort) 
	ON_UPDATE_COMMAND_UI(ID_FIND_PORT, OnUpdateFindPort) 
	ON_COMMAND(ID_TOOLBAR3, OnToolbar3) 
	ON_UPDATE_COMMAND_UI(ID_TOOLBAR3, OnUpdateToolbar3) 
	ON_COMMAND(ID_VIEW_MESS, OnViewMess) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_MESS, OnUpdateViewMess) 
	ON_COMMAND(ID_CREATE_TREE, OnCreateTree) 
	ON_UPDATE_COMMAND_UI(ID_CREATE_TREE, OnUpdateCreateTree) 
	ON_COMMAND(ID_FILE_CLEAR, OnFileClear) 
	ON_UPDATE_COMMAND_UI(ID_RECT_SCALE, OnUpdateRectScale) 
	ON_COMMAND(ID_VIEW_GANSHE, OnViewGanshe) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_GANSHE, OnUpdateViewGanshe) 
	ON_COMMAND(ID_FIT, OnFit) 
	ON_UPDATE_COMMAND_UI(ID_FIT, OnUpdateFit) 
	ON_WM_DESTROY() 
	ON_COMMAND(ID_VIEW_ALL_PARA, OnViewAllPara) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_ALL_PARA, OnUpdateViewAllPara) 
	ON_COMMAND(ID_VIEW_BACK, OnViewBack) 
	ON_UPDATE_COMMAND_UI(ID_VIEW_BACK, OnUpdateViewBack) 
	//}}AFX_MSG_MAP 
	// Standard printing commands 
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview) 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CMfcopenView construction/destruction 
 
static int mm = 0; 
static int gg = 0; 
CMfcopenView::CMfcopenView() 
{ 
	// TODO: add construction code here 
	para = new CParaSetting(this); 
	ResetData(); 
} 
 
CMfcopenView::~CMfcopenView() 
{ 
	if(para) 
		delete para; 
	for(int i=0; i<10; i++) 
	{ 
		DestroyTree(root[i]); 
	} 
	if(ganshe_first) 
	{ 
		delete ganshe_first; 
		ganshe_first = 0; 
	} 
	if(ganshe_second) 
	{ 
		delete ganshe_second; 
		ganshe_second = 0; 
	} 
	CMfcopenDoc* pDoc = GetDocument(); 
	glDeleteLists(1, pDoc->m_iDArrnumber); 
} 
 
BOOL CMfcopenView::PreCreateWindow(CREATESTRUCT& cs) 
{ 
	// TODO: Modify the Window class or styles here by modifying 
	//  the CREATESTRUCT cs 
	cs.style|=WS_CLIPSIBLINGS|WS_CLIPCHILDREN; 
	return CView::PreCreateWindow(cs); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CMfcopenView drawing 
bool CMfcopenView::DrawGLScene(void) 
{ 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	COutputBar *m_output = &(pFrame->m_wndOutput); 
	 
	//把干涉信息记入output窗口	 
	float begin = GetTickCount(); 
	float end = begin; 
 
	CMfcopenDoc* pDoc = GetDocument(); 
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear The Scrreen And The Depth Buffer  
 
    glLoadIdentity();                                       // Reset The Currrent Modelview Matrix  
 
	glEnable(GL_LIGHTING); 
	glDisable(GL_TEXTURE_2D); 
	glDisable(GL_BLEND); 
 
	glPushMatrix(); 
	glDisable(GL_LIGHTING); 
	glColor3f(1.0, 0, 0); 
	glTranslatef(0, 0, 5.0f); 
	glRasterPos2f(0, 0); 
 
	glCallList(sztemp_jin._dlist); 
	glCallList(sztemp_de._dlist); 
	glCallList(sztemp_cai._dlist); 
	glPopMatrix(); 
 
	glEnable(GL_LIGHTING); 
    glEnable(GL_LIGHT0);  
	 
	glTranslatef(0, 0, -0.2f); 
 
	switch(m_view){ 
	case INT_FRONT: 
		break; 
	case INT_LEFT: 
		glRotatef(90, 0, 1.0f, 0); 
		break; 
	case INT_TOP: 
		glRotatef(90, 1.0f, 0, 0); 
		break; 
	case INT_BACK: 
		glRotatef(180, 0, 1.0f, 0); 
		break; 
	default: 
		break; 
	} 
 
 
 
	if(m_view == INT_FRONT) 
	{ 
		glTranslatef(m_fxtra, m_fytra, 0.0f); 
		glRotatef(m_fxrot, 1.0f,0.0f, 0.0f); 
		glRotatef(m_fyrot, 0.0f,1.0f, 0.0f); 
	} 
 
	if(m_view == INT_TOP) 
	{ 
		glTranslatef(m_fxtra, 0.0f, -m_fytra); 
		glRotatef(m_fxrot, 1.0f,0.0f, 0.0f); 
		glRotatef(m_fyrot, 0.0f,0.0f, 1.0f);	 
	} 
 
	if(m_view == INT_LEFT) 
	{ 
		glTranslatef(0.0f, m_fytra, m_fxtra); 
		glRotatef(m_fxrot, 0.0f,0.0f, 1.0f); 
		glRotatef(m_fyrot, 0.0f,1.0f, 0.0f);	 
	}	 
 
	if(m_view == INT_BACK) 
	{ 
		glTranslatef(-m_fxtra, m_fytra, 0.0f); 
		glRotatef(-m_fxrot, 1.0f,0.0f, 0.0f); 
		glRotatef(m_fyrot, 0.0f,1.0f, 0.0f);	 
	}	 
 
	///////////////////////////////// 
	/////select objects////////////// 
	///////////////////////////////// 
 
	glInitNames(); 
	glPushName(0); 
	glDisable(GL_LIGHTING); 
	glDisable(GL_BLEND); 
 
	if(m_bviewmess) 
	{ 
		glPolygonMode(GL_FRONT, GL_LINE ); 
		for(int vv=0; vv<10; vv++) 
			if(root[vv] != NULL) 
			{ 
				m_lgcubenumber = 0; 
				DrawCubeWeb(root[vv]); 
			} 
	} 
 
	if(m_bviewganshe) 
	{ 
		glLineStipple(2, 0x1C47); 
		glEnable(GL_LINE_STIPPLE); 
		glPolygonMode(GL_FRONT, GL_LINE ); 
		ViewGanshe(); 
		glDisable(GL_LINE_STIPPLE); 
	} 
 
	glEnable(GL_LIGHTING); 
	glDisable(GL_CULL_FACE); 
	glPushMatrix(); 
 
	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff[0]); 
	if(pDoc->m_bFakOpen) 
	{ 
		glBegin(GL_TRIANGLES); 
		glCallList(21); 
		glEnd(); 
	} 
	glEnable(GL_CULL_FACE);	 
	glDisable(GL_LIGHTING);	 
	for(int r=1; r<=pDoc->m_iDArrnumber; r++) 
	{	 
		glMaterialf(GL_FRONT, GL_SHININESS, shininess);	 
		/////////////////// 
		//干涉检查///////// 
		/////////////////// 
 
		//重复播放规定只用于正常情况 
		if(m_bplay) 
		{ 
			InterfaceCheck(r); 
			end = GetTickCount(); 
			CString str; 
			str.Format("%f", (end-begin)); 
 
			if(writer > 0) 
				m_output->m_DebugList.ResetContent(); 
			writer++; 
 
			m_output->m_Find1List.AddString(str); 
		} 
 
		//隐藏实体 
		if(m_ilflag[r] == 1) 
		{ 
			glLoadName(r); 
			glEnd(); 
			continue; 
		} 
 
		glDisable(GL_LIGHTING); 
 
		CMainFrame* pFrame; 
		pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
		CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
		int m_itreeflag = pTree->GetSelectItemIndex(); 
		if(r==m_itreeflag) 
			glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff_ganshe); 
		else 
			glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff[r]); 
 
		//画截面 
		if(m_bcut1){ 
			glColor4fv(mat_amb_diff[r]); 
			ShowSection(r, m_istlmove[r]); 
		} 
 
		glEnable(GL_LIGHTING); 
		glEnable(GL_CULL_FACE); 
		glCullFace(GL_BACK); 
 
		//平移实体 
		int k = m_istlmove[r]; 
		if(m_fmove[r][k][3]>0)//表示此物体要平移 
		{ 
			glPushMatrix(); 
			glTranslatef(m_fsectcenter[r][0]-m_forigincenter[r][0]+m_fmove[r][k][3]*m_fsteptranslate[r][k][0], m_fsectcenter[r][1]-m_forigincenter[r][1]+m_fmove[r][k][3]*m_fsteptranslate[r][k][1], m_fsectcenter[r][2]-m_forigincenter[r][2]+m_fmove[r][k][3]*m_fsteptranslate[r][k][2]); 
			m_fcenter[r][0] = m_fsectcenter[r][0] + m_fmove[r][k][3]*m_fsteptranslate[r][k][0]; 
			m_fcenter[r][1] = m_fsectcenter[r][1] + m_fmove[r][k][3]*m_fsteptranslate[r][k][1]; 
			m_fcenter[r][2] = m_fsectcenter[r][2] + m_fmove[r][k][3]*m_fsteptranslate[r][k][2];	 
 
			glLoadName(r); 
			glPolygonMode(GL_FRONT, m_umodelview); 
			glBegin(GL_TRIANGLES); 
 
			glCallList(r); 
			glEnd(); 
			glEnd(); 
			glPopMatrix(); 
		} 
		else 
		{ 
			if(m_fglobaltime<=m_ftimemove[r][k][0])//开始延迟时间区间暂停 
			{ 
				glLoadName(r); 
				glPolygonMode(GL_FRONT, m_umodelview); 
				glBegin(GL_TRIANGLES); 
				 
				glCallList(r); 
				glEnd(); 
				glEnd(); 
			} 
			else 
			{	 
				//最后位置 
				glPushMatrix(); 
				glTranslatef(m_fcenter[r][0]-m_forigincenter[r][0], m_fcenter[r][1]-m_forigincenter[r][1], m_fcenter[r][2]-m_forigincenter[r][2]); 
				glLoadName(r); 
				glPolygonMode(GL_FRONT, m_umodelview); 
				glBegin(GL_TRIANGLES); 
				 
				glCallList(r); 
				glEnd(); 
				glEnd(); 
				glPopMatrix(); 
			} 
		} 
 
	}	 
	glPopMatrix(); 
	glPopMatrix(); 
	glDisable(GL_LIGHTING); 
	glDisable(GL_TEXTURE_2D); 
	glEnable(GL_BLEND); 
    glDepthFunc(GL_ALWAYS);   
	glDepthMask(GL_TRUE); 
	glLineWidth(1); 
	glBegin(GL_LINES); 
		glColor3f(1.0f, 1.0f, 1.0f); 
		glVertex3f(0, 0, 0); 
		glVertex3f(0.1f*m_scale, 0, 0); 
	glEnd(); 
	glColor3f(1.0, 1.0, 1.0); 
	glPushMatrix(); 
	glTranslatef(0.12f*m_scale, -0.01f*m_scale, ((m_view==INT_LEFT)?-0.01f:0.01)*m_scale); 
	glRasterPos3f(0, 0, 0); 
	myfont.DisplayFonts("X"); 
	glPopMatrix(); 
	// 
	glPushMatrix(); 
	glTranslatef(0.4f*m_scale, 0.4f*m_scale, ((m_view==INT_LEFT)?0.4f:-0.4)*m_scale); 
	glRasterPos3f(0, 0, 0); 
	CString str_cubenum; 
	char buffer[50]; 
	str_cubenum.Format("%d", m_lgcubenumber); 
	sprintf(buffer, "%s", str_cubenum); 
	myfont.DisplayFonts(buffer); 
	glPopMatrix(); 
	// 
 
	glBegin(GL_LINES); 
		glColor3f(1.0f, 1.0f, 1.0f); 
		glVertex3f(0, 0, 0); 
		glVertex3f(0, 0.1f*m_scale, 0); 
	glEnd(); 
 
	glColor3f(1.0, 1.0, 1.0); 
	glPushMatrix(); 
	glTranslatef(-0.01f*m_scale, 0.12f*m_scale, ((m_view==INT_LEFT)?-0.01f:0.01)*m_scale); 
	glRasterPos3f(0, 0, 0); 
	myfont.DisplayFonts("Y"); 
	glPopMatrix(); 
 
	glBegin(GL_LINES); 
		glColor3f(1.0f, 1.0f, 1.0f); 
		glVertex3f(0, 0, 0); 
		glVertex3f(0, 0, 0.1f*m_scale); 
	glEnd(); 
 
	glColor3f(1.0, 1.0, 1.0); 
	glPushMatrix(); 
	glTranslatef(-0.01f*m_scale, -0.01f*m_scale, 0.12f*m_scale); 
	glRasterPos3f(0, 0, 0); 
	glPopMatrix(); 
	myfont.DisplayFonts("Z"); 
 
    glDepthFunc(GL_LEQUAL);   
 
    return TRUE;                                             
 
}  
 
int initfont = 0; 
bool CMfcopenView::InitGL(void) 
{  
 
      glShadeModel(GL_SMOOTH);                        // Enables Smooth Shadin  
 
      glClearColor(0.2235294f, 0.427451f, 0.647059f, 0.0f);           // Black Background  
      glClearDepth(1.0);                              // Depth Buffer Setup  
 
	  glEnable(GL_TEXTURE_2D); 
	  glEnable(GL_BLEND); 
	  glBlendFunc(GL_SRC_ALPHA, GL_ONE); 
      glEnable(GL_DEPTH_TEST);                        // Enables Depth Testing  
      glDepthFunc(GL_LEQUAL);                         // The Type Of Depth Tesst To Do  
 
      glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Really Nice Perspective Calculations  
 
	  CreateTexture(g_Texture, "back.bmp", 0); 
 
      return TRUE;                                            // Initializatioon Went OK  
} 
 
static int initgl = 0; 
//whenever Invalidate(false) calls, this function will recall! 
void CMfcopenView::OnDraw(CDC* pDC) 
{ 
	CMfcopenDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
	// TODO: add draw code for native data here 
	if(m_bIsPrint) 
	{ 
		KillTimer(1); 
		CMyBitmap bmp; 
 
		GLint viewport[4]; 
		glGetIntegerv(GL_VIEWPORT, viewport); 
		int w = viewport[2]; 
		int h = viewport[3]; 
		w = (w+3)&~3;// x&~3一定能被4整除！ 
		bmp.load("jin.bmp"); 
		pDC->SetBkMode(TRANSPARENT); 
		for(int i=0; iSetPixelV(j, h-i, RGB(255, 255, 255)); 
					continue; 
				} 
				pDC->SetPixelV(j, h-i, col); 
			} 
		 
		return; 
	} 
	wglMakeCurrent(pDC->m_hDC,m_hRC); 
	if(initgl < 1) 
	{ 
		InitGL(); 
		initgl++; 
	} 
	if(initgl > 2) 
		initgl = 2; 
	if(initfont < 1) 
	{ 
		myfont.InitFont(pDC->m_hDC, 12); 
		initfont++; 
 
		init_wchar(pDC->m_hDC, *szfont_jin, sztemp_jin); 
		init_wchar(pDC->m_hDC, *szfont_de , sztemp_de); 
		init_wchar(pDC->m_hDC, *szfont_cai, sztemp_cai); 
	} 
	if(initfont > 2) 
		initfont = 2; 
	m_bFakOpen = pDoc->m_bFakOpen; 
	m_bfileopen = pDoc->m_bfileopen; 
	m_banimalfileopen = pDoc->m_banimalfileopen; 
	m_fBoxMax = pDoc->m_fBoxMax; 
	//考虑到一般情形，只能先加已存在的文件，再加其他文件！ 
	//STL 
	if(m_bfileopen && !m_bFakOpen) 
	{ 
		//epc没被打开，STL被打开 
		if(mmm_iDArrnumber) 
		{ 
			ProcessData(pDoc->m_array); 
			BuildDispList(pDoc->m_iDArrnumber); 
			mm++; 
		}	 
		DrawGLScene(); 
 
	} 
	else if(!m_bfileopen && m_bFakOpen) 
	{ 
		//epc没打开，但是fak被打开 
		BuildFakList(21); 
		DrawGLScene(); 
	} 
	else 
	{ 
		if( (gg < 1) && (pDoc->m_banimalfileopen)) 
		{ 
			//先打开硬盘中的STL文件，没有处理过 
			ProcessData(pDoc->m_array); 
			BuildDispList(pDoc->m_iDArrnumber); 
			gg++; 
			mm = pDoc->m_iDArrnumber; 
			m_scale = pDoc->m_scale; 
			m_ftimes = pDoc->m_ftimes; 
			for(int i=0; i<100; i++) 
			{ 
				m_itrannumber[i] = pDoc->m_itrannumber[i]; 
				for(int r=0; r<4; r++) 
				{ 
					m_ftimemove[i][r][0] = pDoc->m_ftimemove[i][r][0]; 
					m_ftimemove[i][r][1] = pDoc->m_ftimemove[i][r][1]; 
				} 
				m_ilflag[i] = pDoc->m_ilflag[i]; 
			} 
 
			for(i=0; i<100; i++) 
			{ 
				for(int r=0; r<3; r++) 
				{ 
					m_fcenter[i][r] = m_fsectcenter[i][r] = m_forigincenter[i][r] = m_fcenter[i][r]; 
				} 
			} 
 
			for(i=0; i<100; i++) 
			{ 
				for(int r=0; r<4; r++) 
				{ 
					m_fInformation[i][r][0] = pDoc->m_fInformation[i][r][0]; 
					m_fInformation[i][r][1] = pDoc->m_fInformation[i][r][1]; 
					m_fInformation[i][r][2] = pDoc->m_fInformation[i][r][2]; 
				} 
			} 
			 
			for(i=0; i<100; i++) 
				for(int j=0; j<4; j++) 
				{ 
					mat_amb_diff[i][j] = pDoc->mat_amb_diff[i][j]; 
					for(int k=0; k<4; k++) 
						m_fmove[i][j][k] = pDoc->m_fmove[i][j][k]; 
				} 
			for(int j=0; j<100; j++) 
			{ 
				for(int r=0; r<4; r++) 
				{ 
					float tempstep = (m_ftimemove[j][r][1]-m_ftimemove[j][r][0])*50; 
 
					m_fsteptranslate[j][r][0] = m_fmove[j][r][0]/tempstep; 
					m_fsteptranslate[j][r][1] = m_fmove[j][r][1]/tempstep; 
					m_fsteptranslate[j][r][2] = m_fmove[j][r][2]/tempstep; 
				} 
			} 
		} 
		DrawGLScene(); 
 
	} 
	if((settime < 1) && (m_banimalfileopen || m_bfileopen || m_bFakOpen)){ 
		SetTimer(1, 20, NULL); 
		settime++; 
		} 
	SwapBuffers(pDC->m_hDC);  
 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CMfcopenView printing 
 
BOOL CMfcopenView::OnPreparePrinting(CPrintInfo* pInfo) 
{ 
	// default preparation 
 
	CRect rc; 
	GetClientRect(&rc); 
	int w = rc.Width(); 
	int h = rc.Height(); 
	int width = w*3; 
	width = (width+3)&~3;//x&~3一定能被4整除！ 
	int bitsize = width*h; 
	CMyBitmap bmp; 
	bmp.data = new BYTE[bitsize]; 
	glReadBuffer(GL_FRONT); 
	glPixelStorei(GL_PACK_ALIGNMENT, 4); 
	bmp.width = w;//viewport[2]; 
	bmp.height = h;//viewport[3]; 
	ClientToScreen(&rc); 
	glReadPixels(0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, bmp.data); 
	bmp.save("jin.bmp"); 
 
	return DoPreparePrinting(pInfo); 
} 
 
void CMfcopenView::OnBeginPrinting(CDC* pDC, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add extra initialization before printing 
	m_bIsPrint = TRUE; 
} 
 
void CMfcopenView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add cleanup after printing 
	m_bIsPrint = FALSE; 
	SetTimer(1, 20, NULL); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CMfcopenView diagnostics 
 
#ifdef _DEBUG 
void CMfcopenView::AssertValid() const 
{ 
	CView::AssertValid(); 
} 
 
void CMfcopenView::Dump(CDumpContext& dc) const 
{ 
	CView::Dump(dc); 
} 
 
CMfcopenDoc* CMfcopenView::GetDocument() // non-debug version is inline 
{ 
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMfcopenDoc))); 
	return (CMfcopenDoc*)m_pDocument; 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CMfcopenView message handlers 
 
int CMfcopenView::OnCreate(LPCREATESTRUCT lpCreateStruct)  
{ 
	PIXELFORMATDESCRIPTOR pixelDesc; 
    pixelDesc.nSize = sizeof(PIXELFORMATDESCRIPTOR); 
	pixelDesc.nVersion = 1; 
	.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | 
		PFD_D 
	pixelDescOUBLEBUFFER | PFD_STEREO_DONTCARE; 
	 
	pixelDesc.iPixelType = PFD_TYPE_RGBA; 
	pixelDesc.cColorBits = 32; 
	pixelDesc.cRedBits = 8; 
	pixelDesc.cRedShift = 16; 
	pixelDesc.cGreenBits = 8; 
	pixelDesc.cGreenShift = 8; 
	pixelDesc.cBlueBits = 8; 
	pixelDesc.cBlueShift = 0; 
	pixelDesc.cAlphaBits = 0; 
	pixelDesc.cAlphaShift = 0; 
	pixelDesc.cAccumBits = 64; 
	pixelDesc.cAccumRedBits = 16; 
	pixelDesc.cAccumGreenBits = 16; 
	pixelDesc.cAccumBlueBits = 16; 
	pixelDesc.cAccumAlphaBits = 0; 
	pixelDesc.cDepthBits = 32; 
	pixelDesc.cStencilBits = 8; 
	pixelDesc.cAuxBuffers = 0; 
	pixelDesc.iLayerType = PFD_MAIN_PLANE; 
	pixelDesc.bReserved = 0; 
	pixelDesc.dwLayerMask = 0; 
	pixelDesc.dwVisibleMask = 0; 
	pixelDesc.dwDamageMask = 0; 
 
	CDC *pdc=GetDC(); 
	ASSERT(pdc->m_hDC); 
	int pixelFormat=ChoosePixelFormat(pdc->m_hDC,&pixelDesc); 
	//返回最匹配的像素格式 
	BOOL success = SetPixelFormat(pdc->m_hDC,pixelFormat,&pixelDesc); 
	//设置像素格式 
	m_hRC=wglCreateContext(pdc->m_hDC); 
	if(m_primeHrc==0) 
	{ 
		m_primeHrc=m_hRC; 
	} 
	else 
	{ 
		wglShareLists(m_primeHrc,m_hRC);//使当前RC共享主RC的显示列表 
	} 
	wglMakeCurrent(NULL,NULL);//使当前RC为空，为释放DC作准备 
	ReleaseDC(pdc); 
	if (CView::OnCreate(lpCreateStruct) == -1) 
		return -1;	 
	return 0; 
} 
 
 
void CMfcopenView::OnSize(UINT nType, int cx, int cy)  
{ 
    CDC *pdc=GetDC(); 
	wglMakeCurrent(pdc->m_hDC,m_hRC); 
	GLsizei width, height; 
	width=cx; 
	height=cy; 
	if(height == 0) 
		height =1; 
 
	m_disp_radio = (float)width/(float)height; 
 
	glViewport(0,0,width,height);//视口的变换 
	glMatrixMode(GL_PROJECTION);//将相继矩阵施加到投影矩阵栈 
    glLoadIdentity();//初始化为单为阵 
 
	m_fleft = -1.0*(GLfloat)width/(GLfloat)height; 
	m_fright = 1.0*(GLfloat)width/(GLfloat)height; 
	m_fbottom = -1.0f; 
	m_ftop  = 1.0f; 
 
	glOrtho((m_fleft+m_ortho_bias_x)*m_scale,(m_fright+m_ortho_bias_x)*m_scale, 
         (m_fbottom-m_ortho_bias_y)*m_scale, (m_ftop-m_ortho_bias_y)*m_scale,-100.0,100.0);  
 
	m_ortho_bias_x = m_ortho_bias_y = 0; 
    glMatrixMode(GL_MODELVIEW);//将相继矩阵施加到投影矩阵栈 
	glLoadIdentity(); 
    glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient);  
 
    glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse);  
 
    glLightfv(GL_LIGHT0, GL_DIFFUSE, LightSpecular);  
 
    glLightfv(GL_LIGHT0, GL_POSITION,LightPosition); 
 
	wglMakeCurrent(NULL,NULL); 
	ReleaseDC(pdc);	 
 
	CView::OnSize(nType, cx, cy); 
} 
 
 
 
 
void CMfcopenView::OnTimer(UINT nIDEvent)  
{ 
	// TODO: Add your message handler code here and/or call default 
	CMfcopenDoc* pDoc = GetDocument(); 
	GetCursorPos(&m_current); 
	ScreenToClient(&m_current); 
	if(nIDEvent == 1) 
	{ 
		m_fpasstime += 0.02f; 
		if(m_blmousedown && ((m_popmenu == INT_TRANSLATE) || (m_popmenu == INT_ROTATE) || (m_popmenu == INT_ZOOM) ))//|| (m_popmenu == INT_ZOOM_RECT) 
			Invalidate(false); 
		 
		if(m_popmenu == INT_END && (m_current.x == m_oldpt.x && m_current.y == m_oldpt.y) && m_fpasstime > 1.0f) 
		{ 
			if(count == 0) 
			{ 
				m_iObjectId = RetrieveObjectID(m_current.x, m_current.y); 
				count++; 
			} 
			if(m_iObjectId > 0) 
			{ 
				m_movecount = 0; 
				CClientDC dc(this); 
				CBrush brush(RGB(255, 255 ,0)); 
				dc.SelectObject(&brush); 
				CString str; 
				str.Format("%s", pDoc->m_savename[m_iObjectId-1]); 
				CSize size; 
				size = dc.GetTextExtent(str); 
				if(size.cx==0) 
					return; 
				dc.Rectangle(m_current.x+16, m_current.y+14, m_current.x+16+4+size.cx, m_current.y+14+4+size.cy); 
				dc.SetBkMode(TRANSPARENT); 
				dc.SetTextAlign(TA_LEFT); 
				dc.TextOut(m_current.x+18, m_current.y+16, str);			 
				 
			} 
			m_fpasstime = 0; 
		} 
		if(m_btempstop) 
			return; 
		if(m_bplay) 
		{ 
			m_fglobaltime += 0.02f; 
			for(int i=1; i<100; i++) 
			{ 
				for(int j=0; j<4; j++) 
				{ 
					if((m_fglobaltime>=m_ftimemove[i][j][0])&&(m_fglobaltime=0) 
						m_istlmove[i] = j; 
						break;			   //每次只有一个时间段的运动或者不动				 
					} 
					else 
					{ 
						if(m_fmove[i][j][3] > 0) 
							memcpy(m_fsectcenter[i], m_fcenter[i], 12);  
						m_fmove[i][j][3] = 0;//关闭它的平移开关 
					} 
				} 
			} 
			Invalidate(false); 
		} 
 
		if(m_brepeat) 
		{ 
			m_fglobaltime += 0.02f; 
			int count = 0; 
			for(int i=1; i<100; i++) 
			{ 
				for(int j=0; j<4; j++) 
				{ 
					if((m_fglobaltime>=m_ftimemove[i][j][0])&&(m_fglobaltime=0) 
						m_istlmove[i] = j; 
						break;			   //每次只有一个时间段的运动或者不动 
					} 
					else  
					{ 
						if(m_fglobaltime >= m_ftimemove[i][j][1]) 
							count++; 
						if(m_fmove[i][j][3] > 0) 
							memcpy(m_fsectcenter[i], m_fcenter[i], 12);  
						m_fmove[i][j][3] = 0;//关闭它的平移开关 
					} 
				} 
			} 
			if(count >= 99*4) 
			{ 
				count = 0; 
				m_fglobaltime = 0; 
				for(i=0; i<100; i++) 
					for(int j=0; j<4; j++) 
						m_fmove[i][j][3] = 0; 
				for(i=0; i<100; i++) 
					for(int j=0; j<3; j++) 
						m_fcenter[i][j] = m_fsectcenter[i][j] = m_forigincenter[i][j]; 
				g_bganshe = FALSE; 
			} 
			Invalidate(false); 
		} 
		 
	} 
	CView::OnTimer(nIDEvent); 
} 
 
void CMfcopenView::OnLButtonDown(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	m_blmousedown = true; 
	CRect rect; 
	GetClientRect(&rect); 
	CPoint temppoint = point; 
	ScreenToClient(&temppoint); 
	if(rect.PtInRect(point)) 
	{ 
		if(m_popmenu == INT_TRANSLATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORTRA)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ROTATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROT)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM)); 
			ShowCursor(true); 
/*			 
			if(::GetKeyState(VK_CONTROL) < 0) 
			{ 
				if(m_scale < 0.1f) 
					m_scale = 0.1f; 
				else 
					m_scale += 0.1f; 
			} 
			else 
			{ 
				m_scale -= 0.1f; 
			} 
*/ 
			m_zoomcenter = point; 
		} 
	 
		else if(m_popmenu == INT_ZOOM_RECT) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM_RECT)); 
			ShowCursor(true); 
 
			m_RectZoomOldpoint = point; 
		} 
		else 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_POINTER)); 
			ShowCursor(true); 
/* 
			CPoint pt = point; 
			ClientToScreen(&pt); 
			int cy = GetSystemMetrics(SM_CYMAXIMIZED); 
			BYTE *color = new BYTE[3]; 
			glReadBuffer(GL_BACK); 
			glReadPixels(pt.x, cy-pt.y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, color); 
			if(abs(color[0]-58)<=1 && abs(color[1]-109)<=1 && abs(color[2]-165)<=1	) 
			{ 
				delete []color; 
				return; 
			} 
			else 
				delete []color; 
*/		 
			m_iObjectId = RetrieveObjectID(point.x, point.y); 
 
			CMainFrame* pFrame; 
			pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
			CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
 
			if(m_iObjectId > 0 && m_itreeflag < 999) 
			{ 
				pTree->SendMessage(WM_HIGHLIGHT, m_iObjectId, m_itreeflag); 
				m_itreeflag = m_iObjectId; 
			} 
 
		} 
	} 
	 
	CView::OnLButtonDown(nFlags, point); 
} 
 
void CMfcopenView::OnLButtonUp(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	m_blmousedown = false; 
	CRect rect; 
	GetClientRect(&rect); 
	 
	if(rect.PtInRect(point)) 
	{ 
		if(m_popmenu == INT_TRANSLATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORTRA)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ROTATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROT)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM_RECT) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM_RECT)); 
			ShowCursor(true); 
 
			CRect rc, rs; 
			CClientDC dc(this); 
			GetClientRect(&rc);	 
			rs.SetRect(m_RectZoomOldpoint, point); 
			if(rs.Width()==0 || rs.Height()==0) 
				return; 
			//放大 
			float rs_value = float(rs.Width())/rc.Width();//min(rs.Width(), rs.Height()); 
			float rc_value = float(rs.Height())/rc.Height();//max(rc.Width(), rc.Height()); 
 
			//平移 
			float deta = 2.0f*m_scale/rect.Height(); 
			m_fstepx = (rc.Width()/2-rs.Width()/2-rs.left)*deta; 
			m_fstepy = (rc.Height()/2-rs.Height()/2-rs.top)*deta; 
			m_fxtra += m_fstepx; 
			m_fytra -= m_fstepy; 
 
			m_scale *= (rs_value>rc_value)?rs_value:rc_value;//rs_value/rc_value 
			m_scale = (m_scale > 0.02) ? m_scale : 0.02; 
			OnSize(SIZE_RESTORED, rc.Width(), rc.Height());	 
			Invalidate(FALSE); 
			UpdateWindow(); 
		} 
		else 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_POINTER)); 
			ShowCursor(true); 
		} 
 
		m_current=point; 
	} 
	CView::OnLButtonUp(nFlags, point); 
} 
 
 
 
void CMfcopenView::BuildDispList(int flag) 
{ 
	CString str; 
	CMfcopenDoc* pDoc = GetDocument();	 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	pDoc->pStatus = &pFrame->m_wndStatusBar; 
	 
 
	int ss = 0; 
	STLArray *temparray = pDoc->m_array->next; 
	while(temparray!=NULL) 
	{ 
		STLData *temp = temparray->stl->next; 
 
		glNewList( ++ss, GL_COMPILE ); 
 
		int i = 0; 
		while(temp != NULL){ 
			 
				glNormal3fv(temp->fNormal);	 
                glVertex3fv(temp->fPoint1 );                   
				glNormal3fv(temp->fNormal); 
                glVertex3fv(temp->fPoint2);                   
				glNormal3fv(temp->fNormal); 
                glVertex3fv(temp->fPoint3);   
 
 
				temp = temp->next; 
 
				i++; 
				int prog = i*100/temparray->trinumber; 
				str.Format( "已处理文件数据%d%%", prog ); 
				pDoc->pStatus->SetPaneText(0, str, true); 
				} 
  
	str.Format("即将输出图形%d,请等待...", ss); 
	pDoc->pStatus->SetPaneText(0, str, true); 
	CCmdTarget::BeginWaitCursor(); 
	glEndList(); 
	EndWaitCursor(); 
	pDoc->pStatus->SetPaneText(0, "图形输出成功，ok!", true); 
	if(i>10000) 
	::Sleep(1000); 
	pDoc->pStatus->SetPaneText(0, "", true); 
	temparray = temparray->next; 
	} 
 
} 
 
 
void CMfcopenView::OnMouseMove(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	if(m_gwel == 0 && point.y < 200) 
	{ 
		KillTimer(1); 
		CWelcome wel; 
		wel.DoModal(); 
		m_gwel++; 
		SetTimer(1, 20, NULL); 
	} 
	m_current = point; 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	pStatus=&pFrame->m_wndStatusBar; 
 
	CMfcopenDoc* pDoc = GetDocument();	 
 
	CRect rect; 
	GetClientRect(&rect); 
 
	if(rect.PtInRect(point)) 
	{ 
		if(m_popmenu == INT_TRANSLATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORTRA)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ROTATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROT)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM_RECT) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM_RECT)); 
			ShowCursor(true);			 
		} 
		else 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_POINTER)); 
			ShowCursor(true); 
			count = 0; 
			if(m_movecount == 0) 
			{ 
				CRect r; 
				r.SetRect(m_oldpt.x+16, m_oldpt.y+16, m_oldpt.x+50, m_oldpt.y+32); 
				InvalidateRect(&r, FALSE); 
				m_movecount++; 
		} 
		} 
	} 
	CString strx, stry; 
	strx.Format("X = %d", m_current.x); 
	pStatus->SetPaneText(2, strx, true); 
	stry.Format("Y = %d", m_current.y); 
	pStatus->SetPaneText(3, stry, true); 
//平移 
	if(m_blmousedown && (m_popmenu == INT_TRANSLATE)) 
	{ 
		float deta = 2.0f*m_scale/rect.Height(); //1.125f*0.004f*m_scale; 
		CPoint ptTemp=m_current-m_oldpt; 
		m_fstepx = ptTemp.x*deta; 
		m_fstepy = ptTemp.y*deta; 
		m_fxtra += m_fstepx; 
		m_fytra -= m_fstepy; 
	} 
 
//旋转 
	if(m_blmousedown && (m_popmenu == INT_ROTATE)) 
	{	 
		CPoint ptTemp=m_current-m_oldpt; 
		m_fanglex = ptTemp.y*sita; 
		m_fangley = ptTemp.x*sita;		 
		m_fxrot += m_fanglex; 
		m_fyrot += m_fangley; 
	} 
//缩放1 
	if(m_blmousedown && (m_popmenu == INT_ZOOM)) 
	{ 
		CPoint ptTemp = m_current-m_zoomcenter; 
		CPoint ptTemp2 = m_current-m_oldpt; 
		if(ptTemp.y > 0 ) 
		{ 
			if(ptTemp2.y > 0) 
				m_scale += ptTemp.y * 0.001f; 
			else 
				m_scale = (m_scale - ptTemp.y * 0.001f) > 0.02f ? (m_scale - ptTemp.y * 0.001f) : 0.02f; 
		} 
		if(ptTemp.y < 0) 
		{ 
			if(ptTemp2.y < 0) 
				m_scale = (m_scale - (-ptTemp.y) * 0.001f) > 0.02f ? (m_scale - (-ptTemp.y) * 0.001f) : 0.02f; 
			else 
				m_scale += (-ptTemp.y) * 0.001f; 
		} 
		OnSize(SIZE_RESTORED, rect.Width(), rect.Height());		 
	} 
//区域缩放	 
	if(m_blmousedown && (m_popmenu == INT_ZOOM_RECT)) 
	{ 
		if(m_RectZoomOldpoint.x == -100) 
			return; 
		CClientDC dc(this); 
		CPen pen(PS_SOLID, 1, RGB(255, 255, 255)); 
		dc.SelectObject(&pen); 
		dc.SetBkMode(TRANSPARENT); 
		dc.SetROP2(R2_NOT); 
		dc.MoveTo(m_RectZoomOldpoint.x, m_RectZoomOldpoint.y); 
		dc.LineTo(m_oldpt.x, m_RectZoomOldpoint.y); 
		dc.LineTo(m_oldpt.x, m_oldpt.y); 
		dc.LineTo(m_RectZoomOldpoint.x, m_oldpt.y); 
		dc.LineTo(m_RectZoomOldpoint.x, m_RectZoomOldpoint.y); 
 
		dc.MoveTo(m_RectZoomOldpoint.x, m_RectZoomOldpoint.y); 
		dc.LineTo(point.x, m_RectZoomOldpoint.y); 
		dc.LineTo(point.x, point.y); 
		dc.LineTo(m_RectZoomOldpoint.x, point.y); 
		dc.LineTo(m_RectZoomOldpoint.x, m_RectZoomOldpoint.y); 
	} 
	m_oldpt = m_current; 
	CView::OnMouseMove(nFlags, point); 
} 
 
 
 
 
 
void CMfcopenView::OnTranslate()  
{ 
	// TODO: Add your command handler code here 
	if(m_popmenu == INT_TRANSLATE) 
	{ 
		m_popmenu = INT_END; 
		m_hcursor = AfxGetApp()->LoadCursor(IDC_POINTER); 
		SetCursor(m_hcursor); 
		ShowCursor(true); 
		return; 
	} 
	m_popmenu = INT_TRANSLATE;	 
	m_hcursor = AfxGetApp()->LoadCursor(IDC_CURSORTRA); 
	SetCursor(m_hcursor); 
	ShowCursor(true); 
 
 
} 
 
void CMfcopenView::OnUpdateTranslate(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen||m_bFakOpen); 
	pCmdUI->SetCheck(m_popmenu == INT_TRANSLATE); 
} 
 
void CMfcopenView::OnUpdateRotate(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen||m_bFakOpen); 
	pCmdUI->SetCheck(m_popmenu == INT_ROTATE); 
} 
 
 
 
void CMfcopenView::ProcessData(STLArray *data) 
{ 
	CMfcopenDoc* pDoc = GetDocument();	 
	STLArray *temparray = data; 
	int ii=0; 
	while(temparray!=NULL) 
	{ 
		STLData *tempdata = temparray->stl; 
		m_fboxsize[ii][0] = pDoc->m_fboxsize[ii][0]/pDoc->m_fBoxMax;//处理数据 
		m_fboxsize[ii][1] = pDoc->m_fboxsize[ii][1]/pDoc->m_fBoxMax; 
		m_fboxsize[ii][2] = pDoc->m_fboxsize[ii][2]/pDoc->m_fBoxMax; 
 
		m_fcenter[ii][0]  = pDoc->m_fcenter[ii][0]/pDoc->m_fBoxMax; 
		m_fcenter[ii][1]  = pDoc->m_fcenter[ii][1]/pDoc->m_fBoxMax; 
		m_fcenter[ii][2]  = pDoc->m_fcenter[ii][2]/pDoc->m_fBoxMax;//处理数据 
 
		m_forigincenter[ii][0] = m_fcenter[ii][0]; 
		m_forigincenter[ii][1] = m_fcenter[ii][1]; 
		m_forigincenter[ii][2] = m_fcenter[ii][2]; 
 
		m_fsectcenter[ii][0] = m_fcenter[ii][0]; 
		m_fsectcenter[ii][1] = m_fcenter[ii][1]; 
		m_fsectcenter[ii][2] = m_fcenter[ii][2]; 
 
		while(tempdata!=NULL) 
		{ 
			for(int i=0; i<3; i++) 
			{ 
				tempdata->fPoint1[i] /= pDoc->m_fBoxMax; 
				tempdata->fPoint2[i] /= pDoc->m_fBoxMax; 
				tempdata->fPoint3[i] /= pDoc->m_fBoxMax; 
			} 
			tempdata = tempdata->next; 
		} 
		ii++; 
		temparray = temparray->next; 
	} 
} 
 
 
void CMfcopenView::OnRotate()  
{ 
	// TODO: Add your command handler code here 
	if(m_popmenu == INT_ROTATE) 
	{ 
		m_popmenu = INT_END; 
		m_hcursor = AfxGetApp()->LoadCursor(IDC_POINTER); 
		SetCursor(m_hcursor); 
		ShowCursor(true); 
		return; 
	} 
	m_popmenu = INT_ROTATE;	 
	m_hcursor = AfxGetApp()->LoadCursor(IDC_CURSORROT); 
	SetCursor(m_hcursor); 
	ShowCursor(true); 
} 
 
void CMfcopenView::OnZoom()  
{ 
	// TODO: Add your command handler code here 
	if(m_popmenu == INT_ZOOM) 
	{ 
		m_popmenu = INT_END; 
		m_hcursor = AfxGetApp()->LoadCursor(IDC_POINTER); 
		SetCursor(m_hcursor); 
		ShowCursor(true); 
		return; 
	} 
	m_popmenu = INT_ZOOM;	 
	m_hcursor = AfxGetApp()->LoadCursor(IDC_CURSORZOOM); 
	SetCursor(m_hcursor); 
	ShowCursor(true);	 
} 
 
void CMfcopenView::OnUpdateZoom(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen||m_bFakOpen); 
	pCmdUI->SetCheck(m_popmenu == INT_ZOOM);	 
} 
 
 
void CMfcopenView::OnRButtonDown(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	CRect rect; 
	GetClientRect(&rect); 
 
	if(rect.PtInRect(point)) 
	{ 
		if(m_popmenu == INT_TRANSLATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORTRA)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ROTATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROT)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM)); 
			ShowCursor(true); 
		} 
		else 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_POINTER)); 
			ShowCursor(true); 
		} 
	} 
	CView::OnRButtonDown(nFlags, point); 
} 
 
void CMfcopenView::OnRButtonDblClk(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	CRect rect; 
	GetClientRect(&rect); 
 
	if(rect.PtInRect(point)) 
	{ 
		if(m_popmenu == INT_TRANSLATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORTRA)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ROTATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROT)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM)); 
			ShowCursor(true); 
		} 
		else 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_POINTER)); 
			ShowCursor(true); 
		} 
	} 
	CView::OnRButtonDblClk(nFlags, point); 
} 
 
void CMfcopenView::OnLButtonDblClk(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	CRect rect; 
	GetClientRect(&rect); 
 
	if(rect.PtInRect(point)) 
	{ 
		if(m_popmenu == INT_TRANSLATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORTRA)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ROTATE) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROT)); 
			ShowCursor(true); 
		} 
		else if(m_popmenu == INT_ZOOM) 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORZOOM)); 
			ShowCursor(true); 
		} 
		else 
		{ 
			SetCursor(AfxGetApp()->LoadCursor(IDC_POINTER)); 
			ShowCursor(true); 
 
		} 
	} 
	CView::OnLButtonDblClk(nFlags, point); 
} 
 
void CMfcopenView::OnTreeColor()  
{ 
	// TODO: Add your command handler code here 
	COLORREF colorTemp = RGB(255, 0, 0); 
	CColorDialog dlg(colorTemp); 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
 
	if(m_itreeflag >= 999) 
		return; 
	 
	if(dlg.DoModal()==IDOK) 
	{ 
		colorTemp=dlg.GetColor(); 
		mat_amb_diff[m_itreeflag][0] = (float)GetRValue(colorTemp) / 255.0f; 
		mat_amb_diff[m_itreeflag][1] = (float)GetGValue(colorTemp) / 255.0f; 
		mat_amb_diff[m_itreeflag][2] = (float)GetBValue(colorTemp) / 255.0f; 
	} 
} 
 
void CMfcopenView::OnUpdateTreeColor(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
 
	if((m_itreeflag >= 999)||(m_itreeflag == 0)) 
		pCmdUI->Enable(FALSE); 
	else 
		pCmdUI->Enable(TRUE);	 
} 
 
void CMfcopenView::OnTreeHide()  
{ 
	// TODO: Add your command handler code here	 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
	 
	if(m_itreeflag == 999) 
	{ 
		m_ballhide = !m_ballhide; 
		if(m_ballhide) 
		{ 
			for(UINT i=1; i<=pTree->m_nItemSum; i++) 
			{ 
					m_ilflag[i] = 1; 
			} 
		} 
		else 
		{ 
			for(UINT i=1; i<=pTree->m_nItemSum; i++) 
			{ 
				m_ilflag[i] = 0; 
			} 
		} 
		return; 
	} 
	int tempcount = 0; 
	for(int i=0; i< pTree->m_itypenumber; i++) 
	{ 
		tempcount++;		//计算是否有类型被点击 
		//第i个类型被点击 
		if(m_itreeflag == (UINT)(1000+i)) 
		{ 
			m_btypehide[i+1] = !m_btypehide[i+1]; 
			tempcount -= 20; 
			int tempcount1 = 1; 
			int tempcount2 = pTree->m_ichildnumber[0]; 
			for(int j=0; jm_ichildnumber[j]; 
				tempcount2 += pTree->m_ichildnumber[j+1]; 
			} 
 
			if(m_btypehide[i+1]) 
			{ 
				for(int i=tempcount1; i<=tempcount2; i++) 
				{ 
					m_ilflag[i] = 1; 
				} 
			} 
			else 
			{ 
				for(int i=tempcount1; i<=tempcount2; i++) 
				{ 
					m_ilflag[i] = 0; 
				} 
			}				 
		} 
	} 
	//类型的子节点被点击 
	if(tempcount >= pTree->m_itypenumber)		//类型没被点击 
	{ 
		if(m_ilflag[m_itreeflag]==1) 
			m_ilflag[m_itreeflag] = 0;//0表示不隐藏 
		else  
			m_ilflag[m_itreeflag] = 1;//1表示隐藏 
	} 
 
} 
 
void CMfcopenView::OnUpdateTreeHide(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
 
	pCmdUI->Enable(m_itreeflag); 
	if(m_itreeflag == 999) 
		pCmdUI->SetCheck(m_ballhide); 
	else  
	{ 
		for(int i=0; im_itypenumber; i++) 
		{ 
			if(m_itreeflag == (UINT)(1000+i)) 
				pCmdUI->SetCheck(m_btypehide[i]); 
		} 
		if(i>=pTree->m_itypenumber) 
			pCmdUI->SetCheck(m_ilflag[m_itreeflag] == 1); 
	} 
} 
 
 
//平移参数接受 
void CMfcopenView::OnTreeTranslate()  
{ 
	// TODO: Add your command handler code here 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
	if(m_itreeflag<999) 
		pTree->SendMessage(WM_HIGHLIGHT, m_itreeflag, m_iObjectId); 
 
	CTransParaDlg dlg; 
	if(m_itreeflag == 999)			 //工作中心被点击 
		return; 
	int tt = dlg.DoModal(); 
	if(tt==IDOK) 
	{ 
		if(dlg.m_ftimestart >= dlg.m_ftimeend) 
		{ 
			MessageBox("时间区间设置错误:\n起始时间不小于终止时间!", "错误", MB_OK | MB_ICONSTOP); 
			return;		 
		} 
		int tempcount = 0; 
		//类型被点击 
		for(int i=0; i< pTree->m_itypenumber; i++) 
		{ 
			tempcount++;		//计算是否有类型被点击 
			//第i个类型被点击 
			if(m_itreeflag == (UINT)(1000+i)) 
			{ 
				tempcount -= 20; 
				int tempcount1 = 1; 
				int tempcount2 = pTree->m_ichildnumber[0]; 
				for(int j=0; jm_ichildnumber[j]; 
					tempcount2 += pTree->m_ichildnumber[j+1]; 
				} 
				//检查 
				for(j=tempcount1; j<=tempcount2; j++) 
				{ 
					if(m_ftimemove[j][3][0] != m_ftimemove[j][3][1]) 
					{ 
						MessageBox("测试版只能定义单个实体的四次运动!\n要想获得更多支持，请购买正式版!\n联系办法见帮助文件!", "注意", MB_OK | MB_ICONEXCLAMATION); 
						return; 
					} 
					//可能的多次运动检查，上限是4次 
					for(int k=0; k<4 ; k++) 
					{ 
						//我们认为两次不同运动不会存在相交时间区间，端点除外 
						//第一次赋值时间区间！ 
						if(m_ftimemove[j][k][0] == m_ftimemove[j][k][1]) 
						{ 
							continue; 
						} 
						if((dlg.m_ftimeend <= m_ftimemove[j][k][0] || dlg.m_ftimestart >= m_ftimemove[j][k][1]) && m_ftimemove[j][k][0]!=0) 
						{ 
							continue; 
						} 
						else 
						{ 
							MessageBox("这个时间区间已经定义了一个运动，您应该再选择别的区间!", "注意", MB_OK|MB_ICONEXCLAMATION); 
							return; 
						} 
					} 
				} 
				//赋予增加的运动！ 
				for(j=tempcount1; j<=tempcount2; j++) 
				{ 
					//可能的多次运动检查，上限是4次 
					for(int k=0; k<4 ; k++) 
					{ 
						//我们认为两次不同运动不会存在相交时间区间，端点除外 
						//第一次赋值时间区间！ 
						if(m_ftimemove[j][k][0] == m_ftimemove[j][k][1]) 
						{ 
							k++; 
							break; 
						} 
					} 
					m_itrannumber[j] = k;// 
 
					if(k>0) 
					{ 
						//运动时间 
						m_ftimemove[j][k-1][0] = dlg.m_ftimestart/m_ftimes; 
						m_ftimemove[j][k-1][1] = dlg.m_ftimeend/m_ftimes; 
 
						//信息记录 
						m_fInformation[j][k-1][0] = dlg.m_ftranx; 
						m_fInformation[j][k-1][1] = dlg.m_ftrany; 
						m_fInformation[j][k-1][2] = dlg.m_ftranz; 
 
						//运动长度,m_fmove[0、1、2]代表终止的位置 
						m_fmove[j][k-1][0] = m_fInformation[j][k-1][0]/m_fBoxMax; 
						m_fmove[j][k-1][1] = m_fInformation[j][k-1][1]/m_fBoxMax; 
						m_fmove[j][k-1][2] = m_fInformation[j][k-1][2]/m_fBoxMax; 
 
						//速度控制 
						m_ftimes = dlg.m_ftimes; 
 
						float tempstep = (m_ftimemove[j][k-1][1]-m_ftimemove[j][k-1][0])*50; 
						m_fsteptranslate[j][k-1][0] = m_fmove[j][k-1][0]/tempstep; 
						m_fsteptranslate[j][k-1][1] = m_fmove[j][k-1][1]/tempstep; 
						m_fsteptranslate[j][k-1][2] = m_fmove[j][k-1][2]/tempstep; 
					} 
				} 
			} 
		} 
		//类型的子节点被点击 
		if(tempcount >= pTree->m_itypenumber)		//类型没被点击 
		{ 
			if(m_ftimemove[m_itreeflag][3][0] != m_ftimemove[m_itreeflag][3][1]) 
			{ 
				MessageBox("测试版只能定义单个实体的四次运动!\n要想获得更多支持，请购买正式版!\n联系办法见帮助文件!", "注意", MB_OK | MB_ICONEXCLAMATION); 
				return; 
			} 
			//可能的多次运动检查，上限是4次 
			for(int k=0; k<4; k++) 
			{ 
				//我们认为两次不同运动不会存在相交时间区间，端点除外,约定所有实体不从0开始运动 
				if(m_ftimemove[m_itreeflag][k][0] == m_ftimemove[m_itreeflag][k][1]) 
					continue; 
				if((dlg.m_ftimeend <= m_ftimemove[m_itreeflag][k][0] || dlg.m_ftimestart >= m_ftimemove[m_itreeflag][k][1]) && m_ftimemove[m_itreeflag][k][0]!=0) 
					continue; 
				else 
				{ 
					MessageBox("这个时间区间已经定义了一个运动，您应该再选择别的区间!", "注意", MB_OK|MB_ICONEXCLAMATION); 
					return; 
				} 
			} 
 
			for(k=0; k<4; k++) 
			{ 
				if(m_ftimemove[m_itreeflag][k][0] == m_ftimemove[m_itreeflag][k][1]) 
				{ 
					k++; 
					break; 
				} 
			} 
			m_itrannumber[m_itreeflag] = k; 
 
			//运动时间 
			m_ftimemove[m_itreeflag][k-1][0] = dlg.m_ftimestart/m_ftimes; 
			m_ftimemove[m_itreeflag][k-1][1] = dlg.m_ftimeend/m_ftimes; 
 
			//信息记录 
			m_fInformation[m_itreeflag][k-1][0] = dlg.m_ftranx; 
			m_fInformation[m_itreeflag][k-1][1] = dlg.m_ftrany; 
			m_fInformation[m_itreeflag][k-1][2] = dlg.m_ftranz; 
 
			//运动长度,m_fmove[0、1、2]代表终止的位置 
			m_fmove[m_itreeflag][k-1][0] = m_fInformation[m_itreeflag][k-1][0]/m_fBoxMax; 
			m_fmove[m_itreeflag][k-1][1] = m_fInformation[m_itreeflag][k-1][1]/m_fBoxMax; 
			m_fmove[m_itreeflag][k-1][2] = m_fInformation[m_itreeflag][k-1][2]/m_fBoxMax; 
 
			//速度控制 
			m_ftimes = dlg.m_ftimes; 
		 
			float tempstep = (m_ftimemove[m_itreeflag][k-1][1]-m_ftimemove[m_itreeflag][k-1][0])*50; 
			//首次减0 
			m_fsteptranslate[m_itreeflag][k-1][0] = m_fmove[m_itreeflag][k-1][0]/tempstep; 
			m_fsteptranslate[m_itreeflag][k-1][1] = m_fmove[m_itreeflag][k-1][1]/tempstep; 
			m_fsteptranslate[m_itreeflag][k-1][2] = m_fmove[m_itreeflag][k-1][2]/tempstep; 
		}	 
	} 
	else 
	{ 
		return; 
	} 
} 
 
void CMfcopenView::OnUpdateTreeTranslate(CCmdUI* pCmdUI)  
{ 
	 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
 
	pCmdUI->Enable(m_itreeflag); 
	//点击工作中心不被平移 
	if(m_itreeflag == 999) 
		pCmdUI->Enable(FALSE); 
	//允许其他的平移 
	else  
	{ 
		for(int i=0; im_itypenumber; i++) 
		{ 
			if(m_itreeflag == (UINT)(1000+i)) 
				pCmdUI->Enable(!m_btypehide[i]); 
		} 
		if(i>=pTree->m_itypenumber) 
			pCmdUI->Enable(!(m_ilflag[m_itreeflag] == 1)); 
	} 
} 
 
 
void CMfcopenView::OnPlay()  
{ 
	// TODO: Add your command handler code here 
	CMfcopenDoc* pDoc = GetDocument(); 
	if(!m_btempstop) 
	{ 
		for(int i=0; i<100; i++) 
			for(int j=0; j<4; j++) 
				m_fmove[i][j][3] = 0; 
		m_fglobaltime = 0; 
			//中心坐标还原 
		for(i=0; i<100; i++) 
			for(int j=0; j<3; j++) 
				m_fcenter[i][j] = m_fsectcenter[i][j] = m_forigincenter[i][j]; 
		g_bganshe = FALSE; 
		Invalidate(FALSE); 
		UpdateWindow(); 
	} 
	m_bplay = !m_bplay; 
 
	if(m_bplay)//启动平移开关 
	{ 
		m_fglobaltime = 0;//时间置零 
		m_brepeat = FALSE; 
	} 
	else//关闭平移开关 
	{ 
		for(int i=0; i<100; i++) 
			for(int j=0; j<4; j++) 
				m_fmove[i][j][3] = 0; 
		m_fglobaltime = 0; 
		//中心坐标还原 
		for(i=0; i<100; i++) 
			for(int j=0; j<3; j++) 
				m_fcenter[i][j] = m_fsectcenter[i][j] = m_forigincenter[i][j]; 
		g_bganshe = FALSE; 
		Invalidate(FALSE); 
		UpdateWindow(); 
	} 
	 
} 
 
void CMfcopenView::OnUpdatePlay(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable((m_bfileopen||m_banimalfileopen)&&!m_brepeat&&!m_btempstop); 
	pCmdUI->SetCheck(m_bplay); 
} 
 
 
void CMfcopenView::OnTreeInformation()  
{ 
	// TODO: Add your command handler code here 
	CClientDC dc(this); 
	CMainFrame* pFrame; 
 	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
 	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex();	 
 
	if(m_itreeflag >= 999) 
		return;	 
		 
	CString str; 
	str.Format("它被平移过%d次\n具体细节信息请查询信息窗口\n", m_itrannumber[m_itreeflag]); 
	MessageBox(str, "信息", MB_ICONINFORMATION); 
} 
 
void CMfcopenView::OnUpdateTreeInformation(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	CChildTree* pTree=(CChildTree*)&pFrame->m_cTree; 
	m_itreeflag = pTree->GetSelectItemIndex(); 
	 
	if((m_itreeflag >= 999)||(m_itreeflag == 0)) 
		pCmdUI->Enable(FALSE); 
	else 
		pCmdUI->Enable(TRUE); 
		 
} 
 
 
void CMfcopenView::OnTempstop()  
{ 
	// TODO: Add your command handler code here 
	m_btempstop = !m_btempstop;	 
} 
 
void CMfcopenView::OnUpdateTempstop(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bplay||m_btempstop||m_brepeat); 
	pCmdUI->SetCheck(m_btempstop); 
} 
 
void CMfcopenView::OnRepeat()  
{ 
	// TODO: Add your command handler code here 
	m_brepeat = !m_brepeat; 
 
	if(!m_btempstop) 
	{ 
		for(int i=0; i<100; i++) 
			for(int j=0; j<4; j++) 
				m_fmove[i][j][3] = 0; 
		m_fglobaltime = 0; 
			//中心坐标还原 
		for(i=0; i<100; i++) 
			for(int j=0; j<3; j++) 
				m_fcenter[i][j] = m_fsectcenter[i][j] = m_forigincenter[i][j]; 
		g_bganshe = FALSE; 
		Invalidate(FALSE); 
		UpdateWindow(); 
	} 
	if(m_brepeat) 
	{	 
		m_bplay = FALSE; 
		m_btempstop = FALSE; 
		m_fglobaltime = 0; 
	} 
	else//关闭平移开关 
	{ 
		for(int i=0; i<100; i++) 
			for(int k=0; k<4; k++) 
				m_fmove[i][k][3] = 0; 
		m_fglobaltime = 0; 
		//中心坐标还原 
		for(i=0; i<100; i++) 
			for(int j=0; j<3; j++) 
				m_fcenter[i][j] = m_fsectcenter[i][j] = m_forigincenter[i][j]; 
		g_bganshe = FALSE; 
		Invalidate(FALSE); 
		UpdateWindow(); 
	}	 
} 
 
void CMfcopenView::OnUpdateRepeat(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable((m_bfileopen||m_banimalfileopen)&&!m_bplay&&!m_btempstop); 
	pCmdUI->SetCheck(m_brepeat); 
} 
 
void CMfcopenView::OnContextMenu(CWnd* pWnd, CPoint point)  
{ 
	// TODO: Add your message handler code here 
	CMfcopenDoc* pDoc = GetDocument(); 
	if((pDoc->m_array == NULL || pDoc->m_array->next == NULL)&&!m_bFakOpen) 
	{ 
		return; 
	} 
	CMenu menu; 
	menu.LoadMenu(IDR_MENUPOPUP); 
	menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON, point.x, point.y, AfxGetMainWnd()); 
		 
} 
 
int CMfcopenView::RetrieveObjectID(int x, int y) 
{ 
	int objectsfound = 0; 
	int viewportcoord[4] = {0}; 
	unsigned int selectbuffer[32] = {0}; 
 
	glSelectBuffer(32, selectbuffer); 
	glGetIntegerv(GL_VIEWPORT, viewportcoord); 
 
	glMatrixMode(GL_PROJECTION); 
	glPushMatrix(); 
		glRenderMode(GL_SELECT); 
		glLoadIdentity(); 
		gluPickMatrix(x, viewportcoord[3]-y, 2, 2, viewportcoord); 
		glOrtho(m_fleft*m_scale,m_fright*m_scale, 
			 m_fbottom*m_scale, m_ftop*m_scale,-100.0,100.0);  
		glMatrixMode(GL_MODELVIEW); 
		DrawGLScene(); 
		objectsfound = glRenderMode(GL_RENDER); 
		glMatrixMode(GL_PROJECTION); 
	glPopMatrix(); 
 
	glMatrixMode(GL_MODELVIEW); 
 
	if(objectsfound > 0) 
	{ 
		unsigned int lowestdepth = selectbuffer[1]; 
		int selectedobject = selectbuffer[3]; 
 
		for(int i=0; im_iDArrnumber; j++) 
		{ 
			float tempvalue = 0; 
			float abs_x = (tempvalue = (m_fcenter[i][0] - m_fcenter[j][0])) > 0 ? tempvalue : -tempvalue; 
			float abs_y = (tempvalue = (m_fcenter[i][1] - m_fcenter[j][1])) > 0 ? tempvalue : -tempvalue; 
			float abs_z = (tempvalue = (m_fcenter[i][2] - m_fcenter[j][2])) > 0 ? tempvalue : -tempvalue; 
 
			if(abs_x > (m_fboxsize[i][0] + m_fboxsize[j][0])/2 || abs_y > (m_fboxsize[i][1] + m_fboxsize[j][1])/2 || abs_z > (m_fboxsize[i][2] + m_fboxsize[j][2])/2) 
				continue;				 
			else 
			{	 
				//2、box已经相交，现在应该进行更加严格的检查 
				if(  DetailCheck(j-1, r-1)  ) 
				{ 
					if(!g_bganshe) 
					{ 
						m_bplay = FALSE; 
 
						KillTimer(1);  
						MessageBox("存在预定运动下的不正常干涉！！", "ERROR", MB_OK); 
						SetTimer(1, 20, NULL); 
						g_bganshe = TRUE; 
 
						//把干涉信息记入output窗口 
						CMainFrame* pFrame; 
						pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
						COutputBar *m_output = &(pFrame->m_wndOutput); 
						CMfcopenDoc *pdoc = GetDocument(); 
 
						if(ganshe_writer > 0) 
							m_output->m_BuildList.ResetContent(); 
						ganshe_writer++; 
						CString str; 
						str = "						预定运动下存在干涉，以下是干涉信息：\n"; 
						m_output->m_BuildList.AddString(str); 
	 
						str = "--------------------------------------------------------------"; 
						m_output->m_BuildList.AddString(str);						 
 
						str.Format("		1、存在干涉的两个物体序列号是：%d 和 %d", j, r); 
						m_output->m_BuildList.AddString(str); 
 
						str.Format("		2、其中实体 %d 运动的实际距离如下：", j); 
						m_output->m_BuildList.AddString(str); 
						str.Format("			X : %f, Y: %f, Z:%f", (m_fcenter[j][0] - m_forigincenter[j][0])*m_fBoxMax, (m_fcenter[j][1] - m_forigincenter[j][1])*m_fBoxMax,(m_fcenter[j][2] - m_forigincenter[j][2])*m_fBoxMax); 
						m_output->m_BuildList.AddString(str); 
						 
						str.Format("		3、其中实体 %d 运动的实际距离如下：", r); 
						m_output->m_BuildList.AddString(str); 
						str.Format("			X : %f, Y: %f, Z:%f", (m_fcenter[r][0] - m_forigincenter[r][0])*m_fBoxMax, (m_fcenter[r][1] - m_forigincenter[r][1])*m_fBoxMax,(m_fcenter[r][2] - m_forigincenter[r][2])*m_fBoxMax); 
						m_output->m_BuildList.AddString(str); 
 
					} 
 
					//////////////////////////// 
					//干涉后事处理 
					for(int n=1; n<=pDoc->m_iDArrnumber; n++) 
					{ 
						m_fmove[n][m_istlmove[n]][3]   = -100;//stop! 
					} 
 
					//定"最后"位置 
					for(int error=1; error <= pDoc->m_iDArrnumber; error++) 
					{ 
						m_fmove[error][m_istlmove[error]][0] = m_fcenter[error][0] - m_forigincenter[error][0]; 
						m_fmove[error][m_istlmove[error]][1] = m_fcenter[error][1] - m_forigincenter[error][1]; 
						m_fmove[error][m_istlmove[error]][2] = m_fcenter[error][2] - m_forigincenter[error][2]; 
					} 
					///////////////////////////// 
					return TRUE;	 
				} 
				else 
					return FALSE; 
			}	 
		} 
 
		return FALSE; 
} 
 
BOOL CMfcopenView::OctTreeCheck(STLOctTree *first, STLOctTree *second, float x[3], float y[3]) 
{ 
	int flag1 = 0; 
	int flag2 = 0; 
	for(int vv=0; vv<8; vv++) 
	{	 
		//两棵树可能有不同的深度，只进行同层比较是不对的！ 
		if(first->pchild[vv] == NULL) 
		{ 
			flag1++; 
			continue; 
		} 
		else 
		{ 
			if(first->pchild[vv]->IsHave == 0) 
				continue; 
			float first_center[3] = { first->pchild[vv]->m_vCenter.x+x[0], first->pchild[vv]->m_vCenter.y+x[1], first->pchild[vv]->m_vCenter.z+x[2] }; 
			int tt = 0; 
			for(int kk=0; kk<8; kk++) 
			{ 
				if(second->pchild[kk] == NULL) 
				{ 
					tt++; 
					continue; 
				} 
				else 
				{ 
					if(second->pchild[kk]->IsHave == 0) 
						continue; 
					float second_center[3] = { second->pchild[kk]->m_vCenter.x+y[0], second->pchild[kk]->m_vCenter.y+y[1], second->pchild[kk]->m_vCenter.z+y[2] }; 
					float delta; 
					float abs_x = (delta = first_center[0] - second_center[0]) > 0 ? delta : -delta; 
					float abs_y = (delta = first_center[1] - second_center[1]) > 0 ? delta : -delta; 
					float abs_z = (delta = first_center[2] - second_center[2]) > 0 ? delta : -delta; 
					if(abs_x > (first->pchild[vv]->m_Width+second->pchild[kk]->m_Width)/2.0f ||  
					   abs_y > (first->pchild[vv]->m_Width+second->pchild[kk]->m_Width)/2.0f || 
					   abs_z > (first->pchild[vv]->m_Width+second->pchild[kk]->m_Width)/2.0f) 
					   continue; 
					else 
					{ 
						if(!OctTreeCheck(first->pchild[vv], second->pchild[kk], x, y)) 
							continue; 
						else 
						{ 
							if(ganshe_first == NULL) 
							{ 
								ganshe_first  = first->pchild[vv]; 
								ganshe_second = second->pchild[kk]; 
 
								m_fganshemove[0][0] = first->pchild[vv]->m_vCenter.x+x[0]; 
								m_fganshemove[0][1] = first->pchild[vv]->m_vCenter.y+x[1]; 
								m_fganshemove[0][2] = first->pchild[vv]->m_vCenter.z+x[2]; 
 
								m_fganshemove[1][0] = second->pchild[kk]->m_vCenter.x+y[0]; 
								m_fganshemove[1][1] = second->pchild[kk]->m_vCenter.y+y[1]; 
								m_fganshemove[1][2] = second->pchild[kk]->m_vCenter.z+y[2]; 
 
							} 
							return TRUE; 
						} 
					} 
				} 
			} 
			if(tt >= 8 && second->IsHave != 0) 
			{ 
				//这棵树的叶节点 
				if(!NonSynOctTreeCheck(first->pchild[vv], second, x, y)) 
					continue; 
				else 
					return TRUE; 
			} 
		} 
	} 
	if(flag1 >= 8 && first->IsHave != 0) 
	{ 
		//这棵树的叶节点 
		int glat = 0; 
		for(int rr=0; rr<8; rr++) 
		{ 
			if(second->pchild[rr] != NULL) 
			{ 
				if(!NonSynOctTreeCheck(second->pchild[rr], first, y, x)) 
					continue; 
				else 
					return TRUE; 
			} 
			else 
				glat++; 
		} 
		if(glat >= 8) 
		{ 
			if(second->IsHave == 0) 
				return FALSE; 
			else 
			{ 
				if(ganshe_first == NULL) 
				{ 
					ganshe_first  = first; 
					ganshe_second = second; 
 
					m_fganshemove[0][0] = first->m_vCenter.x+x[0]; 
					m_fganshemove[0][1] = first->m_vCenter.y+x[1]; 
					m_fganshemove[0][2] = first->m_vCenter.z+x[2]; 
 
					m_fganshemove[1][0] = second->m_vCenter.x+y[0]; 
					m_fganshemove[1][1] = second->m_vCenter.y+y[1]; 
					m_fganshemove[1][2] = second->m_vCenter.z+y[2]; 
				} 
				return TRUE; 
			} 
		} 
	} 
	return FALSE; 
} 
 
//非同层比较 
BOOL CMfcopenView::NonSynOctTreeCheck(STLOctTree *root, STLOctTree *leaf, float x[3], float y[3]) 
{ 
	float root_center[3] = { root->m_vCenter.x+x[0], root->m_vCenter.y+x[1], root->m_vCenter.z+x[2] }; 
	float leaf_center[3] = { leaf->m_vCenter.x+y[0], leaf->m_vCenter.y+y[1], leaf->m_vCenter.z+y[2] }; 
	 
	float delta; 
	float abs_x = (delta = root_center[0] - leaf_center[0]) > 0 ? delta : -delta; 
	float abs_y = (delta = root_center[1] - leaf_center[1]) > 0 ? delta : -delta; 
	float abs_z = (delta = root_center[2] - leaf_center[2]) > 0 ? delta : -delta; 
	if(abs_x > (root->m_Width+leaf->m_Width)/2.0f ||  
	   abs_y > (root->m_Width+leaf->m_Width)/2.0f || 
	   abs_z > (root->m_Width+leaf->m_Width)/2.0f) 
		return FALSE; 
	else 
	{ 
		int flag2 = 0; 
		for(int vv=0; vv<8; vv++) 
		{ 
			if(root->pchild[vv] != NULL) 
			{ 
				if(!NonSynOctTreeCheck(root->pchild[vv], leaf, x, y)) 
					continue; 
				else 
				{ 
					if(ganshe_first == NULL) 
					{ 
						ganshe_first  = root->pchild[vv]; 
						ganshe_second = leaf; 
 
						m_fganshemove[0][0] = root->pchild[vv]->m_vCenter.x+x[0]; 
						m_fganshemove[0][1] = root->pchild[vv]->m_vCenter.y+x[1]; 
						m_fganshemove[0][2] = root->pchild[vv]->m_vCenter.z+x[2]; 
 
						m_fganshemove[1][0] = leaf->m_vCenter.x+y[0]; 
						m_fganshemove[1][1] = leaf->m_vCenter.y+y[1]; 
						m_fganshemove[1][2] = leaf->m_vCenter.z+y[2]; 
					} 
					return TRUE; 
				} 
			} 
			else 
				flag2++; 
		} 
		//两个叶节点比较 
		if(flag2 >= 8) 
		{ 
			if(root->IsHave == 0) 
				return FALSE; 
			if(ganshe_first == NULL) 
			{ 
				ganshe_first  = root; 
				ganshe_second = leaf; 
 
				m_fganshemove[0][0] = root->m_vCenter.x+x[0]; 
				m_fganshemove[0][1] = root->m_vCenter.y+x[1]; 
				m_fganshemove[0][2] = root->m_vCenter.z+x[2]; 
 
				m_fganshemove[1][0] = leaf->m_vCenter.x+y[0]; 
				m_fganshemove[1][1] = leaf->m_vCenter.y+y[1]; 
				m_fganshemove[1][2] = leaf->m_vCenter.z+y[2]; 
			} 
			return TRUE; 
		} 
	} 
	return FALSE; 
} 
 
BOOL CMfcopenView::DetailCheck(int i, int j) 
{ 
	//两棵树之间进行比较 
	STLOctTree *first  = root[i]; 
	STLOctTree *second = root[j]; 
	if(first == NULL || second == NULL) 
		return FALSE; 
	float x[3] = {m_fcenter[i+1][0] - m_forigincenter[i+1][0], m_fcenter[i+1][1] - m_forigincenter[i+1][1], m_fcenter[i+1][2] - m_forigincenter[i+1][2]}; 
	float y[3] = {m_fcenter[j+1][0] - m_forigincenter[j+1][0], m_fcenter[j+1][1] - m_forigincenter[j+1][1], m_fcenter[j+1][2] - m_forigincenter[j+1][2]}; 
	return OctTreeCheck(first, second, x, y); 
} 
 
void CMfcopenView::OnViewFont()  
{ 
	// TODO: Add your command handler code here 
	m_view = INT_FRONT; 
	m_fxrot = 0; 
	m_fyrot = 0; 
	m_fxtra = 0; 
	m_fytra = 0; 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateViewFont(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->SetRadio(m_view == INT_FRONT); 
} 
 
void CMfcopenView::OnViewLeft()  
{ 
	// TODO: Add your command handler code here 
	m_view = INT_LEFT; 
	m_fxrot = 0; 
	m_fyrot = 0; 
	m_fxtra = 0; 
	m_fytra = 0; 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateViewLeft(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->SetRadio(m_view == INT_LEFT); 
} 
 
void CMfcopenView::OnViewTop()  
{ 
	// TODO: Add your command handler code here 
	m_view = INT_TOP; 
	m_fxrot = 0; 
	m_fyrot = 0; 
	m_fxtra = 0; 
	m_fytra = 0; 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateViewTop(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->SetRadio(m_view == INT_TOP); 
} 
 
void CMfcopenView::OnViewPoints()  
{ 
	// TODO: Add your command handler code here 
	m_umodelview = GL_POINT; 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateViewPoints(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen); 
	pCmdUI->SetCheck(m_umodelview == GL_POINT); 
} 
 
void CMfcopenView::OnViewTriangles()  
{ 
	// TODO: Add your command handler code here 
	m_umodelview = GL_FILL; 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateViewTriangles(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen); 
	pCmdUI->SetCheck(m_umodelview == GL_FILL); 
} 
 
void CMfcopenView::OnViewLines()  
{ 
	// TODO: Add your command handler code here 
	m_umodelview = GL_LINE; 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateViewLines(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen); 
	pCmdUI->SetCheck(m_umodelview == GL_LINE); 
} 
 
void CMfcopenView::OnViewRefresh()  
{ 
	// TODO: Add your command handler code here 
	m_brefresh = TRUE; 
	for(int i=0; i<2; i++) 
		for(int j=0; j<3; j++) 
			m_lineganshe[i][j] = 0; 
 
	for(i=0; i<3; i++) 
		for(int j=0; j<3; j++) 
			m_triangleganshe[i][j] = 0; 
} 
 
void CMfcopenView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)  
{ 
	// TODO: Add your message handler code here and/or call default 
	//获取主框架窗口的指针 
	CMainFrame *pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	switch(nChar){ 
	case VK_ESCAPE: 
		//调用主窗口类的自定义函数 EndFullScreen ，便可退出全屏显示状态 
		pFrame->OnViewRestore(); 
		break; 
	case VK_UP: 
		m_fd -= 0.002f; 
		Invalidate(FALSE); 
		break; 
	case VK_DOWN: 
		m_fd += 0.002f; 
		Invalidate(FALSE); 
		break; 
	} 
 
	CView::OnKeyDown(nChar, nRepCnt, nFlags); 
} 
 
void CMfcopenView::OnRectScale()  
{ 
	// TODO: Add your command handler code here 
	if(m_popmenu == INT_ZOOM_RECT) 
	{ 
		m_popmenu = INT_END; 
		m_hcursor = AfxGetApp()->LoadCursor(IDC_POINTER); 
		SetCursor(m_hcursor); 
		ShowCursor(true); 
		return; 
	} 
	m_popmenu = INT_ZOOM_RECT;	 
	m_hcursor = AfxGetApp()->LoadCursor(IDC_CURSORZOOM_RECT); 
	SetCursor(m_hcursor); 
	ShowCursor(true);	 
} 
 
void CMfcopenView::CreateTexture(UINT textureArray[], LPSTR strFileName, int textureID) 
{ 
	AUX_RGBImageRec *pBitmap = NULL; 
	 
	if(!strFileName)									// Return from the function if no file name was passed in 
		return; 
	 
	// We need to load the texture data, so we use a cool API that the glaux.lib offers. 
	 
	pBitmap = auxDIBImageLoad(strFileName);				// Load the bitmap and store the data 
	 
	if(pBitmap == NULL)									// If we can't load the file, quit! 
		exit(0); 
 
	// Now that we have the texture data, we need to register our texture with OpenGL 
	// To do this we need to call glGenTextures().  The 1 for the first parameter is 
	// how many texture we want to register this time (we could do a bunch in a row). 
	// The second parameter is the array index that will hold the reference to this texture. 
 
	// Generate a texture with the associative texture ID stored in the array 
	glGenTextures(1, &textureArray[textureID]); 
 
	// Now that we have a reference for the texture, we need to bind the texture 
	// to tell OpenGL this is the reference that we are assigning the bitmap data too. 
	// The first parameter tells OpenGL we want are using a 2D texture, while the 
	// second parameter passes in the reference we are going to assign the texture too. 
	// We will use this function later to tell OpenGL we want to use this texture to texture map. 
 
	// Bind the texture to the texture arrays index and init the texture 
	glBindTexture(GL_TEXTURE_2D, textureArray[textureID]); 
 
	// Now comes the important part, we actually pass in all the data from the bitmap to 
	// create the texture. Here is what the parameters mean in gluBuild2DMipmaps(): 
	// (We want a 2D texture, 3 channels (RGB), bitmap width, bitmap height, It's an RGB format, 
	//  the data is stored as unsigned bytes, and the actuall pixel data); 
 
	// What is a Mip map?  Mip maps are a bunch of scaled pictures from the original.  This makes 
	// it look better when we are near and farther away from the texture map.  It chooses the 
	// best looking scaled size depending on where the camera is according to the texture map. 
	// Otherwise, if we didn't use mip maps, it would scale the original UP and down which would 
	// look not so good when we got far away or up close, it would look pixelated. 
 
	// Build Mipmaps (builds different versions of the picture for distances - looks better) 
	gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pBitmap->sizeX, pBitmap->sizeY, GL_RGB, GL_UNSIGNED_BYTE, pBitmap->data); 
 
	// Lastly, we need to tell OpenGL the quality of our texture map.  GL_LINEAR is the smoothest. 
	// GL_NEAREST is faster than GL_LINEAR, but looks blochy and pixelated.  Good for slower computers though. 
	// Read more about the MIN and MAG filters at the bottom of main.cpp 
		 
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); 
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);	 
 
	// Now we need to free the bitmap data that we loaded since openGL stored it as a texture 
 
	if (pBitmap)										// If we loaded the bitmap 
	{ 
		if (pBitmap->data)								// If there is texture data 
		{ 
			free(pBitmap->data);						// Free the texture data, we don't need it anymore 
		} 
 
		free(pBitmap);									// Free the bitmap structure 
	} 
 
} 
 
void CMfcopenView::OnFindLine()  
{ 
	// TODO: Add your command handler code here 
	m_bfindline = INT_LINE; 
} 
 
void CMfcopenView::OnUpdateFindLine(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(g_bganshe); 
} 
 
 
void CMfcopenView::OnFindPort()  
{ 
	// TODO: Add your command handler code here 
	m_bfindline = INT_PORT; 
	OnViewFont(); 
} 
 
void CMfcopenView::OnUpdateFindPort(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(g_bganshe);	 
} 
 
void CMfcopenView::OnToolbar3()  
{ 
	// TODO: Add your command handler code here 
	KillTimer(1); 
	m_bcut1 = !m_bcut1; 
	if(m_bcut1) 
	{ 
		float a, b, c, d; 
		CPlandlg planedlg; 
		if(planedlg.DoModal()==IDOK) 
		{ 
			a = planedlg.m_fa;	b = planedlg.m_fb;	c = planedlg.m_fc;	d = -planedlg.m_fd; 
		} 
		CVector3 xishu; 
		xishu.x = a; xishu.y = b; xishu.z = c; 
		Normalize(xishu); 
		m_xishu = xishu; 
		d = d/Magnitude(xishu);	 
		m_fd = d; 
	} 
	SetTimer(1, 20, NULL); 
} 
 
void CMfcopenView::OnUpdateToolbar3(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen); 
	pCmdUI->SetCheck(m_bcut1); 
	pCmdUI->Enable(!m_bcut2); 
} 
 
void CMfcopenView::ShowSection(int i, int rk) 
{ 
	Link *head = new Link; 
	head->point1.x = head->point1.y = head->point1.z = 1000.0f; 
	head->point2.x = head->point2.y = head->point2.z = 1000.0f; 
	head->flag = FALSE; 
	head->next = NULL; 
 
	CMfcopenDoc* pDoc = GetDocument(); 
	STLArray *data = pDoc->m_array; 
 
	STLStruct *first = NULL; 
	for( ; data!=NULL; data=data->next) 
	{ 
		if((unsigned)i == data->flag) 
			first = data->stl; 
	} 
	//对这个物体的每一三角形，求它与平面的相交情况，优化！！！！！！！！！！！ 
	while(first->next != NULL) 
		{ 
			CVector3 point1, point2, point3; 
			point1.x = first->next->fPoint1[0]; point1.y = first->next->fPoint1[1]; point1.z = first->next->fPoint1[2]; 
			point2.x = first->next->fPoint2[0]; point2.y = first->next->fPoint2[1]; point2.z = first->next->fPoint2[2]; 
			point3.x = first->next->fPoint3[0]; point3.y = first->next->fPoint3[1]; point3.z = first->next->fPoint3[2]; 
 
			//因为规定所有的点都保持不变，故现在只有计算变化了的临时值 
			point1.x += m_fcenter[i][0] - m_forigincenter[i][0]; point1.y += m_fcenter[i][1] - m_forigincenter[i][1]; point1.z += m_fcenter[i][2] - m_forigincenter[i][2]; 
			point2.x += m_fcenter[i][0] - m_forigincenter[i][0]; point2.y += m_fcenter[i][1] - m_forigincenter[i][1]; point2.z += m_fcenter[i][2] - m_forigincenter[i][2]; 
			point3.x += m_fcenter[i][0] - m_forigincenter[i][0]; point3.y += m_fcenter[i][1] - m_forigincenter[i][1]; point3.z += m_fcenter[i][2] - m_forigincenter[i][2]; 
			////////////// 
 
			CVector3 line1[2] = {{point1.x, point1.y, point1.z}, {point2.x, point2.y, point2.z}}; 
			CVector3 line2[2] = {{point2.x, point2.y, point2.z}, {point3.x, point3.y, point3.z}}; 
			CVector3 line3[2] = {{point3.x, point3.y, point3.z}, {point1.x, point1.y, point1.z}}; 
 
			//假设交点唯一 
			CVector3 fpoint1, fpoint2, fpoint3; 
			bool xiangjiao1 = IntersectedPlane_2(line1, m_xishu, m_fd); 
			if(xiangjiao1) 
				fpoint1 = IntersectionPoint(m_xishu, line1, m_fd); 
 
			bool xiangjiao2 = IntersectedPlane_2(line2, m_xishu, m_fd); 
			if(xiangjiao2) 
				fpoint2 = IntersectionPoint(m_xishu, line2, m_fd);	 
 
			bool xiangjiao3 = IntersectedPlane_2(line3, m_xishu, m_fd); 
			if(xiangjiao3) 
				fpoint3 = IntersectionPoint(m_xishu, line3, m_fd); 
			 
			//画三角形 
			if(xiangjiao1) 
			{ 
				if(xiangjiao2) 
				{ 
					if(xiangjiao3) 
					{ 
						glBegin(GL_LINE_LOOP);//三点都在面上 
							glVertex3f(point1.x, point1.y, point1.z); 
							glVertex3f(point2.x, point2.y, point2.z); 
							glVertex3f(point3.x, point3.y, point3.z); 
						glEnd(); 
					} 
					else//1和2在面上 
					{ 
						//记录到链表之中去 
						Link *node = new Link; 
						node->point1 = fpoint1; 
						node->point2 = fpoint2; 
						node->flag   = FALSE; 
						node->next   = head; 
						head = node; 
 
						if(m_bcut1) 
						{ 
							glBegin(GL_LINES); 
								glVertex3f(fpoint1.x, fpoint1.y, fpoint1.z); 
								glVertex3f(fpoint2.x, fpoint2.y, fpoint2.z); 
							glEnd(); 
						} 
					} 
				} 
				else 
				{ 
					if(xiangjiao3) 
					{ 
						//记录到链表之中去 
						Link *node = new Link; 
						node->point1 = fpoint1; 
						node->point2 = fpoint3; 
						node->flag   = FALSE; 
						node->next   = head; 
						head = node; 
 
						if(m_bcut1) 
						{ 
							glBegin(GL_LINES); 
								glVertex3f(fpoint1.x, fpoint1.y, fpoint1.z); 
								glVertex3f(fpoint3.x, fpoint3.y, fpoint3.z); 
							glEnd(); 
						} 
					} 
				} 
			} 
			else//1没有交点 
			{ 
				if(xiangjiao2) 
				{ 
					if(xiangjiao3) 
					{ 
						//记录到链表之中去 
						Link *node = new Link; 
						node->point1 = fpoint2; 
						node->point2 = fpoint3; 
						node->flag   = FALSE; 
						node->next   = head; 
						head = node; 
 
						if(m_bcut1) 
						{ 
							glBegin(GL_LINES); 
								glVertex3f(fpoint2.x, fpoint2.y, fpoint2.z); 
								glVertex3f(fpoint3.x, fpoint3.y, fpoint3.z); 
							glEnd();						 
						} 
					} 
				} 
			} 
			first = first->next; 
		} 
 
	while(head != NULL) 
	{ 
		Link *temp = head; 
		head = head->next; 
		delete temp; 
	} 
 
} 
 
 
Link * CMfcopenView::FindSketch(Link *dest, Link *back) 
{ 
	Link *temp = dest; 
 
	static int count = 0; 
	while(temp != NULL) 
	{ 
		BOOL point1  = fabs(temp->point1.x - back->point1.x) < 0.000001 && fabs(temp->point1.y - back->point1.y) < 0.000001 && fabs(temp->point1.z - back->point1.z) < 0.000001; 
		BOOL point2  = fabs(temp->point2.x - back->point2.x) < 0.000001 && fabs(temp->point2.y - back->point2.y) < 0.000001 && fabs(temp->point2.z - back->point2.z) < 0.000001; 
		BOOL point12 = fabs(temp->point1.x - back->point2.x) < 0.000001 && fabs(temp->point1.y - back->point2.y) < 0.000001 && fabs(temp->point1.z - back->point2.z) < 0.000001; 
		BOOL point21 = fabs(temp->point2.x - back->point1.x) < 0.000001 && fabs(temp->point2.y - back->point1.y) < 0.000001 && fabs(temp->point2.z - back->point1.z) < 0.000001; 
 
		if(!temp->flag && (point1 || point2 || point12 || point21)) 
		{ 
			Link *newnode = new Link; 
			newnode->point1 = temp->point1; 
			newnode->point2 = temp->point2; 
			newnode->flag   = TRUE;			 
			temp->flag      = TRUE;//表示他已经记录到了链表之中 
			newnode->next   = back; 
			back = newnode; 
 
			count++; 
			break; 
		} 
		temp = temp->next; 
	} 
	if(count > 0) 
	{ 
		//找到一个和第一个有相同顶点的线，继续找和这个有相同顶点的线 
		count = 0; 
		back = FindSketch(dest, back); 
	} 
	return back; 
} 
 
void CMfcopenView::DestroyTree(STLOctTree *root) 
{ 
	if(root != NULL) 
	{ 
		for(int vv=0; vv<8; vv++) 
			if(root->pchild[vv] != NULL) 
				DestroyTree(root->pchild[vv]); 
		delete root; 
	} 
} 
 
void CMfcopenView::DrawCubeWeb(STLOctTree *root) 
{ 
	if(root == NULL || root->IsHave == 0) 
		return; 
	int flag = 0; 
	for(int vvv=0; vvv<8; vvv++) 
	{ 
		if(root->pchild[vvv] != NULL) 
			DrawCubeWeb(root->pchild[vvv]); 
		flag++; 
	} 
	if(flag < 8) 
		return; 
 
	glColor3f(1.0f, 1.0f, 0); 
	glBegin(GL_QUADS); 
		//前 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
 
		//后 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
 
		//左 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
 
		//右 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
 
		//上 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y+root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
 
		//下 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x-root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z+root->m_Width/2.0f); 
		glVertex3f(root->m_vCenter.x+root->m_Width/2.0f, root->m_vCenter.y-root->m_Width/2.0f, root->m_vCenter.z-root->m_Width/2.0f); 
	glEnd(); 
	m_lgcubenumber++; 
} 
 
void CMfcopenView::OnViewMess()  
{ 
	// TODO: Add your command handler code here 
	m_bviewmess = !m_bviewmess; 
} 
 
void CMfcopenView::OnUpdateViewMess(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable((m_bfileopen || m_banimalfileopen) && root[0]); 
	pCmdUI->SetCheck(m_bviewmess == TRUE); 
} 
 
void CMfcopenView::CreateTree(STLArray *data, int i) 
{ 
	CMfcopenDoc* pDoc = GetDocument(); 
	 
	root[itree] = new STLOctTree;	 
	root[itree]->IsHave = 1; 
	root[itree]->m_vCenter.x = m_forigincenter[itree+1][0]; 
	root[itree]->m_vCenter.y = m_forigincenter[itree+1][1]; 
	root[itree]->m_vCenter.z = m_forigincenter[itree+1][2]; 
	 
	float maxbox = m_fboxsize[i][0] > m_fboxsize[i][1] ? m_fboxsize[i][0] : m_fboxsize[i][1]; 
	maxbox       = maxbox > m_fboxsize[i][2] ? maxbox : m_fboxsize[i][2]; 
	root[itree]->m_Width = maxbox; 
	for(int vv=0; vv<8; vv++) 
		root[itree]->pchild[vv] = NULL; 
 
	whichnode = 1;//重新下一颗数的计算进度 
	CreateNode(root[itree], data, m_fprecision, i);	 
	 
 	itree++; 
 
} 
 
static int g_precision = 0; 
 
void CMfcopenView::OnCreateTree()  
{ 
	// TODO: Add your command handler code here 
	CMfcopenDoc* pDoc = GetDocument(); 
	STLArray *data = pDoc->m_array->next; 
	if(g_precision <= 0) 
	{ 
		CPrecisionDlg predlg; 
		if(predlg.DoModal() == IDOK) 
		{ 
			m_fprecision = predlg.m_fprecision; 
			g_precision++; 
		} 
		else 
			return; 
	} 
	BeginWaitCursor(); 
	for(int vv=0; vv<10; vv++) 
	{ 
		if(root[vv] != NULL && data != NULL) 
		{ 
			data = data->next; 
			continue; 
		} 
		else 
		{ 
			if(data == NULL) 
			{ 
				::SendMessage(AfxGetApp()->GetMainWnd()->m_hWnd, WM_DISPPROG, 0, zongshu_d); 
				break; 
			} 
			else 
			{ 
				zongshu = 0; 
				zongshu_d = 0; 
				CreateTree(data, vv+1); 
				data = data->next; 
			} 
		} 
	} 
	EndWaitCursor(); 
} 
 
void CMfcopenView::OnUpdateCreateTree(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen || m_banimalfileopen); 
} 
 
 
 
void CMfcopenView::OnFileClear()  
{ 
	// TODO: Add your command handler code here 
	CMfcopenDoc* pDoc = GetDocument(); 
 
	pDoc->szFilename = ""; 
	for(int i=0; i<10; i++) 
	{ 
		DestroyTree(root[i]); 
	} 
 
	STLArray *tt; 
	while(pDoc->m_array != NULL) 
	{ 
		tt = pDoc->m_array; 
		pDoc->m_array = pDoc->m_array->next; 
		while(tt->stl != NULL) 
		{ 
			STLData *temp; 
			temp = tt->stl; 
			tt->stl = tt->stl->next; 
			delete temp; 
		} 
		delete tt; 
	} 
	ResetData();  
	//doc变量变化 
	pDoc->ResetData(); 
	// 
	CMainFrame* pFrame; 
	pFrame=(CMainFrame*)AfxGetApp()->m_pMainWnd; 
	pFrame->m_cTree.DeleteAllItems(); 
	pFrame->m_cTree.ResetData(); 
	pFrame->m_cTree.AddRoot(); 
	//静态变量归位 
	mm = gg = 0; 
	g_createtree = 0; 
	g_precision = 0; 
	// 
	::SetWindowText(pFrame->GetSafeHwnd(), "模具动态装配"); 
 
	Invalidate(TRUE); 
	CRect rc; 
	GetClientRect(&rc); 
	OnSize(SIZE_RESTORED, rc.Width(), rc.Height()); 
} 
 
 
void CMfcopenView::OnUpdateRectScale(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(m_bfileopen||m_banimalfileopen||m_bFakOpen); 
	pCmdUI->SetCheck(m_popmenu == INT_ZOOM_RECT);	 
} 
 
void CMfcopenView::ResetData() 
{ 
	g_bganshe = FALSE; 
	m_bviewganshe = FALSE; 
	ganshe_first  = NULL; 
	ganshe_second = NULL; 
	m_lgcubenumber = 0; 
	ganshe_writer = 0; 
	writer = 0; 
	itree = 0; 
	m_movecount = count = 0; 
	m_fpasstime = 0; 
	m_bIsPrint = false; 
	m_bcutplane = FALSE; 
	m_RectZoomOldpoint.x = m_RectZoomOldpoint.y = -100; 
	m_iObjectId = 0; 
	m_bviewmess = FALSE; 
	for(int vv=0; vv<10; vv++) 
	{ 
		root[vv] = NULL; 
	} 
	m_bcut2 = FALSE; 
	m_bcut1 = FALSE; 
	m_ortho_bias_x = m_ortho_bias_y = 0; 
	m_brefresh = FALSE; 
	m_bfindline = INT_LAST; 
	m_umodelview = GL_FILL; 
	m_view = INT_FRONT; 
	m_zoomcenter.x = m_zoomcenter.y = 0; 
	m_fleft = m_fright = m_fbottom = m_ftop = 0; 
	m_brepeat = FALSE; 
	m_btempstop = FALSE; 
	m_banimalfileopen = FALSE; 
	m_ballhide = FALSE; 
	m_fglobaltime = 0; 
	m_bplay = FALSE; 
	m_fBoxMax = 0; 
	m_itreeflag = 0; 
	for(int q=0; q<100; q++) 
	{ 
		m_itrannumber[q] =0; 
		m_ilflag[q] = 0; 
		m_btypehide[q] = FALSE; 
		m_istlmove[q] = 0; 
	} 
	for(q=0; q<100; q++) 
		for(int d=0; d<4; d++) 
			for(int t=0; t<3; t++) 
			{ 
				m_fsteptranslate[q][d][t] = 0; 
				m_fInformation[q][d][t] = 0; 
			} 
 
	for(q=0; q<100; q++) 
		for(int d=0; d<4; d++) 
		{ 
			m_fmove[q][d][0] = 0; 
			m_fmove[q][d][1] = 0; 
			m_fmove[q][d][2] = 0; 
			m_fmove[q][d][3] = 0; 
		} 
 
	for(q=0; q<2; q++) 
		for(int d=0; d<3; d++) 
			m_fganshemove[q][d] = 0; 
 
	//程序认定时间是0秒开始的 
	for(q=0; q<100; q++) 
		for(int i=0; i<4; i++) 
			for(int kk=0; kk<2; kk++) 
			{ 
				m_ftimemove[q][i][kk] = 0; 
			} 
 
	for(q=0; q<100; q++) 
		for(int i=0; i<3; i++) 
			m_fcenter[q][i] = m_forigincenter[q][i] = m_fsectcenter[q][i] = 0; 
	 
	for(q=0; q<2; q++) 
		for(int i=0; i<3; i++) 
			m_lineganshe[q][i] = 0; 
 
	for(q=0; q<3; q++) 
		for(int i=0; i<3; i++) 
			m_triangleganshe[q][i] = 0; 
 
	m_ftimes = 1.0f; 
	m_fstepx = m_fstepy = 0.04f; 
	m_fanglex = m_fangley = m_fanglez = 0; 
	m_popmenu = INT_END; 
	m_hcursor = AfxGetApp()->LoadCursor(IDC_POINTER); 
	m_current.x = m_current.y = 200; 
	m_oldpt.x = m_oldpt.y = 200; 
	m_fxtra = m_fytra = 0; 
	m_scale = 0.5f; 
	m_fxrot = m_fyrot = m_fzrot = 0; 
	m_blmousedown = false; 
	m_bfileopen = false; 
	m_bFakOpen = false; 
	LightAmbient[0]= 0.0f; 
	LightAmbient[1]= 0.0f; 
	LightAmbient[2]= 0.0f; 
	LightAmbient[3]= 1.0f; 
 
	LightSpecular[0]= 1.0f; 
	LightSpecular[1]= 1.0f; 
	LightSpecular[2]= 1.0f;  
	LightSpecular[3]= 1.0f; 	 
 
	LightDiffuse[0]= 1.0f; 
	LightDiffuse[1]= 1.0f; 
	LightDiffuse[2]= 1.0f;  
	LightDiffuse[3]= 1.0f;  
	 
	LightPosition[0]= 0.0f; 
	LightPosition[1]= 1.0f; 
	LightPosition[2]= 80.0f;  
	LightPosition[3]= 1.0f; 
 
	for(q=0; q<100; q++) 
	{ 
		mat_amb_diff[q][0] = 1.0f; 
		mat_amb_diff[q][1] = 0.2F; 
		mat_amb_diff[q][2] = 0.2f; 
		mat_amb_diff[q][3] = 0.5f; 
	} 
 
	mat_amb_diff_org[0] = 0.8f; 
	mat_amb_diff_org[1] = 0.8f; 
	mat_amb_diff_org[2] = 0.8f; 
	mat_amb_diff_org[3] = 0.5f; 
 
	mat_amb_diff_ganshe[0] = 1.0f; 
	mat_amb_diff_ganshe[1] = 1.0f; 
	mat_amb_diff_ganshe[2] = 1.0f; 
	mat_amb_diff_ganshe[3] = 0.5f; 
 
	shininess = 100.0f; 
} 
 
void CMfcopenView::OnViewGanshe()  
{ 
	// TODO: Add your command handler code here 
	m_bviewganshe = !m_bviewganshe; 
} 
 
void CMfcopenView::OnUpdateViewGanshe(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable(g_bganshe); 
	pCmdUI->SetCheck(m_bviewganshe); 
} 
 
void CMfcopenView::ViewGanshe() 
{ 
	glColor3f(1.0f, 1.0f, 1.0f); 
	STLOctTree *ganshe_node[2]; 
	ganshe_node[0] = ganshe_first; 
	ganshe_node[1] = ganshe_second; 
 
	glBegin(GL_QUADS); 
	for(int i=0; i<2; i++) 
	{ 
		//前 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
 
		//后 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
 
		//左 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
 
		//右 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
 
		//上 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
 
		//下 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z+ganshe_node[i]->m_Width/2.0f); 
		glVertex3f(ganshe_node[i]->m_vCenter.x+ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.y-ganshe_node[i]->m_Width/2.0f, ganshe_node[i]->m_vCenter.z-ganshe_node[i]->m_Width/2.0f); 
	} 
	glEnd(); 
 
} 
 
void CMfcopenView::OnFit()  
{ 
	// TODO: Add your command handler code here 
	if(m_popmenu == INT_FIT) 
	{ 
		m_popmenu = INT_END; 
		m_hcursor = AfxGetApp()->LoadCursor(IDC_POINTER); 
		SetCursor(m_hcursor); 
		ShowCursor(true); 
		return; 
	} 
	m_popmenu = INT_FIT; 
	m_fxtra = m_fytra = 0; 
	m_fstepx = m_fstepy = 0.04f; 
	m_scale = 0.5f; 
	CRect rc; 
	GetClientRect(&rc); 
	OnSize(SIZE_RESTORED, rc.Width(), rc.Height());	 
	Invalidate(FALSE); 
	UpdateWindow(); 
} 
 
void CMfcopenView::OnUpdateFit(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->SetCheck(m_popmenu == INT_FIT); 
} 
 
void CMfcopenView::BuildFakList(int num) 
{ 
	CMfcopenDoc* pDoc = GetDocument();	 
	glNewList( num, GL_COMPILE ); 
	 
	for(int i=0; im_Trinumber; i++) 
	{ 
		glNormal3fv(pDoc->webtri[i].nor1);	 
		glVertex3fv(pDoc->webtri[i].point1);                   
		glNormal3fv(pDoc->webtri[i].nor2);	 
		glVertex3fv(pDoc->webtri[i].point2);                  
		glNormal3fv(pDoc->webtri[i].nor3);	 
		glVertex3fv(pDoc->webtri[i].point3); 		 
	} 
	glEndList(); 
} 
 
void CMfcopenView::OnDestroy()  
{ 
	CView::OnDestroy(); 
	 
	// TODO: Add your message handler code here 
	wglDeleteContext(m_hRC); 
} 
 
void CMfcopenView::OnViewAllPara()  
{ 
	// TODO: Add your command handler code here 
	if(para->GetSafeHwnd() == NULL) 
		para->Create(); 
	para->ShowWindow(TRUE); 
	para->SetActiveWindow(); 
} 
 
void CMfcopenView::OnUpdateViewAllPara(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->Enable((m_bfileopen || m_banimalfileopen) && !m_bplay && !m_brepeat); 
} 
 
void CMfcopenView::OnViewBack()  
{ 
	// TODO: Add your command handler code here 
	m_view = INT_BACK; 
	m_fxrot = 0; 
	m_fyrot = 0; 
	m_fxtra = 0; 
	m_fytra = 0; 
	Invalidate(FALSE); 
	UpdateWindow();	 
} 
 
void CMfcopenView::OnUpdateViewBack(CCmdUI* pCmdUI)  
{ 
	// TODO: Add your command update UI handler code here 
	pCmdUI->SetRadio(m_view == INT_BACK); 
}