के द्वारा तस्वीर sskennel.
आज का प्रश्न और उत्तर सत्र सुपरयूसर की सौजन्य है - स्टैक एक्सचेंज का एक उपविभाग, क्यू एंड ए वेब साइट्स का एक समुदाय-ड्राइव समूह।
प्रश्न
सुपर यूज़र रीडर सत्य ने सवाल उठाया:
यहां आप ओपनजीएल एपीआई के आधार पर घूर्णन त्रिकोण के साथ Triangle.exe नामक एक छोटे सी ++ प्रोग्राम का एक स्क्रीनशॉट देख सकते हैं।
मैं सिर्फ उत्सुक था और विंडोज़ XP के तहत Triangle.exe पर डबल क्लिक से पूरी प्रक्रिया जानना चाहता था जब तक कि मैं मॉनिटर पर घूर्णन त्रिकोण को देख सकूं। क्या होता है, सीपीयू (जो पहले.exe को संभालता है) और जीपीयू (जो आखिरकार स्क्रीन पर त्रिकोण को आउटपुट करता है) कैसे इंटरैक्ट करते हैं?
मुझे लगता है कि इस घूर्णन त्रिकोण को प्रदर्शित करने में शामिल मुख्य रूप से निम्नलिखित हार्डवेयर / सॉफ्टवेयर है:
हार्डवेयर
- HDD
- सिस्टम मेमोरी (रैम)
- सी पी यू
- वीडियो स्मृति
- GPU
- आयसीडी प्रदर्शन
सॉफ्टवेयर
- ऑपरेटिंग सिस्टम
- डायरेक्टएक्स / ओपनजीएल एपीआई
- Nvidia चालक
क्या कोई इस प्रक्रिया को समझा सकता है, शायद चित्रण के लिए किसी प्रकार के प्रवाह चार्ट के साथ?
यह एक जटिल स्पष्टीकरण नहीं होना चाहिए जो प्रत्येक चरण को शामिल करता है (अनुमान है कि दायरे से बाहर जाएगा), लेकिन एक मध्यवर्ती आईटी लड़का एक स्पष्टीकरण का पालन कर सकता है।
मुझे पूरा यकीन है कि बहुत से लोग जो खुद को कॉल करेंगे आईटी प्रोफेशनल इस प्रक्रिया का सही ढंग से वर्णन नहीं कर सके।
उत्तर
जेसनसी द्वारा छवि, यहां वॉलपेपर के रूप में उपलब्ध है।
वह लिखता है:
मैंने प्रोग्रामिंग पहलू के बारे में कुछ लिखने का फैसला किया और कैसे घटक एक-दूसरे से बात करते हैं। शायद यह कुछ क्षेत्रों पर कुछ प्रकाश डालेगा।
प्रदर्शन
स्क्रीन पर खींचे गए आपके प्रश्न में पोस्ट की गई एक ही छवि को भी लेने में क्या लगता है?
स्क्रीन पर एक त्रिकोण खींचने के कई तरीके हैं। सादगी के लिए, मान लें कि कोई वर्टेक्स बफर का उपयोग नहीं किया गया था। (ए वर्टेक्स बफरस्मृति का एक क्षेत्र है जहां आप निर्देशांक संग्रहीत करते हैं।) आइए मान लें कि कार्यक्रम ने केवल एक ही चरम पर एक ग्राफिक्स प्रसंस्करण पाइपलाइन को बताया है (एक चरम सीमा में केवल एक समन्वय है)।
परंतु, इससे पहले कि हम कुछ भी आकर्षित कर सकें, हमें पहले कुछ मचान चलाना होगा। हम देखेंगे क्यूं कर बाद में:
// Clear The Screen And The Depth Buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Reset The Current Modelview Matrix glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Drawing Using Triangles glBegin(GL_TRIANGLES); // Red glColor3f(1.0f,0.0f,0.0f); // Top Of Triangle (Front) glVertex3f( 0.0f, 1.0f, 0.0f); // Green glColor3f(0.0f,1.0f,0.0f); // Left Of Triangle (Front) glVertex3f(-1.0f,-1.0f, 1.0f); // Blue glColor3f(0.0f,0.0f,1.0f); // Right Of Triangle (Front) glVertex3f( 1.0f,-1.0f, 1.0f); // Done Drawing glEnd();
तो उसने क्या किया?
जब आप एक प्रोग्राम लिखते हैं जो ग्राफिक्स कार्ड का उपयोग करना चाहता है, तो आप आमतौर पर ड्राइवर को किसी प्रकार का इंटरफ़ेस चुनेंगे। ड्राइवर के लिए कुछ प्रसिद्ध इंटरफेस हैं:
- ओपन
- Direct3D
- CUDA
इस उदाहरण के लिए हम ओपनजीएल के साथ रहेंगे। अब आपका ड्राइवर के लिए इंटरफ़ेस यह आपको अपने कार्यक्रम को बनाने के लिए आवश्यक सभी टूल्स देता है बातचीत ग्राफिक्स कार्ड (या ड्राइवर, जो तब तक बाते कार्ड के लिए)।
यह इंटरफ़ेस आपको निश्चित करने के लिए बाध्य है उपकरण। ये टूल एक एपीआई का आकार लेते हैं जिसे आप अपने प्रोग्राम से कॉल कर सकते हैं।
वह एपीआई हम उपरोक्त उदाहरण में उपयोग किए जाने वाले देखते हैं। आओ हम इसे नज़दीक से देखें।
मचान
इससे पहले कि आप वास्तव में कोई वास्तविक ड्राइंग कर सकें, आपको एक प्रदर्शन करना होगा सेट अप। आपको अपना व्यूपोर्ट (वह क्षेत्र जो वास्तव में प्रस्तुत किया जाएगा) को परिभाषित करना होगा, आपका परिप्रेक्ष्य (द कैमरा अपनी दुनिया में), आप एंटी-एलाइजिंग का उपयोग करेंगे (आपके त्रिकोण के किनारे को सुगम बनाने के लिए) …
लेकिन हम उसमें से किसी को भी नहीं देख पाएंगे। हम आपको जो सामान करना होगा उस पर हम केवल एक झलक लेंगे हर फ्रेम । पसंद:
स्क्रीन साफ़ करना
ग्राफिक्स पाइपलाइन आपके लिए प्रत्येक फ्रेम के लिए स्क्रीन साफ़ नहीं कर रही है। आपको इसे बताना होगा। क्यूं कर? इसलिए:
यदि आप स्क्रीन को साफ़ नहीं करते हैं, तो आप बस करेंगे खींचो यह हर फ्रेम। यही कारण है कि हम कॉल करते हैं
glClear
उसके साथ
GL_COLOR_BUFFER_BIT
सेट। दूसरा बिट (
GL_DEPTH_BUFFER_BIT
) ओपनजीएल को साफ़ करने के लिए बताता है गहराईबफर। यह बफर यह निर्धारित करने के लिए प्रयोग किया जाता है कि कौन से पिक्सल अन्य पिक्सल के सामने (या पीछे) हैं।
परिवर्तन
परिवर्तन वह हिस्सा है जहां हम सभी इनपुट निर्देशांक (हमारे त्रिकोण के शिखर) लेते हैं और हमारे मॉडल व्यू मैट्रिक्स को लागू करते हैं। यह मैट्रिक्स है कि बताते हैं कैसे हमारे आदर्श (शिखर) घूर्णन, स्केल, और अनुवादित (स्थानांतरित) हैं।
इसके बाद, हम अपने प्रोजेक्शन मैट्रिक्स को लागू करते हैं। यह सभी निर्देशांक चलाता है ताकि वे हमारे कैमरे का सही ढंग से सामना कर सकें।
अब हम अपने व्यूपोर्ट मैट्रिक्स के साथ एक बार फिर बदल जाते हैं। हम इसे स्केल करने के लिए करते हैं आदर्श हमारे मॉनिटर के आकार के लिए। अब हमारे पास शिखर का एक सेट है जो प्रस्तुत करने के लिए तैयार हैं!
हम थोड़ी देर बाद परिवर्तन में वापस आ जाएंगे।
चि त्र का री
एक त्रिकोण खींचने के लिए, हम केवल एक नया शुरू करने के लिए ओपनजीएल को बता सकते हैं त्रिकोण की सूची फोन करके
glBegin
उसके साथ
GL_TRIANGLES
स्थिर। ऐसे अन्य रूप भी हैं जिन्हें आप आकर्षित कर सकते हैं। एक त्रिकोण पट्टी या एक त्रिकोण प्रशंसक की तरह।ये मुख्य रूप से ऑप्टिमाइज़ेशन हैं, क्योंकि उन्हें सीपीयू और जीपीयू के बीच समान संचार की आवश्यकता होती है ताकि समान त्रिकोणों को आकर्षित किया जा सके।
उसके बाद, हम 3 कोष्ठकों के सेट की एक सूची प्रदान कर सकते हैं जो प्रत्येक त्रिकोण को बनाना चाहिए। प्रत्येक त्रिभुज 3 निर्देशांक का उपयोग करता है (जैसा कि हम 3 डी-स्पेस में हैं)। इसके अतिरिक्त, मैं भी एक प्रदान करता हूं रंग कॉल करके, प्रत्येक चरम के लिए
glColor3f
से पहले बुला
glVertex3f
3 कोष्ठक (त्रिभुज के 3 कोनों) के बीच छाया ओपनजीएल द्वारा गणना की जाती है खुद ब खुद । यह बहुभुज के पूरे चेहरे पर रंग को अलग करेगा।
इंटरेक्शन
अब, जब आप विंडो पर क्लिक करते हैं। एप्लिकेशन को केवल उस विंडो संदेश को कैप्चर करना होगा जो क्लिक को सिग्नल करता है। फिर आप अपने इच्छित प्रोग्राम में कोई भी कार्रवाई चला सकते हैं।
यह एक हो जाता है बहुत एक बार जब आप अपने 3 डी दृश्य से बातचीत करना शुरू करना चाहते हैं तो अधिक कठिन होता है।
आपको सबसे पहले स्पष्ट रूप से पता होना चाहिए कि उपयोगकर्ता ने किस पिक्सेल को विंडो पर क्लिक किया था। फिर, अपना ले लो परिप्रेक्ष्यखाते में, आप माउस के बिंदु से अपने दृश्य में क्लिक करके, किरण की दिशा की गणना कर सकते हैं। फिर आप अपने दृश्य में किसी ऑब्जेक्ट की गणना कर सकते हैं intersects उस किरण के साथ। अब आप जानते हैं कि उपयोगकर्ता ने किसी ऑब्जेक्ट पर क्लिक किया है या नहीं।
तो, आप इसे कैसे घुमाते हैं?
परिवर्तन
मुझे दो प्रकार के परिवर्तनों के बारे में पता है जो आम तौर पर लागू होते हैं:
- मैट्रिक्स आधारित परिवर्तन
- हड्डी आधारित परिवर्तन
अंतर यह है कि हड्डियों सिंगल को प्रभावित करें कोने। Matrices हमेशा एक ही तरह से सभी खींचे गए कोने को प्रभावित करते हैं। आइए एक उदाहरण देखें।
उदाहरण
इससे पहले, हमने अपना भार उठाया पहचान मैट्रिक्स हमारे त्रिकोण ड्राइंग से पहले। पहचान मैट्रिक्स वह है जो बस प्रदान करता है कोई परिवर्तन नहीं बिल्कुल भी। तो, जो भी मैं आकर्षित करता हूं, केवल मेरे परिप्रेक्ष्य से प्रभावित होता है। तो, त्रिभुज बिल्कुल घुमाया नहीं जाएगा।
अगर मैं इसे अभी घुमाने के लिए चाहता हूं, तो मैं या तो गणित स्वयं (सीपीयू पर) कर सकता हूं और बस कॉल कर सकता हूं
glVertex3f
साथ मेंअन्य निर्देशांक (जो घुमाए गए हैं)। या मैं जीपीयू को कॉल करके सभी काम कर सकता हूं
glRotatef
ड्राइंग से पहले:
// Rotate The Triangle On The Y axis glRotatef(amount,0.0f,1.0f,0.0f);
amount
बेशक, बस एक निश्चित मूल्य है। यदि आप चाहते हैं चेतन, आपको ट्रैक रखना होगा
amount
और इसे हर फ्रेम में वृद्धि।
तो, प्रतीक्षा करें, पहले सभी मैट्रिक्स बातों के साथ क्या हुआ?
इस सरल उदाहरण में, हमें matrices के बारे में परवाह नहीं है। हम बस कॉल करते हैं
glRotatef
और यह हमारे लिए यह सब कुछ ख्याल रखता है।
glRotate
एक घूर्णन पैदा करता है
angle
वेक्टर एक्स वाई जेड के आसपास डिग्री। मौजूदा मैट्रिक्स (seeglMatrixMode) को वर्तमान मैट्रिक्स को प्रतिस्थापित करने वाले उत्पाद के साथ रोटेशन मैट्रिक्स द्वारा गुणा किया जाता है, जैसे ifglMultMatrix को निम्न मैट्रिक्स के साथ इसके तर्क के रूप में बुलाया गया था:
एक्स 2 1 - सी + सीएक्स वाई 1 - सी - जेड एसएक्स जेड 1 - सी + वाई एस 0 वाई एक्स 1 - सी + जेड सी 2 1 - सी + सी जेड 1 - सी - एक्स एस 0 एक्स जेड 1 - सी - वाई sy z 1 - सी + एक्स एसजे 2 1 - सी + सी 0 0 0 0 1
खैर, इसके लिए धन्यवाद!
निष्कर्ष
क्या स्पष्ट हो जाता है, बहुत सी बात है सेवा मेरे ओपन। लेकिन यह नहीं कह रहा है हमें कुछ भी। संचार कहां है?
ओपनजीएल हमें इस उदाहरण में बता रहा है कि एकमात्र चीज है जब ये पूर्ण हो जाए। प्रत्येक ऑपरेशन में निश्चित समय लगेगा। कुछ ऑपरेशन अविश्वसनीय रूप से लंबे समय तक लेते हैं, अन्य अविश्वसनीय रूप से तेज़ होते हैं।
एक कशेरुक भेजना जीपीयू के लिए इतना तेज़ होगा, मैं यह भी नहीं जानता कि इसे कैसे व्यक्त किया जाए। सीपीयू से जीपीयू तक हजारों शिखर भेजना, हर एक फ्रेम, सबसे अधिक संभावना है, बिल्कुल कोई मुद्दा नहीं है।
स्क्रीन साफ़ करना आपका व्यूपोर्ट कितना बड़ा है, इस पर निर्भर करता है कि एक मिलीसेकंड या बदतर हो सकता है (ध्यान रखें, आमतौर पर आपके पास प्रत्येक फ्रेम को आकर्षित करने के लिए लगभग 16 मिलीसेकंड होते हैं)। इसे साफ़ करने के लिए, ओपनजीएल को उस रंग में प्रत्येक पिक्सेल को आकर्षित करना है जिसे आप साफ़ करना चाहते हैं, यह लाखों पिक्सल हो सकता है।
इसके अलावा, हम अपने ग्राफिक्स एडाप्टर (अधिकतम रिज़ॉल्यूशन, अधिकतम एंटी-एलियासिंग, अधिकतम रंग गहराई, …) की क्षमताओं के बारे में ओपनजीएल से काफी कुछ पूछ सकते हैं।
लेकिन हम एक बनावट को पिक्सेल के साथ भी भर सकते हैं जिसमें प्रत्येक का एक विशिष्ट रंग होता है। प्रत्येक पिक्सेल इस प्रकार एक मान रखता है और बनावट डेटा से भरा एक विशाल "फ़ाइल" है। हम इसे ग्राफिक्स कार्ड में लोड कर सकते हैं (एक बनावट बफर बनाकर), फिर एक शेडर लोड करें, उस शेडर को इनपुट के रूप में हमारे बनावट का उपयोग करने के लिए बताएं और हमारी "फाइल" पर कुछ बेहद भारी गणनाएं चलाएं।
हम फिर एक नई बनावट में हमारे गणना (नए रंगों के रूप में) के परिणाम "प्रस्तुत" कर सकते हैं।
इस तरह आप जीपीयू को अन्य तरीकों से आपके लिए काम कर सकते हैं। मुझे लगता है कि सीयूडीए उस पहलू के समान प्रदर्शन करता है, लेकिन मुझे इसके साथ काम करने का अवसर कभी नहीं मिला।
हम वास्तव में केवल पूरे विषय को थोड़ा छुआ। 3 डी ग्राफिक्स प्रोग्रामिंग एक जानवर का नरक है।
स्पष्टीकरण में जोड़ने के लिए कुछ है? टिप्पणियों में आवाज उठाओ। अन्य तकनीक-समझदार स्टैक एक्सचेंज उपयोगकर्ताओं से अधिक उत्तरों पढ़ना चाहते हैं? यहां पूर्ण चर्चा धागा देखें।
