विषय

• कदम
• 3 में से 1 भाग: प्रारंभिक स्थापना
• 3 का भाग 2: प्रदर्शन () फ़ंक्शन
• भाग ३ का ३: कार्यक्रम अन्तरक्रियाशीलता

OpenGL एक 3D प्रोग्रामिंग टूल है जो आपको साधारण आकृतियों से जटिल 3D चित्र बनाने की अनुमति देता है। इस लेख में, आप सीखेंगे कि उसकी मदद से एक साधारण घन कैसे खींचना है जिसे तीन आयामों में घुमाया जा सकता है!

कदम

3 में से 1 भाग: प्रारंभिक स्थापना

1. 1 ओपनजीएल स्थापित करें। अपने कंप्यूटर पर ओपनजीएल कैसे स्थापित करें, इस पर एक ट्यूटोरियल के साथ शुरू करें। यदि आपके पास पहले से OpenGL और C कंपाइलर है, तो आप इस चरण को छोड़ सकते हैं और अगले पर जा सकते हैं।
2. 2 एक दस्तावेज़ बनाएँ। अपने पसंदीदा कोड संपादक में एक नई फ़ाइल बनाएं और इसे mycube.c . के रूप में सहेजें
3. 3 #शामिल करें। यहां बुनियादी #include निर्देश दिए गए हैं जिनकी आपको आवश्यकता होगी। यह याद रखना महत्वपूर्ण है कि विभिन्न ऑपरेटिंग सिस्टम के निर्देश अलग-अलग हैं, और इसलिए आपको सब कुछ चुनने की आवश्यकता है ताकि कार्यक्रम सार्वभौमिक हो और किसी भी सिस्टम पर चलाया जा सके।

   // शामिल हैं #stdio.h> #stdarg.h शामिल करें> #गणित शामिल करें।

4. 4 कार्यात्मक प्रोटोटाइप और ग्लोबल्स जोड़ें। अगला कदम कार्यात्मक प्रोटोटाइप घोषित करना है।

   // कार्यात्मक प्रोटोटाइप शून्य प्रदर्शन (); शून्य विशेष कुंजी (); // वैश्विक चर डबल रोटेट_वाई = 0; डबल रोटेट_एक्स = 0;

5. 5 मुख्य () फ़ंक्शन को परिभाषित करें।

   int main (int argc, char * argv []) // GLUT को इनिशियलाइज़ करें और कस्टम पैरामीटर glutInit (& argc, argv) को प्रोसेस करें; // डबल बफरिंग, जेड-बफरिंग और ट्रू कलर glutInitDisplayMode (GLUT_DOUBLE) के समर्थन के साथ एक विंडो का अनुरोध करें

3 का भाग 2: प्रदर्शन () फ़ंक्शन

1. 1 डिस्प्ले () फ़ंक्शन के उद्देश्य को समझें। क्यूब को रेंडर करने का सारा काम इस फंक्शन की नाजुक रेखाओं पर होगा। सामान्य विचार यह है: आप घन के छह अलग-अलग फलक बनाएंगे और उन्हें उनके संबंधित स्थान पर रखेंगे।
   • प्रत्येक चेहरे के लिए, आप चार कोनों को परिभाषित करेंगे, और ओपनजीएल उन्हें लाइनों से जोड़ देगा और उन्हें आपके चुने हुए रंग से भर देगा। यह कैसे करना है नीचे समझाया जाएगा।
2. 2 GlClear () फ़ंक्शन जोड़ें। सबसे पहले, इस फ़ंक्शन के साथ काम करते समय, हमें चाहिए स्पष्ट रंग और जेड-बफर... इसके बिना, पुरानी तस्वीर नई तस्वीर के नीचे दिखाई देगी, और कार्यक्रम द्वारा खींची गई वस्तुओं को गलत तरीके से रखा जाएगा।

   शून्य प्रदर्शन () // स्क्रीन और Z बफर को साफ़ करें glClear (GL_COLOR_BUFFER_BIT)

   • अंतिम दो पंक्तियों पर ध्यान दें। ये कार्य हैं ग्लफ्लश (); तथा ग्लूटस्वैपबफर ();, डबल बफरिंग का प्रभाव दे रहा है, जिसका वर्णन ऊपर किया गया था।

भाग ३ का ३: कार्यक्रम अन्तरक्रियाशीलता

