"धुंधली अवधारणा की स्पष्ट छवि से बदतर कुछ भी नहीं है।" - फोटोग्राफर एंसल एडम्स

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

हमारे पास पहले से मौजूद कोड के आधार पर, हम 1986 में जेम्स कैजिया द्वारा तैयार किए गए प्रतिपादन समीकरण को हल करेंगे और हमारे रेंडरर को उपरोक्त प्रभावों को प्रसारित करने में सक्षम पथ ट्रैसर में बदल देंगे। हम फिर से लिपियों के लिए स्क्रिप्ट और एचएलएसएल के लिए C # का उपयोग करेंगे। कोड को Bitbucket पर अपलोड किया गया है ।

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

नीचे की छवि एचडीआरआई हेवन वेबसाइट से भित्तिचित्र आश्रय मानचित्र का उपयोग करके प्रदान की गई है। इस लेख में अन्य छवियों को Kiara 9 Dusk कार्ड का उपयोग करके प्रस्तुत किया गया है।

रेंडरिंग समीकरण

एक औपचारिक दृष्टिकोण से, फोटोलेरिस्टिक रेंडरर का कार्य रेंडरिंग समीकरण को हल करना है, जो इस प्रकार लिखा जाता है:

$$

$$L (x, \, \ vec \ omega_ {o}) = L_e (x, \, \ vec \ omega_ {o}) + \ int _ {\ _ Omega} {f_r (x, \, \ vec \ omega_ {i) }, \, \ vec \ omega_ {o}), ((\ vec \ omega_ {i} \ cdot \ vec n) \ _, L (x, \, \ vec \ omega_ {i}, d \ vec \ _) ओमेगा_ {i}}$$

आइए इसका विश्लेषण करते हैं। हमारा अंतिम लक्ष्य स्क्रीन पिक्सेल की चमक निर्धारित करना है। रेंडरिंग समीकरण हमें रोशनी की मात्रा देता है $$$L (x, \, \ vec \ omega_ {o})$ एक बिंदु से आ रहा है $$$x$ (बीम की घटना का बिंदु) दिशा में $$$\ vec \ omega_ {o}$ (जिस दिशा में बीम गिरती है)। सतह ही प्रकाश उत्सर्जित करने वाला प्रकाश स्रोत हो सकता है $$$L_e (x, \, \ vec \ omega_ {o})$ हमारी दिशा में। अधिकांश सतहें नहीं होती हैं, इसलिए वे केवल बाहर से प्रकाश को दर्शाते हैं। यही कारण है कि अभिन्न का उपयोग किया जाता है। यह गोलार्ध के हर संभव दिशा से आने वाले प्रकाश को संचित करता है। $$$\ _ ओमेगा$ सामान्य के आसपास (इसलिए, जब हम ऊपर से सतह पर गिरने वाली रोशनी को ध्यान में रखते हैं , और अंदर से नहीं, जो पारभासी सामग्री के लिए आवश्यक हो सकता है)।

पहला भाग है $$$f_r$ को एक द्विदिश परावर्तन वितरण समारोह (BRDF) कहा जाता है। यह फ़ंक्शन नेत्रहीन रूप से उस सामग्री के प्रकार का वर्णन करता है जो हम काम कर रहे हैं: धातु या ढांकता हुआ, अंधेरे या उज्ज्वल, चमकदार या मैट। BRDF प्रकाश से आने वाले अनुपात को निर्धारित करता है $$$\ vec \ omega_ {i}$ जो दिशा में परिलक्षित होता है $$$\ vec \ omega_ {o}$ । व्यवहार में, यह अंतराल में लाल, हरे और नीले रंग के मूल्यों के साथ तीन-घटक वेक्टर का उपयोग करके कार्यान्वित किया जाता है $$$[0,1]$ ।

दूसरा भाग - $$$(\ vec \ omega_ {i} \ cdot \ vec n)$ ¹ के बराबर है $$$cos \ थीटा$ जहाँ $$$$ थीटा$ - घटना प्रकाश और सतह के बीच का कोण सामान्य $$$\ vec n$ । सतह पर लंबवत रूप से गिरने वाली प्रकाश की समानांतर किरणों के एक स्तंभ की कल्पना करें। अब समतल कोण पर सतह पर गिरने वाली उसी किरण की कल्पना करें। प्रकाश एक बड़े क्षेत्र में वितरित किया जाएगा, लेकिन इसका मतलब यह भी है कि इस क्षेत्र का प्रत्येक बिंदु गहरा दिखाई देगा। इसे ध्यान में रखने के लिए कोसाइन की आवश्यकता होती है।

