OpenGL को जानें

ओपन

ओपनजीएल के साथ आरंभ करने के लिए, आपको यह कहकर शुरू करने की आवश्यकता है कि ओपनजीएल एक विनिर्देश है । यानी ओपनजीएल केवल आवश्यक सुविधाओं के एक सेट को परिभाषित करता है। कार्यान्वयन विशिष्ट प्लेटफ़ॉर्म पर निर्भर करता है।

OpenGL क्रॉस-प्लेटफ़ॉर्म है, ग्राफिक्स के साथ काम करने के लिए प्रोग्रामिंग भाषा एपीआई से स्वतंत्र है। OpenGL एक निम्न-स्तरीय API है, इसलिए इसके साथ काम करने में अच्छा है कि ग्राफ के बारे में पूरी तरह से विचार करें और रैखिक बीजगणित की मूल बातें जानें।

नामकरण

आइए OpenGL में फ़ंक्शन नामकरण के बारे में कुछ शब्द कहते हैं। सबसे पहले, OpenGL द्वारा सीधे प्रदान किए गए सभी कार्यों के नाम उपसर्ग gl के साथ शुरू होते हैं। दूसरे, संख्याओं के एक समूह (उदाहरण के लिए, समन्वय या रंग) की विशेषता वाले एक निश्चित पैरामीटर को निर्दिष्ट करने वाले फ़ंक्शंस में फॉर्म का एक प्रत्यय होता है [मापदंडों की संख्या + मापदंडों के प्रकार + मापदंडों का प्रतिनिधित्व]।

• मापदंडों की संख्या - प्राप्त मापदंडों की संख्या को इंगित करता है। यह निम्न मान लेता है: 1 , 2 , 3 , 4
• मापदंडों का प्रकार - प्राप्त मापदंडों के प्रकार को इंगित करता है। निम्नलिखित मान संभव हैं: b , s , i , f , d , ub , us , ui । यानी बाइट (चार सी में पूर्णांक, 8-बिट पूर्णांक), लघु (16-बिट पूर्णांक), इंट (32-बिट पूर्णांक), फ्लोट (फ्लोटिंग-पॉइंट), डबल (डबल-सटीक फ़्लोटिंग-पॉइंट), अहस्ताक्षरित बाइट, अहस्ताक्षरित लघु, अहस्ताक्षरित int (अंतिम तीन अहस्ताक्षरित पूर्णांक हैं)
• मापदंडों की प्रस्तुति - यह दर्शाता है कि पैरामीटर किस रूप में प्रेषित होते हैं, यदि प्रत्येक संख्या अलग है, तो कुछ भी नहीं लिखा जाता है, यदि मापदंडों को एक सरणी के रूप में स्थानांतरित किया जाता है, तो फ़ंक्शन के नाम में अक्षर v जोड़ा जाता है

उदाहरण: glVertex3iv एक सरणी के लिए एक सूचक के रूप में पारित किए गए तीन पूर्णांकों से मिलकर, शीर्ष समन्वय स्थापित करता है।

ग्राफिक्स

ओपनजीएल में सभी चित्रमय वस्तुएँ बिंदुओं, रेखाओं और बहुभुजों का एक संग्रह हैं। 10 अलग-अलग आदिम हैं जिनके साथ सभी ऑब्जेक्ट बनाए जाते हैं। दो आयामी और तीन आयामी। सभी आदिम, बदले में, बिंदुओं द्वारा परिभाषित होते हैं - कोने।

