Përmbajtje

• Hapa
• Pjesa 1 nga 3: Instalimi fillestar
• Pjesa 2 nga 3: Funksioni i ekranit ()
• Pjesa 3 nga 3: Interaktiviteti i Programit

OpenGL është një mjet programimi 3D që ju lejon të krijoni imazhe komplekse 3D nga forma të thjeshta. Në këtë artikull, do të mësoni se si të vizatoni me ndihmën e tij një kub të thjeshtë që mund të rrotullohet në tre dimensione!

Hapa

Pjesa 1 nga 3: Instalimi fillestar

1. 1 Instaloni OpenGL. Filloni me një mësim se si të instaloni OpenGL në kompjuterin tuaj. Nëse tashmë keni OpenGL dhe një përpilues C, mund ta kaloni këtë hap dhe të kaloni në tjetrin.
2. 2 Krijoni një dokument. Krijoni një skedar të ri në redaktuesin tuaj të preferuar të kodeve dhe ruajeni si mycube.c
3. 3 Shto #përfshin. Këtu janë direktivat themelore #përfshini që do t'ju nevojiten. Importantshtë e rëndësishme të mbani mend se direktivat për sisteme të ndryshme operative janë të ndryshme, dhe për këtë arsye ju duhet të zgjidhni gjithçka në mënyrë që programi të jetë universal dhe të mund të ekzekutohet në çdo sistem.

   // Përfshin #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 Shtoni prototipe funksionale dhe globale. Hapi tjetër është deklarimi i prototipeve funksionale.

   // Prototipet funksionale void display (); void specialKeys (); // Variablat globale rrotullohen dyfish_y = 0; rrotullimi i dyfishtë_x = 0;

5. 5 Përcaktoni funksionin kryesor ().

   int main (int argc, char * argv []) // Inicializoni GLUT dhe përpunoni parametrat e personalizuar glutInit (& argc, argv); // Kërkoni një dritare me mbështetje për tampon të dyfishtë, z-tampon dhe ngjyra të vërteta glutInitDisplayMode (GLUT_DOUBLE

Pjesa 2 nga 3: Funksioni i ekranit ()

1. 1 Kuptoni qëllimin e funksionit të ekranit (). E gjithë puna në dhënien e kubit do të bjerë në linjat e brishta të këtij funksioni. Ideja e përgjithshme është kjo: ju do të vizatoni gjashtë faqe të veçanta të kubit dhe do t'i vendosni në pozicionet e tyre përkatëse.
   • Për secilën fytyrë, ju do të përcaktoni katër qoshe, dhe OpenGL do t'i lidhë ato me vija dhe do t'i mbushë ato me ngjyrën tuaj të zgjedhur. Si ta bëni këtë do të shpjegohet më poshtë.
2. 2 Shtoni funksionin glClear (). Para së gjithash, kur punojmë me këtë funksion, ne kemi nevojë ngjyrë të qartë dhe z-tampon... Pa këtë, e vjetra do të jetë e dukshme nën figurën e re, dhe objektet e vizatuara nga programi do të pozicionohen gabimisht.

   ekran i pavlefshëm () // Pastro ekranin dhe z Buffer glClear (GL_COLOR_BUFFER_BIT

   • Kushtojini vëmendje dy rreshtave të fundit. Këto janë funksionet glFlush (); dhe glutSwapBuffers ();, duke dhënë efektin e ruajtjes së dyfishtë, e cila u përshkrua më sipër.

Pjesa 3 nga 3: Interaktiviteti i Programit

