main.cpp

一本关于OPenGL的很好的电子书

#define WIN32_LEAN_AND_MEAN				// trim the excess fat from Windows

/*******************************************************************
*	Program: Chapter 6 Light Example 3: Moving and Rotating Lights
*	OpenGL Game Programming
*	Author: Kevin Hawkins
*	Description: Shows a rotating cube with spotlight and a point
*				 light rotating around it. User can press
*				 keys to change the color of the point light:
*	[R] - Red, [G] - Green, [B] - Blue, [S] - Turn spotlight on/off
********************************************************************/

////// Includes
#include <windows.h>					// standard Windows app include
#include <gl/gl.h>						// standard OpenGL include
#include <gl/glu.h>						// OpenGL utilties
#include <gl/glaux.h>					// OpenGL auxiliary functions

////// Global Variables
float angle = 0.0f;						// current angle of the rotating triangle
HDC g_HDC;								// global device context
bool fullScreen = false;				// true = fullscreen; false = windowed
bool keyPressed[256];					// holds true for keys that are pressed

// Red, Green, and Blue light positions
float lightPositionR[] = { 0.0f, 0.0f, 75.0f, 1.0f };
float lightPositionG[] = { 0.0f, 0.0f, 75.0f, 1.0f };
float lightPositionB[] = { 0.0f, 0.0f, 75.0f, 1.0f };

// Red, Green, and Blue ambient light intensities
float diffuseLightR[] = { 1.0f, 0.0f, 0.0f, 1.0f };
float diffuseLightG[] = { 0.0f, 1.0f, 0.0f, 1.0f };
float diffuseLightB[] = { 0.0f, 0.0f, 1.0f, 1.0f };

// Red, Green, and Blue specular light intensities
float specularLightR[] = { 1.0f, 0.0f, 0.0f, 1.0f };
float specularLightG[] = { 0.0f, 1.0f, 0.0f, 1.0f };
float specularLightB[] = { 0.0f, 0.0f, 1.0f, 1.0f };

// Spotlight's direction
float spotDirection[] = { 0.0f, 0.0f, -1.0f };

// World light properties: diffuse, specular, position
float diffuseLight[] = { 0.5f, 0.5f, 0.5f, 1.0f };	 
float specularLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };	 
float lightPosition[] = { 0.0f, 0.0f, 100.0f, 1.0f };

float objectXRot;					// the cube's x rotation
float objectYRot;					// the cube's y rotation
float objectZRot;					// the cube's z rotation

float redXRot;						// red light x rotation
float redYRot;						// red light y rotation

int currentColor = 1;				// 1 = red, 2 = green, 3 = blue
bool spotEnabled = true;			// true = on; false = off

// Initialize
// desc: initializes OpenGL
void Initialize()
{
	glShadeModel(GL_SMOOTH);			// use smooth shading
	glEnable(GL_DEPTH_TEST);			// hidden surface removal
	glEnable(GL_CULL_FACE);				// do not calculate inside of poly's
	glFrontFace(GL_CCW);				// counter clock-wise polygons are out

	glEnable(GL_LIGHTING);				// enable lighting
	
	// LIGHT0 is the spotlight.
	// It points from (0.0, 0.0, 100.0) down the
	// negative z-axis.
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
	glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 40.0f);
	glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 80.0f);

	// LIGHT1 is our moving point light
	// It starts out as a red light.
	glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLightR);
	glLightfv(GL_LIGHT1, GL_SPECULAR, specularLightR);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPositionR);

	// Enable our lights
	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHT1);

	// Use color tracking for material properties
	glEnable(GL_COLOR_MATERIAL);
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

	// we want a very shiny effect on the cube
	glMaterialfv(GL_FRONT, GL_SPECULAR, specularLight);
	glMateriali(GL_FRONT, GL_SHININESS, 128);

	// Clear background to black
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}