• GL_POINTS - प्रत्येक शीर्ष एक बिंदु को परिभाषित करता है
• GL_LINES - प्रत्येक व्यक्ति की जोड़ी एक पंक्ति को परिभाषित करती है
• GL_LINE_STRIP - वर्टिकल की प्रत्येक जोड़ी एक रेखा को परिभाषित करती है (यानी पिछली पंक्ति का अंत अगली शुरुआत है)
• GL_LINE_LOOP - पिछले एक के समान, सिवाय इसके कि अंतिम शीर्ष पहले से जुड़ता है और एक बंद आंकड़ा प्राप्त होता है
• GL_TRIANGLES - प्रत्येक व्यक्तिगत त्रिभुज त्रिभुज को परिभाषित करता है
• GL_TRIANGLE_STRIP - प्रत्येक अगला शीर्ष दो पिछले वाले (त्रिकोण का एक रिबन प्राप्त होता है) के साथ एक त्रिकोण को परिभाषित करता है
• GL_TRIANGLE_FAN - प्रत्येक त्रिकोण को पहले शीर्ष और बाद के युग्मों द्वारा परिभाषित किया जाता है (यानी त्रिकोण पहले शीर्ष के चारों ओर निर्मित होते हैं, जो एक डायाफ्राम जैसा कुछ बनाते हैं)
• GL_QUADS - प्रत्येक चार कोने एक चतुर्भुज बनाते हैं
• GL_QUAD_STRIP - प्रत्येक अगली जोड़ी का जोड़ पूर्व की एक जोड़ी के साथ एक चतुर्भुज बनाता है
• GL_POLYGON - निर्दिष्ट बहुभुजों की संख्या के बराबर कोणों की संख्या के साथ एक बहुभुज सेट करता है

GlBegin (primitive_type) ... glEnd () निर्माण का उपयोग आदिम सेट करने के लिए किया जाता है। कार्य glVertex * द्वारा निर्दिष्ट किए जाते हैं । कार्यक्षेत्र वामावर्त सेट हैं। निर्देशांक खिड़की के ऊपरी बाएं कोने से निर्धारित किए जाते हैं। शीर्ष का रंग glColor * द्वारा निर्धारित किया गया है। रंग को RGB या RGBA के रूप में निर्दिष्ट किया गया है। GlColor * कमांड सभी कार्यक्षेत्रों पर कार्य करता है जो किसी अन्य glColor * कमांड के पूरा होने के बाद तक आते हैं, या यदि कोई अन्य GlColor * कमांड नहीं हैं।

यहाँ बहु-रंग वाले कोने के साथ एक वर्ग बनाने का कोड है:

1. glBegin ( GL_QUADS ) ;
2. glColor3f ( 1.0 , 1.0 , 1.0 ) ;
3. glVertex2i ( 250 , 450 ) ;
4. glColor3f ( 0.0 , 0.0 , 1.0 ) ;
5. glVertex2i ( 250 , 150 ) ;
6. glColor3f ( 0.0 , 1.0 , 0.0 ) ;
7. glVertex2i ( 550 , 150 ) ;
8. glColor3f ( 1.0 , 0.0 , 0.0 ) ;
9. glVertex2i ( 550 , 450 ) ;
10. glEnd ( ) ;

ओपनजीएल कार्यक्रम मूल बातें

खिड़कियों के साथ प्लेटफ़ॉर्म-स्वतंत्र संचालन के लिए, आप GLUT लाइब्रेरी का उपयोग कर सकते हैं। GLUT, OpenGL के साथ काम करना आसान बनाता है।

कार्यक्रम की शुरुआत में GLUT को इनिशियलाइज़ करने के लिए glutInit (& argc, argv) पर कॉल करें। प्रदर्शन मोड सेट करने के लिए, glutInitDisplayMode (मोड) कहा जाता है, जहां मोड निम्नलिखित मान ले सकता है:

• GLUT_RGBA - एक चार-घटक रंग शामिल है (डिफ़ॉल्ट रूप से उपयोग किया जाता है)
• GLUT_RGB - GLUT_RGBA के समान
• GLUT_INDEX - अनुक्रमित रंग को सक्षम करता है
• GLUT_DOUBLE - एक डबल स्क्रीन बफर सक्षम करता है
• GLUT_SINGLE - एकल स्क्रीन बफ़र (डिफ़ॉल्ट) सक्षम करता है
• GLUT_DEPTH - Z- बफर (गहराई बफर) सक्षम करें
• GLUT_STENCIL - स्क्रीन बफर सक्षम करता है
• GLUT_ACCUM - संचय बफर सक्षम करें
• GLUT_ALPHA - अल्फा सम्मिश्रण (पारदर्शिता) को सक्षम करता है
• GLUT_MULTISAMPLE - मल्टीस्मैपलिंग ( स्मूथिंग ) सक्षम करता है
• GLUT_STEREO - स्टीरियो छवि सक्षम करता है

