毕业设计view.cpp

毕业设计作品

// 毕业设计View.cpp : implementation of the CMyView class
//

#include "stdafx.h"
#include "毕业设计.h"

#include "毕业设计Doc.h"
#include "毕业设计View.h"
#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define BUFSIZE 512

/////////////////////////////////////////////////////////////////////////////
// CMyView

IMPLEMENT_DYNCREATE(CMyView, CView)

BEGIN_MESSAGE_MAP(CMyView, CView)
	//{{AFX_MSG_MAP(CMyView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_ERASEBKGND()
	ON_WM_SIZE()
	ON_COMMAND(ID_HELP_OPERATION, OnHelpOperation)
	ON_WM_CONTEXTMENU()
	ON_COMMAND(ID_CONTROL_LROTATE, OnControlLrotate)
	ON_COMMAND(ID_CONTROL_DROTATE, OnControlDrotate)
	ON_COMMAND(ID_CONTROL_RROTATE, OnControlRrotate)
	ON_COMMAND(ID_CONTROL_UROTATE, OnControlUrotate)
	ON_COMMAND(ID_CONTROL_TLS, OnControlTls)
	ON_COMMAND(ID_CONTROL_TRS, OnControlTrs)
	ON_COMMAND(ID_WINDOW_OPEN, OnWindowOpen)
	ON_UPDATE_COMMAND_UI(ID_WINDOW_OPEN, OnUpdateWindowOpen)
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(ID_CONTROL_NOD, OnControlNod)
	ON_COMMAND(ID_CONTROL_YT, OnControlYt)
	ON_COMMAND(ID_CONTROL_CLOSETB, OnControlClosetb)
	ON_COMMAND(ID_CONTROL_OPENTB, OnControlOpentb)
	ON_COMMAND(ID_CONTROL_RECOVER, OnControlRecover)
	ON_COMMAND(ID_CONTROL_TLT, OnControlTlt)
	ON_COMMAND(ID_CONTROL_TRT, OnControlTrt)
	ON_COMMAND(ID_CONTROL_PLAY, OnControlPlay)
	ON_WM_TIMER()
	ON_UPDATE_COMMAND_UI(ID_CONTROL_PLAY, OnUpdateControlPlay)
	ON_WM_CHAR()
	ON_COMMAND(ID_CONTROL_MOVE_UP, OnControlMoveUp)
	ON_COMMAND(ID_CONTROL_MOVE_RIGHT, OnControlMoveRight)
	ON_COMMAND(ID_CONTROL_MOVE_LEFT, OnControlMoveLeft)
	ON_COMMAND(ID_CONTROL_MOVE_DOWN, OnControlMoveDown)
	ON_COMMAND(ID_HELP_NUMBER, OnHelpNumber)
	ON_COMMAND(ID_CONTROL_SCALE, OnControlScale)
	ON_UPDATE_COMMAND_UI(ID_CONTROL_SCALE, OnUpdateControlScale)
	ON_COMMAND(ID_CONTROL_WALK, OnControlWalk)
	ON_UPDATE_COMMAND_UI(ID_CONTROL_WALK, OnUpdateControlWalk)
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMyView construction/destruction

/*一些参数初始化*/
CMyView::CMyView()
{
	throwHead=0;
	nod=0;
	leftFoot=0;
	rightFoot=0;
	leftHand=0;
	rightHand=0;
	rotate_up_down = 0;
	rotate_left_right = 0;
	leftHand_x = 1;
	rightHand_x = 1;
	ok = false;
	hits = 0;
	nod_x = 1;
	throwHead_x = 1;
	nod_true = true;
	render_select = false;
	leftDatui=0;
	leftDatui_x=1;
	rightDatui=0;
	rightDatui_x=1;
	m_play = false;
	scaleMol=1;
    left_right=0;
    up_down=0;
	scaleMolNow=2.0;
	scaleMode = false;
	bWalk = true;
	distance = 0;
	spin = 0;
	k = 1;
	m_xRotation = 0.0;
	m_yRotation = 0.0;
	m_leftButtonDown = false;
}

CMyView::~CMyView()
{
}

BOOL CMyView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMyView drawing

void CMyView::OnDraw(CDC* pDC)
{
	CMyDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
	if( bWalk )/*是否是走步模式*/
	{
		displayBoneWalk();/*走步显示函数*/
	}
	else
	{
		display();/*显示全景视图函数*/
	}
	

}

/////////////////////////////////////////////////////////////////////////////
// CMyView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CMyView message handlers

