Ang OpenGL ay isang malakas na tool sa pagprograma ng 3D na ginamit upang gumuhit ng mga kumplikadong three-dimensional na eksena mula sa mga simpleng primitibo. Ituturo sa iyo ng artikulong ito kung paano gumuhit ng isang simpleng kubo na maaari mong iikot upang matingnan sa tatlong sukat!
Para sa proyektong ito kakailanganin mo ang isang code editor at ilang kaalaman sa C program.
Mga hakbang
Bahagi 1 ng 3: Paunang Pag-set up
Hakbang 1. I-install ang OpenGL Upang simulang sundin ang mga hakbang na ito sa pag-install ng OpenGL sa iyong system
Kung mayroon ka nang OpenGL, pati na rin ang isang katugmang C compiler na naka-install, maaari mong laktawan ang hakbang na ito at pumunta sa susunod.
Hakbang 2. Lumikha ng dokumento
Lumikha ng isang bagong file sa iyong paboritong editor ng code at i-save ito bilang mycube.c
Hakbang 3. Magdagdag ng #includes
Ito ang pangunahing mga kasamang kakailanganin mo para sa iyong programa. Mahalagang mapagtanto na mayroong talagang magkakaibang mga kasamang kinakailangan para sa iba't ibang mga operating system. Tiyaking isama ang lahat ng ito upang matiyak na maraming nalalaman ang iyong programa at maaaring tumakbo para sa anumang gumagamit.
// May kasamang #include #include #include #define GL_GLEXT_PROTOTYPES #ifdef _APPLE_ #include #else #include #endif
Hakbang 4. Magdagdag ng mga prototype ng pag-andar at mga variable ng pandaigdigan
Ang iyong susunod na hakbang ay upang ideklara ang ilang mga prototype ng pag-andar.
// Function Prototypes void display (); walang bisa mga specialKeys (); // Global Variables doble rotate_y = 0; doble paikutin_x = 0;
Hakbang 5. I-set up ang pangunahing () pagpapaandar
int main (int argc, char * argv ) {// Initialize GLUT at iproseso ang mga parameter ng gumagamit glutInit (& argc, argv); // Humiling ng dobleng buffered totoong window ng kulay na may Z-buffer glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
Hakbang 6. Lumikha ng window
Ang susunod na hakbang ay upang lumikha ng window sa loob nito ay iguhit mo ang kubo. Sa tutorial na ito, ang window ay tinatawag na "Galing Cube".
// Lumikha ng window glutCreateWindow ("Kahanga-hanga Cube");
Hakbang 7. Paganahin ang pagsubok sa lalim
Ang OpenGL ay isang mahigpit na wika na hindi nito ipinapalagay ang anumang mga espesyal na tampok na pinagana. Para maipakita nang maayos ang iyong programa sa 3-dimensyon gamit ang Z-buffer na tiningnan mo nang mas maaga, kailangan mo paganahin ang deep-test. Sa pagpapatuloy mong tuklasin ang OpenGL, madidiskubre mo ang maraming mga tampok na kakailanganin mong paganahin kabilang ang pag-iilaw, mga texture, nakaharap sa cull at marami pa.
// Paganahin ang Z-buffer lalim na pagsubok na glEnable (GL_DEPTH_TEST);
Hakbang 8. Magdagdag ng mga pagpapaandar sa callback
Narito ang mga function ng callback na isinulat mo ang mga prototype para sa mas maaga. Sa bawat oras sa pamamagitan ng pangunahing loop, ang mga pagpapaandar na ito ay tatawagin. Ang pagpapaandar ng display ay binabago muli ang eksena batay sa anumang mga pagbabago sa mga variable na ginawa mula noong nakaraang tawag. Pinapayagan kami ng pagpapaandar ng specialKeys na makipag-ugnay sa programa.
// Callback function glutDisplayFunc (display); glutSpesyalFunc (specialKeys);
Hakbang 9. Simulan ang MainLoop
Maaalala nito ang pangunahing pagpapaandar hanggang sa isara mo ang programa upang payagan ang mga animasyon at pakikipag-ugnay ng gumagamit.
// Pass control to GLUT para sa mga kaganapan glutMainLoop (); // Return to OS return 0; }
Bahagi 2 ng 3: Ang display () Pag-andar
Hakbang 1. Maunawaan ang layunin ng pagpapaandar na ito
Ang lahat ng mga gawain ng pagguhit ng iyong kubo ay magagawa sa pagpapaandar na ito. Ang pangkalahatang ideya sa likod ng iyong kubo ay upang iguhit ang lahat ng anim na panig nang isa-isa at ilagay ang mga ito sa naaangkop na posisyon.
Konseptwal, ang bawat panig ay iguguhit sa pamamagitan ng pagtukoy sa apat na sulok at hayaan ang OpenGL na ikonekta ang mga linya at punan ito ng isang kulay na tinukoy mo. Nasa ibaba ang mga hakbang sa paggawa nito
Hakbang 2. Magdagdag ng glClear ()
Ang unang hakbang na kailangan mong gawin sa pagpapaandar na ito ay upang limasin ang kulay at Z buffer. Kung wala ang mga hakbang na ito, maaaring makita pa rin ang mga lumang guhit sa ilalim ng mga bagong guhit at ang mga bagay na iginuhit ay wala sa tamang lokasyon sa screen.
walang bisa ang pagpapakita () {// I-clear ang screen at Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Hakbang 3. Magdagdag ng glBegin () at glEnd ()
Tinutukoy ng OpenGL ang mga bagay bilang mga kumbinasyon ng iba't ibang mga polygon. Gamit ang glBegin () utos, mabisa mong inilagay ang isang lapis na iguhit ang isang hugis. Upang iangat ang lapis at magsimula ng isang bagong hugis, dapat mong gamitin ang glEnd () utos Sa tutorial na ito gagamit ka ng GL_POLYGON upang iguhit ang bawat panig ng kubo ngunit posible na gumamit ng iba pang mga pagpipilian sa parameter tulad ng GL_LINE, GL_QUAD, o GL_TRIANGLE upang lumikha ng iba pang mga hugis.
- Dito ka magsisimula sa harap ng iyong cube. Mamaya magdagdag ka ng kulay sa lahat ng 6 na panig.
// Multi-kulay na gilid - FRONT glBegin (GL_POLYGON); // Ang mga Vertice ay idaragdag sa susunod na hakbang glEnd ();
Hakbang 4. Magdagdag ng glVertex3f ()
Kapag naipahayag mo na nais mong simulan ang iyong polygon, kailangan mo tukuyin ang mga vertex ng bagay. Ang glVertex ay may maraming mga form depende sa kung ano ang nais mong gawin sa iyong object.
- Ang una ay kung gaano karaming mga sukat ka nagtatrabaho. Ang 3 sa itaas sa glVertex3f ay nagsasabi na gumuhit ka sa 3 sukat. Posible ring magtrabaho sa 2 o 4 na sukat. Sinasabi ng f sa itaas sa glVertex3f na nagtatrabaho ka sa mga lumulutang na numero ng point. Maaari mo ring gamitin ang mga shorts, integer o doble.
- Pansinin na ang mga puntong ito ay tinukoy sa a pakaliwa paraan Hindi ito gaanong mahalaga sa ngayon ngunit kapag nagsimula kang magtrabaho kasama ang pag-iilaw, pagkakayari, at nakaharap sa cull, ito ay magiging hindi kapani-paniwalang kahalagahan kaya ugaliing tukuyin ang iyong mga puntos nang pabaliktad sa ngayon.
- Idagdag idagdag ang mga vertex sa pagitan ng mga linya ng glBegin () at glEnd ().
// Multi-kulay na gilid - 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 ();
Hakbang 5. Magdagdag ng glColor3f ()
Gumagana ang glColor sa isang katulad na paraan sa glVertex. Maaari mong tukuyin ang mga puntos bilang shorts, integer, doble, o float. Ang bawat kulay ay may halaga mula 0 hanggang 1. Lahat ng 0 ay ginagawang itim ang puntong at lahat ng 1 ay magpaputi ng puntong. Ang 3 sa glColor3f () ay tumutukoy sa sistema ng kulay ng RGB na walang alpha channel. Ang alpha ng isang kulay ay tumutukoy sa transparency nito. Upang baguhin ang antas ng alpha, gamitin ang glColor4f () kasama ang huling parameter na isang halagang 0 hanggang 1 para sa opaque hanggang sa transparent.
- Kapag tumawag ka sa glColor3f () bawat vertex na iginuhit mula sa puntong iyon ay magiging kulay na iyon. Samakatuwid, kung nais mong ang lahat ng apat na mga vertex ay pula, itakda lamang ang kulay minsan anumang oras bago ang mga glVertex3f () na utos at ang lahat ng mga vertex ay magiging pula.
- Ang Front side na tinukoy sa ibaba ay nagpapakita kung paano tukuyin ang isang bagong kulay para sa bawat vertex. Kapag ginawa mo ito, maaari mong makita ang isang kagiliw-giliw na pag-aari ng mga kulay na OpenGL. Dahil ang bawat tuktok ng polygon ay may sariling kulay, awtomatikong ihalo ng OpenGL ang mga kulay! Ipapakita ng susunod na hakbang kung paano magtalaga ng apat na mga vertex na may parehong kulay.
// Multi-kulay na gilid - FRONT glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1 ay pulang glColor3f (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2 ay berde glColor3f (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3 ay asul na glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4 ay lila glEnd ();
Hakbang 6. hawakan ang iba pang mga panig
Gawin kung ano ang lokasyon ng bawat tuktok para sa iba pang limang panig ng kubo ngunit para sa pagiging simple, ang mga ito ay nakalkula para sa iyo at kasama sa pangwakas na pagpapakita () na pagpapaandar sa ibaba.
// White side - BACK 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 (); // Lila na gilid - RIGHT 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 (); // Green side - Kaliwang 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 (); // Blue side - 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 (); // Red side - 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 (); }
Nais din naming idagdag sa dalawang huling linya ng code para sa pagpapaandar na ito. Ito ay glFlush ();
at glutSwapBuffers ();
na nagbibigay sa amin ng dobleng buffering effect na natutunan mo tungkol sa mas maaga.
Bahagi 3 ng 3: Pakikipag-ugnay ng User
Hakbang 1. Magdagdag ng mga specialKeys ()
Halos tapos ka na ngunit sa ngayon, maaari kang gumuhit ng isang kubo ngunit walang paraan upang paikutin ito. Upang gawin ito, gagawin mo lumikha ng isang espesyal naKeys () pagpapaandar upang payagan kaming pindutin ang mga arrow key at paikutin ang kubo!
- Ang pagpapaandar na ito ay kung bakit mo idineklara ang mga pandaigdigang variable na paikutin_x at paikutin_y. Kapag pinindot mo ang kanan at kaliwang mga arrow key, ang rotate_y ay madagdagan o mababawasan ng 5 degree. Katulad nito, kapag pinindot mo ang pataas at pababang mga arrow key, ang rotate_x ay magbabago nang naaayon.
void specialKeys (int key, int x, int y) {// Kanang arrow - dagdagan ang pag-ikot ng 5 degree kung (key == GLUT_KEY_RIGHT) paikutin_y + = 5; // Kaliwang arrow - bawasan ang pag-ikot ng 5 degree iba pa kung (key == GLUT_KEY_LEFT) paikutin_y - = 5; kung hindi man kung (key == GLUT_KEY_UP) paikutin_x + = 5; kung hindi man (key == GLUT_KEY_DOWN) paikutin_x - = 5; // Humiling ng pag-update sa display glutPostRedisplay (); }
Hakbang 2. Magdagdag ng glRotate ()
Ang iyong huling pahayag ay upang idagdag ang pahayag na paikutin ang iyong object. Bumalik sa display na () function at bago ang harap na FRONT, idagdag ang mga linyang ito:
// Reset transformations glLoadIdentity (); // Paikutin kapag binago ng gumagamit ang rotate_x at rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (paikutin_y, 0.0, 1.0, 0.0); // Multi-kulay na gilid - FRONT….
Hakbang 3. Idagdag ang mga sumusunod na utos upang sukatin ang kubo ng 2 kasama ang x-axis, 2 kasama ang y-axis, paikutin ang kubo ng 180 degree tungkol sa y-axis, at isalin ang cube ng 0.1 kasama ang x-axis
Siguraduhin na ayusin ang mga ito pati na rin ang nakaraang mga utos ng glRotate () sa tamang pagkakasunud-sunod tulad ng inilarawan sa itaas. (Kung hindi ka sigurado, ginagawa ito sa huling code sa dulo ng tutorial.)
// Other transformations glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);
Hakbang 4. Compile at patakbuhin ang iyong code
Ipagpalagay na gumagamit ka ng gcc bilang iyong tagatala, patakbuhin ang mga utos na ito mula sa iyong terminal upang maipon at subukan ang iyong programa.
Sa Linux: gcc cube.c -o cube -lglut -lGL./ mycube Sa Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL./ mycube Sa Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32./ mycube
Hakbang 5. Suriin ang iyong kumpletong code
Dapat ganito:
// // File: mycube.c // May-akda: Matt Daisley // Nilikha: 4/25/2012 // Project: Source code para sa Gumawa ng isang Cube sa OpenGL // Paglalarawan: Lumilikha ng isang window ng OpenGL at kumukuha ng isang 3D cube / / Na maaaring paikutin ng gumagamit gamit ang mga arrow key // // Mga Kontrol: Kaliwa Arrow - Paikutin Kaliwa // Kanang Arrow - Paikutin Kanang // Up Arrow - Paikutin // Down Arrow - Paikutin Down // ------ ---- - // May kasamang // ------------------------------------------- ---------------- -------------------------------------------- // Function Prototypes / / ----------------- --------- walang bisa ang pagpapakita (); walang bisa mga specialKeys (); // ----------------- ---------- // Mga Global Variable // ----------------- ----------------- doble paikutin_y = 0; doble paikutin_x = 0; // ----------------- ---------- // display () Callback function // ------------------------------- --------------------------- void display () {// I-clear ang screen at Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Reset transformations glLoadIdentity (); // Other Transformations // glTranslatef (0.1, 0.0, 0.0); // Hindi kasama // glRotatef (180, 0.0, 1.0, 0.0); // Hindi kasama // Paikutin kapag binago ng gumagamit ang rotate_x at rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (paikutin_y, 0.0, 1.0, 0.0); // Other Transformations // glScalef (2.0, 2.0, 0.0); // Hindi kasama // Multi-kulay na gilid - FRONT glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1 ay pulang glColor3f (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2 ay berde glColor3f (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3 ay asul na glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4 ay lila glEnd (); // White side - BACK 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 (); // Lila na gilid - RIGHT 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 (); // Green side - Kaliwang 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 (); // Blue side - 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 (); // Red side - 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 () Callback Function // ------------------------------ ---------------------------- void specialKeys (int key, int x, int y) {// Kanang arrow - dagdagan ang pag-ikot ng 5 degree kung (key == GLUT_KEY_RIGHT) paikutin_y + = 5; // Kaliwang arrow - bawasan ang pag-ikot ng 5 degree iba pa kung (key == GLUT_KEY_LEFT) paikutin_y - = 5; kung hindi man kung (key == GLUT_KEY_UP) paikutin_x + = 5; kung hindi man kung (key == GLUT_KEY_DOWN) paikutin_x - = 5; // Humiling ng pag-update sa display glutPostRedisplay (); } // -------------------------------------------- ----------- // pangunahing () pagpapaandar // ----------------- --------------------------- int main (int argc, char * argv ) {// Simulan ang GLUT at iproseso ang mga parameter ng gumagamit glutInit (& argc, argv); // Humiling ng dobleng buffered totoong window ng kulay na may Z-buffer glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Lumikha ng window glutCreateWindow ("Kahanga-hanga Cube"); // Paganahin ang Z-buffer lalim na pagsubok na glEnable (GL_DEPTH_TEST); // Callback function glutDisplayFunc (display); glutSpesyalFunc (specialKeys); // Pass control to GLUT para sa mga kaganapan glutMainLoop (); // Return to OS return 0; }
