game.cpp

体现了lod(level of detail)算法 包括网格细分,空间层次

#include <windows.h>
#include <stdio.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
#include <math.h>
#include <mmsystem.h>
#include "game.h"
#include "app.h"
#include "system.h"
#include "Roam.h"
#include "3DMath.h"

/* Global variables */
static int g_lastTime;
static int g_frameCount;

int g_tenFrames[10];

float g_maxSpeed;
float g_acceleration;
float g_maxTurnRate;

//#define PI (3.1415926535f)

in_mouseState_type in_mouseState;

extern int win_width;
extern int win_height;
int HeightmapCollide;
extern Landscape gLand;

extern int PATCH_SIZE;

extern float h_scale, v_scale;
float YCollide;

// Camera variables
int		MCenX, MCenY, accX, accY;
bool	MouseMove;


bool frcam_create()
{
		MouseMove=false;
		MCenX=0; MCenY=0;
		accX=0; accY=0;
	return true;
}

void frcam_update( )
{
	in_mouseState.xPos = -accX;
	in_mouseState.yPos = -accY;
	accX = 0; accY = 0;
}

void frcam_motion()
{
	int dx, dy;
	POINT pt;
	
	GetCursorPos(&pt);
	if (!MouseMove) {
		MCenX = (win_width/2);
		MCenY = (win_height/2);	
		SetCursorPos(MCenX, MCenY);
		accX = 0;
		accY = 0;
		MouseMove = true;
	}

	else 
	{
		if (MCenX==pt.x && MCenY==pt.y){return;}
		dx = MCenX -pt.x;
		dy = MCenY -pt.y;
		accX += dx;
		accY += dy;
		SetCursorPos(MCenX, MCenY);
	}
}

void gUpdate()
{
	int dt;
	static perSecond = 0;
	static int pPressed = FALSE;
	dt = sysTime() - g_lastTime;
	g_lastTime = sysTime();
	g_tenFrames[g_frameCount] = dt;
	g_frameCount = (g_frameCount + 1)%10;

	frcam_update();
	frcam_motion();

	g_previous = g_current;
	g_current.timeStamp = sysTime();

//	if(TRUE) //If not playing back recording...
	{
		gNewGameState(&g_current, &g_previous);
	}
}

void DrawAlignes(g_gamestate_type *g_current)
{
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glDisable(GL_DEPTH_TEST);
	{
		glLoadIdentity();
		glPushMatrix();
		glTranslatef(0.0f, 0.0f, -15.0f);
		
		glRotatef(g_current->XYAngle, 0.0f, 0.0f, 1.0f);

		glRotatef(g_current->YZAngle, 1.0f, 0.0f, 0.0f);
		glRotatef(g_current->XZAngle, 0.0f, 1.0f, 0.0f);

		

		glDisable(GL_TEXTURE_2D);
		
		glBegin(GL_LINES);
			glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
			glVertex3f(0.0f, 0.0f, 0.0f);
			glVertex3f(1.0f, 0.0f, 0.0f);
			glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
			glVertex3f(0.0f, 0.0f, 0.0f);
			glVertex3f(0.0f, 1.0f, 0.0f);
			glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
			glVertex3f(0.0f, 0.0f, 0.0f);
			glVertex3f(0.0f, 0.0f, 1.0f);
		glEnd();

		glPopMatrix();
	}
	glPopAttrib();
}

float Clip(float x, float y)
{
	return gLand.clipPoint(x, y);
}

