नंगे C ++ की 256 लाइनों में समझ में आने वाला रे ट्रेसिंग

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

वेब पर काफी मात्रा में लेख हैं; हालाँकि समस्या यह है कि उनमें से लगभग सभी तैयार सॉफ्टवेयर दिखाते हैं जिन्हें समझना काफी मुश्किल हो सकता है। उदाहरण के लिए, बहुत प्रसिद्ध बसिननेस कार्ड रे ट्रेसर चुनौती को लीजिए। यह बहुत प्रभावशाली कार्यक्रम तैयार करता है, लेकिन यह समझना बहुत मुश्किल है कि यह कैसे काम करता है। यह दिखाने के बजाय कि मैं रेंडर कर सकता हूं, मैं आपको विस्तार से बताना चाहता हूं कि आप इसे कैसे कर सकते हैं।

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

इसलिए, आज का लक्ष्य ऐसी छवियों को प्रस्तुत करना सीखना है:

चरण 1: डिस्क पर एक छवि लिखें

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

#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 एफ मूल्यों के एक आयामी आयाम के रूप में परिभाषित करता हूं, वे सरल त्रि-आयामी वैक्टर हैं जो हमें प्रत्येक पिक्सेल के लिए (आर, जी, बी) मान देते हैं। वैक्टर का वर्ग फ़ाइल ज्यामिति में रहता है। इसलिए, मैं इसका वर्णन यहां नहीं करूंगा: यह वास्तव में दो और तीन आयामी वैक्टर (इसके अलावा, घटाव, असाइनमेंट, एक स्केलर द्वारा गुणा, स्केलर उत्पाद) का एक तुच्छ हेरफेर है।

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

चेतावनी: मेरा कोड बग्स से भरा है, मैं उन्हें अपस्ट्रीम में ठीक करता हूं, लेकिन पुराने कमिट प्रभावित होते हैं। इस समस्या की जाँच करें ।

तो, इस कदम का लक्ष्य यह सुनिश्चित करना है कि हम एक) मेमोरी में एक छवि बना सकते हैं + विभिन्न रंगों को असाइन करें और बी) डिस्क पर परिणाम को बचाएं। फिर आप इसे थर्ड-पार्टी सॉफ्टवेयर में देख सकते हैं। यहाँ परिणाम है:

चरण 2, महत्वपूर्ण एक: किरण अनुरेखण

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

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

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

 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); } }  [...] } 

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

• चित्र की चौड़ाई
• चित्र ऊंचाई
• दृश्य कोण का क्षेत्र
• कैमरा स्थान, Vec3f (0.0.0)
• माइनस इनफिनिटी की दिशा में, z- अक्ष के साथ, दिशा देखें

मुझे यह बताइए कि हम ट्रेस करने के लिए किरण की प्रारंभिक दिशा की गणना कैसे करते हैं। मुख्य लूप में हमारे पास यह सूत्र है:

  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.); 

यह कहां से आता है? बहुत ही सरल। हमारा कैमरा मूल में रखा गया है और यह -z दिशा का सामना करता है। मुझे सामान की व्याख्या करने दें, यह छवि ऊपर से कैमरा दिखाती है, वाई अक्ष स्क्रीन से बाहर की ओर इशारा करती है:

जैसा कि मैंने कहा, कैमरे को मूल स्थान पर रखा गया है, और दृश्य को स्क्रीन पर पेश किया गया है जो विमान z = -1 में स्थित है। देखने का क्षेत्र निर्दिष्ट करता है कि स्क्रीन पर अंतरिक्ष का कौन सा क्षेत्र दिखाई देगा। हमारी छवि में स्क्रीन 16 पिक्सेल चौड़ी है; क्या आप विश्व की दिशाओं में इसकी लंबाई की गणना कर सकते हैं? यह बहुत आसान है: हमें लाल, ग्रे और ग्रे धराशायी लाइन द्वारा गठित त्रिकोण पर ध्यान दें। यह देखना आसान है कि टैन (देखने का क्षेत्र / 2) = (स्क्रीन की चौड़ाई) 0.5 / (स्क्रीन-कैमरा दूरी)। हमने स्क्रीन को कैमरे से 1 की दूरी पर रखा, इस प्रकार (स्क्रीन की चौड़ाई) = 2 टैन (देखने का क्षेत्र / 2)।

अब हम कहते हैं कि हम स्क्रीन के 12 वें पिक्सेल के केंद्र के माध्यम से एक वेक्टर डालना चाहते हैं, अर्थात हम नीले वेक्टर की गणना करना चाहते हैं। हम ऐसा कैसे कर सकते हैं? स्क्रीन के बाईं ओर से नीले वेक्टर की नोक की दूरी कितनी है? सबसे पहले, यह 12 + 0.5 पिक्सेल है। हम जानते हैं कि स्क्रीन के 16 पिक्सल 2 टैन (fov / 2) विश्व इकाइयों के अनुरूप हैं । इस प्रकार, वेक्टर की नोक बाएं किनारे से (12 + 0.5) / 16 2 टैन (fov / 2) विश्व इकाइयों पर स्थित है, या (12 + 0.5) 2/16 * tan (fov / 2) की दूरी पर - स्क्रीन और -z अक्ष के बीच चौराहे से टैन (fov / 2)। अभिकलन के लिए स्क्रीन पहलू अनुपात जोड़ें और आप किरण दिशा के लिए बिल्कुल सूत्र पाएंगे।

चरण 3: अधिक गोले जोड़ें

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

चरण 4: प्रकाश व्यवस्था

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

 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; } 

पिछले चरण में किए गए संशोधन यहाँ उपलब्ध हैं , और यहाँ परिणाम है:

चरण 5: स्पेक्युलर लाइटिंग

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

जाँच करें कि कितने संशोधन आवश्यक थे। संक्षेप में, चमकदार सतहों पर हल्का प्रकाश, दृश्य दिशा और परावर्तित प्रकाश की दिशा के बीच का कोण कम होता है ।

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

चरण 6: छाया

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

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

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

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

चरण 7: प्रतिबिंब

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

  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); 

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

चरण 8: अपवर्तन

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

चरण 9: गोले से परे

इस क्षण तक हमने केवल क्षेत्रों का प्रतिपादन किया क्योंकि यह सबसे सरल nontrivial गणितीय वस्तुओं में से एक है। हमें एक विमान जोड़ें। बिसात क्लासिक पसंद है। इस प्रयोजन के लिए, यह एक दर्जन लाइनों को जोड़ने के लिए पर्याप्त है।

और यहाँ परिणाम है:

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

चरण 10: होम असाइनमेंट

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

असाइनमेंट 1: पर्यावरण का नक्शा

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

असाइनमेंट 2: क्वैक-क्वैक!

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

निष्कर्ष

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

कुछ घंटे और कोड की दो सौ पचास पंक्तियाँ हमें एक रेक्ट्रासेर देती हैं। सॉफ्टवेयर रैस्टराइजर की पांच सौ लाइनें कुछ दिनों में की जा सकती हैं। प्रोग्रामिंग सीखने के लिए ग्राफिक्स वास्तव में अच्छा है!