www.pudn.com > 基于SDK框架下OpenGL的实现.rar > WindowOpengGL.cpp

 
#include "WindowOpenGL.hpp" 
 
int APIENTRY WinMain(	HINSTANCE 	hInstance, 
						HINSTANCE 	hPrevInstance, 
						LPSTR 		lpCmdLine, 
						int			nCmdShow) 
{ 
	MSG			msg; 
	WNDCLASS	wc; 
	HWND		hWnd;	 
	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC; 
	wc.lpfnWndProc		= (WNDPROC) WndProc; 
	wc.cbClsExtra		= 0; 
	wc.cbWndExtra		= 0; 
	wc.hInstance 		= hInstance; 
	wc.hIcon			= NULL; 
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW); 
	wc.hbrBackground	= NULL;		 
	wc.lpszMenuName		= NULL; 
	wc.lpszClassName	= lpszAppName; 
	if(RegisterClass(&wc) == 0) 
		return FALSE; 
	hWnd = CreateWindow( 
				lpszAppName, 
				lpszAppName, 
				WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 
				100, 100, 
				600, 400, 
				NULL, 
				NULL, 
				hInstance, 
				NULL); 
	if(hWnd == NULL) 
		return FALSE; 
	ShowWindow(hWnd,SW_SHOW); 
	UpdateWindow(hWnd); 
 
	while( GetMessage(&msg, NULL, 0, 0)) 
  { 
		TranslateMessage(&msg); 
		DispatchMessage(&msg); 
  } 
	return msg.wParam; 
} 
 
LRESULT CALLBACK WndProc(	HWND 	hWnd,UINT	message,WPARAM	wParam,LPARAM	lParam) 
{ 
	static HGLRC hRC; 
	static HDC hDC;	 
 
	switch (message) 
  { 
    case WM_CREATE: 
			hDC = GetDC(hWnd);		 
			SetDCPixelFormat(hDC);		 
			hRC = wglCreateContext(hDC); 
			wglMakeCurrent(hDC, hRC); 
			hPalette = GetOpenGLPalette(hDC); 
      SetupRC(); 
			break; 
		case WM_SIZE: 
			ChangeSize(LOWORD(lParam), HIWORD(lParam)); 
			break; 
    case WM_KEYDOWN: 
      switch (wParam) 
      { 
        case	VK_UP: 
          xRot -= 5.0f; 
          SendMessage(hWnd,WM_PAINT,0,0l); 
          break; 
        case VK_DOWN: 
          xRot += 5.0f; 
          SendMessage(hWnd,WM_PAINT,0,0l); 
          break; 
        case	VK_LEFT: 
          yRot -= 5.0f; 
          SendMessage(hWnd,WM_PAINT,0,0l); 
          break; 
        case	VK_RIGHT: 
          yRot += 5.0f; 
          SendMessage(hWnd,WM_PAINT,0,0l); 
          break; 
      }     
      break; 
		case WM_PAINT: 
			RenderScene(); 
			SwapBuffers(hDC); 
			ValidateRect(hWnd,NULL); 
			break; 
		case WM_QUERYNEWPALETTE: 
			if(hPalette) 
      { 
				int nRet; 
				SelectPalette(hDC, hPalette, FALSE); 
				nRet = RealizePalette(hDC); 
				InvalidateRect(hWnd,NULL,FALSE); 
				return nRet; 
      } 
			break; 
		case WM_PALETTECHANGED: 
			if((hPalette != NULL) && ((HWND)wParam != hWnd)) 
      { 
				SelectPalette(hDC,hPalette,FALSE); 
				RealizePalette(hDC); 
				UpdateColors(hDC); 
				return 0; 
      } 
			break; 
    case WM_DESTROY: 
			KillTimer(hWnd,101); 
			wglMakeCurrent(hDC,NULL); 
			wglDeleteContext(hRC); 
      ReleaseDC(hWnd,hDC); 
			if(hPalette != NULL) 
				DeleteObject(hPalette); 
			PostQuitMessage(0); 
			break; 
    default:   
      return (DefWindowProc(hWnd, message, wParam, lParam)); 
  } 
  return (0L); 
} 
 
