showlist.cpp

空战游戏flacon源码

//___________________________________________________________________

#include "showlist.h"
//___________________________________________________________________

#define	ANGLEROTATION		512
#define	LEFTSHIFTBIT		1
#define	RIGHTSHIFTBIT		2
#define	SHIFTBIT			3
#define	SCREENWIDTH			640
#define	SCREENHEIGHT		480
#define	SCREENDEPTH			16

//___________________________________________________________________

void CShowListApp::StartTimer ()
{
	TimerStart = timeGetTime ();
}

void CShowListApp::CalculateFramerate ()
{
	GLint	endtime;

	TotalFrameRate += (GLfloat) 1.0;
	endtime = timeGetTime () - TimerStart;
	if (endtime > 1000) {
		CurrentFrameRate = (TotalFrameRate * (GLfloat) 1000.0) / (GLfloat) endtime;
		TotalFrameRate = (GLfloat) 0.0;
		StartTimer ();
	}
}

BOOL CShowListApp::InitProgram ()
{
	TheLoader.Setup ();
	HWND hWnd = m_pMainWnd -> GetSafeHwnd();
	if (myGraphics.Setup (hWnd, SCREENWIDTH, SCREENHEIGHT, SCREENDEPTH)) {
		return FALSE;
	}
//	myGraphics.WindowMove (hWnd);

	myContext = &myGraphics.context;
	glSetObjectDirectory ("object\\");
	glSetTextureDirectory ("object\\texture\\");
	if (glSetUp3D (myContext -> rc, "objects.lst", "color.lst", "texture.lst")) {
		return FALSE;
	}


	lightdir.x = (GLfloat) 0.0;
	lightdir.y = (GLfloat) 1.0;
	lightdir.z = (GLfloat) 0.0;
	myViewport.glSetLightDirection (&lightdir);

	cameraheading = cameraclimb = camerabank = 0;
	cameraangle = 4096;	// 90 degree viewing angle
	SetCameraAngle ();

	shadowflag = 0;
	colormode = 0;
	keypressed = 0;
	currentflag = 0;
	currentstate = 0;
	bgcolor = 0xffffffff;
	myContext -> SetState (MPR_STA_BG_COLOR, bgcolor);
	myViewport.glSetDepthCueColor ((GLfloat) 1.0, (GLfloat) 1.0, (GLfloat) 1.0);

	objectheading = objectclimb = objectbank = 0;

	obj[0].objectID = 16;
	obj[0].scale = (GLfloat) 1.0;
	obj[0].anim = glAdd3DObject (obj[0].objectID);
	obj[0].objcoord.z = glGetObjectRadius (obj[0].objectID);
	obj[0].objcoord.x = (GLfloat) 0.0;
	obj[0].objcoord.y = (GLfloat) 0.0;
	obj[0].objectheading = obj[0].objectclimb = obj[0].objectbank = 0;
	glCreateTransformation (obj[0].objectheading,obj[0].objectclimb,obj[0].objectbank, &obj[0].objectMatrix);

	obj[1].objectID = 17;
	obj[1].scale = (GLfloat) 1.0;
	obj[1].anim = glAdd3DObject (obj[1].objectID);

	GLint i;
	for (i=2; i < TOTAL_OBJECTS;i++) {
		obj[i].objectID = 18;
		obj[i].scale = (GLfloat) 1.0;
		obj[i].anim = glAdd3DObject (obj[i].objectID);
	}

	glInsertObjectInSlot (obj[1].objectID, 4, obj[0].anim, obj[1].anim);
	glInsertObjectInSlot (obj[2].objectID, 0, obj[1].anim);
	glInsertObjectInSlot (obj[3].objectID, 1, obj[1].anim);
	glInsertObjectInSlot (obj[4].objectID, 2, obj[1].anim);

	glInsertObjectInSlot (obj[5].objectID, 0, obj[0].anim);
	glInsertObjectInSlot (obj[6].objectID, 1, obj[0].anim);
	glInsertObjectInSlot (obj[7].objectID, 2, obj[0].anim);
	glInsertObjectInSlot (obj[8].objectID, 3, obj[0].anim);
	glInsertObjectInSlot (obj[9].objectID, 5, obj[0].anim);
	glInsertObjectInSlot (obj[10].objectID, 6, obj[0].anim);
	glInsertObjectInSlot (obj[11].objectID, 7, obj[0].anim);
	glInsertObjectInSlot (obj[12].objectID, 8, obj[0].anim);

	GLfloat zoff = myViewport.glCalculateMinimumDistance (obj[0].objcoord.z * obj[0].scale);
	obj[0].objcoord.z = (GLfloat) 0.0;

	centercoord.x = centercoord.y = centercoord.z = (GLfloat) 0.0;
	originalcoord.x = curcenter.x = centercoord.x;
	originalcoord.y = curcenter.y = centercoord.y;
	originalcoord.z = curcenter.z = centercoord.z - zoff;
	myViewport.glSetCameraPosition (&curcenter);

	TotalFrameRate = (GLfloat) 0.0;
	CurrentFrameRate = (GLfloat) 10.0;
	StartTimer ();

	textureset = 0;
	return TRUE;
}

