Cum se creează un cub OpenGL

OpenGL este un instrument puternic de programare 3D folosit pentru a crea compoziții complexe tridimensionale derivate din forme simple. Acest articol vă va învăța cum să creați un simplu cub care poate fi rotit pentru a fi văzut în trei dimensiuni!

Pentru acest proiect, veți avea nevoie de un editor de cod sursă și de o mică cunoaștere în limbajul de programare C.

pași

Metoda 1
Configurarea inițială și funcția principală ()

1) Instalați OpenGL

Pentru a începe, urmați aceste instrucțiuni pentru a instala OpenGL pe sistemul dvs. Dacă aveți deja OpenGL și un compilator C, săriți peste acest pas și treceți la următorul.

2) Creați documentul

Creați un fișier nou în editorul dvs. de cod preferat și salvați-l ca meucubo.c

3) #include

Există incluziuni de bază pe care va trebui să le creați. Este important să rețineți că pachetele care trebuie incluse se pot modifica în funcție de sistemul de operare. Asigurați-vă că includeți toate pachetele care vă asigură că programul dvs. este versatil și poate fi utilizat de orice utilizator.
```
// Inclusions # include #include #include #define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # alt # include # endif
```

4) Declarațiile de funcții și variabilele globale

Următorul pas este să declarăm câteva funcții.

// Funcții Declarații void specialKeys () - // Variabile Globalsdouble rotate_y = 0-double rotate_x = 0-

Aceste funcții și variabile vor fi explicate în detaliu în timpul tutorialului. Pentru moment, opriți-vă doar să le declarați.

5) Configurarea funcției principal ()

int principal (int argc, char * argv []) GLUT_DEPTH) -

Această comandă stabilește mediul. Un aspect important când scrieți programe în OpenGL este că trebuie să comandați totul. De aceea, trebuie să aveți o înțelegere detaliată a modului în care programul dvs. va funcționa și ce trebuie să includeți în cod pentru a crea funcționalitatea dorită. În această linie, am creat ecranul de prezentare al programului cu tampon dublu, culori RGB și un tampon Z.
"Tampon dublu" este o tehnică folosită în programele grafice pentru a elimina problemele care apar atunci când desenați imagini pe ecran. De fiecare dată când o scenă trebuie actualizată, ecranul trebuie șters și noile informații extrase. Fără tamponul dublu veți observa un efect oscilant în timp ce ecranul este șters și reproiectat rapid.

Problema este rezolvată prin adăugarea unui al doilea tampon la rutinele de scriere pe ecran. Cu această metodă, imaginea este mai întâi trasă în tampon și apoi tamponul este afișat pe ecran. Următorul cadru al scenei va fi desenat în al doilea tampon, iar când procesul va fi terminat, tampoanele vor fi inversate. Imediat vom vedea al doilea tampon, dar între timp, primul tampon este ascuns fiind șters și redesenat cu un al treilea cadru care va fi afișat când este finalizat.
De asemenea, dorim să permitem sistemul de culori "RGB" în fereastra noastră. Vom arăta cum este folosită culoarea în OpenGL atunci când lucrați cu funcția "afișare".
Z-buffering este instrumentul folosit pentru a crea efectele 3D pe care le dorim. OpenGL utilizează un sistem cu trei coordonate cu axele x, y și z. Pentru a da efectul că un obiect este mai aproape de dvs., poziția dvs. pe axa z este mărită. Pentru a realiza efectul invers, poziția sa pe axa z este scăzută. Vom vorbi mai mult despre asta când vom crea vârful cubului nostru.

6) Crearea ferestrei programului

Următorul pas este să crea fereastra în care cubul nostru va fi desenat. În acest tutorial, vom numi fereastra "Super Cube".
```
// Creați janelaglutCreateWindow ("Super Cube") -
```

7) Activați testul de adâncime

OpenGL este un limbaj restrâns care nu are caracteristici speciale activate în mod implicit. Pentru ca programul nostru să prezinte corect imaginile 3D folosind tamponul Z, trebuie să activați "testul de adâncime". Când explorați OpenGL, veți descoperi câteva caracteristici care trebuie activate, cum ar fi iluminarea și texturile.
```
// Activați testul de adâncime Z-bufferglEnable (GL_DEPTH_TEST) -
```

8) Funcții de apel invers

Iată funcțiile de apel invers pe care le-am scris în instrucțiunile anterioare. Aceste funcții vor fi chemați de fiecare dată când programul se rotește prin bucla principală. Funcția de afișare redă scenariul pe baza oricărei modificări a variabilelor efectuate de la ultima convorbire. Funcția specialKeys ne permite să interacționăm cu programul.
```
// Funcții callbackglutDisplayFunc (afișare) -glutSpecialFunc (specialKeys) -
```

