ओपनजीएल जानें। पाठ 6.4 - IBL। स्पेक्युलर एक्सपोज़र

पिछले पाठ में, हमने IBL विधि के साथ काम करने के लिए अपना PBR मॉडल तैयार किया - इसके लिए हमें पहले से एक विकिरण मानचित्र तैयार करने की आवश्यकता थी जो अप्रत्यक्ष रोशनी के फैलने वाले हिस्से का वर्णन करता है। इस पाठ में हम प्रतिबिंबितता की अभिव्यक्ति के दूसरे भाग पर ध्यान देंगे - दर्पण:

$$

$$L_o (p, \ omega_o) = \ int \ limit _ {\ _ Omega} (k_d \ frac {c} {\ pi} + k_s \ frac {DFG} {4 (\ nomega_o \ cdot n) (\ omega_i \ cdot n )}) L_i (p, \ omega_i) n \ cdot \ omega_i d \ omega_i$$

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

इस दृष्टिकोण में, परावर्तन अभिव्यक्ति के दर्पण घटक को दो भागों में विभाजित किया गया है, जिसे व्यक्तिगत रूप से पूर्व-दोषी ठहराया जा सकता है और फिर एक PBR shader में संयुक्त रूप से अप्रत्यक्ष स्पेक्युलर विकिरण के स्रोत के रूप में उपयोग किया जा सकता है। विकिरण मानचित्र निर्माण के साथ, कनवल्शन प्रक्रिया को इसके इनपुट पर एक एचडीआर पर्यावरण मानचित्र प्राप्त होता है।

विभाजन-योग सन्निकटन विधि को समझने के लिए, आइए हम परावर्तन की अभिव्यक्ति को फिर से देखें, इसमें दर्पण घटक के लिए केवल उपप्राथमिकता को छोड़ दें ( पिछले पाठ में विसरित भाग को अलग से माना गया था):

$$

$$L_o (p, \ omega_o) = \ int \ limit _ {\ _ Omega} (k_s \ frac {DFG} {4 (\ omega_o \ cdot n) (\ omega_o \ _ cdot n)} L_i (p, \ omega_i) n \ n cdot \ omega_i d \ omega_i = \ int \ limit _ {\ _ Omega} f_r (p, \ omega_i, \ omega_o) L_i (p, \ omega_i) n \ cdot \ omega_i d \ omega_i$$

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

$$

$$f_r (p, w_i, w_o) = \ frac {DFG} {4 (\ omega_o \ cdot n) (\ omega_i \ cdot n)}$$

अभिन्न के तहत अभिव्यक्ति पर भी निर्भर करता है $$$\ _ omega_o$ - दो दिशा वाले वैक्टर के लिए, पहले से तैयार क्यूबिक मैप से चयन करना लगभग असंभव है। बिंदु स्थिति $$$पी$ इस मामले में, आप इस पर ध्यान नहीं दे सकते हैं - पिछले पाठ में इस पर चर्चा क्यों की गई थी। सभी संभावित संयोजनों के लिए अभिन्न की प्रारंभिक गणना $$$\ _ omega_i$ और $$$\ _ omega_o$ वास्तविक समय कार्यों में असंभव है।

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

$$

$$L_o (p, \ omega_o) = \ int \ limit _ {\ _ Omega} L_i (p, \ omega_i) d \ omega_i * \ int \ limit \ _ \ _ Omega }__r (p, \ omega_i, \ omega_o) n \ cdot \ _ omega_i d \ omega_i$$

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


सैंपल वैक्टर और उनका प्रसार कुक-टॉरेंस बीआरडीएफ मॉडल के सामान्य वितरण समारोह ( एनडीएफ ) के आधार पर निर्धारित किया जाता है। यह फ़ंक्शन सामान्य वेक्टर और इनपुट मापदंडों के रूप में अवलोकन की दिशा को स्वीकार करता है। चूंकि प्रारंभिक गणना के समय अवलोकन की दिशा पहले से ज्ञात नहीं है, इसलिए एपिक गेम्स डेवलपर्स को एक और धारणा बनानी पड़ी: टकटकी की दिशा (और इसलिए स्पेक्युलर परावर्तन की दिशा) हमेशा नमूना की आउटपुट दिशा के समान होती है। $$$\ _ omega_o$ । कोड के रूप में:

vec3 N = normalize(w_o); vec3 R = N; vec3 V = R; 

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


विभाजन-योग अभिव्यक्ति के दूसरे भाग में दर्पण घटक के लिए मूल अभिव्यक्ति का BRDF शामिल है। यह मानते हुए कि आने वाली ऊर्जा चमक को सभी दिशाओं के लिए सफेद रोशनी द्वारा दर्शाया गया है (अर्थात। $$$L (p, x) = 1.0$ ), निम्नलिखित इनपुट मापदंडों के साथ BRDF के लिए मूल्य की पूर्व-गणना करना संभव है: सामग्री खुरदरापन और सामान्य के बीच का कोण $$$एन$ और प्रकाश की दिशा $$$\ _ omega_i$ (या $$$n \ cdot \ omega_i$ )। महाकाव्य खेलों के दृष्टिकोण में खुरदरापन के प्रत्येक संयोजन के लिए BRDF गणना के परिणामों को संग्रहीत करना और सामान्य और प्रकाश के बीच कोण को द्वि-आयामी बनावट के रूप में जाना जाता है जिसे BRDF एकीकरण मानचित्र के रूप में जाना जाता है, जिसे बाद में लुक-अप टेबल ( LUT ) के रूप में उपयोग किया जाता है। । यह संदर्भ बनावट सतह के फ्रेसेल गुणांक की गणना के लिए पैमाने और ऑफसेट को स्टोर करने के लिए लाल और हरे रंग के आउटपुट चैनलों का उपयोग करता है, जो अंततः हमें अलग-अलग राशि के लिए अभिव्यक्ति के दूसरे भाग को हल करने की अनुमति देता है:


यह सहायक बनावट इस प्रकार बनाई गई है: क्षैतिज बनावट निर्देशांक ([0., 1. से लेकर) को इनपुट पैरामीटर मान के रूप में माना जाता है $$$n \ cdot \ omega_i$ बीआरडीएफ कार्य; ऊर्ध्वाधर बनावट निर्देशांक इनपुट खुरदरापन मान के रूप में माना जाता है।

नतीजतन, इस तरह के एकीकरण का नक्शा और एक पूर्व-संसाधित पर्यावरण मानचित्र होने के कारण, आप दर्पण घटक के अभिन्न अभिव्यक्ति के अंतिम मूल्य को प्राप्त करने के लिए उनसे नमूनों को जोड़ सकते हैं:

 float lod = getMipLevelFromRoughness(roughness); vec3 prefilteredColor = textureCubeLod(PrefilteredEnvMap, refVec, lod); vec2 envBRDF = texture2D(BRDFIntegrationMap, vec2(NdotV, roughness)).xy; vec3 indirectSpecular = prefilteredColor * (F * envBRDF.x + envBRDF.y) 

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

एचडीआर पर्यावरण मानचित्र को पूर्व फ़िल्टर करना

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

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

 unsigned int prefilterMap; glGenTextures(1, &prefilterMap); glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap); for (unsigned int i = 0; i < 6; ++i) { glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 128, 128, 0, GL_RGB, GL_FLOAT, nullptr); } glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenerateMipmap(GL_TEXTURE_CUBE_MAP); 

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

पिछले पाठ में, हमने सैंपल वैक्टर बनाकर पर्यावरण के नक्शे का विश्वास दिलाया जो समान रूप से गोलार्ध में वितरित किया जाता है $$$\ _ ओमेगा$ गोलाकार निर्देशांक का उपयोग करना। विकिरण को प्राप्त करने के लिए, यह विधि काफी प्रभावी है, जिसे स्पेक्युलर प्रतिबिंबों की गणना के बारे में नहीं कहा जा सकता है। स्पेक्युलर हाइलाइट्स की भौतिकी हमें बताती है कि परावर्तित रूप से परावर्तित प्रकाश की दिशा परावर्तित वेक्टर के समीप होती है $$$आर$ एक सामान्य सतह के लिए $$$एन$ भले ही खुरदरापन शून्य न हो:


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

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

मोंटे कार्लो एकीकरण और महत्व का नमूना

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

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

$$

$$O = \ int \ limit_ {a} ^ {b} f (x) dx = \ frac {1} {N} \ sum_ {i = 0} ^ {N-1} \ frac {f (x)} { pdf (x)}$$

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


