ओपनजीएल क्यूब कैसे बनाएं

ओपनजीएल एक शक्तिशाली 3D प्रोग्रामिंग टूल है जो सरल आकृतियों से प्राप्त जटिल तीन आयामी रचनाओं को बनाने के लिए उपयोग किया जाता है। यह आलेख आपको सिखा देगा कि एक सरल क्यूब कैसे बनाया जाए जिसे तीन आयामों में देखा जा सकता है!

सामग्री

चरणों

विधि 1प्रारंभिक विन्यास और मुख्य () फ़ंक्शन

1) ओपनजीएल स्थापित करें
2) दस्तावेज़ बनाएँ
3) # शामिल
4) फंक्शन स्टेटमेंट्स और ग्लोबल वैरिएबल
5) मुख्य () फ़ंक्शन को कॉन्फ़िगर करना
6) प्रोग्राम विंडो बनाना
7) गहराई टेस्ट सक्षम करें
8) कॉलबैक कार्य
9) कॉलबैक कार्य

विधि 2डिस्प्ले फ़ंक्शन ()

1) ग्लैचियर ()
2) ग्लोबिन () और ग्लैंड ()
3) ग्लवेटेक्स 3 एफ ()
4) glcolor3f ()
5) अन्य पक्षों

विधि 3उपयोगकर्ता इंटरैक्टिविटी

1) विशेष कियां ()
2) ग्लोटाट ()
संकलन

विधि 4अंतिम स्रोत कोड

सूत्रों और कोटेशन

इस परियोजना के लिए, आपको सी प्रोग्रामिंग भाषा में एक स्रोत कोड संपादक और थोड़ा ज्ञान की आवश्यकता होगी।

चरणों

विधि 1
प्रारंभिक विन्यास और मुख्य () फ़ंक्शन

1) ओपनजीएल स्थापित करें

आरंभ करने के लिए, इन निर्देशों का पालन करें ओपनजीएल स्थापित करने के लिए आपके सिस्टम पर यदि आपके पास पहले से ही OpenGL और सी संकलक है, तो इस चरण को छोड़ दें और अगले एक पर जाएं।

2) दस्तावेज़ बनाएँ

अपने पसंदीदा कोड संपादक में एक नई फाइल बनाएं और इसे meucubo.c के रूप में सहेजें

3) # शामिल

मूलभूत समावेशन हैं जो आपको कार्यक्रम बनाने की आवश्यकता होगी। यह ध्यान रखना महत्वपूर्ण है कि ऑपरेटिंग सिस्टम के आधार पर शामिल किए जाने वाले पैकेज बदल सकते हैं। सभी पैकेज शामिल करना सुनिश्चित करें जो कि सुनिश्चित करें कि आपका प्रोग्राम बहुमुखी है और किसी भी उपयोगकर्ता द्वारा उपयोग किया जा सकता है
```
// शामिल # शामिल # शामिल # शामिल #define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # else # शामिल #endif
```

4) फंक्शन स्टेटमेंट्स और ग्लोबल वैरिएबल

हमारा अगला कदम कुछ कार्यों को घोषित करना है।

// प्रदर्शन Funçõesvoid बयान () - specialKeys शून्य () - // चर Globaisdouble डबल rotate_y = 0 = 0- rotate_x

इन कार्यों और चर को ट्यूटोरियल के दौरान विस्तार से समझाया जाएगा। अभी के लिए, उन्हें घोषित करने के लिए बस बंद करो।

5) मुख्य () फ़ंक्शन को कॉन्फ़िगर करना

int main (int argc, char * argv []) GLUT_DEPTH) -

यह कमांड पर्यावरण सेट करता है ओपनजीएल में प्रोग्राम लिखते समय एक महत्वपूर्ण पहलू यह है कि आपको हर चीज के ऑर्डर करने की ज़रूरत है यही कारण है कि आपको अपने कार्यक्रम के बारे में विस्तृत समझने की ज़रूरत है और आपको जो कार्यशीलता आप चाहते हैं उसे बनाने के लिए आपको अपने कोड में शामिल करने की आवश्यकता है। इस रेखा में, हमने प्रोग्राम के प्रस्तुति स्क्रीन को डबल बफर, आरजीबी रंग और एक जेड-बफर बनाया है।
"डबल बफरिंग" ग्राफिक्स कार्यक्रमों में इस्तेमाल किया है कि पैदा होती है जब स्क्रीन पर छवियों ड्राइंग समस्याओं को खत्म करने के लिए एक तकनीक है। हर बार एक दृश्य को अपडेट करने की आवश्यकता होती है, स्क्रीन को हटा दिया जाना चाहिए और नई जानकारी तैयार की जाती है। कोई डबल बफरिंग आप जबकि स्क्रीन मिट और जल्दी से फिर से ताज़ा होता एक दोलन प्रभाव देखेंगे।