अंत में, खुद से प्राप्त प्रकाश $$$\ vec \ omega_ {i}$ उसी समीकरण का उपयोग करके पुनरावर्ती रूप से निर्धारित किया जाता है। यही है, बिंदु पर प्रकाश व्यवस्था $$$x$ ऊपरी गोलार्ध में सभी संभावित दिशाओं से घटना प्रकाश पर निर्भर करता है। इनमें से प्रत्येक दिशा में एक बिंदु से $$$x$ एक और बात है $$$x \ Prime$ जिस की चमक फिर से इस बिंदु के ऊपरी गोलार्ध के सभी संभावित दिशाओं से गिरने वाली रोशनी पर निर्भर करती है। सभी गणना दोहराई जाती है।

यहाँ क्या होता है, यह एक असीम रूप से पुनरावर्ती अभिन्न समीकरण है जिसमें एकीकरण के गोलार्ध क्षेत्रों की एक अनंत संख्या है। हम इस समीकरण को सीधे हल नहीं कर सकते हैं, लेकिन एक काफी सरल समाधान है।

---

¹ इसके बारे में मत भूलना! हम अक्सर कोसाइन के बारे में बात करेंगे, और हम स्केलर उत्पाद को हमेशा ध्यान में रखेंगे। क्योंकि $$$\ vec {a} \ cdot \ vec {b} = \ | \ vec {a \ _ \ _ \ _ | \ vec {b} \ | \ cos (\ theta)$ , और हम दिशाओं (यूनिट वैक्टर) के साथ काम कर रहे हैं, तो स्केलर उत्पाद अधिकांश कंप्यूटर ग्राफिक्स कार्यों में कोसाइन है।

मोंटे कार्लो बचाव के लिए आता है

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

$$

$$F_N \ अनुमानित \ frac {1} {N} \ sum_ {n = 0} ^ {N} {\ frac {f (x_n)} {p (x_n)}}$$

इसलिए, समारोह का अभिन्न अंग $$$च (x_n)$ एकीकरण डोमेन में यादृच्छिक नमूनों के औसत से लगभग गणना की जा सकती है। प्रत्येक नमूने को उसके चयन की संभावना से विभाजित किया गया है। $$$p (x_n)$ । इसके कारण, अधिक बार चुने गए नमूने में कम चुने गए एक से अधिक वजन होगा।

गोलार्ध में समान नमूनों के मामले में (प्रत्येक दिशा में चयनित होने की समान संभावना है), नमूनों की संभावना निरंतर हो सकती है: $$$p (\ omega) = \ frac {1} {2 \ pi}$ (क्योंकि $$$2 \ pi$ एक गोलार्ध का सतह क्षेत्र है)। यदि हम यह सब एक साथ करते हैं, तो हमें निम्नलिखित मिलते हैं:

$$

$$L (x, \, \ vec \ omega_ {o}) \ अनुमानित L_e (x, \, \ vec \ omega_ {o}) + \ frac {1} {N} \ sum_ / n = 0} ^ {N } {\ color {Green} {2 \ pi \, f_r (x, \, \ vec \ omega_ {i}, \, \ vec \ omega_ {o}) \ _, (\ vec \ nomega_ {i} \ cdot \ _ vec n)} \ _, एल (x, \, \ vec \ omega_ {i})}$$

विकिरण $$$L_e (x, \, \ vec \ omega_ {o})$ क्या सिर्फ हमारे Shade फ़ंक्शन द्वारा वापस लौटाया गया मान है। $$$\ frac {1} {N}$ पहले से ही हमारे AddShader फ़ंक्शन में चल रहा है। द्वारा गुणा करना $$$L (x, \, \ vec \ omega_ {i})$ तब होता है जब हम किरण को प्रतिबिंबित करते हैं और इसे आगे ट्रेस करते हैं। हमारा काम समीकरण के हरे हिस्से को जीवन देना है।

आवश्यक शर्तें

एक यात्रा पर जाने से पहले, आइए कुछ पहलुओं का ध्यान रखें: नमूने एकत्रित करना, नियतात्मक दृश्य, और शेडर यादृच्छिकता।

