Example #1
0
/*	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 Full screen Mode			*
*	height			- Height Of The GL Window Or Full screen Mode			*
*	bits			- Number Of Bits To Use For Color (8/16/24/32)			*
*	fullscreenflag	- Use Full screen Mode (TRUE) Or Windowed Mode (FALSE)	*/
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullScreenFlag)
{
	GLuint		PixelFormat;				// Holds the results after searching for a match
	WNDCLASS	wc;							// Windows class structure
	DWORD		dwExStyle;					// Window extended style
	DWORD		dwStyle;					// Window style
	RECT		WindowRect;					// Grabs rectangle upper left/lower right values
	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

	g_bFullscreen = fullScreenFlag;			// Set the global full screen flag

	hInstance = GetModuleHandle(NULL);								// Grab an instance for out window
	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;					// Redraw on size, and own DC for window
	wc.lpfnWndProc = (WNDPROC)WndProc;								// WndProc handles messages
	wc.cbClsExtra = 0;												// No extra window data
	wc.cbWndExtra = 0;												// No extra window data
	wc.hInstance = hInstance;										// Set the instance
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);							// Load the default icon
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);						// Load the arrow pointer
	wc.hbrBackground = NULL;										// No background required for GL
	wc.lpszMenuName = NULL;											// We don't want a menu
	wc.lpszClassName = CLASSNAME;									// Set the class name

	if (!RegisterClass(&wc))										// Attempt to register the window class
	{
		MessageBox(NULL, MSG_REGISTERCLASSFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}
	if (g_bFullscreen)
	{
		DEVMODE dmScreenSettings;									// Device mode
		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));		// Makes sure memory's cleared
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);			// Size of the devmode structure
		dmScreenSettings.dmPelsWidth = width;						// Selected screen width
		dmScreenSettings.dmPelsHeight = height;						// Selected screen height
		dmScreenSettings.dmBitsPerPel = bits;						// Selected bits per pixel
		dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
		// Try to set selected mode and get results. NOTE: CDS_FULLSCREEN gets rid of start bar.
		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			// If the mode failed, offer two options. Quit or use windowed mode.
			if (MessageBox(NULL, MSG_FULLSCREENNOTSUPPORT,
				ARTIST_NAME, MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
			{
				g_bFullscreen = FALSE;								// Windowed mode selected. Fullscreen = FALSE
			}
			else
			{
				// Pop up a message box letting user know the program is closing.
				MessageBox(NULL, MSG_PROGRAMNOTCLOSE,
					ERR_ERROR, MB_OK | MB_ICONSTOP);
				return FALSE;					// Return FALSE
			}
		}
	}
	if (g_bFullscreen)												// 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;				// Windows Extended style
		dwStyle = WS_OVERLAPPEDWINDOW;								// Windows Style
	}

	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);		// Adjust window to true requested size
	// Create the window
	if (!(hWnd = CreateWindowEx(dwExStyle,							// Extended style for the window
		CLASSNAME,													// Class name
		title,														// Window title
		dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,				// Defined window style
		0, 0,														// Window position
		WindowRect.right - WindowRect.left,							// Calculate window width
		WindowRect.bottom - WindowRect.top,							// Calculate window height
		NULL,														// No parent window
		NULL,														// No menu
		hInstance,													// Instance
		NULL)))														// Don't pass anything to WM_CREATE
	{
		KillGLWindow();												// Reset the display
		MessageBox(NULL, MSG_CREATEWINDOWFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}
	static PIXELFORMATDESCRIPTOR pfd =								// pfd tells widows how we want things to be
	{
		sizeof(PIXELFORMATDESCRIPTOR),								// Size of this pixel format descriptor
		1,															// Version number
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,	// Format must support window/opengl/double buffering
		PFD_TYPE_RGBA,												// Request an RGBA format
		bits,														// Select our color depth
		0, 0, 0, 0, 0, 0,											// Color bits ignored
		0,															// No Alpha buffer
		0,															// Shift bit ignored
		0,															// No accumulation buffer
		0, 0, 0, 0,													// Accumulation bits ignored
		DEPTHBUFFER,												// 16bit z-buffer (depth buffer)
		0,															// No stencil buffer
		0,															// No auxiliary buffer
		PFD_MAIN_PLANE,												// Main drawing layer
		0,															// Reserved
		0, 0, 0														// Layer masks ignored
	};
	if (!(hDC = GetDC(hWnd)))										// Did we get a device context
	{
		KillGLWindow();												// Reset the display
		MessageBox(NULL, MSG_CREATEGLDCFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}
	if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))				// Did Windows Find A Matching Pixel Format?
	{
		KillGLWindow();												// Reset The Display
		MessageBox(NULL, MSG_FINDPIXELFORMATFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}

	if (!SetPixelFormat(hDC, PixelFormat, &pfd))					// Are We Able To Set The Pixel Format?
	{
		KillGLWindow();												// Reset The Display
		MessageBox(NULL, MSG_SETPIXELFORMATFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}

	if (!(hRC = wglCreateContext(hDC)))								// Are We Able To Get A Rendering Context?
	{
		KillGLWindow();												// Reset The Display
		MessageBox(NULL, MSG_CREATEGLRCFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}

	if (!wglMakeCurrent(hDC, hRC))									// Try To Activate The Rendering Context
	{
		KillGLWindow();												// Reset The Display
		MessageBox(NULL, MSG_ACTIVEGLRCFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;												// Return FALSE
	}

	ShowWindow(hWnd, SW_SHOW);										// Show The Window
	SetForegroundWindow(hWnd);										// Slightly Higher Priority
	SetFocus(hWnd);													// Sets Keyboard Focus To The Window
	ReSizeGLScene(width, height);									// Set Up Our Perspective GL Screen

	if (!InitGL())													// Initialize Our Newly Created GL Window
	{
		KillGLWindow();												// Reset The Display
		MessageBox(NULL, MSG_INITFAILED,
			ERR_ERROR, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	return TRUE;									// Success
}
Example #2
0
LRESULT CALLBACK WndProc(	HWND	hWnd,			// Handle For This Window
							UINT	uMsg,			// Message For This Window
							WPARAM	wParam,			// Additional Message Information
							LPARAM	lParam)			// Additional Message Information
{
	switch (uMsg)									// Check For Windows Messages
	{
		case WM_ACTIVATE:							// Watch For Window Activate Message
		{
			if (!HIWORD(wParam))					// Check Minimization State
			{
				g_bActive = TRUE;					// Program Is Active
			}
			else
			{
				g_bActive = FALSE;					// Program Is No Longer Active
			}

			return 0;								// Return To The Message Loop
		}

		case WM_SYSCOMMAND:							// Intercept System Commands
		{
			switch (wParam)							// Check System Calls
			{
				case SC_SCREENSAVE:					// Screensaver Trying To Start?
				case SC_MONITORPOWER:				// Monitor Trying To Enter Powersave?
				return 0;							// Prevent From Happening
			}
			break;									// Exit
		}

		case WM_CLOSE:								// Did We Receive A Close Message?
		{
			PostQuitMessage(0);						// Send A Quit Message
			return 0;								// Jump Back
		}

		case WM_KEYDOWN:							// Is A Key Being Held Down?
		{
			g_bKeysArr[wParam] = TRUE;				// If So, Mark It As TRUE
			return 0;								// Jump Back
		}

		case WM_KEYUP:								// Has A Key Been Released?
		{
			g_bKeysArr[wParam] = FALSE;					// If So, Mark It As FALSE
			return 0;								// Jump Back
		}

		case WM_SIZE:								// Resize The OpenGL Window
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
			return 0;								// Jump Back
		}
		default: break;
	}

	// Pass All Unhandled Messages To DefWindowProc
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint		PixelFormat;			// Holds The Results After Searching For A Match
	WNDCLASS	wc;						// Windows Class Structure
	DWORD		dwExStyle;				// Window Extended Style
	DWORD		dwStyle;				// Window Style
	RECT		WindowRect;				// Grabs Rectangle Upper Left / Lower Right Values
	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

	fullscreen=fullscreenflag;			// Set The Global Fullscreen Flag

	hInstance			= GetModuleHandle(NULL);				// Grab An Instance For Our Window
	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;	// Redraw On Size, And Own DC For Window.
	wc.lpfnWndProc		= (WNDPROC) WndProc;					// WndProc Handles Messages
	wc.cbClsExtra		= 0;									// No Extra Window Data
	wc.cbWndExtra		= 0;									// No Extra Window Data
	wc.hInstance		= hInstance;							// Set The Instance
	wc.hIcon			= LoadIcon(NULL, IDI_WINLOGO);			// Load The Default Icon
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);			// Load The Arrow Pointer
	wc.hbrBackground	= NULL;									// No Background Required For GL
	wc.lpszMenuName		= NULL;									// We Don't Want A Menu
	wc.lpszClassName	= "OpenGL";								// Set The Class Name

	if (!RegisterClass(&wc))									// Attempt To Register The Window Class
	{
		MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;											// Return FALSE
	}
	
	if (fullscreen)												// Attempt Fullscreen Mode?
	{
		DEVMODE dmScreenSettings;								// Device Mode
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));	// Makes Sure Memory's Cleared
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);		// Size Of The Devmode Structure
		dmScreenSettings.dmPelsWidth	= width;				// Selected Screen Width
		dmScreenSettings.dmPelsHeight	= height;				// Selected Screen Height
		dmScreenSettings.dmBitsPerPel	= bits;					// Selected Bits Per Pixel
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

		// Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
		{
			// If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
			if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","OpenGL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
				fullscreen=FALSE;		// Windowed Mode Selected.  Fullscreen = FALSE
			}
			else
			{
				// Pop Up A Message Box Letting User Know The Program Is Closing.
				MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
				return FALSE;									// Return 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

	// Create The Window
	if (!(hWnd=CreateWindowEx(	dwExStyle,							// Extended Style For The Window
								"OpenGL",							// Class Name
								title,								// Window Title
								dwStyle |							// Defined Window Style
								WS_CLIPSIBLINGS |					// Required Window Style
								WS_CLIPCHILDREN,					// Required Window Style
								0, 0,								// Window Position
								WindowRect.right-WindowRect.left,	// Calculate Window Width
								WindowRect.bottom-WindowRect.top,	// Calculate Window Height
								NULL,								// No Parent Window
								NULL,								// No Menu
								hInstance,							// Instance
								NULL)))								// Dont Pass Anything To WM_CREATE
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	static	PIXELFORMATDESCRIPTOR pfd=				// pfd Tells Windows How We Want Things To Be
	{
		sizeof(PIXELFORMATDESCRIPTOR),				// Size Of This Pixel Format Descriptor
		1,											// Version Number
		PFD_DRAW_TO_WINDOW |						// Format Must Support Window
		PFD_SUPPORT_OPENGL |						// Format Must Support OpenGL
		PFD_DOUBLEBUFFER,							// Must Support Double Buffering
		PFD_TYPE_RGBA,								// Request An RGBA Format
		bits,										// Select Our Color Depth
		0, 0, 0, 0, 0, 0,							// Color Bits Ignored
		0,											// No Alpha Buffer
		0,											// Shift Bit Ignored
		0,											// No Accumulation Buffer
		0, 0, 0, 0,									// Accumulation Bits Ignored
		16,											// 16Bit Z-Buffer (Depth Buffer)  
		0,											// No Stencil Buffer
		0,											// No Auxiliary Buffer
		PFD_MAIN_PLANE,								// Main Drawing Layer
		0,											// Reserved
		0, 0, 0										// Layer Masks Ignored
	};
	
	if (!(hDC=GetDC(hWnd)))							// Did We Get A Device Context?
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))	// Did Windows Find A Matching Pixel Format?
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	if(!SetPixelFormat(hDC,PixelFormat,&pfd))		// Are We Able To Set The Pixel Format?
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	if (!(hRC=wglCreateContext(hDC)))				// Are We Able To Get A Rendering Context?
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	if(!wglMakeCurrent(hDC,hRC))					// Try To Activate The Rendering Context
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	ShowWindow(hWnd,SW_SHOW);						// Show The Window
	SetForegroundWindow(hWnd);						// Slightly Higher Priority
	SetFocus(hWnd);									// Sets Keyboard Focus To The Window
	ReSizeGLScene(width, height);					// Set Up Our Perspective GL Screen

	if (!InitGL())									// Initialize Our Newly Created GL Window
	{
		KillGLWindow();								// Reset The Display
		MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;								// Return FALSE
	}

	return TRUE;									// Success
}
LRESULT CALLBACK WndProc(	HWND	hWnd,			// Handle For This Window
							UINT	uMsg,			// Message For This Window
							WPARAM	wParam,			// Additional Message Information
							LPARAM	lParam)			// Additional Message Information
{
	switch (uMsg)									// Check For Windows Messages
	{
		case WM_ACTIVATE:							// Watch For Window Activate Message
		{
			if (!HIWORD(wParam))					// Check Minimization State
			{
				gActive=TRUE;						// Program Is Active
			}
			else
			{
				gActive=FALSE;						// Program Is No Longer Active
			}

			return 0;								// Return To The Message Loop
		}

        case WM_POWERBROADCAST:
            REPORT(cDebugSystem::General,">>>>>>> WM_POWERBROADCAST <<<<<<<");
            if(wParam == PBT_APMSUSPEND)
            {
                REPORT(cDebugSystem::General,"--> System is suspending <--");
                CameraLibrary::CameraManager::X().PrepareForSuspend();
            }
            if(wParam == PBT_APMRESUMEAUTOMATIC)
            {
                REPORT(cDebugSystem::General,"--> System is resuming <--");
                CameraLibrary::CameraManager::X().ResumeFromSuspend();
            }
            break;

		case WM_SYSCOMMAND:							// Intercept System Commands
		{
			switch (wParam)							// Check System Calls
			{
				case SC_SCREENSAVE:					// Screensaver Trying To Start?
				case SC_MONITORPOWER:				// Monitor Trying To Enter Powersave?
				return 0;							// Prevent From Happening
			}
			break;									// Exit
		}

		case WM_CLOSE:								// Did We Receive A Close Message?
		{
			PostQuitMessage(0);						// Send A Quit Message
			return 0;								// Jump Back
		}

		case WM_KEYDOWN:							// Is A Key Being Held Down?
		{
			keys[wParam] = TRUE;					// If So, Mark It As TRUE
			return 0;								// Jump Back
		}

		case WM_KEYUP:								// Has A Key Been Released?
		{
			keys[wParam] = FALSE;					// If So, Mark It As FALSE
			return 0;								// Jump Back
		}
        case WM_MOVE:
            DrawGLScene(0);
            SwapBuffers(hDC);
			return 0;								// Jump Back
        case WM_PAINT:
            return 0;
		case WM_SIZE:								// Resize The OpenGL Window
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
            DrawGLScene(0);
            SwapBuffers(hDC);
			return 0;								// Jump Back
		}
	}

	// Pass All Unhandled Messages To DefWindowProc
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
Example #5
0
LRESULT CALLBACK
ScreenSaverProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    RECT Screen;                            // Used Later On To Get The Size Of The Window
    GLuint PixelFormat;                     // Pixel Format Storage
    static PIXELFORMATDESCRIPTOR pfd=       // Pixel Format Descriptor
    {
        sizeof(PIXELFORMATDESCRIPTOR),      // Size Of This Pixel Format Descriptor
        1,                                  // Version Number (?)
        PFD_DRAW_TO_WINDOW |                // Format Must Support Window
        PFD_SUPPORT_OPENGL |                // Format Must Support OpenGL
        PFD_DOUBLEBUFFER,                   // Must Support Double Buffering
        PFD_TYPE_RGBA,                      // Request An RGBA Format
        16,                                 // Select A 16Bit Color Depth
        0, 0, 0, 0, 0, 0,                   // Color Bits Ignored (?)
        0,                                  // No Alpha Buffer
        0,                                  // Shift Bit Ignored (?)
        0,                                  // No Accumulation Buffer
        0, 0, 0, 0,                         // Accumulation Bits Ignored (?)
        16,                                 // 16Bit Z-Buffer (Depth Buffer)
        0,                                  // No Stencil Buffer
        0,                                  // No Auxiliary Buffer (?)
        PFD_MAIN_PLANE,                     // Main Drawing Layer
        0,                                  // Reserved (?)
        0, 0, 0                             // Layer Masks Ignored (?)
    };

    switch (message)
    {
        case WM_CREATE:
            LoadSettings();

            // Gets A Device Context For The Window
            hDC = GetDC(hWnd);

            // Finds The Closest Match To The Pixel Format We Set Above
            PixelFormat = ChoosePixelFormat(hDC, &pfd);

            // No Matching Pixel Format?
            if (!PixelFormat)
            {
                MessageBox(0, _TEXT("Can't Find A Suitable PixelFormat."), _TEXT("Error"),MB_OK | MB_ICONERROR);

                // This Sends A 'Message' Telling The Program To Quit
                PostQuitMessage(0);
                break;
            }

            // Can We Set The Pixel Mode?
            if (!SetPixelFormat(hDC, PixelFormat, &pfd))
            {
                MessageBox(0, _TEXT("Can't Set The PixelFormat."), _TEXT("Error"), MB_OK | MB_ICONERROR);

                // This Sends A 'Message' Telling The Program To Quit
                PostQuitMessage(0);
                break;
            }

            // Grab A Rendering Context
            hRC = wglCreateContext(hDC);

            // Did We Get One?
            if (!hRC)
            {
                MessageBox(0, _TEXT("Can't Create A GL Rendering Context."), _TEXT("Error"), MB_OK | MB_ICONERROR);

                // This Sends A 'Message' Telling The Program To Quit
                PostQuitMessage(0);
                break;
            }

            // Can We Make The RC Active?
            if (!wglMakeCurrent(hDC, hRC))
            {
                MessageBox(0, _TEXT("Can't Activate GLRC."), _TEXT("Error"), MB_OK | MB_ICONERROR);

                // This Sends A 'Message' Telling The Program To Quit
                PostQuitMessage(0);
                break;
            }

            // Grab Screen Info For The Current Window
            GetClientRect(hWnd, &Screen);

            // Initialize The GL Screen Using Screen Info
            InitGL(Screen.right, Screen.bottom);
            break;

        case WM_DESTROY:
            // Disable Fullscreen Mode
            ChangeDisplaySettings(NULL, 0);

            // Deletes The Font Display List
            KillFont();

            // Make The DC Current
            wglMakeCurrent(hDC, NULL);

            // Kill The RC
            wglDeleteContext(hRC);

            // Free The DC
            ReleaseDC(hWnd, hDC);
            break;

        case WM_PAINT:
            DrawGLScene();
            SwapBuffers(hDC);
            break;

        case WM_SIZE: // Resizing The Screen
            // Resize To The New Window Size
            ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
            break;

        default:
            // Pass Windows Messages to the default screensaver window procedure
            return DefScreenSaverProc(hWnd, message, wParam, lParam);
    }

    return 0;
}
Example #6
0
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_CREATE:		return 0;
		case WM_ERASEBKGND: return 0;
		case WM_PAINT:
			{ 
				PAINTSTRUCT ps;
				RECT r;
				HDC hdc = BeginPaint(hwnd,&ps);
				GetClientRect(hwnd,&r);
				BitBlt(hdc,0,0,r.right,r.bottom,memDC,0,0,SRCCOPY);
				EndPaint(hwnd,&ps);
			}
		return 0;
		case WM_CLOSE:																				// Did We Receive A Close Message?
		{
			PostQuitMessage(0);																		// Send A Quit Message
			return 0;																				// Jump Back
		}
		case WM_DESTROY: PostQuitMessage(0); return 0;
		{																							// get this_mod from our window's user data
			winampVisModule *this_mod = (winampVisModule *) GetWindowLong(hwnd,GWL_USERDATA);
			PostMessage(this_mod->hwndParent,message,wParam,lParam);
		}
		return 0;
		case WM_MOVE:
			{	
				RECT r;
				GetWindowRect(hMainWnd,&r);
				config_x = 1024;
				config_y = 768;
			}
		return 0;
		case WM_SIZE:																				// Resize The OpenGL Window
		{
			width=LOWORD(lParam);
			height=HIWORD(lParam);
			ReSizeGLScene(width,height);															// LoWord=Width, HiWord=Height
			return 0;																				// Jump Back
		}
		case WM_SYSCOMMAND:																			// Intercept System Commands
		{
			switch (wParam)																			// Check System Calls
			{
				case SC_SCREENSAVE:																	// Screensaver Trying To Start?
				case SC_MONITORPOWER:																// Monitor Trying To Enter Powersave?
				return 0;																			// Prevent From Happening
			}
			break;																					// Exit
		}
		case WM_KEYDOWN:																			// Is A Key Being Held Down?
		{
			keys[wParam] = TRUE;																	// If So, Mark It As TRUE
			keyboard();
			return 0;																				// Jump Back
		}
		case WM_KEYUP:																				// Has A Key Been Released?
		{
			keys[wParam] = FALSE;																	// If So, Mark It As FALSE
			return 0;																				// Jump Back
		}
		case WM_MOUSEMOVE:
		{
			return 0;
		}
		case WM_LBUTTONUP :
		{
			return 0;
		}
		case WM_RBUTTONDOWN :
		{
			return 0;	
		}
	}
	return DefWindowProc(hwnd,message,wParam,lParam);
}
Example #7
0
// title = titolo della finestra
// width = larghezza finestra o risoluzione in fullscreen
// height = altezza finestra o risoluzione in fullscreen
// bits = numero di bits del colore
// fullscreenflag = lanciare in modalità fullscreen?
bool OpenGL_Genesis::CreateGLWindow (char* title, int width, int height, int bits, int fullscreenflag)
{
	GLuint			PixelFormat;				// contiene il risultato dopo aver cercato il formato dei pixel
	WNDCLASS		wc;						// struttura della Windows Class
	DWORD		dwExStyle;				// stile esteso finestra
	DWORD		dwStyle;				// stile finestra

	RECT			WindowRect;			// coordinate degli angoli alto/sx e basso/dx della finestra
	WindowRect.left = (long)0;
	WindowRect.right = (long)width;
	WindowRect.top = (long)0;
	WindowRect.bottom = (long)height;

	fullscreen = fullscreenflag;

	hInstance 			= GetModuleHandle(NULL);						// ottiene un'istanza per la finestra
	wc.style				= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;	// ottiene il DC e disegna nell'area
	wc.lpfnWndProc		= (WNDPROC) MyWndProc;						// indica che WndProc gestisce e msg di sistema
	wc.cbClsExtra		= 0;												// nessun dato extra
	wc.cbWndExtra		= 0;												// nessun dato extra
	wc.hInstance		= hInstance;										// setta l'istanza
	wc.hIcon			= LoadIcon(NULL, IDI_WINLOGO);				// carica l'icona di default
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);				// carica il puntatore di default
	wc.hbrBackground	= NULL;										// nessun background richiesto per l'OpenGL
	wc.lpszMenuName	= NULL;										// nessun menu
	wc.lpszClassName	= "OpenGL";										// nome della classe

	if (!RegisterClass(&wc)) {								// registrazione classe riuscita?
		MessageBox(NULL, " Registrazione Window Class fallita. ", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	if (fullscreen) {
		DEVMODE dmScreenSettings;								// Device Mode
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));		// azzeramento memoria (pulisce lo schermo)
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);			// dimensioni del Device Mode
		dmScreenSettings.dmPelsWidth	= width;						// larghezza finestra
		dmScreenSettings.dmPelsHeight	= height;					// altezza finestra
		dmScreenSettings.dmBitsPerPel	= bits;						// seleziona i bits per pixel
		dmScreenSettings.dmFields=DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

		// cambio modalità video riuscito?
		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) {			//NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
			// se cambio modalità fallito entra in windowed mode
			if (MessageBox (NULL, " Modalità fullscreen non supportata.\nEntrare in window mode? ", "Genesis", MB_YESNO|MB_ICONEXCLAMATION) == IDYES)
				fullscreen = FALSE;
			else {
				MessageBox(NULL, " Chiusura programma. ", "Genesis - ERROR", MB_OK | MB_ICONSTOP);
				return FALSE;
			}
		}
	}

	if (fullscreen) {
		ShowCursor(FALSE);										// nascondi il puntatore del mouse
		dwExStyle=WS_EX_APPWINDOW;						// stile esteso finestra
		dwStyle=WS_POPUP;									// stile finestra
	}
	else {
		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;			// stile esteso finestra
		dwStyle=WS_OVERLAPPEDWINDOW;									// stile finestra
	}

	AdjustWindowRectEx (&WindowRect, dwStyle, FALSE, dwExStyle);				// settaggio dimensioni finestra

	// crea la finestra
	if (!(hWnd = CreateWindowEx(	dwExStyle,							// stile esteso finestra
									"OpenGL",							// nome della classe
									title,								// titolo finestra
									dwStyle |							// stile finestra
									WS_CLIPSIBLINGS |				// stile finestra rischiesto
									WS_CLIPCHILDREN,				// stile finestra rischiesto
									0, 0,								// posizione
									WindowRect.right - WindowRect.left,		// calcolo larghezza
									WindowRect.bottom - WindowRect.top,		// calcolo altezza
									NULL,								// nessuna finestra madre
									NULL,								// nessun menu
									hInstance,							// istanza
									NULL)))								// non passare niente a WM_CREATE
	{
		KillGLWindow();								// distrugge la finestra
		MessageBox(NULL," Errore nella creazione della finestra. ", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	static	PIXELFORMATDESCRIPTOR pfd =			// pfd descrive il formato pixel
	{
		sizeof(PIXELFORMATDESCRIPTOR),				// dimensione del formato pixel
		1,												// numero versione
		PFD_DRAW_TO_WINDOW |					// il formato deve supportare Windows
		PFD_SUPPORT_OPENGL |						// il formato deve supportare le OpenGL
		PFD_DOUBLEBUFFER,							// il formato deve supportare il double buffering
		PFD_TYPE_RGBA,								// rischiesta RGBA
		bits,											// profondità colore
		0, 0, 0, 0, 0, 0,									// bit del colore ignorati
		0,												// no alpha buffer
		0,												// shift bit ignorati
		0,												// no accumulation buffer
		0, 0, 0, 0,										// accumulation bits ignorati
		16,												// 16bit Z-Buffer (Depth Buffer)
		0,												// no Stencil Buffer
		0,												// no Auxiliary Buffer
		PFD_MAIN_PLANE,								// livello di rendering primario
		0,												// RISERVATO
		0, 0, 0											// maschere non utilizzate
	};

	if (!(hDC = GetDC (hWnd))) {								// abbiamo un DC?
		KillGLWindow();										// distrugge la finestra
		MessageBox(NULL," Impossibile creare un GL Device Context. ", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	if (!(PixelFormat = ChoosePixelFormat(hDC,&pfd))) {				// formato pixel adatto trovato?
		KillGLWindow();											// distrugge la finestra
		MessageBox(NULL," Impossibile trovarre un formato pixel. ", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	if(!SetPixelFormat (hDC,PixelFormat, &pfd)) {					// formato pixel settato?
		KillGLWindow();											// distrugge la finestra
		MessageBox(NULL," Impossibile settare il formato pixel.", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	if (!(hRC=wglCreateContext(hDC))) {				// Rendering Context settato?
		KillGLWindow();								// distrugge la finestra
		MessageBox(NULL," Impossibile creare un GL Rendering Context. ", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	if(!wglMakeCurrent (hDC, hRC)) {					// RC attivato?
		KillGLWindow();								// distrugge la finestra
		MessageBox(NULL," Impossibile attivare il Rendering Context. ", "Genesis - ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;
	}

	ShowWindow(hWnd, SW_SHOW);					// visualizza finestra
	SetForegroundWindow(hWnd);						// massimo livello priorità
	SetFocus(hWnd);									// da il controllo della tastiera all'applicazione
	ReSizeGLScene(width, height);					// attiva la modalità OpenGL

	return TRUE;
}
Example #8
0
BOOL CreateGLWindow( char* title, int width, int height, int bits, bool fullscreenflag )

{

    GLuint    PixelFormat;              // Хранит результат после поиска


    WNDCLASS  wc;

    DWORD    dwExStyle;              // Расширенный стиль окна

    DWORD    dwStyle;              // Обычный стиль окна

    RECT WindowRect;                // Grabs Rectangle Upper Left / Lower Right Values

    WindowRect.left = (long)0;            // Установить левую составляющую в 0

    WindowRect.right = (long)width;            // Установить правую составляющую в Width

    WindowRect.top = (long)0;              // Установить верхнюю составляющую в 0

    WindowRect.bottom = (long)height;            // Установить нижнюю составляющую в Height


    fullscreen = fullscreenflag;            // Устанавливаем значение глобальной переменной fullscreen


    hInstance    = GetModuleHandle(NULL);        // Считаем дескриптор нашего приложения

    wc.style    = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;      // Перерисуем при перемещении и создаём скрытый DC

    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  = NULL;              // Фон не требуется для GL

    wc.lpszMenuName    = NULL;              // Меню в окне не будет

    wc.lpszClassName  = "OpenGL";            // Устанавливаем имя классу


    if( !RegisterClass( &wc ) )              // Пытаемся зарегистрировать класс окна

    {

        MessageBox( NULL, "Failed To Register The Window Class.", "ERROR", MB_OK | MB_ICONEXCLAMATION );

        return FALSE;                // Выход и возвращение функцией значения false

    }


    if( fullscreen )                // Полноэкранный режим?

    {


        DEVMODE dmScreenSettings;            // Режим устройства

        memset( &dmScreenSettings, 0, sizeof( dmScreenSettings ) );    // Очистка для хранения установок

        dmScreenSettings.dmSize = sizeof( dmScreenSettings );    // Размер структуры Devmode

        dmScreenSettings.dmPelsWidth  =   width;        // Ширина экрана

        dmScreenSettings.dmPelsHeight  =   height;        // Высота экрана

        dmScreenSettings.dmBitsPerPel  =   bits;        // Глубина цвета

        dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; // Режим Пикселя



        // Пытаемся установить выбранный режим и получить результат.  Примечание: CDS_FULLSCREEN убирает панель управления.

        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;          // Выбор оконного режима (fullscreen = false)

            }

            else

            {

                // Выскакивающее окно, сообщающее пользователю о закрытие окна.

                MessageBox( NULL, "Program Will Now Close.", "ERROR", MB_OK | MB_ICONSTOP );

                return FALSE;            // Выход и возвращение функцией 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 );      // Подбирает окну подходящие размеры


    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 ) ) )          // Не передаём ничего до WM_CREATE (???)


    {

        KillGLWindow();                // Восстановить экран

        MessageBox( NULL, "Window Creation Error.", "ERROR", MB_OK | MB_ICONEXCLAMATION );

        return FALSE;                // Вернуть false

    }

    static  PIXELFORMATDESCRIPTOR pfd =           // pfd сообщает Windows каким будет вывод на экран каждого пикселя

    {

        sizeof(PIXELFORMATDESCRIPTOR),            // Размер дескриптора данного формата пикселей

        1,                  // Номер версии

        PFD_DRAW_TO_WINDOW |              // Формат для Окна

        PFD_SUPPORT_OPENGL |              // Формат для OpenGL

        PFD_DOUBLEBUFFER,              // Формат для двойного буфера

        PFD_TYPE_RGBA,                // Требуется RGBA формат

        bits,                  // Выбирается бит глубины цвета

        0, 0, 0, 0, 0, 0,              // Игнорирование цветовых битов

        0,                  // Нет буфера прозрачности

        0,                  // Сдвиговый бит игнорируется

        0,                  // Нет буфера накопления

        0, 0, 0, 0,                // Биты накопления игнорируются

        32,                  // 32 битный Z-буфер (буфер глубины)

        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;                // Вернуть false

    }

    if( !( PixelFormat = ChoosePixelFormat( hDC, &pfd ) ) )        // Найден ли подходящий формат пикселя?

    {

        KillGLWindow();                // Восстановить экран

        MessageBox( NULL, "Can't Find A Suitable PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION );

        return FALSE;                // Вернуть false

    }


    if( !SetPixelFormat( hDC, PixelFormat, &pfd ) )          // Возможно ли установить Формат Пикселя?

    {

        KillGLWindow();                // Восстановить экран

        MessageBox( NULL, "Can't Set The PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION );

        return FALSE;                // Вернуть false

    }

    if( !( hRC = wglCreateContext( hDC ) ) )          // Возможно ли установить Контекст Рендеринга?

    {

        KillGLWindow();                // Восстановить экран

        MessageBox( NULL, "Can't Create A GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);

        return FALSE;                // Вернуть false

    }


    if( !wglMakeCurrent( hDC, hRC ) )            // Попробовать активировать Контекст Рендеринга

    {

        KillGLWindow();                // Восстановить экран

        MessageBox( NULL, "Can't Activate The GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION );

        return FALSE;                // Вернуть false

    }


    ShowWindow( hWnd, SW_SHOW );              // Показать окно

    SetForegroundWindow( hWnd );              // Слегка повысим приоритет

    SetFocus( hWnd );                // Установить фокус клавиатуры на наше окно

    ReSizeGLScene( width, height );              // Настроим перспективу для нашего OpenGL экрана.


    if( !InitGL() )                  // Инициализация только что созданного окна

    {

        KillGLWindow();                // Восстановить экран

        MessageBox( NULL, ("Initialization Failed."), ("ERROR"), MB_OK | MB_ICONEXCLAMATION );

        return FALSE;                // Вернуть false

    }


    return TRUE;                  // Всё в порядке!

}
Example #9
0
LRESULT GLWindow::WndProc(HWND	hWnd,			// Handle For This Window
				UINT	uMsg,			// Message For This Window
				WPARAM	wParam,			// Additional Message Information
				LPARAM	lParam)			// Additional Message Information
{
	switch (uMsg)
	{
		case WM_ACTIVATE:				// Watch For Window Activate Message		
		{
			if (LOWORD(wParam)==WA_INACTIVE || HIWORD(wParam)!=0)			// Check Minimization State			
			{
				active=false;			// Program Is Active	
//				SetCursor(LoadCursor(NULL, IDC_ARROW));
			}
			else			
			{
				active=true;			// Program Is No Longer Active			
			}
			
			return 0;				// Return To The Message Loop		
		}
		case WM_SYSCOMMAND:				// Intercept System Commands		
		{
				switch (wParam)				// Check System Calls			
				{
					case SC_SCREENSAVE:		// Screensaver Trying To Start?
					case SC_MONITORPOWER:		// Monitor Trying To Enter Powersave?
					return 0;			// Prevent From Happening			
				}			
				break;					// Exit		
		}
		case WM_CLOSE:					// Did We Receive A Close Message?		
		{
			PostQuitMessage(0);			// Send A Quit Message			
			break;						// Jump Back		
		}
		case WM_MOUSEMOVE:				// Is A Key Being Held Down?		
		{
			LeftMouseButton = ((wParam & MK_LBUTTON)!=0);              // key flags 
			if (LeftMouseButton)
				LeftMouseButton=true;
			RightMouseButton = ((wParam & MK_RBUTTON)!=0);              // key flags 
			if (RightMouseButton)
				RightMouseButton=true;
			break;;				// Jump Back
		}
		case WM_RBUTTONDOWN:
		{
			RightMouseButton = true;			// If So, Mark It As TRUE		
			break;				// Jump Back
		}
		case WM_RBUTTONUP:	
		{
			RightMouseButton = false;			// If So, Mark It As TRUE		
			break;				// Jump Back
		}
		case WM_LBUTTONDOWN:
		{
			LeftMouseButton = true;			// If So, Mark It As TRUE		
			break;				// Jump Back
		}
		case WM_LBUTTONUP:	
		{
			LeftMouseButton = false;			// If So, Mark It As TRUE		
			break;				// Jump Back
		}
		case WM_MOUSEWHEEL:
		{

			speed += (short) HIWORD(wParam) / 60;   
			if (speed<0)
				speed=0;
			break;
		}
		case WM_KEYDOWN:				// Is A Key Being Held Down?		
		{
			keys[wParam] = TRUE;			// If So, Mark It As TRUE		
			break;				// Jump Back
		}
		case WM_KEYUP:					// Has A Key Been Released?		
		{
			keys[wParam] = FALSE;			// If So, Mark It As FALSE
			break;				// Jump Back		
		}
		case WM_SIZE:					// Resize The OpenGL Window		
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
			return 0;				// Jump Back		
		}	
		case WM_COMMAND:
		{
		}

		
	}

	Event* myEvent=new Event(uMsg,wParam, lParam);
	MessageManager::handleOSMessages(myEvent);
	return (LRESULT)0;
	//return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
Example #10
0
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
    GLuint		PixelFormat;
    WNDCLASS	wc;
    DWORD		dwExStyle;
    DWORD		dwStyle;
    RECT		WindowRect;
    WindowRect.left=(long)0;
    WindowRect.right=(long)width;
    WindowRect.top=(long)0;
    WindowRect.bottom=(long)height;

    fullscreen=fullscreenflag;

    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	= NULL;
    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)
    {
        DEVMODE dmScreenSettings;
        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;
    }

    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,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

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

    if (!InitGL())
    {
        KillGLWindow();
        MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    return TRUE;
}
Example #11
0
HWND GLWindow::CreateGLWindow(const char* title, int width, int height, int bits, bool full, WNDPROC MainWndProc)
{
	bool fullscreen=full;
	GLuint			PixelFormat, xStart,yStart;
	HINSTANCE		hInstance;
	WNDCLASS		wc;
	DWORD			dwExStyle;
	DWORD			dwStyle;
	hInstance		= GetModuleHandle(NULL);		// Grab An Instance For Our Window
	wc.style		= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;	// Redraw On Size, And Own DC For Window
	wc.lpfnWndProc		= (WNDPROC) MainWndProc;			// WndProc Handles Messages
	wc.cbClsExtra		= 0;					// No Extra Window Data
	wc.cbWndExtra		= 0;					// No Extra Window Data
	wc.hInstance		= hInstance;				// Set The Instance
    wc.hIcon = LoadIcon( hInstance, MAKEINTRESOURCE(IDI_MAIN_ICON));
//	wc.hIconSm= LoadIcon( hInstance, MAKEINTRESOURCE(IDI_MAIN_ICON)); 
    wc.hCursor = LoadCursor(hInstance, MAKEINTRESOURCE(IDC_CURSOR1) );
	wc.hbrBackground	= CreateSolidBrush(COLOR_BACKGROUND);					// No Background Required For GL
	wc.lpszMenuName		= 0;//MAKEINTRESOURCE(IDR_MENU1);
	wc.lpszClassName	= "OpenGL";				// Set The Class Name

	if (!RegisterClass(&wc))
	{
		MessageBox(NULL, "Failed to Register the WindowClass","SHUTDOWN ERROR", MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		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 FullScreenMode is not supported by\nYour VideoCard. Use windowed Mode instead?","eclipse GLwin", 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 | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
		ShowCursor(FALSE);
		xStart=0;yStart=0;
	}
	else
	{
		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle		= WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
		xStart=64;yStart=64;
	}
	int cx = width+GetSystemMetrics(SM_CXSIZEFRAME)*(fullscreen ? 0:2);
	int cy = height+GetSystemMetrics(SM_CYSIZEFRAME)*(fullscreen ? 0:2) + GetSystemMetrics(SM_CYCAPTION) * (fullscreen ? 0:1);

	if (!(hWnd=CreateWindowEx(	dwExStyle,
								"OpenGL",
								title,
								dwStyle,
								xStart,yStart, cx, cy,
								NULL,
								NULL,
								hInstance,
								NULL)))
	{
		KillGLWindow();
		MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		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 DeviceContext.","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,"Can't activate the GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ReSizeGLScene(width, height);
	if (!InitGL())
	{
		KillGLWindow();
		MessageBox(NULL,"Can't initialize GL Scene.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	SetCursorPos(320,240);
	return hWnd;
}
Example #12
0
int main()
{
    // Create the main window
    sf::Window App(sf::VideoMode(800, 600, 32), "SFML/NeHe OpenGL");

    InitGL();
    ReSizeGLScene(800, 600);

    // Start game loop
    while (App.IsOpened())
    {
        // Process events
        sf::Event Event;
        while (App.GetEvent(Event))
        {
            // Close window : exit
            if (Event.Type == sf::Event::Closed)
                App.Close();

            // Resize event : adjust viewport
            if (Event.Type == sf::Event::Resized)
                ReSizeGLScene(Event.Size.Width, Event.Size.Height);

            // Handle Keyboard Events
            if (Event.Type == sf::Event::KeyPressed) {
                switch (Event.Key.Code) {
                    case sf::Key::Escape:
                        App.Close();
                        break;
                    case sf::Key::F1:
                        fullscreen = !fullscreen;
                        App.Create(fullscreen ? sf::VideoMode::GetDesktopMode() : sf::VideoMode(800, 600, 32) , "SFML/NeHe OpenGL",
                        (fullscreen ? sf::Style::Fullscreen : sf::Style::Resize | sf::Style::Close));
                        ReSizeGLScene(App.GetWidth(),App.GetHeight());
                        break;
                    case sf::Key::F5:
                        vsync = !vsync;
                        break;
                    case sf::Key::L:
                        light=!light;
                        if (!light) {
                            glDisable(GL_LIGHTING);
                        } else {
                            glEnable(GL_LIGHTING);
                        }
                        break;
                    case sf::Key::F:
                        filter+=1;
                        if (filter>2) {
                            filter=0;
                        }
                        break;
                    case sf::Key::B:
                        blend = !blend;
                        if(blend) {
                            glEnable(GL_BLEND);			// Turn Blending On
                            glDisable(GL_DEPTH_TEST);	// Turn Depth Testing Off
                        } else {
                            glDisable(GL_BLEND);		// Turn Blending Off
                            glEnable(GL_DEPTH_TEST);	// Turn Depth Testing On
                        }
                        break;
                    default:
                        break;
                }
            }
        }

        //Handle movement keys
        const sf::Input& Input = App.GetInput();

        if (Input.IsKeyDown(sf::Key::PageUp)) {
            z-=0.02f;
        }
        if (Input.IsKeyDown(sf::Key::PageDown)) {
            z+=0.02f;
        }
        if (Input.IsKeyDown(sf::Key::Up)) {
            xspeed-=0.01f;
        }
        if (Input.IsKeyDown(sf::Key::Down)) {
            xspeed+=0.01f;
        }
        if (Input.IsKeyDown(sf::Key::Right)) {
            yspeed+=0.01f;
        }
        if (Input.IsKeyDown(sf::Key::Left)) {
            yspeed-=0.01f;
        }

        // Turn VSYNC on so that animations run at a more reasonable speed on new CPU's/GPU's.
        App.UseVerticalSync(vsync);

        // Set the active window before using OpenGL commands
        // It's useless here because active window is always the same,
        // but don't forget it if you use multiple windows or controls
        App.SetActive();

        //Draw some pretty stuff
        DrawGLScene();

        // Finally, display rendered frame on screen
        App.Display();
    }

    return EXIT_SUCCESS;
}
LRESULT CALLBACK WndProc(	HWND	hWnd,			// Handle For This Window
							UINT	uMsg,			// Message For This Window
							WPARAM	wParam,			// Additional Message Information
							LPARAM	lParam)			// Additional Message Information
{
	switch (uMsg)									// Check For Windows Messages
	{
		case WM_ACTIVATE:							// Watch For Window Activate Message
		{
			if (!HIWORD(wParam))					// Check Minimization State
			{
				active=TRUE;						// Program Is Active
			}
			else
			{
				active=FALSE;						// Program Is No Longer Active
			}

			return 0;								// Return To The Message Loop
		}

		case WM_SYSCOMMAND:							// Intercept System Commands
		{
			switch (wParam)							// Check System Calls
			{
				case SC_MAXIMIZE:
				break;

				case SC_RESTORE:
				break;

				case SC_MINIMIZE:
				break;

				case SC_SCREENSAVE:					// Screensaver Trying To Start?
				case SC_MONITORPOWER:				// Monitor Trying To Enter Powersave?
				return 0;							// Prevent From Happening
				
			}
			break;									// Exit
		}

		case WM_CLOSE:								// Did We Receive A Close Message?
		{
			PostQuitMessage(0);						// Send A Quit Message
			return 0;								// Jump Back
		}

		case WM_KEYDOWN:							// Is A Key Being Held Down?
		{
			// auxillary handle keyboard
			// use the keys interface instead
			// this is for special functions
			switch(wParam)
			{

				case VK_TAB:
					ToggleViewMode();
				break;

				case VK_DOWN:
					Toggle_MenuItems(1);
				break;

				case VK_UP:
					Toggle_MenuItems(-1);
				break;

				case VK_RETURN:
				case VK_SPACE:

					// check for the current 
					if (Set_MenuMode())
					{
						ShowCursor(TRUE);
						done = true;
						return 0;
					} // end of the if 

					if (ant_globals->menu_mode == MENU_HELP_MODE)
					{
						ShowCursor(TRUE);
					} // end of the if 
					else if (ant_globals->menu_mode == MENU_RUN_MODE)
					{
						ShowCursor(FALSE);
					} // end of if - else
						
				break;

				case VK_ESCAPE:

					// Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
					if (active)	// Active?  Was There A Quit Received?
					{
						if (ant_globals->menu_mode == MENU_TITLE_MODE) {

							if (ant_globals->_menu_state == FIRST_TIME_TRUE)
								done = TRUE;
							else {

								// put back in run mode
								ant_globals->paused = 0;
								ant_globals->menu_mode = MENU_RUN_MODE;
								ShowCursor(FALSE);

							} // end of if

						} else if (ant_globals->menu_mode 
								== MENU_HELP_MODE) {
							ant_globals->paused = 1;
							ant_globals->menu_mode = MENU_TITLE_MODE;

							ShowCursor(TRUE);

						} else {

							//done=TRUE;							// ESC or DrawGLScene Signalled A Quit
							ant_globals->paused = 1;
							ant_globals->menu_mode = MENU_TITLE_MODE;

							ShowCursor(TRUE);
						} // end of if-else

					} // end of the if 

				break;

				case 'P':

					if (ant_globals->menu_mode == MENU_RUN_MODE) {
						TogglePaused();
					} // end of the if 


				break;

				case 'Q':
					
					done = TRUE;

				break;

				default:break;
			};

			keys[wParam] = TRUE;					// If So, Mark It As TRUE
			return 0;								// Jump Back
		}

		case WM_KEYUP:								// Has A Key Been Released?
		{
			keys[wParam] = FALSE;					// If So, Mark It As FALSE
			return 0;								// Jump Back
		}

		case WM_SIZE:								// Resize The OpenGL Window
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
			return 0;								// Jump Back
		}
	}

	// Pass All Unhandled Messages To DefWindowProc
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
Example #14
0
LRESULT CALLBACK WndProc(	HWND	hWnd,			// Handle For This Window
							UINT	uMsg,			// Message For This Window
							WPARAM	wParam,			// Additional Message Information
							LPARAM	lParam)			// Additional Message Information
{
	switch (uMsg)									// Check For Windows Messages
	{
		case WM_ACTIVATE:							// Watch For Window Activate Message
		{
			if (!HIWORD(wParam))					// Check Minimization State
			{
				active=TRUE;						// Program Is Active
			}
			else
			{
				active=FALSE;						// Program Is No Longer Active
			}

			return 0;								// Return To The Message Loop
		}

		case WM_SYSCOMMAND:							// Intercept System Commands
		{
			switch (wParam)							// Check System Calls
			{
				case SC_SCREENSAVE:					// Screensaver Trying To Start?
				case SC_MONITORPOWER:				// Monitor Trying To Enter Powersave?
				return 0;							// Prevent From Happening
			}
			break;									// Exit
		}

		case WM_CLOSE:								// Did We Receive A Close Message?
		{
			PostQuitMessage(0);						// Send A Quit Message
			return 0;								// Jump Back
		}

		case WM_KEYDOWN:							// Is A Key Being Held Down?
		{
			if(wParam<256 )
				keys[wParam]=true;
			if(activeController){
				activeController->KeyPressed(wParam,!!(lParam & (1<<30)));
			}
			return 0;
		}				
		case WM_CHAR:							// Is A Key Being Held Down?
		{
			#ifdef NEW_GUI
				GUIcontroller::Character(char(wParam));
				return 0;
			#endif
			if(activeController){
				if(activeController->userWriting && (wParam>31))
					if(activeController->ignoreNextChar || activeController->ignoreChar==char(wParam))
						activeController->ignoreNextChar=false;
					else
						if(wParam>31 && wParam<250)
							activeController->userInput+=char(wParam);
			}
			return 0;
		}				
		case WM_KEYUP:								// Has A Key Been Released?
		{
			if(activeController){
				activeController->KeyReleased(wParam);
			}
			if(wParam<256)
				keys[wParam]=false;
			return 0;				
		}
		case WM_SYSKEYDOWN:							// Is A Key Being Held Down?
		{
			if(wParam<256)
				keys[wParam]=true;
			if ( activeController )
			{
				activeController->KeyPressed(wParam, !!(lParam & (1<<30)));
			}
			return 0;
		}
		case WM_SYSKEYUP:								// Has A Key Been Released?
		{
			if(wParam<256)
				keys[wParam]=false;
			if ( activeController )
			{
				activeController->KeyReleased(wParam);
			}
			return 0;				
		}

		case WM_SIZE:								// Resize The OpenGL Window
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
			return 0;								// Jump Back
		}
		case WM_MOUSEMOVE:
		{
			if ( fullscreen )
			{
				RECT WindowBounds;
				GetClientRect(hWnd, &WindowBounds);
				ClipCursor(&WindowBounds);
			}
			if(mouse)
				mouse->MouseMove(LOWORD(lParam),HIWORD(lParam));
			return 0;
		}
		case WM_RBUTTONDOWN:
		{
			if(mouse)
				mouse->MousePress(LOWORD(lParam),HIWORD(lParam),1);
			return 0;
		}
		case WM_RBUTTONUP:
		{
			if(mouse)
				mouse->MouseRelease(LOWORD(lParam),HIWORD(lParam),1);
			return 0;
		}
		case WM_LBUTTONDOWN:
		{
			if(mouse)
				mouse->MousePress(LOWORD(lParam),HIWORD(lParam),0);
			return 0;
		}
		case WM_LBUTTONUP:
		{
			if(mouse)
				mouse->MouseRelease(LOWORD(lParam),HIWORD(lParam),0);
			return 0;
		}
		case 522: //WM_MOUSEWHEEL:
		{
			if(mouse){
				float move;
				move=((short) HIWORD(wParam));    // wheel rotation
				mouse->currentCamController->MouseWheelMove(move);
			}
			return 0;
		}
		case WM_MBUTTONDOWN:
		{
			if(mouse)
				mouse->MousePress(LOWORD(lParam),HIWORD(lParam),2);
			return 0;
		}
		case WM_MBUTTONUP:
		{
			if(mouse)
				mouse->MouseRelease(LOWORD(lParam),HIWORD(lParam),2);
			return 0;
		}
		case 523: //Mouse key4?:
		{
			if(mouse)
				mouse->MousePress(mouse->lastx,mouse->lasty,3+HIWORD(wParam));
			return 0;
		}
	}
//	if(info)
//		info->AddLine("msg %i %i",uMsg,HIWORD(wParam));
	// Pass All Unhandled Messages To DefWindowProc
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
Example #15
0
LRESULT CALLBACK WndProc(	HWND	hWnd,			// Handle For This Window
							UINT	uMsg,			// Message For This Window
							WPARAM	wParam,			// Additional Message Information
							LPARAM	lParam)			// Additional Message Information
{
	switch (uMsg)									// Check For Windows Messages
	{
		case WM_ACTIVATE:							// Watch For Window Activate Message
		{
			if (!HIWORD(wParam))					// Check Minimization State
			{
				active=TRUE;						// Program Is Active
			}
			else
			{
				active=FALSE;						// Program Is No Longer Active
			}

			return 0;								// Return To The Message Loop
		}

		case WM_SYSCOMMAND:							// Intercept System Commands
		{
			switch (wParam)							// Check System Calls
			{
				case SC_SCREENSAVE:					// Screensaver Trying To Start?
				case SC_MONITORPOWER:				// Monitor Trying To Enter Powersave?
				return 0;							// Prevent From Happening
			}
			break;									// Exit
		}
        case WM_KEYDOWN:
            if ( wParam == 0x31 )
                gizmo = gizmoMove;
            else if ( wParam==0x32 )
                gizmo = gizmoRotate;
            else if ( wParam==0x33 )
                gizmo = gizmoScale;

            gizmo->SetEditMatrix( objectMatrix );
            gizmo->SetScreenDimension( screenWidth, screenHeight );
            gizmo->SetLocation( IGizmo::LOCATE_VIEW );
            break;
		case WM_CLOSE:								// Did We Receive A Close Message?
		{
			PostQuitMessage(0);						// Send A Quit Message
			return 0;								// Jump Back
		}
        case WM_MOUSEMOVE:
            {
                mousex = LOWORD(lParam);
                mousey = HIWORD(lParam);
                if (gizmo)
                    gizmo->OnMouseMove( mousex, mousey );
                return 0;
            }
        case WM_LBUTTONDOWN:
            mbMouseDown = true;
            if (gizmo)
                if (gizmo->OnMouseDown( mousex, mousey ))
                    SetCapture( hWnd );
            break;
        case WM_LBUTTONUP:
            ReleaseCapture();
            mbMouseDown = false;
                if (gizmo)
                    gizmo->OnMouseUp( mousex, mousey );
            break;


		case WM_SIZE:								// Resize The OpenGL Window
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
			return 0;								// Jump Back
		}
	}

	// Pass All Unhandled Messages To DefWindowProc
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
Example #16
0
LRESULT CALLBACK WndProc(	HWND	hWnd,
				UINT	message,
				WPARAM	wParam,
				LPARAM	lParam)
{
	RECT	Screen;							// Used Later On To Get The Size Of The Window
	GLuint	PixelFormat;
	static	PIXELFORMATDESCRIPTOR pfd=
	{
		sizeof(PIXELFORMATDESCRIPTOR),		// Size Of This Pixel Format Descriptor
		1,									// Version Number (?)
		PFD_DRAW_TO_WINDOW |				// Format Must Support Window
		PFD_SUPPORT_OPENGL |				// Format Must Support OpenGL
		PFD_DOUBLEBUFFER,					// Must Support Double Buffering
		PFD_TYPE_RGBA,						// Request An RGBA Format
		16,									// Select A 16Bit Color Depth
		0, 0, 0, 0, 0, 0,					// Color Bits Ignored (?)
		0,									// No Alpha Buffer
		0,									// Shift Bit Ignored (?)
		0,									// No Accumulation Buffer
		0, 0, 0, 0,							// Accumulation Bits Ignored (?)
		16,									// 16Bit Z-Buffer (Depth Buffer)  
		0,									// No Stencil Buffer
		0,									// No Auxiliary Buffer (?)
		PFD_MAIN_PLANE,						// Main Drawing Layer
		0,									// Reserved (?)
		0, 0, 0								// Layer Masks Ignored (?)
	};

	switch (message)						// Tells Windows We Want To Check The Message
	{
		case WM_CREATE:
			hDC = GetDC(hWnd);				// Gets A Device Context For The Window
			PixelFormat = ChoosePixelFormat(hDC, &pfd);		// Finds The Closest Match To The Pixel Format We Set Above

			if (!PixelFormat)
			{
				MessageBox(0,"Can't Find A Suitable PixelFormat.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);			// This Sends A 'Message' Telling The Program To Quit
				break;						// Prevents The Rest Of The Code From Running
			}

			if(!SetPixelFormat(hDC,PixelFormat,&pfd))
			{
				MessageBox(0,"Can't Set The PixelFormat.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);
				break;
			}

			hRC = wglCreateContext(hDC);
			if(!hRC)
			{
				MessageBox(0,"Can't Create A GL Rendering Context.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);
				break;
			}

			if(!wglMakeCurrent(hDC, hRC))
			{
				MessageBox(0,"Can't activate GLRC.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);
				break;
			}

			GetClientRect(hWnd, &Screen);
			InitGL(Screen.right, Screen.bottom);
			break;

		case WM_DESTROY:
		case WM_CLOSE:
			ChangeDisplaySettings(NULL, 0);

			wglMakeCurrent(hDC,NULL);
			wglDeleteContext(hRC);
			ReleaseDC(hWnd,hDC);

			PostQuitMessage(0);
			break;

		case WM_KEYDOWN:
			keys[wParam] = TRUE;
			break;

		case WM_KEYUP:
			keys[wParam] = FALSE;
			break;

		case WM_SIZE:
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
			break;

		default:
			return (DefWindowProc(hWnd, message, wParam, lParam));
	}
return (0);
}
Example #17
0
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	GLuint	PixelFormat;
	static	PIXELFORMATDESCRIPTOR pfd = 
	{
		sizeof(PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER, 
		PFD_TYPE_RGBA, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
	};
	switch (message)
	{
	case WM_CREATE:
		hDC = GetDC(hWnd);
		PixelFormat = ChoosePixelFormat(hDC, &pfd);
		if (!PixelFormat){
			MessageBox(0, "Can't Find A SuitablePixelFormat.", "Error", MB_OK|MB_ICONERROR);
			PostQuitMessage(0);
			break;
		}
		if(!SetPixelFormat(hDC, PixelFormat, &pfd)){
			MessageBox(0, "Can't Set ThePixelFormat.", "Error", MB_OK|MB_ICONERROR);
			PostQuitMessage(0);
			break;
		}
		hRC = wglCreateContext(hDC);
		if(!hRC){
			MessageBox(0, "Can't Create A GLRenderingContext.", "Error", MB_OK|MB_ICONERROR);
			PostQuitMessage(0);
			break;
		}
		if(!wglMakeCurrent(hDC, hRC)){
			MessageBox(0, "Can't activate GLRC.", "Error", MB_OK|MB_ICONERROR);
			PostQuitMessage(0);
			break;
		}
		GetClientRect(hWnd, &Screen);
		ratio = (float) Screen.bottom / Screen.right;
		InitGL(Screen.right, Screen.bottom);
		break;
	case WM_DESTROY:
	case WM_CLOSE:
		ChangeDisplaySettings(NULL, 0);
		wglMakeCurrent(hDC, NULL);
		wglDeleteContext(hRC);
		ReleaseDC(hWnd, hDC);
		PostQuitMessage(0);
		break;
	case WM_KEYDOWN:		
		switch((int)wParam){
		case VK_ESCAPE:
			SendMessage(hWnd, WM_CLOSE, 0, 0);
			break;
		case VK_UP:
			if(approximation > 0.6) approximation -= .1;
			flag = 0;
			l = 0;
			break;
		case VK_DOWN:
			if(approximation < 4) approximation += .1;
			flag = 0;
			l = 0;
			break;
		case VK_RIGHT:
			angle += 5;
			if(angle > 360) angle = 5;
			flag = 0;
			l = 0;
			break;
		case VK_LEFT:
			angle -= 5;
			if(angle < 0) angle = 355;
			flag = 0;
			l = 0;
			break;
		case 'A':
			l += .05;
			flag = 1;
			angle = 0;
			approximation = 1.5;
			break;
		case 'D':
			l -= .05;
			flag = 1;
			angle = 0;
			approximation = 1.5;
			break;
		case 'Q':
			turn -= 5;
			break;
		case 'E':
			turn += 5;
			break;
		}
		break;
	case WM_SIZE:
		GetClientRect(hWnd, &Screen);
		ratio = (float) Screen.bottom / Screen.right;
		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
		break;
	default:
		return (DefWindowProc(hWnd, message, wParam, lParam));
	}
	return (0);
}
Example #18
0
LRESULT CALLBACK WndProc(  HWND  hWnd,            // Дескриптор нужного окна

                           UINT  uMsg,            // Сообщение для этого окна

                           WPARAM  wParam,            // Дополнительная информация

                           LPARAM  lParam)            // Дополнительная информация

{


    switch (uMsg)                // Проверка сообщения для окна

    {

        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:              // Мы получили сообщение о закрытие?

        {

            PostQuitMessage( 0 );          // Отправить сообщение о выходе

            return 0;            // Вернуться назад

        }

        case WM_KEYDOWN:            // Была ли нажата кнопка?

        {

            keys[wParam] = TRUE;          // Если так, мы присваиваем этой ячейке true

            return 0;            // Возвращаемся

        }


        case WM_KEYUP:              // Была ли отпущена клавиша?

        {

            keys[wParam] = FALSE;          //  Если так, мы присваиваем этой ячейке false

            return 0;            // Возвращаемся

        }


        case WM_SIZE:              // Изменены размеры OpenGL окна

        {

            ReSizeGLScene( LOWORD(lParam), HIWORD(lParam) );  // Младшее слово=Width, старшее слово=Height

            return 0;            // Возвращаемся

        }

    }


    // пересылаем все необработанные сообщения DefWindowProc

    return DefWindowProc( hWnd, uMsg, wParam, lParam );

}
Example #19
0
LRESULT CALLBACK WndProc(	HWND	hWnd,			// 窗口的句柄
                            UINT	uMsg,			// 窗口的消息
                            WPARAM	wParam,			// 附加的消息内容
                            LPARAM	lParam)			// 附加的消息内容
{
    switch (uMsg)									// 检查Windows消息
    {
    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:								// 收到Close消息?
    {
        PostQuitMessage(0);						// 发出退出消息
        return 0;								// 返回
    }

    case WM_KEYDOWN:							// 有键按下么?
    {

        keys[wParam] = TRUE;					// 如果是,设为TRUE
        return 0;								// 返回
    }

    case WM_KEYUP:								// 有键放开么?
    {
        keys[wParam] = FALSE;					// 如果是,设为FALSE
        return 0;								// 返回
    }

    case WM_SIZE:								// 调整OpenGL窗口大小
    {
        ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width,HiWord=Height
        return 0;								// 返回
    }
    case WM_CHAR:
    {
        InputEngine::Instance()->addEvent(wParam);
    }
    break;
    case WM_LBUTTONUP:
    {
        int y = (lParam >> 16) & 0xFFFF;
        int x = lParam & 0xFFFF;
        InputEngine::Instance()->addEvent(Touch_End, x, y);
    }
    break;
    case WM_LBUTTONDOWN:
    {
        int y = (lParam >> 16) & 0xFFFF;
        int x = lParam & 0xFFFF;
        InputEngine::Instance()->addEvent(Touch_Down, x, y);
    }
    break;
    }

    // 向 DefWindowProc传递所有未处理的消息。
    return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
Example #20
0
int init(struct winampVisModule *this_mod)
{
	//config_read(this_mod);

	/* ----------------------------------------------------Register our window class-----------------------------------*/
	/* ----------------------------------------------------------------------------------------------------------------*/

	GLuint PixelFormat;																		// Speichert das Pixelformat
	WNDCLASS wc;																			// wc wird eine Instanz der Fensterklasse
	DWORD dwExStyle;																		// weitere Informationen
	DWORD dwStyle;																			// Fensterinformationen
	RECT WindowRect;																		// Speicher für aktuelle Auflösung
	WindowRect.left=(long)0;																// Die linke Seite des Rechtecks wirtd auf 0 gesetzt
	WindowRect.right=(long)width;															// Hier wird die gewünschte Breite des Fensters gespeichert
	WindowRect.top=(long)0; 																// Die obere Seite wird auch auf 0 gesetzt
	WindowRect.bottom=(long)height;															// Und hier wird die Höhe abgelegt 
	hInstance = this_mod->hDllInstance; 
	memset(&wc,0,sizeof(wc));
	wc.lpfnWndProc = (WNDPROC) WndProc;
	wc.hInstance = this_mod->hDllInstance;													// hInstance of DLL
	wc.lpszClassName = szAppName;															// our window class name
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);												// Lädt einen Cursor
	wc.lpszMenuName = NULL;																	// Auch ein Menü wird nicht benötigt.
	//if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", 
	//	"Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
	//{
		fullscreen=FALSE;																	// Windowed Mode
	//}

	if (!RegisterClass(&wc)) 
	{
		MessageBox(	NULL,"Can't register window class.","ERROR",
					MB_OK|MB_ICONEXCLAMATION);
		return 1;
	}
	if (fullscreen)																			// Soll im Vollbildmodus gestartet werden
	{
		DEVMODE dmScreenSettings;															// Instanz von DEVMODE wird erzeugt
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));								// Diese wird geleert
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);									// dmsize soll genauso groß wie die dmScreenSettings sein
		dmScreenSettings.dmPelsWidth = width; 
		dmScreenSettings.dmPelsHeight = height;
		dmScreenSettings.dmBitsPerPel = 32; 
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;											
		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)
								!=DISP_CHANGE_SUCCESSFUL)    
		{
			if (MessageBox(NULL,"Fullscreen device not available , Do you want to start in a windowed mode?",
				"Problem",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
				fullscreen=FALSE; 
			}

			else
			{
				return FALSE;
			}
		}
	}
	if (fullscreen) 
	{
		dwExStyle=WS_EX_APPWINDOW;															// Fenstereigenschaften
		dwStyle=WS_POPUP; 
		ShowCursor(FALSE);																	// Der Mauszeiger wird nicht angezeigt
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;										// Das Fenster soll zusätzlich einen 3D Rahmen bekommen
		dwStyle=WS_OVERLAPPEDWINDOW;														// Ein typisches Windowsfenster mit Minimieren, Maximieren, etc
	}
	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);								// Fenster wird angepasst
	hMainWnd = CreateWindowEx(dwExStyle,													// these exstyles put a nice small frame, but also a button in the taskbar
		szAppName,																			// our window class name
		this_mod->description,																// use description for a window title
		WS_CLIPSIBLINGS |																	// Wird von OpenGL benötigt
		WS_CLIPCHILDREN |																	// Wird auch von OpenGL benötigt
		dwStyle,
		0,0,																				// screen position (read from config)
		WindowRect.right-WindowRect.left,													// Hier werden die ermittelten Werte für die Breite eingesetzt
		WindowRect.bottom-WindowRect.top,													// und hier für die Länge
		this_mod->hwndParent,																// parent window (winamp main window)
		NULL,																				// no menu
		this_mod->hDllInstance,																// hInstance of DLL
		0);																					// no window creation data
	if (!hMainWnd) 
	{
		MessageBox(this_mod->hwndParent,"Error creating window","ERROR",MB_OK);
		return 1;
	}
	static PIXELFORMATDESCRIPTOR pfd=														// pdf ist jetzt ein PIXELFORMATDESCRIPTOR
	{
		sizeof(PIXELFORMATDESCRIPTOR), 
		1,																					// Versionsnummer
		PFD_DRAW_TO_WINDOW |																// Das Format muss in Fenster sichtbar sein können
		PFD_SUPPORT_OPENGL |																// OpenGL muss unterstützt werden
		PFD_DOUBLEBUFFER,																	// Double Buffering muss unterstützt werden
		PFD_TYPE_RGBA,																		// Das RGBA (Rot,Grün,Blau,Alpha(Transparenz)) muss unterstützt werden
		32,																					// Die Farbtiefe, die schon übergeben wurde, wird hier benötigt
		0, 0, 0, 0, 0, 0,																	// wird nicht benötigt
		0,																					// kein Alpha Buffer
		0,																					// Shift Bit ignoriert
		0,																					// kein Accumulation Buffer
		0, 0, 0, 0,																			// nicht benötigt
		32,																					// 16Bit Z-Buffer (Depth Buffer)
		0,																					// kein Stencil Buffer
		0,																					// kein Auxiliary Buffer
		PFD_MAIN_PLANE,																		// Die Hauptebene auf die später gezeichnet wird
		0,																					// unwichtig
		0, 0, 0																				// keine Ebenenmasken benötigt
	};
	if (!(hDC=GetDC(hMainWnd)))																// Versuch, den DC zu bekommen
	{
		KillGLWindow(this_mod);																// Alles rückgängig machen

		MessageBox(	NULL,"NO dc available.","ERROR",
					MB_OK|MB_ICONEXCLAMATION);
		return FALSE;																		// FALSE zurückgeben, beenden
	}
	if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))											// Kann Windows ein passendes finden? 
	{ 
		KillGLWindow(this_mod);																// Alles zurücksetzen
		MessageBox(	NULL,"Can't find pixelformat.","ERROR",
					MB_OK|MB_ICONEXCLAMATION);
		return FALSE;																		// FALSE zurück und Ende.
	}
	if(!SetPixelFormat(hDC,PixelFormat,&pfd))
    {
		KillGLWindow(this_mod);																// Leider nicht, Fehlerpopup und raus
		MessageBox(	NULL,"Can't use pixelformat.",
					"ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;																		// FALSE zurück und raus
	}
	if (!(hRC=wglCreateContext(hDC)))														// Versuch den RC zu bekommen
    {
		KillGLWindow(this_mod);																// Alles rückgängig machen
		MessageBox(	NULL,"Can't get rendering context.","ERROR",
					MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	if(!wglMakeCurrent(hDC,hRC))															// Versuch den RC zu aktivieren
	{
		KillGLWindow(this_mod);																// hat nicht geklappt, also alles zurück
		MessageBox(	NULL,"Can't activate rendering context.","ERROR",
					MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	ShowWindow(hMainWnd,SW_SHOW);															// Fenster anzeigen
	SetForegroundWindow(hMainWnd);															// Priorität des Programms wird erhöht
	SetFocus(hMainWnd);																		// Tastatureingaben werden jetzt an das Programm geleitet
	ReSizeGLScene(width, height);															// Die Perspektive wird aktiviert 
	
	SetTimer(hMainWnd , FPS_TIMER, FPS_INTERVAL, NULL);

	myinit();
	initializeSpheres();

	return 0;								
}
Example #21
0
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
    unsigned int		PixelFormat;			// 保存查找匹配的结果
    WNDCLASS	wc;						// 窗口类结构
    DWORD		dwExStyle;				// 扩展窗口风格
    DWORD		dwStyle;				// 窗口风格
    RECT		WindowRect;				// 取得矩形的左上角和右下角的坐标值
    WindowRect.left=(long)0;			// 将Left   设为 0
    WindowRect.right=(long)width;		// 将Right  设为要求的宽度
    WindowRect.top=(long)0;				// 将Top    设为 0
    WindowRect.bottom=(long)height;		// 将Bottom 设为要求的高度

    fullscreen=fullscreenflag;			// 设置全局全屏标志

    hInstance			= GetModuleHandle(NULL);				// 取得我们窗口的实例
    wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;	// 移动时重画,并为窗口取得DC
    wc.lpfnWndProc		= (WNDPROC) 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	= NULL;									// GL不需要背景
    wc.lpszMenuName		= NULL;									// 不需要菜单
    wc.lpszClassName	= "OpenG";								// 设定类名字

    if (!RegisterClass(&wc))									// 尝试注册窗口类
    {
        MessageBox(NULL,"注册窗口失败","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;											// 退出并返回FALSE
    }

    if (fullscreen)												// 要尝试全屏模式吗?
    {
        DEVMODE dmScreenSettings;								// 设备模式
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));	// 确保内存清空为零
        dmScreenSettings.dmSize=sizeof(dmScreenSettings);		// Devmode 结构的大小
        dmScreenSettings.dmPelsWidth	= width;				// 所选屏幕宽度
        dmScreenSettings.dmPelsHeight	= height;				// 所选屏幕高度
        dmScreenSettings.dmBitsPerPel	= bits;					// 每象素所选的色彩深度
        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

        // 尝试设置显示模式并返回结果。注: CDS_FULLSCREEN 移去了状态条
        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
        {
            // 若模式失败,提供两个选项:退出或在窗口内运行。
            if (MessageBox(NULL,"全屏模式在当前显卡上设置失败!\n使用窗口模式?","NeHe G",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
            {
                //如果用户选择窗口模式,变量fullscreen 的值变为FALSE,程序继续运行
                fullscreen=FALSE;		// 选择窗口模式(Fullscreen=FALSE)
            }
            else
            {
                //如果用户选择退出,弹出消息窗口告知用户程序将结束。并返回FALSE告诉程序窗口未能成功创建。程序退出。
                MessageBox(NULL,"程序将被关闭","错误",MB_OK|MB_ICONSTOP);
                return FALSE;									// 退出并返回 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);		// 调整窗口达到真正要求的大小

    // 创建窗口
    if (!(hWnd=CreateWindowEx(	dwExStyle,							// 扩展窗体风格
                                "OpenG",							// 类名字
                                title,								// 窗口标题
                                dwStyle |							// 必须的窗体风格属性
                                WS_CLIPSIBLINGS |					// 必须的窗体风格属性
                                WS_CLIPCHILDREN,					// 必须的窗体风格属性
                                0, 0,								// 窗口位置
                                WindowRect.right-WindowRect.left,	// 计算调整好的窗口宽度
                                WindowRect.bottom-WindowRect.top,	// 计算调整好的窗口高度
                                NULL,								// 无父窗口
                                NULL,								// 无菜单
                                hInstance,							// 实例
                                NULL)))								// 不向WM_CREATE传递任何东东
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"窗口创建错误","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    static	PIXELFORMATDESCRIPTOR pfd=				//pfd 告诉窗口我们所希望的东东,即窗口使用的像素格式
    {
        sizeof(PIXELFORMATDESCRIPTOR),				// 上述格式描述符的大小
        1,											// 版本号
        PFD_DRAW_TO_WINDOW |						// 格式支持窗口
        PFD_SUPPORT_OPENGL |						// 格式必须支持OpenGL
        PFD_DOUBLEBUFFER,							// 必须支持双缓冲
        PFD_TYPE_RGBA,								// 申请 RGBA 格式
        bits,										// 选定色彩深度
        0, 0, 0, 0, 0, 0,							// 忽略的色彩位
        0,											// 无Alpha缓存
        0,											// 忽略Shift Bit
        0,											// 无累加缓存
        0, 0, 0, 0,									// 忽略聚集位
        16,											// 16位 Z-缓存 (深度缓存)
        0,											// 无蒙板缓存
        0,											// 无辅助缓存
        PFD_MAIN_PLANE,								// 主绘图层
        0,											// 不使用重叠层
        0, 0, 0										// 忽略层遮罩
    };

    if (!(hDC=GetDC(hWnd)))							// 取得设备描述表了么?
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"不能创建一个窗口设备描述表","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))	// Windows 找到相应的象素格式了吗?
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"不能创建一种相匹配的像素格式","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    if(!SetPixelFormat(hDC,PixelFormat,&pfd))		// 能够设置象素格式么?
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"不能设置像素格式","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    if (!(hRC=wglCreateContext(hDC)))				// 能否取得OpenGL渲染描述表?
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"不能创建OpenGL渲染描述表","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    if(!wglMakeCurrent(hDC,hRC))					// 尝试激活着色描述表
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"不能激活当前的OpenGL渲然描述表","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    ShowWindow(hWnd,SW_SHOW);						// 显示窗口
    SetForegroundWindow(hWnd);						// 略略提高优先级
    SetFocus(hWnd);									// 设置键盘的焦点至此窗口
    ReSizeGLScene(width, height);					// 设置透视 GL 屏幕

    if (!Init())									// 初始化新建的GL窗口
    {
        KillGLWindow();								// 重置显示区
        MessageBox(NULL,"初始化失败","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;								// 返回 FALSE
    }

    return TRUE;									// 成功
}
int DrawGLScene(GLvoid)									// Here's Where We Do All The Drawing
{
	if(op || pp)
	{
		if(perspective == 0){
			glViewport(0,0,w_window,h_window);						// Reset The Current Viewport
			glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
			glLoadIdentity();									// Reset The Projection Matrix
			glOrtho(-10.0f, (w_window-10.0f)/80, -5.0f, (h_window-5.0f)/80, -60.0f,60.0f);				// Create Ortho 640x480 View (0,0 At Top Left)
			glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
			glLoadIdentity();									// Reset The Modelview Matrix
		}
		else{
			ReSizeGLScene(w_window, h_window);
		}
	}

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen And Depth Buffer

    if(wire == 1)
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	else
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	//draw front wheel
	glLoadIdentity();									// Reset The Current Modelview Matrix
	//glRotatef(rtri,0.0f,1.0f,0.0f);						// Rotate The Triangle On The Y axis ( NEW )

	int numOuter = 32;
	int numInner = 24;
	float innerRadius = 0.15f;
	float outerRadius = 0.8f;

	GLfloat sceneroty = 360.0f - yrot;
	GLfloat xtrans = -xpos;
	GLfloat ztrans = -zpos;
	GLfloat ytrans = -walkbias-0.25f;


	glTranslatef(0.0f, 0.0f, -10.0f);						// Move Right 1.5 Units And Into The Screen 7.0

 
	glTranslatef(xtrans, ytrans, ztrans);
	glRotatef(lookupdown,1.0f,0,0);
	glRotatef(sceneroty,0,1.0f,0);

//	glTranslatef(xtrans, ytrans, ztrans);
	glTranslatef(0.0f, 0.0f, zoom);

	glPushMatrix();
	glTranslatef(-4.5f, 0.0f, 0.0f);						// Move Right 1.5 Units And Into The Screen 7.0
	glColor3f(0.2f,0.2f,0.2f);							// Set The Color To Grey
	gldrawTorus(innerRadius, outerRadius, numInner, numOuter);

	glColor3f(0.8f,0.8f,0.8f);							// Set The Color To Grey
	gldrawTorus(innerRadius / 2, outerRadius - innerRadius, numInner, numOuter);

	gldrawFan(outerRadius - 1.5f*innerRadius, 15);
	glPopMatrix();
	
	//draw shaft
	glPushMatrix();
	glTranslatef(-4.5f, 0.0f, 0.2f);						
	glRotatef(180, 0.0f, 1.0f, 0.0f);					
	glColor3f(0.8f,0.8f,0.8f);							
	gluCylinder(quadratic,0.05f,0.05f,0.4f,32,32);		
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-4.5f, -0.05f, -0.2f);					
	glRotatef(-30, 0.0f, 0.0f, 1.0f);					
	glRotatef(270, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.8f,0.8f,0.8f);							
	gluCylinder(quadratic,0.05f,0.05f,1.3f,32,32);		
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-4.5f, -0.05f, 0.2f);					
	glRotatef(-30, 0.0f, 0.0f, 1.0f);					
	glRotatef(270, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.8f,0.8f,0.8f);							
	gluCylinder(quadratic,0.05f,0.05f,1.3f,32,32);		
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-4.5f, 0.0f, 0.0f);					
	glRotatef(18, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.9f, 0.8f, 0.2f);					
	glRotatef(180, 0.0f, 1.0f, 0.0f);				
	glColor3f(0.8f,0.8f,0.8f);						
	gluCylinder(quadratic,0.05f,0.05f,0.4f,32,32);	
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-4.5f, 0.0f, 0.0f);					
	glRotatef(12, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.85f, 0.85f, 0.0f);					
	glRotatef(-30, 0.0f, 0.0f, 1.0f);					
	glRotatef(270, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.5f,0.5f,0.5f);							
	gluCylinder(quadratic,0.1f,0.1f,1.5f,32,32);	
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-3.5f, 0.1f, 0.0f);				
	glColor3f(0.5f,0.5f,0.5f);							
	gldrawCurve(0.9f, 32, 1.5f, 1.0f);
	glPopMatrix();

	//draw handle bars
	glPushMatrix();
	glTranslatef(-4.7f, -0.4f, 0.0f);						
	glRotatef(-25, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.0f, 3.0f, 0.0f);						
	glRotatef(180, 0.0f, 1.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);							
	gluCylinder(quadratic,0.06f,0.06f,0.6f,32,32);		
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-4.7f, -0.4f, 0.6f);						
	glRotatef(-25, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.0f, 3.0f, 0.0f);						
	glRotatef(180, 0.0f, 1.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);							
	gluCylinder(quadratic,0.06f,0.06f,0.6f,32,32);		
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-3.45f, 2.3f, 0.6f);						
	glRotatef(-20, 0.0f, 0.0f, 1.0f);					
	glRotatef(270, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);							
	gluCylinder(quadratic,0.06f,0.06f,0.8f,32,32);		
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-3.45f, 2.3f, -0.6f);						
	glRotatef(-20, 0.0f, 0.0f, 1.0f);					
	glRotatef(270, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);							
	gluCylinder(quadratic,0.06f,0.06f,0.8f,32,32);		
	glPopMatrix();
	
	glPushMatrix();
	glTranslatef(-4.4f, 0.3f, 1.1f);						
	glRotatef(-25, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.0f, 3.0f, 0.0f);						
	glRotatef(180, 0.0f, 1.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);							
	gluCylinder(quadratic,0.08f,0.08f,0.6f,32,32);		

	gldrawCircle(0.08f);
	glPopMatrix();
	
	glPushMatrix();
	glTranslatef(-4.4f, 0.3f, -0.6f);						
	glRotatef(-25, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.0f, 3.0f, 0.0f);						
	glRotatef(180, 0.0f, 1.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);							
	gluCylinder(quadratic,0.08f,0.08f,0.6f,32,32);		

	gldrawCircle(0.08f);
	glPopMatrix();
	
	//draw cover of wheel
	glPushMatrix();
	glTranslatef(-4.5f, 0.1f, 0.0f);				
	gldrawCurve(0.6f, 32, 1.5, 5.0);
	glPopMatrix();

	//draw light
	glPushMatrix();
	glTranslatef(-4.5f, 0.0f, 0.0f);					
	glRotatef(-5, 0.0f, 0.0f, 1.0f);				
	glTranslatef(0.65f, 0.0f, 0.0f);				
	glRotatef(-90, 0.0f, 1.0f, 0.0f);				
	glTranslatef(0.0f, 2.0f, 0.0f);				
	glColor3f(0.8f,0.8f,0.8f);							
	gluCylinder(quadratic,0.1f,0.3f,0.5f,32,32);

	glColor3f(0.8f,0.8f,0.0f);							
	glTranslatef(0.0f, 0.0f, 0.5f);				
	gldrawCircle(0.3f);
	glPopMatrix();

	//draw windscreen
	glPushMatrix();
	glColor3f(0.6f,0.6f,0.6f);							
	glTranslatef(-3.6f, 2.2f, 0.0f);				
	glRotatef(-15, 0.0f, 0.0f, 1.0f);				
	glRotatef(-90, 0.0f, 1.0f, 0.0f);				

	glBegin(GL_QUADS);
	glVertex3f(0.6f, 0.6f, 0.0f);
	glVertex3f(-0.6f, 0.6f, 0.0f);
	glVertex3f(-0.6f, -0.6f, 0.0f);
	glVertex3f(0.6f, -0.6f, 0.0f);
	glEnd();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-3.5f, 2.6f, 0.0f);				
	glRotatef(-15, 0.0f, 0.0f, 1.0f);				
	glRotatef(-90, 0.0f, 1.0f, 0.0f);				
	gldrawCircle(0.6f);
	glPopMatrix();
	
	
	//draw Rear wheel
	glPushMatrix();
	glTranslatef(-0.5f, 0.0f, 0.0f);				

	glColor3f(0.2f,0.2f,0.2f);						
	gldrawTorus(innerRadius, outerRadius, numInner, numOuter);

	glColor3f(0.8f,0.8f,0.8f);						
	gldrawTorus(innerRadius / 2, outerRadius - innerRadius, numInner, numOuter);

	gldrawFan(outerRadius - 1.5f*innerRadius, 15);
	glPopMatrix();

	//draw exhaust pipe
	glPushMatrix();
	glTranslatef(-2.0f, 0.3f, 0.2f);				
	glRotatef(90, 0.0f, 0.0f, 1.0f);					
	glRotatef(90, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.4f,0.4f,0.4f);						
	gluCylinder(quadratic,0.15f,0.15f,2.0f,32,32);		
	glPopMatrix();

	//draw seat
	glPushMatrix();
	glTranslatef(-1.5f, 1.0f, 0.0f);					
	glRotatef(180,1.0f,0.0f,0.0f);						
	glColor3f(0.4f,0.4f,0.4f);						
	glDrawCube(2.0f, 0.4f, 0.4f);
	glPopMatrix();

	glPushMatrix();
	glTranslatef(0.4f, 1.2f, 0.0f);					
	glRotatef(180,1.0f,0.0f,0.0f);						
	glColor3f(0.6f,0.6f,0.6f);						
	glDrawCube(0.6f, 0.6f, 0.7f);
	glPopMatrix();

	glPushMatrix();
	glTranslatef(1.0f, 1.0f, 0.0f);				
	glRotatef(90, 0.0f, 0.0f, 1.0f);					
	glRotatef(90, 1.0f, 0.0f, 0.0f);					
	glColor3f(0.2f,0.2f,0.2f);						
	gluCylinder(quadratic,0.05f,0.05f,0.5f,32,32);		
	glPopMatrix();

	//draw gas tank
	glPushMatrix();
	glTranslatef(-3.0f, 0.8f, -0.6f);				
	glColor3f(0.2f,0.2f,0.2f);						
	gluCylinder(quadratic,0.5f,0.5f,1.3f,32,32);		
	
	glColor3f(0.7f,0.7f,0.7f);						
	gldrawCircle(0.5f);
	glTranslatef(0.0f, 0.0f, 1.45f);				
	gldrawCircle(0.5f);

	glTranslatef(-0.2f, 0.2f, 0.0f);				
	glColor3f(0.5f,0.5f,0.5f);						
	gluCylinder(quadratic,0.1f,0.1f,0.05f,32,32);		
	gldrawCircle(0.1f);
	glPopMatrix();

	//draw trailer
	//draw cargo of the trailer
	glPushMatrix();
	glTranslatef(3.0f, 0.5f, 0.0f);
	glColor3f(0.5f,0.5f,0.5f);							
	glDrawCube(1.5f, 0.6f, 1.0f);

	//draw wheels of the trailer
	glTranslatef(0.0f, -0.8f, 1.0f);						
	glDrawWheel(0.1f, 0.6f);

	glTranslatef(0.0f, 0.0f, -2.0f);					
	glDrawWheel(0.1f, 0.6f);
	glPopMatrix();

	return TRUE;										// Keep Going
}
Example #23
0
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) {
    GLuint      PixelFormat;            // Содержит результаты подбора глубины цвета
    WNDCLASS    wc;                     // Структура классов Windows
    DWORD       dwExStyle;              // Расширенный стиль окна
    DWORD       dwStyle;                // Стиль окна
    RECT        WindowRect;             // Получает значения верхнего левого и нижнего правого углов прямоугольника
    WindowRect.left = (long)0;          // Устанавливает значение лево (Left) в 0
    WindowRect.right = (long)width;     // Устанавливает значение право (Right) в требуемую ширину (Width)
    WindowRect.top = (long)0;           // Устанавливает значение верх (Top) в 0
    WindowRect.bottom = (long)height;   // Устанавливает значение низ (Bottom) в требуемую высоту (Height)

    fullscreen = fullscreenflag;        // Устанавливаем глобальный флвг Fullscreen

    hInstance           = GetModuleHandle(NULL);                // Захватываем Instance для нашего окна
    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;   // Перерисовываем по размеру, и получаем DC для окна.
    wc.lpfnWndProc      = (WNDPROC) WndProc;                    // WndProc Handles Messages
    wc.cbClsExtra       = 0;                                    // Нет дополнительных данных окна
    wc.cbWndExtra       = 0;                                    // Нет дополнительных данных окна
    wc.hInstance        = hInstance;                            // Установим Instance
    wc.hIcon            = LoadIcon(NULL, IDI_WINLOGO);          // Згрузим иконку по умолчанию
    wc.hCursor          = LoadCursor(NULL, IDC_ARROW);          // Згрузим стрелку курсора
    wc.hbrBackground    = NULL;                                 // Фон для GL не требуется
    wc.lpszMenuName     = NULL;                                 // Нам не нужны меню
    wc.lpszClassName    = "OpenGL";                             // Установим имя класса

    if (!RegisterClass(&wc)) {                                  // Попытаемся зарегистрировать класс окна
        MessageBox(NULL, "Failed To Register The Window Class.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                           // Возращаем FALSE
    }

    if (fullscreen) {                                           // Попытаться включить полноеэкранный режим?
        DEVMODE dmScreenSettings;                               // Режим устройства
        memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); // Убедимся, что памать очищена
        dmScreenSettings.dmSize = sizeof(dmScreenSettings);     // Размер структуры devmode
        dmScreenSettings.dmPelsWidth    = width;                // Выбрана ширина экрана
        dmScreenSettings.dmPelsHeight   = height;               // Выбрана высота экрана
        dmScreenSettings.dmBitsPerPel   = bits;                 // Выбрано количество бит на пиксель
        dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        // Попытаемся установить выбранный режим и получить резутьтаты.  К седению: CDS_FULLSCREEN избавляется от кнопки стариGets Rid Of Start Bar.
        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;     // Выбран оконный режим.  Fullscreen = FALSE
            } else {
                // Показать сообщение, что приложение закончило работу.
                MessageBox(NULL, "Program Will Now Close.", "ERROR", MB_OK | MB_ICONSTOP);
                return FALSE;                                   // Возвращаем 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);     // Подстроить окно, чтобы оно соответствовало требуемому размеру

    // Создать окно
    if (!(hWnd = CreateWindowEx(  dwExStyle,                        // Расширенный стиль для окна
                                  "OpenGL",                           // Наименование класса
                                  title,                              // Заголовок окна
                                  dwStyle |                           // Определенный стиль окна
                                  WS_CLIPSIBLINGS |                   // Требуемый стиль окна
                                  WS_CLIPCHILDREN,                    // Требуемый стиль окна
                                  0, 0,                               // Местоположение окна
                                  WindowRect.right - WindowRect.left, // Вычисление ширины окна
                                  WindowRect.bottom - WindowRect.top, // Вычисление высоты окна
                                  NULL,                               // Нет родительского окна
                                  NULL,                               // Нет меню
                                  hInstance,                          // Instance
                                  NULL))) {                           // Не посылать сообщение по WM_CREATE
        KillGLWindow();                             // Инициализация дисплея
        MessageBox(NULL, "Window Creation Error.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                               // Вернуть FALSE
    }

    static  PIXELFORMATDESCRIPTOR pfd = {           // pfd сообщает Windows какие параметры мы хотим
        sizeof(PIXELFORMATDESCRIPTOR),              // Размер дескриптора формата пикселей
        1,                                          // Номер версии
        PFD_DRAW_TO_WINDOW |                        // Формат должен поддерживать окно
        PFD_SUPPORT_OPENGL |                        // Формат должен поддерживать OpenGL
        PFD_DOUBLEBUFFER,                           // Должна поддерживаться двойная буферизация
        PFD_TYPE_RGBA,                              // Запрос RGBA формата
        bits,                                       // Выбор глубины цвета
        0, 0, 0, 0, 0, 0,                           // Биты цвета игнорируются
        0,                                          // Нет альфа буферизации
        0,                                          // Бит сдвига игнорируется
        0,                                          // Нет буфера накопления
        0, 0, 0, 0,                                 // Биты накопления игнорируются
        16,                                         // 16битный Z-бувер (Буфер глубины)
        0,                                          // Нет буфера трафарета (stencil buffer)
        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;                               // Вернуть FALSE
    }

    if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) { // Windows нашла соответствующий формат пикселя?
        KillGLWindow();                             // Инициализация дисплея
        MessageBox(NULL, "Can't Find A Suitable PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                               // Вернуть FALSE
    }

    if(!SetPixelFormat(hDC, PixelFormat, &pfd)) {   // Мы можем установить формат пикселя?
        KillGLWindow();                             // Инициализация дисплея
        MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                               // Вернуть FALSE
    }

    if (!(hRC = wglCreateContext(hDC))) {           // Мы можем получить контекст изображения?
        KillGLWindow();                             // Инициализация дисплея
        MessageBox(NULL, "Can't Create A GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                               // Вернуть FALSE
    }

    if(!wglMakeCurrent(hDC, hRC)) {                 // Пытаемся активировать контекст изображения
        KillGLWindow();                             // Инициализация дисплея
        MessageBox(NULL, "Can't Activate The GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                               // Вернуть FALSE
    }

    ShowWindow(hWnd, SW_SHOW);                      // Показать окно
    SetForegroundWindow(hWnd);                      // Слегка увеличим приоритет
    SetFocus(hWnd);                                 // Устанавливаем фокус клавииатуры на окно
    ReSizeGLScene(width, height);                   // Устанавливаем наше GL окно с перспективой

    if (!InitGL()) {                                // Инициализируем наше GL окно
        KillGLWindow();                             // Инициализация дисплея
        MessageBox(NULL, "Initialization Failed.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                               // Возращает FALSE
    }

    return TRUE;                                    // Успешное завершение инициализациии
}
Example #24
0
int main()
{
    // Create the main window
    sf::Window App(sf::VideoMode(800, 600, 32), "SFML/NeHe OpenGL");

    InitGL();
    ReSizeGLScene(800, 600);

    // Start game loop
    while (App.isOpen())
    {
        // Process events
        sf::Event Event;
        while (App.pollEvent(Event))
        {
            // close window : exit
            if (Event.type == sf::Event::Closed)
                App.close();

            // Resize event : adjust viewport
            if (Event.type == sf::Event::Resized)
                ReSizeGLScene(Event.size.width, Event.size.height);

            // Handle Keyboard Events
            if (Event.type == sf::Event::KeyPressed) {
                switch (Event.key.code) {
                    case sf::Keyboard::Escape:
                        App.close();
                        break;
                    case sf::Keyboard::F1:
                        fullscreen = !fullscreen;
                        App.create(fullscreen ? sf::VideoMode::getDesktopMode() : sf::VideoMode(800, 600, 32) , "SFML/NeHe OpenGL",
                        (fullscreen ? sf::Style::Fullscreen : sf::Style::Resize | sf::Style::Close));
                        InitGL();
                        ReSizeGLScene(App.getSize().x,App.getSize().y);
                        break;
                    case sf::Keyboard::F5:
                        vsync = !vsync;
                        break;
                    default:
                        break;
                }
            }
        }

        // Turn VSYNC on so that animations run at a more reasonable speed on new CPU's/GPU's.
        App.setVerticalSyncEnabled(vsync);

        // Set the active window before using OpenGL commands
        // It's useless here because active window is always the same,
        // but don't forget it if you use multiple windows or controls
        App.setActive();

        //Draw some pretty stuff
        DrawGLScene();

        // Finally, display rendered frame on screen
        App.display();
    }

    return EXIT_SUCCESS;
}
Example #25
0
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
	MSG		msg;
	BOOL	done = FALSE;

	::hInst = hInst;

	if (!CreateGLWindow())
		return 0;

	ShowWindow(hWnd, SW_SHOW);
	ReSizeGLScene(WIDTH, HEIGHT);

	glewInit();
	
	/************* GL things ***************/
	if (!InitGL()) {
		MessageBox(0, "Fail to init GL", "ERROR", MB_OK);
		return FALSE;
	}
	
	/************* Game things ***************/
	InitClasses();

	LARGE_INTEGER _FREQ;
	QueryPerformanceFrequency(&_FREQ);
	tickFreq = (double)_FREQ.QuadPart;
	
	MersenneRandomInit((int)ReadTSC());

	// load textures
	s_Texture->LoadAllTextures();

	//************* Game preinit ***************/

	s_World->LoadWorld();

	m_Player->eyepos = float3(20, 20, 80);
	m_Player->theta = PI/2;
	m_Player->phi = PI/4;
	
	//************* Event loop ***************/

	ShowCursor(false);

	while (!done) {
		if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
			if (msg.message == WM_QUIT)
				done = TRUE;
			else {
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else {
			if (active && !DrawGLScene()) {
				done = TRUE;
			}
			else {
				SwapBuffers(hDC);
			}
		}
	}
	
	ShowCursor(true);

	DeInitClasses();

	wglMakeCurrent(0, 0);
	wglDeleteContext(hRC);
	ReleaseDC(hWnd, hDC);
	DestroyWindow(hWnd);
	UnregisterClass("OpenGL", hInst);

	KillFont();

	return 0;
}