int CMyView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	// TODO: Add your specialized creation code here
	if( SetupPixelFormat() == false )/*设置像素格式*/
	{
		return 0;
	}
//	AfxMessageBox( "Test" );
	if( CreateOpenGLContext() == false )/*创建绘图描述表*/
	{
		return 0;
	}

	myinit();/*初始化*/
	

	return 0;
}

/*销毁函数*/
void CMyView::OnDestroy() 
{
	CView::OnDestroy();
	
	// TODO: Add your message handler code here
	if( wglGetCurrentContext() != NULL )/*当前描述表是否与设备描述关联*/
	{
		wglMakeCurrent( NULL, NULL );/*如果关联，则取消其关联*/
	}

	if( m_hRC )/*绘图描述表是否为空*/
	{
		wglDeleteContext( m_hRC );/*如果不为空，则将其置空*/
		m_hRC = NULL;
	}	
}

BOOL CMyView::OnEraseBkgnd(CDC* pDC) 
{
	// TODO: Add your message handler code here and/or call default
	
	return true;/*改为手动刷新屏幕*/
}

/*窗口大小改变*/
void CMyView::OnSize(UINT nType, int cx, int cy) 
{
	CView::OnSize(nType, cx, cy);
	
	// TODO: Add your message handler code here
	w=cx;
	h=cy;
//	AfxMessageBox( "Test" );
/*	glViewport( 0, 0, cx, cy );
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
//	glFrustum( -1.0, 1.0, -1.0, 1.0, 1.5, 20.0 );
	gluPerspective( 60.0, (GLfloat)w/(GLfloat)h, 1.0, 500.0 );
	if( w <= h )
	{
		glOrtho( -1.5, 1.5, -1.5*(GLdouble)h/(GLdouble)w, 1.5*(GLdouble)h/(GLdouble)w, -10.0, 10.0 );
	}
	else
	{
		glOrtho( -1.5*(GLdouble)w/(GLdouble)h, 1.5*(GLdouble)w/(GLdouble)h, -1.5, 1.5, -10.0, 10.0 );
	}
	
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
	glTranslatef( 0.0, 0.0, -5.5 );
	Invalidate();*/	
}

bool CMyView::SetupPixelFormat()
{
	HWND hWnd = GetSafeHwnd();
	m_hDC = ::GetDC( hWnd );/*创建设备描述表*/


	static PIXELFORMATDESCRIPTOR pfd =/*像素格式结构初始化*/
	{
		sizeof( PIXELFORMATDESCRIPTOR ),
		1,
		PFD_DRAW_TO_WINDOW |
		PFD_SUPPORT_OPENGL |
		PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,
		24,
		 0, 0, 0, 0, 0, 0,               // color bits ignored
        0,                              // no alpha buffer
        0,                              // shift bit ignored
        0,                              // no accumulation buffer
        0, 0, 0, 0,                     // accum bits ignored
        16,                             // 16-bit z-buffer
        0,                              // no stencil buffer
        0,                              // no auxiliary buffer
        PFD_MAIN_PLANE,                 // main layer
        0,                              // reserved
        0, 0, 0                         // layer masks ignored
    };

	int m_PixelFormat;
	m_PixelFormat = ::ChoosePixelFormat( m_hDC, &pfd );/*选择与设备描述表相关的像素格式索引*/
   
    SetPixelFormat(m_hDC, m_PixelFormat, &pfd );/*设置像素格式*/

	return true;
}

bool CMyView::CreateOpenGLContext()
{
	m_hRC = ::wglCreateContext( m_hDC );/*创建绘图描述表*/
//	AfxMessageBox( "Test" );
	if( m_hRC == NULL )
	{
		return false;
	}
 //   AfxMessageBox( "Test" );
	if( wglMakeCurrent( m_hDC, m_hRC )==false)/*设备描述表与绘图描述表是否关联成功*/
	{
		return false;
	}
//	AfxMessageBox( "Test" );

	return true;
}