// Render
// desc: handles drawing of scene
void Render()
{
	// clear screen and depth buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// reset modelview matrix
	glLoadIdentity();										

	// Move everything back to (0, 0, -150)
	glTranslatef(0.0f, 0.0f, -150.0f);

	glPushMatrix();
		// rotate along the x and y axes
		glRotatef(redYRot, 0.0f, 1.0f, 0.0f);
		glRotatef(redXRot, 1.0f, 0.0f, 0.0f);

		// place the light in the world
		glLightfv(GL_LIGHT1, GL_POSITION, lightPositionR);
	
		switch (currentColor)
		{
		case 1:			// red light
			{
				glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLightR);
				glLightfv(GL_LIGHT1, GL_POSITION, lightPositionR);
				glLightfv(GL_LIGHT1, GL_SPECULAR, specularLightR);

				// translate to draw the light's sphere
				glTranslatef(lightPositionR[0], lightPositionR[1], lightPositionR[2]);
				glColor3f(1.0f, 0.0f, 0.0f);
				break;
			}
		case 2:			// green light
			{
				glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLightG);
				glLightfv(GL_LIGHT1, GL_POSITION, lightPositionG);
				glLightfv(GL_LIGHT1, GL_SPECULAR, specularLightG);

				// translate to draw the light's sphere
				glTranslatef(lightPositionG[0], lightPositionG[1], lightPositionG[2]);
				glColor3f(0.0f, 1.0f, 0.0f);
				break;
			}
		case 3:			// blue light
			{
				glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLightB);
				glLightfv(GL_LIGHT1, GL_POSITION, lightPositionB);
				glLightfv(GL_LIGHT1, GL_SPECULAR, specularLightB);

				// translate to draw the light's sphere
				glTranslatef(lightPositionB[0], lightPositionB[1], lightPositionB[2]);
				glColor3f(0.0f, 0.0f, 1.0f);
				break;
			}
		}

		// Save the lighting attributes
		glPushAttrib(GL_LIGHTING_BIT);
			glDisable(GL_LIGHTING);		// disable lighting when we draw the sphere
				auxSolidSphere(2.5f);	// so the sphere is not affected by any lights
			glEnable(GL_LIGHTING);
		glPopAttrib();					// restore the lighting attributes
	glPopMatrix();

	// Draw the rotating cube
	glPushMatrix();
		glColor3f(1.0f, 1.0f, 1.0f);
		glRotatef(objectXRot, 1.0f, 0.0f, 0.0f);
		glRotatef(objectYRot, 0.0f, 1.0f, 0.0f);
		glRotatef(objectZRot, 0.0f, 0.0f, 1.0f);
		auxSolidCube(70.0f);
	glPopMatrix();
	
	glFlush();
	SwapBuffers(g_HDC);			// bring backbuffer to foreground

	// increase rotation values
	objectXRot += 0.01f;
	objectYRot += 0.02f;
	objectZRot += 0.01f;

	redXRot += 0.3f;
	redYRot += 0.1f;
}

// function to set the pixel format for the device context
void SetupPixelFormat(HDC hDC)
{
	int nPixelFormat;					// our pixel format index

	static PIXELFORMATDESCRIPTOR pfd = {
		sizeof(PIXELFORMATDESCRIPTOR),	// size of structure
		1,								// default version
		PFD_DRAW_TO_WINDOW |			// window drawing support
		PFD_SUPPORT_OPENGL |			// OpenGL support
		PFD_DOUBLEBUFFER,				// double buffering support
		PFD_TYPE_RGBA,					// RGBA color mode
		32,								// 32 bit color mode
		0, 0, 0, 0, 0, 0,				// ignore color bits, non-palettized mode
		0,								// no alpha buffer
		0,								// ignore shift bit
		0,								// no accumulation buffer
		0, 0, 0, 0,						// ignore accumulation bits
		16,								// 16 bit z-buffer size
		0,								// no stencil buffer
		0,								// no auxiliary buffer
		PFD_MAIN_PLANE,					// main drawing plane
		0,								// reserved
		0, 0, 0 };						// layer masks ignored

	nPixelFormat = ChoosePixelFormat(hDC, &pfd);	// choose best matching pixel format

	SetPixelFormat(hDC, nPixelFormat, &pfd);		// set pixel format to device context
}

// the Windows Procedure event handler
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	static HGLRC hRC;					// rendering context
	static HDC hDC;						// device context
	int width, height;					// window width and height

	switch(message)
	{
		case WM_CREATE:					// window is being created

			hDC = GetDC(hwnd);			// get current window's device context
			g_HDC = hDC;
			SetupPixelFormat(hDC);		// call our pixel format setup function

			// create rendering context and make it current
			hRC = wglCreateContext(hDC);
			wglMakeCurrent(hDC, hRC);

			return 0;
			break;

		case WM_CLOSE:					// windows is closing

			// deselect rendering context and delete it
			wglMakeCurrent(hDC, NULL);
			wglDeleteContext(hRC);

			// send WM_QUIT to message queue
			PostQuitMessage(0);

			return 0;
			break;

		case WM_SIZE:
			height = HIWORD(lParam);		// retrieve width and height
			width = LOWORD(lParam);

			if (height==0)					// don't want a divide by zero
			{
				height=1;					
			}

			glViewport(0, 0, width, height);	// reset the viewport to new dimensions
			glMatrixMode(GL_PROJECTION);		// set projection matrix current matrix
			glLoadIdentity();					// reset projection matrix

			// calculate aspect ratio of window
			gluPerspective(54.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);

			glMatrixMode(GL_MODELVIEW);			// set modelview matrix
			glLoadIdentity();					// reset modelview matrix

			return 0;
			break;

		case WM_KEYDOWN:					// is a key pressed?
			keyPressed[wParam] = true;
			return 0;
			break;

		case WM_KEYUP:
			keyPressed[wParam] = false;
			return 0;
			break;

		default:
			break;
	}

	return (DefWindowProc(hwnd, message, wParam, lParam));
}