1. 1 विशेषकी () फ़ंक्शन जोड़ें। सिद्धांत रूप में, सब कुछ लगभग तैयार है, लेकिन घन केवल खींचा जाता है और घुमाया नहीं जाता है। ऐसा करने के लिए, आपको बनाने की जरूरत है विशेष कुंजी () फ़ंक्शन, जो आपको तीर कुंजियों को दबाकर क्यूब को घुमाने की अनुमति देगा!
   • यह इस फ़ंक्शन के लिए है कि वैश्विक चर रोटेट_एक्स और रोटेट_य घोषित किए गए थे। जब आप बाएँ और दाएँ तीर कुंजियों को दबाते हैं, तो रोटेट_वाई मान पाँच डिग्री तक बढ़ या घटेगा। रोटेट_एक्स का मान उसी तरह बदल जाएगा, लेकिन इस बार ऊपर और नीचे तीर कुंजियों को दबाने से।

   शून्य विशेष कुंजी (int कुंजी, int x, int y) {// दायां तीर - रोटेशन को 5 डिग्री तक बढ़ाएं यदि (कुंजी == GLUT_KEY_RIGHT) रोटेट_y + = 5; // लेफ्ट एरो - रोटेशन को 5 डिग्री तक घटाएं अगर (कुंजी == GLUT_KEY_LEFT) रोटेट_y - = 5; और अगर (कुंजी == GLUT_KEY_UP) रोटेट_x + = 5; और अगर (कुंजी == GLUT_KEY_DOWN) रोटेट_x - = 5; // अनुरोध स्क्रीन रीफ्रेश glutPostRedisplay (); }

2. 2 ग्लोरोटेट () जोड़ें। आखिरी चीज जो हम करेंगे वह है एक लाइन जोड़ना जो हमें ऑब्जेक्ट को घुमाने की अनुमति देगी। समारोह पर लौटें प्रदर्शन () और सामने की ओर के विवरण से पहले जोड़ें:

   // रीसेट ट्रांसफ़ॉर्म glLoadIdentity (); // घुमाएँ जब उपयोगकर्ता मान बदलता है रोटेट_एक्स और रोटेट_य ग्लोटेटेफ (रोटेट_एक्स, 1.0, 0.0, 0.0); glRotatef (रोटेट_वाई, 0.0, 1.0, 0.0); // बहुरंगा पक्ष - सामने ....

   • कृपया ध्यान दें कि वाक्यविन्यास ग्लोरोटेफ ()जो glColor3f () और glVertex3f () के सिंटैक्स के समान है, लेकिन हमेशा चार पैरामीटर की आवश्यकता होती है। पहला रोटेशन कोण डिग्री में है। अगले तीन अक्ष हैं जिनके साथ x, y, z क्रम में घूर्णन होता है। अभी के लिए, हमें घन को दो अक्षों, x और y के अनुदिश घुमाना होगा।
   • कार्यक्रम में परिभाषित सभी परिवर्तनों के लिए समान पंक्तियों की आवश्यकता होती है। मूल रूप से, हम x-अक्ष के साथ किसी वस्तु के घूर्णन को Rotate_x के मान में परिवर्तन के रूप में, और y-अक्ष के साथ घूर्णन को रोटेट_y के मान में परिवर्तन के रूप में दर्शाते हैं। हालांकि, ओपनजीएल सब कुछ एक परिवर्तन मैट्रिक्स में बंडल करेगा। हर बार जब आप डिस्प्ले को कॉल करते हैं, तो आप एक ट्रांसफ़ॉर्मेशन मैट्रिक्स बनाएंगे, और ग्ललोड आइडेंटिटी () आपको हर बार एक नए मैट्रिक्स के साथ शुरुआत करने की अनुमति देगा।
   • आपके द्वारा उपयोग किए जा सकने वाले अन्य परिवर्तन कार्य हैं glTranslatef () और glScalef ()। वे glRotatef () के समान हैं, सिवाय इसके कि उन्हें केवल तीन मापदंडों की आवश्यकता होती है: ऑब्जेक्ट का आकार बदलने और स्केल करने के लिए x, y, और z मान।
   • जब सभी तीन रूपांतरण एक वस्तु पर लागू होते हैं, तो सब कुछ सही ढंग से प्रदर्शित होने के लिए, आपको परिवर्तनों को उचित क्रम में सेट करने की आवश्यकता होती है, अर्थात् ग्लट्रांसलेट, ग्लोरोटेट, ग्लस्केल - और कभी नहीं। ओपनजीएल प्रोग्राम को नीचे से ऊपर तक पढ़कर ऑब्जेक्ट को बदल देता है। इसे बेहतर ढंग से समझने के लिए, कल्पना करें कि 1x1x1 क्यूब सभी परिवर्तनों की देखभाल कैसे करेगा यदि ओपनजीएल ने उन्हें दिखाए गए क्रम (ऊपर से नीचे) में लागू किया है, और फिर सोचें कि ओपनजीएल नीचे से ऊपर के निर्देशों को पढ़कर क्यूब को कैसे संसाधित करेगा।
3. 3 क्यूब को x और y दिशाओं में दो बार स्केल करने के लिए, क्यूब को y अक्ष में 180 डिग्री घुमाने के लिए, और क्यूब को x अक्ष में 0.1 ले जाने के लिए निम्नलिखित कमांड जोड़ें। सुनिश्चित करें कि पहले दिए गए glRotate () कमांड सहित सभी प्रासंगिक कमांड सही क्रम में हैं। यदि आप गलती करने से डरते हैं, तो लेख के अंत में कार्यक्रम का अंतिम संस्करण देखें।

   // अधिक परिवर्तन glTranslatef (०.१, ०.०, ०.०); glRotatef (१८०, ०.०, १.०, ०.०); ग्लस्केलेफ (2.0, 2.0, 0.0);

4. 4 कोड संकलित करें और चलाएं। मान लें कि आप अपने कंपाइलर के रूप में gcc का उपयोग कर रहे हैं, इसलिए अपने टर्मिनल में निम्नलिखित कमांड दर्ज करें:

   लिनक्स पर: gcc cube.c -o cube -lglut -lGL ./ mycube मैक पर: gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube विंडोज़ पर: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -लोपेंगल32 ./ mycube

5. 5 अंतिम कोड की जाँच करें। यहाँ लेख के लेखक द्वारा बनाया गया अंतिम कोड है, जो टिप्पणियों का अनुवाद नहीं करता है।

   // // फ़ाइल: mycube.c // लेखक: मैट डेज़ली // बनाया गया: 4/25/2012 // प्रोजेक्ट: ओपनजीएल में एक क्यूब बनाने के लिए स्रोत कोड // विवरण: एक ओपनजीएल विंडो बनाता है और एक 3 डी क्यूब बनाता है / / कि उपयोगकर्ता तीर कुंजियों का उपयोग करके घुमा सकता है // // नियंत्रण: बायाँ तीर - बाएँ घुमाएँ // दायाँ तीर - दाएँ घुमाएँ // ऊपर तीर - ऊपर घुमाएँ // नीचे तीर - नीचे घुमाएँ // ------ -------------------------------------------------- - // शामिल हैं // ------------------------------------------- - -------------- #stdio.h शामिल करें> #stdarg.h शामिल करें> #गणित शामिल करें। GL / glut.h> #endif // --------------------------------------- - ------------------- // फंक्शन प्रोटोटाइप // ----------------------------- - -------------------------------- शून्य प्रदर्शन (); शून्य विशेष कुंजी (); //----------------------------------------------------- ---------- // सार्वत्रिक चर // ---------------------------------- ------------------------ डबल रोटेट_वाई = 0; डबल रोटेट_एक्स = 0; //----------------------------------------------------- ---------- // डिस्प्ले () कॉलबैक फ़ंक्शन // ----------------------------- --------------------------- शून्य प्रदर्शन () // स्पष्ट स्क्रीन और जेड-बफर ग्लक्लेयर (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // स्पेशल कीज़ () कॉलबैक फंक्शन // --------------------------------------- - ------------------- शून्य विशेष कुंजी (इंट की, इंट एक्स, इंट वाई) {// राइट एरो - रोटेशन को 5 डिग्री बढ़ाएं अगर (कुंजी == GLUT_KEY_RIGHT) रोटेट_y + = 5; // बायां तीर - रोटेशन को 5 डिग्री कम करें यदि (कुंजी == GLUT_KEY_LEFT) रोटेट_y - = 5; अन्यथा यदि (कुंजी == GLUT_KEY_UP) रोटेट_x + = 5; अन्यथा यदि (कुंजी == GLUT_KEY_DOWN) रोटेट_x - = 5; // अनुरोध प्रदर्शन अद्यतन glutPostRedisplay ();} // ----------------------------------- - ---------------------- // मुख्य () फ़ंक्शन // ------------------- - --------------------------------------- इंट मेन (इंट argc, char * argv [] ) GLUT_RGB