3 डी कंसोल रेंडरर

कुछ नहीं करना है? तो शायद सिर्फ 3 डी कंसोल सॉफ्टवेयर प्रतिपादन लिख सकते हैं?

बिल्ली में आपका स्वागत है!







आज मैं आपको बताऊंगा कि सबसे सरल 3D रेंडर सॉफ्टवेयर कैसे लिखा जाता है।

किसी भी अनुकूलन के बिना (जो इस तरह के कार्यक्रमों के लिए विशिष्ट है), क्योंकि मेरा मुख्य लक्ष्य यह बताना है कि 3 डी प्रतिपादन कैसे होता है, बजाय इसे गति देने के।



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

तो, चलिए शुरू करते हैं:

परिचय

हमारे मामले में, सबसे सरल 3D रेंडरर शामिल होंगे:

• रंग बफर "स्क्रीन" के आकार के बराबर आयामों के साथ एक सरणी है, और प्रत्येक सेल "पिक्सेल" के रंग को संग्रहीत करता है (हमारे मामले में, स्क्रीन आयामों के साथ एक कंसोल है, उदाहरण के लिए, 80x25, और एक पिक्सेल कंसोल का प्रतीक है - इसका "रंग" है) वर्ण कोड और कंसोल में उसका रंग)
• गहराई बफ़र एक सरणी है जिसका आयाम कलर बफ़र के समान है, लेकिन यह किसी दिए गए बिंदु के "गहराई" के मूल्य को संग्रहीत करता है। दरअसल, जब से हम स्क्रीन पर तीन-आयामी स्थान प्रोजेक्ट करते हैं, प्रत्येक बिंदु में स्क्रीन के लिए लंबवत अक्ष में z समन्वय का एक निश्चित मूल्य होता है। हमें इसकी आवश्यकता होगी ताकि दूसरे द्वारा एक "पिक्सेल" के ओवरलैपिंग के मामले में, उस पिक्सेल को z- समन्वय (जेड-टेस्ट में और अधिक, नीचे विस्तार से) के करीब स्क्रीन पर प्रदर्शित किया जाएगा।
• Rasterizer - वास्तव में, यह एक एल्गोरिथ्म है जो स्क्रीन के निर्देशांक में दिए गए तीन बिंदुओं के लिए दिए गए तीन बिंदुओं से एक त्रिभुज बनाता है (इसमें रेखाओं का रेखापुंज भी होता है - यह इसके सिरों पर दी गई रेखा पर स्थित स्क्रीन के बिंदुओं को उत्पन्न करता है)। यह इस तथ्य के कारण है कि हम बहुभुज प्रतिपादन का उपयोग करेंगे, अर्थात्। स्क्रीन पर प्रदर्शित 3 डी वस्तुओं को त्रि-आयामी अंतरिक्ष में त्रिकोणों के सेट द्वारा परिभाषित किया गया है।
• मैट्रिक्स रूपांतरण वास्तव में स्रोत से स्क्रीन तक त्रिकोण के निर्देशांक का रूपांतरण हैं (अर्थात, x, y, z निर्देशांक के साथ प्रत्येक बिंदु को त्रि-आयामी अंतरिक्ष में x, y निर्देशांक के साथ एक बिंदु में बदल दिया जाएगा - "स्क्रीन" और z - गहराई मान के लिए बिंदु z-बफर))।

मैं सामान्य रूप से एक त्रिकोण के प्रतिपादन के लिए एल्गोरिथ्म का वर्णन करूंगा (इस तरह, यह स्क्रीन पर प्रदर्शित प्रत्येक त्रिकोण के लिए दोहराया जाएगा)।

