Sådan opretter du en OpenGL Cube

OpenGL er et kraftfuldt 3D programmeringsværktøj, der bruges til at skabe komplekse tredimensionale kompositioner afledt af simple former. Denne artikel vil lære dig, hvordan du opretter en simpel terning, der kan roteres for at ses i tre dimensioner!

Til dette projekt skal du have en kildekode editor og lidt viden i C programmeringssproget.

trin

Metode 1
Indledende konfiguration og hovedfunktionen ()

1) Installer OpenGL

Følg disse instruktioner for at komme i gang at installere OpenGL på dit system. Hvis du allerede har OpenGL og en C compiler, spring over dette trin og gå videre til den næste.

2) Opret dokumentet

Opret en ny fil i din foretrukne kode editor og gem den som meucubo.c

3) #includes

Der er grundlæggende indlejringer, som du skal oprette programmet. Det er vigtigt at huske på, at pakkerne der skal inkluderes, kan ændre sig afhængigt af operativsystemet. Sørg for at inkludere alle pakker, der sikrer, at dit program er alsidigt og kan bruges af enhver bruger.
```
// Inkluderinger # inkluderer #include #include #define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # andet # inkluderer #endif
```

4) Funktionserklæringerne og de globale variabler

Vores næste skridt er at erklære nogle funktioner.

// display Funçõesvoid erklæringer () - specialKeys void () - // Variabler Globaisdouble double-rotate_y = 0 = 0- rotate_x

Disse funktioner og variabler vil blive forklaret i detaljer under vejledningen. For nu, bare stop ved at erklære dem.

5) Konfiguration af hovedfunktionen ()

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

Denne kommando indstiller miljøet. Et vigtigt aspekt ved programmering i OpenGL er, at du skal bestille alt. Så det er nødvendigt, at du har en detaljeret forståelse af, hvordan dit program virker og hvad der skal medtages i koden til at skabe den funktionalitet, du ønsker. I denne linje skabte vi præsentationsskærmen i programmet med dobbelt buffer, RGB farver og en Z-buffer.
"Double Buffer" er en teknik, der bruges i grafiske programmer til at eliminere problemer, der opstår ved tegning af billeder på skærmen. Hver gang en scene skal opdateres, skal skærmen slettes, og de nye oplysninger trækkes. Uden dobbeltbufferen vil du bemærke en oscillerende effekt, mens skærmen slettes og genopbygges hurtigt.

Problemet løses ved at tilføje en anden buffer til skærmrutinerne på skærmen. Med denne metode trækkes billedet først i bufferen, og derefter vises bufferen på skærmen. Den næste ramme af scenen trækkes i den anden buffer, og når processen er færdig, vil bufferne blive omvendt. Umiddelbart vil vi se den anden buffer, men i mellemtiden bliver den første buffer gemt, slettet og genoprettet med en tredje ramme, der vil blive vist, når den er færdiggjort.
Vi ønsker også at tillade "RGB" farvesystemet i vores vindue. Vi viser, hvordan farven bruges i OpenGL, når du arbejder med "display" -funktionen.
Z-buffering er værktøjet brugt til at oprette de 3D-effekter, vi ønsker. OpenGL bruger et tre-koordinatsystem med x, y og z akser. For at give den effekt, at et objekt er tættere på dig, øges din position på z-aksen. For at påvirke den inverse effekt er dens position på z-aksen reduceret. Vi taler lidt mere om dette, når vi skaber vores kubes hjørner.

6) Oprettelse af programvinduet

Det næste skridt er at opret vinduet hvor vores terning bliver tegnet. I denne vejledning kalder vi vores "Super Cube" vindue.
```
// Opret janelaglutCreateWindow ("Super Cube") -
```

7) Aktiver dybdestest

OpenGL er et begrænset sprog, der ikke har nogen specielle funktioner aktiveret som standard. For vores program at præsentere 3D-billederne korrekt ved hjælp af Z-bufferen, skal vi aktivere "dybdestesten". Når du udforsker OpenGL, vil du opdage flere funktioner, der skal aktiveres, såsom belysning og teksturer.
```
// Aktiver Z-bufferglEnable depth test (GL_DEPTH_TEST) -
```

