Conţinut

• Pași
• Partea 1 din 3: Instalarea inițială
• Partea 2 din 3: Funcția afișaj ()
• Partea 3 din 3: Interactivitatea programului

OpenGL este un instrument de programare 3D care vă permite să creați imagini 3D complexe din forme simple. În acest articol, veți învăța cum să desenați cu ajutorul său un cub simplu care poate fi rotit în trei dimensiuni!

Pași

Partea 1 din 3: Instalarea inițială

1. 1 Instalați OpenGL. Începeți cu un tutorial despre cum să instalați OpenGL pe computer. Dacă aveți deja OpenGL și un compilator C, puteți sări peste acest pas și să treceți la următorul.
2. 2 Creați un document. Creați un fișier nou în editorul de cod preferat și salvați-l ca mycube.c
3. 3 Adăugați #include. Iată directivele de bază #include de care aveți nevoie. Este important să ne amintim că directivele pentru diferite sisteme de operare sunt diferite și, prin urmare, trebuie să alegeți totul, astfel încât programul să fie universal și să poată fi rulat pe orice sistem.

   // Include #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 Adăugați prototipuri funcționale și globale. Următorul pas este declararea prototipurilor funcționale.

   // Prototipuri funcționale void display (); void specialKeys (); // Variabile globale rotit dublu_y = 0; rotire dublă_x = 0;

5. 5 Definiți funcția main ().

   int main (int argc, char * argv []) // Inițializați GLUT și procesați parametrii personalizați glutInit (& argc, argv); // Solicitați o fereastră cu suport pentru tamponare dublă, tamponare Z și culoare True glutInitDisplayMode (GLUT_DOUBLE

Partea 2 din 3: Funcția afișaj ()

1. 1 Înțelegeți scopul funcției display (). Toate lucrările de redare a cubului vor cădea pe liniile fragile ale acestei funcții. Ideea generală este următoarea: veți desena șase fețe separate ale cubului și le veți așeza în pozițiile lor respective.
   • Pentru fiecare față, veți defini patru colțuri, iar OpenGL le va conecta cu linii și le va umple cu culoarea aleasă. Cum se face acest lucru va fi explicat mai jos.
2. 2 Adăugați funcția glClear (). În primul rând, atunci când lucrăm cu această funcție, avem nevoie culoare clară și tampon z... Fără aceasta, cea veche va fi vizibilă sub noua imagine, iar obiectele desenate de program vor fi poziționate incorect.

   afișare nulă () // Ștergeți ecranul și tamponul Z glClear (GL_COLOR_BUFFER_BIT

   • Acordați atenție ultimelor două rânduri. Acestea sunt funcțiile glFlush (); și glutSwapBuffers ();, dând efectul de tamponare dublă, care a fost descris mai sus.

Partea 3 din 3: Interactivitatea programului