1. प्रत्येक निर्देशांक के निर्देशांक को मूल निर्देशांक से स्क्रीन पर परिवर्तित करना। इसके लिए, तथाकथित "सजातीय निर्देशांक"। यह जानना आवश्यक नहीं है कि यह क्या है, बस इसे कैसे उपयोग करना है, समझें। सार यह है: हम प्रत्येक शीर्ष पर चौथे समन्वय w = 1 असाइन करते हैं। फिर हम 3 मेट्रिसेस - वर्ल्ड, व्यू, प्रोजेक्शन से गुणा करते हैं, फिर हम निर्देशांक x / w, y / w, z / w के साथ एक शीर्ष लेते हैं और x और y निर्देशांक को स्क्रीन पर एक बिंदु के निर्देशांक में बदलते हैं (नीचे एक विशिष्ट विवरण दिया गया है)
2. अगला, स्क्रीन पर तीन बिंदुओं के एक रेखापुंज का उपयोग करते हुए, हम त्रिकोण के सभी बिंदुओं के स्क्रीन निर्देशांक प्राप्त करते हैं और प्रत्येक बिंदु के लिए एक जेड-टेस्ट करते हैं। Z- परीक्षण स्क्रीन पर एक बिंदु की गहराई की तुलना उस बिंदु की गहराई के साथ है जिसे हम प्रदर्शित करना चाहते हैं। यदि आउटपुट बिंदु "पहले से मौजूद" की तुलना में "आगे" है, तो आउटपुट के लिए कुछ भी नहीं होना चाहिए। इस प्रकार, हम किसी भी क्रम में 3 डी ऑब्जेक्ट्स को आकर्षित कर सकते हैं, बिना इस बात की परवाह किए कि कौन सा करीब है और कौन सा आगे है। यदि हमारे पास एक z- परीक्षण है, तो सब कुछ अपने आप बाहर हो जाएगा - निकटतम वस्तुएं दूरियों को कवर करेंगी।
3. उसके बाद, आपको बस स्क्रीन पर बिंदु प्रदर्शित करने की आवश्यकता है। ऐसा करने के लिए, "बिंदु का रंग" रंगीन बफर में दर्ज किया गया है, और जेड-बफर में इसकी गहराई।

चरण 1. रंग बफर और जेड-बफर

हमारे मामले में ColorBuffer और ZBuffer सिर्फ 2 80x25 सरणियाँ हैं (यह एक उदाहरण है, निश्चित रूप से, यह सभी कंसोल के आकार पर निर्भर करता है)। पहला कंसोल वर्णों को संग्रहीत करेगा और, यदि आप चाहें, तो उनका रंग। दूसरा प्रत्येक पिक्सेल के लिए गहराई मान है। यह एक फ्लोट या डबल हो सकता है - कोई भी डेटा प्रकार जो एक फ्लोटिंग-पॉइंट नंबर है। मैंने इसे टेम्प्लेट क्लास के रूप में लागू किया है, जहां टेम्प्लेट पैरामीटर सरणी में संग्रहीत डेटा प्रकार है।

चरण 2. रेखापुंज

रेखांकन एल्गोरिथ्म को उनके निर्देशांक x, y, z के साथ स्क्रीन पर दिए गए तीन बिंदुओं से एक पिक्सेल त्रिकोण बनाने की आवश्यकता है; इसे समझने और समझने के लिए, मैं एक पंक्ति को रेखापुंज करने के लिए ru.wikipedia.org/wiki/Bresenham_algorithm पढ़ने की सलाह देता हूं और फिर एक त्रिकोण को व्यवस्थित करने के लिए इसका उपयोग करता हूं : compgraphics.info/2D/triad_rasterization.php

इन उद्देश्यों के लिए अलग-अलग एल्गोरिदम हैं, जो आपको पसंद है उसका उपयोग करें। मुख्य बात यह है कि दिए गए स्क्रीन निर्देशांक के अनुसार त्रिकोण / रेखा के सभी बिंदुओं को उत्पन्न करने की कार्यक्षमता को लागू किया जाना चाहिए (अर्थात, मेरे लिए, उदाहरण के लिए, यह 0..79, 0..24 सीमा में होगा)।

या आप जो मेरे द्वारा कार्यान्वित किया गया है, उसे ले सकते हैं - एक त्रिभुज रेखांकन कार्य है जो लाइन रेखांकन कार्य का उपयोग करता है, जो बिंदु रेखांकन कार्य कहता है, जो एक z- परीक्षण करता है और स्क्रीन पर बिंदु प्रदर्शित करता है। (एक अंडे में सुई, एक बतख में अंडा, आदि)

मैं काम की गति पर ध्यान नहीं देता, क्योंकि काम के तर्क का पता लगाना आसान है। घर पर, ज़ाहिर है, आप कुछ का अनुकूलन कर सकते हैं।

चरण 3. ट्रांसफॉर्मिंग निर्देशांक

तो, निर्देशांक x, y, z को त्रि-आयामी अंतरिक्ष में दिए जाने के साथ एक बिंदु दें;

मैं आपको तीन-आयामी प्रभाव बनाने के लिए सही मॉडल-व्यू-प्रोजेक्शन परिवर्तनों को दिखाने का तरीका दिखाऊंगा। जैसा कि मैंने कहा, पहले हम एक चार-आयामी वेक्टर बनाते हैं (x, y, z, 1)

