winmain.cpp

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

#include <windows.h>
#include <stdio.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>

#include "winmain.h"
#include "system.h"

int win_x_position;
int win_y_position;
int win_width;
int win_height;
int bpp;



#pragma comment( lib, "opengl32.lib" )
#pragma comment( lib, "glu32.lib" )
#pragma comment( lib, "glaux.lib" )

//CModel cOBJModel;


HDC			hDC=NULL;
HGLRC		hRC=NULL;
HWND		hWnd;
HINSTANCE	hInstance;

bool	keys[256];
bool	active=TRUE;
int	fullscreen;



LRESULT	CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);


GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
	if (height==0)	{height=1;}
	glViewport(0,0,width,height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
//	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);	
	glMatrixMode(GL_MODELVIEW);	
	glLoadIdentity();
	
}

bool GetKey(int virtKeyCode)
{
    if (GetAsyncKeyState(virtKeyCode) & 0x8000) return true;
    return false;
}


int InitGL(GLvoid)
{
	appInit();

	return TRUE;
}

int DrawGLScene(GLvoid)	
{	
	
	appDraw();
	glFlush();
	
	return TRUE;													
}

GLvoid KillGLWindow(GLvoid)
{
//	DestroyScript();
	appCleanup();

	if (fullscreen)	{
		ChangeDisplaySettings(NULL,0);		
		ShowCursor(TRUE);					
	}

	if (hRC) {
		if (!wglMakeCurrent(NULL,NULL))	{
			MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		}

		if (!wglDeleteContext(hRC))	{
			MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		}
		hRC=NULL;
	}

	if (hDC && !ReleaseDC(hWnd,hDC)){
		MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hDC=NULL;
	}

	if (hWnd && !DestroyWindow(hWnd)){
		MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hWnd=NULL;
	}

	if (!UnregisterClass("OpenGL",hInstance)){
		MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hInstance=NULL;	
	}
}

/*	This Code Creates Our OpenGL Window.  Parameters Are:					*
 *	title			- Title To Appear At The Top Of The Window				*
 *	width			- Width Of The GL Window Or Fullscreen Mode				*
 *	height			- Height Of The GL Window Or Fullscreen Mode			*
 *	bits			- Number Of Bits To Use For Color (8/16/24/32)			*
 *	fullscreenflag	- Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE)	*/
 
BOOL CreateGLWindow(char* title, int width, int height, int bits, BOOL fullscreenflag)
{
	GLuint		PixelFormat;
	WNDCLASS	wc;
	DWORD		dwExStyle;
	DWORD		dwStyle;
	RECT		WindowRect;
	HDC			hdc;
	DEVMODE		dmScreenSettings;
	char szHello[]="Hello World!";
	
	hWnd=NULL;
	hdc = GetDC(NULL);
	fullscreen=fullscreenflag;	

	if (fullscreen)	{
		width=GetDeviceCaps(hdc, HORZRES);
		height=GetDeviceCaps(hdc, VERTRES);
	}
	
	WindowRect.left=(long)win_x_position;
	WindowRect.right=(long)width;
	WindowRect.top=(long)win_y_position;
	WindowRect.bottom=(long)height;								

	hInstance			= GetModuleHandle(NULL);				
	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;	
	wc.lpfnWndProc		= (WNDPROC) WndProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 0;
	wc.hInstance		= hInstance;
	wc.hIcon			= LoadIcon(NULL, IDI_WINLOGO);			
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);			
	wc.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);				
	wc.lpszMenuName		= NULL;									
	wc.lpszClassName	= "OpenGL";

	if (!RegisterClass(&wc))									
	{
		MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;										
	}
	
	if (fullscreen)	{
		if(!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dmScreenSettings))
		{
			MessageBox(NULL, "Error EnumDisplaySettings", "Error", MB_OK); 
			return FALSE;
		}
		
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));	
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);		
		dmScreenSettings.dmPelsWidth	= width;				
		dmScreenSettings.dmPelsHeight	= height;				
		dmScreenSettings.dmBitsPerPel	= bits;					
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
		{
			if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
				fullscreen=FALSE;
			}
			else
			{
				MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
				return FALSE;							
			}
		}
	}

	if (fullscreen)										
	{
		dwExStyle=WS_EX_APPWINDOW;
		dwStyle=WS_POPUP;								
		ShowCursor(FALSE);								
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;	
		dwStyle=WS_OVERLAPPEDWINDOW;					
	}

	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);

	// Create The Window
	if (!(hWnd=CreateWindowEx(	dwExStyle,							
								"OpenGL",							
								title,								
								dwStyle | WS_CLIPSIBLINGS |	WS_CLIPCHILDREN,
								0, 0,								
								WindowRect.right-WindowRect.left,	
								WindowRect.bottom-WindowRect.top,	
								NULL,								
								NULL,								
								hInstance,							
								NULL)))								
	{
		KillGLWindow();												
		MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}

	static	PIXELFORMATDESCRIPTOR pfd=
	{
		sizeof(PIXELFORMATDESCRIPTOR),				
		1,											
		PFD_DRAW_TO_WINDOW |						
		PFD_SUPPORT_OPENGL |						
		PFD_DOUBLEBUFFER,							
		PFD_TYPE_RGBA,								
		bits,										
		0, 0, 0, 0, 0, 0,							
		0,											
		0,											
		0,											
		0, 0, 0, 0,									
		16,											
		0,											
		0,											
		PFD_MAIN_PLANE,								
		0,											
		0, 0, 0										
	};
	
	if (!(hDC=GetDC(hWnd)))							
	{
		KillGLWindow();								
		MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;										
	}

	if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))	
	{
		KillGLWindow();										
		MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								
	}

	if(!SetPixelFormat(hDC,PixelFormat,&pfd))		
	{
		KillGLWindow();								
		MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								
	}

	if (!(hRC=wglCreateContext(hDC)))				
	{
		KillGLWindow();								
		MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;							
	}

	if(!wglMakeCurrent(hDC,hRC))				
	{
		KillGLWindow();							
		MessageBox(NULL,"Error Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;						
	}

	ShowWindow(hWnd,SW_SHOW);
	//UpdateWindow (hWnd);//
	SetForegroundWindow(hWnd);				
	SetFocus(hWnd);							
	ReSizeGLScene(width, height);			

	ShowCursor(FALSE);
	//TextOut(hdc, 50, 50, szHello, strlen(szHello));
	if (!InitGL())							
	{
		KillGLWindow();						
		MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;							
	}

	return TRUE;								
}