9) Funcții de apel invers

Ultimul pas în configurația noastră inițială este porniți MainLoop. Aceasta va determina funcția principală până când închidem programul, permițând realizarea animațiilor și interacțiunii cu utilizatorul.
```
// Trecerea controlului la evenimente GLUTglutMainLoop () - // Înapoi la SOreturn 0-
```

Metoda 2
Funcția de afișare ()

Toate lucrările efectuate în desenarea cubului se vor face în această funcție. Ideea generală din spatele cubului este de a desena toate cele șase laturi în mod individual și de a le plasa în pozițiile corespunzătoare.
Conceptual, fiecare parte va fi desenată prin definirea celor patru vârfuri, apoi lăsând OpenGL să conecteze liniile și să completeze o culoare aleasă. Mai jos sunt pașii pentru a face acest lucru.

1) glClear ()

Primul pas pe care trebuie să-l realizăm în această funcție este ștergeți culoarea și tamponul Z. Fără acești pași, vechile desene pot fi văzute printre informațiile noi și obiectele nu vor fi în locația corectă pe ecran.
```
void display () GL_DEPTH_BUFFER_BIT) -
```

2) glBegin () și glEnd ()

OpenGL definește obiectele ca combinații de poligoane diferite. Când utilizați comanda glBegin (), spunem OpenGL că este gata să deseneze formatul dorit. Pentru a termina procesul și a începe un nou format, trebuie să folosim comanda glEnd (). In acest tutorial, vom folosi GL_POLYGON pentru a desena fiecare parte a cubului, dar este, de asemenea, posibil să se utilizeze alți parametri ca GL_LINE, GL_QUAD GL_TRIANGLE sau pentru a crea alte forme.

Să începem cu partea din față a cubului. Vom adăuga culorile pe cele 6 laturi mai târziu.

// Partea multicoloră - FRENTEglBegin (GL_POLYGON) - // Vertexele vor fi adăugate în următoarea etapaglEnd () -

3) glVertex3f ()

Odată ce declarăm că vrem să începem poligonul, trebuie să facem asta definiți nodurile a obiectului. Funcția glVertex are mai multe moduri de a face acest lucru în funcție de modul în care doriți obiectul.
Prima opțiune este în câte dimensiuni doriți să lucrați. 3 în glVertex3f spune că noi trasăm în trei dimensiuni. Este, de asemenea, posibil să lucrați în 2 sau 4 dimensiuni. Funcția f în glVertexf ne spune că lucrăm cu numere float (punct în flotantă). De asemenea, puteți utiliza alte tipuri de date, cum ar fi pantaloni scurți, numere întregi sau duble.
Verificați dacă aceste puncte sunt setate în ordine invers acelor de ceasornic. Acest lucru nu este atât de important acum, dar când începem să lucrăm cu iluminare și texturi, va fi extrem de necesar să fim obișnuiți să stabilim punctele într-o ordine anti-orar.

Acum putem adăuga nodurile între comenzile glBegin () și glEnd ().

// multicolori Side - FRENTEglBegin (GL_POLYGON) -glVertex3f (-0.5, -0.5, -0.5) - // P1glVertex3f (-0.5, 0.5, -0.5) - // P2glVertex3f (0,5, 0,5, -0.5) - // P3glVertex3f (0,5, -0,5, -0,5) - // P4glEnd () -

4) glColor3f ()

glColor funcționează similar cu glVertex. Putem defini punctele ca pantaloni scurți, numere întregi, duble sau flotoare. Fiecare culoare are o valoare cuprinsă între 0 și 1. Totul ca 0 va lăsa punctul negru și totul ca 1 va părăsi punctul alb. 3 în glColor3f () se referă la sistemul RGB fără canal alfa. Alfa-ul unei culori definește transparența sa. Pentru a modifica nivelul alfa, utilizați comanda glColor4f (), ultimul parametru fiind o valoare între 0 și 1, respectiv opac la transparent.
Când numim funcția glColor3f (), fiecare vârf tras din acel punct va fi de culoarea definită. Dacă doriți ca cele patru noduri să fie roșii, setați culoarea o dată înainte de comanda glVertex3f () și toate nodurile vor fi roșii.

Fața frontală definită mai jos arată cum definim o culoare nouă pentru fiecare vârf. Când facem acest lucru, vedem o proprietate interesantă a culorilor OpenGL. Deoarece fiecare vârf al poligonului are propria culoare, OpenGL le va amesteca automat! Următorul pas vă va arăta cum să creați patru noduri de aceeași culoare.