1. 1 Shtoni funksionin specialKeys (). Në parim, gjithçka është pothuajse gati, por kubi është tërhequr vetëm dhe nuk rrotullohet. Për ta bërë këtë, duhet të krijoni funksioni specialKeys (), e cila do t'ju lejojë të rrotulloni kubin duke shtypur tastet e shigjetave!
   • Për këtë funksion u deklaruan variablat globale rotate_x dhe rotate_y. Kur shtypni shigjetat majtas dhe djathtas, vlera e rotate_y do të rritet ose ulet me pesë gradë. Vlera e rotate_x do të ndryshojë në të njëjtën mënyrë, por këtë herë duke shtypur shigjetat lart dhe poshtë.

   çelësat e pavlefshëm (çelësi int, int x, int y) {// Shigjeta e djathtë - rrotullo rrotullimin me 5 gradë nëse (çelësi == GLUT_KEY_RIGHT) rrotullohet_y + = 5; // Shigjeta e majtë - Zvogëloni rrotullimin me 5 gradë tjetër nëse (çelësi == GLUT_KEY_LEFT) rrotullohet_y - = 5; përndryshe nëse (çelësi == GLUT_KEY_UP) rrotullo_x + = 5; përndryshe nëse (çelësi == GLUT_KEY_DOWN) rrotullohet_x - = 5; // Kërko Screen Refresh glutPostRedisplay (); }

2. 2 Shto glRotate (). Gjëja e fundit që do të bëjmë është të shtojmë një vijë që do të na lejojë të rrotullojmë objektin. Kthehu në funksion shfaqje () dhe para përshkrimit të anës FRONT shtoni:

   // Reset Transforms glLoadIdentity (); // Rrotullo Kur Përdoruesi Ndryshon Vlerat rrotullohen_x dhe rrotullohen_y glRotatef (rrotullohen_x, 1.0, 0.0, 0.0); glRotatef (rrotullimi_y, 0.0, 1.0, 0.0); // Ana shumëngjyrëshe - FRONT ....

   • Ju lutemi vini re se sintaksa glRotatef ()e cila është e ngjashme me sintaksën e glColor3f () dhe glVertex3f (), por gjithmonë kërkon katër parametra. E para është këndi i rrotullimit në gradë. Tre të tjerat janë boshtet përgjatë të cilave bëhet rrotullimi, në rendin x, y, z. Tani për tani, ne duhet të rrotullojmë kubin përgjatë dy akseve, x dhe y.
   • Të gjitha transformimet që ne përcaktojmë në program kërkojnë linja të ngjashme. Në thelb, ne përfaqësojmë rrotullimin e një objekti përgjatë boshtit x si një ndryshim në vlerën e rrotullimit_x, dhe rrotullimin përgjatë boshtit y si një ndryshim në vlerën e rrotullimit_y. Sidoqoftë, OpenGL do të bashkojë gjithçka në një matricë transformimi. Sa herë që thërrisni ekranin, do të krijoni një matricë transformimi, dhe glLoadIdentity () do t'ju lejojë të filloni me një matricë të re çdo herë.
   • Funksione të tjera transformimi që mund të keni përdorur janë glTranslatef () dhe glScalef (). Ato janë të ngjashme me glRotatef (), përveç se ato kërkojnë vetëm tre parametra: vlerat x, y dhe z për të ndryshuar madhësinë dhe shkallëzuar objektin.
   • Që gjithçka të shfaqet saktë kur të tre transformimet aplikohen në një objekt, ju duhet të vendosni transformimet në rendin e duhur, domethënë glTranslate, glRotate, glScale - dhe kurrë ndryshe. OpenGL transformon objektin duke lexuar programin nga poshtë lart. Për ta kuptuar më mirë këtë, imagjinoni se si do të dukej kubi 1x1x1 pas të gjitha transformimeve nëse OpenGL do t'i zbatonte ato në rendin e treguar (nga lart poshtë), dhe pastaj mendoni se si OpenGL do ta përpunonte kubin duke lexuar udhëzimet nga poshtë lart.
3. 3 Shtoni komandat e mëposhtme për të shkallëzuar kubin dy herë në drejtimet x dhe y, për ta rrotulluar kubin 180 gradë në boshtin y dhe për të lëvizur kubin 0.1 në boshtin x. Sigurohuni që të gjitha komandat përkatëse, përfshirë komandat e dhëna më parë glRotate (), të jenë në rendin e duhur. Nëse keni frikë të bëni një gabim, shihni versionin përfundimtar të programit në fund të artikullit.

   // Më shumë transformime glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 Përpiloni dhe ekzekutoni kodin. Le të themi se jeni duke përdorur gcc si përpiluesin tuaj, kështu që futni komandat e mëposhtme në terminalin 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

5. 5 Kontrolloni kodin përfundimtar. Këtu është kodi përfundimtar i krijuar nga autori i artikullit, i cili nuk përkthen komentet.

   // // 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 // ------------------------------------------------ * GL / glut.h> #endif // --------------------------------------------- ------------------ // Prototipet e funksionit // -------------------------- --------------------------------- shfaqje e pavlefshme (); void specialKeys (); // ---------------------------------------------------- ---------- // Variablat Globale // ---------------------------------- ------------------------ dyfisho rotate_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 // ------ ------------------------------------------------------ -// specialKeys () Funksioni i kthimit në telefon // -------------------------------------------- ------------------ ç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 ();} // ---------------------------------------- ---------------------- // funksioni kryesor () // -------------------- -------------------------------------- int kryesore (int argc, char * argv [] ) GLUT_RGB