संचय

किसी कारण के लिए, एकता ने मुझे OnRenderImage में destination रूप में एचडीआर बनावट पास नहीं किया destination । R8G8B8A8_Typeless प्रारूप ने मेरे लिए काम किया, इसलिए बड़ी संख्या में नमूने संचित करने के लिए सटीकता बहुत कम हो जाती है। इसे संभालने के लिए, आइए private RenderTexture _converged को C # private RenderTexture _converged । यह हमारा बफ़र होगा, स्क्रीन पर उन्हें प्रदर्शित करने से पहले उच्च सटीकता के साथ परिणाम। हम InitRenderTexture फंक्शन में _target तरह ही टेक्सचर को इनिशियलाइज़ / रिलीज़ करते हैं। Render फ़ंक्शन में, डबल ब्लिटिंग:

 Graphics.Blit(_target, _converged, _addMaterial); Graphics.Blit(_converged, destination); 

नियतात्मक दृश्य

प्रभाव का मूल्यांकन करने के लिए प्रतिपादन में परिवर्तन करते समय, पिछले परिणामों की तुलना करना उपयोगी होता है। अब तक, प्ले मोड के प्रत्येक पुनरारंभ या स्क्रिप्ट के पुनर्संयोजन के साथ, हमें एक नया यादृच्छिक दृश्य मिलेगा। इससे बचने के लिए, सी # public int SphereSeed और SetUpScene की शुरुआत में निम्नलिखित पंक्ति में public int SphereSeed जोड़ें:

 Random.InitState(SphereSeed); 

अब हम मैन्युअल रूप से बीज दृश्यों को सेट कर सकते हैं। कोई भी नंबर दर्ज करें और जब तक आपको सही दृश्य नहीं मिलता है तब तक RayTracingMaster / चालू करें।

नमूना छवियों के लिए निम्नलिखित मापदंडों का उपयोग किया गया था: स्फेयर सीड 1223832719, स्फेयर रेडियस [5, 30], क्षेत्रों मैक्स 10000, स्फेयर प्लेसमेंट रेडियस 100।

सुडौल यादृच्छिकता

स्टोचस्टिक सैंपलिंग शुरू करने से पहले, हमें शेडर में यादृच्छिकता जोड़ना होगा। मैं सुविधा के लिए संशोधित कैनोनिकल स्ट्रिंग का उपयोग करूँगा, जो सुविधा के लिए संशोधित है:

 float2 _Pixel; float _Seed; float rand() { float result = frac(sin(_Seed / 100.0f * dot(_Pixel, float2(12.9898f, 78.233f))) * 43758.5453f); _Seed += 1.0f; return result; } 

_Pixel सीधे CSMain को _Pixel = id.xy CSMain रूप में प्रारंभ करें ताकि प्रत्येक पिक्सेल विभिन्न यादृच्छिक मानों का उपयोग कर सके। _Seed SetShaderParameters फ़ंक्शन में C # से प्रारंभ किया जाता है।

 RayTracingShader.SetFloat("_Seed", Random.value); 

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

गोलार्ध का नमूना

