Hoe een kubus in OpenGL te maken

OpenGL is een veelzijdig driedimensionaal programmeergereedschap dat wordt gebruikt om complexe scènes in 3D te tekenen met eenvoudige routines. In dit artikel leer je hoe je een kubus kunt tekenen die je kunt draaien om deze in drie dimensies te zien!

Inhoud

Stappen

Deel 1eerste configuratie en hoofd ()

1) installeer opengl
2) maak het document
3) bibliotheken (#omvatten)
4) functieprototypes en globale variabelen
5) configureer de functie main ()

Deel 2de "display ()" -functie

1) functie glclear ()

Deel 3interactiviteit met de gebruiker

1) functie specialkeys ()
2) glrotate ()
Compilatie

Deel 4laatste code

Voor dit project heb je een code-editor nodig en een beetje programmeerkennis met de C-taal.

stappen

Deel 1
Eerste configuratie en hoofd ()

1) Installeer OpenGL

Om te beginnen, volg deze stappen om OpenGL te installeren in uw systeem. Als u deze al hebt naast de C-compiler, kunt u deze stap overslaan en naar de volgende gaan.

2) Maak het document

Maak een nieuw bestand in je favoriete code-editor en sla het op als: micubo.c

3) Bibliotheken (#omvatten)

Dit zijn de basisbibliotheken die u nodig heeft voor uw programma. Het is belangrijk om te onthouden dat afhankelijk van het besturingssysteem mogelijk andere bibliotheken nodig zijn. Zorg ervoor dat u deze allemaal toevoegt, zodat uw programma veelzijdig is en door elke gebruiker kan worden uitgevoerd.

// Inclusief # # include #include # define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # else # include #endif

4) Functieprototypes en globale variabelen

De volgende stap zal zijn om enkele functie-prototypen te declareren.

// Prototypes van functionvoid display () - void specialKeys () - // Globale variabelendouble rotate_y = 0-double rotate_x = 0-

Elk van deze functies en de globale variabelen zullen in detail worden uitgelegd terwijl u ze later volgens deze tutorial implementeert. Voor nu is het belangrijk om ze te verklaren.

5) Configureer de functie main ()

int main (int argc, char * argv []) // Initialiseer de GLUT en gebruikersparameters procesoglutInit (&argc, argv) - // Verzoekvenster met echte kleur en dubbele buffer met Z-buffer glutInitDisplayMode (GLUT_DOUBLE

Deel 2
De "display ()" -functie

Al het werk om de kubus te tekenen zal met deze functie worden gedaan. Het belangrijkste idee is om de 6 zijden te tekenen en ze in de juiste positie te plaatsen.
Conceptueel zul je de 4 hoeken aan één zijde moeten definiëren en OpenGL de punten laten verbinden met lijnen en ze kleuren zoals je ze hebt gedefinieerd. Hier zullen we de stappen presenteren om het te doen:

1) functie glClear ()

De eerste stap die u moet nemen in deze functie zal zijn maak de kleur en de Z-buffer schoon, anders zullen de oude tekeningen nog steeds zichtbaar zijn onder de nieuwe tekeningen en zullen de getekende objecten niet op de juiste positie op het scherm staan.

void display () // Verwijder het scherm en de Z-bufferglClear (GL_COLOR_BUFFER_BIT

U moet ook twee laatste regels code toevoegen voor deze functie: glFlush () - en glutSwapBuffers () -, waardoor je het dubbele buffereffect krijgt.

Deel 3
Interactiviteit met de gebruiker

1) functie SpecialKeys ()

Alles is bijna klaar: je hebt de kubus al, maar je kunt hem niet draaien. Hiertoe maakt u een functie specialKeys ()om u toe te staan om de pijltjestoetsen met pijlen in te drukken en de kubus te draaien!
Voor deze functie moest u de globale variabelen "rotate_x" en "rotate_y" declareren. Wanneer u de pijltjestoetsen naar rechts en links drukt, wordt de variabele "rotate_y" met 5 graden verhoogd of verlaagd. Evenzo, wanneer u de pijltjestoetsen omhoog en omlaag drukt, wordt de variabele "rotate_x" met 5 graden verhoogd of verlaagd.

specialKeys void (int key, int x, y int) {// de pijltoetsen verhoogt de rotatie 5 gradosif (item == GLUT_KEY_RIGHT) rotate_y + = 5 - // Met de toets: verlaagt rotatie in 5 gradoselse if ( key == GLUT_KEY_LEFT) rotate_y - = 5-else if (key == GLUT_KEY_UP) rotate_x + = 5-else if (key == GLUT_KEY_DOWN) rotate_x - = 5 - // Request for-update pantallaglutPostRedisplay () -}

2) glRotate ()

De laatste instructie is om de lijnen toe te voegen voor het object dat moet worden geroteerd. Keer terug naar de functie display () en vóór FRONT SIDE, voeg de onderstaande regels toe:

// Stel de transformacionesglLoadIdentity () - // draaien wanneer de gebruiker de waarden "rotate_x" en "rotate_y" .glRotatef (rotate_x, 1,0, 0,0, 0,0) -glRotatef (rotate_y, 0.0, 1.0, 0.0) verandert - // VOORKANT: veelkleurige kant ....