// multicolori Side - FrenteglBegin (GL_POLYGON) -glColor3f (1.0, 0.0, 0.0) - glVertex3f (0.5, -0.5, -0.5) - // P1 este vermelhoglColor3f (0.0, 1.0, 0.0) - glVertex3f (0,5, 0,5, - 0.5) - // P2 este verdeglColor3f (0.0, 0.0, 1.0) - glVertex3f (-0.5, 0.5, -0.5) - // P3 este azulglColor3f (1,0, 0,0, 1,0) - glVertex3f (-0.5, -0.5, -0.5 ) - // P4 este roxoglEnd () -

5) Celelalte părți

Vă recomandăm să descoperiți poziția fiecăruia dintre vârfurile celorlalte cinci părți, dar pentru simplitate, le calculam deja pentru dvs. și le includem în funcția finală de afișare () de mai jos.

// side White - TRASEIRAglBegin (GL_POLYGON) -glColor3f (1,0, 1,0, 1,0) -glVertex3f (0.5, -0.5, 0.5) -glVertex3f (0,5, 0,5, 0,5) -glVertex3f (-0,5, 0,5, 0,5) -glVertex3f ( -0.5, -0.5, 0.5) -glEnd () - partea mov // - DIREITAglBegin (GL_POLYGON) -glColor3f (1,0, 0,0, 1,0) -glVertex3f (0.5, -0.5, -0.5) -glVertex3f (0,5, 0,5, - 0,5) -glVertex3f (0,5, 0,5, 0,5) -glVertex3f (0.5, -0.5, 0.5) -glEnd () - // Side verde - ESQUERDAglBegin (GL_POLYGON) -glColor3f (0.0, 1.0, 0.0) -glVertex3f (-0.5, -0.5, 0.5) -glVertex3f (-0,5, 0,5, 0,5) -glVertex3f (-0.5, 0.5, -0.5) -glVertex3f (-0.5, -0.5, -0.5) -glEnd () - // albastru Side - TOPOglBegin ( GL_POLYGON) -glColor3f (0,0, 0,0, 1,0) -glVertex3f (0,5, 0,5, 0,5) -glVertex3f (0,5, 0,5, -0.5) -glVertex3f (-0.5, 0.5, -0.5) -glVertex3f (-0,5, 0,5, 0,5 ) -glEnd () - // Side roșu - BASEglBegin (GL_POLYGON) -glColor3f (1,0, 0,0, 0,0) -glVertex3f (0.5, -0.5, -0.5) -glVertex3f (0.5, -0.5, 0.5) -glVertex3f (-0.5 , -0.5, 0.5) -glVertex3f (-0.5, -0.5, -0.5) -glEnd () - glFlush () - glutSwapBuffer s () -

Încă mai trebuie să adăugăm încă două linii în codul pentru această funcție.

Metoda 3
Interactivitatea utilizatorilor

1) specialKeys ()

Aproape am terminat, dar pentru moment nu putem crea decât un cub static. Nu putem roti. Pentru a face acest lucru, vom crea funcția specialăKeys () care ne va permite să apăsați tastele săgeată pentru a roti cubul!

Din cauza acestei funcții am declarat variabilele globale rotate_x și rotate_y. Când folosim săgețile din dreapta sau din stânga, variabila rotate_y va fi mărită sau scăzută cu 5 grade. În mod similar, atunci când utilizați săgețile în sus și în jos, variabila rotate_x se va schimba în același mod.

specialKeys void (int cheie, int x, int y) {// Săgeată dreapta - 5 mărește grausif rotație (cheie == GLUT_KEY_RIGHT) rotate_y = 5 + - // Săgeată stânga - 5 reduce grauselse rotație dacă ( cheie == GLUT_KEY_LEFT) rotate_y - = 5-else if (element == GLUT_KEY_UP) + = rotate_x-5 else if (cheie == GLUT_KEY_DOWN) rotate_x - 5 = - // Solicitare actualizare telaglutPostRedisplay () -}

2) glRotate ()

Pasul nostru final este să adăugăm o metodă care va roti obiectul. Să revenim la funcția "display ()" și înainte de a crea partea frontală a cubului, vom adăuga următoarele rânduri:

// Reset transformaçõesglLoadIdentity () - // Rotire atunci când modificați variabilele și rotate_x rotate_yglRotatef (rotate_x, 1,0, 0,0, 0,0) -glRotatef (rotate_y, 0.0, 1.0, 0.0) - // Side multicolori - FAȚĂ ....