आइए फिर से शुरू करें: हमें गोलार्ध में समान रूप से वितरित यादृच्छिक दिशाओं की आवश्यकता है। कोरी साइमन के इस लेख में पूर्ण दायरे के लिए गैर-तुच्छ कार्य का विस्तार से वर्णन किया गया है। गोलार्ध के लिए अनुकूल करना आसान है। यहाँ shader कोड कैसा दिखता है:

 float3 SampleHemisphere(float3 normal) { //     float cosTheta = rand(); float sinTheta = sqrt(max(0.0f, 1.0f - cosTheta * cosTheta)); float phi = 2 * PI * rand(); float3 tangentSpaceDir = float3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta); //      return mul(tangentSpaceDir, GetTangentSpace(normal)); } 

सकारात्मक जेड अक्ष पर केंद्रित गोलार्ध के लिए दिशाएं उत्पन्न होती हैं, इसलिए हमें उन्हें बदलने की आवश्यकता है ताकि वे वांछित सामान्य पर केंद्रित हों। हम एक स्पर्शरेखा और द्विपद (दो वैक्टर ऑर्थोगोनल को सामान्य और एक-दूसरे को ऑर्थोगोनल उत्पन्न करते हैं)। पहले, हम स्पर्शरेखा उत्पन्न करने के लिए एक सहायक वेक्टर का चयन करते हैं। ऐसा करने के लिए, हम सकारात्मक एक्स अक्ष लेते हैं, और सकारात्मक जेड पर वापस जाते हैं केवल अगर यह सामान्य रूप से (लगभग) एक्स अक्ष के साथ गठबंधन किया जाता है। तो हम स्पर्शरेखा उत्पन्न करने के लिए वेक्टर उत्पाद का उपयोग कर सकते हैं, और फिर असामान्य।

 float3x3 GetTangentSpace(float3 normal) { //       float3 helper = float3(1, 0, 0); if (abs(normal.x) > 0.99f) helper = float3(0, 0, 1); //   float3 tangent = normalize(cross(normal, helper)); float3 binormal = normalize(cross(normal, tangent)); return float3x3(tangent, binormal, normal); } 

लैम्बर्ट बिखरना

अब जब हमारे पास एक समान यादृच्छिक दिशाएँ हैं, तो हम पहले BRDF के कार्यान्वयन के साथ आगे बढ़ सकते हैं। फैलाना प्रतिबिंब के लिए, सबसे अधिक इस्तेमाल किया जाता है लैम्बर्ट बीआरडीएफ, जो आश्चर्यजनक रूप से सरल है: $$$f_r (x, \, \ vec \ omega_ {i}, \, \ vec \ omega_ {o}) = \ frac {k_d} {\ pi}$ जहाँ $$$k_d$ - यह अल्बेडो सतह है। आइए इसे हमारे मोंटे कार्लो प्रतिपादन समीकरण में डालें (मैं अभी तक एमिसिटी को ध्यान में नहीं रखूंगा) और देखें कि क्या होता है:

$$

$$L (x, \, \ vec \ omega_ {o}) \ लगभग \ frac {1} {N} \ sum_ {n = 0} ^ {N} {\ n रंग {BlueViolet} {2 k_d_ \ _ (\ _) vec \ omega_ {i} \ cdot \ vec n) \, L (x, \, \ vec \ omega_ {i})}$$

आइए इस समीकरण को अभी शेडर में डालें। Shade फ़ंक्शन में, कोड को प्रतिस्थापित करें if (hit.distance < 1.#INF) निर्माण निम्न पंक्तियों के साथ होता है:

 //   ray.origin = hit.position + hit.normal * 0.001f; ray.direction = SampleHemisphere(hit.normal); ray.energy *= 2 * hit.albedo * sdot(hit.normal, ray.direction); return 0.0f; 

परावर्तित बीम की नई दिशा सजातीय गोलार्ध के नमूनों के हमारे कार्य का उपयोग करके निर्धारित की जाती है। बीम की ऊर्जा ऊपर दिखाए गए समीकरण के संबंधित भाग से गुणा की जाती है। चूंकि सतह किसी भी रोशनी का उत्सर्जन नहीं करती है (यह केवल आकाश से प्रत्यक्ष या अप्रत्यक्ष रूप से प्राप्त प्रकाश को दर्शाती है), हम 0. वापस आते हैं। यहाँ, यह मत भूलो कि AddShader के नमूने औसत हैं, इसलिए हमें चिंता करने की आवश्यकता नहीं है। $$$\ frac {1} {N} \ sum$ । CSMain पहले से गुणा शामिल है $$$L (x, \, \ vec \ omega_ {i})$ (अगला प्रतिबिंबित बीम), इसलिए हमारे पास बहुत काम नहीं बचा है।

sdot एक सहायक कार्य है जिसे मैंने अपने लिए परिभाषित किया है। यह एक अतिरिक्त गुणांक के साथ स्केलर उत्पाद का परिणाम देता है, और फिर इसे अंतराल तक सीमित करता है $$$[0,1]$ :

 float sdot(float3 x, float3 y, float f = 1.0f) { return saturate(dot(x, y) * f); } 

आइए संक्षेप में बताएं कि हमारा कोड अब तक क्या कर रहा है। CSMain कैमरे की प्राथमिक किरणों को उत्पन्न करता है और Shade कॉल करता है। सतह को पार करते समय, यह फ़ंक्शन बदले में एक नया बीम (सामान्य रूप से गोलार्ध में समान रूप से यादृच्छिक) उत्पन्न करता है और बीम की ऊर्जा में सामग्री और कोसाइन के बीआरडीएफ को ध्यान में रखता है। आकाश के साथ किरण के चौराहे पर, हम एचडीआरआई (रोशनी का एकमात्र स्रोत) का नमूना लेते हैं और रोशनी को लौटाते हैं, जो किरण की ऊर्जा से गुणा किया जाता है (यानी सभी पिछले चौराहों का परिणाम, कैमरे से शुरू होता है)। यह एक साधारण नमूना है जो एक अभिसरण परिणाम के साथ मिश्रित होता है। नतीजतन, प्रभाव को प्रत्येक नमूने में ध्यान में रखा जाता है। $$$\ frac {1} {N}$ ।

काम में सब कुछ जांचने का समय है। चूंकि धातुओं में विसरित प्रतिबिंब नहीं होता है, इसलिए आइए अब उनके लिए C # स्क्रिप्ट के SetUpScene फ़ंक्शन को बंद करें (लेकिन फिर भी दृश्य के Random.value को बनाए रखने के लिए यहां Random.value को कॉल करें):

 bool metal = Random.value < 0.0f; 

प्ले मोड लॉन्च करें और देखें कि शुरू में शोर वाली छवि को कैसे साफ़ किया जाता है और एक सुंदर प्रतिपादन में परिवर्तित होता है:

फोंग मिरर इमेज

कोड की कुछ पंक्तियों के लिए बुरा नहीं है (और गणित का एक छोटा सा अंश)। आइए Phong के BRDF का उपयोग करके दर्पण प्रतिबिंबों को जोड़कर चित्र को परिष्कृत करें। फोंग के मूल सूत्रीकरण में इसकी समस्याएं (रिश्तों की कमी और ऊर्जा संरक्षण) थीं, लेकिन सौभाग्य से अन्य लोगों ने उन्हें समाप्त कर दिया । बढ़ा हुआ BRDF नीचे दिखाया गया है। $$$\ vec \ omega_ {r}$ पूरी तरह से प्रतिबिंबित प्रकाश की दिशा है, और $$$\ अल्फा$ एक फोंग इंडिकेटर है जो खुरदरापन को नियंत्रित करता है:

$$

$$f_r (x, \, \ vec \ omega_ {i}, \, \ vec \ omega_ {o}) = k_s \, \ frac {\ अल्फा + 2} {2 \ pi} \ (\ vec \ omega_ {) r} \ cdot \ vec \ omega_ {o}) ^ \ Alpha$$

एक इंटरैक्टिव द्वि-आयामी ग्राफ दिखाता है कि जब Phong के लिए BRDF कैसा दिखता है $$$\ अल्फा = 15$ 45 ° के कोण पर एक बीम घटना के लिए। मान बदलने का प्रयास करें। $$$\ अल्फा$ ।

इसे हमारे मोंटे कार्लो प्रतिपादन समीकरण में पेस्ट करें:

$$

$$L (x, \, \ vec \ omega_ {o}) \ लगभग \ frac {1} {N} \ sum_ {n = 0} ^ {N} {\ color {brown} {k_s \ _, (\ Alpha +) 2) \, (\ vec \ omega_ {r} \ cdot \ vec \ omega_ {o}) ^ \ Alpha} \, (\ vec \ omega_ {i} \ cdot \ vec n \ _, L (x, \), \ vec \ omega_ {i})}$$

और अंत में, आइए इसे मौजूदा लैम्बर्ट BRDF में जोड़ें:

$$

$$L (x, \, \ vec \ omega_ {o}) \ लगभग \ frac {1} {N} \ sum_ {n = 0} ^ {N} {[\ _ {color_vilViolet} {2 k_n} + \ color {भूरा} {k_s \ _, (\ अल्फा + 2) \, (\ vec \ omega_ {r} \ cdot \ vec \ omega_ {o}) ^ \ Alpha}] \ _, (\ vec \ nomega_ {i} \ cdot \ vec n) \, L (x, \, \ vec \ omega_ {i})}$$

और इस तरह वे लैम्बर्ट बिखरने के साथ कोड में दिखते हैं:

 //    ray.origin = hit.position + hit.normal * 0.001f; float3 reflected = reflect(ray.direction, hit.normal); ray.direction = SampleHemisphere(hit.normal); float3 diffuse = 2 * min(1.0f - hit.specular, hit.albedo); float alpha = 15.0f; float3 specular = hit.specular * (alpha + 2) * pow(sdot(ray.direction, reflected), alpha); ray.energy *= (diffuse + specular) * sdot(hit.normal, ray.direction); return 0.0f; 

ध्यान दें कि हमने स्केलर उत्पाद को थोड़ा अलग, लेकिन समकक्ष (प्रतिबिंबित) के साथ बदल दिया $$$\ _ omega_o$ के बजाय $$$\ _ omega_i$ )। अब मेटल मटेरियल को वापस SetUpScene फंक्शन्स में बदल SetUpScene और देखें कि यह कैसे काम करता है।