void SetDCPixelFormat(HDC hDC) 
{ 
	int nPixelFormat; 
	static PIXELFORMATDESCRIPTOR pfd = { 
    sizeof(PIXELFORMATDESCRIPTOR), 
		1,								 
		PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL |PFD_DOUBLEBUFFER,			 
		PFD_TYPE_RGBA,				 
		32,								 
		0,0,0,0,0,0,			 
		0,0,							 
		0,0,0,0,0,				 
		16,								 
		0,								 
		0,								 
		0,	            	 
		0,								 
		0,0,0 };					 
	nPixelFormat = ChoosePixelFormat(hDC, &pfd); 
	SetPixelFormat(hDC, nPixelFormat, &pfd); 
} 
 
HPALETTE GetOpenGLPalette(HDC hDC) 
{ 
	HPALETTE hRetPal = NULL; 
	PIXELFORMATDESCRIPTOR pfd; 
	LOGPALETTE *pPal; 
	int nPixelFormat; 
	int nColors; 
	int i; 
	BYTE RedRange,GreenRange,BlueRange; 
	nPixelFormat = GetPixelFormat(hDC); 
	DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd); 
	if(!(pfd.dwFlags & PFD_NEED_PALETTE)) 
		return NULL; 
	nColors = 1 << pfd.cColorBits;	 
	pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +nColors*sizeof(PALETTEENTRY)); 
	pPal->palVersion = 0x300;	 
	pPal->palNumEntries = nColors; 
	RedRange = (1 << pfd.cRedBits) -1; 
	GreenRange = (1 << pfd.cGreenBits) - 1; 
	BlueRange = (1 << pfd.cBlueBits) -1; 
	for(i = 0; i < nColors; i++) 
		{ 
		pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange; 
		pPal->palPalEntry[i].peRed = (unsigned char)( 
			(double) pPal->palPalEntry[i].peRed * 255.0 / RedRange); 
		pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange; 
		pPal->palPalEntry[i].peGreen = (unsigned char)( 
			(double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange); 
		pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange; 
		pPal->palPalEntry[i].peBlue = (unsigned char)( 
			(double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange); 
		pPal->palPalEntry[i].peFlags = (unsigned char) NULL; 
		} 
	hRetPal = CreatePalette(pPal); 
	SelectPalette(hDC,hRetPal,FALSE); 
	RealizePalette(hDC); 
	free(pPal); 
	return hRetPal; 
} 
 
void ChangeSize(GLsizei w, GLsizei h) 
{ 
	GLfloat nRange = 1.7f; 
 
	// Prevent a divide by zero 
	if(h == 0) 
		h = 1; 
 
	// Set Viewport to window dimensions 
    glViewport(0, 0, w, h); 
 
	// Reset projection matrix stack 
	glMatrixMode(GL_PROJECTION); 
	glLoadIdentity(); 
 
	// Establish clipping volume (left, right, bottom, top, near, far) 
    if (w <= h)  
		glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange); 
    else  
		glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange); 
 
	// Reset Model view matrix stack 
	glMatrixMode(GL_MODELVIEW); 
	glLoadIdentity(); 
 
} 
 
void SetupRC() 
{ 
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); 
 
    // Enable Depth Testing 
    glEnable(GL_DEPTH_TEST); 
 
	// Enable lighting 
  glEnable(GL_LIGHTING); 
 
	// Setup and enable light 0 
	glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight); 
	glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight); 
	glLightfv(GL_LIGHT0,GL_SPECULAR,specular); 
	glEnable(GL_LIGHT0); 
 
	// Enable color tracking 
	glEnable(GL_COLOR_MATERIAL); 
	 
	// Set Material properties to follow glColor values 
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); 
 
	// All materials hereafter have full specular reflectivity 
	// with a high shine 
	glMaterialfv(GL_FRONT, GL_SPECULAR,specref); 
	glMateriali(GL_FRONT,GL_SHININESS,128); 
 
 
	// Set drawing color to blue 
	glColor3ub(0, 0, 255); 
} 
void RenderScene() 
{ 
	glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); 
	glColor3f(0.0f,0.0f, 1.0f); 
  glPushMatrix(); 
	glRotatef(xRot, 1.0f, 0.0f, 0.0f); 
	glRotatef(yRot, 0.0f, 1.0f, 0.0f); 
	glutSolidTeapot(1.0f); 
  glPopMatrix(); 
}