void CShowListApp::ExitProgram ()
{
	GLint i;
	for (i=0; i < TOTAL_OBJECTS; i++)
		glRemove3DObject (obj[i].objectID, obj[i].anim);

	glCleanUp3D();
	myGraphics.Cleanup ();
	TheLoader.Cleanup ();
}

void CShowListApp::SetCameraAngle ()
{
	GLfloat hScale, vScale;

	glCalculateViewScale (&hScale, &vScale, cameraangle, SCREENWIDTH, SCREENHEIGHT);
	myViewport.glSetViewport (myContext, 0, 0, SCREENWIDTH, SCREENHEIGHT, hScale, vScale);//, SCREENWIDTH/2, SCREENHEIGHT/2);
	SetCamera ();
}

void CShowListApp::SetCamera ()
{
/*	GLvertex dir, dir1;
	dir.x = dir.y = (GLfloat) 0.0;
	dir.z = (GLfloat) 1.0;
	glCreateTransformation (cameraheading, cameraclimb, camerabank,&myCameraMatrix);
	glMultVertex (&dir1, &dir, &myCameraMatrix);
	glLookAt (&dir1, &myCameraMatrix);
	glAdjustMatrix (&myCameraMatrix, cameraangle, SCREENWIDTH, SCREENHEIGHT);
*/
	glCreateInverseTransformation (	cameraheading, cameraclimb, camerabank,
									&myCameraMatrix,cameraangle,SCREENWIDTH, SCREENHEIGHT);
	glCreateInverseTransformation (	0, 0, camerabank,
									&myBillboardMatrix,cameraangle,SCREENWIDTH, SCREENHEIGHT);
	glCreateInverseTransformation (	0, cameraclimb, camerabank,
									&myBillboard1Matrix,cameraangle,SCREENWIDTH, SCREENHEIGHT);
	myViewport.glSetCameraMatrix (	&myCameraMatrix, 
									&myBillboardMatrix, &myBillboard1Matrix);
}

void CShowListApp::CheckKeyReleased (WPARAM wParam)
{
	WORD		scanCode;

	scanCode = MapVirtualKey (wParam, 0);
	switch (scanCode) {
		case KEYLEFTSHIFT:
			keypressed &= ~LEFTSHIFTBIT;
			break;
		case KEYRIGHTSHIFT:
			keypressed &= ~RIGHTSHIFTBIT;
			break;
	}
}