विभिन्न मूल्यों के साथ प्रयोग $$$\ अल्फा$ , आप एक समस्या देख सकते हैं: यहां तक ​​कि कम प्रदर्शन में अभिसरण के लिए बहुत समय की आवश्यकता होती है, और उच्च प्रदर्शन पर शोर विशेष रूप से हड़ताली होता है। प्रतीक्षा के कुछ मिनटों के बाद भी, परिणाम आदर्श से बहुत दूर है, जो इस तरह के एक सरल दृश्य के लिए अस्वीकार्य है। $$$\ अल्फा = 15$ और $$$\ अल्फा = 300$ 8192 नमूने इस तरह दिखते हैं:



ऐसा क्यों हुआ? आखिरकार, इससे पहले कि हम इस तरह के सुंदर आदर्श प्रतिबिंब थे ( $$$\ अल्फा = \ infty$ )! .. समस्या यह है कि हम सजातीय नमूने उत्पन्न करते हैं और उन्हें बीआरडीएफ के अनुसार वजन प्रदान करते हैं। उच्च फोंग मूल्यों के साथ, बीआरडीएफ सभी के लिए छोटा है, लेकिन ये दिशाएं पूर्ण प्रतिबिंब के बहुत करीब हैं, और यह बहुत संभावना नहीं है कि हम बेतरतीब ढंग से अपने सजातीय नमूनों का उपयोग करके उनका चयन करेंगे। दूसरी ओर, यदि हम वास्तव में इनमें से किसी एक दिशा को पार करते हैं, तो बीआरडीएफ अन्य सभी छोटे नमूनों की भरपाई के लिए बहुत बड़ा होगा। परिणाम एक बहुत बड़ा फैलाव है। कई स्पेकुलर रिफ्लेक्शंस वाले रास्ते और भी खराब हैं और नतीजा इमेजों में दिखाई देता है।