बहुत पहले रूपांतरण मॉडल है। संक्षेप में, यह केवल एक अनुवाद / रोटेशन / संपीड़न / विस्तार या समन्वय प्रणाली के अन्य परिवर्तन है। समय के साथ वस्तु को आसानी से स्थानांतरित करने के लिए यह आवश्यक है - उदाहरण के लिए, हमारी वस्तु हर 10 एमएस एक्स एक्स के चारों ओर कई डिग्री घूमती है। तदनुसार, हम मॉडल के निर्देशांक को स्टोर करते हैं, लेकिन बस उस मैट्रिक्स को बदलते हैं जो इस रोटेशन को परिभाषित करता है।

मैं सरलतम त्रि-आयामी परिवर्तन मैट्रिसेस का एक उदाहरण दूंगा - स्थानांतरण, रोटेशन, संपीड़न।

तदनुसार, अधिक जटिल परिवर्तनों के लिए, उनकी संरचना लें। मैं वेक्टर को कॉलम वेक्टर के रूप में प्रस्तुत करता हूं और इसे दाईं ओर मैट्रिक्स द्वारा गुणा करता हूं। तदनुसार, यदि आपको विपरीत करने की आवश्यकता है - मैट्रिसेस को स्थानांतरित करें और एक अलग क्रम में गुणा करें। ध्यान दें कि स्वयं मैट्रिसेस के गुणन का क्रम महत्वपूर्ण है - यदि आप ऑब्जेक्ट को घुमाना चाहते हैं और फिर ट्रांसफर करते हैं, तो ट्रांसफर मैट्रिक्स को रोटेशन से और फिर पॉइंट के रेडियस वेक्टर के निर्देशांक से गुणा करें। परिणामस्वरूप वेक्टर रूपांतरित बिंदु का त्रिज्या वेक्टर होगा।

मैट्रिक्स उदाहरण:

(Translation)

(x,y,z) -



1 0 0 x

0 1 0 y

0 0 1 z

0 0 0 1



/ (Scale)

(x,y,z) -

x 0 0 0

0 y 0 0

0 0 z 0

0 0 0 1

α (Rotate)

1 0 0 0

0 cos α -sin α 0

0 sin α cos α 0

0 0 0 1







अन्य कुल्हाड़ियों के चारों ओर रोटेशन उसी तरह से किया जाता है: बस ऊपरी बाएं 3x3 सबमेट्रिक्स में संबंधित रोटेशन मैट्रिक्स को प्रतिस्थापित करें



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

फ़ंक्शन केवल रोटेशन मैट्रिक्स की गणना करता है, इसलिए मैं यहां इसका वर्णन नहीं करूंगा। आप इसे स्वयं लिख सकते हैं, इसे गूगल कर सकते हैं (जिसे ग्लोटोट कहा जाता है) या इसे मेरे स्रोत से लें (मैं पहले से ही आपके लिए इसे Google :)



अगला, दृश्य परिवर्तन किया जाता है। संभवतः इसे समझाने का सबसे आसान तरीका "कैमरा" की अवधारणा है। यदि आप तीन-आयामी गेम खेलते हैं, तो आप शायद कल्पना करते हैं कि यह वह बिंदु है जिससे आप खेल की दुनिया और इस दुनिया के अंतरिक्ष में कैमरे के उन्मुखीकरण को देखते हैं। ऐसा करने के लिए, आपको ऊपर दिए गए रूपांतरणों को करने की आवश्यकता है। उदाहरण के लिए, यदि आपको बिंदु (1,2,3) से दुनिया को देखने की आवश्यकता है, तो आपको स्थानांतरण (-1, -2, -3) बनाने की आवश्यकता है। यह तर्कसंगत है - कल्पना करें कि 3 डी दुनिया की एक वस्तु में निर्देशांक (ए, बी, सी) है। फिर इसका मॉडल मैट्रिक्स संबंधित होगा - a, b, c स्थानांतरित करें। यदि एक ही समय में कैमरा एक ही बिंदु से दुनिया को देखता है, तो दृश्य मैट्रिक्स ऐसा दिखेगा: स्थानांतरण -a, -b, -c और परिणामस्वरूप, जब हम * मॉडल * (x, y, z, 1) को गुणा करते हैं, तो हमें मूल निर्देशांक मिलते हैं। ऑब्जेक्ट - इस प्रकार कैमरा ऑब्जेक्ट के समान जगह पर है।

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