एक ही समय में कई मोड का चयन करने के लिए, बिटवाइस या '|' का उपयोग करें। उदाहरण के लिए: glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH) में डबल बफरिंग, Z बफर और चार-घटक रंग शामिल हैं। खिड़की के आकार glutInitWindowSize (चौड़ाई, ऊंचाई) द्वारा निर्धारित किए जाते हैं । इसकी स्थिति glutInitWindowPosition (x, y) है । एक विंडो glutCreateWindow फ़ंक्शन (window_head) के साथ बनाई गई है।

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

• void glutDisplayFunc (void (* func) (void)) - इमेज ड्रॉइंग फंक्शन सेट करता है
• void glutReshapeFunc (void (* func) (int चौड़ाई, int ऊँचाई)) - प्रसंस्करण प्रक्रिया के रूप में विंडो को सेट करता है
• शून्य glutVisibilityFunc (void (* func) (int स्थिति)) - एक विंडो की दृश्यता स्थिति को बदलने के प्रसंस्करण कार्य को सेट करता है
• void glutKeyboardFunc (void (* func) (अहस्ताक्षरित चार कुंजी, int x, int y)) - प्रसंस्करण कीबोर्ड कीस्ट्रोक्स के कार्य को परिभाषित करता है (केवल जो कि इस्की अक्षर उत्पन्न करते हैं)
• void glutSpecialFunc (void (* func) (int key, int x, int y)) - प्रसंस्करण कीबोर्ड कीस्ट्रोक्स के फ़ंक्शन को परिभाषित करता है (जो कि एससीआई वर्ण उत्पन्न नहीं करते हैं)
• void glutIdleFunc (void (* func) (शून्य)) - फ़ंक्शन को अन्य घटनाओं की अनुपस्थिति में बुलाया जाना
• void glutMouseFunc (void (* func) (int बटन, int state, int x, int y)) - माउस कमांड को प्रोसेस करने वाले फ़ंक्शन को परिभाषित करता है
• void glutMotionFunc (void (* func) (int x, int y)) - एक फ़ंक्शन को परिभाषित करता है जो किसी माउस बटन को दबाने पर माउस कर्सर की गति को संसाधित करता है।
• void glutPassiveMotionFunc (void (* func) (int x, int y)) - एक फ़ंक्शन को परिभाषित करता है जो माउस कर्सर की गति को संसाधित करता है जब कोई माउस बटन दबाया नहीं जाता है।
• void glutEntryFunc (void (* func) (int state)) - एक फ़ंक्शन को परिभाषित करता है जो विंडो के बाहर कर्सर की गति और उसकी वापसी की प्रक्रिया करता है
• शून्य glutTimerFunc (अहस्ताक्षरित int msecs, void (* func) (int value), मान) - टाइमर द्वारा कहे जाने वाले फ़ंक्शन को सेट करता है

फिर आप मुख्य ग्लूटामेनलोप () लूप चला सकते हैं।

पहला कार्यक्रम

अब हम ओपनजीएल के साथ काम करने की मूल बातें जानते हैं। आप ज्ञान को मजबूत करने के लिए एक सरल कार्यक्रम लिख सकते हैं।

इसके साथ शुरू करने के लिए, आपको GLUT हैडर फ़ाइल शामिल करने की आवश्यकता है:

1. #if परिभाषित (linux) || परिभाषित (_WIN32)
2. #include <GL / glut.h> / * लिनक्स और विंडोज के लिए * /
3. #else
4. मैक ओएस * के लिए #include <GLUT / GLUT.h> / *
5. #endif

अब हम पहले से ही जानते हैं कि मुख्य में क्या लिखना है। हम दो संचालकों को पंजीकृत करेंगे: विंडो की सामग्री को आरेखण करने और आकार बदलने से निपटने के लिए। ये दो हैंडलर अनिवार्य रूप से किसी भी प्रोग्राम में उपयोग किए जाते हैं जो ओपनजीएल और ग्लूट का उपयोग करता है।

1. int main ( int argc , char * argv [ ] )
2. {
3. glutInit ( & argc , argv ) ;
4. glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGBA ) ; / * डबल बफरिंग और चार-घटक रंग चालू करें * /
6. glutInitWindowSize ( 800 , 600 ) ;
7. glutCreateWindow ( "OpenGL पाठ 1" ) ;
9. glutReshapeFunc ( reshape ) ;
10. glutDisplayFunc ( प्रदर्शन ) ;
12. glutMainLoop ( ) ;
14. वापसी 0 ;
15. }