बढ़ा हुआ नमूना

अपने पथ अनुचर को व्यावहारिक बनाने के लिए, हमें प्रतिमान बदलने की जरूरत है। उन क्षेत्रों में कीमती नमूनों को बर्बाद करने के बजाय जिसमें वे महत्वहीन हो जाते हैं (क्योंकि वे बहुत कम बीआरडीएफ और / या कोसाइन मूल्य प्राप्त करते हैं), चलो महत्वपूर्ण नमूने उत्पन्न करते हैं ।

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

 //       hit.albedo = min(1.0f - hit.specular, hit.albedo); float specChance = energy(hit.specular); float diffChance = energy(hit.albedo); float sum = specChance + diffChance; specChance /= sum; diffChance /= sum; //     float roulette = rand(); if (roulette < specChance) { //   ray.origin = hit.position + hit.normal * 0.001f; ray.direction = reflect(ray.direction, hit.normal); ray.energy *= (1.0f / specChance) * hit.specular * sdot(hit.normal, ray.direction); } else { //   ray.origin = hit.position + hit.normal * 0.001f; ray.direction = SampleHemisphere(hit.normal); ray.energy *= (1.0f / diffChance) * 2 * hit.albedo * sdot(hit.normal, ray.direction); } return 0.0f; 

energy एक छोटा सहायक कार्य है जो औसत रंग चैनल:

 float energy(float3 color) { return dot(color, 1.0f / 3.0f); } 

इसलिए हमने पिछले भाग से एक अधिक सुंदर Whited ray tracer बनाया, लेकिन अब असली फैलाना छायांकन के साथ (जो मुलायम छाया, परिवेश रोड़ा, वैश्विक प्रकाश को फैलाता है):

महत्व का नमूना

आइए मूल मोंटे कार्लो सूत्र पर एक और नज़र डालते हैं:

$$

$$F_N \ अनुमानित \ frac {1} {N} \ sum_ {n = 0} ^ {N} {\ frac {f (x_n)} {p (x_n)}}$$