यह देखा जा सकता है कि यादृच्छिक नमूने बिंदुओं का उपयोग करते समय, हमारे पास 150 सेमी की वृद्धि वाले किसी व्यक्ति की तुलना में 170 सेमी के विकास मूल्य को पूरा करने की बहुत अधिक संभावना है।

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

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

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

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


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

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

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

कम बेमेल अनुक्रम

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

ट्रिकी बिटवाइज़ अंकगणित ट्रिक्स का उपयोग करते हुए, आप काफी कुशलता से वैन डेर कोर्पुट अनुक्रम को सीधे शेडर में सेट कर सकते हैं और इसके आधार पर चयन से हैमरस्ली अनुक्रम का i-th तत्व बनाते हैं $$$एन$ तत्वों:

 float RadicalInverse_VdC(uint bits) { bits = (bits << 16u) | (bits >> 16u); bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u); bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u); bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u); bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u); return float(bits) * 2.3283064365386963e-10; // / 0x100000000 } // ---------------------------------------------------------------------------- vec2 Hammersley(uint i, uint N) { return vec2(float(i)/float(N), RadicalInverse_VdC(i)); } 

हैमर्सली () कई आकार के नमूनों से कम बेमेल अनुक्रम के ith तत्व को लौटाता है $$$एन$ ।

सभी OpenGL ड्राइवर बिटवाइज़ ऑपरेशंस (उदाहरण के लिए WebGL और OpenGL ES 2.0) का समर्थन नहीं करते हैं, इसलिए कुछ निश्चित वातावरणों के लिए, उनके उपयोग के वैकल्पिक कार्यान्वयन की आवश्यकता हो सकती है:

 float VanDerCorpus(uint n, uint base) { float invBase = 1.0 / float(base); float denom = 1.0; float result = 0.0; for(uint i = 0u; i < 32u; ++i) { if(n > 0u) { denom = mod(float(n), 2.0); result += denom * invBase; invBase = invBase / 2.0; n = uint(float(n) / 2.0); } } return result; } // ---------------------------------------------------------------------------- vec2 HammersleyNoBitOps(uint i, uint N) { return vec2(float(i)/float(N), VanDerCorpus(i, 2u)); } 

मैं ध्यान देता हूं कि पुराने हार्डवेयर में साइकिल ऑपरेटरों पर कुछ प्रतिबंधों के कारण, यह कार्यान्वयन सभी 32 बिट्स से होकर गुजरता है। नतीजतन, यह संस्करण पहले विकल्प के रूप में उत्पादक नहीं है - लेकिन यह किसी भी हार्डवेयर पर काम करता है, और यहां तक ​​कि बिट संचालन की अनुपस्थिति में भी।

जीजीएक्स मॉडल में महत्व नमूना

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

 const uint SAMPLE_COUNT = 4096u; for(uint i = 0u; i < SAMPLE_COUNT; ++i) { vec2 Xi = Hammersley(i, SAMPLE_COUNT); 

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

 vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness) { float a = roughness*roughness; float phi = 2.0 * PI * Xi.x; float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y)); float sinTheta = sqrt(1.0 - cosTheta*cosTheta); //       vec3 H; Hx = cos(phi) * sinTheta; Hy = sin(phi) * sinTheta; Hz = cosTheta; //        vec3 up = abs(Nz) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0); vec3 tangent = normalize(cross(up, N)); vec3 bitangent = cross(N, tangent); vec3 sampleVec = tangent * Hx + bitangent * Hy + N * Hz; return normalize(sampleVec); } 

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

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

 #version 330 core out vec4 FragColor; in vec3 localPos; uniform samplerCube environmentMap; uniform float roughness; const float PI = 3.14159265359; float RadicalInverse_VdC(uint bits); vec2 Hammersley(uint i, uint N); vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness); void main() { vec3 N = normalize(localPos); vec3 R = N; vec3 V = R; const uint SAMPLE_COUNT = 1024u; float totalWeight = 0.0; vec3 prefilteredColor = vec3(0.0); for(uint i = 0u; i < SAMPLE_COUNT; ++i) { vec2 Xi = Hammersley(i, SAMPLE_COUNT); vec3 H = ImportanceSampleGGX(Xi, N, roughness); vec3 L = normalize(2.0 * dot(V, H) * H - V); float NdotL = max(dot(N, L), 0.0); if(NdotL > 0.0) { prefilteredColor += texture(environmentMap, L).rgb * NdotL; totalWeight += NdotL; } } prefilteredColor = prefilteredColor / totalWeight; FragColor = vec4(prefilteredColor, 1.0); } 