ऑन-स्क्रीन लेखन रोज़गारों के लिए दूसरा बफर जोड़कर समस्या का समाधान किया जाता है। इस विधि के साथ, छवि पहले बफर में तैयार की है, तो बफर स्क्रीन पर प्रदर्शित होता है। दृश्य के अगले फ्रेम दूसरा बफर में तैयार किया जाएगा, और जब प्रक्रिया पूरी हो जाए बफ़र्स उलट दिया जाएगा। हम तुरंत दूसरा बफर देखते हैं, लेकिन इस बीच में, पहले बफर छिपा मिट और एक तीसरे फ्रेम के साथ दोबारा बनाई जा रही है जब आप समाप्त कर प्रदर्शित करने के लिए।
हम अपनी विंडो में "आरजीबी" रंग सिस्टम को भी अनुमति देना चाहते हैं। हम "डिस्प्ले" फ़ंक्शन के साथ काम करते समय ओपनएलएल में रंग का प्रयोग करेंगे।
जेड बफरिंग हम चाहते हैं कि 3 डी प्रभाव बनाने के लिए इस्तेमाल किया उपकरण है ओपनजीएल एक्स, वाई, और जेड एक्सिस के साथ एक तीन-समन्वय प्रणाली का उपयोग करता है। प्रभाव है कि एक वस्तु आप के करीब है देने के लिए, z- अक्ष में अपनी स्थिति बढ़ जाती है। व्युत्क्रम प्रभाव को प्रभावित करने के लिए, z- अक्ष पर इसकी स्थिति कम हो गई है। जब हम अपने घन के कोने बनाते हैं तो हम इसके बारे में कुछ और बातें करेंगे।

6) प्रोग्राम विंडो बनाना

अगला कदम यह है कि खिड़की बनाएं जिसमें हमारे घन को तैयार किया जाएगा। इस ट्यूटोरियल में, हम "सुपर क्यूब" विंडो को कॉल करेंगे।
```
// janelaglutCreateWindow बनाएँ ("सुपर क्यूब") -
```

7) गहराई टेस्ट सक्षम करें

ओपनजीएल एक प्रतिबंधित भाषा है जिस पर डिफ़ॉल्ट रूप से कोई विशेष सुविधाएं सक्षम नहीं होती हैं। हमारे प्रोग्राम को Z-बफर का उपयोग करके ठीक से 3D छवियों को पेश करने के लिए, हमें "गहराई परीक्षण" को सक्षम करना होगा ओपनजीएल की खोज करते समय, आप कई विशेषताओं की खोज करेंगे जिन्हें सक्षम होना चाहिए, जैसे कि प्रकाश और बनावट
```
// Z- बफरगेल सक्षम गहराई परीक्षण (GL_DEPTH_TEST) सक्षम करें -
```

8) कॉलबैक कार्य

यहां दिए गए कॉलबैक फ़ंक्शन हैं जो हमने पिछले बयान में लिखे हैं। इन कार्यों को प्रत्येक बार कार्यक्रम चक्र मुख्य लूप के माध्यम से बुलाया जाएगा। डिस्प्ले फ़ंक्शन अंतिम कॉल के बाद से किए गए चर में किसी भी बदलाव के आधार पर दृश्य को रेखांकित करता है। विशेष कियो समारोह हमें कार्यक्रम के साथ बातचीत करने की अनुमति देता है।
```
// फ़ंक्शंस कॉलबैक्लुट डिस्प्लेफंक (डिस्प्ले) -ग्लुसटविशेषफंक्स (विशेष किकेज़) -
```

9) कॉलबैक कार्य