8) Tilbagekaldelsesfunktioner

Her er de tilbagekaldelsesfunktioner, vi skrev i de foregående udsagn. Disse funktioner kaldes hver gang programmet cykler gennem hovedløkken. Displayfunktionen genopretter scenen baseret på en ændring i de variabler, der er foretaget siden sidste opkald. Funktionen SpecialKeys giver os mulighed for at interagere med programmet.
```
// Funktioner callbackglutDisplayFunc (display) -glutSpecialFunc (specialKeys) -
```

9) Tilbagekaldelsesfunktioner

Det sidste trin i vores første opsætning er start MainLoop. Dette vil kalde hovedfunktionen, indtil vi lukker programmet, så animationer og interaktion med brugeren kan gøres.
```
// Passerer kontrol til begivenheder GLUTglutMainLoop () - // Tilbage til SOreturn 0-
```

Metode 2
Skærmfunktionen ()

Alt arbejdet i tegning af terningen skal udføres i denne funktion. Den generelle idé bag terningen er at tegne alle seks sider individuelt og placere dem i de rigtige positioner.
Konceptuelt bliver hver side tegnet ved at definere sine fire hjørner, så lad OpenGL forbinde linjerne og udfylde en valgt farve. Nedenfor er trinnene for at gøre dette.

1) glClear ()

Det første skridt, vi skal udføre i denne funktion er Fjern farven og Z-bufferen. Uden disse trin kan de gamle tegninger ses blandt de nye oplysninger, og objekterne vil ikke være i den rigtige placering på skærmen.
```
void display () GL_DEPTH_BUFFER_BIT) -
```

2) glBegin () og glEnd ()

OpenGL definerer objekter som kombinationer af forskellige polygoner. Når du bruger kommandoen glBegin (), vi fortæller OpenGL, at den er klar til at tegne det format, vi ønsker. For at afslutte processen og starte et nyt format, skal vi bruge kommandoen glEnd (). I denne tutorial, vil vi bruge GL_POLYGON at tegne hver side af terningen, men det er også muligt at anvende andre parametre som GL_LINE, GL_QUAD GL_TRIANGLE eller oprette andre former.

Lad os starte med kubens front. Vi vil tilføje farverne til de 6 sider senere.

// Flerfarvede Side - FRENTEglBegin (GL_POLYGON) - // De knudepunkter vil blive tilføjet i næste etapaglEnd () -

3) glVertex3f ()

Når vi erklærer at vi vil starte vores polygon, skal vi definer hjørnerne af objektet. Funktionen glVertex har flere måder at gøre dette afhængigt af, hvordan du vil have objektet.
Video: How to Draw a Half Circle in Adobe Illustrator
Den første mulighed er, i hvor mange dimensioner du vil arbejde med. De 3 i glVertex3f siger, at vi tegner i 3 dimensioner. Det er også muligt at arbejde i 2 eller 4 dimensioner. F i glVertexf fortæller os, at vi arbejder med float (floating point) tal. Du kan også bruge andre typer data, som f.eks. Shorts, heltal eller doubler.
Bekræft, at disse punkter er angivet i rækkefølge mod uret. Det er ikke så vigtigt nu, men når vi begynder at arbejde med belysning og teksturer, er det yderst nødvendigt at være vant til at sætte punkterne i en modsat retning.

Nu kan vi tilføje punkterne mellem kommandoerne glBegin () og glEnd ().

// Flerfarvede 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 ()

den glColor fungerer på samme måde som glVertex. Vi kan definere punkterne som shorts, heltal, doubler eller floats. Hver farve har en værdi fra 0 til 1. Alt som 0 vil forlade det sorte punkt, og alt som 1 vil forlade det hvide punkt. De 3 i glColor3f () refererer til RGB-systemet uden alfakanal. Alfabetet af en farve er, hvad der definerer dets gennemsigtighed. For at ændre alfa-niveauet skal du bruge kommandoen glColor4f (), hvor den sidste parameter er en værdi mellem 0 og 1, for henholdsvis uigennemsigtig til gennemsigtig.
Når opkaldet glColor3f () funktion, designet hvert hjørne punkt er, at den definerede farve. Hvis du vil have de fire hjørner er røde, bare indstille farven engang glVertex3f () kommando før og alle knuder er røde.

Frontfladen defineret nedenfor viser, hvordan vi definerer en ny farve for hvert hjørne. Når vi gør dette, kan vi se en interessant egenskab af OpenGL farver. Da hvert hjørne af polygonen har sin egen farve, vil OpenGL blande dem automatisk! Det næste trin viser dig, hvordan du opretter fire hjørner af samme farve.

// Flerfarvede Side - FrenteglBegin (GL_POLYGON) -glColor3f (1,0, 0,0, 0,0) - glVertex3f (0,5, -0,5, -0,5) - // P1 er vermelhoglColor3f (0,0, 1,0, 0,0) - glVertex3f (0,5, 0,5, - 0,5) - // P2 er verdeglColor3f (0,0, 0,0, 1,0) - glVertex3f (-0,5, 0,5, -0,5) - // P3 er azulglColor3f (1,0, 0,0, 1,0) - glVertex3f (-0,5, -0,5, -0,5 ) - // P4 er roxoglEnd () -

5) De andre sider

Vi anbefaler at du opdager placeringen af hver af de fem fem sides hjørner, men for enkelhed beregner vi dem allerede for dig og indgår dem i vores endelig visning () funktion nedenfor.

Video: Et analog ur i geogebra

// Hvid side - 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 () - lilla side // - 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 () - // grøn Side - 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 () - // blå 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 () - // red Side - 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 () -

Vi skal stadig tilføje to linjer i koden for denne funktion.

Metode 3
Brugerinteraktivitet

1) specialKeys ()

Vi er næsten færdige, men for nu kan vi kun oprette en statisk terning. Vi kan ikke rotere det. For at gøre dette vil vi oprette specialKeys () funktion som vil tillade os at trykke piletasterne for at dreje terningen!

Det var på grund af denne funktion, at vi erklærede de globale variabler rotate_x og rotate_y. Når vi bruger højre eller venstre pile, vil rotate_y variablen blive forøget eller formindsket med 5 grader. Tilsvarende ændres rotat_x-variablen på samme måde, når du bruger op- og nedpilene.

specialKeys void (nøgle int, int x, int y) {// Højre pil - 5 forøger rotation grausif (nøgle == GLUT_KEY_RIGHT) rotate_y = 5 + - // Venstre pil - 5 reducerer rotation grauselse if ( nøgle == GLUT_KEY_LEFT) rotate_y - = 5-else if (key == GLUT_KEY_UP) + = rotate_x-5 ellers hvis (nøgle == GLUT_KEY_DOWN) rotate_x - 5 = - // opdatering Request telaglutPostRedisplay () -}

2) glRotate ()

Vores sidste trin er at tilføje en metode, der vil rotere objektet. Lad os gå tilbage til "display ()" -funktionen, og inden vi skaber kubens forside, tilføjer vi disse linjer:

// Nulstil transformaçõesglLoadIdentity () - // Roter, når du ændrer de variabler og rotate_x rotate_yglRotatef (rotate_x, 1,0, 0,0, 0,0) -glRotatef (rotate_y, 0,0, 1,0, 0,0) - // Flerfarvede Side - FRONT ....