हम कुछ दिए गए खुरदरेपन के आधार पर पर्यावरण के नक्शे की प्रारंभिक फ़िल्टरिंग करते हैं, जिसके परिणामस्वरूप परिणामस्वरूप क्यूबिक मैप (0.0 से 1.0) के प्रत्येक मील स्तर के लिए परिवर्तन होता है, और फ़िल्टर का परिणाम प्रीफ़िल्ड कार्डबोर्ड चर में संग्रहीत होता है । अगला, चर पूरे नमूने के लिए कुल वजन से विभाजित है, और अंतिम परिणाम के लिए एक छोटे से योगदान के साथ नमूने (कम एनडीओटीएल मूल्य वाले ) भी कुल वजन कम बढ़ाते हैं।

एमआईपी स्तरों में पूर्व फ़िल्टरिंग डेटा को सहेजना

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

 prefilterShader.use(); prefilterShader.setInt("environmentMap", 0); prefilterShader.setMat4("projection", captureProjection); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); unsigned int maxMipLevels = 5; for (unsigned int mip = 0; mip < maxMipLevels; ++mip) { //        - unsigned int mipWidth = 128 * std::pow(0.5, mip); unsigned int mipHeight = 128 * std::pow(0.5, mip); glBindRenderbuffer(GL_RENDERBUFFER, captureRBO); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, mipWidth, mipHeight); glViewport(0, 0, mipWidth, mipHeight); float roughness = (float)mip / (float)(maxMipLevels - 1); prefilterShader.setFloat("roughness", roughness); for (unsigned int i = 0; i < 6; ++i) { prefilterShader.setMat4("view", captureViews[i]); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, prefilterMap, mip); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderCube(); } } glBindFramebuffer(GL_FRAMEBUFFER, 0); 

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

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

 vec3 envColor = textureLod(environmentMap, WorldPos, 1.2).rgb; 

इस क्रिया का परिणाम निम्न चित्र होगा:


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

पूर्व फ़िल्टर कनवल्शन कलाकृतियों

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

घन मानचित्र के सीमों की अभिव्यक्ति

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


सौभाग्य से, OpenGL में एक साधारण ध्वज के साथ इस फ़िल्टरिंग को सक्रिय करने की क्षमता है:

 glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); 

यह एप्लीकेशन इनिशियलाइज़ेशन कोड में कहीं ध्वज को स्थापित करने के लिए पर्याप्त है और इस विरूपण साक्ष्य के साथ दूर किया जाता है।

चमकीले डॉट्स दिखाई देते हैं

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


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

 float D = DistributionGGX(NdotH, roughness); float pdf = (D * NdotH / (4.0 * HdotV)) + 0.0001; //        float resolution = 512.0; float saTexel = 4.0 * PI / (6.0 * resolution * resolution); float saSample = 1.0 / (float(SAMPLE_COUNT) * pdf + 0.0001); float mipLevel = roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel); 

एमआईपी स्तरों से सफलतापूर्वक चयन करने के लिए पर्यावरण मानचित्र के लिए ट्रिलिनियर फ़िल्टरिंग को सक्षम करना याद रखें:

 glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); 

इसके अलावा, OpenGL का उपयोग करके बनावट के लिए सीधे mip स्तर बनाना न भूलें, लेकिन केवल मुख्य mip स्तर पूरी तरह से बनने के बाद:

 //  HDR      ... [...] //  - glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap); glGenerateMipmap(GL_TEXTURE_CUBE_MAP); 

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

BRDF की प्रारंभिक गणना

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

$$

$$L_o(p,\omega_o) = \int\limits_{\Omega} L_i(p,\omega_i) d\omega_i * \int\limits_{\Omega} f_r(p, \omega_i, \omega_o) n \cdot \omega_i d\omega_i$$