अब हमें विंडो को आकार देने के लिए एक हैंडलर फ़ंक्शन लिखना होगा। GlViewport कमांड (x, y, चौड़ाई, ऊंचाई) का उपयोग करके छवि के आउटपुट क्षेत्र को पूरी विंडो के आकार में सेट करें। फिर प्रक्षेपण मैट्रिक्स glMatrixMode (GL_PROJECTION) को लोड करें, इसे इकाई glLoadIdentity () के साथ बदलें और ऑर्थोगोनल प्रक्षेपण सेट करें। अंत में, मॉडल को देखें- glamatrixMode मैट्रिक्स (GL_MODELVIEW) देखें और इसे एक एकल के साथ बदलें।

नतीजतन, हम प्राप्त करते हैं:

1. शून्य आकार ( इंट डब्ल्यू , इंट एच )
2. {
3. glViewport ( 0 , 0 , w , h ) ;
5. glMatrixMode ( GL_PROJECTION ) ;
6. glLoadIdentity ( ) ;
7. gluOrtho2D ( 0 , w , 0 , h ) ;
9. glMatrixMode ( GL_MODELVIEW ) ;
10. glLoadIdentity ( ) ;
11. }

यह केवल खिड़की की सामग्री को आकर्षित करने के लिए एक फ़ंक्शन लिखने के लिए रहता है। हम एक उदाहरण के रूप में ऊपर दिए गए वर्ग का उल्लेख करेंगे। आपको काफी कोड जोड़ना होगा। सबसे पहले, ड्राइंग से पहले, आपको glClear (मोड) का उपयोग करके विभिन्न बफ़र्स को साफ़ करना होगा। साथ ही glutInitDisplayMode का उपयोग किया जाता है। संभावित मूल्य:

• GL_COLOR_BUFFER_BIT - रंग बफ़र को साफ़ करने के लिए
• GL_DEPTH_BUFFER_BIT - गहराई बफ़र को साफ़ करने के लिए
• GL_ACCUM_BUFFER_BIT - संचय बफर को साफ़ करने के लिए
• GL_STENCIL_BUFFER_BIT - स्क्रीन बफर को साफ़ करने के लिए

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

हमें मिलता है:

1. शून्य प्रदर्शन ( )
2. {
3. glClear ( GL_COLOR_BUFFER_BIT ) ;
5. glBegin ( GL_QUADS ) ;
6. glColor3f ( 1.0 , 1.0 , 1.0 ) ;
7. glVertex2i ( 250 , 450 ) ;
8. glColor3f ( 0.0 , 0.0 , 1.0 ) ;
9. glVertex2i ( 250 , 150 ) ;
10. glColor3f ( 0.0 , 1.0 , 0.0 ) ;
11. glVertex2i ( 550 , 150 ) ;
12. glColor3f ( 1.0 , 0.0 , 0.0 ) ;
13. glVertex2i ( 550 , 450 ) ;
14. glEnd ( ) ;
16. glutSwapBuffers ( ) ;
17. }

परिणाम

वह सब है! आप संकलन कर सकते हैं। आपको कुछ इस तरह से मिलना चाहिए:



संपूर्ण कोड (उन लोगों के लिए जिन्होंने लेख में महारत हासिल नहीं की है)।

सिद्धांत रूप में, इसमें कुछ भी जटिल नहीं है, कम से कम यदि आप पहले से ही ग्राफिक्स का सामना कर चुके हैं।



OpenGL ग्राफिक्स का उपयोग करके क्रॉस-प्लेटफ़ॉर्म एप्लिकेशन बनाने के लिए एक सुविधाजनक उपकरण है। OpenGL एक प्रोग्रामिंग भाषा के साथ उपयोग करना आसान है जो आपके लिए अधिक सुविधाजनक है। OpenGL के लिए कई लोकप्रिय भाषाओं में बाँध हैं, जैसे C, C ++, C #, Java, पायथन, पर्ल, VB और अन्य। आप उनके बारे में आधिकारिक OpenGL वेबसाइट पर जानकारी देख सकते हैं।