मैं कंप्यूटर ग्राफिक्स पर अपने व्याख्यान पाठ्यक्रम से अगला अध्याय प्रकाशित कर रहा हूं ( यहां आप मूल रूसी में पढ़ सकते हैं , हालांकि अंग्रेजी संस्करण नया है)। इस बार, वार्तालाप का विषय किरण अनुरेखण का उपयोग करते हुए दृश्य खींच रहा है । हमेशा की तरह, मैं तीसरे पक्ष के पुस्तकालयों से बचने की कोशिश करता हूं, क्योंकि यह छात्रों को हुड के नीचे देखता है।

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

ध्यान दें: बस मेरे कोड को देख रहा है, साथ ही सिर्फ एक कप चाय के साथ इस लेख को पढ़ रहा है, इसका कोई मतलब नहीं है। यह लेख आपको एक कीबोर्ड को पकड़ने और अपने स्वयं के इंजन को लिखने के लिए डिज़ाइन किया गया है। वह निश्चित रूप से मेरी तुलना में बेहतर होगा। ठीक है, या बस प्रोग्रामिंग भाषा को बदलें!

तो, आज मैं दिखाऊंगा कि ऐसी तस्वीरें कैसे खींची जाती हैं:

स्टेज एक: डिस्क पर चित्र सहेजें

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

#include <limits> #include <cmath> #include <iostream> #include <fstream> #include <vector> #include "geometry.h" void render() { const int width = 1024; const int height = 768; std::vector<Vec3f> framebuffer(width*height); for (size_t j = 0; j<height; j++) { for (size_t i = 0; i<width; i++) { framebuffer[i+j*width] = Vec3f(j/float(height),i/float(width), 0); } } std::ofstream ofs; // save the framebuffer to file ofs.open("./out.ppm"); ofs << "P6\n" << width << " " << height << "\n255\n"; for (size_t i = 0; i < height*width; ++i) { for (size_t j = 0; j<3; j++) { ofs << (char)(255 * std::max(0.f, std::min(1.f, framebuffer[i][j]))); } } ofs.close(); } int main() { render(); return 0; } 

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

वैक्टर का वर्ग ज्यामिति में रहता है। फ़ाइल में, मैं यहाँ इसका वर्णन नहीं करूँगा: सबसे पहले, वहाँ सब कुछ तुच्छ है, दो और तीन-आयामी वैक्टर के सरल हेरफेर (इसके अलावा, घटाव, असाइनमेंट, एक स्केलर द्वारा गुणा, स्केलर उत्पाद), और दूसरी बात, gbg ने पहले ही इसे कंप्यूटर ग्राफिक्स पर एक व्याख्यान पाठ्यक्रम के हिस्से के रूप में विस्तार से वर्णित किया है।

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

कुल मिलाकर, इस चरण का लक्ष्य यह सुनिश्चित करना है कि हम एक) स्मृति में एक चित्र बना सकते हैं और वहां अलग-अलग रंग मान लिख सकते हैं b) परिणाम को डिस्क पर सहेजें ताकि इसे तीसरे पक्ष के कार्यक्रम में देखा जा सके। यहाँ परिणाम है:

स्टेज दो, सबसे कठिन: सीधे किरण अनुरेखण

यह पूरी श्रृंखला का सबसे महत्वपूर्ण और कठिन चरण है। मैं अपने कोड में एक क्षेत्र को परिभाषित करना चाहता हूं और इसे सामग्री या प्रकाश व्यवस्था से परेशान किए बिना स्क्रीन पर दिखाता हूं। यह हमारे परिणाम जैसा दिखना चाहिए:



सुविधा के लिए, मेरे भंडार में, प्रत्येक चरण के लिए एक प्रतिबद्ध है; Github आपके परिवर्तनों को देखने के लिए बहुत सुविधाजनक बनाता है। यहाँ, उदाहरण के लिए , पहले की तुलना में दूसरी प्रतिबद्धताओं में क्या बदलाव आया है।

के साथ शुरू करने के लिए: हमें कंप्यूटर की मेमोरी में एक क्षेत्र का प्रतिनिधित्व करने की क्या आवश्यकता है? हमारे लिए चार संख्याएँ पर्याप्त हैं: एक त्रि-आयामी सदिश क्षेत्र और त्रिज्या का वर्णन करने वाला एक अदिश:

 struct Sphere { Vec3f center; float radius; Sphere(const Vec3f &c, const float &r) : center(c), radius(r) {} bool ray_intersect(const Vec3f &orig, const Vec3f &dir, float &t0) const { Vec3f L = center - orig; float tca = L*dir; float d2 = L*L - tca*tca; if (d2 > radius*radius) return false; float thc = sqrtf(radius*radius - d2); t0 = tca - thc; float t1 = tca + thc; if (t0 < 0) t0 = t1; if (t0 < 0) return false; return true; } }; 