हमने कुल राशि के बाएं हिस्से की गणना की और अलग-अलग क्यूबिक मैप में विभिन्न खुरदरापन स्तरों के लिए परिणामों को दर्ज किया। दाईं ओर निम्नलिखित मापदंडों के साथ BDRF अभिव्यक्ति के दृढ़ीकरण की आवश्यकता होगी: कोण$$n ⋅ ω मैं , सतह खुरदरापन और Fresnel के गुणांक$n \cdot \omega_i$$$$F_0$ । एक प्रक्रिया पूरी तरह से सफेद पर्यावरण के लिए या निरंतर ऊर्जा चमक के साथ एक प्रतिबिंबित बीआरडीएफ को एकीकृत करने के समान है $$$L_i = 1.0$ । तीन चरों के लिए BRDF की खोज करना कोई तुच्छ कार्य नहीं है, लेकिन इस मामले में $$F 0 दर्पण BRDF का वर्णन करने वाली अभिव्यक्ति से लिया जा सकता है:$F_0$

$$

$$\int\limits_{\Omega} f_r(p, \omega_i, \omega_o) n \cdot \omega_i d\omega_i = \int\limits_{\Omega} f_r(p, \omega_i, \omega_o) \frac{F(\omega_o, h)}{F(\omega_o, h)} n \cdot \omega_i d\omega_i$$

यहां $$ए एफ - एक फ़ंक्शन जो फ्रेस्नेल सेट की गणना का वर्णन करता है। बीआरडीएफ के लिए अभिव्यक्ति में विभाजक को आगे बढ़ाते हुए, आप निम्नलिखित समकक्ष रिकॉर्ड पर जा सकते हैं:$एफ$

$$

$$\int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} F(\omega_o, h) n \cdot \omega_i d\omega_i$$

राइट एंट्री की जगह $$खोज परिणाम के लि फ Fresnel-श्लिक के सन्निकटन पर, हम पाते हैं:$एफ$

$$

$$\int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} (F_0 + (1 - F_0){(1 - \omega_o \cdot h)}^5) n \cdot \omega_i d\omega_i$$

अभिव्यक्ति को नकारें $$${(1 - \omega_o \cdot h)}^5$ कैसे $$/ a l p h a पर निर्णय को सरल बनाने के लिए$/alpha$$$$F_0$ :

$$

$$\int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} (F_0 + (1 - F_0)\alpha) n \cdot \omega_i d\omega_i$$

$$

$$\int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} (F_0 + 1*\alpha - F_0*\alpha) n \cdot \omega_i d\omega_i$$

$$

$$\int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} (F_0 * (1 - \alpha) + \alpha) n \cdot \omega_i d\omega_i$$

अगला कार्य $$ए एफ हम दो अभिन्न भागों में विभाजित करते हैं:$एफ$

$$

$$\int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} (F_0 * (1 - \alpha)) n \cdot \omega_i d\omega_i + \int\limits_{\Omega} \frac{f_r(p, \omega_i, \omega_o)}{F(\omega_o, h)} (\alpha) n \cdot \omega_i d\omega_i$$

इस तरह से $$एफ 0 अभिन्न के तहत निरंतर होगा, और हम इसे अभिन्न के संकेत से बाहर निकाल सकते हैं। आगे, हम प्रकट करेंगे$F_0$$$मूल अभिव्यक्ति में α और BRDF के लिए एक अलग योग के रूप में अंतिम प्रविष्टि प्राप्त करें:$\alpha$

$$

$$F_0 \int\limits_{\Omega} f_r(p, \omega_i, \omega_o)(1 - {(1 - \omega_o \cdot h)}^5) n \cdot \omega_i d\omega_i + \int\limits_{\Omega} f_r(p, \omega_i, \omega_o) {(1 - \omega_o \cdot h)}^5 n \cdot \omega_i d\omega_i$$

परिणामी दो अभिन्नता पैमाने और मूल्य के लिए ऑफसेट का प्रतिनिधित्व करते हैं $$$F_0$ क्रमशः। ध्यान दें $$च ( पी , ω मैं , ω ओ ) प्रविष्टि शामिल$f(p, \omega_i, \omega_o)$$$ए एफ , क्योंकि ये घटनाएँ एक दूसरे को रद्द करती हैं और अभिव्यक्ति से गायब हो जाती हैं। पहले से विकसित दृष्टिकोण का उपयोग करते हुए, BRDF कनवल्शन को इनपुट डेटा के साथ एक साथ किया जा सकता है: वैक्टर के बीच खुरदरापन और कोण$एफ$

