Ինչպես պատրաստել խորանարդ OpenGL- ում (նկարներով)

Բովանդակություն:

Ինչպես պատրաստել խորանարդ OpenGL- ում (նկարներով)
Ինչպես պատրաստել խորանարդ OpenGL- ում (նկարներով)

Video: Ինչպես պատրաստել խորանարդ OpenGL- ում (նկարներով)

Video: Ինչպես պատրաստել խորանարդ OpenGL- ում (նկարներով)
Video: Ինչի՞ համար են նախատեսված համակարգչի այս կոճակները 2024, Երթ
Anonim

OpenGL- ը հզոր ծրագրավորման 3D գործիք է, որն օգտագործվում է պարզ պարզունակներից բարդ եռաչափ տեսարաններ նկարելու համար: Այս հոդվածը կսովորեցնի ձեզ, թե ինչպես նկարել մի պարզ խորանարդ, որը կարող եք պտտել ՝ երեք հարթություններում դիտելու համար:

Այս նախագծի համար ձեզ հարկավոր կլինի կոդի խմբագիր և C ծրագրավորման որոշակի իմացություն:

Քայլեր

Մաս 1 -ից 3 -ից. Նախնական կարգավորում

1994315 1 1
1994315 1 1

Քայլ 1. Տեղադրեք OpenGL Սկսելու համար հետևեք այս համակարգում OpenGL- ը տեղադրելու այս քայլերին:

Եթե արդեն ունեք OpenGL, ինչպես նաև տեղադրված համատեղելի C կոմպիլյատոր, կարող եք բաց թողնել այս քայլը և գնալ հաջորդին:

1994315 2 1
1994315 2 1

Քայլ 2. Ստեղծեք փաստաթուղթ:

Ստեղծեք նոր ֆայլ ձեր նախընտրած կոդերի խմբագրիչում և պահեք այն որպես mycube.c

1994315 3 1
1994315 3 1

Քայլ 3. Ավելացնել #ներառում:

Սրանք այն հիմնական ընդգրկումներն են, որոնք ձեզ անհրաժեշտ կլինեն ձեր ծրագրի համար: Կարևոր է գիտակցել, որ իրականում տարբեր օպերացիոն համակարգերի համար պահանջվող տարբեր ներառումներ կան: Համոզվեք, որ ներառեք այս բոլորը `ձեր ծրագիրը բազմակողմանի լինելու և ցանկացած օգտվողի համար աշխատելու համար:

    // Ներառում է #ներառել #ներառել #ներառել #սահմանել GL_GLEXT_PROTOTYPES #ifdef _APPLE_ #Include #else #Include #endif

1994315 4 1
1994315 4 1

Քայլ 4. Ավելացրեք գործառույթի նախատիպեր և գլոբալ փոփոխականներ:

Ձեր հաջորդ քայլը որոշ գործառույթների նախատիպերի հայտարարումն է:

    // Function Prototypes void display (); void specialKeys (); // Global Variables double rotate_y = 0; կրկնակի պտտել_ x = 0;

1994315 5 1
1994315 5 1

Քայլ 5. Ստեղծեք հիմնական () գործառույթը:

    int main (int argc, char* argv ) {// Initialize GLUT և մշակել օգտվողի պարամետրերը glutInit (& argc, argv); // Պահանջել կրկնակի բուֆերային իրական գույնի պատուհան Z-buffer glutInitDisplayMode- ով (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

  • Այս հայտարարությունը ստեղծում է ձեր միջավայրը: OpenGL ծրագրեր գրելիս հիշելն այն է, որ դուք պետք է ամեն ինչ խնդրեք: Սա պահանջում է, որ դուք ավելի մեծ պատկերացում ունենաք, թե ինչպես է աշխատում ձեր ծրագիրը և այն, ինչ ձեզ հարկավոր է ներառել ՝ ձեր ուզած ֆունկցիոնալությունը ստանալու համար: Այս տողում դուք կկարգավորեք ցուցադրումը կրկնակի բուֆերացմամբ, RGB գույնով և Z- բուֆերով:
  • Կրկնակի բուֆերացում տեխնիկա է, որն օգտագործվում է գրաֆիկական ծրագրերում `խնդիրը վերացնելու համար, որը ծագում է այն պատճառով, թե ինչպես են պատկերները ձգվում դեպի էկրան: Ամեն անգամ, երբ վերափոխում եք տեսարանը, էկրանը նախ պետք է ջնջվի, այնուհետև նոր տեղեկատվությունը կքաշվի: Առանց կրկնակի բուֆերացման դուք նկատելու եք թարթման ազդեցություն, քանի որ էկրանը ջնջվում և վերագծվում է բազմիցս:
  • Այս խնդիրը շտկվում է ՝ դրան ավելացնելով երկրորդ բուֆերը: Այս մեթոդով պատկերը գծվում է առաջին բուֆերի վրա և այդ բուֆերը ցուցադրվում է ձեզ: Հաջորդ շրջանակը գծված կլինի երկրորդ բուֆերի վրա, և երբ դա արվի, երկու բուֆերները կփոխեն իրենց տեղը: Դուք անմիջապես կտեսնեք երկրորդ բուֆերը, բայց մեզանից թաքնված, առաջին բուֆերը ջնջվում և վերագծվում է երրորդ շրջանակով, որն ավարտվելուց հետո կփոխանակվի:
  • Դուք նաև ցանկանում եք միացնել RGB գույն համակարգը ձեր պատուհանում:
  • Z- բուֆերացում այն է, թե ինչպես եք ստանում ձեր ուզած եռաչափ էֆեկտները: OpenGL- ն օգտագործում է x, y և z առանցքներով եռաչափ կոորդինատային համակարգ: Էֆեկտ ստեղծելու համար, որ օբյեկտը ձեզ ավելի մոտ է, z դիրքը z առանցքի վրա մեծանում է, սակայն, այն ավելի հեռու տեսնելու համար z դիրքի առանցքի վրա դիրքը նվազում է:
