Inhalt

• Schrëtt
• Deel 1 vun 3: Éischt Installatioun
• Deel 2 vun 3: Display () Funktioun
• Deel 3 vun 3: Programm Interaktivitéit

OpenGL ass en 3D Programméierungsinstrument dat Iech erlaabt komplex 3D Biller aus einfache Formen ze kreéieren. An dësem Artikel léiert Dir wéi Dir mat senger Hëllef en einfachen Wierfel zeechnen deen an dräi Dimensioune rotéiert ka ginn!

Schrëtt

Deel 1 vun 3: Éischt Installatioun

1. 1 Installéiert OpenGL. Fänkt mat engem Tutorial un wéi Dir OpenGL op Ärem Computer installéiere wëllt. Wann Dir schonn OpenGL an en C Compiler hutt, kënnt Dir dëse Schrëtt iwwersprangen an op den nächste weidergoen.
2. 2 Erstellt en Dokument. Erstellt eng nei Datei an Ärem Liiblingscode Editor a späichert se als mycube.c
3. 3 Füügt #includes. Hei sinn d'Basis #include Direktiven déi Dir braucht. Et ass wichteg ze erënneren datt d'Direktiven fir verschidde Betribssystemer anescht sinn, an dofir musst Dir alles wielen sou datt de Programm universell ass a kann op all System lafen.

   // Enthält #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 Füügt funktionell Prototypen a Globale bäi. Den nächste Schrëtt ass fir funktionell Prototypen ze deklaréieren.

   // Funktionell Prototypen ongëlteg Display (); ongëlteg specialKeys (); // Globale Variabelen duebel rotate_y = 0; duebel rotate_x = 0;

5. 5 Definéiert d'Haaptfunktioun ().

   int main (int argc, char * argv []) // Initialiséieren GLUT a veraarbecht personaliséiert Parameteren glutInit (& argc, argv); // Ufro eng Fënster mat Ënnerstëtzung fir Duebelbufferen, Z-Bufferen A True Faarf glutInitDisplayMode (GLUT_DOUBLE

Deel 2 vun 3: Display () Funktioun

1. 1 Verstitt den Zweck vun der Display () Funktioun. All d'Aarbechte fir de Kubus ze maachen falen op déi fragil Linnen vun dëser Funktioun. Déi allgemeng Iddi ass dëst: Dir zitt sechs getrennte Gesiichter vum Würfel a setzt se an hir jeeweileg Positiounen.
   • Fir all Gesiicht definéiert Dir véier Ecker, an OpenGL verbënnt se mat Linnen a fëllt se mat Ärer gewielter Faarf. Wéi dëst ze maachen gëtt ënnendrënner erkläert.
2. 2 Füügt glClear () Funktioun derbäi. Als éischt, wa mir mat dëser Funktioun schaffen, brauche mir kloer Faarf an z-Puffer... Ouni dëst ass déi al ënner dem neie Bild sichtbar, an d'Objete vum Programm ginn falsch positionéiert.

   ongëlteg Display () // Écran läschen An Z Buffer glClear (GL_COLOR_BUFFER_BIT

   • Opgepasst op déi lescht zwou Linnen. Dëst sinn d'Funktiounen glFlush (); an glutSwapBuffers ();, gëtt den Effekt vun duebeler Pufferung, déi uewe beschriwwe gouf.

Deel 3 vun 3: Programm Interaktivitéit