इस कोड में एकमात्र निरर्थक बात एक फ़ंक्शन है जो आपको यह जांचने की अनुमति देता है कि क्या एक दी गई किरण (dir की दिशा में उत्पत्ति से उत्पन्न) हमारे क्षेत्र के साथ प्रतिच्छेदन करती है। बीम और चौराहे की जांच के लिए एल्गोरिथ्म का एक विस्तृत विवरण यहां पढ़ा जा सकता है , मैं इसे करने और अपने कोड की जांच करने की अत्यधिक अनुशंसा करता हूं।

किरण अनुरेखण कैसे काम करती है? बहुत सरल है। पहले चरण में, हमने बस एक ढाल के साथ छवि को कवर किया:

  for (size_t j = 0; j<height; j++) { for (size_t i = 0; i<width; i++) { framebuffer[i+j*width] = Vec3f(j/float(height),i/float(width), 0); } } 

अब, प्रत्येक पिक्सेल के लिए, हम निर्देशांक के केंद्र से आने वाली और हमारे पिक्सेल से गुजरने वाली एक किरण का निर्माण करेंगे, और जाँचेंगे कि क्या यह किरण हमारे क्षेत्र को काटती है।



यदि गोले के साथ कोई चौराहा नहीं है, तो हम color1 डाल देंगे, अन्यथा color2:

 Vec3f cast_ray(const Vec3f &orig, const Vec3f &dir, const Sphere &sphere) { float sphere_dist = std::numeric_limits<float>::max(); if (!sphere.ray_intersect(orig, dir, sphere_dist)) { return Vec3f(0.2, 0.7, 0.8); // background color } return Vec3f(0.4, 0.4, 0.3); } void render(const Sphere &sphere) {  [...] for (size_t j = 0; j<height; j++) { for (size_t i = 0; i<width; i++) { float x = (2*(i + 0.5)/(float)width - 1)*tan(fov/2.)*width/(float)height; float y = -(2*(j + 0.5)/(float)height - 1)*tan(fov/2.); Vec3f dir = Vec3f(x, y, -1).normalize(); framebuffer[i+j*width] = cast_ray(Vec3f(0,0,0), dir, sphere); } }  [...] } 

इस बिंदु पर, मैं एक पेंसिल लेने और कागज पर सभी गणनाओं की जांच करने की सलाह देता हूं, एक गोले के साथ एक किरण के दोनों चौराहे, और किरणों के साथ एक तस्वीर की व्यापकता। बस के मामले में, हमारा कैमरा निम्नलिखित बातों से निर्धारित होता है:

• छवि की चौड़ाई
• चित्र ऊंचाई
• देखने के कोण, fov
• कैमरा स्थान, Vec3f (0,0,0)
• टकटकी की दिशा, शून्य अक्ष के साथ, शून्य से अनंत की दिशा में

स्टेज तीन: अधिक क्षेत्रों को जोड़ें

सभी सबसे मुश्किल हमारे पीछे है, अब हमारा रास्ता बादल रहित है। अगर हम एक क्षेत्र को आकर्षित कर सकते हैं। तो जाहिर है कुछ और काम जोड़ना मुश्किल नहीं है। यहाँ आप कोड में परिवर्तन देख सकते हैं, और यहाँ परिणाम है:

स्टेज चार: प्रकाश व्यवस्था

हर कोई हमारी तस्वीर पर अच्छा है, लेकिन यह सिर्फ पर्याप्त प्रकाश व्यवस्था नहीं है। शेष लेख के दौरान, हम केवल इस बारे में बात करेंगे। कुछ बिंदु प्रकाश स्रोत जोड़ें:

 struct Light { Light(const Vec3f &p, const float &i) : position(p), intensity(i) {} Vec3f position; float intensity; }; 

वास्तविक प्रकाश व्यवस्था पर विचार करना एक बहुत ही कठिन काम है, इसलिए, हर किसी की तरह, हम पूरी तरह से अस्पष्ट, लेकिन सबसे संभावित, प्रशंसनीय परिणाम खींचकर आंख को धोखा देंगे। पहली टिप्पणी: यह सर्दियों में ठंडा और गर्मियों में गर्म क्यों होता है? क्योंकि पृथ्वी की सतह को गर्म करना सूर्य के प्रकाश की घटनाओं के कोण पर निर्भर करता है। क्षितिज के ऊपर सूर्य जितना ऊँचा होता है, सतह उतनी ही चमकीली होती है। और इसके विपरीत, कम क्षितिज, कमजोर। खैर, सूरज क्षितिज पर सेट होने के बाद, फोटॉन हम तक बिल्कुल नहीं पहुंचते हैं। हमारे गोले के संबंध में: यहाँ हमारे बीम को कैमरे से उत्सर्जित किया गया है (फोटॉन से कोई संबंध नहीं है, ध्यान दें!) क्षेत्र के साथ जुड़ा हुआ है। हम कैसे समझें कि चौराहे का बिंदु कैसे रोशन है? आप बस इस बिंदु पर सामान्य वेक्टर और प्रकाश की दिशा का वर्णन करने वाले वेक्टर के बीच के कोण को देख सकते हैं। कोण जितना छोटा होगा, सतह उतनी ही बेहतर होगी। इसे और भी सुविधाजनक बनाने के लिए, आप सामान्य वेक्टर और प्रकाश वेक्टर के बीच अदिश उत्पाद ले सकते हैं। मुझे याद है कि दो वैक्टर ए और बी के बीच का अदिश उत्पाद वैक्टर के कोण के कोसाइन द्वारा वैक्टर के मानदंडों के उत्पाद के बराबर होता है: ए * बी = | ए | | बी | cos (अल्फा (a, b))। यदि हम यूनिट लंबाई के वैक्टर लेते हैं, तो सबसे सरल स्केलर उत्पाद हमें सतह की रोशनी की तीव्रता देगा।

इस प्रकार, कास्ट_रे फ़ंक्शन में, एक स्थिर रंग के बजाय, हम प्रकाश स्रोतों को ध्यान में रखते हुए रंग वापस करेंगे:

 Vec3f cast_ray(const Vec3f &orig, const Vec3f &dir, const Sphere &sphere) { [...] float diffuse_light_intensity = 0; for (size_t i=0; i<lights.size(); i++) { Vec3f light_dir = (lights[i].position - point).normalize(); diffuse_light_intensity += lights[i].intensity * std::max(0.f, light_dir*N); } return material.diffuse_color * diffuse_light_intensity; } 

यहां परिवर्तन देखें , लेकिन कार्यक्रम का परिणाम:

स्टेज पांच: चमकदार सतहों

एक सामान्य वेक्टर और एक प्रकाश वेक्टर के बीच एक स्केलर उत्पाद के साथ एक चाल मैट सतहों की रोशनी को काफी अच्छी तरह से अनुमानित करती है, साहित्य में इसे फैलाना रोशनी कहा जाता है। अगर हम चिकनी और चमकदार चाहते हैं तो क्या करें? मैं इस तस्वीर को प्राप्त करना चाहता हूं:



देखते हैं कि बदलाव की कितनी कम जरूरत है। संक्षेप में, चमकदार सतहों पर प्रतिबिंब चमकीले होते हैं, देखने की दिशा और प्रतिबिंबित प्रकाश की दिशा के बीच का कोण छोटा होता है । ठीक है, कोनों, निश्चित रूप से, हम स्केलर उत्पादों के माध्यम से गिनती करेंगे, बिल्कुल पहले की तरह।

प्रकाश मैट और चमकदार सतहों वाले इस जिम्नास्टिक को फोंग मॉडल के रूप में जाना जाता है। विकी के पास इस प्रकाश मॉडल का काफी विस्तृत वर्णन है, यह मेरे कोड के समानांतर होने पर अच्छी तरह से पढ़ता है। समझने के लिए यहां एक महत्वपूर्ण तस्वीर है:

स्टेज छह: छाया

हमारे पास प्रकाश क्यों है, लेकिन छाया नहीं है? विकार! मुझे यह चित्र चाहिए:



कोड की केवल छह लाइनें हमें इसे प्राप्त करने की अनुमति देती हैं: प्रत्येक बिंदु को खींचते समय, हम बस यह सुनिश्चित करते हैं कि प्रकाश का बिंदु स्रोत हमारे दृश्य की वस्तुओं को नहीं काटता है, और यदि ऐसा होता है, तो वर्तमान प्रकाश स्रोत रुक जाता है। केवल एक छोटी सी सूक्ष्मता है: मैं बिंदु को सामान्य की दिशा में थोड़ा स्थानांतरित करता हूं:

 Vec3f shadow_orig = light_dir*N < 0 ? point - N*1e-3 : point + N*1e-3; 

क्यों? हां, बस इतना है कि हमारा बिंदु वस्तु की सतह पर स्थित है, और (संख्यात्मक त्रुटियों के मुद्दे को छोड़कर) इस बिंदु से कोई भी किरण हमारे दृश्य को पार कर जाएगी।

चरण सात: प्रतिबिंब

यह अविश्वसनीय है, लेकिन हमारे दृश्य में प्रतिबिंब जोड़ने के लिए, हमें केवल तीन पंक्तियों को जोड़ना होगा:

  Vec3f reflect_dir = reflect(dir, N).normalize(); Vec3f reflect_orig = reflect_dir*N < 0 ? point - N*1e-3 : point + N*1e-3; // offset the original point to avoid occlusion by the object itself Vec3f reflect_color = cast_ray(reflect_orig, reflect_dir, spheres, lights, depth + 1); 

खुद के लिए देखें: ऑब्जेक्ट के साथ चौराहे पर, हम बस परिलक्षित किरण की गणना करते हैं (b की गणना से फ़ंक्शन काम आया!) और पुन: परावर्तित किरण की दिशा में कास्ट_रे फ़ंक्शन को कॉल करता है। पुनरावृत्ति की गहराई के साथ खेलना सुनिश्चित करें, मैंने इसे चार पर सेट किया है, खरोंच से शुरू होता है, तस्वीर में क्या बदलेगा? यहाँ मेरा काम एक प्रतिबिंब और चार की गहराई के साथ है:

स्टेज आठ: अपवर्तन

प्रतिबिंबों को गिनना सीखने से, अपवर्तन को समान रूप से गिना जाता है । एक फ़ंक्शन जो हमें अपवर्तित किरण की दिशा ( स्नेल के नियम के अनुसार ) की गणना करने की अनुमति देता है, और हमारे पुनरावर्ती फ़ंक्शन कास्ट_रे में कोड की तीन लाइनें। यहाँ परिणाम है, जिसमें निकटतम गेंद "ग्लास" बन गई, यह अपवर्तित और थोड़ा प्रतिबिंबित करती है:

स्टेज नौ: अधिक ऑब्जेक्ट जोड़ें

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

खैर, यहाँ परिणाम है:



जैसा कि मैंने वादा किया था, कोड की बिल्कुल 256 लाइनें, अपने लिए गिनें !

स्टेज दस: होमवर्क

हम एक लंबा रास्ता तय कर चुके हैं: हमने सीखा कि वस्तुओं को दृश्य में जोड़ना है, बल्कि जटिल प्रकाश व्यवस्था पर विचार करना है। मुझे होमवर्क के रूप में दो कार्यों को छोड़ देना चाहिए। पूरी तरह से होमवर्क_साइनमेंट शाखा में सभी तैयारी कार्य पहले ही किए जा चुके हैं । प्रत्येक नौकरी के लिए कोड की अधिकतम दस लाइनों की आवश्यकता होगी।

टास्क एक: पर्यावरण का नक्शा

फिलहाल, यदि बीम दृश्य को पार नहीं करता है, तो हम इसे निरंतर रंग पर सेट करते हैं। और क्यों, वास्तव में, स्थायी? आइए एक गोलाकार फोटो ( envmap.jpg फ़ाइल) लें और इसे एक पृष्ठभूमि के रूप में उपयोग करें! जीवन को आसान बनाने के लिए, मैंने jpegs के साथ काम करने की सुविधा के लिए हमारे प्रोजेक्ट को stb लाइब्रेरी के साथ जोड़ा। इसे इस तरह प्रस्तुत किया जाना चाहिए:

दूसरा काम: नीम हकीम!

हम दोनों क्षेत्रों और विमानों को प्रस्तुत कर सकते हैं (शतरंज की बिसात देखें)। तो चलो त्रिकोणित मॉडल की एक ड्राइंग जोड़ें! मैंने त्रिभुजों की ग्रिड को पढ़ने के लिए कोड लिखा था, और वहां एक रे-ट्रायंगल चौराहा फ़ंक्शन जोड़ा। अब हमारे दृश्य में एक बतख जोड़ना पूरी तरह से तुच्छ होना चाहिए!

निष्कर्ष

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

पुनरावृत्ति की दो सौ पचास पंक्तियाँ वास्तव में कुछ घंटों में लिखी जा सकती हैं। सॉफ्टवेयर रैस्टराइज़र की पांच सौ लाइनों को कुछ दिनों में महारत हासिल की जा सकती है। अगली बार हम rakecasting के माध्यम से सॉर्ट करेंगे, और साथ ही मैं सबसे सरल गेम दिखाऊंगा जो मेरे प्रथम वर्ष के छात्र C ++ प्रोग्रामिंग सिखाने के हिस्से के रूप में लिखते हैं। देखते रहो!