void gNewGameState(g_gamestate_type *newState, const g_gamestate_type *oldState)
{
//	float accX = 0.0f, accY = 0.0f, accZ = 0.0f;	//Acceleration vector
	int dt = newState->timeStamp - oldState->timeStamp;
	float dxzAngle, dyzAngle;
	float dxyAngle=0;
	float AngleSpeed=0.2f;

	
	dxzAngle = (float)in_mouseState.xPos*g_maxTurnRate;
	newState->XZAngle = oldState->XZAngle + dxzAngle;
	if(newState->XZAngle > 360.0f)  newState->XZAngle -= 360.f;
	if(newState->XZAngle < 0.0f)	newState->XZAngle += 360.f;


	dyzAngle=(float)in_mouseState.yPos*g_maxTurnRate;
	newState->YZAngle = oldState->YZAngle - dyzAngle;
	if(newState->YZAngle > 360.0f)	newState->YZAngle -= 360.f;
	if(newState->YZAngle < 0.0f)	newState->YZAngle += 360.f;


	if (GetKey(VK_LEFT))  dxyAngle +=0.5; if (GetKey(VK_RIGHT)) dxyAngle -=0.5;

	newState->XYAngle = oldState->XYAngle - dxyAngle;
	if(newState->XYAngle > 360.0f)  newState->XYAngle -= 360.f;
	if(newState->XYAngle < 0.0f)	newState->XYAngle += 360.f;
		
	if ( (newState->XYAngle > 5.0f) && (newState->XYAngle < 45.0f)) {
		//AngleSpeed=newState->XZAngle/3;if (AngleSpeed>1) AngleSpeed=1;
		newState->XZAngle +=AngleSpeed;//0.7
	}

	if ( (newState->XYAngle < 355.0f) && (newState->XYAngle > 305.0f)) {
			newState->XZAngle -=AngleSpeed;
	}

		


	if (GetKey(VK_UP) || GetKey('A')) {newState->speed = oldState->speed - g_acceleration * (float)dt;}//0.000198
	if (GetKey(VK_DOWN) || GetKey('Z')) {newState->speed = oldState->speed + g_acceleration * (float)dt;}

	if(newState->speed > g_maxSpeed)	newState->speed = g_maxSpeed;
	if(newState->speed < -g_maxSpeed)	newState->speed = -g_maxSpeed;

	newState->XPos = oldState->XPos + (float)dt * newState->speed * (float)sin(-newState->XZAngle/180.0*PI) * (float)cos(newState->YZAngle/180.0*PI);
	newState->YPos = oldState->YPos + (float)dt * newState->speed * (float)sin(newState->YZAngle/180.0*PI);
	newState->ZPos = oldState->ZPos + (float)dt * newState->speed * (float)cos(-newState->XZAngle/180.0*PI) * (float)cos(newState->YZAngle/180.0*PI);

	if (HeightmapCollide==1){
		if(newState->YPos < (YCollide + Clip(newState->XPos, newState->ZPos)))
		   newState->YPos = (YCollide + Clip(newState->XPos, newState->ZPos));

			if(newState->YPos < (YCollide + Clip(newState->XPos, newState->ZPos+g_current.radius)))
				newState->YPos = (YCollide + Clip(newState->XPos, newState->ZPos+g_current.radius));

			if(newState->YPos < (YCollide + Clip(newState->XPos, newState->ZPos-g_current.radius)))
				newState->YPos = (YCollide + Clip(newState->XPos, newState->ZPos-g_current.radius));

			if(newState->YPos < (YCollide + Clip(newState->XPos+g_current.radius, newState->ZPos)))
				newState->YPos = (YCollide + Clip(newState->XPos+g_current.radius, newState->ZPos));

			if(newState->YPos < (YCollide + Clip(newState->XPos-g_current.radius, newState->ZPos)))
				newState->YPos = (YCollide + Clip(newState->XPos-g_current.radius, newState->ZPos));
	}

}

void drawFrustum(float x_pos, float y_pos, float z_pos, float XZAngle, float fov)
{
	//
	// Draw the camera eye & frustum
	//
	glDisable(GL_LIGHTING);
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_TEXTURE_GEN_S);
	glDisable(GL_TEXTURE_GEN_T);

	glPointSize(5.f);
	glLineWidth(3.f);

	glBegin(GL_LINES);

		// Draw the View Vector starting at the eye (red)
		glColor3f(1, 0, 0);
		glVertex3f(	x_pos, y_pos, z_pos );

		glVertex3f(	x_pos + 800.0f * sinf( XZAngle * M_PI / 180.0f ),
					y_pos,
					z_pos - 800.0f * cosf( XZAngle * M_PI / 180.0f ));//50

		// Draw the view frustum (blue)
		glColor3f(0, 0, 1);

		glVertex3f(	x_pos, y_pos, z_pos );
		
		glVertex3f(	x_pos + 1000.0f * sinf( (XZAngle-fov) * M_PI / 180.0f ),
					y_pos,
					z_pos - 1000.0f * cosf( (XZAngle-fov) * M_PI / 180.0f ));

		glVertex3f(	x_pos, y_pos, z_pos );
	
		glVertex3f(	x_pos + 1000.0f * sinf( (XZAngle+fov) * M_PI / 180.0f ),
					y_pos,
					z_pos - 1000.0f * cosf( (XZAngle+fov) * M_PI / 180.0f ));

		// Draw the clipping planes behind the eye (yellow)
		const float PI_DIV_180 = M_PI / 180.0f;
		const float FOV_DIV_2 = fov/2;

		int ptEyeX = (int)(x_pos - PATCH_SIZE * sinf( XZAngle * PI_DIV_180 ));
		int ptEyeY = (int)(z_pos + PATCH_SIZE * cosf( XZAngle * PI_DIV_180 ));

		int ptLeftX = (int)(ptEyeX + 100.0f * sinf( (XZAngle-FOV_DIV_2) * PI_DIV_180 ));
		int ptLeftY = (int)(ptEyeY - 100.0f * cosf( (XZAngle-FOV_DIV_2) * PI_DIV_180 ));

		int ptRightX = (int)(ptEyeX + 100.0f * sinf( (XZAngle+FOV_DIV_2) * PI_DIV_180 ));
		int ptRightY = (int)(ptEyeY - 100.0f * cosf( (XZAngle+FOV_DIV_2) * PI_DIV_180 ));

		glColor3f(1, 1, 0);

		glVertex3f(	(float)ptEyeX,	 y_pos, (float)ptEyeY );
		glVertex3f(	(float)ptLeftX,  y_pos, (float)ptLeftY);
		glVertex3f(	(float)ptEyeX,	 y_pos, (float)ptEyeY );
		glVertex3f(	(float)ptRightX, y_pos, (float)ptRightY);

	glEnd();

	glLineWidth(1.f);
	glColor3f(1, 1, 1);
}