1. 1 Fügt d'SpezialKeys () Funktioun derbäi. Am Prinzip ass alles bal fäerdeg, awer de Würfel gëtt nëmmen gezeechent an net rotéiert. Fir dëst ze maachen, musst Dir erstellen der specialKeys () Funktioun, wat Iech erlaabt de Würfel ze dréinen andeems Dir d'Pfeiltasten dréckt!
   • Et ass fir dës Funktioun datt déi global Variabelen rotate_x a rotate_y deklaréiert goufen. Wann Dir déi lénks a riets Pfeiltasten dréckt, wäert de Rotate_y Wäert eropgoen oder erofgoen mat fënnef Grad. De Wäert vu rotate_x ännert sech op déiselwecht Manéier, awer dës Kéier andeems Dir op d'Pfeiler no uewen an ënnen dréckt.

   void specialKeys (int key, int x, int y) {// Riets Pfeil - erhéicht d'Rotatioun mat 5 Grad wann (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Lénks Pfeil - Reduktioun vun der Rotatioun ëm 5 Grad anescht wann (Schlëssel == GLUT_KEY_LEFT) rotate_y - = 5; anescht wann (Schlëssel == GLUT_KEY_UP) rotate_x + = 5; anescht wann (Schlëssel == GLUT_KEY_DOWN) rotate_x - = 5; // Ufro Écran Erfrëschen glutPostRedisplay (); }

2. 2 GlRotate () derbäisetzen. Déi lescht Saach déi mir maache wäerten ass eng Linn derbäisetzen déi et eis erlaabt den Objet ze rotéieren. Zréck op d'Funktioun affichéieren () a virun der Beschreiwung vun der FRONT Säit add:

   // Reset Transforms glLoadIdentity (); // Rotéieren Wann De Benotzer Ännert D'Wäerter rotate_x a rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // Multicolor Säit - FRONT ....

   • Notéiert w.e.g. datt d'Syntax glRotatef ()wat ähnlech wéi d'Syntax vu glColor3f () a glVertex3f () ass, awer ëmmer véier Parameteren erfuerdert. Déi éischt ass de Rotatiounswénkel a Grad. Déi nächst dräi sinn d'Axen laanscht déi d'Rotatioun stattfënnt, an der Uerdnung x, y, z. Fir de Moment musse mir de Würfel laanscht zwou Axen rotéieren, x an y.
   • All Transformatiounen, déi mir am Programm definéieren, erfuerderen ähnlech Linnen. Prinzipiell representéiere mir d'Rotatioun vun engem Objet laanscht d'x-Achs als eng Ännerung am Wäert vun rotate_x, a Rotatioun laanscht d'y-Achs als eng Ännerung am Wäert vun rotate_y. Wéi och ëmmer, OpenGL wäert alles an eng Transformatiounsmatrix bündelen. All Kéier wann Dir Display nennt, erstellt Dir eng Transformatiounsmatrix, an glLoadIdentity () erlaabt Iech all Kéier mat enger neier Matrix ze starten.
   • Aner Transformatiounsfunktiounen déi Dir benotzt hutt kënne sinn glTranslatef () a glScalef (). Si sinn ähnlech wéi glRotatef (), ausser datt se nëmmen dräi Parameteren erfuerderen: d'Wäerter x, y, an z fir den Objet z'änneren an ze skalaéieren.
   • Fir datt alles richteg ugewise gëtt wann all dräi Transformatiounen op een Objet applizéiert ginn, musst Dir Transformatiounen an déi entspriechend Uerdnung setzen, nämlech glTranslate, glRotate, glScale - an ni anescht. OpenGL transforméiert den Objet andeems Dir de Programm vun ënnen no uewen liest. Fir dëst besser ze verstoen, stellt Iech vir wéi den 1x1x1 Würfel no all den Transformatioune géif ausgesinn wann OpenGL se an der ugewandter Uerdnung applizéiert (uewen no ënnen), an denkt dann iwwer wéi OpenGL de Würfel veraarbecht andeems Dir d'Instruktioune vun ënnen no uewen liest.
3. 3 Fügt déi folgend Kommandoen derbäi fir de Würfel zweemol an de x an y Richtungen ze skala, fir de Würfel 180 Grad an der y Achs ze rotéieren, an de Kubus 0.1 an der x Achs ze réckelen. Gitt sécher datt all relevant Kommandoen, inklusiv déi virdru uginn glRotate () Kommandoen, an der korrekter Uerdnung sinn. Wann Dir Angscht hutt e Feeler ze maachen, kuckt déi lescht Versioun vum Programm um Enn vum Artikel.

   // Méi Transformatiounen glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 Compiléieren a lafen de Code. Loosst eis soen datt Dir gcc als Äre Compiler benotzt, gitt also déi folgend Kommandoen an Ärem Terminal:

   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 Préift de leschte Code. Hei ass de leschte Code erstallt vum Auteur vum Artikel, deen d'Kommentaren net iwwersetzt.

   // // Datei: mycube.c // Auteur: Matt Daisley // Erstellt: 25.04.2012 // Projet: Quellcode fir Maacht e Cube an OpenGL // Beschreiwung: Erstellt eng OpenGL Fënster an zitt en 3D Cube/ / Dass de Benotzer mat de Pfeiltasten rotéiere kann // // Kontrollen: Pfeil lénks -Riets lénks // Pfeil no riets -Riets rotéieren // Pfeil no uewen -Rotéieren no // Pfeil no ënnen -Dréien // ------ ---------------------------------------------------------- -// Enthält // ------------------------------------------- -------------- #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 // ---------------------------------------- ------------------ // Funktioun Prototypen // -------------------------- -------------------------------- ongëlteg Display (); ongëlteg specialKeys (); // ------------------------------------------------- ---------- // Globale Variabelen // ---------------------------------- ------------------------ duebel rotate_y = 0; duebel rotate_x = 0; // ------------------------------------------------- ---------- // Display () Callback Funktioun // ------------------------------- --------------------------- eidel Display () // Écran läschen an Z-Puffer glClear (GL_COLOR_BUFFER_BIT // ------ ---------------------------------------------------------- -// specialKeys () Callback Funktioun // ------------------------------------------ ------------------ void specialKeys (int key, int x, int y) {// Riets Pfeil-erhéicht d'Rotatioun ëm 5 Grad wann (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Lénks Pfeil - reduzéiert d'Rotatioun mat 5 Grad anescht wann (Schlëssel == GLUT_KEY_LEFT) rotate_y - = 5; soss wann (Schlëssel == GLUT_KEY_UP) rotate_x + = 5; anescht wann (Schlëssel == GLUT_KEY_DOWN) rotate_x - = 5; // Ufro Displayupdate glutPostRedisplay ();} // ------------------------------------ ---------------------- // main () Funktioun // -------------------- -------------------------------------- int main (int argc, char * argv [] ) GLUT_RGB