$$$n$ और $$$w_o$ ।- 2 डी बनावट में परिणाम लिखें कार्ड complexation BRDF ( BRDF एकीकरण नक्शा ) है, जो अंतिम शेडर में इस्तेमाल के लिए एक सहायक तालिका मूल्यों, जो अप्रत्यक्ष specular प्रकाश व्यवस्था के अंतिम परिणाम बनेगी रूप में काम करेगा।

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

 vec2 IntegrateBRDF(float NdotV, float roughness) { vec3 V; Vx = sqrt(1.0 - NdotV*NdotV); Vy = 0.0; Vz = NdotV; float A = 0.0; float B = 0.0; vec3 N = vec3(0.0, 0.0, 1.0); const uint SAMPLE_COUNT = 1024u; for(uint i = 0u; i < SAMPLE_COUNT; ++i) { vec2 Xi = Hammersley(i, SAMPLE_COUNT); vec3 H = ImportanceSampleGGX(Xi, N, roughness); vec3 L = normalize(2.0 * dot(V, H) * H - V); float NdotL = max(Lz, 0.0); float NdotH = max(Hz, 0.0); float VdotH = max(dot(V, H), 0.0); if(NdotL > 0.0) { float G = GeometrySmith(N, V, L, roughness); float G_Vis = (G * VdotH) / (NdotH * NdotV); float Fc = pow(1.0 - VdotH, 5.0); A += (1.0 - Fc) * G_Vis; B += Fc * G_Vis; } } A /= float(SAMPLE_COUNT); B /= float(SAMPLE_COUNT); return vec2(A, B); } // ---------------------------------------------------------------------------- void main() { vec2 integratedBRDF = IntegrateBRDF(TexCoords.x, TexCoords.y); FragColor = integratedBRDF; } 

जैसा कि आप देख सकते हैं, उपरोक्त गणितीय गणनाओं के लगभग शाब्दिक व्यवस्था के रूप में BRDF के दृढ़ संकल्प को लागू किया गया है। खुरदरापन और कोण के इनपुट मापदंडों को लिया जाता है।$$θ , वेक्टर नमूना महत्व नमूना ज्यामिति के एक समारोह और तब्दील अभिव्यक्ति Fresnel BRDF का उपयोग करके संसाधित किया जाता है के आधार पर ही बना है। परिणामस्वरूप, प्रत्येक नमूने के लिए, मूल्य के स्केलिंग और विस्थापन की भयावहता$\theta$$$F 0 , जो अंत में औसत है और फॉर्मvec2में वापस आ जाता है। एकसैद्धांतिकसबक में, यह उल्लेख किया गया था कि गुणांक के बाद से, IBL की गणना के मामले में BRDF का ज्यामितीय घटक थोड़ा अलग है$F_0$

$$k अलग तरीके से निर्दिष्ट किया गया है:$k$

$$

$$k_{direct} = \frac{(\alpha + 1)^2}{8}$$

$$

$$k_{IBL} = \frac{\alpha^2}{2}$$

चूंकि बीआरडीएफ, आईबीएल की गणना के मामले में अभिन्न के समाधान का हिस्सा है, इसलिए हम गुणांक का उपयोग करेंगे $$श्लिक-जीजीएक्स मॉडल में ज्यामिति फ़ंक्शन की गणना के लिए k I B L :$k_{IBL}$

 float GeometrySchlickGGX(float NdotV, float roughness) { float a = roughness; float k = (a * a) / 2.0; float nom = NdotV; float denom = NdotV * (1.0 - k) + k; return nom / denom; } // ---------------------------------------------------------------------------- float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) { float NdotV = max(dot(N, V), 0.0); float NdotL = max(dot(N, L), 0.0); float ggx2 = GeometrySchlickGGX(NdotV, roughness); float ggx1 = GeometrySchlickGGX(NdotL, roughness); return ggx1 * ggx2; } 

कृपया ध्यान दें कि गुणांक $$k की गणना पैरामीटरa केआधार पर की जातीहै। इसके अलावा, इस मामले में, पैरामीटर कावर्णन करते समयखुरदरापनपैरामीटरनहीं होताहै, जो अन्य स्थानों पर किया गया था जहां यह पैरामीटर लागू किया गया था। सुनिश्चित नहीं हैं कि जहां समस्या यहाँ झूठ: महाकाव्य खेल या डिज्नी द्वारा मूल काम में, लेकिन यह कह रही है कि इसके बारे में मूल्य का एक सीधा काम है लायक हैखुरदरापनपैरामीटरएकएकीकृत नक्शे के निर्माण के लिए सुराग BRDF समान, महाकाव्य खेल के प्रकाशन में प्रस्तुत किया।इसके अलावा, BRDF कनवल्शन परिणाम को 512x512 आकार की 2 डी बनावट के रूप में सहेजा जाएगा:$k$

 unsigned int brdfLUTTexture; glGenTextures(1, &brdfLUTTexture); //   ,     glBindTexture(GL_TEXTURE_2D, brdfLUTTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, 512, 512, 0, GL_RG, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 

जैसा कि एपिक गेम्स द्वारा अनुशंसित किया गया है, यहां 16-बिट फ्लोटिंग-पॉइंट टेक्सचर फॉर्मेट का उपयोग किया जाता है। धार से नमूना कलाकृतियों से बचने के लिए GL_CLAMP_TO_EDGE में रिपीट मोड सेट करना सुनिश्चित करें ।

अगला, हम एक ही फ्रेम बफर ऑब्जेक्ट का उपयोग करते हैं और एक फुल-स्क्रीन क्वाड की सतह पर एक शेडर निष्पादित करते हैं:

 glBindFramebuffer(GL_FRAMEBUFFER, captureFBO); glBindRenderbuffer(GL_RENDERBUFFER, captureRBO); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, brdfLUTTexture, 0); glViewport(0, 0, 512, 512); brdfShader.use(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); RenderQuad(); glBindFramebuffer(GL_FRAMEBUFFER, 0); 

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


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

IBL मॉडल में अंतिम परावर्तन गणना

तो, एक मूल्य प्राप्त करने के लिए जो परावर्तन की सामान्य अभिव्यक्ति में अप्रत्यक्ष दर्पण घटक का वर्णन करता है, एक अलग राशि के रूप में गणना किए गए सन्निकटन घटकों को एक पूरे में "गोंद" करना आवश्यक है। पहले, पूर्व-परिकलित डेटा के लिए अंतिम shader में उपयुक्त नमूने जोड़ें:

 uniform samplerCube prefilterMap; uniform sampler2D brdfLUT; 

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

 void main() { [...] vec3 R = reflect(-V, N); const float MAX_REFLECTION_LOD = 4.0; vec3 prefilteredColor = textureLod(prefilterMap, R, roughness * MAX_REFLECTION_LOD).rgb; [...] } 

प्रारंभिक कनवल्शन स्टेज पर, हमने केवल 5 mip स्तरों (शून्य से चौथे तक) को तैयार किया, निरंतर MAX_REFLECTION_LOD जनरेट किए गए mip स्तरों से चयन को सीमित करने का कार्य करता है।

अगला, हम सामान्य और देखने की दिशा के बीच खुरदरापन और कोण के आधार पर BRDF एकीकरण मानचित्र से चयन करते हैं:

 vec3 F = FresnelSchlickRoughness(max(dot(N, V), 0.0), F0, roughness); vec2 envBRDF = texture(brdfLUT, vec2(max(dot(N, V), 0.0), roughness)).rg; vec3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y); 

मानचित्र से प्राप्त मूल्य में मूल्य के लिए स्केलिंग और विस्थापन कारक शामिल हैं $$F 0 (यहाँ हम मान लेते हैंF- Fresnel गुणांक)। परिवर्तित मानFतब मूल इंटीग्रल एक्सप्रेशन -स्पेक्युलर केएक अनुमानित समाधान को प्राप्त करने के लिए पूर्व फ़िल्टरिंग मैप से प्राप्त मूल्य के साथ संयुक्त है।इस प्रकार, हम परावर्तन की अभिव्यक्ति के भाग के लिए एक समाधान प्राप्त करते हैं, जो स्पेक्युलर प्रतिबिंब के लिए जिम्मेदार है। PBR IBL मॉडल का एक संपूर्ण समाधान प्राप्त करने के लिए, आपको इस मूल्य को समाधान के साथ संयोजित करने की आवश्यकता है, जो किअंतिमपाठमें हमें परिलक्षित अभिव्यक्ति के प्रसार भाग के लिए है:$F_0$

 vec3 F = FresnelSchlickRoughness(max(dot(N, V), 0.0), F0, roughness); vec3 kS = F; vec3 kD = 1.0 - kS; kD *= 1.0 - metallic; vec3 irradiance = texture(irradianceMap, N).rgb; vec3 diffuse = irradiance * albedo; const float MAX_REFLECTION_LOD = 4.0; vec3 prefilteredColor = textureLod(prefilterMap, R, roughness * MAX_REFLECTION_LOD).rgb; vec2 envBRDF = texture(brdfLUT, vec2(max(dot(N, V), 0.0), roughness)).rg; vec3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y); vec3 ambient = (kD * diffuse + specular) * ao; 

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

आइए धातु और खुरदरापन की बदलती विशेषताओं के साथ एक परिचित क्षेत्र के साथ हमारे परीक्षण एप्लिकेशन को चलाएं और पीबीआर के पूर्ण वैभव में उनकी उपस्थिति पर एक नज़र डालें:


आप आगे भी जा सकते हैं और PBR मॉडल के अनुरूप बनावट का एक सेट डाउनलोड कर सकते हैं और वास्तविक सामग्रियों से गोले प्राप्त कर सकते हैं :


या एंड्रयू मैक्सिमोव से तैयार पीबीआर बनावट के साथ एक भव्य मॉडल भी डाउनलोड करें :


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


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

आगे क्या है?

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

इसीलिए, सामान्य स्थिति में, एक विकिरण मानचित्र और एक पूर्व-संसाधित पर्यावरण मानचित्र एक बार तैयार किया जाता है, और फिर डिस्क पर सहेजा जाता है (BRDF एकत्रीकरण मानचित्र पर्यावरण के नक्शे पर निर्भर नहीं करता है, ताकि इसे आम तौर पर एक बार गणना या डाउनलोड किया जा सके)। यह इस प्रकार है कि आपको एचडीआर क्यूबिक कार्डों को संग्रहीत करने के लिए एक प्रारूप की आवश्यकता होगी, जिसमें उनके एमआईपी स्तर भी शामिल हैं। ठीक है, या आप व्यापक रूप से उपयोग किए जाने वाले प्रारूपों में से एक का उपयोग करके उन्हें स्टोर और लोड कर सकते हैं (ताकि। Mds बचत स्तरों का समर्थन करता है)।

एक और महत्वपूर्ण बिंदु: इन पाठों में पीबीआर पाइपलाइन की गहरी समझ देने के लिए, मैंने पीबीआर रेंडर के लिए तैयारी की पूरी प्रक्रिया का वर्णन किया, जिसमें आईबीएल के लिए सहायक कार्ड की प्रारंभिक गणना भी शामिल है। हालाँकि, अपने अभ्यास में, आप केवल उन उपयोगिताओं को तैयार करने वाले महान उपयोगिताओं में से एक का उपयोग कर सकते हैं: उदाहरण के लिए cmftStudio या IBLBaker ।

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

(नमूने का कार्यान्वयन, और बहुत कुछ इंजन के कच्चे ट्यूटोरियल लेखक में पाया जा सकता है यहाँ , prim.per। )

अतिरिक्त सामग्री

1. अवास्तविक इंजन 4 में वास्तविक छायांकन : एक विभाजित राशि द्वारा दर्पण घटक के लिए अभिव्यक्ति को अनुमानित करने के लिए महाकाव्य खेलों के दृष्टिकोण का स्पष्टीकरण। इस लेख के आधार पर, IBL PBR पाठ के लिए कोड लिखा गया था।
2. फिजिकली बेस्ड शेडिंग एंड इमेज बेस्ड लाइटिंग : पीबीआर इंटरएक्टिव पाइपलाइन एप्लिकेशन में आईबीएल के दर्पण घटक की गणना सहित प्रक्रिया का वर्णन करने वाला एक उत्कृष्ट लेख।
3. इमेज बेस्ड लाइटिंग : स्पेक्युलर IBL और संबंधित मुद्दों पर एक बहुत लंबी और विस्तृत पोस्ट, जिसमें प्रकाश जांच प्रक्षेप समस्या भी शामिल है।
4. Moving Frostbite to PBR : , PBR «AAA».
5. Physically Based Rendering – Part Three : , IBL PBR JMonkeyEngine.
6. Implementation Notes: Runtime Environment Map Filtering for Image Based Lighting : HDR , .