// the main windows entry point
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASSEX windowClass;		// window class
	HWND	   hwnd;			// window handle
	MSG		   msg;				// message
	bool	   done;			// flag saying when our app is complete
	DWORD	   dwExStyle;		// Window Extended Style
	DWORD	   dwStyle;			// Window Style
	RECT	   windowRect;

	// temp var's
	int width = 800;
	int height = 600;
	int bits = 32;

	//fullScreen = TRUE;

	windowRect.left=(long)0;						// Set Left Value To 0
	windowRect.right=(long)width;					// Set Right Value To Requested Width
	windowRect.top=(long)0;							// Set Top Value To 0
	windowRect.bottom=(long)height;					// Set Bottom Value To Requested Height

	// fill out the window class structure
	windowClass.cbSize			= sizeof(WNDCLASSEX);
	windowClass.style			= CS_HREDRAW | CS_VREDRAW;
	windowClass.lpfnWndProc		= WndProc;
	windowClass.cbClsExtra		= 0;
	windowClass.cbWndExtra		= 0;
	windowClass.hInstance		= hInstance;
	windowClass.hIcon			= LoadIcon(NULL, IDI_APPLICATION);	// default icon
	windowClass.hCursor			= LoadCursor(NULL, IDC_ARROW);		// default arrow
	windowClass.hbrBackground	= NULL;								// don't need background
	windowClass.lpszMenuName	= NULL;								// no menu
	windowClass.lpszClassName	= "MyClass";
	windowClass.hIconSm			= LoadIcon(NULL, IDI_WINLOGO);		// windows logo small icon

	// register the windows class
	if (!RegisterClassEx(&windowClass))
		return 0;

	if (fullScreen)								// fullscreen?
	{
		DEVMODE dmScreenSettings;					// device mode
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);	
		dmScreenSettings.dmPelsWidth = width;		// screen width
		dmScreenSettings.dmPelsHeight = height;		// screen height
		dmScreenSettings.dmBitsPerPel = bits;		// bits per pixel
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

		// 
		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			// setting display mode failed, switch to windowed
			MessageBox(NULL, "Display mode failed", NULL, MB_OK);
			fullScreen=FALSE;	
		}
	}

	if (fullScreen)								// Are We Still In Fullscreen Mode?
	{
		dwExStyle=WS_EX_APPWINDOW;				// Window Extended Style
		dwStyle=WS_POPUP;						// Windows Style
		ShowCursor(FALSE);						// Hide Mouse Pointer
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;	// Window Extended Style
		dwStyle=WS_OVERLAPPEDWINDOW;					// Windows Style
	}

	AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);		// Adjust Window To True Requested Size

	// class registered, so now create our window
	hwnd = CreateWindowEx(NULL,									// extended style
						  "MyClass",							// class name
						  "Lighting Example 3: Moving and Rotating Light",		// app name
						  dwStyle | WS_CLIPCHILDREN |
						  WS_CLIPSIBLINGS,
						  0, 0,									// x,y coordinate
						  windowRect.right - windowRect.left,
						  windowRect.bottom - windowRect.top,	// width, height
						  NULL,									// handle to parent
						  NULL,									// handle to menu
						  hInstance,							// application instance
						  NULL);								// no extra params

	// check if window creation failed (hwnd would equal NULL)
	if (!hwnd)
		return 0;

	ShowWindow(hwnd, SW_SHOW);			// display the window
	UpdateWindow(hwnd);					// update the window

	done = false;						// intialize the loop condition variable
	Initialize();						// initialize OpenGL

	// main message loop
	while (!done)
	{
		PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);

		if (msg.message == WM_QUIT)		// do we receive a WM_QUIT message?
		{
			done = true;				// if so, time to quit the application
		}
		else
		{
			if (keyPressed[VK_ESCAPE])
				done = true;
			else
			{
				if (keyPressed['R'])
					currentColor = 1;

				if (keyPressed['G'])
					currentColor = 2;

				if (keyPressed['B'])
					currentColor = 3;

				if ((keyPressed['S']) && (spotEnabled))
				{
					spotEnabled = false;
					glDisable(GL_LIGHT0);
				}
				else if ((keyPressed['S']) && (!spotEnabled))
				{
					spotEnabled = true;
					glEnable(GL_LIGHT0);
				}

				Render();

				TranslateMessage(&msg);		// translate and dispatch to event queue
				DispatchMessage(&msg);
			}
		}
	}

	if (fullScreen)
	{
		ChangeDisplaySettings(NULL,0);		// If So Switch Back To The Desktop
		ShowCursor(TRUE);					// Show Mouse Pointer
	}

	return msg.wParam;
}