If I call the MessageBox function:

MessageBox(NULL, "Message", "Message", MB_OK);

for example, the box will not appear. It will make the beeping sound, though.

Alright:

#include	<windows.h>
#include	<gl/gl.h>
#include	<gl/glu.h>
#include	<gl/glext.h>

#define ELEMENTS(var) sizeof(var) / sizeof(var[0])

#define TITLE "RPG!"
#define WIDTH 1024
#define HEIGHT 768
#define BITS 16

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

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

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

bool LoadBitmap(char *file, BITMAP *BMP, bool DIB = false)
{
	HBITMAP hBMP;
	
	hBMP = (HBITMAP)LoadImage(GetModuleHandle(NULL), file, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
	if(!hBMP)
	{
		return FALSE;
	}
	GetObject(hBMP, sizeof(BMP), BMP);
	
	if(DIB)
	{
		BITMAPINFOHEADER bmInfoHeader;
		bmInfoHeader.biSize = sizeof(bmInfoHeader);
		bmInfoHeader.biWidth = BMP->bmWidth;
		bmInfoHeader.biHeight = BMP->bmHeight;
		bmInfoHeader.biPlanes = 1;
		bmInfoHeader.biBitCount = 16;
		bmInfoHeader.biCompression = BI_RGB;
		bmInfoHeader.biSizeImage = 0;
		bmInfoHeader.biXPelsPerMeter = 0;
		bmInfoHeader.biYPelsPerMeter = 0;
		bmInfoHeader.biClrUsed = 0;
		bmInfoHeader.biClrImportant = 0;
		
		BITMAPINFO bmInfo;
		bmInfo.bmiHeader = bmInfoHeader;
		
		GetDIBits(hDC, hBMP, 0, BMP->bmHeight, &(BMP->bmBits), &bmInfo, DIB_RGB_COLORS);
	}
	
	DeleteObject(hBMP);
	
	return TRUE;
}

bool LoadTexture(char *textureFile, GLuint *texture)
{
	BITMAP BMP;
	
	glGenTextures(1, texture);
	
	if(!LoadBitmap(textureFile, &BMP))
	{
		return FALSE;
	}
	
	glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
	
	glBindTexture(GL_TEXTURE_2D, *texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	//glTexImage2D(GL_TEXTURE_2D, 0, 3, BMP.bmWidth, BMP.bmHeight, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, BMP.bmBits);
	gluBuild2DMipmaps(GL_TEXTURE_2D, 3, BMP.bmWidth, BMP.bmHeight, GL_BGR_EXT, GL_UNSIGNED_BYTE, BMP.bmBits);
		
	return TRUE;
}

void ResizeGLScene(GLsizei width, GLsizei height)
{
	if(height == 0)
	{
		height = 1;
	}
	
	glViewport(0, 0, width, height);
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	
	gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);
	
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

bool InitGL()
{
	glEnable(GL_TEXTURE_2D);
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	
	return TRUE;
}

bool DrawGLScene()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	
	glTranslatef(0.0f, 0.0f, -5.0f);
	
	glColor3f(0.0f, 0.0f, 1.0f);
	glBegin(GL_QUADS);
		glVertex3f(0.0f, 1.0f, 0.0f);
		glVertex3f(1.0f, 1.0f, 0.0f);
		glVertex3f(1.0f, 0.0f, 0.0f);
		glVertex3f(0.0f, 0.0f, 0.0f);
	glEnd();
	
	return TRUE;
}

void KillGLWindow()
{
	if(fullscreen)
	{
		ChangeDisplaySettings(NULL, 0);
		ShowCursor(TRUE);
	}
	
	if(hRC)
	{
		if(!wglMakeCurrent(NULL, NULL))
		{
			MessageBox(NULL, "Failed to release DC and RC.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		}
		
		if(!wglDeleteContext(hRC))
		{
			MessageBox(NULL, "Failed to release rendering context.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		}
		hRC = NULL;
	}
	
	if(hDC && !ReleaseDC(hWnd, hDC))
	{
		MessageBox(NULL, "Failed to release device context.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		hDC = NULL;
	}
	
	if(hWnd && !DestroyWindow(hWnd))
	{
		MessageBox(NULL, "Failed to release hWnd.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		hWnd = NULL;
	}
	
	if(!UnregisterClass("OpenGL", hInstance))
	{
		MessageBox(NULL, "Failed to unregister class.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		hInstance = NULL;
	}
}

bool CreateGLWindow(char *title, int width, int height, int bits, bool fullscreenFlag)
{
	GLuint pixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle, dwStyle;
	
	RECT wndRect;
	wndRect.left = 0;
	wndRect.top = 0;
	wndRect.right = width;
	wndRect.bottom = height;
	
	fullscreen = fullscreenFlag;
	
	hInstance = GetModuleHandle(NULL);
	
	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc = 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 class.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		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_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
		
		if(ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN != DISP_CHANGE_SUCCESSFUL))
		{
			if(MessageBox(NULL, "The requested fullscreen mode is not supported by\nyour video card.", title, MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
			{
				fullscreen = FALSE;
			}
			else
			{
				MessageBox(NULL, "Program will now close.", title, MB_ICONEXCLAMATION | MB_OK);
				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(&wndRect, dwStyle, FALSE, dwExStyle);
	
	hWnd = CreateWindowEx(dwExStyle,
						  "OpenGL",
						  title,
						  dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
						  0,
						  0,
						  wndRect.right - wndRect.left,
						  wndRect.bottom - wndRect.top,
						  NULL,
						  NULL,
						  hInstance,
						  NULL);
	
	if(!hWnd)
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to create window.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	static PIXELFORMATDESCRIPTOR pfd;
	pfd.nSize = sizeof(pfd);
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = bits;
	pfd.cDepthBits = 16;
	pfd.iLayerType = PFD_MAIN_PLANE;
	
	hDC = GetDC(hWnd);
	if(!hDC)
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to create GL device context.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	pixelFormat = ChoosePixelFormat(hDC, &pfd);
	if(!pixelFormat)
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to find suitable pixel format.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	if(!SetPixelFormat(hDC, pixelFormat, &pfd))
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to set pixel format.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	hRC = wglCreateContext(hDC);
	if(!hRC)
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to create GL rendering context.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	if(!wglMakeCurrent(hDC, hRC))
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to activate GL rendering context.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ResizeGLScene(width, height);
	
	if(!InitGL())
	{
		KillGLWindow();
		MessageBox(NULL, "Failed to initialize Open GL.", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return FALSE;
	}
	
	return TRUE;
}

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;
			break;
		}
		
		case WM_KEYUP:
		{
			keys[wParam] = FALSE;
			break;
		}
		
		case WM_SIZE:
		{
			ResizeGLScene(LOWORD(lParam), HIWORD(lParam));
			return 0;
		}
	}
	
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	bool quit = FALSE;
	
	if(MessageBox(NULL, "Would you like to run in fullscreen mode?", "Run Fullscreen?", MB_ICONQUESTION | MB_YESNO) == IDNO)
	{
		fullscreen = FALSE;
	}
	
	if(!CreateGLWindow(TITLE, WIDTH, HEIGHT, BITS, fullscreen))
	{
		return 0;
	}
	
	while(!quit)
	{
		if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if(msg.message == WM_QUIT)
			{
				quit = TRUE;
			}
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else
		{
			if(active)
			{
				if(keys[VK_ESCAPE])
				{
					quit = TRUE;
				}
				else
				{
					DrawGLScene();
					SwapBuffers(hDC);
				}
			}
			
			if(keys[VK_F1])
			{
				keys[VK_F1] = FALSE;
				KillGLWindow();
				fullscreen = !fullscreen;
				if(!CreateGLWindow(TITLE, WIDTH, HEIGHT, BITS, fullscreen))
				{
					return 0;
				}
			}
		}
	}
	
	KillGLWindow();
	return (msg.wParam);
}

The message asking if they want to run in fullscreen mode (line 387) never comes up, it just shows a black screen with the blue square I created.

Give me the source file on share ,because i can't compile it because of the numbers.
Anyway i am a noob in win32 api so i think i can solve your problem.

Are you sure that you can have 2 WndProc?

You can click on the link that says "Toggle Plain Text" and just copy it from there. And the first WndProc is just a definition, because one of the other functions uses it before it is defined. Otherwise it would be a compiler error, and this compiles fine.

I can't even compile it with Dev-C++,
I try to open projects like OpenGL in C ,and WIN API in C ,and none of them can compile it sorry because i am a noob .

You have to set the project as Windows GUI type and add the opengl libraries to the project. But thats alright, thanks for the effort at least.

This article has been dead for over six months. Start a new discussion instead.