सामग्री

• पावले
• 3 पैकी 1 भाग: प्रारंभिक स्थापना
• 3 पैकी 2 भाग: प्रदर्शन () कार्य
• 3 पैकी 3 भाग: प्रोग्राम इंटरएक्टिव्हिटी

ओपनजीएल हे एक 3 डी प्रोग्रामिंग साधन आहे जे आपल्याला साध्या आकारांपासून जटिल 3 डी प्रतिमा तयार करण्यास अनुमती देते. या लेखात, आपण त्याच्या मदतीने एक साधा क्यूब कसा काढायचा ते शिकाल जे तीन आयामांमध्ये फिरवता येते!

पावले

3 पैकी 1 भाग: प्रारंभिक स्थापना

1. 1 ओपनजीएल स्थापित करा. आपल्या संगणकावर ओपनजीएल कसे प्रतिष्ठापीत करायचे याच्या ट्यूटोरियलसह प्रारंभ करा. आपल्याकडे आधीपासूनच ओपनजीएल आणि सी कंपाईलर असल्यास, आपण ही पायरी वगळू शकता आणि पुढीलकडे जाऊ शकता.
2. 2 एक दस्तऐवज तयार करा. तुमच्या आवडत्या कोड एडिटरमध्ये नवीन फाइल तयार करा आणि mycube.c म्हणून सेव्ह करा
3. 3 #समाविष्ट करा. आपल्याला आवश्यक असलेले मूलभूत #समाविष्ट निर्देश येथे आहेत. हे लक्षात ठेवणे महत्वाचे आहे की विविध ऑपरेटिंग सिस्टमचे निर्देश भिन्न आहेत, आणि म्हणून आपल्याला सर्वकाही निवडण्याची आवश्यकता आहे जेणेकरून कार्यक्रम सार्वत्रिक असेल आणि कोणत्याही प्रणालीवर चालवता येईल.

   // समाविष्ट #include stdio.h> #includ stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else #include GL / glut.h> #endif

4. 4 फंक्शनल प्रोटोटाइप आणि ग्लोबल्स जोडा. पुढील पायरी म्हणजे कार्यात्मक प्रोटोटाइप घोषित करणे.

   // कार्यात्मक प्रोटोटाइप शून्य प्रदर्शन (); शून्य स्पेशल कीज (); // ग्लोबल व्हेरिएबल्स डबल rotate_y = 0; डबल rotate_x = 0;

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

   int main (int argc, char * argv []) // GLUT सुरू करा आणि glutInit (& argc, argv) कस्टम पॅरामीटर्सवर प्रक्रिया करा; // डबल बफरिंग, झेड-बफरिंग आणि ट्रू कलर glutInitDisplayMode (GLUT_DOUBLE

3 पैकी 2 भाग: प्रदर्शन () कार्य

1. 1 प्रदर्शन () कार्याचा हेतू समजून घ्या. क्यूब प्रस्तुत करण्याचे सर्व काम या फंक्शनच्या नाजूक रेषांवर येईल. सामान्य कल्पना अशी आहे: आपण क्यूबचे सहा स्वतंत्र चेहरे काढाल आणि त्यांना त्यांच्या संबंधित स्थितीत ठेवाल.
   • प्रत्येक चेहऱ्यासाठी, आपण चार कोपरे परिभाषित कराल आणि ओपनजीएल त्यांना रेषांसह जोडेल आणि त्यांना तुमच्या निवडलेल्या रंगाने भरेल. हे कसे करावे ते खाली स्पष्ट केले जाईल.
2. 2 GlClear () फंक्शन जोडा. सर्वप्रथम, या फंक्शनसह काम करताना, आपल्याला आवश्यक आहे स्पष्ट रंग आणि z- बफर... याशिवाय, जुने चित्र नवीन चित्राखाली दिसेल आणि प्रोग्रामद्वारे काढलेल्या वस्तू चुकीच्या पद्धतीने ठेवल्या जातील.

   शून्य प्रदर्शन () // स्क्रीन साफ ​​करा आणि Z बफर glClear (GL_COLOR_BUFFER_BIT

   • शेवटच्या दोन ओळींकडे लक्ष द्या. ही कार्ये आहेत glFlush (); आणि glutSwapBuffers ();, वर वर्णन केलेल्या डबल बफरिंगचा प्रभाव देत आहे.

3 पैकी 3 भाग: प्रोग्राम इंटरएक्टिव्हिटी

1. 1 SpecialKeys () फंक्शन जोडा. तत्त्वानुसार, सर्वकाही जवळजवळ तयार आहे, परंतु क्यूब फक्त काढला जातो आणि फिरवला जात नाही. हे करण्यासाठी, आपल्याला तयार करणे आवश्यक आहे specialKeys () फंक्शन, जे तुम्हाला बाण की दाबून क्यूब फिरवण्याची परवानगी देईल!
   • या कार्यासाठीच ग्लोबल व्हेरिएबल्स rotate_x आणि rotate_y घोषित करण्यात आले. जेव्हा तुम्ही डावी आणि उजवी बाण की दाबता, तेव्हा rotate_y मूल्य पाच अंशांनी वाढेल किंवा कमी होईल. Rotate_x चे मूल्य त्याच प्रकारे बदलेल, परंतु यावेळी वर आणि खाली बाण की दाबून.

   void specialKeys (int key, int x, int y) {// उजवा बाण - रोटेशन 5 अंशांनी वाढवा जर (key == GLUT_KEY_RIGHT) rotate_y + = 5; // डावा बाण - 5 अंशांनी रोटेशन कमी करा जर (की == GLUT_KEY_LEFT) rotate_y - = 5; अन्यथा जर (की == GLUT_KEY_UP) rotate_x + = 5; अन्यथा जर (की == GLUT_KEY_DOWN) rotate_x - = 5; // विनंती स्क्रीन रिफ्रेश glutPostRedisplay (); }

2. 2 GlRotate () जोडा. शेवटची गोष्ट म्हणजे आपण एक रेषा जोडतो जी आपल्याला ऑब्जेक्ट फिरवू देते. कार्यावर परत या प्रदर्शन () आणि समोरच्या बाजूच्या वर्णनापूर्वी जोडा:

   // रीसेट ट्रान्सफॉर्म glLoadIdentity (); // जेव्हा वापरकर्ता बदलतो तेव्हा फिरवा मूल्य rotate_x आणि rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // बहुरंगी बाजू - समोर ....

   • कृपया लक्षात घ्या की वाक्यरचना glRotatef ()जे glColor3f () आणि glVertex3f () च्या वाक्यरचनासारखे आहे, परंतु नेहमी चार पॅरामीटर्सची आवश्यकता असते. प्रथम अंशांमध्ये रोटेशन कोन आहे. पुढील तीन अक्ष आहेत ज्याच्या बाजूने रोटेशन होते, x, y, z क्रमाने. आत्तासाठी, आपल्याला क्यूब दोन अक्षांसह फिरवणे आवश्यक आहे, x आणि y.
   • आम्ही प्रोग्राममध्ये परिभाषित केलेल्या सर्व परिवर्तनांना समान रेषांची आवश्यकता आहे. मुळात, आम्ही x- अक्षाच्या बाजूने ऑब्जेक्टच्या रोटेशनचे प्रतिनिधित्व करतो rotate_x च्या मूल्यात बदल म्हणून, आणि y-axis सोबत रोटेशन rotat_y च्या मूल्यात बदल म्हणून. तथापि, ओपनजीएल सर्वकाही एका रूपांतरण मॅट्रिक्समध्ये एकत्रित करेल. प्रत्येक वेळी जेव्हा तुम्ही डिस्प्लेला कॉल कराल, तेव्हा तुम्ही ट्रान्सफॉर्मेशन मॅट्रिक्स तयार कराल आणि glLoadIdentity () आपल्याला प्रत्येक वेळी नवीन मॅट्रिक्ससह प्रारंभ करण्यास अनुमती देईल.
   • इतर ट्रान्सफॉर्मेशन फंक्शन्स तुम्ही वापरू शकता glTranslatef () आणि glScalef (). ते glRotatef () सारखे आहेत, त्याशिवाय त्यांना फक्त तीन पॅरामीटर्सची आवश्यकता आहे: ऑब्जेक्टचा आकार बदलण्यासाठी आणि स्केल करण्यासाठी x, y आणि z व्हॅल्यू.
   • जेव्हा एका ऑब्जेक्टवर तीनही परिवर्तन लागू केले जातात तेव्हा सर्वकाही योग्यरित्या प्रदर्शित होण्यासाठी, आपल्याला योग्य क्रमाने परिवर्तन सेट करणे आवश्यक आहे, म्हणजे glTranslate, glRotate, glScale - आणि अन्यथा नाही. ओपनजीएल प्रोग्राम तळापासून वरपर्यंत वाचून ऑब्जेक्टचे रूपांतर करते. हे अधिक चांगल्या प्रकारे समजून घेण्यासाठी, कल्पना करा की 1x1x1 क्यूब सर्व बदलांची कशी काळजी घेईल जर ओपनजीएलने त्यांना दाखवलेल्या क्रमाने (वरून खालपर्यंत) लागू केले आणि मग तळापासून वरच्या सूचना वाचून ओपनजीएल क्यूबवर कशी प्रक्रिया करेल याचा विचार करा.
3. 3 क्यूबला x आणि y दिशानिर्देशांमध्ये दोनदा मोजण्यासाठी, क्यूबला y अक्षात 180 अंश फिरवण्यासाठी आणि x अक्षात क्यूब 0.1 हलवण्यासाठी खालील आदेश जोडा. पूर्वी दिलेल्या glRotate () कमांडसह सर्व संबंधित आदेश योग्य क्रमाने असल्याची खात्री करा. आपण चूक करण्यास घाबरत असल्यास, लेखाच्या शेवटी प्रोग्रामची अंतिम आवृत्ती पहा.

   // अधिक परिवर्तन glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 कोड संकलित करा आणि चालवा. समजा आपण gcc आपला कंपाइलर म्हणून वापरत आहात, म्हणून आपल्या टर्मिनलमध्ये खालील आदेश प्रविष्ट करा:

   लिनक्सवर: 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 ./ मायक्यूब

5. 5 अंतिम कोड तपासा. लेखाच्या लेखकाने तयार केलेला अंतिम कोड येथे आहे, जो टिप्पण्यांचे भाषांतर करत नाही.

   // // फाइल: mycube.c // लेखक: मॅट डेसली // निर्मित: 4/25/2012 // प्रकल्प: ओपनजीएलमध्ये मेक क्यूबसाठी स्रोत कोड // वर्णन: ओपनजीएल विंडो तयार करते आणि 3 डी क्यूब काढते/ / वापरकर्ता बाण कळा वापरून फिरवू शकतो // // नियंत्रणे: डावा बाण -डावीकडे फिरवा // उजवा बाण -उजवीकडे फिरवा // वर बाण -वर फिरवा // खाली बाण -खाली फिरवा // ------ -------------------------------------------------- -// समाविष्ट आहे // --------------------------------------------------- -------- GL / glut.h> #endif // ---------------------------------------- ------------------ // फंक्शन प्रोटोटाइप // -------------------------- -------------------------------- शून्य प्रदर्शन (); शून्य स्पेशल कीज (); // ------------------------------------------------ ---------- // ग्लोबल व्हेरिएबल्स // ---------------------------------- ------------------------ दुहेरी फिरवा_ y = 0; डबल rotate_x = 0; // ------------------------------------------------ ---------- // प्रदर्शन () कॉलबॅक फंक्शन // ------------------------------- --------------------------- शून्य प्रदर्शन () // स्पष्ट स्क्रीन आणि Z- बफर glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- -// specialKeys () कॉलबॅक फंक्शन // ---------------------------------------- ------ = 5; // डावा बाण - रोटेशन 5 अंशाने कमी करा अन्यथा (की == GLUT_KEY_LEFT) rotate_y - = 5; अन्यथा जर (key == GLUT_KEY_UP) rotate_x + = 5; अन्यथा जर (key == GLUT_KEY_DOWN) rotate_x - = 5; // विनंती प्रदर्शन अद्यतन glutPostRedisplay ();} // ------------------------------------ ---------------------- // मुख्य () फंक्शन // -------------------- -------------------------------------- int मुख्य (int argc, char * argv [] ) GLUT_RGB