👨🏿‍🤝‍👨🏻 🚚 🚴🏻 ओपनजीएल जानें। पाठ ५.१० - स्क्रीन स्पेस एम्बिएंट इंक्लूजन ➰ 👉 👨🏻‍🎨

SSAO

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

अप्रत्यक्ष प्रकाश से छायांकन की एक प्रकार की अनुमानित गणना परिवेशीय रोड़ा (एओ ) एल्गोरिथ्म है, जो कोनों, झुर्रियों और अन्य सतह अनियमितताओं के आसपास के क्षेत्र में अप्रत्यक्ष प्रकाश के क्षीणन को अनुकरण करता है। ऐसे तत्व, सामान्य रूप से, आसन्न ज्यामिति द्वारा अतिव्याप्त होते हैं और इसलिए इन क्षेत्रों को निहारते हुए, बाहर निकलने के लिए प्रकाश की कम किरणों को छोड़ते हैं।

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

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

सामग्री

भाग 1. आरंभ करना

भाग 2. बुनियादी प्रकाश

भाग 3। 3 डी मॉडल डाउनलोड करें

भाग 4. उन्नत OpenGL सुविधाएँ

भाग 5. उन्नत प्रकाश

भाग 6. पीबीआर

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

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

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

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

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

क्रायटेक के विशिष्ट SSAO कार्यान्वयन में एक पहचानने योग्य दृश्य शैली थी। चूंकि क्रायटेक विशेषज्ञों ने नमूने के एक गोलाकार कोर का उपयोग किया था, इसने दीवारों जैसे समतल सतहों को भी प्रभावित किया, जिससे उन्हें छायांकित किया गया - क्योंकि नमूने के मूल का आधा हिस्सा ज्यामिति के नीचे डूबा हुआ था। नीचे छायांकन कारक के मूल्य के आधार पर ग्रेस्केल में दिखाए गए क्राइसिस के एक दृश्य का एक स्क्रीनशॉट है। यहां "ग्रेनेस" का प्रभाव स्पष्ट रूप से दिखाई देता है:

इस प्रभाव से बचने के लिए, हम नमूने के गोलाकार कोर से एक गोलार्ध को उन्मुख करेंगे जो सतह पर सामान्य होता है:

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

कच्चे डेटा बफर

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

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

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

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

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

चूंकि निर्देशांक और मानदंडों के बारे में खंड जानकारी तक पहुंच जी-बफर के कारण पहले से ही उपलब्ध होनी चाहिए, ज्यामिति प्रसंस्करण चरण का टुकड़ा shader काफी सरल है:

#version 330 core layout (location = 0) out vec4 gPosition; layout (location = 1) out vec3 gNormal; layout (location = 2) out vec4 gAlbedoSpec; in vec2 TexCoords; in vec3 FragPos; in vec3 Normal; void main() { //        gPosition = FragPos; //       gNormal = normalize(Normal); //    -   gAlbedoSpec.rgb = vec3(0.95); }

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

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

GPosition रंग बफ़र बनावट निम्नानुसार कॉन्फ़िगर किया गया है:

 glGenTextures(1, &gPosition); glBindTexture(GL_TEXTURE_2D, gPosition); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

यह बनावट टुकड़ों के निर्देशांक को संग्रहीत करती है और इसका उपयोग नमूनों के मूल से प्रत्येक बिंदु के लिए गहराई डेटा प्राप्त करने के लिए किया जा सकता है। मैं ध्यान देता हूं कि बनावट एक फ्लोटिंग-पॉइंट डेटा प्रारूप का उपयोग करती है - इससे अंशों के निर्देशांक को अंतराल [0., 1.] तक कम नहीं किया जा सकेगा। रिपीट मोड पर भी ध्यान दें - GL_CLAMP_TO_EDGE सेट है। उद्देश्य पर स्क्रीन स्पेस में ओवरसैंपलिंग नहीं करने की संभावना को समाप्त करने के लिए यह आवश्यक है। बनावट के निर्देशांक के मुख्य अंतराल से परे जाने से हमें गलत स्थिति और गहराई के आंकड़े मिलेंगे।

अगला, हम नमूनों के एक गोलार्द्धीय कोर के निर्माण और यादृच्छिक अभिविन्यास की एक विधि के निर्माण में संलग्न होंगे।

एक सामान्य-उन्मुख गोलार्ध बनाना

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

गोलार्ध की त्रिज्या को एक एकल प्रक्रिया मानते हुए, 64 बिंदुओं के नमूने के मूल का गठन इस प्रकार होता है:

 //      0.0 - 1.0 std::uniform_real_distribution<float> randomFloats(0.0, 1.0); std::default_random_engine generator; std::vector<glm::vec3> ssaoKernel; for (unsigned int i = 0; i < 64; ++i) { glm::vec3 sample( randomFloats(generator) * 2.0 - 1.0, randomFloats(generator) * 2.0 - 1.0, randomFloats(generator) ); sample = glm::normalize(sample); sample *= randomFloats(generator); float scale = (float)i / 64.0; ssaoKernel.push_back(sample); }

यहाँ हम बेतरतीब ढंग से अंतराल में x और y निर्देशांक का चयन करते हैं [-1, 1.], और अंतराल में z समन्वय करते हैं [0., 1.] (यदि अंतराल x और y के समान है , तो हमें एक गोलाकार कोर मिलेगा नमूना)। परिणामी नमूना वैक्टर गोलार्द्धों तक सीमित होंगे, क्योंकि नमूने का मूल अंत में सतह के सामान्य के साथ उन्मुख होगा।

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

 scale = lerp(0.1f, 1.0f, scale * scale); sample *= scale; ssaoKernel.push_back(sample); }

Lerp () फ़ंक्शन को इस प्रकार परिभाषित किया गया है:

 float lerp(float a, float b, float f) { return a + f * (b - a); }

इस तरह की चाल हमें एक संशोधित वितरण प्रदान करती है, जहां अधिकांश नमूना बिंदु कर्नेल की उत्पत्ति के पास होते हैं।

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

नमूना कोर का रैंडम रोटेशन

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

एक 4x4 सरणी बनाएं और इसे यादृच्छिक घुमाव वाले वैक्टर के साथ भरें जो सामान्य वेक्टर के साथ स्पर्शरेखा स्थान में उन्मुख हो:

 std::vector<glm::vec3> ssaoNoise; for (unsigned int i = 0; i < 16; i++) { glm::vec3 noise( randomFloats(generator) * 2.0 - 1.0, randomFloats(generator) * 2.0 - 1.0, 0.0f); ssaoNoise.push_back(noise); }

चूंकि कोर को स्पर्शरेखा स्थान में सकारात्मक अर्धचालक जेड के साथ जोड़ा जाता है, हम जेड घटक को शून्य के बराबर छोड़ देते हैं - यह केवल जेड अक्ष के चारों ओर रोटेशन सुनिश्चित करेगा।

अगला, एक 4x4 बनावट बनाएं और इसे हमारे घूमने वाले वैक्टरों के साथ भरें। बनावट के लिए GL_REPEAT रिप्ले मोड का उपयोग करना सुनिश्चित करें:

 unsigned int noiseTexture; glGenTextures(1, &noiseTexture); glBindTexture(GL_TEXTURE_2D, noiseTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, 4, 4, 0, GL_RGB, GL_FLOAT, &ssaoNoise[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

खैर, अब हमारे पास SSAO एल्गोरिदम के प्रत्यक्ष कार्यान्वयन के लिए आवश्यक सभी डेटा हैं!

Shader SSAO

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

 unsigned int ssaoFBO; glGenFramebuffers(1, &ssaoFBO); glBindFramebuffer(GL_FRAMEBUFFER, ssaoFBO); unsigned int ssaoColorBuffer; glGenTextures(1, &ssaoColorBuffer); glBindTexture(GL_TEXTURE_2D, ssaoColorBuffer); glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ssaoColorBuffer, 0);

चूंकि एल्गोरिथ्म का परिणाम केवल [0., 1.] के भीतर वास्तविक संख्या है, भंडारण के लिए यह केवल उपलब्ध घटक के साथ एक बनावट बनाने के लिए पर्याप्त होगा। यही कारण है कि GL_RED को रंगीन बफर के लिए आंतरिक प्रारूप के रूप में सेट किया गया है।

सामान्य तौर पर, SSAO स्टेज रेंडरिंग प्रक्रिया कुछ इस तरह दिखाई देती है:

 //  :  G- glBindFramebuffer(GL_FRAMEBUFFER, gBuffer); [...] glBindFramebuffer(GL_FRAMEBUFFER, 0); //  G-      SSAO glBindFramebuffer(GL_FRAMEBUFFER, ssaoFBO); glClear(GL_COLOR_BUFFER_BIT); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, gPosition); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, gNormal); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, noiseTexture); shaderSSAO.use(); SendKernelSamplesToShader(); shaderSSAO.setMat4("projection", projection); RenderQuad(); glBindFramebuffer(GL_FRAMEBUFFER, 0); //  :    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaderLightingPass.use(); [...] glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, ssaoColorBuffer); [...] RenderQuad();

ShaderSSAO shader G-बफर बनावट को इनपुट, साथ ही शोर बनावट और नमूना कोर के रूप में स्वीकार करता है:

 #version 330 core out float FragColor; in vec2 TexCoords; uniform sampler2D gPosition; uniform sampler2D gNormal; uniform sampler2D texNoise; uniform vec3 samples[64]; uniform mat4 projection; //             //      1280x720 const vec2 noiseScale = vec2(1280.0/4.0, 720.0/4.0); void main() { [...] }

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

 vec3 fragPos = texture(gPosition, TexCoords).xyz; vec3 normal = texture(gNormal, TexCoords).rgb; vec3 randomVec = texture(texNoise, TexCoords * noiseScale).xyz;

टेक्सनोइज़ शोर बनावट बनाते समय हम दोहराने मोड को GL_REPEAT पर सेट करते हैं, अब इसे स्क्रीन की सतह पर कई बार दोहराया जाएगा। RandomVec , fragPos और हाथ पर सामान्य मूल्यों के साथ, हम स्पर्शरेखा से प्रजातियों के स्थान पर TBN परिवर्तन मैट्रिक्स बना सकते हैं:

 vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); vec3 bitangent = cross(normal, tangent); mat3 TBN = mat3(tangent, bitangent, normal);

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

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

जबकि यह भ्रामक लगता है, चलो चरणों के माध्यम से चलते हैं:

 float occlusion = 0.0; for(int i = 0; i < kernelSize; ++i) { //     vec3 sample = TBN * samples[i]; //      - sample = fragPos + sample * radius; [...] }

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

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

 vec4 offset = vec4(sample, 1.0); offset = projection * offset; //     offset.xyz /= offset.w; //   offset.xyz = offset.xyz * 0.5 + 0.5; //    [0., 1.]

क्लिप स्पेस में रूपांतरण के बाद, हम मैन्युअल रूप से x घटक को w घटक से विभाजित करके परिप्रेक्ष्य विभाजन करते हैं। सामान्यीकृत डिवाइस निर्देशांक ( NDC ) में परिणामी वेक्टर को मूल्यों के अंतराल में अनुवादित किया जाता है [0., 1.] ताकि इसे बनावट निर्देशांक के रूप में इस्तेमाल किया जा सके:

 float sampleDepth = texture(gPosition, offset.xy).z;

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

 occlusion += (sampleDepth >= sample.z + bias ? 1.0 : 0.0);

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

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

जाँच केवल नमूना के त्रिज्या के भीतर पड़े गहराई के मूल्यों के लिए छायांकन गुणांक में योगदान को सीमित करेगा:

 float rangeCheck = smoothstep(0.0, 1.0, radius / abs(fragPos.z - sampleDepth)); occlusion += (sampleDepth >= sample.z + bias ? 1.0 : 0.0) * rangeCheck;

हम GLSL स्मूथस्टेप () फ़ंक्शन का भी उपयोग करते हैं, जो पहले और दूसरे के बीच तीसरे पैरामीटर के सुचारू प्रक्षेप को कार्यान्वित करता है। उसी समय, 0 लौटाता है यदि तीसरा पैरामीटर पहले से कम या उसके बराबर है, या 1 यदि तीसरा पैरामीटर दूसरे से अधिक या उसके बराबर है। यदि गहराई का अंतर त्रिज्या के भीतर है , तो इसका मान इस अंतराल के अनुसार [0., 1.] अंतराल में आसानी से चिकना हो जाएगा:

यदि हम गहराई की जाँच करने की शर्तों में स्पष्ट सीमाओं का उपयोग करते हैं, तो यह उन स्थानों पर तेज सीमाओं के रूप में कलाकृतियों को जोड़ देगा जहां गहराई में अंतर के मान त्रिज्या की सीमा के बाहर हैं।

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

 } occlusion = 1.0 - (occlusion / kernelSize); FragColor = occlusion;

हमारे साथ परिचित नैनोसुइट वाले दृश्य के लिए, SSAO shader का प्रदर्शन निम्नलिखित बनावट देता है:

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

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

धुंधला पृष्ठभूमि छायांकन

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

 unsigned int ssaoBlurFBO, ssaoColorBufferBlur; glGenFramebuffers(1, &ssaoBlurFBO); glBindFramebuffer(GL_FRAMEBUFFER, ssaoBlurFBO); glGenTextures(1, &ssaoColorBufferBlur); glBindTexture(GL_TEXTURE_2D, ssaoColorBufferBlur); glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ssaoColorBufferBlur, 0);

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

 #version 330 core out float FragColor; in vec2 TexCoords; uniform sampler2D ssaoInput; void main() { vec2 texelSize = 1.0 / vec2(textureSize(ssaoInput, 0)); float result = 0.0; for (int x = -2; x < 2; ++x) { for (int y = -2; y < 2; ++y) { vec2 offset = vec2(float(x), float(y)) * texelSize; result += texture(ssaoInput, TexCoords + offset).r; } } FragColor = result / (4.0 * 4.0); }

Shader बस SSAO बनावट के टेक्सल्स को -2 से +2 तक की ऑफसेट के साथ परिवर्तित करता है, जो शोर बनावट के वास्तविक आकार से मेल खाता है। ऑफ़सेट एक टेक्सल के सटीक आकार के बराबर होता है: टेक्सचरसाइज़ () फ़ंक्शन का उपयोग गणना के लिए किया जाता है, जो निर्दिष्ट बनावट के आयामों के साथ vec2 देता है। इस प्रकार Shader बस बनावट में संग्रहीत परिणामों को औसत करता है, जो एक त्वरित और काफी प्रभावी धब्बा देता है:

कुल मिलाकर, हमारे पास स्क्रीन पर प्रत्येक टुकड़े के लिए पृष्ठभूमि छायांकन डेटा के साथ एक बनावट है - अंतिम छवि में कमी के चरण के लिए सब कुछ तैयार है!

पृष्ठभूमि छायांकन लागू करें

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

 #version 330 core out vec4 FragColor; in vec2 TexCoords; uniform sampler2D gPosition; uniform sampler2D gNormal; uniform sampler2D gAlbedo; uniform sampler2D ssao; struct Light { vec3 Position; vec3 Color; float Linear; float Quadratic; float Radius; }; uniform Light light; void main() { //    G- vec3 FragPos = texture(gPosition, TexCoords).rgb; vec3 Normal = texture(gNormal, TexCoords).rgb; vec3 Diffuse = texture(gAlbedo, TexCoords).rgb; float AmbientOcclusion = texture(ssao, TexCoords).r; //   -    //   :   -  vec3 ambient = vec3(0.3 * Diffuse * AmbientOcclusion); vec3 lighting = ambient; //    (0, 0, 0)   - vec3 viewDir = normalize(-FragPos); //   vec3 lightDir = normalize(light.Position - FragPos); vec3 diffuse = max(dot(Normal, lightDir), 0.0) * Diffuse * light.Color; //   vec3 halfwayDir = normalize(lightDir + viewDir); float spec = pow(max(dot(Normal, halfwayDir), 0.0), 8.0); vec3 specular = light.Color * spec; //   float dist = length(light.Position - FragPos); float attenuation = 1.0 / (1.0 + light.Linear * dist + light.Quadratic * dist * dist); diffuse *= attenuation; specular *= attenuation; lighting += diffuse + specular; FragColor = vec4(lighting, 1.0); }

केवल दो बड़े बदलाव हैं: व्यूपोर्ट में गणना के लिए संक्रमण और एम्बिएंटओक्विक्लूशन के मान से बैकग्राउंड लाइटिंग घटक का गुणन । एकल नीले बिंदु प्रकाश के साथ एक दृश्य का एक उदाहरण:

पूर्ण स्रोत कोड यहाँ है ।

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

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

 occlusion = 1.0 - (occlusion / kernelSize); FragColor = pow(occlusion, power);

मैं आपको सेटिंग्स के साथ खेल पर कुछ समय बिताने की सलाह देता हूं, क्योंकि यह अंतिम तस्वीर में परिवर्तनों की प्रकृति की बेहतर समझ देगा।

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

अतिरिक्त संसाधन

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

पुनश्च : हमारे पास तबादलों के समन्वय के लिए एक तार है । यदि आपको अनुवाद में मदद करने की गंभीर इच्छा है, तो आपका स्वागत है!

ओपनजीएल जानें। पाठ ५.१० - स्क्रीन स्पेस एम्बिएंट इंक्लूजन