OpenGL एक शक्तिशाली 3D प्रोग्रामिंग टूल है जिसका उपयोग साधारण आदिम से जटिल त्रि-आयामी दृश्यों को खींचने के लिए किया जाता है। यह लेख आपको सिखाएगा कि एक साधारण घन कैसे बनाया जाए जिसे आप तीन आयामों में देखने के लिए घुमा सकते हैं!
इस परियोजना के लिए आपको एक कोड संपादक और सी प्रोग्रामिंग के कुछ ज्ञान की आवश्यकता होगी।
कदम
3 का भाग 1: आरंभिक सेटअप
चरण 1. ओपनजीएल स्थापित करें आरंभ करने के लिए अपने सिस्टम पर ओपनजीएल स्थापित करने के लिए इन चरणों का पालन करें।
यदि आपके पास पहले से ओपनजीएल है, साथ ही एक संगत सी कंपाइलर स्थापित है, तो आप इस चरण को छोड़ सकते हैं और अगले पर जा सकते हैं।
चरण 2. दस्तावेज़ बनाएँ।
अपने पसंदीदा कोड संपादक में एक नई फ़ाइल बनाएं और इसे mycube.c. के रूप में सहेजें
चरण 3. #शामिल करें।
ये बुनियादी शामिल हैं जिनकी आपको अपने कार्यक्रम के लिए आवश्यकता होगी। यह महसूस करना महत्वपूर्ण है कि वास्तव में अलग-अलग ऑपरेटिंग सिस्टम के लिए अलग-अलग शामिल हैं। यह सुनिश्चित करने के लिए कि आपका प्रोग्राम बहुमुखी है और किसी भी उपयोगकर्ता के लिए चल सकता है, इन सभी को शामिल करना सुनिश्चित करें।
// शामिल है #शामिल करें #शामिल करें #शामिल करें #GL_GLEXT_PROTOTYPES परिभाषित करें #ifdef _APPLE_ #include #else #include #endif
चरण 4. फ़ंक्शन प्रोटोटाइप और वैश्विक चर जोड़ें।
आपका अगला कदम कुछ फ़ंक्शन प्रोटोटाइप घोषित करना है।
// फ़ंक्शन प्रोटोटाइप शून्य प्रदर्शन (); शून्य विशेष कुंजी (); // वैश्विक चर डबल रोटेट_वाई = 0; डबल रोटेट_एक्स = 0;
चरण 5. मुख्य () फ़ंक्शन सेट करें।
int main(int argc, char* argv){ // GLUT को इनिशियलाइज़ करें और यूजर पैरामीटर्स को प्रोसेस करें glutInit(&argc, argv); // Z-बफर glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH) के साथ डबल बफर्ड ट्रू कलर विंडो का अनुरोध करें;
चरण 6. विंडो बनाएं।
अगला कदम है खिड़की बनाएं जिसके भीतर आप घन खींचेंगे। इस ट्यूटोरियल में, विंडो को "Awesome Cube" कहा जाता है।
// विंडो बनाएं glutCreateWindow ("बहुत बढ़िया क्यूब");
चरण 7. गहराई परीक्षण सक्षम करें।
ओपनजीएल एक सख्त भाषा है जिसमें यह नहीं माना जाता है कि कोई विशेष सुविधा सक्षम है। Z-बफर का उपयोग करके आपके प्रोग्राम को 3-आयामों में ठीक से प्रदर्शित करने के लिए, जिसे आपने पहले देखा था, आपको करने की आवश्यकता है गहराई-परीक्षण सक्षम करें. जैसे-जैसे आप ओपनजीएल को एक्सप्लोर करना जारी रखेंगे, आपको कई ऐसी सुविधाएं मिलेंगी, जिन्हें आपको सक्षम करने की आवश्यकता होगी, जिसमें लाइटिंग, टेक्सचर, कूल-फेसिंग और बहुत कुछ शामिल हैं।
// Z-बफर गहराई परीक्षण सक्षम करें glEnable(GL_DEPTH_TEST);
चरण 8. कॉलबैक फ़ंक्शन जोड़ें।
यहां वे कॉलबैक फ़ंक्शन हैं जिनके लिए आपने पहले प्रोटोटाइप लिखा था। हर बार मुख्य लूप के माध्यम से, इन कार्यों को बुलाया जाएगा। प्रदर्शन फ़ंक्शन पिछले कॉल के बाद से किए गए चर में किसी भी परिवर्तन के आधार पर दृश्य को फिर से तैयार करता है। SpecialKeys फंक्शन हमें प्रोग्राम के साथ इंटरैक्ट करने की अनुमति देता है।
// कॉलबैक फ़ंक्शन glutDisplayFunc (प्रदर्शन); glutSpecialFunc (विशेष कुंजी);
चरण 9. मेनलूप प्रारंभ करें।
यह मुख्य फ़ंक्शन को तब तक याद रखेगा जब तक आप एनिमेशन और उपयोगकर्ता इंटरैक्शन की अनुमति देने के लिए प्रोग्राम को बंद नहीं करते।
// घटनाओं के लिए GLUT पर नियंत्रण पास करें glutMainLoop (); // ओएस रिटर्न 0 पर लौटें; }
3 का भाग 2: प्रदर्शन () फ़ंक्शन
चरण 1. इस फ़ंक्शन के उद्देश्य को समझें।
इस फंक्शन में आपका क्यूब बनाने का सारा काम हो जाएगा। आपके घन के पीछे सामान्य विचार सभी छह पक्षों को अलग-अलग खींचना और उन्हें उपयुक्त स्थिति में रखना है।
संकल्पनात्मक रूप से, प्रत्येक पक्ष चार कोनों को परिभाषित करके और ओपनजीएल को लाइनों को जोड़ने और इसे आपके द्वारा परिभाषित रंग से भरने के द्वारा खींचा जा रहा है। ऐसा करने के चरण नीचे दिए गए हैं।
चरण 2. ग्लिक्लेयर () जोड़ें।
इस फ़ंक्शन में आपको जो पहला कदम उठाने की आवश्यकता है वह है: रंग और Z बफर साफ़ करें. इन चरणों के बिना, पुराने चित्र अभी भी नए चित्रों के नीचे दिखाई दे सकते हैं और खींची गई वस्तुएँ स्क्रीन पर सही स्थान पर नहीं होंगी।
शून्य प्रदर्शन () {// स्पष्ट स्क्रीन और जेड-बफर glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
चरण 3. GlBegin () और glEnd () जोड़ें।
ओपनजीएल वस्तुओं को विभिन्न बहुभुजों के संयोजन के रूप में परिभाषित करता है। का उपयोग करते हुए ग्लबीगिन () आदेश, आप प्रभावी रूप से एक पेंसिल डालते हैं जो एक आकृति खींचेगी। पेंसिल को ऊपर उठाने और एक नया आकार शुरू करने के लिए, आपको इसका उपयोग करना चाहिए ग्लेंड () आदेश। इस ट्यूटोरियल में आप क्यूब के प्रत्येक पक्ष को खींचने के लिए GL_POLYGON का उपयोग करेंगे लेकिन अन्य आकार बनाने के लिए GL_LINE, GL_QUAD, या GL_TRIANGLE जैसे अन्य पैरामीटर विकल्पों का उपयोग करना संभव है।
- यहां आप अपने क्यूब के सामने से शुरुआत करेंगे। बाद में आप सभी 6 पक्षों में रंग डालेंगे।
// बहु-रंगीन पक्ष - फ्रंट ग्लबीगिन (GL_POLYGON); // अगले चरण में कोने जोड़े जाएंगे glEnd ();
चरण 4. GlVertex3f() जोड़ें।
एक बार जब आपने कहा कि आप अपना बहुभुज शुरू करना चाहते हैं, तो आपको करने की आवश्यकता है शीर्षों को परिभाषित करें वस्तु का। आप अपनी वस्तु के साथ क्या करना चाहते हैं, इसके आधार पर glVertex के कई रूप हैं।
- पहला यह है कि आप कितने आयामों में काम कर रहे हैं। glVertex3f में उपरोक्त 3 कहता है कि आप 3 आयामों में आरेखण कर रहे हैं। 2 या 4 आयामों में काम करना भी संभव है। GlVertex3f में उपरोक्त f कहता है कि आप फ़्लोटिंग पॉइंट नंबरों के साथ काम कर रहे हैं। आप शॉर्ट्स, पूर्णांक या डबल्स का भी उपयोग कर सकते हैं।
- ध्यान दें कि इन बिंदुओं को परिभाषित किया गया है a वामावर्त तौर - तरीका। यह इस समय बहुत महत्वपूर्ण नहीं है, लेकिन जब आप लाइटिंग, टेक्सचर्स और कूल-फेसिंग के साथ काम करना शुरू करते हैं, तो यह अविश्वसनीय रूप से महत्वपूर्ण हो जाएगा, इसलिए अब अपने पॉइंट्स को वामावर्त परिभाषित करने की आदत डालें।
- GlBegin () और glEnd () लाइनों के बीच कोने जोड़ें।
// बहु-रंगीन पक्ष - फ्रंट ग्लबीगिन (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); // पी 4 ग्लेंड ();
चरण 5. GlColor3f() जोड़ें।
glColor, glVertex की तरह ही काम करता है। आप अंक को शॉर्ट्स, पूर्णांक, युगल या फ्लोट के रूप में परिभाषित कर सकते हैं। प्रत्येक रंग का मान 0 से 1 तक होता है। सभी 0 बिंदु को काला बनाते हैं और सभी 1 बिंदु को सफेद बनाते हैं। GlColor3f() में 3 आरजीबी रंग प्रणाली को संदर्भित करता है जिसमें कोई अल्फा चैनल नहीं है। एक रंग का अल्फा इसकी पारदर्शिता को परिभाषित करता है। अल्फा स्तर को बदलने के लिए, अंतिम पैरामीटर 0 से 1 के मान के साथ अपारदर्शी से पारदर्शी के लिए glColor4f() का उपयोग करें।
- जब आप glColor3f() को कॉल करते हैं तो उस बिंदु से खींचा गया प्रत्येक शीर्ष उस रंग का होगा। इसलिए, यदि आप चाहते हैं कि सभी चार कोने लाल हों, तो glVertex3f() कमांड से पहले कभी भी एक बार रंग सेट करें और सभी कोने लाल हो जाएंगे।
- नीचे परिभाषित सामने वाला पक्ष दिखाता है कि प्रत्येक शीर्ष के लिए एक नया रंग कैसे परिभाषित किया जाए। जब आप ऐसा करते हैं, तो आप ओपनजीएल रंगों की एक दिलचस्प संपत्ति देख सकते हैं। चूंकि बहुभुज के प्रत्येक शीर्ष का अपना रंग होता है, OpenGL स्वचालित रूप से रंगों को मिश्रित कर देगा! अगला चरण दिखाएगा कि एक ही रंग के साथ चार शीर्षों को कैसे निर्दिष्ट किया जाए।
// बहु-रंगीन पक्ष - फ्रंट ग्लबीगिन (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 () है;
चरण 6. दूसरे पक्षों को संभालें।
गणना करें कि घन की अन्य पाँच भुजाओं के लिए प्रत्येक शीर्ष का स्थान क्या होगा, लेकिन सरलता के लिए, ये आपके लिए परिकलित किए गए हैं और इन्हें इसमें शामिल किया गया है अंतिम प्रदर्शन () फ़ंक्शन नीचे।
// सफेद पक्ष - बैक ग्लोबिन (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); ग्लेंड (); // पर्पल साइड - राइट ग्लोबिन (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); ग्लेंड (); // ग्रीन साइड - लेफ्ट ग्लोबिन (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); ग्लेंड (); // ब्लू साइड - टॉप ग्लोबिन (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); ग्लेंड (); // रेड साइड - बॉटम ग्लबीगिन (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); ग्लेंड (); ग्लफ्लश (); ग्लूटस्वैपबफर (); }
हम इस फ़ंक्शन के लिए कोड की दो अंतिम पंक्तियों में भी जोड़ना चाहते हैं। य़े हैं ग्लफ्लश ();
तथा ग्लूटस्वैपबफर ();
जो हमें डबल-बफरिंग प्रभाव देता है जिसके बारे में आपने पहले सीखा था।
भाग ३ का ३: उपयोगकर्ता अन्तरक्रियाशीलता
चरण 1. विशेष कुंजी () जोड़ें।
आपका काम लगभग पूरा हो चुका है, लेकिन इस समय आप एक घन बना सकते हैं, लेकिन उसे घुमाने का कोई तरीका नहीं है। ऐसा करने के लिए, आप करेंगे एक विशेष कुंजी बनाएं () हमें तीर कुंजियों को दबाने और क्यूब को घुमाने की अनुमति देने के लिए कार्य करता है!
- यही कारण है कि आपने वैश्विक चर रोटेट_एक्स और रोटेट_य घोषित किया है। जब आप दाएँ और बाएँ तीर कुंजियाँ दबाते हैं, तो रोटेट_y 5 डिग्री से बढ़ा या घटाया जाएगा। इसी तरह, जब आप ऊपर और नीचे तीर कुंजियों को दबाते हैं, तो उसी के अनुसार रोटेट_एक्स बदल जाएगा।
शून्य विशेष कुंजी (इंट कुंजी, इंट एक्स, इंट वाई) {// दायां तीर - 5 डिग्री से रोटेशन बढ़ाएं अगर (कुंजी == GLUT_KEY_RIGHT) रोटेट_y + = 5; // बायां तीर - रोटेशन को 5 डिग्री कम करें यदि (कुंजी == GLUT_KEY_LEFT) रोटेट_य - = 5; और अगर (कुंजी == GLUT_KEY_UP) रोटेट_x + = 5; और अगर (कुंजी == GLUT_KEY_DOWN) रोटेट_एक्स - = 5; // अनुरोध प्रदर्शन अद्यतन glutPostRedisplay (); }
चरण 2. GlRotate () जोड़ें।
आपका अंतिम कथन उस कथन को जोड़ना है जो आपकी वस्तु को घुमाएगा। डिस्प्ले () फ़ंक्शन पर वापस जाएं और सामने की तरफ, इन पंक्तियों को जोड़ें:
// परिवर्तनों को रीसेट करें glLoadIdentity (); // घुमाएँ जब उपयोगकर्ता रोटेट_एक्स और रोटेट_य ग्लोटेटेफ़ (रोटेट_एक्स, 1.0, 0.0, 0.0) बदलता है; glRotatef (रोटेट_वाई, 0.0, 1.0, 0.0); // बहुरंगी पक्ष - सामने…।
चरण 3. क्यूब को x-अक्ष के साथ 2, y-अक्ष के साथ 2 से स्केल करने के लिए निम्नलिखित कमांड जोड़ें, क्यूब को y-अक्ष के बारे में 180 डिग्री घुमाएँ, और क्यूब को x-अक्ष के साथ 0.1 से अनुवाद करें।
सुनिश्चित करें कि इन और साथ ही पिछले glRotate() कमांड को ऊपर बताए अनुसार सही क्रम में व्यवस्थित करें। (यदि आप अनिश्चित हैं, तो यह ट्यूटोरियल के अंत में अंतिम कोड में किया जाता है।)
// अन्य परिवर्तन glTranslatef (०.१, ०.०, ०.०); glRotatef (१८०, ०.०, १.०, ०.०); ग्लस्केलेफ (2.0, 2.0, 0.0);
चरण 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. अपना पूरा कोड जांचें।
यह इस तरह होना चाहिए:
// // फ़ाइल: mycube.c // लेखक: मैट डेज़ली // बनाया गया: 4/25/2012 // प्रोजेक्ट: ओपनजीएल में एक क्यूब बनाने के लिए स्रोत कोड // विवरण: एक ओपनजीएल विंडो बनाता है और एक 3 डी क्यूब बनाता है / / कि उपयोगकर्ता तीर कुंजियों का उपयोग करके घुमा सकता है // // नियंत्रण: बायाँ तीर - बाएँ घुमाएँ // दायाँ तीर - दाएँ घुमाएँ // ऊपर तीर - ऊपर घुमाएँ // नीचे तीर - नीचे घुमाएँ // ------ -------------------------------------------------- --//शामिल है//------------------------------------------- --------------- #शामिल करें #शामिल करें #शामिल करें # परिभाषित करें GL_GLEXT_PROTOTYPES #ifdef _APPLE_ #include #else #include #endif // ------------- ------------------------------------------- // फंक्शन प्रोटोटाइप / / ------------------------------------------------- --------- शून्य प्रदर्शन (); शून्य विशेष कुंजी (); //----------------------------------------------------- ---------- // सार्वत्रिक चर // ---------------------------------- ------------------------ डबल रोटेट_वाई = 0; डबल रोटेट_एक्स = 0; //----------------------------------------------------- ---------- // डिस्प्ले () कॉलबैक फ़ंक्शन // ----------------------------- --------------------------- शून्य प्रदर्शन () {// स्पष्ट स्क्रीन और जेड-बफर glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // परिवर्तनों को रीसेट करें glLoadIdentity (); // अन्य परिवर्तन // glTranslatef (०.१, ०.०, ०.०); // शामिल नहीं है // glRotatef (180, 0.0, 1.0, 0.0); // शामिल नहीं है // जब उपयोगकर्ता रोटेट_एक्स और रोटेट_य ग्लोटेटेफ (रोटेट_एक्स, 1.0, 0.0, 0.0) बदलता है तो घुमाएं; glRotatef (रोटेट_वाई, 0.0, 1.0, 0.0); // अन्य परिवर्तन // glScalef (२.०, २.०, ०.०); // शामिल नहीं है // बहु-रंगीन पक्ष - 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 () है; // सफेद पक्ष - बैक ग्लोबिन (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); ग्लेंड (); // पर्पल साइड - राइट ग्लोबिन (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); ग्लेंड (); // ग्रीन साइड - लेफ्ट ग्लबीगिन (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); ग्लेंड (); // ब्लू साइड - टॉप ग्लोबिन (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); ग्लेंड (); // रेड साइड - बॉटम ग्लबीगिन (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); ग्लेंड (); ग्लफ्लश (); ग्लूटस्वैपबफर (); } // ------------------------------------------- ----------- // विशेष कुंजी () कॉलबैक फ़ंक्शन // ----------------------------- ----------------------------- शून्य विशेष कुंजी (इंट कुंजी, इंट एक्स, इंट वाई) {// दायां तीर - 5 से रोटेशन बढ़ाएं डिग्री अगर (कुंजी == GLUT_KEY_RIGHT) Rotate_y += 5; // बायां तीर - रोटेशन को 5 डिग्री कम करें यदि (कुंजी == GLUT_KEY_LEFT) रोटेट_य - = 5; और अगर (कुंजी == GLUT_KEY_UP) रोटेट_x += 5; और अगर (कुंजी == GLUT_KEY_DOWN) रोटेट_एक्स - = 5; // अनुरोध प्रदर्शन अद्यतन glutPostRedisplay (); } // ------------------------------------------- ----------- // मुख्य कार्य // ------------------------------- ---------------------------- int main(int argc, char* argv){ // GLUT को इनिशियलाइज़ करें और यूजर पैरामीटर्स को प्रोसेस करें glutInit (और argc, argv); // Z-बफर glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH) के साथ डबल बफर्ड ट्रू कलर विंडो का अनुरोध करें; // विंडो बनाएं glutCreateWindow ("बहुत बढ़िया क्यूब"); // Z-बफर गहराई परीक्षण सक्षम करें glEnable(GL_DEPTH_TEST); // कॉलबैक फ़ंक्शन glutDisplayFunc (प्रदर्शन); glutSpecialFunc (विशेष कुंजी); // घटनाओं के लिए GLUT पर नियंत्रण पास करें glutMainLoop (); // ओएस रिटर्न 0 पर लौटें; }