1. 1 Adăugați funcția specialKeys (). În principiu, totul este aproape gata, dar cubul este doar tras și nu rotit. Pentru a face acest lucru, trebuie să creați funcția specialKeys (), care vă va permite să rotiți cubul apăsând tastele săgeată!
   • Pentru această funcție au fost declarate variabilele globale rotate_x și rotate_y. Când apăsați tastele săgeată stânga și dreapta, valoarea rotate_y va crește sau scădea cu cinci grade. Valoarea rotate_x se va schimba în același mod, dar de această dată apăsând tastele săgeată sus și jos.

   void specialKeys (tasta int, int x, int y) {// Săgeata dreapta - crește rotația cu 5 grade dacă (tasta == GLUT_KEY_RIGHT) rotate_y + = 5; // Săgeată la stânga - Reduceți rotația cu 5 grade altfel dacă (tasta == GLUT_KEY_LEFT) rotate_y - = 5; altfel dacă (cheie == GLUT_KEY_UP) rotate_x + = 5; altfel dacă (cheie == GLUT_KEY_DOWN) rotate_x - = 5; // Solicitați reîmprospătarea ecranului glutPostRedisplay (); }

2. 2 Adăugați glRotate (). Ultimul lucru pe care îl vom face este să adăugăm o linie care ne va permite să rotim obiectul. Reveniți la funcție display () și înainte de descrierea faței FRONT adăugați:

   // Reset Transforms glLoadIdentity (); // Rotire când utilizatorul se schimbă Valorile rotate_x și rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0,0, 1,0, 0,0); // Partea multicolor - FRONT ....

   • Vă rugăm să rețineți că sintaxa glRotatef ()care este similar cu sintaxa glColor3f () și glVertex3f (), dar necesită întotdeauna patru parametri. Primul este unghiul de rotație în grade. Următoarele trei sunt axele de-a lungul cărora are loc rotația, în ordinea x, y, z. Deocamdată, trebuie să rotim cubul de-a lungul a două axe, x și y.
   • Toate transformările pe care le definim în program necesită linii similare. Practic, reprezentăm rotația unui obiect de-a lungul axei x ca o modificare a valorii rotate_x și rotația de-a lungul axei y ca o modificare a valorii rotate_y. Cu toate acestea, OpenGL va grupa totul într-o singură matrice de transformare. De fiecare dată când apelați afișarea, veți crea o matrice de transformare și glLoadIdentity () vă va permite să începeți de fiecare dată cu o nouă matrice.
   • Alte funcții de transformare pe care le-ați fi folosit sunt glTranslatef () și glScalef (). Acestea sunt similare cu glRotatef (), cu excepția faptului că necesită doar trei parametri: valorile x, y și z pentru redimensionarea și scalarea obiectului.
   • Pentru ca totul să fie afișat corect atunci când toate cele trei transformări sunt aplicate unui singur obiect, trebuie să setați transformările în ordinea corespunzătoare, și anume glTranslate, glRotate, glScale - și niciodată altfel. OpenGL transformă obiectul citind programul de jos în sus. Pentru a înțelege mai bine acest lucru, imaginați-vă cum ar arăta cubul 1x1x1 după toate transformările dacă OpenGL le-ar aplica în ordinea arătată (de sus în jos) și apoi gândiți-vă la modul în care OpenGL ar procesa cubul citind instrucțiunile de jos în sus.
3. 3 Adăugați următoarele comenzi pentru a scala cubul de două ori în direcțiile x și y, pentru a roti cubul cu 180 de grade pe axa y și pentru a muta cubul 0,1 pe axa x. Asigurați-vă că toate comenzile relevante, inclusiv comenzile glRotate () date anterior, sunt în ordinea corectă. Dacă vă este frică să greșiți, consultați versiunea finală a programului la sfârșitul articolului.

   // Mai multe transformări glTranslatef (0,1, 0,0, 0,0); glRotatef (180, 0,0, 1,0, 0,0); glScalef (2.0, 2.0, 0.0);

4. 4 Compilați și rulați codul. Să presupunem că utilizați gcc ca compilator, așa că introduceți următoarele comenzi în terminal:

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

5. 5 Verificați codul final. Iată codul final creat de autorul articolului, care nu traduce comentariile.

   // // Fișier: mycube.c // Autor: Matt Daisley // Creat: 25.04.2012 // Proiect: Cod sursă pentru Make a Cube în OpenGL // Descriere: Creează o fereastră OpenGL și desenează un cub 3D / / Că utilizatorul poate roti folosind tastele săgeată // // Comenzi: Săgeată stânga - Rotire stânga // Săgeată dreapta - Rotire dreaptă // Săgeată sus - Rotire sus // Săgeată jos - Rotire jos // ------ -------------------------------------------------- - // Include // ------------------------------------------- - -------------- #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 // --------------------------------------- - ------------------ // Prototipuri de funcții // ------------------------- - -------------------------------- afișare nulă (); void specialKeys (); // ------------------------------------------------ ---------- // Variabile globale // ---------------------------------- ------------------------ rotire dublă_y = 0; rotire dublă_x = 0; // ------------------------------------------------ ---------- // display () Functie callback // ------------------------------- --------------------------- Afișare nulă () // Ștergeți ecranul și Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // specialKeys () Funcție de apel invers // --------------------------------------- - ------------------ void specialKeys (tasta int, int x, int y) {// Săgeata dreapta - crește rotația cu 5 grade dacă (tasta == GLUT_KEY_RIGHT) rotate_y + = 5; // Săgeata spre stânga - micșorați rotația cu 5 grade altfel dacă (tasta == GLUT_KEY_LEFT) rotate_y - = 5; altfel dacă (tasta == GLUT_KEY_UP) rotate_x + = 5; altfel dacă (tasta == GLUT_KEY_DOWN) rotate_x - = 5; // Solicitați actualizarea afișajului glutPostRedisplay ();} // ----------------------------------- - ---------------------- // funcția main () // ------------------- - -------------------------------------- int main (int argc, char * argv [] ) GLUT_RGB