जैसा कि आप देख सकते हैं, हम इस विशेष नमूने को चुनने की संभावना पर प्रत्येक नमूने (नमूना) के प्रभाव को विभाजित करते हैं। अब तक, हमने सजातीय गोलार्ध के नमूनों का उपयोग किया है, इसलिए हमारे पास एक निरंतर था $$$p (\ omega) = \ frac {1} {2 \ pi}$ । जैसा कि हमने ऊपर देखा, यह इष्टतम से बहुत दूर है, उदाहरण के लिए, फोंग बीआरडीएफ के मामले में, जो बहुत कम संख्या में दिशाओं में बड़ा है।

कल्पना करें कि हम एक पूर्णांक मिलान योग्य फल वितरण की संभावना प्राप्त कर सकते हैं: $$$p (x) = f (x)$ । फिर निम्नलिखित होगा:

$$

$$F_N \ लगभग \ frac {1} {N} \ sum_ {n = 0} ^ {N} {1}$$

अब हमारे पास कोई नमूना नहीं है जो बहुत कम योगदान देता है। इन नमूनों का चयन होने की संभावना कम होगी। यह परिणाम के विचरण को काफी कम कर देगा और प्रतिपादन के अभिसरण को गति देगा।

व्यवहार में, इस तरह के एक आदर्श वितरण को खोजना असंभव है, क्योंकि पूर्णांक फ़ंक्शन के कुछ हिस्से (हमारे मामले में BRDF × cosine × घटना प्रकाश) अज्ञात हैं (यह घटना प्रकाश के लिए सबसे अधिक स्पष्ट है), लेकिन BRDF × कोसाइन के अनुसार नमूनों का वितरण या यहां तक ​​कि केवल BRDF के अनुसार नमूनों की मदद मिलेगी हमें। इस सिद्धांत को महत्व द्वारा नमूना कहा जाता है।

कोसाइन नमूना

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

थॉमस पोले के इस लेख में बताया गया है कि यह कैसे करना है। हम alpha पैरामीटर को अपने SampleHemisphere फ़ंक्शन में जोड़ देंगे। फ़ंक्शन कोसीन्स के चयन के सूचकांक को निर्धारित करता है: 0 एक समान नमूने के लिए, 1 कोसाइन के चयन के लिए, या फोंग के उच्च मूल्यों के लिए उच्चतर। कोड में, यह इस तरह दिखता है:

 float3 SampleHemisphere(float3 normal, float alpha) { //  ,      float cosTheta = pow(rand(), 1.0f / (alpha + 1.0f)); float sinTheta = sqrt(1.0f - cosTheta * cosTheta); float phi = 2 * PI * rand(); float3 tangentSpaceDir = float3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta); //      return mul(tangentSpaceDir, GetTangentSpace(normal)); } 

अब प्रत्येक नमूने की संभावना बराबर है $$$p (\ omega) = \ frac {\ अल्फा + 1} {2 \ pi} \, (\ vec \ omega \ cdot \ vec n) ^ \ अल्फा$ । इस समीकरण की सुंदरता तुरंत स्पष्ट नहीं लग सकती है, लेकिन थोड़ी देर बाद आप इसे समझेंगे।

महत्व द्वारा लैम्बर्ट नमूना

शुरुआत के लिए, हम फैलाने वाले प्रतिबिंब प्रतिपादन को परिष्कृत करेंगे। हमारे सजातीय वितरण में, लैम्बर्ट निरंतर बीआरडीएफ पहले से ही उपयोग किया जाता है, लेकिन हम इसे कॉशन जोड़कर सुधार कर सकते हैं। कोसाइन द्वारा नमूना की संभावना वितरण (जहां) $$$\ अल्फा = 1$ ) बराबर है $$$\ frac {(\ vec \ omega_ {i} \ cdot \ vec n)} {\ pi}$ , जो विसरित प्रतिबिंब के लिए हमारे मोंटे कार्लो सूत्र को सरल बनाता है:

$$

$$L (x, \, \ vec \ omega_ {o}) \ लगभग \ frac {1} {N} \ sum_ {n = 0} ^ {N} {\ n {{नीला रंग} {k_d} \ _, L (x) ,, \ vec \ omega_ {i})}$$

 //   ray.origin = hit.position + hit.normal * 0.001f; ray.direction = SampleHemisphere(hit.normal, 1.0f); ray.energy *= (1.0f / diffChance) * hit.albedo; 