GLint CShowListApp::ProcessInput (WPARAM wParam, HWND hWnd)
{
	WORD	scanCode;
	GLfloat	stepsize;
	GLint	i, j;

	stepsize = (GLfloat) 1.0;
	scanCode = MapVirtualKey (wParam, 0);
	switch (scanCode) {
		case KEYF1:
			textureset++;
			break;
		case KEYF2:
			textureset--;
			if (textureset < 0) textureset = 0;
			break;

		case KEYF:
			shadowflag ^= 1;
			break;
		case KEY8:
			colormode ^= 1;
			if (colormode) {
				myViewport.glEnableColorMode (GL_MAKE_COLOR_GREEN);
			}
			else {
				myViewport.glDisableColorMode (GL_MAKE_COLOR_GREEN);
			}
			break;

		case KEYESCAPE:
			return (1);

		case KEYLEFTSHIFT:
			keypressed |= LEFTSHIFTBIT;
			break;
		case KEYRIGHTSHIFT:
			keypressed |= RIGHTSHIFTBIT;
			break;

		case KEY9:
			cameraangle += 64;
			if (cameraangle > 8128) cameraangle = 8128;	// max == 178.59375 deg
			SetCameraAngle ();
			break;
		case KEY0:
			cameraangle -= 64;
			if (cameraangle < 64) cameraangle = 64;	// min == 1.40625 deg
			SetCameraAngle ();
			break;

		case KEY1:
		case KEY2:
		case KEY3:
		case KEY4:
		case KEY5:
		case KEY6:
			if (keypressed & SHIFTBIT) {
				switch (scanCode) {
					case KEY1:
						cameraheading -= ANGLEROTATION;
						break;
					case KEY2:
						cameraheading += ANGLEROTATION;
						break;
					case KEY3:
						cameraclimb -= ANGLEROTATION;
						break;
					case KEY4:
						cameraclimb += ANGLEROTATION;
						break;
					case KEY5:
						camerabank -= ANGLEROTATION;
						break;
					case KEY6:
						camerabank += ANGLEROTATION;
						break;
				}
				SetCamera ();
			}
			else {
				switch (scanCode) {
					case KEY1:
						objectheading -= ANGLEROTATION;
						break;
					case KEY2:
						objectheading += ANGLEROTATION;
						break;
					case KEY3:
						objectclimb -= ANGLEROTATION;
						break;
					case KEY4:
						objectclimb += ANGLEROTATION;
						break;
					case KEY5:
						objectbank -= ANGLEROTATION;
						break;
					case KEY6:
						objectbank += ANGLEROTATION;
						break;
				}
				glCreateTransformation (objectheading,objectclimb,objectbank, &obj[0].objectMatrix);
			}
			break;

		case KEYR:
			textureset = 0;
			cameraheading = cameraclimb = camerabank = 0;
			cameraangle = 4096;
			SetCameraAngle ();
			curcenter.x = originalcoord.x;
			curcenter.y = originalcoord.y;
			curcenter.z = originalcoord.z;
			myViewport.glSetCameraPosition (&curcenter);
			bgcolor = 0xffffffff;
			myContext -> SetState (MPR_STA_BG_COLOR, bgcolor);
			myViewport.glSetDepthCueColor ((GLfloat) 1.0, (GLfloat) 1.0, (GLfloat) 1.0);

			lightcoord.x = lightcoord.y = lightcoord.z = (GLfloat) 0.0;
			myViewport.glSetPointLight (&lightcoord);

			objectheading = objectclimb = objectbank = 0;
			glCreateTransformation (objectheading,objectclimb,objectbank, &obj[0].objectMatrix);
			break;

		case KEYP:
			if (keypressed & SHIFTBIT) {
				currentflag ^= 4;
				if (currentflag & 4) {
					currentstate |= ENABLE_FILTERING_PERSPECTIVE_STATE;
					currentflag |= 2;
				}
				else currentstate &= ~ENABLE_FILTERING_STATE;
			}
			else {
				currentflag ^= 2;
				if (currentflag & 2) currentstate |= ENABLE_PERSPECTIVE_STATE;
				else if (currentflag & 4) {
					currentstate &= ~ENABLE_FILTERING_PERSPECTIVE_STATE;
					currentflag ^= 4;
				}
				else currentstate &= ~ENABLE_PERSPECTIVE_STATE;
			}
			myContext -> SetupMPRState (currentstate);
			break;

		case KEYT:
			if (keypressed & SHIFTBIT)
				myViewport.glToggleSurfaceDetail (GL_DETAIL_TRANSPARENT);
			else myViewport.glToggleSurfaceDetail (GL_DETAIL_TEXTURE);
			break;
		case KEYS:
			if (keypressed & SHIFTBIT)
				myViewport.glToggleSurfaceDetail (GL_DETAIL_SHADING);
			else myViewport.glDisableSurfaceDetail (GL_DETAIL_TEXTURE | GL_DETAIL_SMOOTH_SHADING);
			break;
		case KEYG:
			if (keypressed & SHIFTBIT)
				myViewport.glToggleSurfaceDetail (GL_DETAIL_GOURAUD);
			else myViewport.glToggleSurfaceDetail (GL_DETAIL_SMOOTH_SHADING);
			break;

		case KEYMINUS:
		case KEYPLUS:
		case KEYLEFTBRACKET:
		case KEYRIGHTBRACKET:
		case KEYCOLON:
		case KEYQUOTE:
			{
				j = 8;
				if (keypressed & SHIFTBIT) j = 1;
				switch (scanCode) {
					case KEYMINUS:
						i = (bgcolor >> 16) & 0xff;			// blue
						i = ((i - j) & 0xff) << 16;
						bgcolor = (bgcolor & 0xff00ffff) | i;
						break;
					case KEYPLUS:
						i = (bgcolor >> 16) & 0xff;			// blue
						i = ((i + j) & 0xff) << 16;
						bgcolor = (bgcolor & 0xff00ffff) | i;
						break;
					case KEYLEFTBRACKET:
						i = (bgcolor >> 8) & 0xff;			// green
						i = ((i - j) & 0xff) << 8;
						bgcolor = (bgcolor & 0xffff00ff) | i;
						break;
					case KEYRIGHTBRACKET:
						i = (bgcolor >> 8) & 0xff;			// green
						i = ((i + j) & 0xff) << 8;
						bgcolor = (bgcolor & 0xffff00ff) | i;
						break;
					case KEYCOLON:
						i = ((bgcolor & 0xff) - j) & 0xff;	// red
						bgcolor = (bgcolor & 0xffffff00) | i;
						break;
					case KEYQUOTE:
						i = ((bgcolor & 0xff) + j) & 0xff;	// red
						bgcolor = (bgcolor & 0xffffff00) | i;
						break;
				}
				myContext -> SetState (MPR_STA_BG_COLOR, bgcolor);
				GLfloat r, g, b;
				r = (GLfloat) (bgcolor & 0xff) / (GLfloat) 255.0;
				g = (GLfloat) ((bgcolor & 0xff00) >> 8) / (GLfloat) 255.0;
				b = (GLfloat) ((bgcolor & 0xff0000) >> 16) / (GLfloat) 255.0;
				myViewport.glSetDepthCueColor (r, g, b);
			}
			break;

		case KEYLEFT:
		case KEYRIGHT:
		case KEYUP: 	
		case KEYDOWN: 	
		case KEYPAGEUP:
		case KEYPAGEDOWN: 	
			if (keypressed & SHIFTBIT) {
				switch (scanCode) {
					case KEYLEFT:
						lightcoord.x -= stepsize;
						break;
					case KEYRIGHT:
						lightcoord.x += stepsize;
						break;
					case KEYUP: 	
						lightcoord.z += stepsize;
						break;
					case KEYDOWN: 	
						lightcoord.z -= stepsize;
						break;
					case KEYPAGEUP:
						lightcoord.y -= stepsize;
						break;
					case KEYPAGEDOWN: 	
						lightcoord.y += stepsize;
						break;
				}
//				if (pointlightflag)
//					myViewport.glSetPointLight (&lightcoord);
//				else myViewport.glSetLightDirection (&lightcoord);
			}
			else {
				switch (scanCode) {
					case KEYLEFT:
						curcenter.x -= stepsize;
						break;
					case KEYRIGHT:
						curcenter.x += stepsize;
						break;
					case KEYUP: 	
						curcenter.z += stepsize;
						break;
					case KEYDOWN: 	
						curcenter.z -= stepsize;
						break;
					case KEYPAGEUP:
						curcenter.y -= stepsize;
						break;
					case KEYPAGEDOWN: 	
						curcenter.y += stepsize;
						break;
				}
				myViewport.glSetCameraPosition (&curcenter);
			}
			break;
	}
	return 0;
}

void CShowListApp::ProgramLoop()
{
	myViewport.glSetTime (timeGetTime());
	myGraphics.StartFrame (currentflag & 1);

	if (shadowflag & 1)
		glDisplayObjectShadow (&myViewport, obj[0].objectID, &obj[0].objcoord, &obj[0].objectMatrix, obj[0].scale, obj[0].anim);
	else {
		glDisplayObject (&myViewport, obj[0].objectID, &obj[0].objcoord, &obj[0].objectMatrix, obj[0].scale, obj[0].anim, textureset);
	}

	myGraphics.FlipBuffer ();
	CalculateFramerate ();
}

//___________________________________________________________________