1994315 6 1
1994315 6 1

Քայլ 6. Ստեղծեք պատուհանը:

Հաջորդ քայլը պետք է ստեղծել պատուհանը որի շրջանակում նկարելու եք խորանարդը: Այս ձեռնարկում պատուհանը կոչվում է «Awesome Cube»:

    // Ստեղծել պատուհանի glutCreateWindow («Հրաշալի խորանարդ»);

1994315 7 1
1994315 7 1

Քայլ 7. Միացնել խորության ստուգումը:

OpenGL- ը խիստ լեզու է, որովհետև չի ենթադրում, որ հատուկ գործառույթները միացված են: Որպեսզի ձեր ծրագիրը պատշաճ կերպով ցուցադրվի եռաչափ ՝ օգտագործելով Z- բուֆերը, որը դուք ավելի վաղ դիտել էիք, պետք է միացնել խորության թեստը. Շարունակելով ուսումնասիրել OpenGL- ը ՝ դուք կբացահայտեք բազմաթիվ հնարավորություններ, որոնք ձեզ անհրաժեշտ կլինեն միացնելու համար, ներառյալ լուսավորությունը, հյուսվածքները, երեսպատումը և շատ ավելին:

    // Միացնել Z- բուֆերի խորության թեստը glEnable (GL_DEPTH_TEST);

1994315 8 1
1994315 8 1

Քայլ 8. Ավելացրեք հետադարձ կապի գործառույթներ:

Ահա հետադարձ կապի գործառույթները, որոնց համար ավելի վաղ գրել եք նախատիպերը: Ամեն անգամ հիմնական հանգույցի միջոցով այս գործառույթները կանչվելու են: Displayուցադրման գործառույթը վերափոխում է տեսարանը ՝ հիմնվելով փոփոխությունների փոփոխությունների վրա, որոնք կատարվել են նախորդ զանգից հետո: SpecialKeys գործառույթը թույլ է տալիս մեզ փոխազդել ծրագրի հետ:

    // Հետադարձ գործառույթներ glutDisplayFunc (ցուցադրում); glutSpecialFunc (specialKeys);

1994315 9 1
1994315 9 1

Քայլ 9. Սկսեք MainLoop- ը:

Սա կհիշեցնի հիմնական գործառույթը, քանի դեռ չեք փակել ծրագիրը `թույլ տալով անիմացիաներ և օգտագործողների փոխազդեցություն:

    // Անցեք հսկողությունը GLUT- ին glutMainLoop իրադարձությունների համար (); // Վերադառնալ OS վերադարձ 0; }

Մաս 2 -ից 3 -ից. Displayուցադրման () գործառույթը

1994315 10 1
1994315 10 1

Քայլ 1. Հասկացեք այս գործառույթի նպատակը:

Ձեր խորանարդը նկարելու ամբողջ աշխատանքը կկատարվի այս գործառույթում: Ձեր խորանարդի հետևում գտնվող ընդհանուր գաղափարն է ՝ նկարել բոլոր վեց կողմերը առանձին և տեղադրել դրանք համապատասխան դիրքում:

Հայեցակարգային առումով, յուրաքանչյուր կողմ գծվելու է `սահմանելով չորս անկյունները և թույլ տալով, որ OpenGL- ը միացնի տողերը և լրացնի այն ձեր սահմանած գույնով: Ստորև բերված են դա անելու քայլերը:

1994315 11 1
1994315 11 1

Քայլ 2. Ավելացնել glClear ():

Առաջին քայլը, որը դուք պետք է կատարեք այս գործառույթի մեջ, դա է մաքրել գույնը և Z բուֆերը. Առանց այս քայլերի, հին գծագրերը կարող են դեռևս տեսանելի լինել նոր գծագրերի ներքո, և գծված առարկաները էկրանին ճիշտ տեղում չեն լինի:

    դատարկ ցուցադրում () {// Մաքրել էկրանը և Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

1994315 12 1
1994315 12 1

Քայլ 3. Ավելացրեք glBegin () և glEnd ():

OpenGL- ը օբյեկտները սահմանում է որպես տարբեր բազմանկյունների համակցություններ: Օգտագործելով glBegin () հրաման, արդյունավետ կերպով վայր ես դնում մատիտ, որը կձևավորի ձև: Մատիտը բարձրացնելու և նոր ձև սկսելու համար հարկավոր է օգտագործել glEnd () հրաման. Այս ձեռնարկում դուք կօգտագործեք GL_POLYGON ՝ խորանարդի յուրաքանչյուր կողմը գծելու համար, բայց հնարավոր է օգտագործել այլ պարամետրերի ընտրանքներ, ինչպիսիք են GL_LINE, GL_QUAD կամ GL_TRIANGLE ՝ այլ ձևեր ստեղծելու համար:

  • Այստեղ դուք կսկսեք ձեր խորանարդի առջևից: Հետագայում գույն կավելացնեք բոլոր 6 կողմերին:
  • // Բազմերանգ կողմ - FRONT glBegin (GL_POLYGON); // Ուղղահայացները կավելացվեն հաջորդ քայլին glEnd ();

1994315 13 1
1994315 13 1

Քայլ 4. Ավելացրեք glVertex3f ():

Երբ դուք հայտարարեցիք, որ ցանկանում եք սկսել ձեր բազմանկյունը, պետք է սահմանել գագաթները օբյեկտի. glVertex- ն ունի բազմաթիվ ձևեր ՝ կախված այն բանից, թե ինչ եք ուզում անել ձեր օբյեկտի հետ:

  • Առաջինը այն է, թե քանի հարթության մեջ եք աշխատում: glVertex3f- ում վերը նշված 3 -ում ասվում է, որ նկարում եք 3 հարթությունում: Հնարավոր է նաև աշխատել 2 կամ 4 հարթություններում: GlVertex3f- ում վերը նշված f- ն ասում է, որ դուք աշխատում եք լողացող կետերի թվերով: Կարող եք օգտագործել նաև շորտեր, ամբողջ թվեր կամ զույգեր:
  • Ուշադրություն դարձրեք, որ այս կետերը սահմանված են ա ժամացույցի սլաքի հակառակ ուղղությամբ կարգը. Այս պահին դա շատ կարևոր չէ, բայց երբ սկսում եք աշխատել լուսավորության, հյուսվածքների և ճակատի երեսպատման հետ, դա աներևակայելի կարևոր կդառնա, այնպես որ սովորություն ձեռք բերեք ձեր միավորները որոշել ժամացույցի սլաքի հակառակ ուղղությամբ:
  • Ավելացնել ավելացնել գագաթները glBegin () և glEnd () տողերի միջև:
  • // Բազմերանգ կողմ - 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 ();

1994315 14 1
1994315 14 1

Քայլ 5. Ավելացրեք glColor3f ():

glColor- ն աշխատում է glVertex- ի նմանությամբ: Դուք կարող եք միավորներ սահմանել որպես շորտեր, ամբողջ թվեր, զույգեր կամ բոցեր: Յուրաքանչյուր գույն ունի 0 -ից մինչև 1 արժեք: Բոլոր 0 -երը կետը դարձնում են սև, իսկ բոլոր 1 -երը `կետը սպիտակ: 3 -ը glColor3f () - ում վերաբերում է RGB գունային համակարգին `առանց ալֆա ալիքի: Գույնի ալֆան սահմանում է դրա թափանցիկությունը: Ալֆա մակարդակը փոխելու համար օգտագործեք glColor4f (), որի վերջին պարամետրը 0 -ից 1 արժեք է `անթափանցից թափանցիկ:

  • Երբ զանգում եք glColor3f (), այդ կետից գծված յուրաքանչյուր գագաթը կլինի այդ գույնի: Հետևաբար, եթե ցանկանում եք, որ բոլոր չորս գագաթները լինեն կարմիր, պարզապես ցանկացած պահի սահմանեք գույնը մինչև glVertex3f () հրամանները և բոլոր գագաթները կլինեն կարմիր:
  • Ստորև սահմանված ճակատային կողմը ցույց է տալիս, թե ինչպես կարելի է սահմանել նոր գույն յուրաքանչյուր գագաթի համար: Երբ դա անում եք, կարող եք տեսնել OpenGL գույների հետաքրքիր հատկություն: Քանի որ բազմանկյան գագաթն ունի իր գույնը, OpenGL- ն ինքնաբերաբար կմիացնի գույները: Հաջորդ քայլը ցույց կտա, թե ինչպես կարելի է վերագրել նույն գույնի չորս գագաթներ:
  • // Բազմերանգ կողմ - FRONT glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1- ը կարմիր glColor3f է (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2- ը կանաչ glColor3f է (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3- ը կապույտ glColor3f է (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4- ը մանուշակագույն է glEnd ();

1994315 15 1
1994315 15 1

Քայլ 6. Կարգավորեք մյուս կողմերը:

Մշակեք յուրաքանչյուր գագաթի գտնվելու վայրը խորանարդի մյուս հինգ կողմերի համար, բայց պարզության համար դրանք հաշվարկվել են ձեզ համար և ներառված են վերջնական ցուցադրման () գործառույթը ստորեւ.

    // Սպիտակ կողմ - 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 (); // Մանուշակագույն կողմ - ԱIGHԻ gl 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 (); // Կանաչ կողմ - 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 (); // Կապույտ կողմ - 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 (); // Կարմիր կողմ - 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 (); }

  • Այս գործառույթի համար մենք նաև ցանկանում ենք ավելացնել երկու վերջին տող կոդ: Սրանք glFlush ();

    եւ glutSwapBuffers ();

    որոնք մեզ տալիս են կրկնակի բուֆերային էֆեկտ, որի մասին դուք իմացել եք ավելի վաղ:

3 -րդ մաս 3 -ից. Օգտվողի ինտերակտիվություն

1994315 16 1
1994315 16 1

Քայլ 1. Ավելացնել հատուկ Keys ():

Դուք գրեթե ավարտված եք, բայց այս պահին կարող եք խորանարդ նկարել, բայց այն պտտելու ոչ մի կերպ չեք կարող: Դա անելու համար դուք կանեք ստեղծել հատուկ բանալիներ () գործառույթը թույլ է տալիս մեզ սեղմել սլաքների ստեղները և պտտել խորանարդը:

  • Այս գործառույթն է պատճառը, որ դուք հայտարարեցիք գլոբալ փոփոխականները rotate_x և rotate_y: Երբ սեղմում եք աջ և ձախ սլաքների ստեղները, rotate_y- ն կավելանա կամ կնվազի 5 աստիճանով: Նմանապես, երբ սեղմում եք վեր և վար սլաքների ստեղները, rotate_x- ը համապատասխանաբար կփոխվի:
  • void specialKeys (int key, int x, int y) {// Right arrow - մեծացնել պտույտը 5 աստիճանով, եթե (key == GLUT_KEY_RIGHT) rotate_y += 5; // Ձախ սլաք - նվազեցրեք պտույտը 5 աստիճանով, եթե (բանալին == GLUT_KEY_LEFT) պտտել_յ - = 5; այլապես, եթե (բանալին == GLUT_KEY_UP) պտտել_ x += 5; այլապես, եթե (բանալին == GLUT_KEY_DOWN) պտտել_ x -= 5; // Պահանջել ցուցադրման թարմացում glutPostRedisplay (); }

1994315 17 1
1994315 17 1

Քայլ 2. Ավելացնել glRotate ():

Ձեր վերջին հայտարարությունը պետք է ավելացնել հայտարարությունը, որը կշրջի ձեր օբյեկտը: Վերադառնալ ցուցադրման () գործառույթին և FRONT- ի կողքին ավելացնել այս տողերը.

    // Վերափոխել վերափոխումները glLoadIdentity (); // Պտտել, երբ օգտվողը փոխում է rotate_x և rotate_y glRotatef (պտտել_ x, 1.0, 0.0, 0.0); glRotatef (պտտել_յ, 0.0, 1.0, 0.0); // Գունավոր կողմ - ԱՌԱ….

  • Նախ նկատեք, որ շարահյուսությունը glRotatef () նման է glColor3f () և glVertex3f () պարամետրերին, բայց միշտ պահանջում է 4 պարամետր: Առաջին պարամետրը կիրառելի պտտման աստիճանն է: Հաջորդ երեք պարամետրերը սահմանում են, թե որ առանցքի շուրջը պտտվել `առաջինը` x առանցքը, երկրորդը `y առանցքը, իսկ երրորդը` z առանցքը: Հենց հիմա պետք է պտտվել միայն x և y առանցքի շուրջը:
  • Բոլոր փոխակերպումները, որոնք դուք գրում եք ձեր ծրագրում, նման տողերի կարիք ունեն: Գաղափարապես, դուք կարող եք դա համարել որպես պտտել ձեր առարկան x առանցքի շուրջ պտտվող_ x- ով սահմանված չափով, այնուհետև պտտվել y առանցքի շուրջ պտտելով_յ: Այնուամենայնիվ, OpenGL- ը միավորում է այս բոլոր հայտարարությունները մեկ մատրիցային փոխակերպման մեջ: Ամեն անգամ, երբ կանչում եք ցուցադրման գործառույթը, կառուցում եք փոխակերպման մատրիցա և glLoadIdentity () վստահեցնում է, որ յուրաքանչյուր անցումում սկսելու եք նոր մատրիցով:
  • Մյուս փոխակերպման գործառույթները, որոնք կարող եք կիրառել, glTranslatef () և glScalef () են: Այս գործառույթները նման են glRotatef () -ին, բացառությամբ, որ դրանք վերցնում են ընդամենը 3 պարամետր ՝ x, y և z գումարները ՝ օբյեկտը թարգմանելու կամ մասշտաբավորելու համար:
  • Երեք փոխակերպումները մեկ օբյեկտի վրա կիրառելիս ճիշտ էֆեկտ ստանալու համար դրանք պետք է կիրառել ճիշտ հերթականությամբ: Միշտ գրեք դրանք հերթականությամբ glTranslate, glRotate, ապա glScale. OpenGL- ը էապես կիրառում է փոխակերպումները ներքևից վեր: Սա հասկանալու համար փորձեք պատկերացնել, թե ինչպիսին կլիներ պարզ 1x1x1 խորանարդը փոխակերպումների դեպքում, եթե OpenGL- ը դրանք կիրառեր վերևից ներքև, և եթե OpenGL- ը դրանք կիրառեր ներքևից վերև:
1994315 18 1
1994315 18 1

Քայլ 3. Ավելացրեք հետևյալ հրամանները ՝ խորանարդը 2-ով x առանցքի երկայնքով, 2-ը ՝ y առանցքի երկայնքով, պտտեք խորանարդը 180 աստիճանով y- առանցքի շուրջ և խորանարդը 0,1-ով թարգմանեք x առանցքի երկայնքով:

Համոզվեք, որ դրանք, ինչպես նաև նախորդ glRotate () հրամանները դասավորեք ճիշտ հերթականությամբ, ինչպես նկարագրված է վերևում: (Եթե վստահ չեք, դա արվում է ձեռնարկի վերջում վերջնական ծածկագրում):

    // այլ փոխակերպումներ glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

1994315 19 1
1994315 19 1

Քայլ 4. Կազմեք և գործարկեք ձեր կոդը:

Ենթադրելով, որ դուք օգտագործում եք gcc- ը որպես ձեր կազմող, գործարկեք այս հրամանները ձեր տերմինալից `ձեր ծրագիրը կազմելու և փորձարկելու համար:

    Linux- ում ՝ gcc cube.c -o cube -lglut -lGL./ mycube Mac- ում ՝ gcc -o foo foo.c -framework GLUT -framework OpenGL./ mycube Windows- ում: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32./ mycube

1994315 20 1
1994315 20 1

Քայլ 5. Ստուգեք ձեր ամբողջական կոդը:

Այն պետք է լինի այսպես.

    // // Ֆայլ ՝ mycube.c // Հեղինակ ՝ Մեթ Դեյսլի // Ստեղծվել է ՝ 4/25/2012 // Նախագիծ. OpenGL- ում Cube պատրաստելու աղբյուրի կոդը // Նկարագրություն. Ստեղծում է OpenGL պատուհան և գծում 3D խորանարդ/ / Որ օգտվողը կարող է պտտվել ՝ օգտագործելով սլաքների ստեղները // // Կառավարում ՝ ձախ սլաք -պտտել ձախ // աջ սլաք -պտտել աջ // վերև սլաք -պտտել վեր // վար սլաք -պտտել ներքև // ------ ------------------------------------------------------ -// Ներառում է // ----------------------------------------------- --------------- #ներառել #ներառել #ներառել #սահմանել GL_GLEXT_PROTOTYPES #ifdef _APPLE_ #ներառել #այլ #ներառել #endif // ------------- ---------------------------------------------- // գործառույթի նախատիպեր / / ----------------------------------------------------- --------- անվավեր ցուցադրում (); void specialKeys (); // ---------------------------------------------------- ---------- // Գլոբալ փոփոխականներ // ---------------------------------- ------------------------ կրկնակի պտտել_յ = 0; կրկնակի պտտել_ x = 0; // ---------------------------------------------------- ---------- // ցուցադրում () Հետադարձ կապի գործառույթ // ----------------------------------- --------------------------- անվավեր ցուցադրում () {// Մաքրել էկրանը և Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Վերափոխել վերափոխումները glLoadIdentity (); // Այլ փոխակերպումներ // glTranslatef (0.1, 0.0, 0.0); // Ներառված չէ // glRotatef (180, 0.0, 1.0, 0.0); // Ներառված չէ // Պտտել, երբ օգտվողը փոխում է rotate_x և rotate_y glRotatef (պտտել_ x, 1.0, 0.0, 0.0); glRotatef (պտտել_յ, 0.0, 1.0, 0.0); // Այլ փոխակերպումներ // glScalef (2.0, 2.0, 0.0); // Ներառված չէ // Գունավոր կողմ - FRONT glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1- ը կարմիր glColor3f է (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2- ը կանաչ glColor3f է (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3- ը կապույտ glColor3f է (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4- ը մանուշակագույն է glEnd (); // Սպիտակ կողմ - 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 (); // Մանուշակագույն կողմ - ԱIGHԻ gl 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 (); // Կանաչ կողմ - 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 (); // Կապույտ կողմ - 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 (); // Կարմիր կողմ - 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 () Հետադարձ գործառույթ // ------------------------------ ---------------------------- անվավեր հատուկ բանալիներ (int ստեղն, int x, int y) {// Աջ սլաք-պտույտը մեծացնել 5-ով աստիճան եթե (բանալին == GLUT_KEY_RIGHT) պտտել_յ += 5; // Ձախ սլաք - նվազեցրեք պտույտը 5 աստիճանով, եթե (բանալին == GLUT_KEY_LEFT) պտտել_յ - = 5; այլապես, եթե (բանալին == GLUT_KEY_UP) պտտել_ x += 5; այլապես, եթե (բանալին == GLUT_KEY_DOWN) պտտել_ x -= 5; // Պահանջել ցուցադրման թարմացում glutPostRedisplay (); } // --------------------------------------------------- ----------- // հիմնական () գործառույթը // ----------------------------------- --------------------------- int main (int argc, char* argv ) {// Initialize GLUT և մշակեք օգտվողի պարամետրերը glutInit (& argc, argv); // Պահանջել կրկնակի բուֆերային իրական գույնի պատուհան Z-buffer glutInitDisplayMode- ով (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Ստեղծել պատուհանի glutCreateWindow («Հրաշալի խորանարդ»); // Միացնել Z- բուֆերի խորության թեստը glEnable (GL_DEPTH_TEST); // Հետադարձ գործառույթներ glutDisplayFunc (ցուցադրում); glutSpecialFunc (specialKeys); // Անցեք հսկողությունը GLUT- ին glutMainLoop իրադարձությունների համար (); // Վերադառնալ OS վերադարձ 0; }

Խորհուրդ ենք տալիս: