blobview.cpp

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

// BlobView.cpp : implementation of the CBlobView class
//

#include "stdafx.h"
#include "Blob.h"

#include "BlobDoc.h"
#include "BlobView.h"

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

// wb add down
#define WIDTH	600
#define HEIGHT	600
//wb add up

/////////////////////////////////////////////////////////////////////////////
// CBlobView

IMPLEMENT_DYNCREATE(CBlobView, CView)

BEGIN_MESSAGE_MAP(CBlobView, CView)
	//{{AFX_MSG_MAP(CBlobView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_ERASEBKGND()
	ON_WM_SIZE()
	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()

/////////////////////////////////////////////////////////////////////////////
// CBlobView construction/destruction

CBlobView::CBlobView()
{
	//add down
	theta=0;
	beta=0; 
	dist=0.0;

	m_pDC = NULL;
	//add up

}

CBlobView::~CBlobView()
{
}

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

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CBlobView drawing

void CBlobView::OnDraw(CDC* pDC)
{
	CBlobDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
	//add down
	DrawScene();
	//add up

}

/////////////////////////////////////////////////////////////////////////////
// CBlobView printing

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CBlobView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CBlobView message handlers
GLfloat light_pos[] = {100.0,100.0,100.0,0.0};
void initLighting(void)
{
	
	GLfloat	   light_diffuse[] = { 1.0, 1.0, 1.0, 0.0 };
    GLfloat	   light_specular[] = { 1.0, 1.0, 1.0, 0.0 };
	GLfloat	   mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat	   mat_shininess[] = { 50.0 };

	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
	glLightfv(GL_LIGHT0,GL_POSITION,light_pos);


	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);

	glColorMaterial(GL_FRONT_AND_BACK,GL_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);
	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHTING);

}

void CALLBACK CBlobView::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();
}

void CALLBACK CBlobView::recSphere(float r,int dir)
{
	if(r > 0.5)
	{
		glPushMatrix();
		  glScalef(r,r,r);
		  glColor3f(rand()%255/255.0,rand()%255/255.0,rand()%255/255.0);
		  glCallList(ell);
		glPopMatrix();

		glPushMatrix();
		  glTranslatef(1.5*r,0.0,0.0);
		  recSphere(0.5*r,1);
		glPopMatrix();

		glPushMatrix();
		  glTranslatef(0.0,1.5*r,0.0);
		  recSphere(0.5*r,1);
		glPopMatrix();

		glPushMatrix();
		  glTranslatef(0.0,-1.5*r,0.0);
		  recSphere(0.5*r,1);
		glPopMatrix();

		glPushMatrix();
		  glTranslatef(0.0,0.0,1.5*r);
		  recSphere(0.5*r,1);
		glPopMatrix();	

		glPushMatrix();
		  glTranslatef(0.0,0.0,-1.5*r);
		  recSphere(0.5*r,1);
		glPopMatrix();
	}

}

void CALLBACK CBlobView::drawBlob(float r)
{
	glPushMatrix();
	glScalef(r,r,r);
	glCallList(ell);
	glPopMatrix();

	glPushMatrix();
	  glTranslatef(1.5*r,0.0,0.0);
	  recSphere(0.5*r,1);
	glPopMatrix();
}


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

void CBlobView::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 CBlobView::OnEraseBkgnd(CDC* pDC) 
{
	return TRUE;
}

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

    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();  

    DrawScene();
	
}

//add down
void CBlobView::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);

	glEnable(GL_NORMALIZE);
    glClearColor(0.0, 0.0, 0.0, 0.0);	

	/* glu stuff */

    qobj = gluNewQuadric();
    gluQuadricDrawStyle(qobj,GLU_FILL);
	gluQuadricNormals(qobj,GLU_SMOOTH);

	ell = glGenLists(1);
	glNewList(ell,GL_COMPILE);
	  gluSphere(qobj,1.0,20,20);
 	glEndList();
	
	MakeAxes();

	initLighting();
	glEnable(GL_CULL_FACE);
}

BOOL CBlobView::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 CBlobView::DrawScene(void)
{
	int i,j,k;
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);


	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);
	
	glLightfv(GL_LIGHT0,GL_POSITION,light_pos);

	glPushMatrix();
		
		glDisable(GL_LIGHTING);
		glDisable(GL_COLOR_MATERIAL);

		glCallList(axes);
		
		glTranslatef(50.0,50.0,50.0);
		glRotatef(45.0,0.0,0.0,1.0);
		glEnable(GL_LIGHTING);
		glEnable(GL_COLOR_MATERIAL);

		glColor3f(1.0,1.0,0.0);
		
		drawBlob(25.0);
		
	glPopMatrix();
 
	glFinish();
	SwapBuffers(wglGetCurrentDC());
}
//add up

void CBlobView::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;

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