Inhoud

• Stappen
• Deel 1 van 3: Eerste installatie
• Deel 2 van 3: De display () Functie
• Deel 3 van 3: Interactiviteit van het programma

OpenGL is een 3D-programmeertool waarmee u complexe 3D-afbeeldingen kunt maken van eenvoudige vormen. In dit artikel leer je hoe je met zijn hulp een eenvoudige kubus kunt tekenen die in drie dimensies kan worden gedraaid!

Stappen

Deel 1 van 3: Eerste installatie

1. 1 Installeer OpenGL. Begin met een tutorial over hoe u OpenGL op uw computer installeert. Als u al OpenGL en een C-compiler hebt, kunt u deze stap overslaan en doorgaan naar de volgende.
2. 2 Maak een document aan. Maak een nieuw bestand in je favoriete code-editor en sla het op als mycube.c
3. 3 #inclusief toevoegen. Dit zijn de basisrichtlijnen voor #include die je nodig hebt. Het is belangrijk om te onthouden dat de richtlijnen voor verschillende besturingssystemen verschillend zijn, en daarom moet u alles kiezen zodat het programma universeel is en op elk systeem kan worden uitgevoerd.

   // Inclusief #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else #include GL / glut.h> #endif

4. 4 Voeg functionele prototypes en globals toe. De volgende stap is het declareren van functionele prototypes.

   // Functionele prototypes ongeldige weergave (); ongeldig speciale sleutels (); // Globale variabelen dubbel roteren_y = 0; dubbel roteren_x = 0;

5. 5 Definieer de hoofdfunctie ().

   int main (int argc, char * argv []) // Initialiseer GLUT en verwerk aangepaste parameters glutInit (& argc, argv); // Vraag een venster aan met ondersteuning voor dubbele buffering, Z-buffering en ware kleuren glutInitDisplayMode (GLUT_DOUBLE

Deel 2 van 3: De display () Functie

1. 1 Begrijp het doel van de weergavefunctie (). Al het werk aan het renderen van de kubus valt op de fragiele lijnen van deze functie. Het algemene idee is dit: je tekent zes afzonderlijke vlakken van de kubus en plaatst ze in hun respectievelijke posities.
   • Voor elk vlak definieert u vier hoeken en OpenGL verbindt ze met lijnen en vult ze met de door u gekozen kleur. Hoe u dit doet, wordt hieronder uitgelegd.
2. 2 Voeg glClear () functie toe. Allereerst, wanneer we met deze functie werken, hebben we nodig: heldere kleur en z-buffer... Zonder dit is de oude zichtbaar onder de nieuwe afbeelding en worden de objecten die door het programma zijn getekend verkeerd geplaatst.

   void display () // Wis het scherm en Z Buffer glClear (GL_COLOR_BUFFER_BIT

   • Let op de laatste twee regels. Dit zijn de functies glFlush (); en glutSwapBuffers ();, wat het effect geeft van dubbele buffering, zoals hierboven beschreven.

Deel 3 van 3: Interactiviteit van het programma