Merk op dat de syntaxis van glRotatef () het is vergelijkbaar met dat van glColor3f () en glVertex3f () maar het vereist altijd 4 parameters. De eerste parameter is de mate van rotatie die zal worden toegepast en de andere drie parameters zijn de rotatie-assen X, Y en Z. Voor nu is het alleen nodig om te roteren op X en Y.
Alle transformaties die u in het programma schrijft, hebben een soortgelijke lijn nodig. Conceptueel wordt het beschouwd als hoe het object op de X-as moet worden geroteerd met de hoeveelheid die wordt gedefinieerd door "rotate_x" en roteert dan op de Y-as door "rotate_y". OpenGL combineert echter al deze verklaringen in een matrixtransformatie. Elke keer dat u de "weergave" -functie aanroept, bouwt u een transformatiematrix en glLoadIdentity () zorgt ervoor dat u in elke gang begint met een nieuwe matrix.
De andere transformatiefuncties die u kunt toepassen zijn glTranslatef () en glScalef (). Deze functies zijn vergelijkbaar met glRotatef (), behalve dat ze alleen vragen om drie parameters, de hoeveelheden X, Y, Z om het object naar schaal te vertalen of te tekenen.
Om het gewenste effect te bereiken wanneer u de drie transformaties op een object toepast, moet u deze in de juiste volgorde toepassen. Schrijf ze altijd in de juiste volgorde: glTranslate, glRotate, then glScale. Wat in wezen OpenGL zal doen, is de transformaties vanaf de basis toepassen. Om het te assimileren, stel je je het uiterlijk voor van een eenvoudige 1x1x1-kubus met de transformaties als OpenGL ze van boven naar beneden toepaste en als dat van onder naar boven gebeurde.
Voeg de volgende opdrachten toe om de kubus met 2 te schalen op de X- en Y-as, draai de kubus 180 graden op de Y-as en verplaats vervolgens de kubus 0.1 op de X-as. Zoals met de glRotate () -opdrachten , zorg ervoor dat u ze in de juiste volgorde plaatst zoals hierboven beschreven (als u het niet zeker weet, ziet u het gedaan in de definitieve code aan het einde van deze tutorial).
```
// Andere transformaties GlTranslatef (0,1, 0,0, 0,0) -glRotatef (180, 0,0, 1,0, 0,0) -glScalef (2,0, 2,0, 0,0) -
```

compilatie

De laatste stap om je eerste project met OpenGL af te ronden zal zijn compileer en voer de code uit. Ervan uitgaande dat u een gcc-compiler tot uw beschikking heeft, voert u de volgende opdrachten in een terminal uit om het programma te compileren en te testen.
```
Linux: gcc -o cube.c kubus -lglut -lGL./ micuboEn Mac: gcc -o foo foo.c -Framework GLUT -Framework OpenGL./ micuboEn Windows: gcc -Wall -ofoo foo.c -lglut32cu -lglu32 - lopengl32./ micubo
```

Deel 4
Laatste code

Klaar, daar heb je je eerste OpenGL-programma! Hieronder vindt u de broncode die u als referentie moet hebben:

//// Bestand: // micubo.c Auteur: Matthew Diaz // Gemaakt: 4/25/2012 // Project: broncode van een kubus in OpenGL // Omschrijving maken: maak een OpenGL venster en teken een 3D-kubus / / dat de gebruiker de pijltjestoetsen // // Controls draaien: pijl naar links: // `links pijltoetsen: // roteer rechts pijl: // omhoog- omlaag: draai naar beneden // ----------------------------------------------- ----------- // Bibliotheken // ---------------------------------- #include #include #include ------------------------ #define __APPLE GL_GLEXT_PROTOTYPES #ifdef __ #include #include endif anders // ---- -------------------------------------------------- ---- // Functieprototypes // --------------------------------------- ------------------- ongeldig display () - void specialKeys () - // ------------------- --------------------------------------- // Algemene variabelen // ----- -------------------------------------------------- --- double rotate_y = 0-double rotates te_x = 0 - // -------------------------------------------- -------------- // Terugroepfunctie "display ()" // ------------------------ ---------------------------------- leegte display () // Clear screen en Z-bufferglClear (GL_COLOR_BUFFER_BIT // -------------------------------------------------- -------- // Terugbelfunctie "specialKeys ()" // ------------------------------ ---------------------------- void specialKeys (int key, int x, y int) {// rechts Pijltjes: verhoging roteren 5 gradosif (item == GLUT_KEY_RIGHT) rotate_y + = 5 - // pijl links 5 gradoselse rotatie afname if (key == GLUT_KEY_LEFT) rotate_y - = 5-else if (item == GLUT_KEY_UP) rotate_x + = 5-else if (key = = GLUT_KEY_DOWN) rotate_x - = 5 - //-update Request visualizaciónglutPostRedisplay () -} // ------------------------------ ---------------------------- // Functie "main ()" // ------------ ---------------------------------------------- int main (int argc, char * argv []) GLUT_RGB

Delen op sociale netwerken:

Verwant