हमारी प्रारंभिक सेटअप में अंतिम चरण है मेनलूप प्रारंभ करें. यह मुख्य फ़ंक्शन को कॉल करेगा जब तक कि हम कार्यक्रम बंद नहीं करते हैं, एनिमेशन को और उपयोगकर्ता के साथ संपर्क करने की इजाजत दे सकते हैं।
```
// घटनाओं पर नियंत्रण पास करना GLUTglutMainLoop () - // वापस SOreturn 0-
```

विधि 2
डिस्प्ले फ़ंक्शन ()

क्यूब ड्राइंग में किए गए सभी कार्य इस फ़ंक्शन में किए जाएंगे। क्यूब के पीछे सामान्य विचार अलग-अलग सभी छह पक्षों को आकर्षित करना है और उन्हें उपयुक्त पदों पर रखें
संकल्पनात्मक रूप से, प्रत्येक पक्ष अपने चार कोने को परिभाषित करके तैयार किया जाएगा, फिर ओपनजीएल को लाइनों से कनेक्ट करना और एक चुना हुआ रंग भरना होगा। ऐसा करने के लिए नीचे दिए गए कदम हैं

1) ग्लैचियर ()

इस फ़ंक्शन में प्रदर्शन करने के लिए हमें पहले चरण चाहिए रंग और जेड-बफर को साफ़ करें. इन चरणों के बिना, पुराने चित्र को नई जानकारी में देखा जा सकता है, और ऑब्जेक्ट स्क्रीन पर सही स्थान पर नहीं होंगे।
```
शून्य प्रदर्शन () GL_DEPTH_BUFFER_BIT) -
```

2) ग्लोबिन () और ग्लैंड ()

ओपनजीएल ऑब्जेक्ट्स को विभिन्न बहुभुजों के संयोजन के रूप में परिभाषित करता है। आदेश का उपयोग करते समय ग्लबेइन (), हम ओपनजीएल को बताते हैं कि यह हम चाहते प्रारूप को आकर्षित करने के लिए तैयार है प्रक्रिया समाप्त करने के लिए और एक नया प्रारूप शुरू करने के लिए, हमें कमांड का उपयोग करना होगा ग्लेन्ड (). इस ट्यूटोरियल में, हम घन के प्रत्येक पक्ष आकर्षित करने के लिए GL_POLYGON का उपयोग करेगा, लेकिन यह भी GL_LINE, GL_QUAD GL_TRIANGLE के रूप में अन्य पैरामीटर का उपयोग करने के लिए या अन्य रूपों बनाने के लिए संभव है।
चलो क्यूब के सामने से शुरू करते हैं। हम बाद में 6 पक्षों में रंग जोड़ देंगे।
```
// बहुरंगी साइड - FRENTEglBegin (GL_POLYGON) - // कोने अगले etapaglEnd में जोड़ दिया जाएगा () -
```

3) ग्लवेटेक्स 3 एफ ()

एक बार जब हम घोषणा करते हैं कि हम हमारी बहुभुज शुरू करना चाहते हैं, तो हमें इसकी आवश्यकता है कोने को परिभाषित करें ऑब्जेक्ट का GlVertex फ़ंक्शन में ऐसा करने के कई तरीके हैं कि आप ऑब्जेक्ट कैसे चाहते हैं।
पहला विकल्प यह है कि आप कितने आयामों के साथ काम करना चाहते हैं। 3 में ग्लिटेक्स 3 एफ का कहना है कि हम 3 आयामों में आ रहे हैं। यह 2 या 4 आयामों में भी काम करना संभव है। GlVertexf में एफ हमें बताता है कि हम फ्लोट (फ्लोटिंग प्वाइंट) संख्याओं के साथ काम कर रहे हैं। आप अन्य प्रकार के डेटा का भी उपयोग कर सकते हैं, जैसे कि शॉर्ट्स, पूर्णांक या युगल
सत्यापित करें कि ये बिंदु क्रम में सेट हैं वामावर्त. यह अब इतनी महत्वपूर्ण नहीं है, लेकिन जब हम प्रकाश और बनावट के साथ काम करना शुरू करते हैं, तो घड़ी-विरोधी क्रम में एक बिंदु सेट करने के आदी होने के लिए यह बेहद जरूरी होगा

अब हम glBegin () और glend () कमांड के बीच के कोने जोड़ सकते हैं।