परिणाम किस प्रकार का मैट्रिक्स है? कल्पना करें कि आपके पास कुछ प्रारंभिक समन्वय प्रणाली है और आप एक आंदोलन / रोटेशन करते हैं और एक अलग समन्वय प्रणाली प्राप्त करते हैं। यह परिवर्तन एक निश्चित मैट्रिक्स द्वारा परिभाषित किया गया है। यदि नए समन्वय प्रणाली की शुरुआत कैमरे की स्थिति के साथ मेल खाती है, तो 'z' अक्ष को देखने की दिशा में निर्देशित किया जाता है, और 'y' ऊपर होता है, तो दृश्य परिवर्तन मैट्रिक्स इस परिवर्तन का व्युत्क्रम मैट्रिक्स है । बेशक, कोई भी उलटा मैट्रिक्स की तलाश में नहीं है - बस व्यूमैट्रिक्स प्राप्त करने के लिए उलटा रूपांतरण तुरंत किया जाता है।



और अंत में, प्रोजेक्शन। प्रोजेक्शन मैट्रिक्स दृश्यता के पिरामिड (Frustum) से निर्देशांक को एक इकाई क्यूब (परिप्रेक्ष्य को ध्यान में रखते हुए) में परिवर्तित करता है, जिसके बाद बिंदु पहले से ही स्क्रीन पर आसानी से प्रदर्शित होता है।

Frustum दुनिया का सिर्फ एक हिस्सा है जिसे स्क्रीन पर पेश किया जाता है। यह आधार पर दो त्रिकोणों के साथ एक छोटा पिरामिड है।

मैं प्रोजेक्शन मैट्रिक्स की संरचना के बारे में स्पष्टीकरण में नहीं जाऊंगा, यह स्पष्ट है कि यह मापदंडों पर निर्भर करता है znear, zfar (फ्रंट और रियर क्लिपिंग प्लेन), fovy (वर्टिकल व्यूइंग एंगल) और एस्पेराट्रियो (colorberer चौड़ाई से ऊंचाई अनुपात) - क्रम में वर्ग एक आयताकार स्क्रीन पर एक वर्ग की तरह लग रहा था, एक आयत नहीं)। Google फ़ंक्शन gluPerspective या मेरे स्रोत से लेता है।



अंततः, हमारा परिवर्तन इस तरह दिखता है: प्रोजेक्शन * दृश्य * मॉडल * (एक्स, वाई, जेड, 1)। वेक्टर के अंतिम त्रिज्या पर, पहले 3 निर्देशांक को 4 से विभाजित करें और रेंडरिंग और जेड-टेस्ट के लिए तैयार बिंदु प्राप्त करें।

4. अंतिम परिवर्तन

यह स्क्रीन निर्देशांक में सब कुछ अनुवाद करने के लिए बनी हुई है। चूंकि हमारे मैट्रिक्स परिवर्तनों ने बिंदुओं के निर्देशांक का एक घन [-1,1] में अनुवाद किया है, और कंसोल के निर्देशांक 0..79 और 0..24 अंक हैं, फिर सरल संचालन के साथ आपको सही निर्देशांक सेट करने की आवश्यकता है: (x + 1.0) 0.5 * 80 और ( y + 1.0) * 0.5 * 25।



अब आपको z- परीक्षण चलाने की आवश्यकता है। यदि परिणामी जेड मान पहले से ही एक से अधिक है, तो पिक्सेल को प्रदर्शित करने की आवश्यकता नहीं है। अन्यथा, आपको रंग बफर में पिक्सेल के रंग का मान लिखने और इसके z- बफर में z- समन्वय करने की आवश्यकता है।



यह बात है! आप डेमो डाउनलोड करके देख सकते हैं!

लिनक्स और खिड़कियों के लिए संग्रह स्रोत और निष्पादन योग्य फाइलें

निष्कर्ष।

लेख सॉफ्टवेयर प्रतिपादन की सबसे सरल विधि का वर्णन करता है। बेशक, वास्तविक परियोजनाओं में वे कई अनुकूलन का उपयोग करते हैं, और प्रतिपादन प्रक्रिया बहुत अधिक जटिल है और अधिक सुविधाओं के साथ है।



अंत में, ubuntu कंसोल से एक और स्क्रीनशॉट: