OpenGL është një mjet i fuqishëm programimi 3D i përdorur për të nxjerrë skena komplekse tre-dimensionale nga primitivët e thjeshtë. Ky artikull do t'ju mësojë se si të vizatoni një kub të thjeshtë që mund ta rrotulloni për ta parë në tre dimensione!
Për këtë projekt do t'ju duhet një redaktues kodesh dhe disa njohuri për programimin C.
Hapa
Pjesa 1 nga 3: Konfigurimi fillestar
Hapi 1. Instaloni OpenGL Për të filluar ndiqni këto hapa për të instaluar OpenGL në sistemin tuaj
Nëse tashmë keni OpenGL, si dhe një përpilues të pajtueshëm C të instaluar, mund ta kaloni këtë hap dhe të shkoni te tjetri.
Hapi 2. Krijoni dokumentin
Krijoni një skedar të ri në redaktuesin tuaj të preferuar të kodeve dhe ruajeni si mycube.c
Hapi 3. Shto #përfshin
Këto janë përfshirjet themelore që do t'ju nevojiten për programin tuaj. Importantshtë e rëndësishme të kuptohet se në fakt ekzistojnë përfshirje të ndryshme të kërkuara për sisteme të ndryshme operative. Sigurohuni që t'i përfshini të gjitha këto për të siguruar që programi juaj është i gjithanshëm dhe mund të funksionojë për çdo përdorues.
// Përfshin #përfshi #përfshi #përfshi #përcakto GL_GLEXT_PROTOTIPAT #ifdef _APPLE_ #përfshi #të tjera #përfshi #endif
Hapi 4. Shtoni prototipe funksioni dhe variabla globale
Hapi juaj i ardhshëm është të deklaroni disa prototipe funksionesh.
// Prototipet e funksionit void display (); void specialKeys (); // Ndryshoret globale rrotullohen dyfish_y = 0; rrotullimi i dyfishtë_x = 0;
Hapi 5. Vendosni funksionin kryesor ()
int kryesore (int argc, char* argv ) {// Inicizoni GLUT dhe përpunoni parametrat e përdoruesit glutInit (& argc, argv); // Kërkoni dritare me ngjyrë të vërtetë të dyfishtë të ruajtur me Z-buffer glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
Hapi 6. Krijoni dritaren
Hapi tjetër është që të krijo dritaren brenda së cilës do të vizatoni kubin. Në këtë tutorial, dritarja quhet "Kubi i Tmerrshëm".
// Krijo dritare glutCreateWindow ("Kubi i mrekullueshëm");
Hapi 7. Aktivizo testin e thellësisë
OpenGL është një gjuhë e rreptë në atë që nuk supozon se janë aktivizuar ndonjë veçori e veçantë. Që programi juaj të shfaqet siç duhet në 3 dimensione duke përdorur tamponin Z që keni parë më herët, ju duhet aktivizoni testin e thellësisëMe Ndërsa vazhdoni të eksploroni OpenGL, do të zbuloni shumë veçori që do t'ju nevojiten për të aktivizuar, përfshirë ndriçimin, teksturat, përballjen me zhurmë dhe shumë më tepër.
// Aktivizo testin e thellësisë Z-buffer glEnable (GL_DEPTH_TEST);
Hapi 8. Shtoni funksionet e kthimit të thirrjes
Këtu janë funksionet e thirrjes për të cilat keni shkruar prototipet më herët. Çdo herë përmes lakut kryesor, këto funksione do të thirren. Funksioni i ekranit rishikon skenën bazuar në çdo ndryshim në ndryshoret që janë bërë që nga thirrja e mëparshme. Funksioni specialKeys na lejon të ndërveprojmë me programin.
// Funksionet e kthimit mbrapsht glutDisplayFunc (ekran); glutSpecialFunc (Keys special);
Hapi 9. Filloni MainLoop
Kjo do të kujtojë funksionin kryesor derisa të mbyllni programin për të lejuar animacione dhe ndërveprim me përdoruesit.
// Kaloni kontrollin në GLUT për ngjarjet glutMainLoop (); // Kthimi në OS kthimi 0; }
Pjesa 2 nga 3: Funksioni i ekranit ()
Hapi 1. Kuptoni qëllimin e këtij funksioni
E gjithë puna e vizatimit të kubit tuaj do të bëhet në këtë funksion. Ideja e përgjithshme pas kubit tuaj është të vizatoni të gjashtë anët individualisht dhe t'i vendosni në pozicionin e duhur.
Konceptualisht, secila anë do të vizatohet duke përcaktuar katër qoshet dhe duke lejuar që OpenGL të lidhë linjat dhe ta mbushë atë me një ngjyrë që ju përcaktoni. Më poshtë janë hapat për ta bërë këtë
Hapi 2. Shto glClear ()
Hapi i parë që duhet të bëni në këtë funksion është të pastroni ngjyrën dhe tamponin ZMe Pa këto hapa, vizatimet e vjetra mund të jenë ende të dukshme nën vizatimet e reja dhe objektet e vizatuara nuk do të jenë në vendin e duhur në ekran.
ekran i pavlefshëm () {// Pastro ekranin dhe Z-tampon glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Hapi 3. Shtoni glBegin () dhe glEnd ()
OpenGL përcakton objektet si kombinime të shumëkëndëshave të ndryshëm. Duke perdorur glBegin () komandë, ju në mënyrë efektive vendosni një laps që do të tërheqë një formë. Për të ngritur lapsin dhe për të filluar një formë të re, duhet të përdorni glEnd () komandë. Në këtë tutorial do të përdorni GL_POLYGON për të vizatuar secilën anë të kubit, por është e mundur të përdorni opsione të tjera parametrash si GL_LINE, GL_QUAD ose GL_TRIANGLE për të krijuar forma të tjera.
- Këtu do të filloni me pjesën e përparme të kubit tuaj. Më vonë do të shtoni ngjyrë në të 6 anët.
// Ana me shumë ngjyra - FRONT glBegin (GL_POLYGON); // Vertices do të shtohen në hapin tjetër glEnd ();
Hapi 4. Shto glVertex3f ()
Pasi të keni deklaruar se doni të filloni poligonin tuaj, duhet ta bëni përcaktojnë kulmet të objektit. glVertex ka forma të shumta në varësi të asaj që dëshironi të bëni me objektin tuaj.
- E para është në sa dimensione po punoni. 3 -të e mësipërme në glVertex3f thotë se po vizatoni në 3 dimensione. Gjithashtu është e mundur të punohet në 2 ose 4 dimensione. F më sipër në glVertex3f thotë se po punoni me numra të pikave lundruese. Ju gjithashtu mund të përdorni pantallona të shkurtra, numra të plotë ose dyshe.
- Vini re se këto pika përcaktohen në a në drejtim të kundërt të akrepave të orës mënyrë. Kjo nuk është shumë e rëndësishme për momentin, por kur të filloni të punoni me ndriçim, tekstura dhe ballafaqim, kjo do të bëhet tepër e rëndësishme, kështu që bëjeni zakon të përcaktoni pikat tuaja në drejtim të kundërt të akrepave të orës.
- Shtoni shtoni kulmet midis linjave glBegin () dhe glEnd ().
// Ana me shumë ngjyra - FRONT glBegin (GL_POLYGON); glVertex3f (-0.5, -0.5, -0.5); // P1 glVertex3f (-0.5, 0.5, -0.5); // P2 glVertex3f (0.5, 0.5, -0.5); // P3 glVertex3f (0.5, -0.5, -0.5); // P4 glEnd ();
Hapi 5. Shto glColor3f ()
glColor punon në një mënyrë të ngjashme me glVertex. Ju mund t'i përcaktoni pikat si pantallona të shkurtra, numra të plotë, dyshe ose nota. Çdo ngjyrë ka një vlerë nga 0 në 1. Të gjitha 0 -të e bëjnë pikën të zezë dhe të gjitha 1 -të do ta bëjnë pikën të bardhë. 3 në glColor3f () i referohet sistemit të ngjyrave RGB pa kanal alfa. Alfa e një ngjyre përcakton transparencën e saj. Për të ndryshuar nivelin alfa, përdorni glColor4f () me parametrin e fundit që është një vlerë prej 0 në 1 për të errët në transparent.
- Kur thërrisni glColor3f () çdo kulm i tërhequr nga ajo pikë e tutje do të jetë i asaj ngjyre. Prandaj, nëse doni që të katër kulmet të jenë të kuq, thjesht vendosni ngjyrën një herë në çdo kohë para komandave glVertex3f () dhe të gjitha kulmet do të jenë të kuqe.
- Ana e përparme e përcaktuar më poshtë tregon se si të përcaktohet një ngjyrë e re për secilën kulm. Kur e bëni këtë, mund të shihni një pronë interesante të ngjyrave OpenGL. Meqenëse çdo kulm i poligonit ka ngjyrën e vet, OpenGL automatikisht do të përziejë ngjyrat! Hapi tjetër do të tregojë se si të caktohen katër kulme me të njëjtën ngjyrë.
// Ana me shumë ngjyra - FRONT glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1 është e kuqe glColor3f (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2 është e gjelbër glColor3f (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3 është blu glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4 është glEnd vjollce ();
Hapi 6. Trajtoni anët e tjera
Punoni se cila do të jetë vendndodhja e secilës kulm për pesë anët e tjera të kubit, por për thjeshtësi, këto janë llogaritur për ju dhe përfshihen në funksioni përfundimtar i shfaqjes () më poshtë.
// Ana e bardhë - SIPAS glBegin (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 (); // Ana e purpurt - E DREJTA glBegin (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 (); // Ana e gjelbër - LEFT glBegin (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 (); // Ana blu - TOP glBegin (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 (); // Ana e kuqe - BOTTOM glBegin (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 (); glutSwapBuffers (); }
Ne gjithashtu duam të shtojmë dy rreshta të fundit të kodit për këtë funksion. Këto janë glFlush ();
dhe glutSwapBuffers ();
të cilat na japin efektin e ruajtjes së dyfishtë për të cilën keni mësuar më herët.
Pjesa 3 nga 3: Interaktiviteti i Përdoruesit
Hapi 1. Shtoni çelësat specialë ()
Ju jeni pothuajse gati, por për momentin, ju mund të vizatoni një kub, por nuk keni asnjë mënyrë për ta rrotulluar atë. Për ta bërë këtë, ju do krijoni një çelës special () funksion për të na lejuar të shtypim butonat me shigjeta dhe të rrotullojmë kubin!
- Ky funksion është arsyeja pse ju deklaruat ndryshoret globale rotate_x dhe rotate_y. Kur shtypni shigjetat e djathta dhe të majta, rotate_y do të rritet ose zvogëlohet me 5 gradë. Në mënyrë të ngjashme, kur shtypni shigjetat lart dhe poshtë, rotate_x do të ndryshojë në përputhje me rrethanat.
çelësat e pavlefshëm (çelësi int, int x, int y) {// Shigjeta e djathtë - rrit rrotullimin me 5 shkallë nëse (çelësi == GLUT_KEY_RIGHT) rrotullohet_y += 5; // Shigjeta e majtë - zvogëloni rrotullimin me 5 shkallë tjetër nëse (çelësi == GLUT_KEY_LEFT) rrotullohet_y - = 5; përndryshe nëse (çelësi == GLUT_KEY_UP) rrotullohet_x += 5; përndryshe nëse (çelësi == GLUT_KEY_DOWN) rrotullohet_x -= 5; // Kërko përditësimin e ekranit glutPostRedisplay (); }
Hapi 2. Shto glRotate ()
Deklarata juaj e fundit është të shtoni deklaratën që do të rrotullojë objektin tuaj. Kthehuni te funksioni i ekranit () dhe para anës FRONT, shtoni këto rreshta:
// Rivendos transformimet glLoadIdentity (); // Rrotulloni kur përdoruesi ndryshon rotate_x dhe rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // Ana me shumë ngjyra - FRONT….
Hapi 3. Shtoni komandat e mëposhtme për të shkallëzuar kubin me 2 përgjatë boshtit x, 2 përgjatë boshtit y, rrotulloni kubin me 180 gradë rreth boshtit y dhe përktheni kubin me 0.1 përgjatë boshtit x
Sigurohuni që t'i rregulloni këto si dhe komandat e mëparshme glRotate () në rendin e duhur siç përshkruhet më sipër. (Nëse nuk jeni të sigurt, kjo bëhet në kodin përfundimtar në fund të mësimit.)
// Transformime të tjera glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);
Hapi 4. Përpiloni dhe ekzekutoni kodin tuaj
Duke supozuar se jeni duke përdorur gcc si përpiluesin tuaj, ekzekutoni këto komanda nga terminali juaj për të përpiluar dhe testuar programin tuaj.
Në Linux: gcc cube.c -o cube -lglut -lGL./ mycube Në Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL./ mycube Në Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32./ mycube
Hapi 5. Kontrolloni kodin tuaj të plotë
Duhet të jetë kështu:
// // Skedari: mycube.c // Autori: Matt Daisley // Krijuar: 4/25/2012 // Projekti: Kodi burimor për Bëni një kub në OpenGL // Përshkrimi: Krijon një dritare OpenGL dhe vizaton një kub 3D/ / Që përdoruesi të mund të rrotullohet duke përdorur shigjetat // // Kontrollet: Shigjeta e Majtë -Rrotulloni Majtas // Shigjeta e Djathtë -Rrotullojeni djathtas // Shigjeta lart -Rrotulloni lart // Shigjeta poshtë -Rrotulloni poshtë // ------ ------------------------------------------------------ -// Përfshin // ----------------------------------------------- -------- ---------------------------------------------- // Prototipet e funksionit / / ----------------------------------------------------- --------- shfaqje e pavlefshme (); void specialKeys (); // ---------------------------------------------------- ---------- // Variablat Globale // ---------------------------------- ------------------------ dyfisho rrotullimin_y = 0; rrotullimi i dyfishtë_x = 0; // ---------------------------------------------------- ---------- // shfaq () funksioni i kthimit të thirrjes // ---------------------------------- --------------------------- ekran i pavlefshëm () {// Pastro ekranin dhe Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Rivendos transformimet glLoadIdentity (); // Transformime të tjera // glTranslatef (0.1, 0.0, 0.0); // Nuk përfshihet // glRotatef (180, 0.0, 1.0, 0.0); // Nuk përfshihet // Rrotullo kur përdoruesi ndryshon rotate_x dhe rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // Transformime të tjera // glScalef (2.0, 2.0, 0.0); // Nuk përfshihet // Ana me shumë ngjyra - FRONT glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1 është e kuqe glColor3f (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2 është e gjelbër glColor3f (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3 është blu glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4 është glEnd vjollce (); // Ana e bardhë - SIPAS glBegin (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 (); // Ana e purpurt - E DREJTA glBegin (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 (); // Ana e gjelbër - LEFT glBegin (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 (); // Ana blu - TOP glBegin (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 (); // Ana e kuqe - BOTTOM glBegin (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 (); glutSwapBuffers (); } // -------------------------------------------------- ----------- // specialKeys () Funksioni i kthimit të thirrjeve // ------------------------------ ---------------------------- Çelësat specialë të pavlefshëm (çelësi int, int x, int y) {// Shigjeta e djathtë-rris rrotullimin me 5 shkalla nëse (çelësi == GLUT_KEY_RIGHT) rrotullo_y += 5; // Shigjeta e majtë - zvogëloni rrotullimin me 5 shkallë tjetër nëse (çelësi == GLUT_KEY_LEFT) rrotullohet_y - = 5; përndryshe nëse (çelësi == GLUT_KEY_UP) rrotullohet_x += 5; përndryshe nëse (çelësi == GLUT_KEY_DOWN) rrotullohet_x -= 5; // Kërko përditësimin e ekranit glutPostRedisplay (); } // -------------------------------------------------- ----------- // funksioni kryesor () // ---------------------------------- --------------------------- int main (int argc, char* argv ) {// Inicializoni GLUT dhe përpunoni parametrat e përdoruesit glutInit (& argc, argv); // Kërkoni dritare me ngjyrë të vërtetë të dyfishtë të ruajtur me Z-buffer glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Krijo dritare glutCreateWindow ("Kubi i mrekullueshëm"); // Aktivizo testin e thellësisë Z-buffer glEnable (GL_DEPTH_TEST); // Funksionet e kthimit mbrapsht glutDisplayFunc (ekran); glutSpecialFunc (Keys special); // Kaloni kontrollin në GLUT për ngjarjet glutMainLoop (); // Kthimi në OS kthimi 0; }