Observați sintaxa funcției glRotatef () este similar cu sintaxa glColor3f () și glVertex3f (), dar acum cu 4 parametri. Primul parametru este gradul de rotație care trebuie aplicat. Ceilalți trei parametri definesc axa de referință care urmează să fie rotită, primul fiind x, al doilea y, iar al treilea z. Pentru moment, trebuie doar să ne rotim în jurul axelor x și y.
Toate transformările din programul nostru au nevoie de comenzi ca acestea. Cantitatea de rotație este definită de variabilele rotate_x și rotate_y pe axele respective. În ciuda acestui fapt, OpenGL simplifică totul și combină toate cele trei comenzi într-o singură transformare de matrice. De fiecare dată când apelăm funcția de afișare, programul va crea o matrice de transformare, iar funcția glLoadIdentity () se va asigura că întotdeauna începem cu o nouă matrice cu fiecare apel.
Alte transformări care pot fi de asemenea aplicate sunt glTranslatef () și glScalef (). Ele sunt similare cu glRotatef (), dar au nevoie doar de 3 parametri, cantitățile din x, y și z pentru a traduce sau scala obiectul.
Pentru a obține efectul corect când aplicați cele trei transformări unui obiect, trebuie să aplicați funcțiile într-o anumită ordine. Scrieți întotdeauna funcțiile în ordine glTranslate, glotate și glScale. OpenGL aplică transformările de jos în sus. Pentru a înțelege această particularitate, imaginați-vă cum ar arăta un simplu cub 1x1x1 dacă transformările au fost aplicate de sus în jos și de jos în sus.
Adăugați următoarele comenzi pentru a redimensiona cubul cu 2 pe axa x, 2 pe axa y, rotiți-l cu 180 de grade pe axa y și faceți o traducere de 0,1 spre axa x. Asigurați-vă că sortați funcțiile în ordinea corectă descrisă mai sus (dacă nu sunteți sigur, exemplul este afișat în codul sursă final la sfârșitul tutorialului).
```
// Alte transformărigTranslatef (0,1, 0,0,0,0) -glRotatef (180, 0,0, 1,0, 0,0) -glScalef (2,0, 2,0, 0,0)
```

compilarea

Ultimul pas pentru finalizarea primului nostru proiect este compilați și rotiți codul. Presupunând că utilizați gcc ca compilator implicit, utilizați aceste comenzi pe terminal pentru a compila și testa programul.
```
Pe Linux: gcc cube.c cub -lglut o- -lGL./ meucuboNo Mac: gcc foo foo.c -framework o- GLUT -framework OpenGL./ meucuboNo Ferestre: GCC -Wall -ofoo foo.c -lglut32cu -lglu32 - lopengl32./ meucubo
```

Metoda 4
Codul sursă finală

Am terminat programul. Am furnizat codul sursă complet de mai jos pentru a putea fi utilizat ca referință.

//// fișier: meucubo.c // Autor: Matt Daisley // Creat 25/4/2012 // Proiect: Source Code la articol Cum sa faci un cub în OpenGL // Descriere: Creează o fereastră de OpenGL și atrage o cub 3D.// Ceea ce utilizatorul se poate roti cu tastele săgeată // // Controale: săgeată spre stânga - roti spre stânga // săgeată dreapta - rotiți la dreapta // sus Arrow - Rotește sus // Set la Jos - rotiți în jos // ------------------------------------------ ---------------- // Includeri // ----------------------------- ----------------------------- # include #include #include #define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # alt # include # endif // ---------------------------------------------- ------------ // Declaratii de roluri // ------------------------------- --------------------------- void display () - void specialKeys () - // ----------- ----------------------------------------------- // Variabile Global // ----------------------------------------------- ----------- rotate_y rotate_x double-double = 0 = 0 - // --------------------------- ------------------------------- // funcția de afișare () // ----------- ----------------------------------------------- void display ( ) // Golește ecran și Z-BufferglClear (GL_COLOR_BUFFER_BIT // ----------------------------------- ----------------------- // funcția specialăCeasuri () // ------------------- --------------------------------------- void specialKeys (int, int, int și ) // {săgeată dreapta - 5 grausif rotație crește (tasta == GLUT_KEY_RIGHT) + = rotate_y 5 - stânga Arrow // - rotatie scade cu 5 grauselse if (cheie == GLUT_KEY_LEFT) rotate_y - = 5 else if ( cheie == GLUT_KEY_UP) rotate_x + = 5- else if (GLUT_KEY_DOWN == cheie) rotate_x - 5 = - // actualizare displayglutPostRedisplay Cerere () -} // ------------------------- --------------------------------- // Funcția principală () // --------- ------------------------------------------------- int main (int argc, char * argv []) GLUT_DEPTH) - // Crearea programaglutCreateWindow fereastra ( "Super cub") - // Permite testarea adâncimii Z-bufferglEnable (GL_DEPTH_TEST) - // FunçõesglutDisplayFunc (afișare) - glutSpecialFunc (specialKeys) - // control de trecere a evenimentelor pentru GLUTglutMainLoop () - // Revine la SOreturn 0-