यह हमारे प्रसार को थोड़ा बढ़ाकर गति देगा। अब चलिए असली मुद्दे पर आते हैं।

Fongov महत्व से नमूना

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

आइए, ऊपर दिए गए उदाहरणों से Phong समीकरण में संभाव्यता वितरण डालें। लाफ्यून और विलेम्स में एक विस्तृत निष्कर्ष पाया जा सकता है : शारीरिक रूप से आधारित प्रतिपादन के लिए संशोधित फोंग परावर्तन मॉडल का उपयोग करना (1994) :

$$

$$L (x, \, \ vec \ omega_ {o}) \ लगभग \ frac {1} {N} \ sum_ {n = 0} ^ {N} {\ color {brown} {k_s \, \ _ \ _ \ _ \ _ \ _ अल्फ़ा + २} {\ अल्फ़ा + १}}}, (\ vec \ omega_ {i} \ cdot \ vec n) \, L (x, \, \ vec \ omega_ {i})$$

 //   float alpha = 15.0f; ray.origin = hit.position + hit.normal * 0.001f; ray.direction = SampleHemisphere(reflect(ray.direction, hit.normal), alpha); float f = (alpha + 2) / (alpha + 1); ray.energy *= (1.0f / specChance) * hit.specular * sdot(hit.normal, ray.direction, f); 

ये परिवर्तन फोंग में उच्च प्रदर्शन के साथ किसी भी समस्या को खत्म करने के लिए पर्याप्त हैं और हमारे प्रतिपादन को अधिक उचित समय में परिवर्तित करते हैं।

सामग्री

अंत में, आइए अपनी दृश्य पीढ़ी का विस्तार करें और गोले की चिकनाई और उत्सर्जन के लिए बदलते मूल्य बनाएं! C # स्क्रिप्ट से struct Sphere , public float smoothness और public Vector3 emission । चूंकि हमने संरचना के आकार को बदल दिया है, हमें कम्प्यूट बफ़र (4 × फ्लोट संख्या की संख्या, याद रखना?) बनाते समय कदम बदलने की आवश्यकता है। चिकनाई और SetUpScene लिए SetUpScene फ़ंक्शन सम्मिलित मान बनाएँ।

शेडर में, दोनों क्षेत्रों को struct Sphere और struct RayHit , और फिर CreateRayHit में उन्हें प्रारंभ करें। और अंत में, IntersectGroundPlane (हार्डकोड, कोई भी मान पेस्ट करें) और IntersectSphere ( Sphere से मान प्राप्त करना) दोनों मान सेट करें।

मैं उसी तरह से चिकनाई मूल्यों का उपयोग करना चाहता हूं जैसे कि मानक यूनिटी शेडर, जो कि एक मनमाने ढंग से फोंग एक्सपोनेंट से भिन्न होता है। यहाँ एक अच्छा रूपांतरण है जिसे Shade फ़ंक्शन में उपयोग किया जा सकता है:

 float SmoothnessToPhongAlpha(float s) { return pow(1000.0f, s * s); } 

 float alpha = SmoothnessToPhongAlpha(hit.smoothness); 

Shade में एक मान लौटाकर उत्सर्जन का उपयोग किया जाता है:

 return hit.emission; 

परिणाम

गहरी सांस लें। आराम करें और तब तक प्रतीक्षा करें जब तक कि छवि इतनी खूबसूरत तस्वीर में न बदल जाए:


बधाई! आप गणितीय अभिव्यक्तियों की थाप के माध्यम से प्राप्त करने में कामयाब रहे। हमने एक पथ अनुरेखक लागू किया है जो फैलाना और दर्पण छायांकन करता है, महत्व के अनुसार नमूने के बारे में सीखा है, तुरंत इस अवधारणा को लागू करता है ताकि प्रतिपादन मिनटों में, घंटों या दिनों में परिवर्तित हो।

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

पढ़ने के लिए धन्यवाद! तीसरे भाग में, हम (थोड़ी देर के लिए) नमूने और छायांकन के जंगल को छोड़ देंगे, और सज्जनों मोलर और ट्रंबोर से मिलने के लिए सभ्यता में लौट आएंगे। हमें उनसे त्रिकोण के बारे में बात करनी होगी।

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