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

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

कुल मिलाकर, ऐसी स्थितियों के तहत कोड की 180 लाइनों में ऐसी तस्वीर कैसे खींचनी है?



मुझे एक एनिमेटेड जिफ़ (छह मीटर) डालें:



और अब हम पूरे कार्य को कई चरणों में विभाजित करेंगे:

स्टेज एक: पिछला लेख पढ़ें

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

स्टेज दो: ड्रा एक क्षेत्र

चलो सामग्री या प्रकाश व्यवस्था से परेशान किए बिना एक क्षेत्र बनाते हैं। सादगी के लिए, यह क्षेत्र निर्देशांक के केंद्र में रहेगा। इस चित्र के बारे में मैं प्राप्त करना चाहता हूं:



यहां कोड देखें, लेकिन मैं आपको लेख के पाठ में मुख्य रूप से सीधे प्रवेश देता हूं:

#define _USE_MATH_DEFINES #include <cmath> #include <algorithm> #include <limits> #include <iostream> #include <fstream> #include <vector> #include "geometry.h" const float sphere_radius = 1.5; float signed_distance(const Vec3f &p) { return p.norm() - sphere_radius; } bool sphere_trace(const Vec3f &orig, const Vec3f &dir, Vec3f &pos) { pos = orig; for (size_t i=0; i<128; i++) { float d = signed_distance(pos); if (d < 0) return true; pos = pos + dir*std::max(d*0.1f, .01f); } return false; } int main() { const int width = 640; const int height = 480; const float fov = M_PI/3.; std::vector<Vec3f> framebuffer(width*height); #pragma omp parallel for for (size_t j = 0; j<height; j++) { // actual rendering loop for (size_t i = 0; i<width; i++) { float dir_x = (i + 0.5) - width/2.; float dir_y = -(j + 0.5) + height/2.; // this flips the image at the same time float dir_z = -height/(2.*tan(fov/2.)); Vec3f hit; if (sphere_trace(Vec3f(0, 0, 3), Vec3f(dir_x, dir_y, dir_z).normalize(), hit)) { // the camera is placed to (0,0,3) and it looks along the -z axis framebuffer[i+j*width] = Vec3f(1, 1, 1); } else { framebuffer[i+j*width] = Vec3f(0.2, 0.7, 0.8); // background color } } } std::ofstream ofs("./out.ppm", std::ios::binary); // save the framebuffer to file 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)(std::max(0, std::min(255, static_cast<int>(255*framebuffer[i][j])))); } } ofs.close(); return 0; } 

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

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

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

ध्यान दें, लेख का मुख्य विचार: यदि पिछले लेख में हमने विश्लेषणात्मक रूप से एक किरण और एक गोले के प्रतिच्छेदन पर विचार किया था, तो अब मैं इसे संख्यात्मक रूप से गिनता हूं। विचार सरल है: क्षेत्र में x ^ 2 + y ^ 2 + z ^ 2 - r ^ 2 = 0 का एक समीकरण है; लेकिन सामान्य रूप से फ़ंक्शन f (x, y, z) = x ^ 2 + y ^ 2 + z ^ 2 - r ^ 2 पूरे स्थान में परिभाषित किया गया है। क्षेत्र के अंदर, फ़ंक्शन f (x, y, z) में नकारात्मक मान होंगे, और क्षेत्र के बाहर, यह सकारात्मक होगा। यही है, फ़ंक्शन f (x, y, z) बिंदु (x, y, z) के लिए हमारे गोले के लिए दूरी (एक संकेत के साथ!) सेट करता है। इसलिए, जब तक हम ऊब नहीं जाते तब तक हम बीम के साथ बस फिसलते हैं या फ़ंक्शन च (x, y, z) नकारात्मक हो जाता है। Sphere_trace () फ़ंक्शन बस यही करता है।

स्टेज तीन: आदिम प्रकाश

चलो सरलतम विसरित प्रकाश को कोड करते हैं, मैं आउटपुट पर ऐसी तस्वीर प्राप्त करना चाहता हूं:



पिछले लेख की तरह, पढ़ने में आसानी के लिए, मैंने एक कदम = एक कमिट किया। यहां परिवर्तन देखे जा सकते हैं ।

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

 Vec3f distance_field_normal(const Vec3f &pos) { const float eps = 0.1; float d = signed_distance(pos); float nx = signed_distance(pos + Vec3f(eps, 0, 0)) - d; float ny = signed_distance(pos + Vec3f(0, eps, 0)) - d; float nz = signed_distance(pos + Vec3f(0, 0, eps)) - d; return Vec3f(nx, ny, nz).normalize(); } 

सिद्धांत रूप में, निश्चित रूप से, चूंकि हम एक क्षेत्र बना रहे हैं, सामान्य को बहुत आसान प्राप्त किया जा सकता है, लेकिन मैंने भविष्य के लिए एक रिजर्व के साथ ऐसा किया।

स्टेज चार: हमारे क्षेत्र पर एक पैटर्न बनाते हैं

और उदाहरण के लिए, हमारे क्षेत्र में किसी तरह का पैटर्न बनाते हैं:



ऐसा करने के लिए, पिछले कोड में, मैंने केवल दो लाइनें बदल दीं!

मैंने यह कैसे किया? बेशक, मेरे पास कोई बनावट नहीं है। मैंने अभी फ़ंक्शन g (x, y, z) = sin (x) * sin (y) * sin (z) लिया; इसे फिर से पूरे अंतरिक्ष में परिभाषित किया गया है। जब मेरी किरण किसी बिंदु पर गोले को पार करती है, तो इस बिंदु पर फ़ंक्शन जी (x, y, z) का मान मेरे लिए पिक्सेल का रंग निर्धारित करता है।

वैसे, गोले के चारों ओर संकेंद्रित हलकों पर ध्यान दें - ये चौराहे की मेरी संख्यात्मक गणना की कलाकृतियां हैं।

पांच कदम: विस्थापन मानचित्रण

मैं इस पैटर्न को क्यों खींचना चाहता था? और वह मुझे ऐसा हेजल बनाने में मदद करेगा:



जहां मेरा पैटर्न काला था, मैं हमारे क्षेत्र में एक छेद करना चाहता हूं, और जहां यह सफेद था, इसके विपरीत, कूबड़ को फैलाएं।

ऐसा करने के लिए, हमारे कोड में केवल तीन पंक्तियों को बदलें :

 float signed_distance(const Vec3f &p) { Vec3f s = Vec3f(p).normalize(sphere_radius); float displacement = sin(16*sx)*sin(16*sy)*sin(16*sz)*noise_amplitude; return p.norm() - (sphere_radius + displacement); } 

यही है, मैंने दूरी की गणना को हमारी सतह पर बदल दिया, इसे x ^ 2 + y ^ 2 + z ^ 2 - r ^ 2 - पाप (x) * पाप (y) * पाप (z) के रूप में परिभाषित किया। वास्तव में, हमने एक निहित कार्य को परिभाषित किया।

छह चरण: एक और निहित कार्य

और मैं केवल हमारे क्षेत्र की सतह पर स्थित बिंदुओं के लिए साइन के उत्पाद का मूल्यांकन क्यों कर रहा हूं? आइए इस तरह से हमारे निहित कार्य को फिर से परिभाषित करें:

 float signed_distance(const Vec3f &p) { float displacement = sin(16*px)*sin(16*py)*sin(16*pz)*noise_amplitude; return p.norm() - (sphere_radius + displacement); } 

पिछले कोड के साथ अंतर बहुत छोटा है, अंतर को देखना बेहतर है। यहाँ परिणाम है:



इस प्रकार, हम अपने ऑब्जेक्ट में डिस्कनेक्ट किए गए घटकों को परिभाषित कर सकते हैं!

चरण सात: छद्म यादृच्छिक शोर

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



इस तरह के शोर को कैसे उत्पन्न किया जाए, यह थोड़ा अपमानजनक है, लेकिन यहां मुख्य विचार है: आपको विभिन्न संकल्पों के साथ यादृच्छिक छवियां उत्पन्न करने की आवश्यकता है, उन्हें कुछ इस तरह प्राप्त करने के लिए चिकना करें:



और फिर बस उन्हें योग:



यहाँ और यहाँ पढ़ें।

आइए कुछ कोड जोड़ते हैं जो इस शोर को उत्पन्न करता है और इस चित्र को प्राप्त करें:



कृपया ध्यान दें कि रेंडरिंग कोड में मैंने कुछ भी नहीं बदला है, केवल वह फ़ंक्शन जो "रिंकल्स" हमारे क्षेत्र में बदल गया है।

स्टेज आठ, अंतिम: रंग जोड़ें

इस कमिट में मैंने केवल एक चीज बदली है कि एक समान सफेद रंग के बजाय, मैंने एक रंग लागू किया है जो रैखिक रूप से शोर की मात्रा पर निर्भर करता है:

 Vec3f palette_fire(const float d) { const Vec3f yellow(1.7, 1.3, 1.0); // note that the color is "hot", ie has components >1 const Vec3f orange(1.0, 0.6, 0.0); const Vec3f red(1.0, 0.0, 0.0); const Vec3f darkgray(0.2, 0.2, 0.2); const Vec3f gray(0.4, 0.4, 0.4); float x = std::max(0.f, std::min(1.f, d)); if (x<.25f) return lerp(gray, darkgray, x*4.f); else if (x<.5f) return lerp(darkgray, red, x*4.f-1.f); else if (x<.75f) return lerp(red, orange, x*4.f-2.f); return lerp(orange, yellow, x*4.f-3.f); } 

यह पांच प्रमुख रंगों के बीच एक सरल रैखिक ढाल है। खैर, यहाँ तस्वीर है!

निष्कर्ष

इस किरण अनुरेखण तकनीक को किरण मार्चिंग कहा जाता है। होमवर्क सरल है: हमारे विस्फोट के साथ लाठी और प्रतिबिंब के साथ पिछली किरण अनुरेखक को पार करें, ताकि विस्फोट भी चारों ओर सब कुछ रोशन करे! वैसे, इस विस्फोट में पारभासी का अभाव है।