bezierview.cpp

C:Documents and SettingsAdministrator桌面VC++多媒体特效制作百例CHAR17Bezier

// BezierView.cpp : implementation of the CBezierView class
//

#include "stdafx.h"
#include "Bezier.h"

#include "BezierDoc.h"
#include "BezierView.h"

#include <math.h> 


#define WIDTH	600
#define HEIGHT	600

#define MMOUSE_ENABLED 1

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

/////////////////////////////////////////////////////////////////////////////
// CBezierView

IMPLEMENT_DYNCREATE(CBezierView, CView)

BEGIN_MESSAGE_MAP(CBezierView, CView)
	//{{AFX_MSG_MAP(CBezierView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_ERASEBKGND()
	ON_WM_SIZE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_KEYDOWN()
	//}}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()

/////////////////////////////////////////////////////////////////////////////
// CBezierView construction/destruction

CBezierView::CBezierView()
{
	m_pDC = NULL;

	fPick=FALSE;

}

CBezierView::~CBezierView()
{
}

BOOL CBezierView::PreCreateWindow(CREATESTRUCT& cs)
{
	//add down
	cs.style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
	//add up

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CBezierView drawing

void CBezierView::OnDraw(CDC* pDC)
{
	CBezierDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	//add down
	DrawScene(GL_RENDER);
	//add up
}

/////////////////////////////////////////////////////////////////////////////
// CBezierView printing

BOOL CBezierView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CBezierView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CBezierView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CBezierView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CBezierView message handlers

int CBezierView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	//add down
	Init(); //初始化OpenGL
	//add up
	
	return 0;
}

void CBezierView::OnDestroy() 
{
	//add down
	HGLRC   hrc;

	hrc = ::wglGetCurrentContext();

	::wglMakeCurrent(NULL,  NULL);

	if (hrc)
		::wglDeleteContext(hrc);

	if (m_pDC)
		delete m_pDC;
	//add up

	CView::OnDestroy();
}

BOOL CBezierView::OnEraseBkgnd(CDC* pDC) 
{
	return TRUE;
}

void CBezierView::OnSize(UINT nType, int cx, int cy) 
{
	CView::OnSize(nType, cx, cy);
	
    glViewport( 0, 0, cx, cy ); 

	setTransform();
    DrawScene(GL_RENDER);
	
}

//add down
void CBezierView::Init()
{
	PIXELFORMATDESCRIPTOR pfd;
	int         n;
	HGLRC       hrc;

	m_pDC = new CClientDC(this);

	ASSERT(m_pDC != NULL);

	if (!bSetupPixelFormat())
		return;

	n = ::GetPixelFormat(m_pDC->GetSafeHdc());
	::DescribePixelFormat(m_pDC->GetSafeHdc(), n, sizeof(pfd), &pfd);

	hrc = wglCreateContext(m_pDC->GetSafeHdc());
	wglMakeCurrent(m_pDC->GetSafeHdc(), hrc);

	int i,j,k;

	theta = 0.0;
	beta = 0.0;
	dist = 0.0;

    glClearColor(0.0, 0.0, 0.0, 0.0);
	glPointSize(10.0);

	MakeAxes();
	bezInit();

}

BOOL CBezierView::bSetupPixelFormat()
{
	static PIXELFORMATDESCRIPTOR pfd =
	{
		sizeof(PIXELFORMATDESCRIPTOR),  // size of this pfd
		1,                              // version number
		PFD_DRAW_TO_WINDOW |            // support window
		  PFD_SUPPORT_OPENGL |          // support OpenGL
		  PFD_DOUBLEBUFFER,             // double buffered
		PFD_TYPE_RGBA,                  // RGBA type
		24,                             // 24-bit color depth
		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
		32,                             // 32-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 pixelformat;

	if ( (pixelformat = ChoosePixelFormat(m_pDC->GetSafeHdc(), &pfd)) == 0 )
	{
		MessageBox("ChoosePixelFormat failed");
		return FALSE;
	}

	if (SetPixelFormat(m_pDC->GetSafeHdc(), pixelformat, &pfd) == FALSE)
	{
		MessageBox("SetPixelFormat failed");
		return FALSE;
	}

	return TRUE;
}

void CBezierView::DrawScene(GLenum mode)
{
	int i,j,k;
	

	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	glMap2f(GL_MAP2_VERTEX_3,0.0,1.0,3,4,0,1,12,4,&vertices[0].v[0]);

	glLoadIdentity();
	glTranslatef(0.0,0.0,dist);
	glRotatef((GLfloat)theta,0.0,1.0,0.0);
	glRotatef((GLfloat)beta,1.0,0.0,0.0);

	gluLookAt(150.0,150.0,100.0,0.0,0.0,0.0,0.0,0.0,1.0);

	glPushMatrix();

		if(mode == GL_SELECT)
			glLoadName(AXES);

		glTranslatef(0.0,0.0,0.0);
		glCallList(axes);
	
		glColor3f(1.0,0.8,0.8);
		glEvalMesh2(GL_LINE,0,20,0,20);

		glPushMatrix();

		for(i=0;i<N;i++)
		{
			if(mode == GL_SELECT)	
				glLoadName(i);
			glBegin(GL_POINTS);
				if(i == selected)
					glColor3f(1.0,1.0,1.0);
				else
					glColor3f(1.0,0.0,0.0);
				glVertex3fv(vertices[i].v);
			glEnd();
			
			
		}
		glPopMatrix();

	glPopMatrix();

 
	glFinish();
	SwapBuffers(wglGetCurrentDC());
}

void  CBezierView::setTransform( void )
{             
    GLdouble fovy = 50.0;
    GLdouble aspect = 1.0;
    GLdouble znear = 10.0, zfar=500.0;
 

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    gluPerspective(fovy, aspect, znear, zfar);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();  

   
}

void CBezierView::MakeAxes(void)
{
	int i;
	
	axes = glGenLists(1);
	glNewList(axes,GL_COMPILE);
 	
	glBegin(GL_LINES);
		glColor3f(1.0,0.0,0.0);
		glVertex3f(0.0,0.0,0.0);
		glVertex3f(100.0,0.0,0.0);

		glColor3f(0.0,1.0,0.0);
		glVertex3f(0.0,0.0,0.0);
		glVertex3f(0.0,100.0,0.0);

		glColor3f(0.0,0.0,1.0);
		glVertex3f(0.0,0.0,0.0);
		glVertex3f(0.0,0.0,100.0);
	glEnd();

	glColor3f(0.5,0.5,0.5);
	for(i=1;i<=10;i++)
	{
		glBegin(GL_LINES);
			glVertex3f(i*10.0,0.0,0.0);
			glVertex3f(i*10.0,100.0,0.0);
		glEnd();
	}

	glColor3f(0.5,0.5,0.5);
	for(i=1;i<=10;i++)
	{
		glBegin(GL_LINES);
			glVertex3f(0.0,i*10.0,0.0);
			glVertex3f(100.0,i*10.0,0.0);
		glEnd();
	}
	
	glEndList();
}

BOOL  CBezierView::hitTest(int x, int y)
{
	GLuint selBuf[512];
	GLint hits;
	GLint viewport[4];
	GLdouble fovy = 50.0;
    GLdouble aspect = 1.0;
    GLdouble znear = 10.0, zfar=500.0;
	int i;

	glGetIntegerv(GL_VIEWPORT,viewport);
	glSelectBuffer(512,selBuf);
	(void)glRenderMode(GL_SELECT);

	glInitNames();
	glPushName(0);

	glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
	gluPickMatrix((GLdouble)x,(GLdouble)(viewport[3]-y),5.0,5.0,viewport);

	gluPerspective(fovy, aspect, znear, zfar);

    glMatrixMode(GL_MODELVIEW);
    
	DrawScene(GL_SELECT);

	hits = glRenderMode(GL_RENDER);

	// process hits
	if(hits > 0)
	{
		// for each hit, first element in selBuf is 1, 
		// since the hit objects are not hierarchial (they are POINTS)
		// 
		for(i=0;i<hits;i++)
		{
			if(selBuf[4*i+3] != AXES)
			{
				selected = selBuf[4*i+3];
			}
			else
				selected = -1;
		}
	}

	setTransform();

	return hits > 0 ? TRUE : FALSE;
}

void CBezierView::bezInit(void)
{

	int i,j;

	for(i=0;i<4;i++)
		for(j=0;j<4;j++)
		{
			vertices[4*i+j].v[0] = 30.0*(GLfloat)(i);  
			vertices[4*i+j].v[1] = 30.0*(GLfloat)(j);  
			vertices[4*i+j].v[2] = 5.0;  
		}
	glEnable(GL_MAP2_VERTEX_3);
	glMapGrid2f(20,0.0,1.0,20,0.0,1.0);

}

void CBezierView::OnLButtonDown(UINT nFlags, CPoint point) 
{
		ptOld.x = point.x;
		ptOld.y = point.y;
		fPick = hitTest(ptOld.x,ptOld.y);

		InvalidateRect(FALSE);
	
	CView::OnLButtonDown(nFlags, point);
}

void CBezierView::OnLButtonUp(UINT nFlags, CPoint point) 
{
		if(fPick)
			fPick = FALSE;

		InvalidateRect(FALSE);
	
	CView::OnLButtonUp(nFlags, point);
}

void CBezierView::OnMouseMove(UINT nFlags, CPoint point) 
{
		ptNew.x = point.x;
		ptNew.y = point.y;

		if(fPick && selected >= 0)
		{
			if(ptNew.x > ptOld.x)
			  vertices[selected].v[0] += 1.0;
			else
			  vertices[selected].v[0] -= 1.0;
			if(ptNew.y > ptOld.y)
			  vertices[selected].v[1] += 1.0;
			else
			  vertices[selected].v[1] -= 1.0;
		}

		ptOld.x = ptNew.x;
		ptOld.y = ptNew.y;

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

void CBezierView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
		switch (nChar) { 
        
		case VK_LEFT: 
            
			theta = (theta + 1)%360;
			InvalidateRect(FALSE);
            break; 
			
		case VK_RIGHT: 
		
			theta = (theta - 1)%360;
			InvalidateRect(FALSE);
           break;

       	case VK_UP: 
          
			beta = (beta + 1)%360;
			InvalidateRect(FALSE);
           break; 
			
		case VK_DOWN: 
		   beta = (beta - 1)%360;
			InvalidateRect(FALSE);
		   break;

		case VK_INSERT: 
		   
			dist += 1.0;
			InvalidateRect(FALSE);
		   break;

		case VK_DELETE: 

		   dist -= 1.0;
			InvalidateRect(FALSE);
		   break;

		default:
			break;
		}
	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}