void CMyView::myinit()
{
	glClearColor( 0.0, 0.0, 0.0, 1.0 );/*设置清屏颜色*/
	glClearDepth( 1.0 );/*设置深度缓存*/
	glShadeModel( GL_SMOOTH );/*平滑着色*/

	head = glmReadOBJ("头.obj");/*初始头模型指针*/
	body = glmReadOBJ("身体.obj");/*初始身体模型指针*/
    leftdatui= glmReadOBJ("左大腿.obj");/*初始左大腿模型指针*/
    rightdatui=glmReadOBJ("右大腿.obj");/*初始右大腿模型指针*/
    rightxiaotui=glmReadOBJ("右小腿.obj");/*初始左小腿模型指针*/
    leftxiaotui=glmReadOBJ("左小腿.obj");/*初始右小腿模型指针*/
    leftfoot=glmReadOBJ("左脚.obj");/*初始左脚模型指针*/
    rightfoot=glmReadOBJ("右脚.obj");/*初始右脚模型指针*/
	leftbi=glmReadOBJ("左臂.obj");/*初始左臂模型指针*/
	rightbi=glmReadOBJ("右臂.obj");/*初始右臂模型指针*/
	leftzhou=glmReadOBJ("左肘.obj");/*初始左肘模型指针*/
	rightzhou=glmReadOBJ("右肘.obj");/*初始右肘模型指针*/
    lefthand=glmReadOBJ("左手.obj");/*初始左手模型指针*/
    righthand=glmReadOBJ("右手.obj");/*初始右手模型指针*/

	/*将模型放大四倍*/
	glmScale(head,4.0f);
	glmScale(body,4.0f);
	glmScale(leftdatui,4.0f);
	glmScale( rightdatui,4.0f );
	glmScale( leftxiaotui,4.0f );
	glmScale(  rightxiaotui,4.0f );
	glmScale( leftfoot,4.0f );
	glmScale( rightfoot,4.0f );
	glmScale(leftbi,4.0f );
	glmScale( rightbi,4.0f );
	glmScale( leftzhou,4.0f );
	glmScale( rightzhou,4.0f );
    glmScale( lefthand,4.0f );
	glmScale( righthand,4.0f );

	GLfloat light_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
	glLightfv( GL_LIGHT0, GL_SPECULAR, light_ambient );/*设置环境光颜色*/
	glEnable( GL_LIGHTING );/*启动光照*/
	glEnable( GL_LIGHT0 );/*启动光源0*/
	glEnable( GL_DEPTH_TEST );/*启动深度测试*/
	glEnable( GL_LESS );
}

/*显示函数*/
void CMyView::display()
{
//	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
	if( ok )/*侧顶视图*/
    {
		glEnable( GL_SCISSOR_TEST );/*启动剪裁测试*/
		glScissor( 0, 0, w/2, h );/*第一个显示区域大小为整个客户区的左半*/
		glClearColor( 0.0, 0.0, 0.0, 1.0 );/*设置第一个客户区的清屏颜色*/
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );/*清除颜色缓存和深度缓存*/
		glDisable( GL_SCISSOR_TEST );/*关闭剪裁测试*/
		glViewport( 0, 0, w/2, h );/*设置视口*/
		glMatrixMode( GL_PROJECTION );//进入投影模式
		glLoadIdentity();/*清空当前矩阵*/
		if( (w/2) <= h )/*设置投影方式*/
		{
			glOrtho( -1.5, 1.5, -1.5*(GLdouble)h/(GLdouble)(w/2), 1.5*(GLdouble)h/(GLdouble)(w/2), -10.0, 10.0 );
		}
		else
		{
			glOrtho( -1.5*(GLdouble)(w/2)/(GLdouble)h, 1.5*(GLdouble)(w/2)/(GLdouble)h, -1.5, 1.5, -10.0, 10.0 );
		}
		glMatrixMode( GL_MODELVIEW );/*退出投影模式，进入视图模式*/
		glLoadIdentity();
		displayFront( GL_RENDER );

		glEnable( GL_SCISSOR_TEST );/*启动剪裁测试*/
		glScissor( w/2, 0, w/2, h/2 );/*第二个区域的大小为右半部分的上半部分*/
		glClearColor( 0.2f, 0.2f, 0.2f, 1.0f );
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
		glDisable( GL_SCISSOR_TEST );
		glViewport( w/2, 0, w/2, h/2);
		glMatrixMode( GL_PROJECTION );//进入投影模式
		glLoadIdentity();/*清空当前矩阵*/
		if( (w) <= h )/*设置投影方式*/
		{
			glOrtho( -1.5, 1.5, -1.5*(GLdouble)h/(GLdouble)(w), 1.5*(GLdouble)h/(GLdouble)(w), -10.0, 10.0 );
		}
		else
		{
			glOrtho( -1.5*(GLdouble)(w)/(GLdouble)h, 1.5*(GLdouble)(w)/(GLdouble)h, -1.5, 1.5, -10.0, 10.0 );
		}
		glMatrixMode( GL_MODELVIEW );/*退出投影模式，进入视图模式*/
		glLoadIdentity();
	    displayTop(GL_RENDER);

		glEnable( GL_SCISSOR_TEST );
		glScissor( w/2, h/2, w/2, h/2 );/*第三个客户区的右半部分的下半部分*/
		glClearColor( 0.25, 0.25, 0.25, 1.0 );
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
		glDisable( GL_SCISSOR_TEST );
		glViewport(  w/2, h/2, w/2, h/2);
		glMatrixMode( GL_PROJECTION );//进入投影模式
		glLoadIdentity();/*清空当前矩阵*/
		if( (w) <= h )/*设置投影方式*/
		{
			glOrtho( -1.5, 1.5, -1.5*(GLdouble)h/(GLdouble)(w), 1.5*(GLdouble)h/(GLdouble)(w), -10.0, 10.0 );
		}
		else
		{
			glOrtho( -1.5*(GLdouble)(w)/(GLdouble)h, 1.5*(GLdouble)(w)/(GLdouble)h, -1.5, 1.5, -10.0, 10.0 );
		}
		glMatrixMode( GL_MODELVIEW );/*退出投影模式，进入视图模式*/
		glLoadIdentity();
		displayBeside(GL_RENDER);

	}
	else/*全景视图下*/
	{
		glClearColor( 0.0, 0.0, 0.0, 0.0 );
		glClearDepth( 1.0 );
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

		glMatrixMode( GL_PROJECTION );//进入投影模式
		glLoadIdentity();
		if( (w) <= h )
		{
			glOrtho( -1.5, 1.5, -1.5*(GLdouble)h/(GLdouble)(w), 1.5*(GLdouble)h/(GLdouble)(w), -10.0, 10.0 );
		}
		else
		{
			glOrtho( -1.5*(GLdouble)(w)/(GLdouble)h, 1.5*(GLdouble)(w)/(GLdouble)h, -1.5, 1.5, -10.0, 10.0 );
		}
//		glFrustum( -1.0, 1.0, -1.0, 1.0, 1.5, 20.0 );
		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity();
		glViewport( 0, 0, w, h );
	/////////////////////////////////////////////////////////////
		displayFront(GL_RENDER);
	}
 
	//////////////////////////////////////////////////////////////////
	glFlush();/*强制显示模型*/
	SwapBuffers( m_hDC );/*交换前后缓存*/

}