Bemærk, at funktionssyntaxen glRotatef () svarer til syntaksen af glColor3f () og glVertex3f (), men nu med 4 parametre. Den første parameter er den rotationsgrad, der skal anvendes. De øvrige tre parametre definerer referenceaksen, der skal drejes, den første er x, den anden y og den tredje z. For nu er vi bare nødt til at rotere rundt om x og y aksen.
Alle transformationerne i vores program har brug for kommandoer som disse. Rotationsmængden er defineret af rotate_x og rotere_y variabler på respektive akser. På trods af dette forenkler OpenGL alt og kombinerer alle tre kommandoer til kun en array transformation. Hver gang vi kalder displayfunktionen, vil programmet oprette en transformationsmatrix og funktionen glLoadIdentity () vil sikre, at vi altid starter med en ny matrix med hvert opkald.
Andre transformationer, som også kan anvendes, er glTranslatef () og glScalef (). De ligner glRotatef (), men behøver kun 3 parametre, mængderne i x, y og z for at oversætte eller skala objektet.
For at opnå den korrekte effekt, når du bruger de tre transformationer til et objekt, skal du anvende funktionerne i en bestemt rækkefølge. Skriv altid funktionerne i ordren glTranslate, glRotate og glScale. OpenGL anvender transformationerne fra bunden opad. For at forstå denne ejendommelighed, forestill dig, hvordan en simpel 1x1x1 terning ville se ud, hvis transformationerne blev anvendt fra top til bund og fra bund til top.
Tilføje følgende kommandoer for at ændre størrelsen terningen på x-aksen med 2, 2 på y-aksen, drej det 180 grader på y-aksen og gøre en oversættelse af 0,1 mod x-aksen. Sørg for at bestille funktionerne i den rigtige rækkefølge er beskrevet ovenfor (hvis du ikke er sikker, er det viste eksempel i slutningen kildekoden i tutorial færdig).
```
// Andre transformationer glTranslatef (0,1, 0,0, 0,0) -glRotatef (180, 0,0, 1,0, 0,0) -glScalef (2,0, 2,0, 0,0) -
```

kompilering

Det sidste skridt til at færdiggøre vores første projekt er kompilere og rotere koden. Hvis du antager at du bruger gcc som standardkompilator, skal du bruge disse kommandoer på din terminal for at kompilere og teste programmet.
```
På Linux: gcc -o cube.c terning -lglut -lGL./ meucuboNo Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL./ meucuboNo Windows: gcc -Wall -ofoo foo.c -lglut32cu -lglu32 - lopengl32./ meucubo
```

Metode 4
Endelig Kildekode

Vi er færdige med programmet. Vi har leveret den komplette kildekode nedenfor for at du kan bruge som reference.

//// Fil: meucubo.c // Forfatter: Matt Daisley // Oprettet 25/4/2012 // Projekt: Source Code til artiklen Hvordan man laver en terning i OpenGL // Beskrivelse: Opretter en OpenGL vindue og trækker et terning 3D.// Hvad brugeren kan rotere med piletasterne // // Kontrol: pil til venstre - drej til venstre // højre pil - drej til højre // op pil - roterer op // Set til ned - rotere ned // ------------------------------------------ ---------------- // Inklusioner // ----------------------------- ----------------------------- # inkludere #include #include #define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # andet # inkluderer # endif // ---------------------------------------------- ------------ // Rolleerklæringer // ------------------------------- --------------------------- ugyldig display () - void specialKeys () - ----------- // ----------------------------------------------- // Variabler Global // ----------------------------------------------- ----------- rotate_y dobbelt-dobbelt rotate_x = 0 = 0 - // --------------------------- ------------------------------- // display funktion () // ----------- ----------------------------------------------- void display ( ) // Rydder skærmen og Z-BufferglClear (GL_COLOR_BUFFER_BIT // ----------------------------------- ----------------------- // funktion specialKeys () // ------------------- --------------------------------------- void specialKeys (int nøgle, int x, int og ) // {højre pil - 5 grausif rotation stigninger (nøgle == GLUT_KEY_RIGHT) + = rotate_y 5 - venstre arrow // - rotation falder med 5 grauselse hvis (nøgle == GLUT_KEY_LEFT) rotate_y - = 5-else if ( nøgle == GLUT_KEY_UP) rotate_x + = 5- ellers hvis (nøgle == GLUT_KEY_DOWN) rotate_x - 5 = - // opdatering displayglutPostRedisplay Request () -} // ------------------------- --------------------------------- // Funktion hoved () // --------- ------------------------------------------------- int main (int argc, char * argv []) GLUT_DEPTH) - // Opret vinduet programaglutCreateWindow ( "Super Cube") - // Aktiverer dybde test Z-bufferglEnable (GL_DEPTH_TEST) - // FunçõesglutDisplayFunc (display) - glutSpecialFunc (specialKeys) - // Pass kontrol af begivenhederne for den GLUTglutMainLoop () - // Vender tilbage til SOreturn 0-