Nilalaman

• Mga hakbang
• Bahagi 1 ng 3: Paunang Pag-install
• Bahagi 2 ng 3: Ang display () Pag-andar
• Bahagi 3 ng 3: Pakikipag-ugnay sa Program

Ang OpenGL ay isang tool sa pagprograma ng 3D na nagbibigay-daan sa iyo upang lumikha ng mga kumplikadong 3D na imahe mula sa mga simpleng hugis. Sa artikulong ito, matututunan mo kung paano gumuhit sa kanyang tulong ng isang simpleng kubo na maaaring paikutin sa tatlong sukat!

Mga hakbang

Bahagi 1 ng 3: Paunang Pag-install

1. 1 I-install ang OpenGL. Magsimula sa isang tutorial sa kung paano i-install ang OpenGL sa iyong computer. Kung mayroon ka nang OpenGL at isang C compiler, maaari mong laktawan ang hakbang na ito at magpatuloy sa susunod.
2. 2 Lumikha ng isang dokumento. Lumikha ng isang bagong file sa iyong paboritong code editor at i-save ito bilang mycube.c
3. 3 Magdagdag ng #includes. Narito ang pangunahing # isama ang mga direktiba na kakailanganin mo. Mahalagang tandaan na ang mga direktiba para sa iba't ibang mga operating system ay magkakaiba, at samakatuwid kailangan mong piliin ang lahat upang ang programa ay unibersal at maaaring patakbuhin sa anumang system.

   // Includes #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 Magdagdag ng mga functional prototype at global. Ang susunod na hakbang ay upang ideklara ang mga functional prototype.

   // Functional prototypes void display (); walang bisa mga specialKeys (); // Global variable na doble paikutin_y = 0; doble paikutin_x = 0;

5. 5 Tukuyin ang pangunahing () pagpapaandar.

   int main (int argc, char * argv []) // Initialize GLUT at iproseso ang mga pasadyang parameter na glutInit (& argc, argv); // Humiling ng Isang Window Na May Suporta Para sa Double Buffering, Z-Buffering At Tunay na Kulay na glutInitDisplayMode (GLUT_DOUBLE

Bahagi 2 ng 3: Ang display () Pag-andar

1. 1 Maunawaan ang layunin ng pagpapaandar ng pagpapakita (). Ang lahat ng gawain sa pag-render ng cube ay mahuhulog sa mga marupok na linya ng pagpapaandar na ito. Ang pangkalahatang ideya ay ito: gaguhit ka ng anim na magkakahiwalay na mukha ng kubo at ilagay ang mga ito sa kani-kanilang posisyon.
   • Para sa bawat mukha, tutukuyin mo ang apat na sulok, at ikonekta ng OpenGL ang mga ito sa mga linya at pupunan ang mga ito ng iyong napiling kulay. Kung paano ito gawin ay ipapaliwanag sa ibaba.
2. 2 Magdagdag ng pagpapaandar ng glClear (). Una sa lahat, kapag nagtatrabaho kasama ang pagpapaandar na ito, kailangan namin malinaw na kulay at z-buffer... Kung wala ito, ang luma ay makikita sa ilalim ng bagong larawan, at ang mga bagay na iginuhit ng programa ay maling nakaposisyon.

   void display () // Clear The Screen And Z Buffer glClear (GL_COLOR_BUFFER_BIT

   • Bigyang-pansin ang huling dalawang linya. Ito ang mga pagpapaandar glFlush (); at glutSwapBuffers ();, na nagbibigay ng epekto ng dobleng buffering, na inilarawan sa itaas.

Bahagi 3 ng 3: Pakikipag-ugnay sa Program

1. 1 Idagdag ang pagpapaandar ng specialKeys (). Sa prinsipyo, ang lahat ay halos handa na, ngunit ang kubo ay iginuhit lamang at hindi paikutin. Upang magawa ito, kailangan mong lumikha ang specialKeys () function, na magpapahintulot sa iyo na paikutin ang kubo sa pamamagitan ng pagpindot sa mga arrow key!
   • Ito ay para sa pagpapaandar na ito na ang pandaigdigang mga variable na rotate_x at rotate_y ay idineklara. Kapag pinindot mo ang kaliwa at kanang mga arrow key, ang paikutin_y halaga ay tataas o babaan ng limang degree. Ang halaga ng rotate_x ay magbabago sa parehong paraan, ngunit sa oras na ito sa pamamagitan ng pagpindot sa pataas at pababang mga arrow key.

   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; // Left Arrow - Bawasan ang Pag-ikot Ng 5 Degree 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; // Request Screen Refresh glutPostRedisplay (); }

