[Código] "Casa girando" em C++

Lembro que tinha um tópico por aqui que tinha um cara pedindo como fazer para criar um quadrado que fica rotacionando sobre um eixo, bom, não achei o tópico que falava sobre isso, mas tô começando a trabalhar com OpenGL agora e achei que seria interessante disponibilizar para o pessoal o que eu fiz, se alguém precisar de algo parecido.

Primeiro tem que criar um projeto no seu compilador para fazer um programa pra Windows. Aí tu usa esse código. Peguei o código que o Dev-C++ já cria por padrão e mudei o que precisa pra poupar trabalho.

/**************************
* Includes
*
**************************/

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

/**************************
* Function Declarations
*
**************************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,

WPARAM wParam, LPARAM lParam);
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC);
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC);

/**************************
* WinMain
*
**************************/

int WINAPI WinMain (HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int iCmdShow)
{

	WNDCLASS wc;
	HWND hWnd;
	HDC hDC;
	HGLRC hRC;
	MSG msg;
	BOOL bQuit = FALSE;
	float theta = 0.0f;

	/* register window class */
	wc.style = CS_OWNDC;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
	wc.hCursor = LoadCursor (NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "GLSample";
	RegisterClass (&wc);

	/* create main window */
	hWnd = CreateWindow (
 "GLSample", "OpenGL Sample",
 WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,
 0, 0, 512, 512,
 NULL, NULL, hInstance, NULL);

	/* enable OpenGL for the window */
	EnableOpenGL (hWnd, &hDC, &hRC);

	/* program main loop */
	while (!bQuit)
	{
 /* check for messages */
 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
 {
 /* handle or dispatch messages */
 if (msg.message == WM_QUIT)
 {
 bQuit = TRUE;
 }
 else
 {
 TranslateMessage (&msg);
 DispatchMessage (&msg);
 }
 }
 else
 {
 /* OpenGL animation code goes here -> ou seja, aqui é a parte do desenho */

 //aqui eu vou começar a desenhar
 glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
 glClear (GL_COLOR_BUFFER_BIT);

 glPushMatrix ();
 //aqui estou botando as formas que vou desenhar aqui em uma matriz para poder rotacioná-la
 glRotatef (theta, 0.0f, 0.0f, 1.0f);
 glBegin (GL_QUADS);
 //aqui eu desenho um quadrado vermelho escuro
 glColor3f (0.6f, 0.0f, 0.0f);
 glVertex2f (0.0f, 1.0f);
 glVertex2f (0.6f, 1.0f);
 glVertex2f (0.6f, 0.3f);
 glVertex2f (0.0f, 0.3f);
 glEnd ();
 glPopMatrix ();

 //essa parte eu boto fora do push matrix, porque eu não quero que esse quadrado branco (que aparece no meio da janela) gire. Ele apenas marca o centro de rotação.
 glBegin(GL_QUADS);
 glColor3f(1.0f, 1.0f, 1.0f);
 glVertex2f (0.01f, 0.01f);
 glVertex2f (0.01f, -0.01f);
 glVertex2f (-0.01f, -0.01f);
 glVertex2f (-0.01f, 0.01f);
 glEnd();

 SwapBuffers (hDC);

 //adiciona ao ângulo de rotação para que na próxima vez que o desenho ocorra, o desenho tenha girado um pouco.
 theta += 1.0f;
 Sleep (1);
 }
	}

	/* shutdown OpenGL */
	DisableOpenGL (hWnd, hDC, hRC);

	/* destroy the window explicitly */
	DestroyWindow (hWnd);

	return msg.wParam;
}

/********************
* Window Procedure
*
********************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{

switch (message)
{
case WM_CREATE:

 return 0;
	case WM_CLOSE:
 PostQuitMessage (0);
 return 0;

	case WM_DESTROY:
 return 0;

	case WM_KEYDOWN:
 switch (wParam)
 {
 case VK_ESCAPE:
 PostQuitMessage(0);
 return 0;
 }
 return 0;

	default:
 return DefWindowProc (hWnd, message, wParam, lParam);
	}
}

/*******************
* Enable OpenGL
*
*******************/

void EnableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{

	PIXELFORMATDESCRIPTOR pfd;
	int iFormat;

	/* get the device context (DC) */
	*hDC = GetDC (hWnd);

	/* set the pixel format for the DC */
	ZeroMemory (&pfd, sizeof (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 = 24;
	pfd.cDepthBits = 16;
	pfd.iLayerType = PFD_MAIN_PLANE;
	iFormat = ChoosePixelFormat (*hDC, &pfd);
	SetPixelFormat (*hDC, iFormat, &pfd);

	/* create and enable the render context (RC) */
	*hRC = wglCreateContext( *hDC );
	wglMakeCurrent( *hDC, *hRC );

}

/******************
* Disable OpenGL
*
******************/

void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{

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