1. 1 Voeg de functie specialKeys () toe. In principe is alles bijna klaar, maar de kubus wordt alleen getekend en niet gedraaid. Om dit te doen, moet je creëren de specialeKeys () functie, waarmee u de kubus kunt draaien door op de pijltjestoetsen te drukken!
   • Het is voor deze functie dat de globale variabelen roteren_x en roteren_y gedeclareerd zijn. Wanneer u op de linker- en rechterpijltoetsen drukt, wordt de waarde roteren_y met vijf graden verhoogd of verlaagd. De waarde van roteren_x zal op dezelfde manier veranderen, maar deze keer door op de pijltoetsen omhoog en omlaag te drukken.

   void specialKeys (int key, int x, int y) {// Pijl naar rechts - verhoog de rotatie met 5 graden als (key == GLUT_KEY_RIGHT) roterende_y + = 5; // Pijl naar links - Verlaag de rotatie met 5 graden anders als (toets == GLUT_KEY_LEFT) roteren_y - = 5; anders als (toets == GLUT_KEY_UP) roteren_x + = 5; anders if (toets == GLUT_KEY_DOWN) roteren_x - = 5; // Verzoek scherm vernieuwen glutPostRedisplay (); }

2. 2 Voeg glRotate () toe. Het laatste dat we zullen doen, is een lijn toevoegen waarmee we het object kunnen roteren. Keer terug naar functie Scherm () en voeg vóór de beschrijving van de VOORZIJDE toe:

   // Reset Transformeert glLoadIdentity (); // Roteren wanneer de gebruiker verandert De waarden rotate_x en rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (roteren_y, 0.0, 1.0, 0.0); // Veelkleurige zijkant - FRONT ....

   • Houd er rekening mee dat de syntaxis glRotatief ()die vergelijkbaar is met de syntaxis van glColor3f () en glVertex3f (), maar altijd vier parameters vereist. De eerste is de rotatiehoek in graden. De volgende drie zijn de assen waarlangs de rotatie plaatsvindt, in de volgorde x, y, z. Voor nu moeten we de kubus langs twee assen roteren, x en y.
   • Alle transformaties die we in het programma definiëren, vereisen vergelijkbare lijnen. In principe stellen we de rotatie van een object langs de x-as voor als een verandering in de waarde van roteren_x, en draaien langs de y-as als een verandering in de waarde van roteren_y. OpenGL bundelt echter alles in één transformatiematrix. Elke keer dat u display oproept, maakt u een transformatiematrix, en glLoadIdentity () kunt u elke keer met een nieuwe matrix beginnen.
   • Andere transformatiefuncties die u mogelijk hebt gebruikt, zijn glTranslatef () en glScalef (). Ze lijken op glRotatef (), behalve dat ze slechts drie parameters nodig hebben: de x-, y- en z-waarden om het object te vergroten of verkleinen en te schalen.
   • Om alles correct weer te geven wanneer alle drie transformaties op één object worden toegepast, moet u transformaties in de juiste volgorde zetten, namelijk glTranslate, glRotate, glScale - en nooit anders. OpenGL transformeert het object door het programma van onder naar boven te lezen. Om dit beter te begrijpen, stelt u zich voor hoe de 1x1x1 kubus eruit zou zien na alle transformaties als OpenGL ze zou toepassen in de getoonde volgorde (van boven naar beneden), en bedenk dan hoe OpenGL de kubus zou verwerken door de instructies van onder naar boven te lezen.
3. 3 Voeg de volgende opdrachten toe om de kubus twee keer te schalen in de x- en y-richtingen, om de kubus 180 graden in de y-as te draaien en om de kubus 0,1 in de x-as te verplaatsen. Zorg ervoor dat alle relevante opdrachten, inclusief de eerder gegeven glRotate ()-opdrachten, in de juiste volgorde staan. Als je bang bent om een ​​fout te maken, bekijk dan de definitieve versie van het programma aan het einde van het artikel.

   // Meer transformaties glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0,0, 1,0, 0,0); glScalef (2.0, 2.0, 0.0);

4. 4 Compileer en voer de code uit. Stel dat u gcc als uw compiler gebruikt, dus voer de volgende opdrachten in uw terminal in:

   Op Linux: gcc cube.c -o cube -lglut -lGL ./ mycube Op Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube Op Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32 ./ mycube

5. 5 Controleer de definitieve code. Hier is de definitieve code gemaakt door de auteur van het artikel, die de opmerkingen niet vertaalt.

   // // Bestand: mycube.c // Auteur: Matt Daisley // Gemaakt: 25-4-2012 // Project: Broncode voor Make a Cube in OpenGL // Beschrijving: Maakt een OpenGL-venster en tekent een 3D-kubus / / Dat de gebruiker kan draaien met behulp van de pijltjestoetsen // // Bediening: Pijl naar links - Naar links roteren // Pijl naar rechts - Naar rechts draaien // Pijl omhoog - Omhoog draaien // Pijl omlaag - Omlaag draaien // ------ -------------------------------------------------- - // Inclusief // ------------------------------------------- - -------------- #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else # include GL / glut.h> #endif // --------------------------------------- - ------------------ // Functie Prototypes // ------------------------- - -------------------------------- weergave ongeldig (); ongeldig speciale sleutels (); // ------------------------------------------------ ---------- // Globale variabelen // ---------------------------------- ------------------------ dubbel roteren_y = 0; dubbel roteren_x = 0; // ------------------------------------------------ ---------- // display () Terugbelfunctie // ------------------------------- --------------------------- void display () // Scherm wissen en Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // speciale toetsen () Terugbelfunctie // --------------------------------------- - ------------------ void specialKeys (int key, int x, int y) {// Pijl naar rechts - verhoog de rotatie met 5 graden if (key == GLUT_KEY_RIGHT) roterende_y + = 5; // Pijl naar links - verlaag de rotatie met 5 graden anders if (toets == GLUT_KEY_LEFT) roteren_y - = 5; else if (toets == GLUT_KEY_UP) roteren_x + = 5; else if (toets == GLUT_KEY_DOWN) roteren_x - = 5; // Verzoek update van weergave glutPostRedisplay ();} // ----------------------------------- - ---------------------- // hoofdfunctie () // ------------------- - -------------------------------------- int main (int argc, char * argv [ ] ) GLUT_RGB