2. 2 Magdagdag ng glRotate (). Ang huling bagay na gagawin namin ay magdagdag ng isang linya na magpapahintulot sa amin na paikutin ang bagay. Bumalik sa pagpapaandar ipakita () at bago ang paglalarawan ng panig na FRONT idagdag:

   // Reset Transforms glLoadIdentity (); // Paikutin Kapag Nagbago ang Gumagamit Ang mga halaga ay paikutin_x at paikutin_y glRotatef (paikutin_x, 1.0, 0.0, 0.0); glRotatef (paikutin_y, 0.0, 1.0, 0.0); // Multicolor side - FRONT ....

   • Mangyaring tandaan na ang syntax glRotatef ()na katulad sa syntax ng glColor3f () at glVertex3f (), ngunit laging nangangailangan ng apat na mga parameter. Ang una ay ang anggulo ng pag-ikot sa degree. Ang susunod na tatlo ay ang mga palakol na kung saan nagaganap ang pag-ikot, sa pagkakasunud-sunod x, y, z. Sa ngayon, kailangan naming paikutin ang kubo kasama ang dalawang palakol, x at y.
   • Ang lahat ng mga pagbabago na tinukoy namin sa programa ay nangangailangan ng mga katulad na linya. Karaniwan, kinakatawan namin ang pag-ikot ng isang bagay sa kahabaan ng x-axis bilang isang pagbabago sa halaga ng rotate_x, at pag-ikot kasama ang y-axis bilang isang pagbabago sa halaga ng rotate_y. Gayunpaman, ibubuklod ng OpenGL ang lahat sa isang pagbabago ng matrix. Sa tuwing tatawag ka sa display, lilikha ka ng isang transformation matrix, at glLoadIdentity () Papayagan kang magsimula sa isang bagong matrix sa bawat oras.
   • Ang iba pang mga pagpapaandar sa pagbabago na maaaring ginamit mo ay ang glTranslatef () at glScalef (). Ang mga ito ay katulad ng glRotatef (), maliban na nangangailangan lamang sila ng tatlong mga parameter: ang mga halagang x, y, at z upang baguhin ang laki at sukatin ang bagay.
   • Para sa lahat na maipakita nang tama kapag ang lahat ng tatlong mga pagbabago ay inilalapat sa isang bagay, kailangan mong itakda ang mga pagbabago sa naaangkop na pagkakasunud-sunod, lalo glTranslate, glRotate, glScale - at hindi kailanman sa ibang paraan. Binago ng OpenGL ang bagay sa pamamagitan ng pagbabasa ng programa mula sa ibaba hanggang sa itaas. Upang mas maintindihan ito, isipin kung paano aalagaan ng 1x1x1 cube ang lahat ng mga pagbabago kung inilapat ito ng OpenGL sa pagkakasunud-sunod na ipinakita (itaas hanggang sa ibaba), at pagkatapos ay isipin kung paano iproseso ng OpenGL ang kubo sa pamamagitan ng pagbabasa ng mga tagubilin mula sa ibaba hanggang sa itaas.
3. 3 Idagdag ang mga sumusunod na utos upang sukatin ang kubo ng dalawang beses sa mga direksyon ng x at y, upang paikutin ang kubo ng 180 degree sa y axis, at ilipat ang kubo na 0.1 sa x axis. Siguraduhin na ang lahat ng nauugnay na mga utos, kabilang ang naunang ibinigay na mga utos na glRotate (), ay nasa wastong pagkakasunud-sunod. Kung natatakot kang magkamali, tingnan ang huling bersyon ng programa sa dulo ng artikulo.

   // More Transformations glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 Compile at patakbuhin ang code. Sabihin nating gumagamit ka ng gcc bilang iyong tagatala, kaya ipasok ang mga sumusunod na utos sa iyong terminal:

   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

5. 5 Suriin ang pangwakas na code. Narito ang pangwakas na code na nilikha ng may-akda ng artikulo, na hindi isinalin ang mga komento.

   // // 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 // ------------------------------------------- - -------------- #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else # isama GL / glut.h> #endif // ------------------------------------- - ----------------- // Mga Prototype ng Pag-andar // ----------------- - ------------------------------- 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 // ------ ---- - // 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 pa kung (key == GLUT_KEY_LEFT) paikutin_y - = 5; iba pa kung (key == GLUT_KEY_UP) paikutin_x + = 5; iba pa kung (key == GLUT_KEY_DOWN) paikutin_x - = 5; // Humiling ng pag-update sa display glutPostRedisplay ();} // ------------------------------------- ----------------- // pangunahing () pagpapaandar // ----------------- - ------------------------------------ int main (int argc, char * argv [] ) GLUT_RGB