GLfloat CMyView::glmMax(GLfloat a, GLfloat b) 
{
	if (b > a)
	{
		return b;
	}
	
	return a;
}

GLfloat CMyView::glmAbs(GLfloat f)
{
	if (f < 0)
	{
		return -f;
	}
	
	return f;
}

GLfloat CMyView::glmDot(GLfloat* u, GLfloat* v)
{
	assert(u); assert(v);

	return u[0]*v[0] + u[1]*v[1] + u[2]*v[2];
}

GLvoid CMyView::glmCross(GLfloat* u, GLfloat* v, GLfloat* n)
{
	assert(u); assert(v); assert(n);
	n[0] = u[1]*v[2] - u[2]*v[1];
	n[1] = u[2]*v[0] - u[0]*v[2];
	n[2] = u[0]*v[1] - u[1]*v[0];
}

GLvoid CMyView::glmNormalize(GLfloat* v)
{
	GLfloat l;
	assert(v);
	l = (GLfloat)sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
	v[0] /= l;
	v[1] /= l;
	v[2] /= l;
}

GLboolean CMyView::glmEqual(GLfloat* u, GLfloat* v, GLfloat epsilon)
{
	if (glmAbs(u[0] - v[0]) < epsilon &&
		glmAbs(u[1] - v[1]) < epsilon &&
		glmAbs(u[2] - v[2]) < epsilon) 
	{
		return GL_TRUE;
	}
	
	return GL_FALSE;
}

GLfloat* CMyView::glmWeldVectors(GLfloat* vectors, GLuint* numvectors, GLfloat epsilon)
{
	GLfloat* copies;
	GLuint   copied;
	GLuint   i, j;

	copies = (GLfloat*)malloc(sizeof(GLfloat) * 3 * (*numvectors + 1));
	memcpy(copies, vectors, (sizeof(GLfloat) * 3 * (*numvectors + 1)));
	
	copied = 1;
	for (i = 1; i <= *numvectors; i++)
	{
		for (j = 1; j <= copied; j++)
		{
			if (glmEqual(&vectors[3 * i], &copies[3 * j], epsilon))
			{
				goto duplicate;
			}
		}