LRESULT CALLBACK WndProc(	HWND	hWnd,		
							UINT	uMsg,		
							WPARAM	wParam,		
							LPARAM	lParam)		
{
	PAINTSTRUCT    ps;
	switch (uMsg)								
	{
		case WM_PAINT:
			BeginPaint(hWnd, &ps);
			EndPaint(hWnd, &ps);
		break;

		case WM_ACTIVATE:						
		{
			if (!HIWORD(wParam))				
			{
				active=TRUE;					
			}
			else
			{
				active=FALSE;					
			}

			return 0;							
		}

		case WM_SYSCOMMAND:						
		{
			switch (wParam)						
			{
				case SC_SCREENSAVE:				
				case SC_MONITORPOWER:			
				return 0;						
			}
			break;								
		}

		case WM_CLOSE:							
		{
			appCleanup();
			PostQuitMessage(0);					
			return 0;							
		}

		case WM_KEYDOWN:						
		{
			keys[wParam] = TRUE;				
			return 0;							
		}

		case WM_KEYUP:
		{
			keys[wParam] = FALSE;
			return 0;
		}

		case WM_SIZE:
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
			return 0;
		}
	}

	// Pass All Unhandled Messages To DefWindowProc
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(	HINSTANCE	hInstance,
					HINSTANCE	hPrevInstance,
					LPSTR		lpCmdLine,
					int			nCmdShow)
{
	MSG		msg;
	BOOL	done=FALSE;

	win_x_position = 0;
	win_y_position = 0;
	//win_width  = 640;
	//win_height = 480;
	//bpp = 16;

	if(!sysLoadSettings("config.ini")) return 0;
	
	int startup_time;
	int render_time;
	int frame = 0;

	sysLogPrintf("\n **** Entry point ****\n");
	startup_time = sysTime();

	
	if (!CreateGLWindow("Proton3 Engine", win_width, win_height, bpp, fullscreen))
	{
		return 0;
	}

	startup_time = sysTime() - startup_time;
	sysLogPrintf("-> Engine started in %.1f seconds. Rendering...\n", (float)startup_time/1000.0f);

	render_time = sysTime();

	while(!done){
		if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))	{
			if (msg.message==WM_QUIT)	{
				done=TRUE;
			}
			else {
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else {	
			if ((active && !DrawGLScene()) || keys[VK_ESCAPE])
			{
				done=TRUE;
			}
			else													
			{
				SwapBuffers(hDC);
				
			}
			/*
			if (keys[VK_F1])
			{
				keys[VK_F1]=FALSE;
				KillGLWindow();
				fullscreen=!fullscreen;
				// Recreate Our OpenGL Window
			if (!CreateGLWindow("Proton3 Engine", win_width, win_height, bpp, fullscreen))
				{
					return 0;
				}
			}
			*/
		}
	}

	render_time = sysTime() - render_time;
	sysLogPrintf("-> Stopped rendering.\nRendered %d frames in %.1f seconds at %.2fFPS\n", frame, (float)render_time/1000.0f, 1000.0f*(float)frame/(float)render_time);

	KillGLWindow();
	return (msg.wParam);
}