// बहुरंगी साइड - FRENTEglBegin (GL_POLYGON) -glVertex3f (-0.5, -0.5, -0.5) - // P1glVertex3f (-0.5, 0.5, -0.5) - // P2glVertex3f (0.5, 0.5, -0.5) - // P3glVertex3f (0.5, -0.5, -0.5) - // P4glEnd () -

4) glColor3f ()

glColor glVertex के समान काम करता है हम अंकों को शॉर्ट्स, इंटिजर्स, डबल्स या फ़्लोट्स के रूप में परिभाषित कर सकते हैं। प्रत्येक रंग का मूल्य 0 से 1 तक होता है। 0 की तरह सब कुछ काला बिंदु को छोड़ देगा और 1 जैसा सब कुछ सफेद बिंदु को छोड़ देगा। ग्लोबल 3 एफ () में 3 अल्फा चैनल के बिना आरजीबी सिस्टम को संदर्भित करता है। एक रंग का अल्फा उसकी पारदर्शिता को परिभाषित करता है अल्फा स्तर को बदलने के लिए, glColor4f () कमांड का प्रयोग करके आखिरी पैरामीटर को 0 और 1 के बीच के मूल्य के साथ, अपारदर्शी पारदर्शी के लिए क्रमशः उपयोग करें।
जब हम glColor3f () फ़ंक्शन को कॉल करते हैं, तो उस बिंदु से खींची गई प्रत्येक वर्टेक्स परिभाषित रंग का होगा। यदि आप चार कोने से लाल होना चाहते हैं, तो glVertex3f () कमांड से पहले एक बार रंग सेट करें और सभी कोने लाल हो जाएंगे
नीचे परिभाषित सामने चेहरा दिखाता है कि हम प्रत्येक शीर्ष के लिए एक नया रंग कैसे परिभाषित करते हैं। जब हम ऐसा करते हैं, तो हम ओपनजीएल रंगों की एक दिलचस्प संपत्ति देख सकते हैं। चूंकि बहुभुज के प्रत्येक शीर्ष का अपना रंग होता है, ओपनजीएल उन्हें स्वचालित रूप से मिश्रित करेगा! अगले चरण आपको दिखाएगा कि एक ही रंग के चार कोने कैसे बनाएं।
```
// बहुरंगी साइड - FrenteglBegin (GL_POLYGON) -glColor3f (1.0, 0.0, 0.0) - glVertex3f (0.5, -0.5, -0.5) - // P1 vermelhoglColor3f (0.0, 1.0, 0.0) है - glVertex3f (0.5, 0.5, - 0.5) - // P2 verdeglColor3f (0.0, 0.0, 1.0) है - glVertex3f (-0.5, 0.5, -0.5) - // पी 3 azulglColor3f (1.0, 0.0 है, 1.0) - glVertex3f (-0.5, -0.5, -0.5 ) - // पी 4 roxoglEnd () है -
```

5) अन्य पक्षों

हम अनुशंसा करते हैं कि आप दूसरे पांच पक्षों के प्रत्येक कोने की स्थिति की खोज करें, लेकिन सादगी के लिए, हम पहले से ही आपके लिए उन्हें गणना करते हैं और उन्हें हमारे अंतिम प्रदर्शन () फ़ंक्शन नीचे दिए गए।

// व्हाइट पक्ष - TRASEIRAglBegin (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 () - बैंगनी पक्ष // - DIREITAglBegin (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 () - // हरी साइड - ESQUERDAglBegin (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 () - // नीले साइड - TOPOglBegin ( 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 () - // लाल साइड - BASEglBegin (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 () - glutSwapBuffer s () -

हमें अभी भी इस फ़ंक्शन के कोड में दो और पंक्तियां जोड़नी है।

विधि 3
उपयोगकर्ता इंटरैक्टिविटी

1) विशेष कियां ()

हम लगभग पूरा कर चुके हैं, लेकिन अभी के लिए हम सिर्फ एक स्थिर क्यूब बना सकते हैं। हम इसे बारी बारी से नहीं कर सकते ऐसा करने के लिए, हम इसे बनाएंगे विशेषकीज़ () फ़ंक्शन जो हमें घन को घुमाने के लिए तीर कुंजियों को दबाएगी!

इस फ़ंक्शन की वजह से हमने वैश्विक चर rotate_x और rotate_y घोषित किया था। जब हम दाएं या बायां तीर का उपयोग करते हैं, तो rotate_y चर बढ़ जाएगा या 5 डिग्री से कम हो जाएगा। इसी तरह, ऊपर और नीचे तीर का उपयोग करते समय, rotate_x वैरिएबल उसी तरह बदल जाएगा।

specialKeys शून्य (कुंजी पूर्णांक, पूर्णांक एक्स, int y) {// दायाँ तीर - 5 रोटेशन grausif बढ़ जाती है (कुंजी == GLUT_KEY_RIGHT) rotate_y = 5 + - // बायाँ तीर - 5 रोटेशन grauselse अगर (कम कर देता है कुंजी == GLUT_KEY_LEFT) rotate_y - = 5-else if (कुंजी == GLUT_KEY_UP) + = rotate_x -5 else if (कुंजी == GLUT_KEY_DOWN) rotate_x - 5 = - // अद्यतन अनुरोध telaglutPostRedisplay () -}

2) ग्लोटाट ()

हमारा अंतिम चरण एक ऐसा तरीका जोड़ना है जो ऑब्जेक्ट को घुमाएगा। चलिए "डिस्प्ले ()" फ़ंक्शन पर वापस जाते हैं और क्यूब के फ्रंट बनाने से पहले, हम इन लाइनों को जोड़ देंगे:
```
// रीसेट transformaçõesglLoadIdentity () - // घुमाएँ जब आप चर बदल सकते हैं और rotate_yglRotatef rotate_x (rotate_x, 1.0, 0.0, 0.0) -glRotatef (rotate_y, 0.0, 1.0, 0.0) - // बहुरंगी साइड - सामने ....
```
ध्यान दें कि फ़ंक्शन सिंटैक्स ग्लोटेटेफ़ () glColor3f () और glVertex3f () के वाक्यविन्यास के समान है, लेकिन अब 4 मापदंडों के साथ। पहला पैरामीटर लागू होने के लिए रोटेशन की डिग्री है। अन्य तीन मापदंडों को संदर्भ अक्ष को घुमाने के लिए परिभाषित किया जाता है, पहले वाला एक्स, दूसरा वाई, और तीसरा ज। अभी के लिए हमें एक्स और वाई अक्ष के आसपास घूमने की जरूरत है
हमारे कार्यक्रम में सभी परिवर्तनों की आवश्यकता होती है जैसे कि ये। रोटेशन की मात्रा को संबंधित अक्षों पर rotate_x और rotate_y चर द्वारा परिभाषित किया गया है। इसके बावजूद, ओपनजीएल सब कुछ सरल करता है और सभी तीन आज्ञाओं को सिर्फ एक सरणी परिवर्तन में जोड़ती है। हर बार जब हम डिस्प्ले फ़ंक्शन कॉल करते हैं, तो प्रोग्राम एक परिवर्तन मैट्रिक्स बनाएगा, और फ़ंक्शन glLoadIdentity () यह सुनिश्चित करेगा कि हम हमेशा प्रत्येक कॉल के साथ एक नया मैट्रिक्स शुरू करें।
अन्य परिवर्तनों को भी लागू किया जा सकता है glTranslatef () और glScalef () वे glRotatef () के समान हैं, लेकिन ऑब्जेक्ट को अनुवाद या पैमाने के लिए केवल 3 पैरामीटर, एक्स, वाई, और जेड में मात्रा की आवश्यकता है।
एक वस्तु में तीन परिवर्तनों को लागू करते समय सही प्रभाव प्राप्त करने के लिए, आपको किसी विशिष्ट क्रम में कार्य लागू करना चाहिए। हमेशा फ़ंक्शन को क्रम में लिखें glTranslate, glRotate और glScale. ओपनजीएल नीचे परिवर्तन से परिवर्तनों को लागू करता है इस ख़ासियत को समझने के लिए, कल्पना करें कि एक सरल 1x1x1 घन क्या होगा यदि परिवर्तनों को ऊपर से नीचे और ऊपर से ऊपर तक लागू किया गया था
एक्स-एक्स पर क्यूब 2 का आकार बदलने के लिए, y-axis पर 2 का आकार बदलने के लिए, y-axis पर 180 डिग्री को घुमाने के लिए, और एक्स-एक्स की ओर 0.1 का अनुवाद करने के लिए निम्न आदेश जोड़ें। कार्यों को ऊपर वर्णित सही क्रम में सॉर्ट करना सुनिश्चित करें (यदि आप निश्चित नहीं हैं, उदाहरण ट्यूटोरियल के अंत में अंतिम स्रोत कोड में प्रदर्शित किया गया है)।
```
// अन्य ट्रांसफ़ॉर्मेंसग्लांसस्लैटफ़ (0.1, 0.0, 0.0) -glRotatef (180, 0.0, 1.0, 0.0) -glScalef (2.0, 2.0, 0.0) -
```

