Tags:    c++ I denne artikel vil vi se på hvordan vi laver vores første OpenGL-prpgram i Windows. Artiklen henvender sig mest til brugere af Dev-C++, så hvis du ikke har den installeret, vil jeg anbefale dig at tage et smut ind på www.bloodshed.net og hente den nyeste version.

Opsætning

Opret et nyt projekt ved at gå ind i Files -> New -> Project... og vælg derefter Windows Application. Slet derefter al kode der måtte fremkomme i main.cpp eftersom vi vil starte helt fra bunden

Gå nu ind i Project -> Project Options og tilføj følgende under linker/library feltet:
-lopengl32 -lglu32
Klik derefter på OK og gem dit projekt.

Så koder vi

Start med at tilføje følgende kode, hvor vi beskriver hvilke funktioner vi
vil bruge:

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

//Her definerer vi vores Windows-procedure
LRESULT CALLBACK WndProc (HWND hWnd, UINT message, 
WPARAM wParam, LPARAM lParam); 


//Her definerer vi vores funktion til at tilgængeliggøre OpenGL.
void EnableOpenGL(HWND hWnd, HDC *hDC, HGLRC *hRC); 


//Her definerer vi vores funktion til at deallokere OpenGL fra RAM'en
//dvs. at vi ryder op efter os med denne funktion
void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC); 

Det er nu tid til at oprette vinduet. Det gør vi med følgende kode:

int WINAPI 
WinMain (HINSTANCE hInstance, 
HINSTANCE hPrevInstance, 
LPSTR lpCmdLine, 
int iCmdShow) 
{ 
WNDCLASS wc; 
HWND hWnd; //Denne variabel bruges til at håndtere vores vindue.

HDC hDC; //Denne variabel bruges til at håndtere vores device context. 

HGLRC hRC; //Denne variabel skal håndtere vores render context.

MSG msg; //Med denne variabel styrer vi Windows-messages (nedlukning af vinduer mm.)

BOOL bQuit = FALSE; //Her styrer vi, om programmet skal lukkes ned (TRUE) eller ikke (FALSE). 



//Så registrerer vi vores Window Class. 
//Det er her vi definerer hvordan vores Window skal se ud 
//(som f.eks. hvilken slags ikon, cursor etc.)

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); //Vi vælger en sort baggrundsfarve
wc.lpszMenuName = NULL; 
wc.lpszClassName = "MitFoersteOpenGL"; //Dette er så vores klassenavn.
RegisterClass (&wc); 




//Så opretter vi vores Window. Vores vindue er 640*480.

hWnd = CreateWindow ( 
"MitFoersteOpenGL", "Mit første OpenGL-program", 
WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,0, 0, 640, 480, 
NULL, NULL, hInstance, NULL); 


//Gør OpenGL tilgængelig for vores program
EnableOpenGL (hWnd, &hDC, &hRC); 

//Her checker vi om der er givet besked om at programmet ska lukkes.
while (!bQuit) //Hvis bQuit returnerer FALSE
{  
if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) 
{  
if (msg.message == WM_QUIT) 
{ 
bQuit = TRUE;  
} 
else 
{ 
TranslateMessage (&msg); //Oversætter en virtual-key til typen char.
DispatchMessage (&msg);  //Sender denne char videre til vores Window procedure (WndProc())
} 
} 
else 
{ 

OpenGL

Nu vil vi igang med at kode noget OpenGL.
Først vil jeg lige fortælle lidt om grundprincipperne i OpenGL:
Alle farver defineres med RGB (Red, Green, Blue). RGB-værdierne er altid af
typen float. Hvis vi nu skriver glClearColor(0.0f,0.0f,1.0f,0.0f) får vi en klar blå farve.

Koordinatsystemet

Koordinatsystemet i OpenGL er opbygget således, at et punkt i bunden af skærmen er en negativ værdi, hvor et punkt øverst er en positiv værdi. Dette inkludere også, at jo dybere ind i skærmen et punkt er, desto lavere bliver værdien, hvilket betyder, at punktet 0.0f,0.0f,1.0f altså befinder sig foran skærmen, hvor -1.0f ved z-værdien befinder sig "inde i" skærmen.
Grunden til at vi bruger 0.0f og ikke bare 0 er, at vi i OpenGL har muligheden for at specificere yderligere og mere præcis hvor hvores koordinat skal ligge.
Kun skærmopløsningen sætter grænsen for hvor præcis dine koordinater er.
1.0f betyder, at koordinatet er rykket 1 enhed. Men du kan også vælge en halv enhed, ved 0.5f eller 0.4f osv.
f'et indikerer, at det er af typen float.

Tegne figurer

Inden man begynder at tegne objekter, skal man fortælle OpenGL hvad vi vil tegne, f.eks. om det skal være en trekant eller en firkant. Dette gøres med
glBegin() og glEnd() hvor der i glBegin defineres hvad vi vil tegne. glBegin(GL_QUADS) fortæller OpenGL at vi vil tegne et kvadrat.
glVertex3f() bruges til at tegne punkterne.
Når man er færdig med at tegne, kalder man altid funktionen SwapBuffers.
Årsagen til, at vi tegner i en buffer og ikke direkte på skærmen, er fordi vi ikke ønsker at brugeren skal se selve tegne-processen, men kun det færdige resultat, hvilket altså bliver kaldt med SwapBuffers. hDC definerer en Device Context.

glClearColor (0.0f, 0.0f, 0.0f, 0.0f); //Vi sætter baggrundsfarven i OpenGL til sort.
glClear (GL_COLOR_BUFFER_BIT); //Reset Screen-bufferen.

glBegin(GL_QUADS);						
		glVertex3f(-0.5f, 0.5f, -1.0f);				
		glVertex3f( 0.5f, 0.5f, -1.0f);				
		glVertex3f( 0.5f,-0.5f, -1.0f);				
		glVertex3f(-0.5f,-0.5f, -1.0f);			
	glEnd();	   

SwapBuffers (hDC); 
} 
}
//Luk ned for OpenGL og vinduet:
DisableOpenGL (hWnd, hDC, hRC); 
DestroyWindow (hWnd); 
return msg.wParam; 
} 

Håndtering af messages

Som jeg skrev før i en kommentar i source-koden da vi lavede lidt Windows-programmering, så skal vi kunne sende messages til Windows for at kunne håndtere lukning af vinduet, tastetur, mus etc. Så hvis du engang skal gøre det muligt at bruge mus/tastetur i dine OpenGL-programmer (eller i andre Windows-programmer for den sags skyld) så er det i følgende procedure det gøres (efter case WM_KEYDOWN):

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); 
} 
} 

Gør OpenGL tilgængelig

Så skal vi til at lave en procedure til at gøre OpenGL tilgengængelig for vores program. Det er i en denne funktion vi får fat på vores device -og render context samt pixel format. Vi har valgt at bruge 24 bits farver og 16 bits dybde.

void 
EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC) 
{ 
PIXELFORMATDESCRIPTOR pfd; //Bruges til at beskrive vores pixel format. 
int iFormat; 


//Få fat i vores Device Context 
*hDC = GetDC (hWnd); 


//Nulstil vores Pixel Format Descriptor.
ZeroMemory (&pfd, sizeof (pfd)); 

pfd.nSize = sizeof (pfd); //Få størelsen af vores pixel format descriptor

pfd.nVersion = 1; //Her sættes versions nummeret af vores pixel format. 
                  //Som standard er den 1



pfd.dwFlags = PFD_DRAW_TO_WINDOW | 
PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; //Her bestemmer vi hvordan vi 
//hvordan vores pixel format descriptor skal opføre sig, som f.eks. 
//hvordan den skal tegne, samt hvor eller hvad den skal tegne i.



pfd.iPixelType = PFD_TYPE_RGBA; //Her sætter vi vores pixel type. 
//Vi har valgt at bruge RGBA hvor RGB jo står som Red, Green og Blue, og A står 
//for Alpha. RGBA er bedre end den traditionelle RGB, til OpenGL da den er 
//mere flexsibel og derfor er bedrer til lys, tåge osv.



pfd.cColorBits = 24; //Sæt farverne til 24 bit.

pfd.cDepthBits = 16; //Sæt dybde til 16 bit.

pfd.iLayerType = PFD_MAIN_PLANE; //Bestem overfladen der skal tegnes på

iFormat = ChoosePixelFormat (*hDC, &pfd); //Vælg vores pixel format.



SetPixelFormat (*hDC, iFormat, &pfd); //Sæt pixel formatet af den specificerede 
//device context til formatet der er specificeret med iFormat.

//Her opretter og tilgængeliggører vi vores render context 
*hRC = wglCreateContext( *hDC ); 
wglMakeCurrent( *hDC, *hRC ); 

} 

Oprydningen

Som førnævnt, skulle vi lukke ned for OpenGL med proceduren DisableOpenGL().
Det gør vi, fordi vi ikke ønsker at OpenGL skal ligge og fylde i RAM'en efter programmet er lukket ned. DisableOpenGL-proceduren laves her:

void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC) 
{ 
wglMakeCurrent (NULL, NULL); //Stop for vores device og render context.
wglDeleteContext (hRC); //Slet render context.
ReleaseDC (hWnd, hDC); //Slip device context.
}

Prøv nu at compile dit projekt (gøres med CTRL+F9) og kør programmet. Du skulle nu gerne have en hvid firkant til at vise sig på skærmen.

Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X