संकलन

हमारी पहली परियोजना को अंतिम रूप देने के लिए अंतिम चरण है संकलन और कोड घुमाएगी. मान लें कि आप जीसीसी को अपने डिफॉल्ट कंपाइलर के रूप में इस्तेमाल करते हैं, प्रोग्राम को संकलित और जांचने के लिए अपने टर्मिनल पर इन कमांड का उपयोग करें।
```
लिनक्स पर: जीसीसी -ओ cube.c घन -lglut -lGL./ meucuboNo मैक: जीसीसी -ओ foo foo.c -framework भरमार -framework OpenGL./ meucuboNo विंडोज: जीसीसी -Wall -ofoo foo.c -lglut32cu -lglu32 - lopengl32./ meucubo
```

विधि 4
अंतिम स्रोत कोड

हमने कार्यक्रम समाप्त कर दिया। संदर्भ के रूप में उपयोग करने के लिए हमने नीचे पूरा स्रोत कोड प्रदान किया है

//// फ़ाइल: मेक्यूबो सी / // लेखक: मैट डेज़ली // निर्मित: 25/4/2012 // परियोजना: आलेख के लिए स्रोत कोड ओपनजीएल में क्यूब कैसे करें // विवरण: एक ओपनजीएल खिड़की बनाता है और एक क्यूब 3 डी में .// कि उपयोगकर्ता तीर कुंजियों के साथ घुमाएगी // // नियंत्रण: बायां तीर - दाएं तीर घुमाएँ / दायाँ तीर - दाएं तीर घुमाएँ / ऊपर तीर - घुमाए / ऊपर तीर डाउन करने के लिए - घुमाएँ डाउन ------------------------------------------ ---------------- // समावेशन // ----------------------------- ----------------------------- # शामिल # शामिल # शामिल #define GL_GLEXT_PROTOTYPES # ifdef __APPLE __ # include # else # शामिल # एंडीफ // ---------------------------------------------- ------------ // रोल घोषणाएं ------------------------------- --------------------------- शून्य प्रदर्शन () - शून्य specialKeys () - ----------- // ----------------------------------------------- // चर ग्लोबल // ----------------------------------------------- ----------- rotate_y डबल-डबल rotate_x = 0 = 0 - // --------------------------- ------------------------------- // डिस्प्ले फ़ंक्शन () // ----------- ----------------------------------------------- शून्य प्रदर्शन ( ) // स्क्रीन साफ़ करता है और जेड BufferglClear (GL_COLOR_BUFFER_BIT // ----------------------------------- ----------------------- // विशेष समारोह () // ------------------- --------------------------------------- specialKeys शून्य (कुंजी पूर्णांक, पूर्णांक एक्स, int y ) // {दायाँ तीर - 5 grausif रोटेशन बढ़ जाती है (कुंजी == GLUT_KEY_RIGHT) + = rotate_y 5 - छोड़ दिया तीर // - रोटेशन 5 grauselse से कम हो जाती है, तो (कुंजी == GLUT_KEY_LEFT) rotate_y - = 5-else if ( कुंजी == GLUT_KEY_UP) rotate_x + = 5- (कुंजी == GLUT_KEY_DOWN) rotate_x else if - 5 = - // अद्यतन displayglutPostRedisplay अनुरोध () -} // ------------------------- --------------------------------- // समारोह मुख्य () // --------- ------------------------------------------------- int मुख्य (int argc, char * argv []) GLUT_DEPTH) - // खिड़की programaglutCreateWindow ( "सुपर घन") बनाएँ - // सक्षम बनाता है गहराई परीक्षण जेड bufferglEnable (GL_DEPTH_TEST) - // FunçõesglutDisplayFunc (प्रदर्शन) - glutSpecialFunc (specialKeys) - GLUTglutMainLoop () के लिए घटनाओं की // पास नियंत्रण - // रिटर्न SOreturn 0- को